ss-component-new 1.1.1007 → 1.2.1

package/dist/STLLoader-memlq1bT.js

@@ -0,0 +1,609 @@
+import { y as J, F as W, C as P, o as re, p as T, ax as M, ab as E, aa as Y, a9 as R, h as se, af as Z, ah as H, e as X, V as I, z as ne, au as ie, a6 as oe, J as K, aD as ae, Y as le, b as ce, _ as N } from "./three-viewport-gizmo-BxFHxv_x.js";
+const he = /^[og]\s*(.+)?/, ue = /^mtllib /, pe = /^usemtl /, fe = /^usemap /, Q = /\s+/, $ = new I(), q = new I(), ee = new I(), te = new I(), F = new I(), B = new P();
+function de() {
+  const S = {
+    objects: [],
+    object: {},
+    vertices: [],
+    normals: [],
+    colors: [],
+    uvs: [],
+    materials: {},
+    materialLibraries: [],
+    startObject: function(e, s) {
+      if (this.object && this.object.fromDeclaration === !1) {
+        this.object.name = e, this.object.fromDeclaration = s !== !1;
+        return;
+      }
+      const i = this.object && typeof this.object.currentMaterial == "function" ? this.object.currentMaterial() : void 0;
+      if (this.object && typeof this.object._finalize == "function" && this.object._finalize(!0), this.object = {
+        name: e || "",
+        fromDeclaration: s !== !1,
+        geometry: {
+          vertices: [],
+          normals: [],
+          colors: [],
+          uvs: [],
+          hasUVIndices: !1
+        },
+        materials: [],
+        smooth: !0,
+        startMaterial: function(t, r) {
+          const h = this._finalize(!1);
+          h && (h.inherited || h.groupCount <= 0) && this.materials.splice(h.index, 1);
+          const c = {
+            index: this.materials.length,
+            name: t || "",
+            mtllib: Array.isArray(r) && r.length > 0 ? r[r.length - 1] : "",
+            smooth: h !== void 0 ? h.smooth : this.smooth,
+            groupStart: h !== void 0 ? h.groupEnd : 0,
+            groupEnd: -1,
+            groupCount: -1,
+            inherited: !1,
+            clone: function(l) {
+              const n = {
+                index: typeof l == "number" ? l : this.index,
+                name: this.name,
+                mtllib: this.mtllib,
+                smooth: this.smooth,
+                groupStart: 0,
+                groupEnd: -1,
+                groupCount: -1,
+                inherited: !1
+              };
+              return n.clone = this.clone.bind(n), n;
+            }
+          };
+          return this.materials.push(c), c;
+        },
+        currentMaterial: function() {
+          if (this.materials.length > 0)
+            return this.materials[this.materials.length - 1];
+        },
+        _finalize: function(t) {
+          const r = this.currentMaterial();
+          if (r && r.groupEnd === -1 && (r.groupEnd = this.geometry.vertices.length / 3, r.groupCount = r.groupEnd - r.groupStart, r.inherited = !1), t && this.materials.length > 1)
+            for (let h = this.materials.length - 1; h >= 0; h--)
+              this.materials[h].groupCount <= 0 && this.materials.splice(h, 1);
+          return t && this.materials.length === 0 && this.materials.push({
+            name: "",
+            smooth: this.smooth
+          }), r;
+        }
+      }, i && i.name && typeof i.clone == "function") {
+        const t = i.clone(0);
+        t.inherited = !0, this.object.materials.push(t);
+      }
+      this.objects.push(this.object);
+    },
+    finalize: function() {
+      this.object && typeof this.object._finalize == "function" && this.object._finalize(!0);
+    },
+    parseVertexIndex: function(e, s) {
+      const i = parseInt(e, 10);
+      return (i >= 0 ? i - 1 : i + s / 3) * 3;
+    },
+    parseNormalIndex: function(e, s) {
+      const i = parseInt(e, 10);
+      return (i >= 0 ? i - 1 : i + s / 3) * 3;
+    },
+    parseUVIndex: function(e, s) {
+      const i = parseInt(e, 10);
+      return (i >= 0 ? i - 1 : i + s / 2) * 2;
+    },
+    addVertex: function(e, s, i) {
+      const t = this.vertices, r = this.object.geometry.vertices;
+      r.push(t[e + 0], t[e + 1], t[e + 2]), r.push(t[s + 0], t[s + 1], t[s + 2]), r.push(t[i + 0], t[i + 1], t[i + 2]);
+    },
+    addVertexPoint: function(e) {
+      const s = this.vertices;
+      this.object.geometry.vertices.push(s[e + 0], s[e + 1], s[e + 2]);
+    },
+    addVertexLine: function(e) {
+      const s = this.vertices;
+      this.object.geometry.vertices.push(s[e + 0], s[e + 1], s[e + 2]);
+    },
+    addNormal: function(e, s, i) {
+      const t = this.normals, r = this.object.geometry.normals;
+      r.push(t[e + 0], t[e + 1], t[e + 2]), r.push(t[s + 0], t[s + 1], t[s + 2]), r.push(t[i + 0], t[i + 1], t[i + 2]);
+    },
+    addFaceNormal: function(e, s, i) {
+      const t = this.vertices, r = this.object.geometry.normals;
+      $.fromArray(t, e), q.fromArray(t, s), ee.fromArray(t, i), F.subVectors(ee, q), te.subVectors($, q), F.cross(te), F.normalize(), r.push(F.x, F.y, F.z), r.push(F.x, F.y, F.z), r.push(F.x, F.y, F.z);
+    },
+    addColor: function(e, s, i) {
+      const t = this.colors, r = this.object.geometry.colors;
+      t[e] !== void 0 && r.push(t[e + 0], t[e + 1], t[e + 2]), t[s] !== void 0 && r.push(t[s + 0], t[s + 1], t[s + 2]), t[i] !== void 0 && r.push(t[i + 0], t[i + 1], t[i + 2]);
+    },
+    addUV: function(e, s, i) {
+      const t = this.uvs, r = this.object.geometry.uvs;
+      r.push(t[e + 0], t[e + 1]), r.push(t[s + 0], t[s + 1]), r.push(t[i + 0], t[i + 1]);
+    },
+    addDefaultUV: function() {
+      const e = this.object.geometry.uvs;
+      e.push(0, 0), e.push(0, 0), e.push(0, 0);
+    },
+    addUVLine: function(e) {
+      const s = this.uvs;
+      this.object.geometry.uvs.push(s[e + 0], s[e + 1]);
+    },
+    addFace: function(e, s, i, t, r, h, c, l, n) {
+      const o = this.vertices.length;
+      let a = this.parseVertexIndex(e, o), u = this.parseVertexIndex(s, o), d = this.parseVertexIndex(i, o);
+      if (this.addVertex(a, u, d), this.addColor(a, u, d), c !== void 0 && c !== "") {
+        const m = this.normals.length;
+        a = this.parseNormalIndex(c, m), u = this.parseNormalIndex(l, m), d = this.parseNormalIndex(n, m), this.addNormal(a, u, d);
+      } else
+        this.addFaceNormal(a, u, d);
+      if (t !== void 0 && t !== "") {
+        const m = this.uvs.length;
+        a = this.parseUVIndex(t, m), u = this.parseUVIndex(r, m), d = this.parseUVIndex(h, m), this.addUV(a, u, d), this.object.geometry.hasUVIndices = !0;
+      } else
+        this.addDefaultUV();
+    },
+    addPointGeometry: function(e) {
+      this.object.geometry.type = "Points";
+      const s = this.vertices.length;
+      for (let i = 0, t = e.length; i < t; i++) {
+        const r = this.parseVertexIndex(e[i], s);
+        this.addVertexPoint(r), this.addColor(r);
+      }
+    },
+    addLineGeometry: function(e, s) {
+      this.object.geometry.type = "Line";
+      const i = this.vertices.length, t = this.uvs.length;
+      for (let r = 0, h = e.length; r < h; r++)
+        this.addVertexLine(this.parseVertexIndex(e[r], i));
+      for (let r = 0, h = s.length; r < h; r++)
+        this.addUVLine(this.parseUVIndex(s[r], t));
+    }
+  };
+  return S.startObject("", !1), S;
+}
+class be extends J {
+  constructor(e) {
+    super(e), this.materials = null;
+  }
+  load(e, s, i, t) {
+    const r = this, h = new W(this.manager);
+    h.setPath(this.path), h.setRequestHeader(this.requestHeader), h.setWithCredentials(this.withCredentials), h.load(e, function(c) {
+      try {
+        s(r.parse(c));
+      } catch (l) {
+        t ? t(l) : console.error(l), r.manager.itemError(e);
+      }
+    }, i, t);
+  }
+  setMaterials(e) {
+    return this.materials = e, this;
+  }
+  parse(e) {
+    const s = new de();
+    e.indexOf(`\r
+`) !== -1 && (e = e.replace(/\r\n/g, `
+`)), e.indexOf(`\\
+`) !== -1 && (e = e.replace(/\\\n/g, ""));
+    const i = e.split(`
+`);
+    let t = [];
+    for (let c = 0, l = i.length; c < l; c++) {
+      const n = i[c].trimStart();
+      if (n.length === 0) continue;
+      const o = n.charAt(0);
+      if (o !== "#")
+        if (o === "v") {
+          const a = n.split(Q);
+          switch (a[0]) {
+            case "v":
+              s.vertices.push(
+                parseFloat(a[1]),
+                parseFloat(a[2]),
+                parseFloat(a[3])
+              ), a.length >= 7 ? (B.setRGB(
+                parseFloat(a[4]),
+                parseFloat(a[5]),
+                parseFloat(a[6])
+              ).convertSRGBToLinear(), s.colors.push(B.r, B.g, B.b)) : s.colors.push(void 0, void 0, void 0);
+              break;
+            case "vn":
+              s.normals.push(
+                parseFloat(a[1]),
+                parseFloat(a[2]),
+                parseFloat(a[3])
+              );
+              break;
+            case "vt":
+              s.uvs.push(
+                parseFloat(a[1]),
+                parseFloat(a[2])
+              );
+              break;
+          }
+        } else if (o === "f") {
+          const u = n.slice(1).trim().split(Q), d = [];
+          for (let p = 0, g = u.length; p < g; p++) {
+            const b = u[p];
+            if (b.length > 0) {
+              const x = b.split("/");
+              d.push(x);
+            }
+          }
+          const m = d[0];
+          for (let p = 1, g = d.length - 1; p < g; p++) {
+            const b = d[p], x = d[p + 1];
+            s.addFace(
+              m[0],
+              b[0],
+              x[0],
+              m[1],
+              b[1],
+              x[1],
+              m[2],
+              b[2],
+              x[2]
+            );
+          }
+        } else if (o === "l") {
+          const a = n.substring(1).trim().split(" ");
+          let u = [];
+          const d = [];
+          if (n.indexOf("/") === -1)
+            u = a;
+          else
+            for (let m = 0, p = a.length; m < p; m++) {
+              const g = a[m].split("/");
+              g[0] !== "" && u.push(g[0]), g[1] !== "" && d.push(g[1]);
+            }
+          s.addLineGeometry(u, d);
+        } else if (o === "p") {
+          const u = n.slice(1).trim().split(" ");
+          s.addPointGeometry(u);
+        } else if ((t = he.exec(n)) !== null) {
+          const a = (" " + t[0].slice(1).trim()).slice(1);
+          s.startObject(a);
+        } else if (pe.test(n))
+          s.object.startMaterial(n.substring(7).trim(), s.materialLibraries);
+        else if (ue.test(n))
+          s.materialLibraries.push(n.substring(7).trim());
+        else if (fe.test(n))
+          console.warn('THREE.OBJLoader: Rendering identifier "usemap" not supported. Textures must be defined in MTL files.');
+        else if (o === "s") {
+          if (t = n.split(" "), t.length > 1) {
+            const u = t[1].trim().toLowerCase();
+            s.object.smooth = u !== "0" && u !== "off";
+          } else
+            s.object.smooth = !0;
+          const a = s.object.currentMaterial();
+          a && (a.smooth = s.object.smooth);
+        } else {
+          if (n === "\0") continue;
+          console.warn('THREE.OBJLoader: Unexpected line: "' + n + '"');
+        }
+    }
+    s.finalize();
+    const r = new re();
+    if (r.materialLibraries = [].concat(s.materialLibraries), !(s.objects.length === 1 && s.objects[0].geometry.vertices.length === 0) === !0)
+      for (let c = 0, l = s.objects.length; c < l; c++) {
+        const n = s.objects[c], o = n.geometry, a = n.materials, u = o.type === "Line", d = o.type === "Points";
+        let m = !1;
+        if (o.vertices.length === 0) continue;
+        const p = new T();
+        p.setAttribute("position", new M(o.vertices, 3)), o.normals.length > 0 && p.setAttribute("normal", new M(o.normals, 3)), o.colors.length > 0 && (m = !0, p.setAttribute("color", new M(o.colors, 3))), o.hasUVIndices === !0 && p.setAttribute("uv", new M(o.uvs, 2));
+        const g = [];
+        for (let x = 0, C = a.length; x < C; x++) {
+          const v = a[x], j = v.name + "_" + v.smooth + "_" + m;
+          let f = s.materials[j];
+          if (this.materials !== null) {
+            if (f = this.materials.create(v.name), u && f && !(f instanceof E)) {
+              const w = new E();
+              Y.prototype.copy.call(w, f), w.color.copy(f.color), f = w;
+            } else if (d && f && !(f instanceof R)) {
+              const w = new R({ size: 10, sizeAttenuation: !1 });
+              Y.prototype.copy.call(w, f), w.color.copy(f.color), w.map = f.map, f = w;
+            }
+          }
+          f === void 0 && (u ? f = new E() : d ? f = new R({ size: 1, sizeAttenuation: !1 }) : f = new se(), f.name = v.name, f.flatShading = !v.smooth, f.vertexColors = m, s.materials[j] = f), g.push(f);
+        }
+        let b;
+        if (g.length > 1) {
+          for (let x = 0, C = a.length; x < C; x++) {
+            const v = a[x];
+            p.addGroup(v.groupStart, v.groupCount, x);
+          }
+          u ? b = new Z(p, g) : d ? b = new H(p, g) : b = new X(p, g);
+        } else
+          u ? b = new Z(p, g[0]) : d ? b = new H(p, g[0]) : b = new X(p, g[0]);
+        b.name = n.name, r.add(b);
+      }
+    else if (s.vertices.length > 0) {
+      const c = new R({ size: 1, sizeAttenuation: !1 }), l = new T();
+      l.setAttribute("position", new M(s.vertices, 3)), s.colors.length > 0 && s.colors[0] !== void 0 && (l.setAttribute("color", new M(s.colors, 3)), c.vertexColors = !0);
+      const n = new H(l, c);
+      r.add(n);
+    }
+    return r;
+  }
+}
+class xe extends J {
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * Loads and parses a MTL asset from a URL.
+   *
+   * @param {String} url - URL to the MTL file.
+   * @param {Function} [onLoad] - Callback invoked with the loaded object.
+   * @param {Function} [onProgress] - Callback for download progress.
+   * @param {Function} [onError] - Callback for download errors.
+   *
+   * @see setPath setResourcePath
+   *
+   * @note In order for relative texture references to resolve correctly
+   * you must call setResourcePath() explicitly prior to load.
+   */
+  load(e, s, i, t) {
+    const r = this, h = this.path === "" ? ne.extractUrlBase(e) : this.path, c = new W(this.manager);
+    c.setPath(this.path), c.setRequestHeader(this.requestHeader), c.setWithCredentials(this.withCredentials), c.load(e, function(l) {
+      try {
+        s(r.parse(l, h));
+      } catch (n) {
+        t ? t(n) : console.error(n), r.manager.itemError(e);
+      }
+    }, i, t);
+  }
+  setMaterialOptions(e) {
+    return this.materialOptions = e, this;
+  }
+  /**
+   * Parses a MTL file.
+   *
+   * @param {String} text - Content of MTL file
+   * @return {MaterialCreator}
+   *
+   * @see setPath setResourcePath
+   *
+   * @note In order for relative texture references to resolve correctly
+   * you must call setResourcePath() explicitly prior to parse.
+   */
+  parse(e, s) {
+    const i = e.split(`
+`);
+    let t = {};
+    const r = /\s+/, h = {};
+    for (let l = 0; l < i.length; l++) {
+      let n = i[l];
+      if (n = n.trim(), n.length === 0 || n.charAt(0) === "#")
+        continue;
+      const o = n.indexOf(" ");
+      let a = o >= 0 ? n.substring(0, o) : n;
+      a = a.toLowerCase();
+      let u = o >= 0 ? n.substring(o + 1) : "";
+      if (u = u.trim(), a === "newmtl")
+        t = { name: u }, h[u] = t;
+      else if (a === "ka" || a === "kd" || a === "ks" || a === "ke") {
+        const d = u.split(r, 3);
+        t[a] = [parseFloat(d[0]), parseFloat(d[1]), parseFloat(d[2])];
+      } else
+        t[a] = u;
+    }
+    const c = new me(this.resourcePath || s, this.materialOptions);
+    return c.setCrossOrigin(this.crossOrigin), c.setManager(this.manager), c.setMaterials(h), c;
+  }
+}
+class me {
+  constructor(e = "", s = {}) {
+    this.baseUrl = e, this.options = s, this.materialsInfo = {}, this.materials = {}, this.materialsArray = [], this.nameLookup = {}, this.crossOrigin = "anonymous", this.side = this.options.side !== void 0 ? this.options.side : ie, this.wrap = this.options.wrap !== void 0 ? this.options.wrap : oe;
+  }
+  setCrossOrigin(e) {
+    return this.crossOrigin = e, this;
+  }
+  setManager(e) {
+    this.manager = e;
+  }
+  setMaterials(e) {
+    this.materialsInfo = this.convert(e), this.materials = {}, this.materialsArray = [], this.nameLookup = {};
+  }
+  convert(e) {
+    if (!this.options) return e;
+    const s = {};
+    for (const i in e) {
+      const t = e[i], r = {};
+      s[i] = r;
+      for (const h in t) {
+        let c = !0, l = t[h];
+        const n = h.toLowerCase();
+        switch (n) {
+          case "kd":
+          case "ka":
+          case "ks":
+            this.options && this.options.normalizeRGB && (l = [l[0] / 255, l[1] / 255, l[2] / 255]), this.options && this.options.ignoreZeroRGBs && l[0] === 0 && l[1] === 0 && l[2] === 0 && (c = !1);
+            break;
+        }
+        c && (r[n] = l);
+      }
+    }
+    return s;
+  }
+  preload() {
+    for (const e in this.materialsInfo)
+      this.create(e);
+  }
+  getIndex(e) {
+    return this.nameLookup[e];
+  }
+  getAsArray() {
+    let e = 0;
+    for (const s in this.materialsInfo)
+      this.materialsArray[e] = this.create(s), this.nameLookup[s] = e, e++;
+    return this.materialsArray;
+  }
+  create(e) {
+    return this.materials[e] === void 0 && this.createMaterial_(e), this.materials[e];
+  }
+  createMaterial_(e) {
+    const s = this, i = this.materialsInfo[e], t = {
+      name: e,
+      side: this.side
+    };
+    function r(c, l) {
+      return typeof l != "string" || l === "" ? "" : /^https?:\/\//i.test(l) ? l : c + l;
+    }
+    function h(c, l) {
+      if (t[c]) return;
+      const n = s.getTextureParams(l, t), o = s.loadTexture(r(s.baseUrl, n.url));
+      o.repeat.copy(n.scale), o.offset.copy(n.offset), o.wrapS = s.wrap, o.wrapT = s.wrap, (c === "map" || c === "emissiveMap") && (o.colorSpace = ce), t[c] = o;
+    }
+    for (const c in i) {
+      const l = i[c];
+      let n;
+      if (l !== "")
+        switch (c.toLowerCase()) {
+          // Ns is material specular exponent
+          case "kd":
+            t.color = new P().fromArray(l).convertSRGBToLinear();
+            break;
+          case "ks":
+            t.specular = new P().fromArray(l).convertSRGBToLinear();
+            break;
+          case "ke":
+            t.emissive = new P().fromArray(l).convertSRGBToLinear();
+            break;
+          case "map_kd":
+            h("map", l);
+            break;
+          case "map_ks":
+            h("specularMap", l);
+            break;
+          case "map_ke":
+            h("emissiveMap", l);
+            break;
+          case "norm":
+            h("normalMap", l);
+            break;
+          case "map_bump":
+          case "bump":
+            h("bumpMap", l);
+            break;
+          case "map_d":
+            h("alphaMap", l), t.transparent = !0;
+            break;
+          case "ns":
+            t.shininess = parseFloat(l);
+            break;
+          case "d":
+            n = parseFloat(l), n < 1 && (t.opacity = n, t.transparent = !0);
+            break;
+          case "tr":
+            n = parseFloat(l), this.options && this.options.invertTrProperty && (n = 1 - n), n > 0 && (t.opacity = 1 - n, t.transparent = !0);
+            break;
+        }
+    }
+    return this.materials[e] = new se(t), this.materials[e];
+  }
+  getTextureParams(e, s) {
+    const i = {
+      scale: new K(1, 1),
+      offset: new K(0, 0)
+    }, t = e.split(/\s+/);
+    let r;
+    return r = t.indexOf("-bm"), r >= 0 && (s.bumpScale = parseFloat(t[r + 1]), t.splice(r, 2)), r = t.indexOf("-s"), r >= 0 && (i.scale.set(parseFloat(t[r + 1]), parseFloat(t[r + 2])), t.splice(r, 4)), r = t.indexOf("-o"), r >= 0 && (i.offset.set(parseFloat(t[r + 1]), parseFloat(t[r + 2])), t.splice(r, 4)), i.url = t.join(" ").trim(), i;
+  }
+  loadTexture(e, s, i, t, r) {
+    const h = this.manager !== void 0 ? this.manager : ae;
+    let c = h.getHandler(e);
+    c === null && (c = new le(h)), c.setCrossOrigin && c.setCrossOrigin(this.crossOrigin);
+    const l = c.load(e, i, t, r);
+    return s !== void 0 && (l.mapping = s), l;
+  }
+}
+class we extends J {
+  constructor(e) {
+    super(e);
+  }
+  load(e, s, i, t) {
+    const r = this, h = new W(this.manager);
+    h.setPath(this.path), h.setResponseType("arraybuffer"), h.setRequestHeader(this.requestHeader), h.setWithCredentials(this.withCredentials), h.load(e, function(c) {
+      try {
+        s(r.parse(c));
+      } catch (l) {
+        t ? t(l) : console.error(l), r.manager.itemError(e);
+      }
+    }, i, t);
+  }
+  parse(e) {
+    function s(n) {
+      const o = new DataView(n), a = 32 / 8 * 3 + 32 / 8 * 3 * 3 + 16 / 8, u = o.getUint32(80, !0);
+      if (80 + 32 / 8 + u * a === o.byteLength)
+        return !0;
+      const m = [115, 111, 108, 105, 100];
+      for (let p = 0; p < 5; p++)
+        if (i(m, o, p)) return !1;
+      return !0;
+    }
+    function i(n, o, a) {
+      for (let u = 0, d = n.length; u < d; u++)
+        if (n[u] !== o.getUint8(a + u)) return !1;
+      return !0;
+    }
+    function t(n) {
+      const o = new DataView(n), a = o.getUint32(80, !0);
+      let u, d, m, p = !1, g, b, x, C, v;
+      for (let y = 0; y < 70; y++)
+        o.getUint32(y, !1) == 1129270351 && o.getUint8(y + 4) == 82 && o.getUint8(y + 5) == 61 && (p = !0, g = new Float32Array(a * 3 * 3), b = o.getUint8(y + 6) / 255, x = o.getUint8(y + 7) / 255, C = o.getUint8(y + 8) / 255, v = o.getUint8(y + 9) / 255);
+      const j = 84, f = 12 * 4 + 2, w = new T(), V = new Float32Array(a * 3 * 3), A = new Float32Array(a * 3 * 3), k = new P();
+      for (let y = 0; y < a; y++) {
+        const U = j + y * f, D = o.getFloat32(U, !0), O = o.getFloat32(U + 4, !0), z = o.getFloat32(U + 8, !0);
+        if (p) {
+          const L = o.getUint16(U + 48, !0);
+          (L & 32768) === 0 ? (u = (L & 31) / 31, d = (L >> 5 & 31) / 31, m = (L >> 10 & 31) / 31) : (u = b, d = x, m = C);
+        }
+        for (let L = 1; L <= 3; L++) {
+          const G = U + L * 12, _ = y * 3 * 3 + (L - 1) * 3;
+          V[_] = o.getFloat32(G, !0), V[_ + 1] = o.getFloat32(G + 4, !0), V[_ + 2] = o.getFloat32(G + 8, !0), A[_] = D, A[_ + 1] = O, A[_ + 2] = z, p && (k.set(u, d, m).convertSRGBToLinear(), g[_] = k.r, g[_ + 1] = k.g, g[_ + 2] = k.b);
+        }
+      }
+      return w.setAttribute("position", new N(V, 3)), w.setAttribute("normal", new N(A, 3)), p && (w.setAttribute("color", new N(g, 3)), w.hasColors = !0, w.alpha = v), w;
+    }
+    function r(n) {
+      const o = new T(), a = /solid([\s\S]*?)endsolid/g, u = /facet([\s\S]*?)endfacet/g, d = /solid\s(.+)/;
+      let m = 0;
+      const p = /[\s]+([+-]?(?:\d*)(?:\.\d*)?(?:[eE][+-]?\d+)?)/.source, g = new RegExp("vertex" + p + p + p, "g"), b = new RegExp("normal" + p + p + p, "g"), x = [], C = [], v = [], j = new I();
+      let f, w = 0, V = 0, A = 0;
+      for (; (f = a.exec(n)) !== null; ) {
+        V = A;
+        const k = f[0], y = (f = d.exec(k)) !== null ? f[1] : "";
+        for (v.push(y); (f = u.exec(k)) !== null; ) {
+          let O = 0, z = 0;
+          const L = f[0];
+          for (; (f = b.exec(L)) !== null; )
+            j.x = parseFloat(f[1]), j.y = parseFloat(f[2]), j.z = parseFloat(f[3]), z++;
+          for (; (f = g.exec(L)) !== null; )
+            x.push(parseFloat(f[1]), parseFloat(f[2]), parseFloat(f[3])), C.push(j.x, j.y, j.z), O++, A++;
+          z !== 1 && console.error("THREE.STLLoader: Something isn't right with the normal of face number " + m), O !== 3 && console.error("THREE.STLLoader: Something isn't right with the vertices of face number " + m), m++;
+        }
+        const U = V, D = A - V;
+        o.userData.groupNames = v, o.addGroup(U, D, w), w++;
+      }
+      return o.setAttribute("position", new M(x, 3)), o.setAttribute("normal", new M(C, 3)), o;
+    }
+    function h(n) {
+      return typeof n != "string" ? new TextDecoder().decode(n) : n;
+    }
+    function c(n) {
+      if (typeof n == "string") {
+        const o = new Uint8Array(n.length);
+        for (let a = 0; a < n.length; a++)
+          o[a] = n.charCodeAt(a) & 255;
+        return o.buffer || o;
+      } else
+        return n;
+    }
+    const l = c(e);
+    return s(l) ? t(l) : r(h(e));
+  }
+}
+export {
+  xe as M,
+  be as O,
+  we as S
+};