@lingbi/studio 0.3.3 → 0.5.0

package/assets/ModelExportWorkerEntry-DwhcdDU3.js

@@ -0,0 +1,3457 @@
+(function() {
+  "use strict";
+  class BrowserExportWorkerPort {
+    addEventListener(type, listener) {
+      globalThis.addEventListener(type, listener);
+    }
+    postMessage(message, transfer) {
+      Reflect.apply(globalThis.postMessage, globalThis, [message, transfer]);
+    }
+  }
+  var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
+  var fleb = new u8([
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    2,
+    2,
+    3,
+    3,
+    3,
+    3,
+    4,
+    4,
+    4,
+    4,
+    5,
+    5,
+    5,
+    5,
+    0,
+    /* unused */
+    0,
+    0,
+    /* impossible */
+    0
+  ]);
+  var fdeb = new u8([
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    2,
+    2,
+    3,
+    3,
+    4,
+    4,
+    5,
+    5,
+    6,
+    6,
+    7,
+    7,
+    8,
+    8,
+    9,
+    9,
+    10,
+    10,
+    11,
+    11,
+    12,
+    12,
+    13,
+    13,
+    /* unused */
+    0,
+    0
+  ]);
+  var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+  var freb = function(eb, start) {
+    var b = new u16(31);
+    for (var i2 = 0; i2 < 31; ++i2) {
+      b[i2] = start += 1 << eb[i2 - 1];
+    }
+    var r = new i32(b[30]);
+    for (var i2 = 1; i2 < 30; ++i2) {
+      for (var j = b[i2]; j < b[i2 + 1]; ++j) {
+        r[j] = j - b[i2] << 5 | i2;
+      }
+    }
+    return { b, r };
+  };
+  var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
+  fl[28] = 258, revfl[258] = 28;
+  var _b = freb(fdeb, 0), revfd = _b.r;
+  var rev = new u16(32768);
+  for (var i = 0; i < 32768; ++i) {
+    var x = (i & 43690) >> 1 | (i & 21845) << 1;
+    x = (x & 52428) >> 2 | (x & 13107) << 2;
+    x = (x & 61680) >> 4 | (x & 3855) << 4;
+    rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+  }
+  var hMap = (function(cd, mb, r) {
+    var s = cd.length;
+    var i2 = 0;
+    var l = new u16(mb);
+    for (; i2 < s; ++i2) {
+      if (cd[i2])
+        ++l[cd[i2] - 1];
+    }
+    var le = new u16(mb);
+    for (i2 = 1; i2 < mb; ++i2) {
+      le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
+    }
+    var co;
+    if (r) {
+      co = new u16(1 << mb);
+      var rvb = 15 - mb;
+      for (i2 = 0; i2 < s; ++i2) {
+        if (cd[i2]) {
+          var sv = i2 << 4 | cd[i2];
+          var r_1 = mb - cd[i2];
+          var v = le[cd[i2] - 1]++ << r_1;
+          for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+            co[rev[v] >> rvb] = sv;
+          }
+        }
+      }
+    } else {
+      co = new u16(s);
+      for (i2 = 0; i2 < s; ++i2) {
+        if (cd[i2]) {
+          co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+        }
+      }
+    }
+    return co;
+  });
+  var flt = new u8(288);
+  for (var i = 0; i < 144; ++i)
+    flt[i] = 8;
+  for (var i = 144; i < 256; ++i)
+    flt[i] = 9;
+  for (var i = 256; i < 280; ++i)
+    flt[i] = 7;
+  for (var i = 280; i < 288; ++i)
+    flt[i] = 8;
+  var fdt = new u8(32);
+  for (var i = 0; i < 32; ++i)
+    fdt[i] = 5;
+  var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+  var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+  var shft = function(p) {
+    return (p + 7) / 8 | 0;
+  };
+  var slc = function(v, s, e) {
+    if (e == null || e > v.length)
+      e = v.length;
+    return new u8(v.subarray(s, e));
+  };
+  var ec = [
+    "unexpected EOF",
+    "invalid block type",
+    "invalid length/literal",
+    "invalid distance",
+    "stream finished",
+    "no stream handler",
+    ,
+    // determined by compression function
+    "no callback",
+    "invalid UTF-8 data",
+    "extra field too long",
+    "date not in range 1980-2099",
+    "filename too long",
+    "stream finishing",
+    "invalid zip data"
+    // determined by unknown compression method
+  ];
+  var err = function(ind, msg, nt) {
+    var e = new Error(msg || ec[ind]);
+    e.code = ind;
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(e, err);
+    if (!nt)
+      throw e;
+    return e;
+  };
+  var wbits = function(d, p, v) {
+    v <<= p & 7;
+    var o = p / 8 | 0;
+    d[o] |= v;
+    d[o + 1] |= v >> 8;
+  };
+  var wbits16 = function(d, p, v) {
+    v <<= p & 7;
+    var o = p / 8 | 0;
+    d[o] |= v;
+    d[o + 1] |= v >> 8;
+    d[o + 2] |= v >> 16;
+  };
+  var hTree = function(d, mb) {
+    var t = [];
+    for (var i2 = 0; i2 < d.length; ++i2) {
+      if (d[i2])
+        t.push({ s: i2, f: d[i2] });
+    }
+    var s = t.length;
+    var t2 = t.slice();
+    if (!s)
+      return { t: et, l: 0 };
+    if (s == 1) {
+      var v = new u8(t[0].s + 1);
+      v[t[0].s] = 1;
+      return { t: v, l: 1 };
+    }
+    t.sort(function(a, b) {
+      return a.f - b.f;
+    });
+    t.push({ s: -1, f: 25001 });
+    var l = t[0], r = t[1], i0 = 0, i1 = 1, i22 = 2;
+    t[0] = { s: -1, f: l.f + r.f, l, r };
+    while (i1 != s - 1) {
+      l = t[t[i0].f < t[i22].f ? i0++ : i22++];
+      r = t[i0 != i1 && t[i0].f < t[i22].f ? i0++ : i22++];
+      t[i1++] = { s: -1, f: l.f + r.f, l, r };
+    }
+    var maxSym = t2[0].s;
+    for (var i2 = 1; i2 < s; ++i2) {
+      if (t2[i2].s > maxSym)
+        maxSym = t2[i2].s;
+    }
+    var tr = new u16(maxSym + 1);
+    var mbt = ln(t[i1 - 1], tr, 0);
+    if (mbt > mb) {
+      var i2 = 0, dt = 0;
+      var lft = mbt - mb, cst = 1 << lft;
+      t2.sort(function(a, b) {
+        return tr[b.s] - tr[a.s] || a.f - b.f;
+      });
+      for (; i2 < s; ++i2) {
+        var i2_1 = t2[i2].s;
+        if (tr[i2_1] > mb) {
+          dt += cst - (1 << mbt - tr[i2_1]);
+          tr[i2_1] = mb;
+        } else
+          break;
+      }
+      dt >>= lft;
+      while (dt > 0) {
+        var i2_2 = t2[i2].s;
+        if (tr[i2_2] < mb)
+          dt -= 1 << mb - tr[i2_2]++ - 1;
+        else
+          ++i2;
+      }
+      for (; i2 >= 0 && dt; --i2) {
+        var i2_3 = t2[i2].s;
+        if (tr[i2_3] == mb) {
+          --tr[i2_3];
+          ++dt;
+        }
+      }
+      mbt = mb;
+    }
+    return { t: new u8(tr), l: mbt };
+  };
+  var ln = function(n, l, d) {
+    return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+  };
+  var lc = function(c) {
+    var s = c.length;
+    while (s && !c[--s])
+      ;
+    var cl = new u16(++s);
+    var cli = 0, cln = c[0], cls = 1;
+    var w = function(v) {
+      cl[cli++] = v;
+    };
+    for (var i2 = 1; i2 <= s; ++i2) {
+      if (c[i2] == cln && i2 != s)
+        ++cls;
+      else {
+        if (!cln && cls > 2) {
+          for (; cls > 138; cls -= 138)
+            w(32754);
+          if (cls > 2) {
+            w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+            cls = 0;
+          }
+        } else if (cls > 3) {
+          w(cln), --cls;
+          for (; cls > 6; cls -= 6)
+            w(8304);
+          if (cls > 2)
+            w(cls - 3 << 5 | 8208), cls = 0;
+        }
+        while (cls--)
+          w(cln);
+        cls = 1;
+        cln = c[i2];
+      }
+    }
+    return { c: cl.subarray(0, cli), n: s };
+  };
+  var clen = function(cf, cl) {
+    var l = 0;
+    for (var i2 = 0; i2 < cl.length; ++i2)
+      l += cf[i2] * cl[i2];
+    return l;
+  };
+  var wfblk = function(out, pos, dat) {
+    var s = dat.length;
+    var o = shft(pos + 2);
+    out[o] = s & 255;
+    out[o + 1] = s >> 8;
+    out[o + 2] = out[o] ^ 255;
+    out[o + 3] = out[o + 1] ^ 255;
+    for (var i2 = 0; i2 < s; ++i2)
+      out[o + i2 + 4] = dat[i2];
+    return (o + 4 + s) * 8;
+  };
+  var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+    wbits(out, p++, final);
+    ++lf[256];
+    var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
+    var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
+    var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+    var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
+    var lcfreq = new u16(19);
+    for (var i2 = 0; i2 < lclt.length; ++i2)
+      ++lcfreq[lclt[i2] & 31];
+    for (var i2 = 0; i2 < lcdt.length; ++i2)
+      ++lcfreq[lcdt[i2] & 31];
+    var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
+    var nlcc = 19;
+    for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+      ;
+    var flen = bl + 5 << 3;
+    var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+    var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+    if (bs >= 0 && flen <= ftlen && flen <= dtlen)
+      return wfblk(out, p, dat.subarray(bs, bs + bl));
+    var lm, ll, dm, dl;
+    wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+    if (dtlen < ftlen) {
+      lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+      var llm = hMap(lct, mlcb, 0);
+      wbits(out, p, nlc - 257);
+      wbits(out, p + 5, ndc - 1);
+      wbits(out, p + 10, nlcc - 4);
+      p += 14;
+      for (var i2 = 0; i2 < nlcc; ++i2)
+        wbits(out, p + 3 * i2, lct[clim[i2]]);
+      p += 3 * nlcc;
+      var lcts = [lclt, lcdt];
+      for (var it = 0; it < 2; ++it) {
+        var clct = lcts[it];
+        for (var i2 = 0; i2 < clct.length; ++i2) {
+          var len = clct[i2] & 31;
+          wbits(out, p, llm[len]), p += lct[len];
+          if (len > 15)
+            wbits(out, p, clct[i2] >> 5 & 127), p += clct[i2] >> 12;
+        }
+      }
+    } else {
+      lm = flm, ll = flt, dm = fdm, dl = fdt;
+    }
+    for (var i2 = 0; i2 < li; ++i2) {
+      var sym = syms[i2];
+      if (sym > 255) {
+        var len = sym >> 18 & 31;
+        wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+        if (len > 7)
+          wbits(out, p, sym >> 23 & 31), p += fleb[len];
+        var dst = sym & 31;
+        wbits16(out, p, dm[dst]), p += dl[dst];
+        if (dst > 3)
+          wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
+      } else {
+        wbits16(out, p, lm[sym]), p += ll[sym];
+      }
+    }
+    wbits16(out, p, lm[256]);
+    return p + ll[256];
+  };
+  var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+  var et = /* @__PURE__ */ new u8(0);
+  var dflt = function(dat, lvl, plvl, pre, post, st) {
+    var s = st.z || dat.length;
+    var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
+    var w = o.subarray(pre, o.length - post);
+    var lst = st.l;
+    var pos = (st.r || 0) & 7;
+    if (lvl) {
+      if (pos)
+        w[0] = st.r >> 3;
+      var opt = deo[lvl - 1];
+      var n = opt >> 13, c = opt & 8191;
+      var msk_1 = (1 << plvl) - 1;
+      var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
+      var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+      var hsh = function(i3) {
+        return (dat[i3] ^ dat[i3 + 1] << bs1_1 ^ dat[i3 + 2] << bs2_1) & msk_1;
+      };
+      var syms = new i32(25e3);
+      var lf = new u16(288), df = new u16(32);
+      var lc_1 = 0, eb = 0, i2 = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+      for (; i2 + 2 < s; ++i2) {
+        var hv = hsh(i2);
+        var imod = i2 & 32767, pimod = head[hv];
+        prev[imod] = pimod;
+        head[hv] = imod;
+        if (wi <= i2) {
+          var rem = s - i2;
+          if ((lc_1 > 7e3 || li > 24576) && (rem > 423 || !lst)) {
+            pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i2 - bs, pos);
+            li = lc_1 = eb = 0, bs = i2;
+            for (var j = 0; j < 286; ++j)
+              lf[j] = 0;
+            for (var j = 0; j < 30; ++j)
+              df[j] = 0;
+          }
+          var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+          if (rem > 2 && hv == hsh(i2 - dif)) {
+            var maxn = Math.min(n, rem) - 1;
+            var maxd = Math.min(32767, i2);
+            var ml = Math.min(258, rem);
+            while (dif <= maxd && --ch_1 && imod != pimod) {
+              if (dat[i2 + l] == dat[i2 + l - dif]) {
+                var nl = 0;
+                for (; nl < ml && dat[i2 + nl] == dat[i2 + nl - dif]; ++nl)
+                  ;
+                if (nl > l) {
+                  l = nl, d = dif;
+                  if (nl > maxn)
+                    break;
+                  var mmd = Math.min(dif, nl - 2);
+                  var md = 0;
+                  for (var j = 0; j < mmd; ++j) {
+                    var ti = i2 - dif + j & 32767;
+                    var pti = prev[ti];
+                    var cd = ti - pti & 32767;
+                    if (cd > md)
+                      md = cd, pimod = ti;
+                  }
+                }
+              }
+              imod = pimod, pimod = prev[imod];
+              dif += imod - pimod & 32767;
+            }
+          }
+          if (d) {
+            syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+            var lin = revfl[l] & 31, din = revfd[d] & 31;
+            eb += fleb[lin] + fdeb[din];
+            ++lf[257 + lin];
+            ++df[din];
+            wi = i2 + l;
+            ++lc_1;
+          } else {
+            syms[li++] = dat[i2];
+            ++lf[dat[i2]];
+          }
+        }
+      }
+      for (i2 = Math.max(i2, wi); i2 < s; ++i2) {
+        syms[li++] = dat[i2];
+        ++lf[dat[i2]];
+      }
+      pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i2 - bs, pos);
+      if (!lst) {
+        st.r = pos & 7 | w[pos / 8 | 0] << 3;
+        pos -= 7;
+        st.h = head, st.p = prev, st.i = i2, st.w = wi;
+      }
+    } else {
+      for (var i2 = st.w || 0; i2 < s + lst; i2 += 65535) {
+        var e = i2 + 65535;
+        if (e >= s) {
+          w[pos / 8 | 0] = lst;
+          e = s;
+        }
+        pos = wfblk(w, pos + 1, dat.subarray(i2, e));
+      }
+      st.i = s;
+    }
+    return slc(o, 0, pre + shft(pos) + post);
+  };
+  var crct = /* @__PURE__ */ (function() {
+    var t = new Int32Array(256);
+    for (var i2 = 0; i2 < 256; ++i2) {
+      var c = i2, k = 9;
+      while (--k)
+        c = (c & 1 && -306674912) ^ c >>> 1;
+      t[i2] = c;
+    }
+    return t;
+  })();
+  var crc = function() {
+    var c = -1;
+    return {
+      p: function(d) {
+        var cr = c;
+        for (var i2 = 0; i2 < d.length; ++i2)
+          cr = crct[cr & 255 ^ d[i2]] ^ cr >>> 8;
+        c = cr;
+      },
+      d: function() {
+        return ~c;
+      }
+    };
+  };
+  var dopt = function(dat, opt, pre, post, st) {
+    if (!st) {
+      st = { 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;
+        st.w = dict.length;
+      }
+    }
+    return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
+  };
+  var mrg = function(a, b) {
+    var o = {};
+    for (var k in a)
+      o[k] = a[k];
+    for (var k in b)
+      o[k] = b[k];
+    return o;
+  };
+  var wbytes = function(d, b, v) {
+    for (; v; ++b)
+      d[b] = v, v >>>= 8;
+  };
+  var Deflate = /* @__PURE__ */ (function() {
+    function Deflate2(opts, cb) {
+      if (typeof opts == "function")
+        cb = opts, opts = {};
+      this.ondata = cb;
+      this.o = opts || {};
+      this.s = { l: 0, i: 32768, w: 32768, z: 32768 };
+      this.b = new u8(98304);
+      if (this.o.dictionary) {
+        var dict = this.o.dictionary.subarray(-32768);
+        this.b.set(dict, 32768 - dict.length);
+        this.s.i = 32768 - dict.length;
+      }
+    }
+    Deflate2.prototype.p = function(c, f) {
+      this.ondata(dopt(c, this.o, 0, 0, this.s), f);
+    };
+    Deflate2.prototype.push = function(chunk, final) {
+      if (!this.ondata)
+        err(5);
+      if (this.s.l)
+        err(4);
+      var endLen = chunk.length + this.s.z;
+      if (endLen > this.b.length) {
+        if (endLen > 2 * this.b.length - 32768) {
+          var newBuf = new u8(endLen & -32768);
+          newBuf.set(this.b.subarray(0, this.s.z));
+          this.b = newBuf;
+        }
+        var split = this.b.length - this.s.z;
+        this.b.set(chunk.subarray(0, split), this.s.z);
+        this.s.z = this.b.length;
+        this.p(this.b, false);
+        this.b.set(this.b.subarray(-32768));
+        this.b.set(chunk.subarray(split), 32768);
+        this.s.z = chunk.length - split + 32768;
+        this.s.i = 32766, this.s.w = 32768;
+      } else {
+        this.b.set(chunk, this.s.z);
+        this.s.z += chunk.length;
+      }
+      this.s.l = final & 1;
+      if (this.s.z > this.s.w + 8191 || final) {
+        this.p(this.b, final || false);
+        this.s.w = this.s.i, this.s.i -= 2;
+      }
+      if (final) {
+        this.s = this.o = {};
+        this.b = et;
+      }
+    };
+    Deflate2.prototype.flush = function(sync) {
+      if (!this.ondata)
+        err(5);
+      if (this.s.l)
+        err(4);
+      this.p(this.b, false);
+      this.s.w = this.s.i, this.s.i -= 2;
+      if (sync) {
+        var c = new u8(6);
+        c[0] = this.s.r >> 3;
+        var ep = wfblk(c, this.s.r, et);
+        this.s.r = 0;
+        this.ondata(c.subarray(0, ep >> 3), false);
+      }
+    };
+    return Deflate2;
+  })();
+  var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder();
+  var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+  var tds = 0;
+  try {
+    td.decode(et, { stream: true });
+    tds = 1;
+  } catch (e) {
+  }
+  function strToU8(str, latin1) {
+    var i2;
+    if (te)
+      return te.encode(str);
+    var l = str.length;
+    var ar = new u8(str.length + (str.length >> 1));
+    var ai = 0;
+    var w = function(v) {
+      ar[ai++] = v;
+    };
+    for (var i2 = 0; i2 < l; ++i2) {
+      if (ai + 5 > ar.length) {
+        var n = new u8(ai + 8 + (l - i2 << 1));
+        n.set(ar);
+        ar = n;
+      }
+      var c = str.charCodeAt(i2);
+      if (c < 128 || latin1)
+        w(c);
+      else if (c < 2048)
+        w(192 | c >> 6), w(128 | c & 63);
+      else if (c > 55295 && c < 57344)
+        c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i2) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
+      else
+        w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
+    }
+    return slc(ar, 0, ai);
+  }
+  var dbf = function(l) {
+    return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0;
+  };
+  var exfl = function(ex) {
+    var le = 0;
+    if (ex) {
+      for (var k in ex) {
+        var l = ex[k].length;
+        if (l > 65535)
+          err(9);
+        le += l + 4;
+      }
+    }
+    return le;
+  };
+  var wzh = function(d, b, f, fn, u, c, ce, co) {
+    var fl2 = fn.length, ex = f.extra, col = co && co.length;
+    var exl = exfl(ex);
+    wbytes(d, b, ce != null ? 33639248 : 67324752), b += 4;
+    if (ce != null)
+      d[b++] = 20, d[b++] = f.os;
+    d[b] = 20, b += 2;
+    d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
+    d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
+    var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
+    if (y < 0 || y > 119)
+      err(10);
+    wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
+    if (c != -1) {
+      wbytes(d, b, f.crc);
+      wbytes(d, b + 4, c < 0 ? -c - 2 : c);
+      wbytes(d, b + 8, f.size);
+    }
+    wbytes(d, b + 12, fl2);
+    wbytes(d, b + 14, exl), b += 16;
+    if (ce != null) {
+      wbytes(d, b, col);
+      wbytes(d, b + 6, f.attrs);
+      wbytes(d, b + 10, ce), b += 14;
+    }
+    d.set(fn, b);
+    b += fl2;
+    if (exl) {
+      for (var k in ex) {
+        var exf = ex[k], l = exf.length;
+        wbytes(d, b, +k);
+        wbytes(d, b + 2, l);
+        d.set(exf, b + 4), b += 4 + l;
+      }
+    }
+    if (col)
+      d.set(co, b), b += col;
+    return b;
+  };
+  var wzf = function(o, b, c, d, e) {
+    wbytes(o, b, 101010256);
+    wbytes(o, b + 8, c);
+    wbytes(o, b + 10, c);
+    wbytes(o, b + 12, d);
+    wbytes(o, b + 16, e);
+  };
+  var ZipPassThrough = /* @__PURE__ */ (function() {
+    function ZipPassThrough2(filename) {
+      this.filename = filename;
+      this.c = crc();
+      this.size = 0;
+      this.compression = 0;
+    }
+    ZipPassThrough2.prototype.process = function(chunk, final) {
+      this.ondata(null, chunk, final);
+    };
+    ZipPassThrough2.prototype.push = function(chunk, final) {
+      if (!this.ondata)
+        err(5);
+      this.c.p(chunk);
+      this.size += chunk.length;
+      if (final)
+        this.crc = this.c.d();
+      this.process(chunk, final || false);
+    };
+    return ZipPassThrough2;
+  })();
+  var ZipDeflate = /* @__PURE__ */ (function() {
+    function ZipDeflate2(filename, opts) {
+      var _this = this;
+      if (!opts)
+        opts = {};
+      ZipPassThrough.call(this, filename);
+      this.d = new Deflate(opts, function(dat, final) {
+        _this.ondata(null, dat, final);
+      });
+      this.compression = 8;
+      this.flag = dbf(opts.level);
+    }
+    ZipDeflate2.prototype.process = function(chunk, final) {
+      try {
+        this.d.push(chunk, final);
+      } catch (e) {
+        this.ondata(e, null, final);
+      }
+    };
+    ZipDeflate2.prototype.push = function(chunk, final) {
+      ZipPassThrough.prototype.push.call(this, chunk, final);
+    };
+    return ZipDeflate2;
+  })();
+  var Zip = /* @__PURE__ */ (function() {
+    function Zip2(cb) {
+      this.ondata = cb;
+      this.u = [];
+      this.d = 1;
+    }
+    Zip2.prototype.add = function(file) {
+      var _this = this;
+      if (!this.ondata)
+        err(5);
+      if (this.d & 2)
+        this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false);
+      else {
+        var f = strToU8(file.filename), fl_1 = f.length;
+        var com = file.comment, o = com && strToU8(com);
+        var u = fl_1 != file.filename.length || o && com.length != o.length;
+        var hl_1 = fl_1 + exfl(file.extra) + 30;
+        if (fl_1 > 65535)
+          this.ondata(err(11, 0, 1), null, false);
+        var header = new u8(hl_1);
+        wzh(header, 0, file, f, u, -1);
+        var chks_1 = [header];
+        var pAll_1 = function() {
+          for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) {
+            var chk = chks_2[_i];
+            _this.ondata(null, chk, false);
+          }
+          chks_1 = [];
+        };
+        var tr_1 = this.d;
+        this.d = 0;
+        var ind_1 = this.u.length;
+        var uf_1 = mrg(file, {
+          f,
+          u,
+          o,
+          t: function() {
+            if (file.terminate)
+              file.terminate();
+          },
+          r: function() {
+            pAll_1();
+            if (tr_1) {
+              var nxt = _this.u[ind_1 + 1];
+              if (nxt)
+                nxt.r();
+              else
+                _this.d = 1;
+            }
+            tr_1 = 1;
+          }
+        });
+        var cl_1 = 0;
+        file.ondata = function(err2, dat, final) {
+          if (err2) {
+            _this.ondata(err2, dat, final);
+            _this.terminate();
+          } else {
+            cl_1 += dat.length;
+            chks_1.push(dat);
+            if (final) {
+              var dd = new u8(16);
+              wbytes(dd, 0, 134695760);
+              wbytes(dd, 4, file.crc);
+              wbytes(dd, 8, cl_1);
+              wbytes(dd, 12, file.size);
+              chks_1.push(dd);
+              uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size;
+              if (tr_1)
+                uf_1.r();
+              tr_1 = 1;
+            } else if (tr_1)
+              pAll_1();
+          }
+        };
+        this.u.push(uf_1);
+      }
+    };
+    Zip2.prototype.end = function() {
+      var _this = this;
+      if (this.d & 2) {
+        this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true);
+        return;
+      }
+      if (this.d)
+        this.e();
+      else
+        this.u.push({
+          r: function() {
+            if (!(_this.d & 1))
+              return;
+            _this.u.splice(-1, 1);
+            _this.e();
+          },
+          t: function() {
+          }
+        });
+      this.d = 3;
+    };
+    Zip2.prototype.e = function() {
+      var bt = 0, l = 0, tl = 0;
+      for (var _i = 0, _a2 = this.u; _i < _a2.length; _i++) {
+        var f = _a2[_i];
+        tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0);
+      }
+      var out = new u8(tl + 22);
+      for (var _b2 = 0, _c = this.u; _b2 < _c.length; _b2++) {
+        var f = _c[_b2];
+        wzh(out, bt, f, f.f, f.u, -f.c - 2, l, f.o);
+        bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b;
+      }
+      wzf(out, bt, this.u.length, tl, l);
+      this.ondata(null, out, true);
+      this.d = 2;
+    };
+    Zip2.prototype.terminate = function() {
+      for (var _i = 0, _a2 = this.u; _i < _a2.length; _i++) {
+        var f = _a2[_i];
+        f.t();
+      }
+      this.d = 2;
+    };
+    return Zip2;
+  })();
+  var ModelExportErrorCode = /* @__PURE__ */ ((ModelExportErrorCode2) => {
+    ModelExportErrorCode2["Cancelled"] = "cancelled";
+    ModelExportErrorCode2["InvalidJob"] = "invalid-job";
+    ModelExportErrorCode2["InvalidModel"] = "invalid-model";
+    ModelExportErrorCode2["InvalidSource"] = "invalid-source";
+    ModelExportErrorCode2["Protocol"] = "protocol";
+    ModelExportErrorCode2["UnsupportedModel"] = "unsupported-model";
+    ModelExportErrorCode2["WriteFailed"] = "write-failed";
+    return ModelExportErrorCode2;
+  })(ModelExportErrorCode || {});
+  class ModelExportError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+      this.name = "ModelExportError";
+    }
+  }
+  class ExportChunkAcknowledgement {
+    chunkId;
+    promise;
+    taskId;
+    rejectPromise;
+    resolvePromise;
+    settled = false;
+    constructor(taskId, chunkId) {
+      this.taskId = taskId;
+      this.chunkId = chunkId;
+      this.promise = new Promise(this.initializePromise.bind(this));
+    }
+    acknowledge() {
+      if (this.settled) {
+        return;
+      }
+      this.settled = true;
+      this.resolvePromise?.();
+    }
+    cancel() {
+      if (this.settled) {
+        return;
+      }
+      this.settled = true;
+      this.rejectPromise?.(
+        new ModelExportError(ModelExportErrorCode.Cancelled, "The model export was cancelled.")
+      );
+    }
+    initializePromise(resolve, reject) {
+      this.resolvePromise = resolve;
+      this.rejectPromise = reject;
+    }
+  }
+  class ExportJobValidator {
+    validate(job) {
+      this.assertTaskId(job.taskId);
+      this.assertRoles(job.roles);
+    }
+    assertTaskId(taskId) {
+      if (!Number.isSafeInteger(taskId) || taskId <= 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The export task id must be a positive safe integer."
+        );
+      }
+    }
+    assertRoles(roles) {
+      if (roles.length === 0 || roles.length > 2) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "An export must contain one or two model roles."
+        );
+      }
+      for (let index = 0; index < roles.length; index += 1) {
+        const role = roles[index];
+        if (role === void 0) {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidJob,
+            "The export contains an empty role."
+          );
+        }
+        this.assertRole(role, index, roles.length);
+      }
+    }
+    assertRole(role, index, roleCount) {
+      const expectedRole = index === 0 ? "stone" : "base";
+      if (roleCount > 1 && role.role !== expectedRole) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "Export roles must be ordered as stone followed by base."
+        );
+      }
+      if (!this.isModelFormat(role.format)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The export role has an unsupported model format."
+        );
+      }
+      this.assertMatrix(role.matrix);
+      if (role.kind === "generated-obj") {
+        this.assertGeneratedRole(role);
+        return;
+      }
+      this.assertFiles(role.files, role.format);
+    }
+    assertGeneratedRole(role) {
+      const roleValue = role.role;
+      if (roleValue !== "base" || !this.isModelFormat(role.sourceFormat)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "Only the base role may contain a generated Boolean mesh."
+        );
+      }
+      if (!this.isSafeFileName(role.modelFileName) || !this.isSafeFileName(role.materialFileName)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "Generated model file names must be single safe file names."
+        );
+      }
+      this.assertFiles(role.files, role.sourceFormat);
+      this.assertGeneratedSnapshot(role.generated);
+    }
+    assertGeneratedSnapshot(snapshot) {
+      if (!Number.isSafeInteger(snapshot.sourceRevision) || snapshot.sourceRevision < 1 || !Number.isSafeInteger(snapshot.revision) || snapshot.revision < 1 || snapshot.positions.length === 0 || snapshot.positions.length % 3 !== 0 || snapshot.normals.length !== snapshot.positions.length || snapshot.uvs.length !== snapshot.positions.length / 3 * 2 || snapshot.indices.length === 0 || snapshot.indices.length % 3 !== 0 || snapshot.groups.length === 0 || snapshot.materials.length === 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The generated Boolean base mesh is incomplete."
+        );
+      }
+      if (!this.hasFiniteValues(snapshot.positions) || !this.hasFiniteValues(snapshot.normals) || !this.hasFiniteValues(snapshot.uvs)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The generated Boolean base mesh contains non-finite values."
+        );
+      }
+      for (const index of snapshot.indices) {
+        if (index >= snapshot.positions.length / 3) {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidJob,
+            "The generated Boolean base mesh contains an invalid index."
+          );
+        }
+      }
+      for (const group of snapshot.groups) {
+        if (!Number.isSafeInteger(group.start) || !Number.isSafeInteger(group.count) || !Number.isSafeInteger(group.materialIndex) || group.start < 0 || group.count <= 0 || group.start + group.count > snapshot.indices.length || group.start % 3 !== 0 || group.count % 3 !== 0 || group.materialIndex < 0 || group.materialIndex >= snapshot.materials.length) {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidJob,
+            "The generated Boolean base mesh has invalid material groups."
+          );
+        }
+      }
+    }
+    hasFiniteValues(values) {
+      return values.every(Number.isFinite);
+    }
+    assertMatrix(matrix) {
+      if (matrix.length !== 16 || !matrix.every(Number.isFinite)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The export role must include sixteen finite world matrix values."
+        );
+      }
+    }
+    assertFiles(files, format) {
+      if (files.length === 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The export role must contain at least one source file."
+        );
+      }
+      const fileNames = /* @__PURE__ */ new Set();
+      let modelCount = 0;
+      for (const file of files) {
+        this.assertFile(file, format, fileNames);
+        if (file.isModel) {
+          modelCount += 1;
+        }
+      }
+      if (modelCount !== 1) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "Each export role must contain exactly one model file."
+        );
+      }
+    }
+    assertFile(file, format, fileNames) {
+      if (!this.isSafeFileName(file.fileName)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "Each export file name must be a single non-empty file name."
+        );
+      }
+      if (fileNames.has(file.fileName)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "File names must be unique within an export role."
+        );
+      }
+      fileNames.add(file.fileName);
+      if (file.url.length === 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "Each export file must include a source URL."
+        );
+      }
+      if (file.isModel && !this.hasExpectedModelExtension(file.fileName, format)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The marked model file does not match the role model format."
+        );
+      }
+    }
+    hasExpectedModelExtension(fileName, format) {
+      return fileName.toLowerCase().endsWith(`.${format}`);
+    }
+    isModelFormat(value) {
+      return value === "obj" || value === "ply";
+    }
+    isSafeFileName(fileName) {
+      return fileName.length > 0 && !fileName.includes("/") && !fileName.includes("\\") && !fileName.includes("\0") && fileName !== "." && fileName !== "..";
+    }
+  }
+  class ExportWorkerMessageParser {
+    parseInbound(value) {
+      const record = this.getRecord(value);
+      if (record === void 0) {
+        return void 0;
+      }
+      switch (record["type"]) {
+        case "acknowledge-chunk":
+          return this.parseAcknowledgement(record);
+        case "cancel":
+          return this.parseCancellation(record);
+        case "start":
+          return this.parseStart(record);
+        default:
+          return void 0;
+      }
+    }
+    parseOutbound(value) {
+      const record = this.getRecord(value);
+      if (record === void 0) {
+        return void 0;
+      }
+      const taskId = record["taskId"];
+      if (!this.isPositiveSafeInteger(taskId)) {
+        return void 0;
+      }
+      switch (record["type"]) {
+        case "cancelled":
+          return {
+            taskId,
+            type: "cancelled"
+          };
+        case "complete":
+          return {
+            taskId,
+            type: "complete"
+          };
+        case "error":
+          return typeof record["message"] === "string" ? {
+            message: record["message"],
+            taskId,
+            type: "error"
+          } : void 0;
+        case "progress":
+          return this.parseProgress(record, taskId);
+        case "zip-chunk":
+          return this.parseZipChunk(record, taskId);
+        default:
+          return void 0;
+      }
+    }
+    getRecord(value) {
+      return this.isRecord(value) ? value : void 0;
+    }
+    isPositiveSafeInteger(value) {
+      return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+    }
+    parseAcknowledgement(record) {
+      const chunkId = record["chunkId"];
+      const taskId = record["taskId"];
+      if (!this.isPositiveSafeInteger(chunkId) || !this.isPositiveSafeInteger(taskId)) {
+        return void 0;
+      }
+      return {
+        chunkId,
+        taskId,
+        type: "acknowledge-chunk"
+      };
+    }
+    parseCancellation(record) {
+      const taskId = record["taskId"];
+      if (!this.isPositiveSafeInteger(taskId)) {
+        return void 0;
+      }
+      return {
+        taskId,
+        type: "cancel"
+      };
+    }
+    parseProgress(record, taskId) {
+      const completedFileCount = record["completedFileCount"];
+      const totalFileCount = record["totalFileCount"];
+      if (!this.isNonNegativeSafeInteger(completedFileCount) || !this.isPositiveSafeInteger(totalFileCount) || completedFileCount > totalFileCount) {
+        return void 0;
+      }
+      return {
+        completedFileCount,
+        taskId,
+        totalFileCount,
+        type: "progress"
+      };
+    }
+    parseStart(record) {
+      const job = this.parseJob(record["job"]);
+      if (job === void 0) {
+        return void 0;
+      }
+      return {
+        job,
+        type: "start"
+      };
+    }
+    parseZipChunk(record, taskId) {
+      const chunk = record["chunk"];
+      const chunkId = record["chunkId"];
+      if (!(chunk instanceof ArrayBuffer) || !this.isPositiveSafeInteger(chunkId)) {
+        return void 0;
+      }
+      return {
+        chunk,
+        chunkId,
+        taskId,
+        type: "zip-chunk"
+      };
+    }
+    isModelFormat(value) {
+      return value === "obj" || value === "ply";
+    }
+    isModelRole(value) {
+      return value === "stone" || value === "base";
+    }
+    isRecord(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+    isUnknownArray(value) {
+      return Array.isArray(value);
+    }
+    parseFile(value) {
+      const record = this.getRecord(value);
+      if (record === void 0 || typeof record["fileName"] !== "string" || typeof record["isModel"] !== "boolean" || typeof record["url"] !== "string") {
+        return void 0;
+      }
+      return {
+        fileName: record["fileName"],
+        isModel: record["isModel"],
+        url: record["url"]
+      };
+    }
+    parseFiles(value) {
+      if (!this.isUnknownArray(value)) {
+        return void 0;
+      }
+      const files = [];
+      for (const item of value) {
+        const file = this.parseFile(item);
+        if (file === void 0) {
+          return void 0;
+        }
+        files.push(file);
+      }
+      return files;
+    }
+    parseJob(value) {
+      const record = this.getRecord(value);
+      const taskId = record?.["taskId"];
+      const roles = this.parseRoles(record?.["roles"]);
+      if (!this.isPositiveSafeInteger(taskId) || roles === void 0) {
+        return void 0;
+      }
+      return {
+        roles,
+        taskId
+      };
+    }
+    parseMatrix(value) {
+      if (!this.isUnknownArray(value)) {
+        return void 0;
+      }
+      const matrix = [];
+      for (const item of value) {
+        if (typeof item !== "number") {
+          return void 0;
+        }
+        matrix.push(item);
+      }
+      return matrix;
+    }
+    parseRole(value) {
+      const record = this.getRecord(value);
+      if (record === void 0) {
+        return void 0;
+      }
+      const files = this.parseFiles(record["files"]);
+      const format = record["format"];
+      const matrix = this.parseMatrix(record["matrix"]);
+      const role = record["role"];
+      if (files === void 0 || !this.isModelFormat(format) || matrix === void 0 || !this.isModelRole(role)) {
+        return void 0;
+      }
+      if (record["kind"] === "generated-obj") {
+        return this.parseGeneratedRole(record, files, matrix);
+      }
+      if (record["kind"] !== void 0 && record["kind"] !== "original") {
+        return void 0;
+      }
+      return {
+        files,
+        format,
+        matrix,
+        role
+      };
+    }
+    parseGeneratedRole(record, files, matrix) {
+      const generated = this.parseGeneratedSnapshot(record["generated"]);
+      const materialFileName = record["materialFileName"];
+      const modelFileName = record["modelFileName"];
+      const role = record["role"];
+      const sourceFormat = record["sourceFormat"];
+      if (generated === void 0 || typeof materialFileName !== "string" || typeof modelFileName !== "string" || role !== "base" || sourceFormat !== "obj" && sourceFormat !== "ply") {
+        return void 0;
+      }
+      return {
+        files,
+        format: "obj",
+        generated,
+        kind: "generated-obj",
+        materialFileName,
+        matrix,
+        modelFileName,
+        role: "base",
+        sourceFormat
+      };
+    }
+    parseGeneratedSnapshot(value) {
+      const record = this.getRecord(value);
+      const groups = this.parseGeneratedGroups(record?.["groups"]);
+      const indices = record?.["indices"];
+      const materials = this.parseGeneratedMaterials(record?.["materials"]);
+      const normals = record?.["normals"];
+      const positions = record?.["positions"];
+      const revision = record?.["revision"];
+      const sourceRevision = record?.["sourceRevision"];
+      const uvs = record?.["uvs"];
+      if (groups === void 0 || !(indices instanceof Uint32Array) || materials === void 0 || !(normals instanceof Float32Array) || !(positions instanceof Float32Array) || !this.isPositiveSafeInteger(revision) || !this.isPositiveSafeInteger(sourceRevision) || !(uvs instanceof Float32Array)) {
+        return void 0;
+      }
+      return {
+        groups,
+        indices,
+        materials,
+        normals,
+        positions,
+        revision,
+        sourceRevision,
+        uvs
+      };
+    }
+    parseGeneratedGroups(value) {
+      if (!this.isUnknownArray(value)) {
+        return void 0;
+      }
+      const groups = [];
+      for (const item of value) {
+        const record = this.getRecord(item);
+        const count = record?.["count"];
+        const materialIndex = record?.["materialIndex"];
+        const start = record?.["start"];
+        if (!this.isNonNegativeSafeInteger(count) || !this.isNonNegativeSafeInteger(materialIndex) || !this.isNonNegativeSafeInteger(start)) {
+          return void 0;
+        }
+        groups.push({ count, materialIndex, start });
+      }
+      return groups;
+    }
+    parseGeneratedMaterials(value) {
+      if (!this.isUnknownArray(value)) {
+        return void 0;
+      }
+      const materials = [];
+      for (const item of value) {
+        const record = this.getRecord(item);
+        const color = this.parseColor(record?.["color"]);
+        const kind = record?.["kind"];
+        const name = record?.["name"];
+        const opacity = record?.["opacity"];
+        if (color === void 0 || typeof name !== "string" || typeof opacity !== "number") {
+          return void 0;
+        }
+        if (kind === "boolean-cut" && name === "lingbi_boolean_cut") {
+          materials.push({ color, kind, name, opacity });
+          continue;
+        }
+        const sourceName = record?.["sourceName"];
+        const textured = record?.["textured"];
+        if (kind !== "source" || typeof sourceName !== "string" || typeof textured !== "boolean") {
+          return void 0;
+        }
+        materials.push({ color, kind, name, opacity, sourceName, textured });
+      }
+      return materials;
+    }
+    parseColor(value) {
+      if (!this.isUnknownArray(value) || value.length !== 3) {
+        return void 0;
+      }
+      const [red, green, blue] = value;
+      return typeof red === "number" && typeof green === "number" && typeof blue === "number" && Number.isFinite(red) && Number.isFinite(green) && Number.isFinite(blue) ? [red, green, blue] : void 0;
+    }
+    parseRoles(value) {
+      if (!this.isUnknownArray(value)) {
+        return void 0;
+      }
+      const roles = [];
+      for (const item of value) {
+        const role = this.parseRole(item);
+        if (role === void 0) {
+          return void 0;
+        }
+        roles.push(role);
+      }
+      return roles;
+    }
+    isNonNegativeSafeInteger(value) {
+      return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+    }
+  }
+  class ExportWorkerTask {
+    abortController = new AbortController();
+    awaitingAcknowledgement;
+    cancelled = false;
+    nextChunkId = 1;
+    queuedZipChunks = [];
+    request;
+    zip;
+    constructor(request) {
+      this.request = request;
+    }
+    cancel() {
+      if (this.cancelled) {
+        return;
+      }
+      this.cancelled = true;
+      this.abortController.abort();
+      this.awaitingAcknowledgement?.cancel();
+      this.zip?.terminate();
+      this.queuedZipChunks.length = 0;
+    }
+  }
+  const GENERATED_TEXT_CHUNK_SIZE = 65536;
+  class GeneratedTextChunkWriter {
+    chunks = [];
+    current = new Uint8Array(GENERATED_TEXT_CHUNK_SIZE);
+    currentLength = 0;
+    encoder = new TextEncoder();
+    appendLine(value) {
+      this.append(this.encoder.encode(`${value}
+`));
+    }
+    toChunks() {
+      const chunks = [...this.chunks];
+      if (this.currentLength > 0) {
+        chunks.push(this.current.slice(0, this.currentLength));
+      }
+      return chunks;
+    }
+    append(value) {
+      let offset = 0;
+      while (offset < value.byteLength) {
+        const available = this.current.byteLength - this.currentLength;
+        const length = Math.min(available, value.byteLength - offset);
+        this.current.set(value.subarray(offset, offset + length), this.currentLength);
+        this.currentLength += length;
+        offset += length;
+        if (this.currentLength === this.current.byteLength) {
+          this.chunks.push(this.current);
+          this.current = new Uint8Array(GENERATED_TEXT_CHUNK_SIZE);
+          this.currentLength = 0;
+        }
+      }
+    }
+  }
+  class GeneratedMtlWriter {
+    createChunks(snapshot, sourceTexts) {
+      const definitions = this.collectDefinitions(sourceTexts);
+      const writer = new GeneratedTextChunkWriter();
+      writer.appendLine("# Lingbi Boolean base materials");
+      for (const material of snapshot.materials) {
+        this.writeMaterial(writer, material, definitions);
+      }
+      return writer.toChunks();
+    }
+    collectDefinitions(sourceTexts) {
+      const definitions = /* @__PURE__ */ new Map();
+      for (const sourceText of sourceTexts) {
+        let currentName;
+        let currentLines = [];
+        for (const line of sourceText.split(/\r?\n/u)) {
+          const match = /^\s*newmtl\s+(.+?)\s*$/iu.exec(line);
+          if (match !== null) {
+            this.addDefinition(definitions, currentName, currentLines);
+            currentName = match[1];
+            currentLines = [line];
+          } else if (currentName !== void 0) {
+            currentLines.push(line);
+          }
+        }
+        this.addDefinition(definitions, currentName, currentLines);
+      }
+      return definitions;
+    }
+    addDefinition(definitions, name, lines) {
+      if (name === void 0 || lines.length === 0) {
+        return;
+      }
+      const existing = definitions.get(name) ?? [];
+      existing.push({ lines });
+      definitions.set(name, existing);
+    }
+    writeMaterial(writer, material, definitions) {
+      if (material.kind === "boolean-cut") {
+        this.writeMinimalMaterial(writer, material);
+        return;
+      }
+      const matches = definitions.get(material.sourceName) ?? [];
+      if (matches.length > 1) {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          `The source material ${material.sourceName} is defined by multiple MTL files.`
+        );
+      }
+      const definition = matches[0];
+      if (definition === void 0) {
+        if (material.textured) {
+          throw new ModelExportError(
+            ModelExportErrorCode.UnsupportedModel,
+            `The textured source material ${material.sourceName} has no unique MTL definition.`
+          );
+        }
+        this.writeMinimalMaterial(writer, material);
+        return;
+      }
+      for (let index = 0; index < definition.lines.length; index += 1) {
+        const line = definition.lines[index];
+        if (line === void 0) {
+          continue;
+        }
+        writer.appendLine(index === 0 ? `newmtl ${material.name}` : line);
+      }
+    }
+    writeMinimalMaterial(writer, material) {
+      writer.appendLine(`newmtl ${material.name}`);
+      writer.appendLine(
+        `Kd ${this.formatNumber(material.color[0])} ${this.formatNumber(material.color[1])} ${this.formatNumber(material.color[2])}`
+      );
+      writer.appendLine(`d ${this.formatNumber(material.opacity)}`);
+      writer.appendLine("Ns 20");
+      writer.appendLine("illum 2");
+    }
+    formatNumber(value) {
+      return String(value);
+    }
+  }
+  class MatrixTransformer {
+    inverseTranspose00;
+    inverseTranspose01;
+    inverseTranspose02;
+    inverseTranspose10;
+    inverseTranspose11;
+    inverseTranspose12;
+    inverseTranspose20;
+    inverseTranspose21;
+    inverseTranspose22;
+    matrix;
+    constructor(matrix) {
+      this.assertAffineMatrix(matrix);
+      this.matrix = matrix;
+      const inverseTranspose = this.createInverseTranspose(matrix);
+      this.inverseTranspose00 = this.getMatrixValue(inverseTranspose, 0);
+      this.inverseTranspose01 = this.getMatrixValue(inverseTranspose, 1);
+      this.inverseTranspose02 = this.getMatrixValue(inverseTranspose, 2);
+      this.inverseTranspose10 = this.getMatrixValue(inverseTranspose, 3);
+      this.inverseTranspose11 = this.getMatrixValue(inverseTranspose, 4);
+      this.inverseTranspose12 = this.getMatrixValue(inverseTranspose, 5);
+      this.inverseTranspose20 = this.getMatrixValue(inverseTranspose, 6);
+      this.inverseTranspose21 = this.getMatrixValue(inverseTranspose, 7);
+      this.inverseTranspose22 = this.getMatrixValue(inverseTranspose, 8);
+    }
+    transformNormal(x2, y, z) {
+      this.assertFiniteVector(x2, y, z, "normal");
+      const transformedX = this.inverseTranspose00 * x2 + this.inverseTranspose01 * y + this.inverseTranspose02 * z;
+      const transformedY = this.inverseTranspose10 * x2 + this.inverseTranspose11 * y + this.inverseTranspose12 * z;
+      const transformedZ = this.inverseTranspose20 * x2 + this.inverseTranspose21 * y + this.inverseTranspose22 * z;
+      const length = Math.hypot(transformedX, transformedY, transformedZ);
+      if (!Number.isFinite(length) || length === 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "A model normal cannot be normalized after its world transform."
+        );
+      }
+      return [
+        this.assertFiniteResult(transformedX / length, "normal"),
+        this.assertFiniteResult(transformedY / length, "normal"),
+        this.assertFiniteResult(transformedZ / length, "normal")
+      ];
+    }
+    transformPosition(x2, y, z) {
+      this.assertFiniteVector(x2, y, z, "position");
+      const matrix = this.matrix;
+      return [
+        this.assertFiniteResult(
+          this.getMatrixValue(matrix, 0) * x2 + this.getMatrixValue(matrix, 4) * y + this.getMatrixValue(matrix, 8) * z + this.getMatrixValue(matrix, 12),
+          "position"
+        ),
+        this.assertFiniteResult(
+          this.getMatrixValue(matrix, 1) * x2 + this.getMatrixValue(matrix, 5) * y + this.getMatrixValue(matrix, 9) * z + this.getMatrixValue(matrix, 13),
+          "position"
+        ),
+        this.assertFiniteResult(
+          this.getMatrixValue(matrix, 2) * x2 + this.getMatrixValue(matrix, 6) * y + this.getMatrixValue(matrix, 10) * z + this.getMatrixValue(matrix, 14),
+          "position"
+        )
+      ];
+    }
+    assertAffineMatrix(matrix) {
+      if (matrix.length !== 16 || !matrix.every(Number.isFinite)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The world matrix must contain sixteen finite values."
+        );
+      }
+      if (this.getMatrixValue(matrix, 3) !== 0 || this.getMatrixValue(matrix, 7) !== 0 || this.getMatrixValue(matrix, 11) !== 0 || this.getMatrixValue(matrix, 15) !== 1) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The world matrix must be affine."
+        );
+      }
+    }
+    assertFiniteResult(value, kind) {
+      if (!Number.isFinite(value)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `The transformed ${kind} is not finite.`
+        );
+      }
+      return value;
+    }
+    assertFiniteVector(x2, y, z, kind) {
+      if (!Number.isFinite(x2) || !Number.isFinite(y) || !Number.isFinite(z)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `The model ${kind} contains a non-finite value.`
+        );
+      }
+    }
+    createInverseTranspose(matrix) {
+      const a00 = this.getMatrixValue(matrix, 0);
+      const a01 = this.getMatrixValue(matrix, 4);
+      const a02 = this.getMatrixValue(matrix, 8);
+      const a10 = this.getMatrixValue(matrix, 1);
+      const a11 = this.getMatrixValue(matrix, 5);
+      const a12 = this.getMatrixValue(matrix, 9);
+      const a20 = this.getMatrixValue(matrix, 2);
+      const a21 = this.getMatrixValue(matrix, 6);
+      const a22 = this.getMatrixValue(matrix, 10);
+      const cofactor00 = a11 * a22 - a12 * a21;
+      const cofactor01 = a12 * a20 - a10 * a22;
+      const cofactor02 = a10 * a21 - a11 * a20;
+      const cofactor10 = a02 * a21 - a01 * a22;
+      const cofactor11 = a00 * a22 - a02 * a20;
+      const cofactor12 = a01 * a20 - a00 * a21;
+      const cofactor20 = a01 * a12 - a02 * a11;
+      const cofactor21 = a02 * a10 - a00 * a12;
+      const cofactor22 = a00 * a11 - a01 * a10;
+      const determinant = a00 * cofactor00 + a01 * cofactor01 + a02 * cofactor02;
+      if (!Number.isFinite(determinant) || determinant === 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The world matrix cannot transform normals because its scale is singular."
+        );
+      }
+      const reciprocalDeterminant = 1 / determinant;
+      return [
+        cofactor00 * reciprocalDeterminant,
+        cofactor01 * reciprocalDeterminant,
+        cofactor02 * reciprocalDeterminant,
+        cofactor10 * reciprocalDeterminant,
+        cofactor11 * reciprocalDeterminant,
+        cofactor12 * reciprocalDeterminant,
+        cofactor20 * reciprocalDeterminant,
+        cofactor21 * reciprocalDeterminant,
+        cofactor22 * reciprocalDeterminant
+      ];
+    }
+    getMatrixValue(matrix, index) {
+      const value = matrix[index];
+      if (value === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidJob,
+          "The world matrix does not contain all sixteen values."
+        );
+      }
+      return value;
+    }
+  }
+  class GeneratedObjModelBaker {
+    createChunks(snapshot, matrix, materialFileName) {
+      const transformer = new MatrixTransformer(matrix);
+      const writer = new GeneratedTextChunkWriter();
+      writer.appendLine(`# Lingbi Boolean base export`);
+      writer.appendLine(`mtllib ${materialFileName}`);
+      writer.appendLine("o base");
+      this.writePositions(writer, snapshot, transformer);
+      this.writeUvs(writer, snapshot);
+      this.writeNormals(writer, snapshot, transformer);
+      this.writeFaces(writer, snapshot);
+      return writer.toChunks();
+    }
+    writeFaces(writer, snapshot) {
+      for (const group of snapshot.groups) {
+        const material = snapshot.materials[group.materialIndex];
+        if (material === void 0) {
+          throw new Error("The generated Boolean material group is incomplete.");
+        }
+        writer.appendLine(`usemtl ${material.name}`);
+        for (let offset = group.start; offset < group.start + group.count; offset += 3) {
+          const first = snapshot.indices[offset];
+          const second = snapshot.indices[offset + 1];
+          const third = snapshot.indices[offset + 2];
+          if (first === void 0 || second === void 0 || third === void 0) {
+            throw new Error("The generated Boolean face index is incomplete.");
+          }
+          writer.appendLine(
+            `f ${this.formatIndex(first)}/${this.formatIndex(first)}/${this.formatIndex(first)} ${this.formatIndex(second)}/${this.formatIndex(second)}/${this.formatIndex(second)} ${this.formatIndex(third)}/${this.formatIndex(third)}/${this.formatIndex(third)}`
+          );
+        }
+      }
+    }
+    writeNormals(writer, snapshot, transformer) {
+      for (let index = 0; index < snapshot.normals.length; index += 3) {
+        const normal = transformer.transformNormal(
+          this.getValue(snapshot.normals, index),
+          this.getValue(snapshot.normals, index + 1),
+          this.getValue(snapshot.normals, index + 2)
+        );
+        writer.appendLine(
+          `vn ${this.formatNumber(normal[0])} ${this.formatNumber(normal[1])} ${this.formatNumber(normal[2])}`
+        );
+      }
+    }
+    writePositions(writer, snapshot, transformer) {
+      for (let index = 0; index < snapshot.positions.length; index += 3) {
+        const position = transformer.transformPosition(
+          this.getValue(snapshot.positions, index),
+          this.getValue(snapshot.positions, index + 1),
+          this.getValue(snapshot.positions, index + 2)
+        );
+        writer.appendLine(
+          `v ${this.formatNumber(position[0])} ${this.formatNumber(position[1])} ${this.formatNumber(position[2])}`
+        );
+      }
+    }
+    writeUvs(writer, snapshot) {
+      for (let index = 0; index < snapshot.uvs.length; index += 2) {
+        writer.appendLine(
+          `vt ${this.formatNumber(this.getValue(snapshot.uvs, index))} ${this.formatNumber(this.getValue(snapshot.uvs, index + 1))}`
+        );
+      }
+    }
+    getValue(values, index) {
+      const value = values[index];
+      if (value === void 0 || !Number.isFinite(value)) {
+        throw new Error("The generated Boolean mesh contains an invalid value.");
+      }
+      return value;
+    }
+    formatIndex(value) {
+      return String(value + 1);
+    }
+    formatNumber(value) {
+      return String(value);
+    }
+  }
+  class ByteChunkWriter {
+    buffer;
+    length = 0;
+    constructor(initialCapacity) {
+      this.buffer = new Uint8Array(Math.max(initialCapacity, 1));
+    }
+    append(bytes) {
+      this.ensureCapacity(bytes.byteLength);
+      this.buffer.set(bytes, this.length);
+      this.length += bytes.byteLength;
+    }
+    appendRange(bytes, start, end) {
+      this.append(bytes.subarray(start, end));
+    }
+    hasData() {
+      return this.length > 0;
+    }
+    toBytes() {
+      return this.buffer.slice(0, this.length);
+    }
+    ensureCapacity(additionalLength) {
+      const requiredLength = this.length + additionalLength;
+      if (requiredLength <= this.buffer.byteLength) {
+        return;
+      }
+      const replacement = new Uint8Array(Math.max(requiredLength, this.buffer.byteLength * 2));
+      replacement.set(this.buffer.subarray(0, this.length));
+      this.buffer = replacement;
+    }
+  }
+  class ObjModelBaker {
+    static MAX_LINE_BYTES = 1048576;
+    encoder = new TextEncoder();
+    transformer;
+    pending = new Uint8Array(0);
+    constructor(matrix) {
+      this.transformer = new MatrixTransformer(matrix);
+    }
+    push(chunk, final) {
+      const source = this.combinePending(chunk);
+      const writer = new ByteChunkWriter(source.byteLength);
+      let lineStart = 0;
+      let cursor = 0;
+      while (cursor < source.byteLength) {
+        const lineEnd = this.findLineEnd(source, cursor, final);
+        if (lineEnd === void 0) {
+          break;
+        }
+        this.appendProcessedLine(writer, source.subarray(lineStart, lineEnd));
+        lineStart = lineEnd;
+        cursor = lineEnd;
+      }
+      const trailing = source.subarray(lineStart);
+      if (final && trailing.byteLength > 0) {
+        this.appendProcessedLine(writer, trailing);
+        this.pending = new Uint8Array(0);
+      } else {
+        this.assertLineLength(trailing.byteLength);
+        this.pending = trailing.slice();
+      }
+      if (final && this.pending.byteLength > 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The OBJ source ended before its final line could be processed."
+        );
+      }
+      return writer.toBytes();
+    }
+    appendProcessedLine(writer, line) {
+      const command = this.findLineCommand(line);
+      if (command === void 0) {
+        writer.append(line);
+        return;
+      }
+      const text = this.decodeLine(line);
+      const fields = this.collectFields(text, command.fieldsStart);
+      if (command.name === "v") {
+        this.appendVertexLine(writer, text, fields);
+        return;
+      }
+      this.appendNormalLine(writer, text, fields);
+    }
+    appendNormalLine(writer, text, fields) {
+      if (fields.length !== 3) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "An OBJ normal must contain exactly three numeric values."
+        );
+      }
+      const transformed = this.transformer.transformNormal(
+        this.parseFiniteNumber(fields[0], "normal"),
+        this.parseFiniteNumber(fields[1], "normal"),
+        this.parseFiniteNumber(fields[2], "normal")
+      );
+      writer.append(this.replaceFieldValues(text, fields, transformed));
+    }
+    appendVertexLine(writer, text, fields) {
+      if (!this.hasSupportedVertexFieldCount(fields.length)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          "The OBJ vertex uses an ambiguous or unsupported field layout."
+        );
+      }
+      const x2 = this.parseFiniteNumber(fields[0], "position");
+      const y = this.parseFiniteNumber(fields[1], "position");
+      const z = this.parseFiniteNumber(fields[2], "position");
+      if (fields.length === 4) {
+        const w = this.parseFiniteNumber(fields[3], "vertex w");
+        if (w !== 1) {
+          throw new ModelExportError(
+            ModelExportErrorCode.UnsupportedModel,
+            "OBJ vertices with a w value other than 1 cannot be exported safely."
+          );
+        }
+      } else if (fields.length === 6 || fields.length === 7) {
+        this.assertFiniteColorValues(fields);
+      }
+      const transformed = this.transformer.transformPosition(x2, y, z);
+      writer.append(this.replaceFieldValues(text, fields, transformed));
+    }
+    assertFiniteColorValues(fields) {
+      for (let index = 3; index < fields.length; index += 1) {
+        const field = fields[index];
+        if (field === void 0) {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidModel,
+            "The OBJ vertex color layout is incomplete."
+          );
+        }
+        this.parseFiniteNumber(field, "vertex color");
+      }
+    }
+    assertLineLength(length) {
+      if (length > ObjModelBaker.MAX_LINE_BYTES) {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          "The OBJ contains a line too large to process safely."
+        );
+      }
+    }
+    collectFields(text, fieldsStart) {
+      const fields = [];
+      let cursor = fieldsStart;
+      while (cursor < text.length) {
+        cursor = this.skipWhitespace(text, cursor);
+        if (cursor >= text.length || text[cursor] === "#") {
+          break;
+        }
+        const start = cursor;
+        while (cursor < text.length && !this.isWhitespace(text[cursor])) {
+          cursor += 1;
+        }
+        fields.push({
+          end: cursor,
+          start,
+          value: text.slice(start, cursor)
+        });
+      }
+      return fields;
+    }
+    combinePending(chunk) {
+      if (this.pending.byteLength === 0) {
+        return chunk;
+      }
+      const combined = new Uint8Array(this.pending.byteLength + chunk.byteLength);
+      combined.set(this.pending);
+      combined.set(chunk, this.pending.byteLength);
+      this.pending = new Uint8Array(0);
+      return combined;
+    }
+    decodeLine(line) {
+      try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(line);
+      } catch {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The OBJ contains an invalid UTF-8 vertex or normal line."
+        );
+      }
+    }
+    findLineCommand(line) {
+      let cursor = 0;
+      while (cursor < line.byteLength && this.isAsciiWhitespace(line[cursor])) {
+        cursor += 1;
+      }
+      if (line[cursor] !== 118) {
+        return void 0;
+      }
+      const next = line[cursor + 1];
+      if (next === 110 && (line[cursor + 2] === void 0 || this.isAsciiWhitespace(line[cursor + 2]))) {
+        return {
+          fieldsStart: cursor + 2,
+          name: "vn"
+        };
+      }
+      if (next === void 0 || this.isAsciiWhitespace(next)) {
+        return {
+          fieldsStart: cursor + 1,
+          name: "v"
+        };
+      }
+      return void 0;
+    }
+    findLineEnd(source, start, final) {
+      for (let cursor = start; cursor < source.byteLength; cursor += 1) {
+        const byte = source[cursor];
+        if (byte === 10) {
+          return cursor + 1;
+        }
+        if (byte !== 13) {
+          continue;
+        }
+        const next = source[cursor + 1];
+        if (next === void 0 && !final) {
+          return void 0;
+        }
+        return next === 10 ? cursor + 2 : cursor + 1;
+      }
+      return void 0;
+    }
+    hasSupportedVertexFieldCount(length) {
+      return length === 3 || length === 4 || length === 6 || length === 7;
+    }
+    isAsciiWhitespace(byte) {
+      return byte === 9 || byte === 11 || byte === 12 || byte === 13 || byte === 32;
+    }
+    isNumericLiteral(value) {
+      return /^[+-]?(?:(?:\d+(?:\.\d*)?)|(?:\.\d+))(?:[eE][+-]?\d+)?$/u.test(value);
+    }
+    isWhitespace(character) {
+      return character === " " || character === "	" || character === "\r" || character === "\n";
+    }
+    parseFiniteNumber(field, kind) {
+      if (field === void 0 || !this.isNumericLiteral(field.value)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `The OBJ ${kind} is not a valid finite number.`
+        );
+      }
+      const value = Number(field.value);
+      if (!Number.isFinite(value)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `The OBJ ${kind} is not finite.`
+        );
+      }
+      return value;
+    }
+    replaceFieldValues(text, fields, values) {
+      let cursor = 0;
+      let output = "";
+      for (let index = 0; index < values.length; index += 1) {
+        const field = fields[index];
+        const value = values[index];
+        if (field === void 0 || value === void 0) {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidModel,
+            "The OBJ model line ended before its position data."
+          );
+        }
+        output += text.slice(cursor, field.start);
+        output += this.formatNumber(value);
+        cursor = field.end;
+      }
+      output += text.slice(cursor);
+      return this.encoder.encode(output);
+    }
+    skipWhitespace(text, cursor) {
+      let next = cursor;
+      while (next < text.length && this.isWhitespace(text[next])) {
+        next += 1;
+      }
+      return next;
+    }
+    formatNumber(value) {
+      return Object.is(value, -0) ? "0" : value.toString();
+    }
+  }
+  class PlyHeaderParser {
+    getScalarDefinition(type) {
+      switch (type) {
+        case "char":
+        case "int8":
+        case "uchar":
+        case "uint8":
+          return {
+            byteLength: 1,
+            floatingPoint: false,
+            integer: true
+          };
+        case "int16":
+        case "short":
+        case "uint16":
+        case "ushort":
+          return {
+            byteLength: 2,
+            floatingPoint: false,
+            integer: true
+          };
+        case "float":
+        case "float32":
+          return {
+            byteLength: 4,
+            floatingPoint: true,
+            integer: false
+          };
+        case "double":
+        case "float64":
+          return {
+            byteLength: 8,
+            floatingPoint: true,
+            integer: false
+          };
+        case "int":
+        case "int32":
+        case "uint":
+        case "uint32":
+          return {
+            byteLength: 4,
+            floatingPoint: false,
+            integer: true
+          };
+      }
+    }
+    parse(headerBytes) {
+      const header = this.decodeHeader(headerBytes);
+      const lines = header.split(/\r\n|\n|\r/u);
+      this.assertMagic(lines[0]);
+      const elements = [];
+      let format;
+      let currentElement;
+      let endHeaderSeen = false;
+      for (let index = 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line === void 0) {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidModel,
+            "The PLY header contains an empty directive."
+          );
+        }
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.startsWith("comment ") || trimmed.startsWith("obj_info ")) {
+          continue;
+        }
+        if (trimmed === "end_header") {
+          endHeaderSeen = true;
+          break;
+        }
+        if (trimmed.startsWith("format ")) {
+          if (format !== void 0) {
+            throw new ModelExportError(
+              ModelExportErrorCode.InvalidModel,
+              "The PLY header declares its format more than once."
+            );
+          }
+          format = this.parseFormat(trimmed);
+          continue;
+        }
+        if (trimmed.startsWith("element ")) {
+          currentElement = this.parseElement(trimmed);
+          elements.push(currentElement);
+          continue;
+        }
+        if (trimmed.startsWith("property ")) {
+          if (currentElement === void 0) {
+            throw new ModelExportError(
+              ModelExportErrorCode.InvalidModel,
+              "A PLY property appears before its element declaration."
+            );
+          }
+          this.addProperty(currentElement, trimmed);
+          continue;
+        }
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          "The PLY header contains an unsupported directive."
+        );
+      }
+      if (!endHeaderSeen || format === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY header is missing a format or end_header directive."
+        );
+      }
+      const vertexElementIndex = this.findVertexElementIndex(elements);
+      const vertexElement = elements[vertexElementIndex];
+      if (vertexElement === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY header is missing its vertex element."
+        );
+      }
+      return {
+        elements,
+        format,
+        vertexElementIndex,
+        vertexLayout: this.createVertexLayout(vertexElement)
+      };
+    }
+    addProperty(element, directive) {
+      const parts = directive.split(/\s+/u);
+      const kind = parts[1];
+      if (kind === "list") {
+        const countType = this.parseScalarType(parts[2]);
+        const itemType = this.parseScalarType(parts[3]);
+        const name2 = this.requirePart(parts, 4, "list property name");
+        if (parts.length !== 5) {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidModel,
+            "A PLY list property must contain exactly five header fields."
+          );
+        }
+        if (!this.getScalarDefinition(countType).integer) {
+          throw new ModelExportError(
+            ModelExportErrorCode.UnsupportedModel,
+            "A PLY list property must use an integer count type."
+          );
+        }
+        element.properties.push({
+          countType,
+          itemType,
+          kind: "list",
+          name: name2
+        });
+        return;
+      }
+      const type = this.parseScalarType(kind);
+      const name = this.requirePart(parts, 2, "scalar property name");
+      if (parts.length !== 3) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "A PLY scalar property must contain exactly three header fields."
+        );
+      }
+      element.properties.push({
+        kind: "scalar",
+        name,
+        type
+      });
+    }
+    assertMagic(value) {
+      const magic = value?.replace(/^\uFEFF/u, "");
+      if (magic !== "ply") {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The model is not a valid PLY file."
+        );
+      }
+    }
+    createVertexLayout(element) {
+      if (element.properties.some(this.isListProperty.bind(this))) {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          "PLY vertex records with list properties cannot be exported safely."
+        );
+      }
+      const fields = this.createVertexFields(element.properties);
+      const position = [
+        this.requireFloatingPointField(fields, ["x", "px", "posx"], "x position"),
+        this.requireFloatingPointField(fields, ["y", "py", "posy"], "y position"),
+        this.requireFloatingPointField(fields, ["z", "pz", "posz"], "z position")
+      ];
+      const normal = this.createNormalFields(fields);
+      return normal === void 0 ? {
+        position,
+        recordByteLength: this.getRecordByteLength(element.properties)
+      } : {
+        normal,
+        position,
+        recordByteLength: this.getRecordByteLength(element.properties)
+      };
+    }
+    createNormalFields(fields) {
+      const x2 = this.findSingleField(fields, ["nx", "normalx"], "x normal");
+      const y = this.findSingleField(fields, ["ny", "normaly"], "y normal");
+      const z = this.findSingleField(fields, ["nz", "normalz"], "z normal");
+      const count = Number(x2 !== void 0) + Number(y !== void 0) + Number(z !== void 0);
+      if (count === 0) {
+        return void 0;
+      }
+      if (count !== 3 || x2 === void 0 || y === void 0 || z === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          "PLY normals must include complete x, y and z fields."
+        );
+      }
+      this.assertFloatingPointField(x2, "x normal");
+      this.assertFloatingPointField(y, "y normal");
+      this.assertFloatingPointField(z, "z normal");
+      return [x2, y, z];
+    }
+    createVertexFields(properties) {
+      const fields = [];
+      let byteOffset = 0;
+      for (let index = 0; index < properties.length; index += 1) {
+        const property = properties[index];
+        if (property?.kind !== "scalar") {
+          throw new ModelExportError(
+            ModelExportErrorCode.UnsupportedModel,
+            "PLY vertex properties must be scalar values."
+          );
+        }
+        fields.push({
+          asciiIndex: index,
+          byteOffset,
+          name: property.name.toLowerCase(),
+          type: property.type
+        });
+        byteOffset += this.getScalarDefinition(property.type).byteLength;
+      }
+      return fields;
+    }
+    decodeHeader(headerBytes) {
+      try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(headerBytes);
+      } catch {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY header is not valid UTF-8 text."
+        );
+      }
+    }
+    findSingleField(fields, aliases, label) {
+      let matching;
+      for (const field of fields) {
+        if (!aliases.includes(field.name)) {
+          continue;
+        }
+        if (matching !== void 0) {
+          throw new ModelExportError(
+            ModelExportErrorCode.UnsupportedModel,
+            `PLY contains ambiguous ${label} fields.`
+          );
+        }
+        matching = field;
+      }
+      return matching;
+    }
+    findVertexElementIndex(elements) {
+      let index = -1;
+      for (let elementIndex = 0; elementIndex < elements.length; elementIndex += 1) {
+        const element = elements[elementIndex];
+        if (element?.name.toLowerCase() === "vertex") {
+          if (index !== -1) {
+            throw new ModelExportError(
+              ModelExportErrorCode.UnsupportedModel,
+              "PLY contains more than one vertex element."
+            );
+          }
+          index = elementIndex;
+        }
+      }
+      if (index === -1) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "PLY is missing a vertex element."
+        );
+      }
+      return index;
+    }
+    getRecordByteLength(properties) {
+      let byteLength = 0;
+      for (const property of properties) {
+        if (property.kind !== "scalar") {
+          throw new ModelExportError(
+            ModelExportErrorCode.UnsupportedModel,
+            "PLY vertex records with list properties cannot be exported safely."
+          );
+        }
+        byteLength += this.getScalarDefinition(property.type).byteLength;
+      }
+      return byteLength;
+    }
+    isListProperty(property) {
+      return property.kind === "list";
+    }
+    parseElement(directive) {
+      const parts = directive.split(/\s+/u);
+      const name = this.requirePart(parts, 1, "element name");
+      const count = this.parseCount(this.requirePart(parts, 2, "element count"));
+      if (parts.length !== 3) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "A PLY element must contain exactly three header fields."
+        );
+      }
+      return {
+        count,
+        name,
+        properties: []
+      };
+    }
+    parseCount(value) {
+      if (!/^\d+$/u.test(value)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "A PLY element count must be a non-negative integer."
+        );
+      }
+      const count = Number(value);
+      if (!Number.isSafeInteger(count)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          "A PLY element count is too large to process safely."
+        );
+      }
+      return count;
+    }
+    parseFormat(directive) {
+      const parts = directive.split(/\s+/u);
+      const format = this.requirePart(parts, 1, "format");
+      const version = this.requirePart(parts, 2, "format version");
+      if (parts.length !== 3 || version !== "1.0") {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          "Only PLY format version 1.0 is supported for export."
+        );
+      }
+      if (format === "ascii" || format === "binary_little_endian" || format === "binary_big_endian") {
+        return format;
+      }
+      throw new ModelExportError(
+        ModelExportErrorCode.UnsupportedModel,
+        "The PLY encoding is not supported for export."
+      );
+    }
+    parseScalarType(value) {
+      const normalized = value?.toLowerCase();
+      if (this.isScalarType(normalized)) {
+        return normalized;
+      }
+      throw new ModelExportError(
+        ModelExportErrorCode.UnsupportedModel,
+        "The PLY header uses an unsupported scalar type."
+      );
+    }
+    isScalarType(value) {
+      switch (value) {
+        case "char":
+        case "int8":
+        case "uchar":
+        case "uint8":
+        case "short":
+        case "int16":
+        case "ushort":
+        case "uint16":
+        case "int":
+        case "int32":
+        case "uint":
+        case "uint32":
+        case "float":
+        case "float32":
+        case "double":
+        case "float64":
+          return true;
+        default:
+          return false;
+      }
+    }
+    requireFloatingPointField(fields, aliases, label) {
+      const field = this.findSingleField(fields, aliases, label);
+      if (field === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          `PLY is missing a writable ${label} field.`
+        );
+      }
+      this.assertFloatingPointField(field, label);
+      return field;
+    }
+    requirePart(parts, index, label) {
+      const value = parts[index];
+      if (value === void 0 || value.length === 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `The PLY header is missing its ${label}.`
+        );
+      }
+      return value;
+    }
+    assertFloatingPointField(field, label) {
+      if (!this.getScalarDefinition(field.type).floatingPoint) {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          `PLY ${label} must be a floating-point scalar.`
+        );
+      }
+    }
+  }
+  class PlyModelBaker {
+    static MAX_BINARY_RECORD_BYTES = 33554432;
+    static MAX_HEADER_BYTES = 65536;
+    static MAX_LINE_BYTES = 1048576;
+    completed = false;
+    elementIndex = 0;
+    encoder = new TextEncoder();
+    headerParser = new PlyHeaderParser();
+    pending = new Uint8Array(0);
+    remainingElementRecords = 0;
+    schema;
+    transformer;
+    constructor(matrix) {
+      this.transformer = new MatrixTransformer(matrix);
+    }
+    push(chunk, final) {
+      const writer = new ByteChunkWriter(chunk.byteLength + this.pending.byteLength);
+      if (this.schema === void 0) {
+        this.pushHeaderAndInitialBody(writer, chunk, final);
+      } else {
+        writer.append(this.pushBody(chunk, final));
+      }
+      if (final) {
+        this.assertCompleteSource();
+      }
+      return writer.toBytes();
+    }
+    appendAsciiRecord(writer, line) {
+      const element = this.getCurrentElement();
+      if (element === void 0) {
+        writer.append(line);
+        return;
+      }
+      if (this.elementIndex === this.getSchema().vertexElementIndex) {
+        writer.append(this.transformAsciiVertex(line));
+      } else {
+        writer.append(line);
+      }
+      this.consumeRecord();
+    }
+    appendBinaryRecords(source, final) {
+      const data = this.combinePending(source);
+      const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      let cursor = 0;
+      while (cursor < data.byteLength && !this.completed) {
+        const element = this.getCurrentElement();
+        if (element === void 0) {
+          break;
+        }
+        const recordByteLength = this.getBinaryRecordByteLength(
+          view,
+          data.byteLength,
+          cursor,
+          element
+        );
+        if (recordByteLength === void 0) {
+          break;
+        }
+        if (this.elementIndex === this.getSchema().vertexElementIndex) {
+          this.transformBinaryVertex(view, cursor, this.getSchema().vertexLayout);
+        }
+        cursor += recordByteLength;
+        this.consumeRecord();
+      }
+      if (this.completed) {
+        this.pending = new Uint8Array(0);
+        return data;
+      }
+      const trailing = data.subarray(cursor);
+      if (final && trailing.byteLength > 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY binary data ends during a record."
+        );
+      }
+      this.assertPendingByteLength(trailing.byteLength);
+      this.pending = trailing.slice();
+      return data.subarray(0, cursor);
+    }
+    appendProcessedAsciiLines(source, final) {
+      const data = this.combinePending(source);
+      const writer = new ByteChunkWriter(data.byteLength);
+      let lineStart = 0;
+      let cursor = 0;
+      while (cursor < data.byteLength) {
+        const lineEnd = this.findLineEnd(data, cursor, final);
+        if (lineEnd === void 0) {
+          break;
+        }
+        this.appendAsciiRecord(writer, data.subarray(lineStart, lineEnd));
+        lineStart = lineEnd;
+        cursor = lineEnd;
+      }
+      const trailing = data.subarray(lineStart);
+      if (final && trailing.byteLength > 0) {
+        this.appendAsciiRecord(writer, trailing);
+        this.pending = new Uint8Array(0);
+      } else {
+        this.assertPendingByteLength(trailing.byteLength);
+        this.pending = trailing.slice();
+      }
+      return writer.toBytes();
+    }
+    assertCompleteSource() {
+      if (this.schema === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY source ended before its header was complete."
+        );
+      }
+      if (!this.completed) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY source ended before all declared records were available."
+        );
+      }
+    }
+    assertPendingByteLength(length) {
+      const maximum = this.getSchemaOrUndefined()?.format === "ascii" ? PlyModelBaker.MAX_LINE_BYTES : PlyModelBaker.MAX_BINARY_RECORD_BYTES;
+      if (length > maximum) {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          "The PLY contains a record too large to process safely."
+        );
+      }
+    }
+    combinePending(chunk) {
+      if (this.pending.byteLength === 0) {
+        return chunk;
+      }
+      const combined = new Uint8Array(this.pending.byteLength + chunk.byteLength);
+      combined.set(this.pending);
+      combined.set(chunk, this.pending.byteLength);
+      this.pending = new Uint8Array(0);
+      return combined;
+    }
+    consumeRecord() {
+      this.remainingElementRecords -= 1;
+      if (this.remainingElementRecords < 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY record stream exceeds its declared element count."
+        );
+      }
+      if (this.remainingElementRecords === 0) {
+        this.elementIndex += 1;
+        this.advanceElement();
+      }
+    }
+    createAsciiFields(text) {
+      const fields = [];
+      let cursor = 0;
+      while (cursor < text.length) {
+        cursor = this.skipWhitespace(text, cursor);
+        if (cursor >= text.length) {
+          break;
+        }
+        const start = cursor;
+        while (cursor < text.length && !this.isWhitespace(text[cursor])) {
+          cursor += 1;
+        }
+        fields.push({
+          end: cursor,
+          start,
+          value: text.slice(start, cursor)
+        });
+      }
+      return fields;
+    }
+    createReplacement(fields, vertexField, value) {
+      const field = fields[vertexField.asciiIndex];
+      if (field === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY vertex record is missing a declared property value."
+        );
+      }
+      return {
+        field,
+        value
+      };
+    }
+    decodeAsciiLine(line) {
+      try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(line);
+      } catch {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY ASCII vertex data is not valid UTF-8 text."
+        );
+      }
+    }
+    findHeaderEnd(source, final) {
+      let lineStart = 0;
+      let cursor = 0;
+      while (cursor < source.byteLength) {
+        const lineEnd = this.findLineEnd(source, cursor, final);
+        if (lineEnd === void 0) {
+          return void 0;
+        }
+        if (this.isEndHeaderLine(source.subarray(lineStart, lineEnd))) {
+          return lineEnd;
+        }
+        lineStart = lineEnd;
+        cursor = lineEnd;
+      }
+      return void 0;
+    }
+    findLineEnd(source, start, final) {
+      for (let cursor = start; cursor < source.byteLength; cursor += 1) {
+        const byte = source[cursor];
+        if (byte === 10) {
+          return cursor + 1;
+        }
+        if (byte !== 13) {
+          continue;
+        }
+        const next = source[cursor + 1];
+        if (next === void 0 && !final) {
+          return void 0;
+        }
+        return next === 10 ? cursor + 2 : cursor + 1;
+      }
+      return void 0;
+    }
+    getBinaryRecordByteLength(view, availableByteLength, start, element) {
+      let cursor = start;
+      for (const property of element.properties) {
+        if (property.kind === "scalar") {
+          const byteLength = this.headerParser.getScalarDefinition(property.type).byteLength;
+          if (cursor + byteLength > availableByteLength) {
+            return void 0;
+          }
+          cursor += byteLength;
+          continue;
+        }
+        const countDefinition = this.headerParser.getScalarDefinition(property.countType);
+        if (cursor + countDefinition.byteLength > availableByteLength) {
+          return void 0;
+        }
+        const count = this.readScalar(view, cursor, property.countType);
+        if (!Number.isSafeInteger(count) || count < 0) {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidModel,
+            "A PLY list count must be a non-negative safe integer."
+          );
+        }
+        cursor += countDefinition.byteLength;
+        const itemByteLength = this.headerParser.getScalarDefinition(
+          property.itemType
+        ).byteLength;
+        const listByteLength = count * itemByteLength;
+        if (!Number.isSafeInteger(listByteLength) || listByteLength > PlyModelBaker.MAX_BINARY_RECORD_BYTES) {
+          throw new ModelExportError(
+            ModelExportErrorCode.UnsupportedModel,
+            "A PLY list record is too large to process safely."
+          );
+        }
+        if (cursor + listByteLength > availableByteLength) {
+          return void 0;
+        }
+        cursor += listByteLength;
+      }
+      const recordByteLength = cursor - start;
+      if (recordByteLength > PlyModelBaker.MAX_BINARY_RECORD_BYTES) {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          "A PLY binary record is too large to process safely."
+        );
+      }
+      return recordByteLength;
+    }
+    getCurrentElement() {
+      const schema = this.getSchema();
+      if (this.completed) {
+        return void 0;
+      }
+      const element = schema.elements[this.elementIndex];
+      if (element === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY element stream does not match its header."
+        );
+      }
+      return element;
+    }
+    getSchema() {
+      const schema = this.schema;
+      if (schema === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY header has not been parsed yet."
+        );
+      }
+      return schema;
+    }
+    getSchemaOrUndefined() {
+      return this.schema;
+    }
+    initializeElements() {
+      this.elementIndex = 0;
+      this.remainingElementRecords = 0;
+      this.completed = false;
+      this.advanceElement();
+    }
+    isEndHeaderLine(line) {
+      try {
+        const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(line);
+        return text.trim() === "end_header";
+      } catch {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY header is not valid UTF-8 text."
+        );
+      }
+    }
+    isNumericLiteral(value) {
+      return /^[+-]?(?:(?:\d+(?:\.\d*)?)|(?:\.\d+))(?:[eE][+-]?\d+)?$/u.test(value);
+    }
+    isWhitespace(character) {
+      return character === " " || character === "	" || character === "\r" || character === "\n";
+    }
+    parseAsciiFloat(field, label) {
+      if (!this.isNumericLiteral(field.value)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `PLY ${label} is not a valid finite number.`
+        );
+      }
+      const value = Number(field.value);
+      if (!Number.isFinite(value)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `PLY ${label} is not finite.`
+        );
+      }
+      return value;
+    }
+    pushBody(chunk, final) {
+      return this.getSchema().format === "ascii" ? this.appendProcessedAsciiLines(chunk, final) : this.appendBinaryRecords(chunk, final);
+    }
+    pushHeaderAndInitialBody(writer, chunk, final) {
+      const source = this.combinePending(chunk);
+      const headerEnd = this.findHeaderEnd(source, final);
+      if (headerEnd === void 0) {
+        if (source.byteLength > PlyModelBaker.MAX_HEADER_BYTES) {
+          throw new ModelExportError(
+            ModelExportErrorCode.UnsupportedModel,
+            "The PLY header is too large to process safely."
+          );
+        }
+        this.pending = source.slice();
+        return;
+      }
+      const header = source.subarray(0, headerEnd);
+      this.schema = this.headerParser.parse(header);
+      this.initializeElements();
+      writer.append(header);
+      writer.append(this.pushBody(source.subarray(headerEnd), final));
+    }
+    readScalar(view, offset, type) {
+      const littleEndian = this.getSchema().format === "binary_little_endian";
+      switch (type) {
+        case "char":
+        case "int8":
+          return view.getInt8(offset);
+        case "uchar":
+        case "uint8":
+          return view.getUint8(offset);
+        case "short":
+        case "int16":
+          return view.getInt16(offset, littleEndian);
+        case "ushort":
+        case "uint16":
+          return view.getUint16(offset, littleEndian);
+        case "int":
+        case "int32":
+          return view.getInt32(offset, littleEndian);
+        case "uint":
+        case "uint32":
+          return view.getUint32(offset, littleEndian);
+        case "float":
+        case "float32":
+          return view.getFloat32(offset, littleEndian);
+        case "double":
+        case "float64":
+          return view.getFloat64(offset, littleEndian);
+      }
+    }
+    replaceAsciiValues(text, replacements) {
+      const sortedReplacements = [...replacements].sort(this.compareReplacements.bind(this));
+      let cursor = 0;
+      let output = "";
+      for (const replacement of sortedReplacements) {
+        output += text.slice(cursor, replacement.field.start);
+        output += this.formatNumber(replacement.value);
+        cursor = replacement.field.end;
+      }
+      output += text.slice(cursor);
+      return this.encoder.encode(output);
+    }
+    compareReplacements(left, right) {
+      return left.field.start - right.field.start;
+    }
+    formatNumber(value) {
+      return Object.is(value, -0) ? "0" : value.toString();
+    }
+    skipWhitespace(text, cursor) {
+      let next = cursor;
+      while (next < text.length && this.isWhitespace(text[next])) {
+        next += 1;
+      }
+      return next;
+    }
+    transformAsciiVertex(line) {
+      const text = this.decodeAsciiLine(line);
+      const fields = this.createAsciiFields(text);
+      const layout = this.getSchema().vertexLayout;
+      if (fields.length !== this.getCurrentElementPropertyCount()) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "A PLY ASCII vertex record does not match its declared properties."
+        );
+      }
+      const replacements = this.createVertexReplacements(fields, layout);
+      return this.replaceAsciiValues(text, replacements);
+    }
+    createVertexReplacements(fields, layout) {
+      const position = layout.position;
+      const transformedPosition = this.transformer.transformPosition(
+        this.parseAsciiFloat(
+          this.requireAsciiField(fields, position[0], "x position"),
+          "x position"
+        ),
+        this.parseAsciiFloat(
+          this.requireAsciiField(fields, position[1], "y position"),
+          "y position"
+        ),
+        this.parseAsciiFloat(
+          this.requireAsciiField(fields, position[2], "z position"),
+          "z position"
+        )
+      );
+      const replacements = [
+        this.createReplacement(fields, position[0], transformedPosition[0]),
+        this.createReplacement(fields, position[1], transformedPosition[1]),
+        this.createReplacement(fields, position[2], transformedPosition[2])
+      ];
+      const normal = layout.normal;
+      if (normal !== void 0) {
+        const transformedNormal = this.transformer.transformNormal(
+          this.parseAsciiFloat(
+            this.requireAsciiField(fields, normal[0], "x normal"),
+            "x normal"
+          ),
+          this.parseAsciiFloat(
+            this.requireAsciiField(fields, normal[1], "y normal"),
+            "y normal"
+          ),
+          this.parseAsciiFloat(
+            this.requireAsciiField(fields, normal[2], "z normal"),
+            "z normal"
+          )
+        );
+        replacements.push(
+          this.createReplacement(fields, normal[0], transformedNormal[0]),
+          this.createReplacement(fields, normal[1], transformedNormal[1]),
+          this.createReplacement(fields, normal[2], transformedNormal[2])
+        );
+      }
+      return replacements;
+    }
+    getCurrentElementPropertyCount() {
+      const element = this.getCurrentElement();
+      if (element === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          "The PLY vertex element is unavailable."
+        );
+      }
+      return element.properties.length;
+    }
+    requireAsciiField(fields, vertexField, label) {
+      if (vertexField === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `The PLY vertex is missing its ${label} field.`
+        );
+      }
+      const field = fields[vertexField.asciiIndex];
+      if (field === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `The PLY vertex is missing its ${label} value.`
+        );
+      }
+      return field;
+    }
+    transformBinaryVertex(view, recordOffset, layout) {
+      const position = layout.position;
+      const transformedPosition = this.transformer.transformPosition(
+        this.readRequiredFloat(view, recordOffset, position[0], "x position"),
+        this.readRequiredFloat(view, recordOffset, position[1], "y position"),
+        this.readRequiredFloat(view, recordOffset, position[2], "z position")
+      );
+      this.writeRequiredFloat(
+        view,
+        recordOffset,
+        position[0],
+        transformedPosition[0],
+        "x position"
+      );
+      this.writeRequiredFloat(
+        view,
+        recordOffset,
+        position[1],
+        transformedPosition[1],
+        "y position"
+      );
+      this.writeRequiredFloat(
+        view,
+        recordOffset,
+        position[2],
+        transformedPosition[2],
+        "z position"
+      );
+      const normal = layout.normal;
+      if (normal !== void 0) {
+        const transformedNormal = this.transformer.transformNormal(
+          this.readRequiredFloat(view, recordOffset, normal[0], "x normal"),
+          this.readRequiredFloat(view, recordOffset, normal[1], "y normal"),
+          this.readRequiredFloat(view, recordOffset, normal[2], "z normal")
+        );
+        this.writeRequiredFloat(
+          view,
+          recordOffset,
+          normal[0],
+          transformedNormal[0],
+          "x normal"
+        );
+        this.writeRequiredFloat(
+          view,
+          recordOffset,
+          normal[1],
+          transformedNormal[1],
+          "y normal"
+        );
+        this.writeRequiredFloat(
+          view,
+          recordOffset,
+          normal[2],
+          transformedNormal[2],
+          "z normal"
+        );
+      }
+    }
+    readRequiredFloat(view, recordOffset, field, label) {
+      if (field === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `The PLY vertex is missing its ${label} field.`
+        );
+      }
+      const value = this.readScalar(view, recordOffset + field.byteOffset, field.type);
+      if (!Number.isFinite(value)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `PLY ${label} is not finite.`
+        );
+      }
+      return value;
+    }
+    writeRequiredFloat(view, recordOffset, field, value, label) {
+      if (field === void 0 || !Number.isFinite(value)) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `PLY ${label} cannot be written as a finite value.`
+        );
+      }
+      const littleEndian = this.getSchema().format === "binary_little_endian";
+      const offset = recordOffset + field.byteOffset;
+      if (field.type === "float" || field.type === "float32") {
+        view.setFloat32(offset, value, littleEndian);
+      } else if (field.type === "double" || field.type === "float64") {
+        view.setFloat64(offset, value, littleEndian);
+      } else {
+        throw new ModelExportError(
+          ModelExportErrorCode.UnsupportedModel,
+          `PLY ${label} must be a floating-point scalar.`
+        );
+      }
+      if (!Number.isFinite(this.readScalar(view, offset, field.type))) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidModel,
+          `PLY ${label} overflows its scalar type after transformation.`
+        );
+      }
+    }
+    advanceElement() {
+      const elements = this.getSchema().elements;
+      while (this.elementIndex < elements.length) {
+        const element = elements[this.elementIndex];
+        if (element === void 0) {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidModel,
+            "The PLY header has an empty element declaration."
+          );
+        }
+        this.remainingElementRecords = element.count;
+        if (this.remainingElementRecords > 0) {
+          return;
+        }
+        this.elementIndex += 1;
+      }
+      this.completed = true;
+    }
+  }
+  class ModelExportWorkerRuntime {
+    activeTask;
+    jobValidator = new ExportJobValidator();
+    latestStartedTaskId = 0;
+    messageParser = new ExportWorkerMessageParser();
+    port;
+    generatedMtlWriter = new GeneratedMtlWriter();
+    generatedObjModelBaker = new GeneratedObjModelBaker();
+    constructor(port) {
+      this.port = port;
+    }
+    attach() {
+      this.port.addEventListener("message", this.handleMessage.bind(this));
+    }
+    acknowledgeChunk(task, chunkId) {
+      const acknowledgement = task.awaitingAcknowledgement;
+      if (acknowledgement?.chunkId === chunkId) {
+        acknowledgement.acknowledge();
+      }
+    }
+    cancelTask(task) {
+      task.cancel();
+    }
+    copyZipChunk(data) {
+      const copy = new Uint8Array(data.byteLength);
+      copy.set(data);
+      return copy.buffer;
+    }
+    createBaker(format, matrix) {
+      return format === "obj" ? new ObjModelBaker(matrix) : new PlyModelBaker(matrix);
+    }
+    createZip(task) {
+      return new Zip(this.handleZipData.bind(this, task));
+    }
+    async drainZipChunks(task) {
+      while (task.queuedZipChunks.length > 0) {
+        this.throwIfCancelled(task);
+        const chunk = task.queuedZipChunks.shift();
+        if (chunk === void 0) {
+          throw new ModelExportError(
+            ModelExportErrorCode.Protocol,
+            "The export ZIP output queue was unexpectedly empty."
+          );
+        }
+        const acknowledgement = new ExportChunkAcknowledgement(
+          task.request.taskId,
+          task.nextChunkId
+        );
+        task.nextChunkId += 1;
+        task.awaitingAcknowledgement = acknowledgement;
+        this.port.postMessage(
+          {
+            chunk,
+            chunkId: acknowledgement.chunkId,
+            taskId: task.request.taskId,
+            type: "zip-chunk"
+          },
+          [chunk]
+        );
+        await acknowledgement.promise;
+        if (task.awaitingAcknowledgement === acknowledgement) {
+          task.awaitingAcknowledgement = void 0;
+        }
+      }
+    }
+    async exportFile(task, format, roleDirectory, file) {
+      this.throwIfCancelled(task);
+      let response;
+      try {
+        response = await fetch(file.url, { signal: task.abortController.signal });
+      } catch {
+        this.throwIfCancelled(task);
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidSource,
+          `The export source ${file.fileName} could not be fetched.`
+        );
+      }
+      if (!response.ok || response.body === null) {
+        throw new ModelExportError(
+          ModelExportErrorCode.InvalidSource,
+          `The export source ${file.fileName} could not be read as a stream.`
+        );
+      }
+      const entry = this.createZipEntry(`${roleDirectory}/${file.fileName}`, file.isModel);
+      const baker = file.isModel ? this.createBaker(format, this.getRoleMatrix(task, roleDirectory)) : void 0;
+      task.zip?.add(entry);
+      await this.drainZipChunks(task);
+      await this.streamResponseIntoEntry(task, response.body, entry, baker);
+    }
+    async exportGeneratedRole(task, role, completedFileCount) {
+      const sourceMaterialTexts = await this.fetchSourceMaterialTexts(task, role);
+      const objChunks = this.generatedObjModelBaker.createChunks(
+        role.generated,
+        role.matrix,
+        role.materialFileName
+      );
+      const mtlChunks = this.generatedMtlWriter.createChunks(role.generated, sourceMaterialTexts);
+      let completed = completedFileCount;
+      await this.writeGeneratedEntry(task, role.role, role.modelFileName, objChunks);
+      completed += 1;
+      this.postProgress(task, completed);
+      await this.writeGeneratedEntry(task, role.role, role.materialFileName, mtlChunks);
+      completed += 1;
+      this.postProgress(task, completed);
+      for (const file of role.files) {
+        if (file.isModel || this.isMtlFile(file.fileName)) {
+          continue;
+        }
+        await this.exportFile(task, role.sourceFormat, role.role, file);
+        completed += 1;
+        this.postProgress(task, completed);
+      }
+      return completed - completedFileCount;
+    }
+    async fetchSourceMaterialTexts(task, role) {
+      const texts = [];
+      for (const file of role.files) {
+        if (file.isModel || !this.isMtlFile(file.fileName)) {
+          continue;
+        }
+        this.throwIfCancelled(task);
+        let response;
+        try {
+          response = await fetch(file.url, { signal: task.abortController.signal });
+        } catch {
+          this.throwIfCancelled(task);
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidSource,
+            `The source material ${file.fileName} could not be fetched.`
+          );
+        }
+        if (!response.ok) {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidSource,
+            `The source material ${file.fileName} could not be read.`
+          );
+        }
+        try {
+          texts.push(await response.text());
+        } catch {
+          throw new ModelExportError(
+            ModelExportErrorCode.InvalidSource,
+            `The source material ${file.fileName} could not be decoded.`
+          );
+        }
+      }
+      return texts;
+    }
+    async writeGeneratedEntry(task, roleDirectory, fileName, chunks) {
+      const entry = new ZipDeflate(`${roleDirectory}/${fileName}`);
+      task.zip?.add(entry);
+      await this.drainZipChunks(task);
+      for (const chunk of chunks) {
+        this.throwIfCancelled(task);
+        entry.push(chunk, false);
+        await this.drainZipChunks(task);
+      }
+      entry.push(new Uint8Array(0), true);
+      await this.drainZipChunks(task);
+    }
+    createZipEntry(fileName, isModel) {
+      return isModel ? new ZipDeflate(fileName) : new ZipPassThrough(fileName);
+    }
+    finishCurrentTask(task) {
+      if (this.activeTask === task) {
+        this.activeTask = void 0;
+      }
+    }
+    getErrorMessage(error) {
+      return error instanceof ModelExportError ? error.message : "The model export failed. Please retry.";
+    }
+    getFileCount(request) {
+      let count = 0;
+      for (const role of request.roles) {
+        count += role.kind === "generated-obj" ? 2 + role.files.filter((file) => !file.isModel && !this.isMtlFile(file.fileName)).length : role.files.length;
+      }
+      return count;
+    }
+    getPotentialTaskId(job) {
+      return Number.isSafeInteger(job.taskId) && job.taskId > 0 ? job.taskId : void 0;
+    }
+    getRoleMatrix(task, roleDirectory) {
+      const role = task.request.roles.find(this.matchesRoleDirectory.bind(this, roleDirectory));
+      if (role === void 0) {
+        throw new ModelExportError(
+          ModelExportErrorCode.Protocol,
+          "The export model role is missing its world matrix."
+        );
+      }
+      return role.matrix;
+    }
+    handleCancellation(taskId) {
+      const task = this.activeTask;
+      if (task?.request.taskId === taskId) {
+        this.cancelTask(task);
+      }
+    }
+    handleChunkAcknowledgement(taskId, chunkId) {
+      const task = this.activeTask;
+      if (task?.request.taskId === taskId) {
+        this.acknowledgeChunk(task, chunkId);
+      }
+    }
+    handleMessage(event) {
+      const message = this.messageParser.parseInbound(event.data);
+      if (message === void 0) {
+        return;
+      }
+      this.handleInboundMessage(message);
+    }
+    handleInboundMessage(message) {
+      switch (message.type) {
+        case "acknowledge-chunk":
+          this.handleChunkAcknowledgement(message.taskId, message.chunkId);
+          return;
+        case "cancel":
+          this.handleCancellation(message.taskId);
+          return;
+        case "start":
+          this.handleStart(message);
+      }
+    }
+    handleStart(message) {
+      try {
+        this.jobValidator.validate(message.job);
+      } catch (error) {
+        const taskId = this.getPotentialTaskId(message.job);
+        if (taskId !== void 0) {
+          this.port.postMessage({
+            message: this.getErrorMessage(error),
+            taskId,
+            type: "error"
+          });
+        }
+        return;
+      }
+      if (message.job.taskId <= this.latestStartedTaskId) {
+        this.port.postMessage({
+          message: "Each model export must use a newer task id.",
+          taskId: message.job.taskId,
+          type: "error"
+        });
+        return;
+      }
+      this.activeTask?.cancel();
+      const task = new ExportWorkerTask(message.job);
+      task.zip = this.createZip(task);
+      this.activeTask = task;
+      this.latestStartedTaskId = task.request.taskId;
+      void this.runTask(task);
+    }
+    handleZipData(task, error, data, _final) {
+      if (!this.isCurrentTask(task) || task.cancelled) {
+        return;
+      }
+      if (error !== null) {
+        throw new ModelExportError(ModelExportErrorCode.InvalidModel, error.message);
+      }
+      if (data.byteLength > 0) {
+        task.queuedZipChunks.push(this.copyZipChunk(data));
+      }
+    }
+    isCurrentTask(task) {
+      return this.activeTask === task;
+    }
+    matchesRoleDirectory(roleDirectory, role) {
+      return role.role === roleDirectory;
+    }
+    isMtlFile(fileName) {
+      return fileName.toLowerCase().endsWith(".mtl");
+    }
+    postCancelled(task) {
+      this.port.postMessage({
+        taskId: task.request.taskId,
+        type: "cancelled"
+      });
+    }
+    postComplete(task) {
+      this.port.postMessage({
+        taskId: task.request.taskId,
+        type: "complete"
+      });
+    }
+    postError(task, error) {
+      this.port.postMessage({
+        message: this.getErrorMessage(error),
+        taskId: task.request.taskId,
+        type: "error"
+      });
+    }
+    postProgress(task, completedFileCount) {
+      this.port.postMessage({
+        completedFileCount,
+        taskId: task.request.taskId,
+        totalFileCount: this.getFileCount(task.request),
+        type: "progress"
+      });
+    }
+    async runTask(task) {
+      let completedFileCount = 0;
+      try {
+        for (const role of task.request.roles) {
+          if (role.kind === "generated-obj") {
+            completedFileCount += await this.exportGeneratedRole(
+              task,
+              role,
+              completedFileCount
+            );
+          } else {
+            for (const file of role.files) {
+              await this.exportFile(task, role.format, role.role, file);
+              completedFileCount += 1;
+              this.postProgress(task, completedFileCount);
+            }
+          }
+        }
+        this.throwIfCancelled(task);
+        task.zip?.end();
+        await this.drainZipChunks(task);
+        this.throwIfCancelled(task);
+        if (this.isCurrentTask(task)) {
+          this.postComplete(task);
+        }
+      } catch (error) {
+        if (this.isCurrentTask(task)) {
+          if (task.cancelled || this.isCancelledError(error)) {
+            this.postCancelled(task);
+          } else {
+            task.zip?.terminate();
+            this.postError(task, error);
+          }
+        }
+      } finally {
+        this.finishCurrentTask(task);
+      }
+    }
+    async streamResponseIntoEntry(task, body, entry, baker) {
+      const reader = body.getReader();
+      try {
+        for (; ; ) {
+          this.throwIfCancelled(task);
+          const result = await reader.read();
+          if (result.done) {
+            break;
+          }
+          const source = result.value;
+          this.pushEntryChunk(
+            entry,
+            baker === void 0 ? source : baker.push(source, false),
+            false
+          );
+          await this.drainZipChunks(task);
+        }
+        const finalChunk = baker?.push(new Uint8Array(0), true);
+        if (finalChunk !== void 0) {
+          this.pushEntryChunk(entry, finalChunk, false);
+        }
+        this.pushEntryChunk(entry, new Uint8Array(0), true);
+        await this.drainZipChunks(task);
+      } finally {
+        reader.releaseLock();
+      }
+    }
+    pushEntryChunk(entry, chunk, final) {
+      if (chunk.byteLength > 0 || final) {
+        entry.push(chunk, final);
+      }
+    }
+    throwIfCancelled(task) {
+      if (task.cancelled || task.abortController.signal.aborted) {
+        throw new ModelExportError(
+          ModelExportErrorCode.Cancelled,
+          "The model export was cancelled."
+        );
+      }
+    }
+    isCancelledError(error) {
+      return error instanceof ModelExportError && error.code === ModelExportErrorCode.Cancelled;
+    }
+  }
+  const runtime = new ModelExportWorkerRuntime(new BrowserExportWorkerPort());
+  runtime.attach();
+})();