(self.webpackChunkRemoteClient = self.webpackChunkRemoteClient || []).push([
  [8936],
  {
    8936: (t, e, n) => {
      'use strict';
      n.r(e),
        n.d(e, {
          E: () => w,
          R: () => x,
          S: () => N,
          V: () => h,
          a: () => l,
          b: () => H,
          g: () => d,
          u: () => S,
          w: () => j,
        });
      var r = n(8358),
        i = n(40167),
        s = n(15215);
      function o(t, e = 0) {
        const n = t.stride;
        return t.fieldNames
          .filter((e) => {
            const n = t.fields.get(e).optional;
            return !(n && n.glPadding);
          })
          .map((r) => {
            const i = t.fields.get(r),
              s = i.constructor.ElementCount,
              o = (function (t) {
                const e = a[t];
                if (e) return e;
                throw new Error('BufferType not supported in WebGL');
              })(i.constructor.ElementType),
              c = i.offset,
              u = !(!i.optional || !i.optional.glNormalized);
            return { name: r, stride: n, count: s, type: o, offset: c, normalized: u, divisor: e };
          });
      }
      const a = { u8: 5121, u16: 5123, u32: 5125, i8: 5120, i16: 5122, i32: 5124, f32: 5126 };
      var c = n(27794),
        u = n(82426),
        f = n(76506);
      const l = (0, s.n)().vec3f('position').u16('componentIndex').u16('u16padding'),
        h = (0, s.n)().vec2u8('sideness'),
        d = o(h),
        p = (0, s.n)()
          .vec3f('position0')
          .vec3f('position1')
          .u16('componentIndex')
          .u8('variantOffset', { glNormalized: !0 })
          .u8('variantStroke')
          .u8('variantExtension', { glNormalized: !0 })
          .u8('u8padding', { glPadding: !0 })
          .u16('u16padding', { glPadding: !0 }),
        g = p.clone().vec3f('normal'),
        m = p.clone().vec3f('normalA').vec3f('normalB'),
        w = new Map([
          ['position0', 0],
          ['position1', 1],
          ['componentIndex', 2],
          ['variantOffset', 3],
          ['variantStroke', 4],
          ['variantExtension', 5],
          ['normal', 6],
          ['normalA', 6],
          ['normalB', 7],
          ['sideness', 8],
        ]);
      class M {
        updateSettings(t) {
          (this.settings = t), (this.edgeHashFunction = t.reducedPrecision ? F : A);
        }
        write(t, e, n) {
          const r = this.edgeHashFunction(n);
          _.seed = r;
          const i = _.getIntRange(0, 255),
            s = _.getIntRange(0, this.settings.variants - 1),
            o = _.getFloat(),
            a =
              255 *
              (0.5 *
                (function (t, e) {
                  const n = t < 0 ? -1 : 1;
                  return Math.abs(t) ** 1.2 * n;
                })(-(1 - Math.min(o / 0.7, 1)) + Math.max(0, o - 0.7) / (1 - 0.7)) +
                0.5);
          t.position0.setVec(e, n.position0),
            t.position1.setVec(e, n.position1),
            t.componentIndex.set(e, n.componentIndex),
            t.variantOffset.set(e, i),
            t.variantStroke.set(e, s),
            t.variantExtension.set(e, a);
        }
        trim(t, e) {
          return t.slice(0, e);
        }
      }
      const b = new Float32Array(6),
        y = new Uint32Array(b.buffer),
        v = new Uint32Array(1);
      function A(t) {
        const e = b;
        (e[0] = t.position0[0]),
          (e[1] = t.position0[1]),
          (e[2] = t.position0[2]),
          (e[3] = t.position1[0]),
          (e[4] = t.position1[1]),
          (e[5] = t.position1[2]),
          (v[0] = 5381);
        for (let t = 0; t < y.length; t++) v[0] = 31 * v[0] + y[t];
        return v[0];
      }
      function F(t) {
        const e = b;
        (e[0] = I(t.position0[0])),
          (e[1] = I(t.position0[1])),
          (e[2] = I(t.position0[2])),
          (e[3] = I(t.position1[0])),
          (e[4] = I(t.position1[1])),
          (e[5] = I(t.position1[2])),
          (v[0] = 5381);
        for (let t = 0; t < y.length; t++) v[0] = 31 * v[0] + y[t];
        return v[0];
      }
      function I(t) {
        return Math.round(1e4 * t) / 1e4;
      }
      class x {
        constructor() {
          this.commonWriter = new M();
        }
        updateSettings(t) {
          this.commonWriter.updateSettings(t);
        }
        allocate(t) {
          return g.createBuffer(t);
        }
        write(t, e, n) {
          this.commonWriter.write(t, e, n),
            (0, u.g)(E, n.faceNormal0, n.faceNormal1),
            (0, u.n)(E, E),
            t.normal.setVec(e, E);
        }
        trim(t, e) {
          return this.commonWriter.trim(t, e);
        }
      }
      (x.Layout = g), (x.glLayout = o(g, 1));
      class N {
        constructor() {
          this.commonWriter = new M();
        }
        updateSettings(t) {
          this.commonWriter.updateSettings(t);
        }
        allocate(t) {
          return m.createBuffer(t);
        }
        write(t, e, n) {
          this.commonWriter.write(t, e, n),
            t.normalA.setVec(e, n.faceNormal0),
            t.normalB.setVec(e, n.faceNormal1);
        }
        trim(t, e) {
          return this.commonWriter.trim(t, e);
        }
      }
      (N.Layout = m), (N.glLayout = o(m, 1));
      const E = (0, u.b)(),
        _ = new c.R();
      function L(t, e) {
        return e.push(t.buffer), { buffer: t.buffer, layout: U(t.layout) };
      }
      function S(t) {
        return (function (t) {
          const e = (0, s.n)();
          return (
            (e.stride = t.stride),
            (e.fieldNames = t.fieldNames),
            t.fields.forEach((t) =>
              e.fields.set(t[0], { ...t[1], constructor: V(t[1].constructor) }),
            ),
            e
          );
        })(t.layout).createView(t.buffer);
      }
      function U(t) {
        const e = new Array();
        return (
          t.fields.forEach((t, n) => {
            const r = { ...t, constructor: B(t.constructor) };
            e.push([n, r]);
          }),
          { stride: t.stride, fields: e, fieldNames: t.fieldNames }
        );
      }
      const k = [
        i.v,
        i.e,
        i.a,
        i.g,
        i.d,
        i.u,
        i.w,
        i.t,
        i.B,
        i.f,
        i.i,
        i.c,
        i.h,
        i.r,
        i.m,
        i.b,
        i.k,
        i.p,
        i.n,
        i.l,
        i.j,
        i.o,
        i.y,
        i.z,
        i.x,
        i.s,
        i.A,
        i.C,
        i.D,
        i.q,
        i.E,
        i.F,
        i.G,
        i.H,
        i.I,
        i.J,
      ];
      function B(t) {
        return `${t.ElementType}_${t.ElementCount}`;
      }
      function V(t) {
        return q.get(t);
      }
      const q = new Map();
      function D(t, e, n) {
        const r = e / 3,
          i = new Uint32Array(n + 1),
          s = new Uint32Array(n + 1),
          o = (t, e) => {
            t < e ? i[t + 1]++ : s[e + 1]++;
          };
        for (let e = 0; e < r; e++) {
          const n = t[3 * e],
            r = t[3 * e + 1],
            i = t[3 * e + 2];
          o(n, r), o(r, i), o(i, n);
        }
        let a = 0,
          c = 0;
        for (let t = 0; t < n; t++) {
          const e = i[t + 1],
            n = s[t + 1];
          (i[t + 1] = a), (s[t + 1] = c), (a += e), (c += n);
        }
        const u = new Uint32Array(6 * r),
          f = i[n],
          l = (t, e, n) => {
            if (t < e) {
              const r = i[t + 1]++;
              (u[2 * r] = e), (u[2 * r + 1] = n);
            } else {
              const r = s[e + 1]++;
              (u[2 * f + 2 * r] = t), (u[2 * f + 2 * r + 1] = n);
            }
          };
        for (let e = 0; e < r; e++) {
          const n = t[3 * e],
            r = t[3 * e + 1],
            i = t[3 * e + 2];
          l(n, r, e), l(r, i, e), l(i, n, e);
        }
        const h = (t, e) => {
          const n = 2 * t,
            r = e - t;
          for (let t = 1; t < r; t++) {
            const e = u[n + 2 * t],
              r = u[n + 2 * t + 1];
            let i = t - 1;
            for (; i >= 0 && u[n + 2 * i] > e; i--)
              (u[n + 2 * i + 2] = u[n + 2 * i]), (u[n + 2 * i + 3] = u[n + 2 * i + 1]);
            (u[n + 2 * i + 2] = e), (u[n + 2 * i + 3] = r);
          }
        };
        for (let t = 0; t < n; t++) h(i[t], i[t + 1]), h(f + s[t], f + s[t + 1]);
        const d = new Int32Array(3 * r),
          p = (e, n) => (e === t[3 * n] ? 0 : e === t[3 * n + 1] ? 1 : e === t[3 * n + 2] ? 2 : -1),
          g = (t, e) => {
            const n = p(t, e);
            d[3 * e + n] = -1;
          },
          m = (t, e, n, r) => {
            const i = p(t, e);
            d[3 * e + i] = r;
            const s = p(n, r);
            d[3 * r + s] = e;
          };
        for (let t = 0; t < n; t++) {
          let e = i[t];
          const n = i[t + 1];
          let r = s[t];
          const o = s[t + 1];
          for (; e < n && r < o; ) {
            const n = u[2 * e],
              i = u[2 * f + 2 * r];
            n === i
              ? (m(t, u[2 * e + 1], i, u[2 * f + 2 * r + 1]), e++, r++)
              : n < i
              ? (g(t, u[2 * e + 1]), e++)
              : (g(i, u[2 * f + 2 * r + 1]), r++);
          }
          for (; e < n; ) g(t, u[2 * e + 1]), e++;
          for (; r < o; ) g(u[2 * f + 2 * r], u[2 * f + 2 * r + 1]), r++;
        }
        return d;
      }
      function z(t, e) {
        return t.cosAngle < e;
      }
      function C(t, e) {
        return t.cosAngle > e;
      }
      function P(t, e) {
        const n = (0, u.i)(t.cosAngle),
          r = R.fwd,
          i = R.ortho;
        return (
          (0, u.D)(r, t.position1, t.position0),
          n * ((0, u.d)((0, u.a)(i, t.faceNormal0, t.faceNormal1), r) > 0 ? -1 : 1) > e
        );
      }
      k.forEach((t) => q.set(B(t), t));
      const R = {
          edge: {
            position0: (0, u.b)(),
            position1: (0, u.b)(),
            faceNormal0: (0, u.b)(),
            faceNormal1: (0, u.b)(),
            componentIndex: 0,
            cosAngle: 0,
          },
          ortho: (0, u.b)(),
          fwd: (0, u.b)(),
        },
        T = { v0: (0, u.b)(), v1: (0, u.b)(), v2: (0, u.b)() },
        W = { anglePlanar: 4, angleSignificantEdge: 35 };
      function j(t) {
        const e = (function (t, e, n, i) {
          if (e) return { faces: n, facesLength: i, neighbors: D(n, i, t.count), vertices: t };
          const s = (0, r.d)(t.buffer, t.stride / 4, {
              originalIndices: n,
              originalIndicesLength: i,
            }),
            o = D(s.indices, i, s.uniqueCount);
          return {
            faces: s.indices,
            facesLength: s.indices.length,
            neighbors: o,
            vertices: l.createView(s.buffer),
          };
        })(t.data, t.skipDeduplicate, t.indices, t.indicesLength);
        return (
          O.updateSettings(t.writerSettings),
          G.updateSettings(t.writerSettings),
          (function (t, e, n, r = W) {
            const i = t.vertices.position,
              s = t.vertices.componentIndex,
              o = (0, u.k)(r.anglePlanar),
              a = (0, u.k)(r.angleSignificantEdge),
              l = Math.cos(a),
              h = Math.cos(o),
              d = R.edge,
              p = d.position0,
              g = d.position1,
              m = d.faceNormal0,
              w = d.faceNormal1,
              M = (function (t) {
                const e = t.faces.length / 3,
                  n = t.vertices.position,
                  r = t.faces,
                  i = T.v0,
                  s = T.v1,
                  o = T.v2,
                  a = new Float32Array(3 * e);
                for (let t = 0; t < e; t++) {
                  const e = r[3 * t + 0],
                    c = r[3 * t + 1],
                    f = r[3 * t + 2];
                  n.getVec(e, i),
                    n.getVec(c, s),
                    n.getVec(f, o),
                    (0, u.s)(s, s, i),
                    (0, u.s)(o, o, i),
                    (0, u.a)(i, s, o),
                    (0, u.n)(i, i),
                    (a[3 * t + 0] = i[0]),
                    (a[3 * t + 1] = i[1]),
                    (a[3 * t + 2] = i[2]);
                }
                return a;
              })(t),
              b = (function (t) {
                const e = t.faces.length / 3,
                  n = t.faces,
                  r = t.neighbors;
                let i = 0;
                for (let t = 0; t < e; t++) {
                  const e = r[3 * t + 0],
                    s = r[3 * t + 1],
                    o = r[3 * t + 2],
                    a = n[3 * t + 0],
                    c = n[3 * t + 1],
                    u = n[3 * t + 2];
                  (i += -1 === e || a < c ? 1 : 0),
                    (i += -1 === s || c < u ? 1 : 0),
                    (i += -1 === o || u < a ? 1 : 0);
                }
                const s = new Int32Array(4 * i);
                let o = 0;
                for (let t = 0; t < e; t++) {
                  const e = r[3 * t + 0],
                    i = r[3 * t + 1],
                    a = r[3 * t + 2],
                    c = n[3 * t + 0],
                    u = n[3 * t + 1],
                    f = n[3 * t + 2];
                  (-1 === e || c < u) && ((s[o++] = c), (s[o++] = u), (s[o++] = t), (s[o++] = e)),
                    (-1 === i || u < f) && ((s[o++] = u), (s[o++] = f), (s[o++] = t), (s[o++] = i)),
                    (-1 === a || f < c) && ((s[o++] = f), (s[o++] = c), (s[o++] = t), (s[o++] = a));
                }
                return s;
              })(t),
              y = b.length / 4,
              v = e.allocate(y);
            let A = 0;
            const F = y,
              I = n.allocate(F);
            let x = 0,
              N = 0,
              E = 0;
            const _ = (0, c.j)(0, y),
              L = new Float32Array(y);
            (0, f.B)(L, (t, e, n) => {
              i.getVec(b[4 * e + 0], p), i.getVec(b[4 * e + 1], g), (n[e] = (0, u.w)(p, g));
            }),
              _.sort((t, e) => L[e] - L[t]);
            const S = new Array(),
              U = new Array();
            for (let t = 0; t < y; t++) {
              const r = _[t],
                a = L[r],
                c = b[4 * r + 0],
                f = b[4 * r + 1],
                y = b[4 * r + 2],
                F = b[4 * r + 3],
                k = -1 === F;
              if ((i.getVec(c, p), i.getVec(f, g), k))
                (0, u.e)(m, M[3 * y + 0], M[3 * y + 1], M[3 * y + 2]),
                  (0, u.j)(w, m),
                  (d.componentIndex = s.get(c)),
                  (d.cosAngle = (0, u.d)(m, w));
              else {
                if (
                  ((0, u.e)(m, M[3 * y + 0], M[3 * y + 1], M[3 * y + 2]),
                  (0, u.e)(w, M[3 * F + 0], M[3 * F + 1], M[3 * F + 2]),
                  (d.componentIndex = s.get(c)),
                  (d.cosAngle = (0, u.d)(m, w)),
                  C(d, h))
                )
                  continue;
                d.cosAngle < -0.9999 && (0, u.j)(w, m);
              }
              (N += a),
                E++,
                k || z(d, l)
                  ? (e.write(v, A++, d), S.push(a))
                  : P(d, o) && (n.write(I, x++, d), U.push(a));
            }
            const k = new Float32Array(S.reverse()),
              B = new Float32Array(U.reverse());
            return {
              regular: { instancesData: e.trim(v, A), lodInfo: { lengths: k } },
              silhouette: { instancesData: n.trim(I, x), lodInfo: { lengths: B } },
              averageEdgeLength: N / E,
            };
          })(e, O, G)
        );
      }
      const O = new x(),
        G = new N();
      var H = Object.freeze({
        __proto__: null,
        wrappedWork: async function (t) {
          const e = (function (t) {
              return {
                data: l.createView(t.dataBuffer),
                indices:
                  'Uint32Array' === t.indicesType
                    ? new Uint32Array(t.indicesBuffer)
                    : 'Uint16Array' === t.indicesType
                    ? new Uint16Array(t.indicesBuffer)
                    : void 0,
                indicesLength: t.indicesLength,
                writerSettings: t.writerSettings,
                skipDeduplicate: t.skipDeduplicate,
              };
            })(t),
            n = j(e),
            r = [e.data.buffer];
          return {
            result: (function (t, e) {
              return (
                e.push(t.regular.lodInfo.lengths.buffer),
                e.push(t.silhouette.lodInfo.lengths.buffer),
                {
                  regular: {
                    instancesData: L(t.regular.instancesData, e),
                    lodInfo: { lengths: t.regular.lodInfo.lengths.buffer },
                  },
                  silhouette: {
                    instancesData: L(t.silhouette.instancesData, e),
                    lodInfo: { lengths: t.silhouette.lodInfo.lengths.buffer },
                  },
                  averageEdgeLength: t.averageEdgeLength,
                }
              );
            })(n, r),
            transferList: r,
          };
        },
        work: j,
      });
    },
    15215: (t, e, n) => {
      'use strict';
      n.d(e, { n: () => a });
      var r = n(40167),
        i = n(27726);
      class s {
        constructor(t, e) {
          (this.layout = t),
            (this.buffer = 'number' == typeof e ? new ArrayBuffer(e * t.stride) : e);
          for (const e of t.fieldNames) {
            const n = t.fields.get(e);
            this[e] = new n.constructor(this.buffer, n.offset, this.stride);
          }
        }
        get stride() {
          return this.layout.stride;
        }
        get count() {
          return this.buffer.byteLength / this.stride;
        }
        get byteLength() {
          return this.buffer.byteLength;
        }
        getField(t, e) {
          const n = this[t];
          return n && n.elementCount === e.ElementCount && n.elementType === e.ElementType
            ? n
            : null;
        }
        slice(t, e) {
          return new s(this.layout, this.buffer.slice(t * this.stride, e * this.stride));
        }
        copyFrom(t, e, n, r) {
          const i = this.stride;
          if (i % 4 == 0) {
            const s = new Uint32Array(t.buffer, e * i, (r * i) / 4);
            new Uint32Array(this.buffer, n * i, (r * i) / 4).set(s);
          } else {
            const s = new Uint8Array(t.buffer, e * i, r * i);
            new Uint8Array(this.buffer, n * i, r * i).set(s);
          }
        }
      }
      class o {
        constructor() {
          (this.stride = 0), (this.fields = new Map()), (this.fieldNames = []);
        }
        vec2f(t, e) {
          return this.appendField(t, r.e, e), this;
        }
        vec2f64(t, e) {
          return this.appendField(t, r.t, e), this;
        }
        vec3f(t, e) {
          return this.appendField(t, r.a, e), this;
        }
        vec3f64(t, e) {
          return this.appendField(t, r.B, e), this;
        }
        vec4f(t, e) {
          return this.appendField(t, r.g, e), this;
        }
        vec4f64(t, e) {
          return this.appendField(t, r.f, e), this;
        }
        mat3f(t, e) {
          return this.appendField(t, r.d, e), this;
        }
        mat3f64(t, e) {
          return this.appendField(t, r.i, e), this;
        }
        mat4f(t, e) {
          return this.appendField(t, r.u, e), this;
        }
        mat4f64(t, e) {
          return this.appendField(t, r.c, e), this;
        }
        vec4u8(t, e) {
          return this.appendField(t, r.b, e), this;
        }
        f32(t, e) {
          return this.appendField(t, r.v, e), this;
        }
        f64(t, e) {
          return this.appendField(t, r.w, e), this;
        }
        u8(t, e) {
          return this.appendField(t, r.h, e), this;
        }
        u16(t, e) {
          return this.appendField(t, r.k, e), this;
        }
        i8(t, e) {
          return this.appendField(t, r.x, e), this;
        }
        vec2i8(t, e) {
          return this.appendField(t, r.s, e), this;
        }
        vec2i16(t, e) {
          return this.appendField(t, r.q, e), this;
        }
        vec2u8(t, e) {
          return this.appendField(t, r.r, e), this;
        }
        vec4u16(t, e) {
          return this.appendField(t, r.l, e), this;
        }
        u32(t, e) {
          return this.appendField(t, r.j, e), this;
        }
        appendField(t, e, n) {
          const r = e.ElementCount * (0, i.e)(e.ElementType),
            s = this.stride;
          this.fields.set(t, { size: r, constructor: e, offset: s, optional: n }),
            (this.stride += r),
            this.fieldNames.push(t);
        }
        alignTo(t) {
          return (this.stride = Math.floor((this.stride + t - 1) / t) * t), this;
        }
        hasField(t) {
          return this.fieldNames.indexOf(t) >= 0;
        }
        createBuffer(t) {
          return new s(this, t);
        }
        createView(t) {
          return new s(this, t);
        }
        clone() {
          const t = new o();
          return (
            (t.stride = this.stride),
            (t.fields = new Map()),
            this.fields.forEach((e, n) => t.fields.set(n, e)),
            (t.fieldNames = this.fieldNames.slice()),
            (t.BufferType = this.BufferType),
            t
          );
        }
      }
      function a() {
        return new o();
      }
    },
    27794: (t, e, n) => {
      'use strict';
      n.d(e, {
        P: () => u,
        R: () => i,
        a: () => p,
        b: () => g,
        c: () => a,
        e: () => s,
        i: () => l,
        j: () => c,
        r: () => h,
      });
      var r = n(76506);
      class i {
        constructor(t = 1) {
          this._seed = t;
        }
        set seed(t) {
          this._seed = null == t ? Math.random() * i._m : t;
        }
        getInt() {
          return (this._seed = (i._a * this._seed + i._c) % i._m), this._seed;
        }
        getFloat() {
          return this.getInt() / (i._m - 1);
        }
        getIntRange(t, e) {
          return Math.round(this.getFloatRange(t, e));
        }
        getFloatRange(t, e) {
          const n = e - t;
          return t + (this.getInt() / i._m) * n;
        }
      }
      function s(t, e, n) {
        if ((0, r.b)(t) && (0, r.b)(e)) return !0;
        if ((0, r.b)(t) || (0, r.b)(e) || t.length !== e.length) return !1;
        if (n) {
          for (let r = 0; r < t.length; r++) if (!n(t[r], e[r])) return !1;
        } else for (let n = 0; n < t.length; n++) if (t[n] !== e[n]) return !1;
        return !0;
      }
      (i._m = 2147483647), (i._a = 48271), (i._c = 0);
      const o = !!Array.prototype.fill;
      function a(t, e) {
        if (o) return new Array(t).fill(e);
        const n = new Array(t);
        for (let r = 0; r < t; r++) n[r] = e;
        return n;
      }
      function c(t, e) {
        void 0 === e && ((e = t), (t = 0));
        const n = new Array(e - t);
        for (let r = t; r < e; r++) n[r - t] = r;
        return n;
      }
      class u {
        constructor() {
          this.last = 0;
        }
      }
      const f = new u();
      function l(t, e, n, r) {
        r = r || f;
        const i = Math.max(0, r.last - 10);
        for (let s = i; s < n; ++s) if (t[s] === e) return (r.last = s), s;
        const s = Math.min(i, n);
        for (let n = 0; n < s; ++n) if (t[n] === e) return (r.last = n), n;
        return -1;
      }
      function h(t, e, n, r) {
        const i = null == n ? t.length : n,
          s = l(t, e, i, r);
        if (-1 !== s) return (t[s] = t[i - 1]), null == n && t.pop(), e;
      }
      const d = new Set();
      function p(t, e, n = t.length, r = e.length, i, s) {
        if (0 === r || 0 === n) return n;
        d.clear();
        for (let t = 0; t < r; ++t) d.add(e[t]);
        i = i || f;
        const o = Math.max(0, i.last - 10);
        for (let e = o; e < n; ++e)
          if (
            d.has(t[e]) &&
            (s && s.push(t[e]),
            d.delete(t[e]),
            (t[e] = t[n - 1]),
            --n,
            --e,
            0 === d.size || 0 === n)
          )
            return d.clear(), n;
        for (let e = 0; e < o; ++e)
          if (
            d.has(t[e]) &&
            (s && s.push(t[e]),
            d.delete(t[e]),
            (t[e] = t[n - 1]),
            --n,
            --e,
            0 === d.size || 0 === n)
          )
            return d.clear(), n;
        return d.clear(), n;
      }
      function g(t, e) {
        const n = t.indexOf(e);
        return -1 !== n ? (t.splice(n, 1), e) : null;
      }
      new i();
    },
    8358: (t, e, n) => {
      'use strict';
      n.d(e, { d: () => i });
      var r = n(82426);
      function i(t, e, n) {
        var i;
        const u = t.byteLength / (4 * e),
          f = new Uint32Array(t, 0, u * e);
        let l = new Uint32Array(u);
        const h = null != (i = null == n ? void 0 : n.minReduction) ? i : 0,
          d = (null == n ? void 0 : n.originalIndices) || null,
          p = d ? d.length : 0,
          g = (null == n ? void 0 : n.componentOffsets) || null;
        let m = 0;
        if (g)
          for (let t = 0; t < g.length - 1; t++) {
            const e = g[t + 1] - g[t];
            e > m && (m = e);
          }
        else m = u;
        const w = Math.floor(1.1 * m) + 1;
        (null == c || c.length < 2 * w) && (c = new Uint32Array((0, r.G)(2 * w)));
        for (let t = 0; t < 2 * w; t++) c[t] = 0;
        let M = 0;
        const b = !!g && !!d,
          y = b ? p : u,
          v = b ? new Uint32Array(p) : null,
          A = 1.96;
        let F = 0 !== h ? Math.ceil(((4 * A * A) / (h * h)) * h * (1 - h)) : y,
          I = 1,
          x = g ? g[1] : y;
        for (let t = 0; t < y; t++) {
          if (t === F) {
            const e = 1 - M / t;
            if (e + A * Math.sqrt((e * (1 - e)) / t) < h) return null;
            F *= 2;
          }
          if (t === x) {
            for (let t = 0; t < 2 * w; t++) c[t] = 0;
            if (d) for (let t = g[I - 1]; t < g[I]; t++) v[t] = l[d[t]];
            x = g[++I];
          }
          const n = b ? d[t] : t,
            r = n * e,
            i = a(f, r, e);
          let o = i % w,
            u = M;
          for (; 0 !== c[2 * o + 1]; ) {
            if (c[2 * o] === i) {
              const t = c[2 * o + 1] - 1;
              if (s(f, r, t * e, e)) {
                u = l[t];
                break;
              }
            }
            o++, o >= w && (o -= w);
          }
          u === M && ((c[2 * o] = i), (c[2 * o + 1] = n + 1), M++), (l[n] = u);
        }
        if (0 !== h && 1 - M / u < h) return null;
        if (b) {
          for (let t = g[I - 1]; t < v.length; t++) v[t] = l[d[t]];
          l = v;
        }
        const N = new Uint32Array(e * M);
        M = 0;
        for (let t = 0; t < y; t++) l[t] === M && (o(f, (b ? d[t] : t) * e, N, M * e, e), M++);
        if (d && !b) {
          const t = new Uint32Array(p);
          for (let e = 0; e < t.length; e++) t[e] = l[d[e]];
          l = t;
        }
        return { buffer: N.buffer, indices: l, uniqueCount: M };
      }
      function s(t, e, n, r) {
        for (let i = 0; i < r; i++) if (t[e + i] !== t[n + i]) return !1;
        return !0;
      }
      function o(t, e, n, r, i) {
        for (let s = 0; s < i; s++) n[r + s] = t[e + s];
      }
      function a(t, e, n) {
        let r = 0;
        for (let i = 0; i < n; i++) (r = (t[e + i] + r) | 0), (r = (r + (r << 11) + (r >>> 2)) | 0);
        return r >>> 0;
      }
      let c = null;
    },
    82426: (t, e, n) => {
      'use strict';
      function r() {
        return [0, 0, 0];
      }
      function i(t) {
        return [t[0], t[1], t[2]];
      }
      function s(t, e, n) {
        return [t, e, n];
      }
      function o(t) {
        const e = [0, 0, 0],
          n = Math.min(3, t.length);
        for (let r = 0; r < n; ++r) e[r] = t[r];
        return e;
      }
      function a(t, e) {
        return new Float64Array(t, e, 3);
      }
      n.d(e, {
        A: () => A,
        B: () => K,
        C: () => L,
        D: () => B,
        E: () => f,
        G: () => O,
        H: () => Z,
        I: () => W,
        O: () => u,
        R: () => l,
        S: () => $,
        T: () => o,
        Z: () => c,
        a: () => x,
        a4: () => M,
        a6: () => H,
        aa: () => j,
        b: () => r,
        c: () => G,
        d: () => I,
        e: () => p,
        f: () => b,
        g: () => g,
        h: () => N,
        i: () => X,
        j: () => d,
        k: () => J,
        l: () => h,
        m: () => Y,
        n: () => F,
        o: () => v,
        p: () => s,
        r: () => Q,
        s: () => m,
        t: () => E,
        u: () => i,
        w: () => y,
        x: () => _,
        y: () => a,
        z: () => k,
      });
      const c = [0, 0, 0],
        u = s(1, 1, 1),
        f = 1e-6,
        l = Math.random;
      function h(t) {
        const e = t[0],
          n = t[1],
          r = t[2];
        return Math.sqrt(e * e + n * n + r * r);
      }
      function d(t, e) {
        return (t[0] = e[0]), (t[1] = e[1]), (t[2] = e[2]), t;
      }
      function p(t, e, n, r) {
        return (t[0] = e), (t[1] = n), (t[2] = r), t;
      }
      function g(t, e, n) {
        return (t[0] = e[0] + n[0]), (t[1] = e[1] + n[1]), (t[2] = e[2] + n[2]), t;
      }
      function m(t, e, n) {
        return (t[0] = e[0] - n[0]), (t[1] = e[1] - n[1]), (t[2] = e[2] - n[2]), t;
      }
      function w(t, e, n) {
        return (t[0] = e[0] * n[0]), (t[1] = e[1] * n[1]), (t[2] = e[2] * n[2]), t;
      }
      function M(t, e, n) {
        return (t[0] = e[0] / n[0]), (t[1] = e[1] / n[1]), (t[2] = e[2] / n[2]), t;
      }
      function b(t, e, n) {
        return (t[0] = e[0] * n), (t[1] = e[1] * n), (t[2] = e[2] * n), t;
      }
      function y(t, e) {
        const n = e[0] - t[0],
          r = e[1] - t[1],
          i = e[2] - t[2];
        return Math.sqrt(n * n + r * r + i * i);
      }
      function v(t, e) {
        const n = e[0] - t[0],
          r = e[1] - t[1],
          i = e[2] - t[2];
        return n * n + r * r + i * i;
      }
      function A(t) {
        const e = t[0],
          n = t[1],
          r = t[2];
        return e * e + n * n + r * r;
      }
      function F(t, e) {
        const n = e[0],
          r = e[1],
          i = e[2];
        let s = n * n + r * r + i * i;
        return (
          s > 0 &&
            ((s = 1 / Math.sqrt(s)), (t[0] = e[0] * s), (t[1] = e[1] * s), (t[2] = e[2] * s)),
          t
        );
      }
      function I(t, e) {
        return t[0] * e[0] + t[1] * e[1] + t[2] * e[2];
      }
      function x(t, e, n) {
        const r = e[0],
          i = e[1],
          s = e[2],
          o = n[0],
          a = n[1],
          c = n[2];
        return (t[0] = i * c - s * a), (t[1] = s * o - r * c), (t[2] = r * a - i * o), t;
      }
      function N(t, e, n, r) {
        const i = e[0],
          s = e[1],
          o = e[2];
        return (
          (t[0] = i + r * (n[0] - i)), (t[1] = s + r * (n[1] - s)), (t[2] = o + r * (n[2] - o)), t
        );
      }
      function E(t, e, n) {
        const r = e[0],
          i = e[1],
          s = e[2];
        return (
          (t[0] = n[0] * r + n[4] * i + n[8] * s + n[12]),
          (t[1] = n[1] * r + n[5] * i + n[9] * s + n[13]),
          (t[2] = n[2] * r + n[6] * i + n[10] * s + n[14]),
          t
        );
      }
      function _(t, e, n) {
        const r = e[0],
          i = e[1],
          s = e[2];
        return (
          (t[0] = r * n[0] + i * n[3] + s * n[6]),
          (t[1] = r * n[1] + i * n[4] + s * n[7]),
          (t[2] = r * n[2] + i * n[5] + s * n[8]),
          t
        );
      }
      function L(t, e, n) {
        const r = n[0],
          i = n[1],
          s = n[2],
          o = n[3],
          a = e[0],
          c = e[1],
          u = e[2];
        let f = i * u - s * c,
          l = s * a - r * u,
          h = r * c - i * a,
          d = i * h - s * l,
          p = s * f - r * h,
          g = r * l - i * f;
        const m = 2 * o;
        return (
          (f *= m),
          (l *= m),
          (h *= m),
          (d *= 2),
          (p *= 2),
          (g *= 2),
          (t[0] = a + f + d),
          (t[1] = c + l + p),
          (t[2] = u + h + g),
          t
        );
      }
      Math.PI, Math.PI;
      const S = [0, 0, 0],
        U = [0, 0, 0];
      function k(t, e) {
        return t[0] === e[0] && t[1] === e[1] && t[2] === e[2];
      }
      function B(t, e, n) {
        const r = n[0] - e[0],
          i = n[1] - e[1],
          s = n[2] - e[2];
        let o = r * r + i * i + s * s;
        return o > 0
          ? ((o = 1 / Math.sqrt(o)), (t[0] = r * o), (t[1] = i * o), (t[2] = s * o), t)
          : ((t[0] = 0), (t[1] = 0), (t[2] = 0), t);
      }
      const V = m,
        q = w,
        D = M,
        z = y,
        C = v,
        P = h,
        R = A;
      Object.freeze({
        __proto__: null,
        length: h,
        copy: d,
        set: p,
        add: g,
        subtract: m,
        multiply: w,
        divide: M,
        ceil: function (t, e) {
          return (t[0] = Math.ceil(e[0])), (t[1] = Math.ceil(e[1])), (t[2] = Math.ceil(e[2])), t;
        },
        floor: function (t, e) {
          return (t[0] = Math.floor(e[0])), (t[1] = Math.floor(e[1])), (t[2] = Math.floor(e[2])), t;
        },
        min: function (t, e, n) {
          return (
            (t[0] = Math.min(e[0], n[0])),
            (t[1] = Math.min(e[1], n[1])),
            (t[2] = Math.min(e[2], n[2])),
            t
          );
        },
        max: function (t, e, n) {
          return (
            (t[0] = Math.max(e[0], n[0])),
            (t[1] = Math.max(e[1], n[1])),
            (t[2] = Math.max(e[2], n[2])),
            t
          );
        },
        round: function (t, e) {
          return (t[0] = Math.round(e[0])), (t[1] = Math.round(e[1])), (t[2] = Math.round(e[2])), t;
        },
        scale: b,
        scaleAndAdd: function (t, e, n, r) {
          return (t[0] = e[0] + n[0] * r), (t[1] = e[1] + n[1] * r), (t[2] = e[2] + n[2] * r), t;
        },
        distance: y,
        squaredDistance: v,
        squaredLength: A,
        negate: function (t, e) {
          return (t[0] = -e[0]), (t[1] = -e[1]), (t[2] = -e[2]), t;
        },
        inverse: function (t, e) {
          return (t[0] = 1 / e[0]), (t[1] = 1 / e[1]), (t[2] = 1 / e[2]), t;
        },
        normalize: F,
        dot: I,
        cross: x,
        lerp: N,
        hermite: function (t, e, n, r, i, s) {
          const o = s * s,
            a = o * (2 * s - 3) + 1,
            c = o * (s - 2) + s,
            u = o * (s - 1),
            f = o * (3 - 2 * s);
          return (
            (t[0] = e[0] * a + n[0] * c + r[0] * u + i[0] * f),
            (t[1] = e[1] * a + n[1] * c + r[1] * u + i[1] * f),
            (t[2] = e[2] * a + n[2] * c + r[2] * u + i[2] * f),
            t
          );
        },
        bezier: function (t, e, n, r, i, s) {
          const o = 1 - s,
            a = o * o,
            c = s * s,
            u = a * o,
            f = 3 * s * a,
            l = 3 * c * o,
            h = c * s;
          return (
            (t[0] = e[0] * u + n[0] * f + r[0] * l + i[0] * h),
            (t[1] = e[1] * u + n[1] * f + r[1] * l + i[1] * h),
            (t[2] = e[2] * u + n[2] * f + r[2] * l + i[2] * h),
            t
          );
        },
        random: function (t, e) {
          e = e || 1;
          const n = 2 * l() * Math.PI,
            r = 2 * l() - 1,
            i = Math.sqrt(1 - r * r) * e;
          return (t[0] = Math.cos(n) * i), (t[1] = Math.sin(n) * i), (t[2] = r * e), t;
        },
        transformMat4: E,
        transformMat3: _,
        transformQuat: L,
        rotateX: function (t, e, n, r) {
          const i = [],
            s = [];
          return (
            (i[0] = e[0] - n[0]),
            (i[1] = e[1] - n[1]),
            (i[2] = e[2] - n[2]),
            (s[0] = i[0]),
            (s[1] = i[1] * Math.cos(r) - i[2] * Math.sin(r)),
            (s[2] = i[1] * Math.sin(r) + i[2] * Math.cos(r)),
            (t[0] = s[0] + n[0]),
            (t[1] = s[1] + n[1]),
            (t[2] = s[2] + n[2]),
            t
          );
        },
        rotateY: function (t, e, n, r) {
          const i = [],
            s = [];
          return (
            (i[0] = e[0] - n[0]),
            (i[1] = e[1] - n[1]),
            (i[2] = e[2] - n[2]),
            (s[0] = i[2] * Math.sin(r) + i[0] * Math.cos(r)),
            (s[1] = i[1]),
            (s[2] = i[2] * Math.cos(r) - i[0] * Math.sin(r)),
            (t[0] = s[0] + n[0]),
            (t[1] = s[1] + n[1]),
            (t[2] = s[2] + n[2]),
            t
          );
        },
        rotateZ: function (t, e, n, r) {
          const i = [],
            s = [];
          return (
            (i[0] = e[0] - n[0]),
            (i[1] = e[1] - n[1]),
            (i[2] = e[2] - n[2]),
            (s[0] = i[0] * Math.cos(r) - i[1] * Math.sin(r)),
            (s[1] = i[0] * Math.sin(r) + i[1] * Math.cos(r)),
            (s[2] = i[2]),
            (t[0] = s[0] + n[0]),
            (t[1] = s[1] + n[1]),
            (t[2] = s[2] + n[2]),
            t
          );
        },
        angle: function (t, e) {
          d(S, t), d(U, e), F(S, S), F(U, U);
          const n = I(S, U);
          return n > 1 ? 0 : n < -1 ? Math.PI : Math.acos(n);
        },
        str: function (t) {
          return 'vec3(' + t[0] + ', ' + t[1] + ', ' + t[2] + ')';
        },
        exactEquals: k,
        equals: function (t, e) {
          const n = t[0],
            r = t[1],
            i = t[2],
            s = e[0],
            o = e[1],
            a = e[2];
          return (
            Math.abs(n - s) <= 1e-6 * Math.max(1, Math.abs(n), Math.abs(s)) &&
            Math.abs(r - o) <= 1e-6 * Math.max(1, Math.abs(r), Math.abs(o)) &&
            Math.abs(i - a) <= 1e-6 * Math.max(1, Math.abs(i), Math.abs(a))
          );
        },
        direction: B,
        sub: V,
        mul: q,
        div: D,
        dist: z,
        sqrDist: C,
        len: P,
        sqrLen: R,
      });
      const T = new Float32Array(1),
        W =
          Number.isFinite ||
          function (t) {
            return 'number' == typeof t && window.isFinite(t);
          },
        j =
          Number.isNaN ||
          function (t) {
            return t != t;
          };
      function O(t) {
        --t;
        for (let e = 1; e < 32; e <<= 1) t |= t >> e;
        return t + 1;
      }
      function G(t, e, n) {
        return Math.min(Math.max(t, e), n);
      }
      function H(t) {
        return 0 == (t & (t - 1));
      }
      Math.sign;
      const Z =
        Math.log2 ||
        function (t) {
          return Math.log(t) / Math.LN2;
        };
      function $(t, e, n) {
        return t + (e - t) * n;
      }
      function J(t) {
        return (t * Math.PI) / 180;
      }
      function Q(t) {
        return (180 * t) / Math.PI;
      }
      function X(t) {
        return Math.acos(G(t, -1, 1));
      }
      function Y(t) {
        return Math.asin(G(t, -1, 1));
      }
      function K(t, e) {
        const n = h(t);
        return p(e, n, Y(t[2] / n), Math.atan2(t[1] / n, t[0] / n)), e;
      }
      !(function (t) {
        (T[0] = t), T[0];
      })(34028234663852886e22);
    },
    27726: (t, e, n) => {
      'use strict';
      function r(t) {
        switch (t) {
          case 'u8':
            return 1;
          case 'u16':
            return 2;
          case 'u32':
            return 4;
          case 'i8':
            return 1;
          case 'i16':
            return 2;
          case 'i32':
          case 'f32':
            return 4;
          case 'f64':
            return 8;
          default:
            return;
        }
      }
      function i(t) {
        switch (t) {
          case 'u8':
          case 'u16':
          case 'u32':
            return !1;
          case 'i8':
          case 'i16':
          case 'i32':
          case 'f32':
          case 'f64':
            return !0;
          default:
            return;
        }
      }
      function s(t) {
        switch (t) {
          case 'u8':
          case 'u16':
          case 'u32':
          case 'i8':
          case 'i16':
          case 'i32':
            return !0;
          case 'f32':
          case 'f64':
            return !1;
          default:
            return;
        }
      }
      function o(t) {
        switch (t) {
          case 'u8':
            return 255;
          case 'u16':
            return 65535;
          case 'u32':
            return 4294967295;
          case 'i8':
            return 127;
          case 'i16':
            return 32767;
          case 'i32':
            return 2147483647;
          case 'f32':
            return 3402823e32;
          case 'f64':
            return 179769e303;
          default:
            return;
        }
      }
      n.d(e, { a: () => i, e: () => r, i: () => s, m: () => o }), n(76506);
    },
  },
]);
