@lingbi/studio 0.4.0 → 0.5.0

package/assets/ArchiveImportWorkerEntry-Dh4RZo22.js

@@ -0,0 +1,1548 @@
+(function() {
+  "use strict";
+  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), fd = _b.b;
+  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 flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+  var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+  var max = function(a) {
+    var m = a[0];
+    for (var i2 = 1; i2 < a.length; ++i2) {
+      if (a[i2] > m)
+        m = a[i2];
+    }
+    return m;
+  };
+  var bits = function(d, p, m) {
+    var o = p / 8 | 0;
+    return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+  };
+  var bits16 = function(d, p) {
+    var o = p / 8 | 0;
+    return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+  };
+  var shft = function(p) {
+    return (p + 7) / 8 | 0;
+  };
+  var slc = function(v, s, e) {
+    if (s == null || s < 0)
+      s = 0;
+    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 inflt = function(dat, st, buf, dict) {
+    var sl = dat.length, dl = 0;
+    if (!sl || st.f && !st.l)
+      return buf || new u8(0);
+    var noBuf = !buf;
+    var resize = noBuf || st.i != 2;
+    var noSt = st.i;
+    if (noBuf)
+      buf = new u8(sl * 3);
+    var cbuf = function(l2) {
+      var bl = buf.length;
+      if (l2 > bl) {
+        var nbuf = new u8(Math.max(bl * 2, l2));
+        nbuf.set(buf);
+        buf = nbuf;
+      }
+    };
+    var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+    var tbts = sl * 8;
+    do {
+      if (!lm) {
+        final = bits(dat, pos, 1);
+        var type = bits(dat, pos + 1, 3);
+        pos += 3;
+        if (!type) {
+          var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+          if (t > sl) {
+            if (noSt)
+              err(0);
+            break;
+          }
+          if (resize)
+            cbuf(bt + l);
+          buf.set(dat.subarray(s, t), bt);
+          st.b = bt += l, st.p = pos = t * 8, st.f = final;
+          continue;
+        } else if (type == 1)
+          lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+        else if (type == 2) {
+          var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+          var tl = hLit + bits(dat, pos + 5, 31) + 1;
+          pos += 14;
+          var ldt = new u8(tl);
+          var clt = new u8(19);
+          for (var i2 = 0; i2 < hcLen; ++i2) {
+            clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+          }
+          pos += hcLen * 3;
+          var clb = max(clt), clbmsk = (1 << clb) - 1;
+          var clm = hMap(clt, clb, 1);
+          for (var i2 = 0; i2 < tl; ) {
+            var r = clm[bits(dat, pos, clbmsk)];
+            pos += r & 15;
+            var s = r >> 4;
+            if (s < 16) {
+              ldt[i2++] = s;
+            } else {
+              var c = 0, n = 0;
+              if (s == 16)
+                n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
+              else if (s == 17)
+                n = 3 + bits(dat, pos, 7), pos += 3;
+              else if (s == 18)
+                n = 11 + bits(dat, pos, 127), pos += 7;
+              while (n--)
+                ldt[i2++] = c;
+            }
+          }
+          var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+          lbt = max(lt);
+          dbt = max(dt);
+          lm = hMap(lt, lbt, 1);
+          dm = hMap(dt, dbt, 1);
+        } else
+          err(1);
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+      }
+      if (resize)
+        cbuf(bt + 131072);
+      var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+      var lpos = pos;
+      for (; ; lpos = pos) {
+        var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+        pos += c & 15;
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (!c)
+          err(2);
+        if (sym < 256)
+          buf[bt++] = sym;
+        else if (sym == 256) {
+          lpos = pos, lm = null;
+          break;
+        } else {
+          var add = sym - 254;
+          if (sym > 264) {
+            var i2 = sym - 257, b = fleb[i2];
+            add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+            pos += b;
+          }
+          var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+          if (!d)
+            err(3);
+          pos += d & 15;
+          var dt = fd[dsym];
+          if (dsym > 3) {
+            var b = fdeb[dsym];
+            dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+          }
+          if (pos > tbts) {
+            if (noSt)
+              err(0);
+            break;
+          }
+          if (resize)
+            cbuf(bt + 131072);
+          var end = bt + add;
+          if (bt < dt) {
+            var shift = dl - dt, dend = Math.min(dt, end);
+            if (shift + bt < 0)
+              err(3);
+            for (; bt < dend; ++bt)
+              buf[bt] = dict[shift + bt];
+          }
+          for (; bt < end; ++bt)
+            buf[bt] = buf[bt - dt];
+        }
+      }
+      st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+      if (lm)
+        final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+    } while (!final);
+    return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+  };
+  var et = /* @__PURE__ */ new u8(0);
+  var b2 = function(d, b) {
+    return d[b] | d[b + 1] << 8;
+  };
+  var b4 = function(d, b) {
+    return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+  };
+  var b8 = function(d, b) {
+    return b4(d, b) + b4(d, b + 4) * 4294967296;
+  };
+  var Inflate = /* @__PURE__ */ (function() {
+    function Inflate2(opts, cb) {
+      if (typeof opts == "function")
+        cb = opts, opts = {};
+      this.ondata = cb;
+      var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);
+      this.s = { i: 0, b: dict ? dict.length : 0 };
+      this.o = new u8(32768);
+      this.p = new u8(0);
+      if (dict)
+        this.o.set(dict);
+    }
+    Inflate2.prototype.e = function(c) {
+      if (!this.ondata)
+        err(5);
+      if (this.d)
+        err(4);
+      if (!this.p.length)
+        this.p = c;
+      else if (c.length) {
+        var n = new u8(this.p.length + c.length);
+        n.set(this.p), n.set(c, this.p.length), this.p = n;
+      }
+    };
+    Inflate2.prototype.c = function(final) {
+      this.s.i = +(this.d = final || false);
+      var bts = this.s.b;
+      var dt = inflt(this.p, this.s, this.o);
+      this.ondata(slc(dt, bts, this.s.b), this.d);
+      this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
+      this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
+    };
+    Inflate2.prototype.push = function(chunk, final) {
+      this.e(chunk), this.c(final);
+    };
+    return Inflate2;
+  })();
+  var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+  var tds = 0;
+  try {
+    td.decode(et, { stream: true });
+    tds = 1;
+  } catch (e) {
+  }
+  var dutf8 = function(d) {
+    for (var r = "", i2 = 0; ; ) {
+      var c = d[i2++];
+      var eb = (c > 127) + (c > 223) + (c > 239);
+      if (i2 + eb > d.length)
+        return { s: r, r: slc(d, i2 - 1) };
+      if (!eb)
+        r += String.fromCharCode(c);
+      else if (eb == 3) {
+        c = ((c & 15) << 18 | (d[i2++] & 63) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+      } else if (eb & 1)
+        r += String.fromCharCode((c & 31) << 6 | d[i2++] & 63);
+      else
+        r += String.fromCharCode((c & 15) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63);
+    }
+  };
+  function strFromU8(dat, latin1) {
+    if (latin1) {
+      var r = "";
+      for (var i2 = 0; i2 < dat.length; i2 += 16384)
+        r += String.fromCharCode.apply(null, dat.subarray(i2, i2 + 16384));
+      return r;
+    } else if (td) {
+      return td.decode(dat);
+    } else {
+      var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+      if (r.length)
+        err(8);
+      return s;
+    }
+  }
+  var z64hs = function(d, b, l, z, sc, su, off) {
+    var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
+    var nf = nsc + nsu + noff;
+    if (nf) {
+      for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
+        if (b2(d, b) == 1) {
+          return [
+            nsc ? b8(d, b + 4 + 8 * nsu) : sc,
+            nsu ? b8(d, b + 4) : su,
+            off,
+            1
+          ];
+        }
+      }
+    }
+    return [sc, su, off, 0];
+  };
+  var UnzipPassThrough = /* @__PURE__ */ (function() {
+    function UnzipPassThrough2() {
+    }
+    UnzipPassThrough2.prototype.push = function(chunk, final) {
+      this.ondata(null, chunk, final);
+    };
+    UnzipPassThrough2.compression = 0;
+    return UnzipPassThrough2;
+  })();
+  var UnzipInflate = /* @__PURE__ */ (function() {
+    function UnzipInflate2() {
+      var _this = this;
+      this.i = new Inflate(function(dat, final) {
+        _this.ondata(null, dat, final);
+      });
+    }
+    UnzipInflate2.prototype.push = function(chunk, final) {
+      try {
+        this.i.push(chunk, final);
+      } catch (e) {
+        this.ondata(e, null, final);
+      }
+    };
+    UnzipInflate2.compression = 8;
+    return UnzipInflate2;
+  })();
+  var Unzip = /* @__PURE__ */ (function() {
+    function Unzip2(cb) {
+      this.onfile = cb;
+      this.k = [];
+      this.o = {
+        0: UnzipPassThrough
+      };
+      this.p = et;
+    }
+    Unzip2.prototype.push = function(chunk, final) {
+      var _this = this;
+      if (!this.onfile)
+        err(5);
+      if (!this.p)
+        err(4);
+      if (this.c > 0) {
+        var len = Math.min(this.c, chunk.length);
+        var toAdd = chunk.subarray(0, len);
+        this.c -= len;
+        if (this.d)
+          this.d.push(toAdd, !this.c);
+        else
+          this.k[0].push(toAdd);
+        chunk = chunk.subarray(len);
+        if (chunk.length)
+          return this.push(chunk, final);
+      } else {
+        var f = 0, i2 = 0, is = void 0, buf = void 0;
+        if (!this.p.length)
+          buf = chunk;
+        else if (!chunk.length)
+          buf = this.p;
+        else {
+          buf = new u8(this.p.length + chunk.length);
+          buf.set(this.p), buf.set(chunk, this.p.length);
+        }
+        var l = buf.length, oc = this.c, add = oc && this.d;
+        var _loop_2 = function() {
+          var sig = b4(buf, i2);
+          if (sig == 67324752) {
+            f = 1, is = i2;
+            this_1.d = null;
+            this_1.c = 0;
+            var bf = b2(buf, i2 + 6), cmp_1 = b2(buf, i2 + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i2 + 26), es = b2(buf, i2 + 28);
+            if (l > i2 + 30 + fnl + es) {
+              var chks_3 = [];
+              this_1.k.unshift(chks_3);
+              f = 2;
+              var lsc = b4(buf, i2 + 18), lsu = b4(buf, i2 + 22);
+              var fn_1 = strFromU8(buf.subarray(i2 + 30, i2 += 30 + fnl), !u);
+              var _a2 = z64hs(buf, i2, es, 2, lsc, lsu, 0), sc_1 = _a2[0], su_1 = _a2[1], z64 = _a2[3];
+              if (dd)
+                sc_1 = -1 - z64;
+              i2 += es;
+              this_1.c = sc_1;
+              var d_1;
+              var file_1 = {
+                name: fn_1,
+                compression: cmp_1,
+                start: function() {
+                  if (!file_1.ondata)
+                    err(5);
+                  if (!sc_1)
+                    file_1.ondata(null, et, true);
+                  else {
+                    var ctr = _this.o[cmp_1];
+                    if (!ctr)
+                      file_1.ondata(err(14, "unknown compression type " + cmp_1, 1), null, false);
+                    d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1);
+                    d_1.ondata = function(err2, dat3, final2) {
+                      file_1.ondata(err2, dat3, final2);
+                    };
+                    for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) {
+                      var dat2 = chks_4[_i];
+                      d_1.push(dat2, false);
+                    }
+                    if (_this.k[0] == chks_3 && _this.c)
+                      _this.d = d_1;
+                    else
+                      d_1.push(et, true);
+                  }
+                },
+                terminate: function() {
+                  if (d_1 && d_1.terminate)
+                    d_1.terminate();
+                }
+              };
+              if (sc_1 >= 0)
+                file_1.size = sc_1, file_1.originalSize = su_1;
+              this_1.onfile(file_1);
+            }
+            return "break";
+          } else if (oc) {
+            if (sig == 134695760) {
+              is = i2 += 12 + (oc == -2 && 8), f = 3, this_1.c = 0;
+              return "break";
+            } else if (sig == 33639248) {
+              is = i2 -= 4, f = 3, this_1.c = 0;
+              return "break";
+            }
+          }
+        };
+        var this_1 = this;
+        for (; i2 < l - 4; ++i2) {
+          var state_1 = _loop_2();
+          if (state_1 === "break")
+            break;
+        }
+        this.p = et;
+        if (oc < 0) {
+          var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 134695760 && 4)) : buf.subarray(0, i2);
+          if (add)
+            add.push(dat, !!f);
+          else
+            this.k[+(f == 2)].push(dat);
+        }
+        if (f & 2)
+          return this.push(buf.subarray(i2), final);
+        this.p = buf.subarray(i2);
+      }
+      if (final) {
+        if (this.c)
+          err(13);
+        this.p = null;
+      }
+    };
+    Unzip2.prototype.register = function(decoder) {
+      this.o[decoder.compression] = decoder;
+    };
+    return Unzip2;
+  })();
+  var ArchiveImportErrorCode = /* @__PURE__ */ ((ArchiveImportErrorCode2) => {
+    ArchiveImportErrorCode2["Cancelled"] = "cancelled";
+    ArchiveImportErrorCode2["InvalidSource"] = "invalid-source";
+    ArchiveImportErrorCode2["Protocol"] = "protocol";
+    return ArchiveImportErrorCode2;
+  })(ArchiveImportErrorCode || {});
+  class ArchiveImportError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.code = code;
+      this.name = "ArchiveImportError";
+    }
+  }
+  class ArchiveImportPathValidator {
+    parse(path) {
+      if (path.length === 0 || path.includes("\\") || path.startsWith("/") || this.isDrivePath(path)) {
+        throw this.invalidPath(path);
+      }
+      if (this.hasControlCharacter(path)) {
+        throw this.invalidPath(path);
+      }
+      const parts = path.split("/");
+      const firstPart = parts[0];
+      const secondPart = parts[1];
+      if (parts.length === 2 && firstPart !== void 0 && secondPart === "") {
+        return this.parseDirectory(firstPart, path);
+      }
+      if (parts.length !== 2 || firstPart === void 0 || secondPart === void 0 || firstPart === "" || secondPart === "") {
+        throw this.invalidPath(path);
+      }
+      const role = this.parseRole(firstPart, path);
+      const fileName = secondPart;
+      if (fileName === "." || fileName === "..") {
+        throw this.invalidPath(path);
+      }
+      const format = this.getModelFormat(fileName);
+      return format === void 0 ? { fileName, isModel: false, kind: "file", role } : { fileName, format, isModel: true, kind: "file", role };
+    }
+    getModelFormat(fileName) {
+      const lowerName = fileName.toLowerCase();
+      if (lowerName.endsWith(".obj")) {
+        return "obj";
+      }
+      return lowerName.endsWith(".ply") ? "ply" : void 0;
+    }
+    hasControlCharacter(path) {
+      for (const character of path) {
+        const code = character.codePointAt(0);
+        if (code !== void 0 && (code < 32 || code === 127)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    invalidPath(path) {
+      return new ArchiveImportError(
+        ArchiveImportErrorCode.InvalidSource,
+        `The archive path "${path}" is not allowed.`
+      );
+    }
+    isDrivePath(path) {
+      return path.length >= 2 && path.charCodeAt(1) === 58;
+    }
+    parseDirectory(roleName, path) {
+      const role = this.parseRole(roleName, path);
+      return { kind: "directory", role };
+    }
+    parseRole(roleName, path) {
+      if (roleName === "stone" || roleName === "base") {
+        return roleName;
+      }
+      throw this.invalidPath(path);
+    }
+  }
+  class ArchiveImportCentralDirectoryValidator {
+    pathValidator = new ArchiveImportPathValidator();
+    async validate(file, entries, signal) {
+      try {
+        this.throwIfAborted(signal);
+        const endRecord = await this.readEndRecord(file, signal);
+        const centralDirectory = await this.readCentralDirectory(file, endRecord, signal);
+        this.throwIfAborted(signal);
+        this.validateRecords(centralDirectory, endRecord.totalEntries, entries);
+      } catch (error) {
+        if (error instanceof ArchiveImportError) {
+          throw error;
+        }
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          "The selected archive has an invalid central directory."
+        );
+      }
+    }
+    decodeName(bytes, flags) {
+      try {
+        return strFromU8(bytes, (flags & 2048) === 0);
+      } catch {
+        throw this.invalidArchive();
+      }
+    }
+    findEndRecord(tail) {
+      for (let index = tail.length - 22; index >= 0; index -= 1) {
+        if (this.readUint32(tail, index) !== 101010256) {
+          continue;
+        }
+        const commentLength = this.readUint16(tail, index + 20);
+        if (index + 22 + commentLength !== tail.length) {
+          continue;
+        }
+        const totalEntries = this.readUint16(tail, index + 10);
+        const entriesOnDisk = this.readUint16(tail, index + 8);
+        const centralDirectorySize = this.readUint32(tail, index + 12);
+        const centralDirectoryOffset = this.readUint32(tail, index + 16);
+        if (entriesOnDisk !== totalEntries || totalEntries === 65535 || centralDirectorySize === 4294967295 || centralDirectoryOffset === 4294967295) {
+          throw this.invalidArchive("ZIP64 archives are not supported.");
+        }
+        if (this.readUint16(tail, index + 4) !== 0 || this.readUint16(tail, index + 6) !== 0) {
+          throw this.invalidArchive("Multi-disk ZIP archives are not supported.");
+        }
+        return {
+          centralDirectoryOffset,
+          centralDirectorySize,
+          commentLength,
+          offsetInTail: index,
+          totalEntries
+        };
+      }
+      throw this.invalidArchive();
+    }
+    invalidArchive(message = "The selected archive is invalid or corrupted.") {
+      return new ArchiveImportError(ArchiveImportErrorCode.InvalidSource, message);
+    }
+    parseCentralRecord(data, offset) {
+      if (this.readUint32(data, offset) !== 33639248 || offset + 46 > data.length) {
+        throw this.invalidArchive();
+      }
+      const flags = this.readUint16(data, offset + 8);
+      const crc32 = this.readUint32(data, offset + 16);
+      const byteLength = this.readUint32(data, offset + 24);
+      const fileNameLength = this.readUint16(data, offset + 28);
+      const extraLength = this.readUint16(data, offset + 30);
+      const commentLength = this.readUint16(data, offset + 32);
+      const nextOffset = offset + 46 + fileNameLength + extraLength + commentLength;
+      if (nextOffset > data.length) {
+        throw this.invalidArchive();
+      }
+      const nameStart = offset + 46;
+      const path = this.decodeName(data.subarray(nameStart, nameStart + fileNameLength), flags);
+      return { byteLength, crc32, nextOffset, path };
+    }
+    async readCentralDirectory(file, endRecord, signal) {
+      this.throwIfAborted(signal);
+      const end = endRecord.centralDirectoryOffset + endRecord.centralDirectorySize;
+      if (!Number.isSafeInteger(end) || end > file.size) {
+        throw this.invalidArchive();
+      }
+      const tailStart = file.size - Math.min(file.size, 65557);
+      const tail = new Uint8Array(await file.slice(tailStart, file.size).arrayBuffer());
+      this.throwIfAborted(signal);
+      if (endRecord.centralDirectoryOffset >= tailStart && end <= file.size && end <= tailStart + tail.byteLength) {
+        const startInTail = endRecord.centralDirectoryOffset - tailStart;
+        return tail.slice(startInTail, startInTail + endRecord.centralDirectorySize);
+      }
+      const directory = new Uint8Array(
+        await file.slice(endRecord.centralDirectoryOffset, end).arrayBuffer()
+      );
+      this.throwIfAborted(signal);
+      return directory;
+    }
+    async readEndRecord(file, signal) {
+      this.throwIfAborted(signal);
+      const tailStart = Math.max(0, file.size - 65557);
+      const tail = new Uint8Array(await file.slice(tailStart, file.size).arrayBuffer());
+      this.throwIfAborted(signal);
+      const endRecord = this.findEndRecord(tail);
+      const endOffset = tailStart + endRecord.offsetInTail + 22 + endRecord.commentLength;
+      const centralDirectoryEnd = endRecord.centralDirectoryOffset + endRecord.centralDirectorySize;
+      if (endOffset !== file.size) {
+        throw this.invalidArchive("The archive contains trailing data.");
+      }
+      if (centralDirectoryEnd !== tailStart + endRecord.offsetInTail) {
+        throw this.invalidArchive("The central directory position is invalid.");
+      }
+      return endRecord;
+    }
+    validatePath(path) {
+      return this.pathValidator.parse(path);
+    }
+    validateRecords(data, totalEntries, entries) {
+      const seenPaths = /* @__PURE__ */ new Set();
+      const expectedEntries = /* @__PURE__ */ new Map();
+      let offset = 0;
+      let fileCount = 0;
+      for (const entry of entries) {
+        if (expectedEntries.has(entry.path)) {
+          throw this.invalidArchive("The archive contains a duplicate file.");
+        }
+        expectedEntries.set(entry.path, entry);
+      }
+      let lastRoleIndex = -1;
+      for (let index = 0; index < totalEntries; index += 1) {
+        const record = this.parseCentralRecord(data, offset);
+        const path = this.validatePath(record.path);
+        const roleIndex = path.role === "stone" ? 0 : 1;
+        if (roleIndex < lastRoleIndex) {
+          throw this.invalidArchive("The archive roles are out of order.");
+        }
+        lastRoleIndex = roleIndex;
+        if (path.kind === "file") {
+          fileCount += 1;
+          if (seenPaths.has(record.path)) {
+            throw this.invalidArchive("The central directory contains a duplicate file.");
+          }
+          seenPaths.add(record.path);
+          const expected = expectedEntries.get(record.path);
+          if (expected === void 0) {
+            throw this.invalidArchive("The archive entry checksum or size is invalid.");
+          }
+          if (expected.byteLength !== record.byteLength || expected.crc32 !== record.crc32) {
+            throw this.invalidArchive("The archive entry checksum or size is invalid.");
+          }
+        } else if (record.byteLength !== 0 || record.crc32 !== 0) {
+          throw this.invalidArchive("The archive directory entry is not empty.");
+        }
+        offset = record.nextOffset;
+      }
+      if (offset !== data.length || fileCount !== entries.length) {
+        throw this.invalidArchive("The central directory does not match the archive entries.");
+      }
+    }
+    readUint16(data, offset) {
+      const first = data[offset];
+      const second = data[offset + 1];
+      if (first === void 0 || second === void 0) {
+        throw this.invalidArchive();
+      }
+      return first | second << 8;
+    }
+    readUint32(data, offset) {
+      const first = data[offset];
+      const second = data[offset + 1];
+      const third = data[offset + 2];
+      const fourth = data[offset + 3];
+      if (first === void 0 || second === void 0 || third === void 0 || fourth === void 0) {
+        throw this.invalidArchive();
+      }
+      return (first | second << 8 | third << 16 | fourth << 24) >>> 0;
+    }
+    throwIfAborted(signal) {
+      if (signal?.aborted) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.Cancelled,
+          "The archive import was cancelled."
+        );
+      }
+    }
+  }
+  class ArchiveImportChunkAcknowledgement {
+    chunkId;
+    promise;
+    taskId;
+    rejectPromise;
+    resolvePromise;
+    settled = false;
+    constructor(taskId, chunkId) {
+      this.chunkId = chunkId;
+      this.promise = new Promise(this.initializePromise.bind(this));
+      this.taskId = taskId;
+    }
+    acknowledge() {
+      if (this.settled) {
+        return;
+      }
+      this.settled = true;
+      this.resolvePromise?.();
+    }
+    cancel() {
+      if (this.settled) {
+        return;
+      }
+      this.settled = true;
+      this.rejectPromise?.(
+        new ArchiveImportError(
+          ArchiveImportErrorCode.Cancelled,
+          "The archive import was cancelled."
+        )
+      );
+    }
+    initializePromise(resolve, reject) {
+      this.resolvePromise = resolve;
+      this.rejectPromise = reject;
+    }
+  }
+  class ArchiveImportCrc32 {
+    table;
+    value = 4294967295;
+    constructor() {
+      const table = [];
+      for (let index = 0; index < 256; index += 1) {
+        let value = index;
+        for (let bit = 0; bit < 8; bit += 1) {
+          value = (value & 1) === 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+        }
+        table.push(value >>> 0);
+      }
+      this.table = table;
+    }
+    digest() {
+      return (this.value ^ 4294967295) >>> 0;
+    }
+    update(data) {
+      for (const byte of data) {
+        const tableIndex = (this.value ^ byte) & 255;
+        const tableValue = this.table[tableIndex];
+        if (tableValue === void 0) {
+          throw new Error("The CRC-32 table is incomplete.");
+        }
+        this.value = tableValue ^ this.value >>> 8;
+      }
+    }
+  }
+  class ArchiveImportJobValidator {
+    validate(job) {
+      if (!Number.isSafeInteger(job.taskId) || job.taskId <= 0) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.Protocol,
+          "The archive import task id must be a positive safe integer."
+        );
+      }
+      const file = job.file;
+      if (!this.isReadableFile(file)) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          "The selected archive could not be read."
+        );
+      }
+    }
+    isReadableFile(value) {
+      const record = this.getRecord(value);
+      if (record === void 0) {
+        return false;
+      }
+      return typeof record["size"] === "number" && Number.isSafeInteger(record["size"]) && record["size"] > 0 && typeof record["stream"] === "function" && typeof record["slice"] === "function" && typeof record["arrayBuffer"] === "function";
+    }
+    getRecord(value) {
+      return this.isRecord(value) ? value : void 0;
+    }
+    isRecord(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+  }
+  class ArchiveImportSignatureValidator {
+    prefix = [];
+    finish() {
+      if (this.prefix.length < 4 || !this.hasLocalFileSignature()) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          "The selected file is not a supported ZIP archive."
+        );
+      }
+    }
+    push(chunk) {
+      for (let index = 0; index < chunk.length && this.prefix.length < 4; index += 1) {
+        const value = chunk[index];
+        if (value !== void 0) {
+          this.prefix.push(value);
+        }
+      }
+      if (this.prefix.length === 4 && !this.hasLocalFileSignature()) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          "The selected file is not a supported ZIP archive."
+        );
+      }
+    }
+    hasLocalFileSignature() {
+      return this.prefix[0] === 80 && this.prefix[1] === 75 && this.prefix[2] === 3 && this.prefix[3] === 4;
+    }
+  }
+  class ArchiveImportWorkerMessageParser {
+    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);
+      const taskId = record?.["taskId"];
+      if (record === void 0 || !this.isPositiveSafeInteger(taskId)) {
+        return void 0;
+      }
+      switch (record["type"]) {
+        case "cancelled":
+          return { taskId, type: "cancelled" };
+        case "complete":
+          return { taskId, type: "complete" };
+        case "entry-chunk":
+          return this.parseEntryChunk(record, taskId);
+        case "entry-start":
+          return this.parseEntryStart(record, taskId);
+        case "error":
+          return typeof record["message"] === "string" ? { message: record["message"], taskId, type: "error" } : void 0;
+        default:
+          return void 0;
+      }
+    }
+    getRecord(value) {
+      return this.isRecord(value) ? value : void 0;
+    }
+    isFileLike(value) {
+      const record = this.getRecord(value);
+      return record !== void 0 && typeof record["name"] === "string" && typeof record["size"] === "number" && Number.isSafeInteger(record["size"]) && typeof record["stream"] === "function" && typeof record["slice"] === "function" && typeof record["arrayBuffer"] === "function";
+    }
+    isFormat(value) {
+      return value === "obj" || value === "ply";
+    }
+    isPositiveSafeInteger(value) {
+      return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+    }
+    isRecord(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+    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"];
+      return this.isPositiveSafeInteger(taskId) ? { taskId, type: "cancel" } : void 0;
+    }
+    parseEntryChunk(record, taskId) {
+      const chunk = record["chunk"];
+      const chunkId = record["chunkId"];
+      const entryId = record["entryId"];
+      const final = record["final"];
+      if (!(chunk instanceof ArrayBuffer) || !this.isPositiveSafeInteger(chunkId) || !this.isPositiveSafeInteger(entryId) || typeof final !== "boolean") {
+        return void 0;
+      }
+      return {
+        chunk,
+        chunkId,
+        entryId,
+        final,
+        taskId,
+        type: "entry-chunk"
+      };
+    }
+    parseEntryStart(record, taskId) {
+      const entryId = record["entryId"];
+      const fileName = record["fileName"];
+      const format = record["format"];
+      const isModel = record["isModel"];
+      const role = record["role"];
+      if (!this.isPositiveSafeInteger(entryId) || typeof fileName !== "string" || typeof isModel !== "boolean" || role !== "stone" && role !== "base" || format !== void 0 && !this.isFormat(format)) {
+        return void 0;
+      }
+      return format === void 0 ? { entryId, fileName, isModel, role, taskId, type: "entry-start" } : { entryId, fileName, format, isModel, role, taskId, type: "entry-start" };
+    }
+    parseStart(record) {
+      const file = record["file"];
+      const taskId = record["taskId"];
+      if (!this.isPositiveSafeInteger(taskId) || !this.isFileLike(file)) {
+        return void 0;
+      }
+      return { file, taskId, type: "start" };
+    }
+  }
+  class ArchiveImportWorkerTask {
+    abortController = new AbortController();
+    awaitingAcknowledgement;
+    activeEntryId;
+    cancelled = false;
+    entryByteCounts = /* @__PURE__ */ new Map();
+    entryChecksums = /* @__PURE__ */ new Map();
+    entries = [];
+    queuedMessages = [];
+    request;
+    roleModelCounts = /* @__PURE__ */ new Map();
+    rolesSeen = /* @__PURE__ */ new Set();
+    seenFileNames = /* @__PURE__ */ new Set();
+    nextChunkId = 1;
+    nextEntryId = 1;
+    lastRoleIndex = -1;
+    constructor(request) {
+      this.request = request;
+    }
+    cancel() {
+      if (this.cancelled) {
+        return;
+      }
+      this.cancelled = true;
+      this.abortController.abort();
+      this.awaitingAcknowledgement?.cancel();
+      this.queuedMessages.length = 0;
+    }
+  }
+  class ArchiveImportWorkerRuntime {
+    inputChunkSize = 64 * 1024;
+    activeTask;
+    jobValidator = new ArchiveImportJobValidator();
+    latestStartedTaskId = 0;
+    centralDirectoryValidator = new ArchiveImportCentralDirectoryValidator();
+    messageParser = new ArchiveImportWorkerMessageParser();
+    pathValidator = new ArchiveImportPathValidator();
+    port;
+    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();
+    }
+    copyChunk(data) {
+      const copy = new Uint8Array(data.byteLength);
+      copy.set(data);
+      return copy.buffer;
+    }
+    createUnzip(task) {
+      const unzip = new Unzip(this.handleFile.bind(this, task));
+      unzip.register(UnzipInflate);
+      return unzip;
+    }
+    async drainMessages(task) {
+      while (task.queuedMessages.length > 0) {
+        this.throwIfCancelled(task);
+        const queued = task.queuedMessages.shift();
+        if (queued === void 0) {
+          throw new ArchiveImportError(
+            ArchiveImportErrorCode.Protocol,
+            "The archive import output queue was unexpectedly empty."
+          );
+        }
+        await this.sendQueuedMessage(task, queued);
+      }
+    }
+    async handleArchiveStream(task) {
+      let reader;
+      try {
+        const stream = task.request.file.stream();
+        reader = stream.getReader();
+      } catch {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          "The selected archive could not be read."
+        );
+      }
+      const unzip = this.createUnzip(task);
+      const signature = new ArchiveImportSignatureValidator();
+      try {
+        for (; ; ) {
+          this.throwIfCancelled(task);
+          const result = await reader.read();
+          if (result.done) {
+            break;
+          }
+          await this.processInputChunk(task, unzip, signature, result.value);
+        }
+        signature.finish();
+        this.pushToUnzip(task, unzip, new Uint8Array(0), true);
+        await this.drainMessages(task);
+        this.validateArchive(task);
+        await this.validateChecksums(task);
+      } finally {
+        await this.cancelReader(reader);
+        reader.releaseLock();
+      }
+    }
+    handleDirectoryData(error, data) {
+      if (error !== null || data === null || data.byteLength > 0) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          "The archive contains an invalid directory entry."
+        );
+      }
+    }
+    handleEntryData(task, entry, error, data, final) {
+      if (error !== null) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          `The archive entry ${entry.metadata.fileName} could not be decompressed.`
+        );
+      }
+      if (data === null) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          `The archive entry ${entry.metadata.fileName} has no decompressed data.`
+        );
+      }
+      this.throwIfCancelled(task);
+      const checksum = task.entryChecksums.get(entry.metadata.entryId);
+      const byteCount = task.entryByteCounts.get(entry.metadata.entryId);
+      if (checksum === void 0 || byteCount === void 0) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.Protocol,
+          "The archive decoder returned an unknown entry."
+        );
+      }
+      checksum.update(data);
+      task.entryByteCounts.set(entry.metadata.entryId, byteCount + data.byteLength);
+      if (task.activeEntryId !== entry.metadata.entryId) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.Protocol,
+          "The archive decoder changed entries unexpectedly."
+        );
+      }
+      if (data.byteLength > 0 || final) {
+        this.queueEntryChunk(task, entry.metadata, data, final);
+      }
+      if (final) {
+        task.activeEntryId = void 0;
+      }
+    }
+    handleFile(task, file) {
+      this.throwIfCancelled(task);
+      const path = this.pathValidator.parse(file.name);
+      if (path.kind === "directory") {
+        this.handleDirectory(task, file, path);
+        return;
+      }
+      const entry = this.registerEntry(task, path);
+      task.activeEntryId = entry.metadata.entryId;
+      file.ondata = this.handleEntryData.bind(this, task, entry);
+      file.start();
+    }
+    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);
+      }
+    }
+    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);
+      }
+    }
+    handleDirectory(task, file, path) {
+      this.assertRoleOrder(task, path.role);
+      task.rolesSeen.add(path.role);
+      file.ondata = this.handleDirectoryData.bind(this);
+      file.start();
+    }
+    handleMessage(event) {
+      const message = this.messageParser.parseInbound(event.data);
+      if (message !== void 0) {
+        this.handleInboundMessage(message);
+      }
+    }
+    handleStart(message) {
+      const request = {
+        file: message.file,
+        taskId: message.taskId
+      };
+      try {
+        this.jobValidator.validate(request);
+      } catch (error) {
+        this.postError(message.taskId, error);
+        return;
+      }
+      if (request.taskId <= this.latestStartedTaskId) {
+        this.postError(
+          request.taskId,
+          new ArchiveImportError(
+            ArchiveImportErrorCode.Protocol,
+            "Each archive import must use a newer task id."
+          )
+        );
+        return;
+      }
+      this.activeTask?.cancel();
+      const task = new ArchiveImportWorkerTask(request);
+      this.activeTask = task;
+      this.latestStartedTaskId = request.taskId;
+      void this.runTask(task);
+    }
+    isCurrentTask(task) {
+      return this.activeTask === task;
+    }
+    postCancelled(task) {
+      this.port.postMessage({ taskId: task.request.taskId, type: "cancelled" });
+    }
+    postComplete(task) {
+      this.port.postMessage({ taskId: task.request.taskId, type: "complete" });
+    }
+    postError(taskId, error) {
+      this.port.postMessage({
+        message: this.getErrorMessage(error),
+        taskId,
+        type: "error"
+      });
+    }
+    async processInputChunk(task, unzip, signature, chunk) {
+      for (let offset = 0; offset < chunk.byteLength; offset += this.inputChunkSize) {
+        const part = chunk.subarray(offset, offset + this.inputChunkSize);
+        signature.push(part);
+        this.pushToUnzip(task, unzip, part, false);
+        await this.drainMessages(task);
+      }
+    }
+    pushToUnzip(task, unzip, chunk, final) {
+      this.throwIfCancelled(task);
+      try {
+        unzip.push(chunk, final);
+      } catch (error) {
+        if (error instanceof ArchiveImportError) {
+          throw error;
+        }
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          "The selected archive is invalid or corrupted."
+        );
+      }
+    }
+    queueEntryChunk(task, metadata, data, final) {
+      const chunkId = task.nextChunkId;
+      if (!Number.isSafeInteger(chunkId)) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.Protocol,
+          "The archive import chunk id overflowed."
+        );
+      }
+      task.nextChunkId += 1;
+      const message = {
+        chunk: this.copyChunk(data),
+        chunkId,
+        entryId: metadata.entryId,
+        final,
+        taskId: task.request.taskId,
+        type: "entry-chunk"
+      };
+      task.queuedMessages.push({ kind: "entry-chunk", message });
+    }
+    queueEntryStart(task, metadata) {
+      const message = metadata.format === void 0 ? {
+        entryId: metadata.entryId,
+        fileName: metadata.fileName,
+        isModel: metadata.isModel,
+        role: metadata.role,
+        taskId: task.request.taskId,
+        type: "entry-start"
+      } : {
+        entryId: metadata.entryId,
+        fileName: metadata.fileName,
+        format: metadata.format,
+        isModel: metadata.isModel,
+        role: metadata.role,
+        taskId: task.request.taskId,
+        type: "entry-start"
+      };
+      task.queuedMessages.push({ kind: "entry-start", message });
+    }
+    registerEntry(task, path) {
+      this.assertRoleOrder(task, path.role);
+      task.rolesSeen.add(path.role);
+      const duplicateKey = `${path.role}/${path.fileName}`;
+      if (task.seenFileNames.has(duplicateKey)) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          `The archive contains a duplicate file named ${duplicateKey}.`
+        );
+      }
+      task.seenFileNames.add(duplicateKey);
+      const entryId = task.nextEntryId;
+      if (!Number.isSafeInteger(entryId)) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.Protocol,
+          "The archive import entry id overflowed."
+        );
+      }
+      task.nextEntryId += 1;
+      const metadata = path.format === void 0 ? {
+        entryId,
+        fileName: path.fileName,
+        isModel: path.isModel,
+        role: path.role
+      } : {
+        entryId,
+        fileName: path.fileName,
+        format: path.format,
+        isModel: path.isModel,
+        role: path.role
+      };
+      task.entries.push(metadata);
+      task.entryChecksums.set(entryId, new ArchiveImportCrc32());
+      task.entryByteCounts.set(entryId, 0);
+      if (metadata.isModel) {
+        const modelCount = task.roleModelCounts.get(metadata.role) ?? 0;
+        task.roleModelCounts.set(metadata.role, modelCount + 1);
+        if (modelCount >= 1) {
+          throw new ArchiveImportError(
+            ArchiveImportErrorCode.InvalidSource,
+            `The ${metadata.role} directory must contain exactly one OBJ or PLY model.`
+          );
+        }
+      }
+      this.queueEntryStart(task, metadata);
+      return { metadata };
+    }
+    async runTask(task) {
+      try {
+        await this.handleArchiveStream(task);
+        this.throwIfCancelled(task);
+        if (this.isCurrentTask(task)) {
+          this.postComplete(task);
+        }
+      } catch (error) {
+        if (!this.isCurrentTask(task)) {
+          return;
+        }
+        if (task.cancelled || this.isCancelledError(error)) {
+          this.postCancelled(task);
+        } else {
+          this.postError(task.request.taskId, error);
+        }
+      } finally {
+        if (this.activeTask === task) {
+          this.activeTask = void 0;
+        }
+      }
+    }
+    async sendQueuedMessage(task, queued) {
+      if (queued.kind === "entry-start") {
+        this.port.postMessage(queued.message);
+        return;
+      }
+      const acknowledgement = new ArchiveImportChunkAcknowledgement(
+        task.request.taskId,
+        queued.message.chunkId
+      );
+      task.awaitingAcknowledgement = acknowledgement;
+      this.port.postMessage(queued.message, [queued.message.chunk]);
+      await acknowledgement.promise;
+      if (task.awaitingAcknowledgement === acknowledgement) {
+        task.awaitingAcknowledgement = void 0;
+      }
+    }
+    throwIfCancelled(task) {
+      if (task.cancelled || task.abortController.signal.aborted) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.Cancelled,
+          "The archive import was cancelled."
+        );
+      }
+    }
+    assertRoleOrder(task, role) {
+      const roleIndex = role === "stone" ? 0 : 1;
+      if (roleIndex < task.lastRoleIndex) {
+        throw new ArchiveImportError(
+          ArchiveImportErrorCode.InvalidSource,
+          "The archive roles are out of order."
+        );
+      }
+      task.lastRoleIndex = roleIndex;
+    }
+    validateArchive(task) {
+      for (const role of ["stone", "base"]) {
+        if (!task.rolesSeen.has(role) || task.roleModelCounts.get(role) !== 1) {
+          throw new ArchiveImportError(
+            ArchiveImportErrorCode.InvalidSource,
+            `The archive must contain exactly one ${role} OBJ or PLY model.`
+          );
+        }
+      }
+    }
+    async validateChecksums(task) {
+      const entries = [];
+      for (const metadata of task.entries) {
+        const checksum = task.entryChecksums.get(metadata.entryId);
+        const byteLength = task.entryByteCounts.get(metadata.entryId);
+        if (checksum === void 0 || byteLength === void 0) {
+          throw new ArchiveImportError(
+            ArchiveImportErrorCode.Protocol,
+            "The archive checksum state is incomplete."
+          );
+        }
+        entries.push({
+          byteLength,
+          crc32: checksum.digest(),
+          path: `${metadata.role}/${metadata.fileName}`
+        });
+      }
+      await this.centralDirectoryValidator.validate(
+        task.request.file,
+        entries,
+        task.abortController.signal
+      );
+    }
+    async cancelReader(reader) {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+    }
+    getErrorMessage(error) {
+      return error instanceof ArchiveImportError ? error.message : "The edited model archive could not be imported.";
+    }
+    isCancelledError(error) {
+      return error instanceof ArchiveImportError && error.code === ArchiveImportErrorCode.Cancelled;
+    }
+  }
+  class BrowserArchiveImportWorkerPort {
+    addEventListener(type, listener) {
+      globalThis.addEventListener(type, listener);
+    }
+    postMessage(message, transfer) {
+      Reflect.apply(globalThis.postMessage, globalThis, [message, transfer]);
+    }
+  }
+  const runtime = new ArchiveImportWorkerRuntime(new BrowserArchiveImportWorkerPort());
+  runtime.attach();
+})();