build-dxf 0.0.34 → 0.0.36

package/src/build.js

@@ -1,16 +1,16 @@
 import * as z from "three";
-import { EventDispatcher as Ge, Color as ze, Matrix4 as ve, Vector3 as ce, Quaternion as _e, BufferAttribute as te, REVISION as qe, CompressedTexture as de, Source as je, NoColorSpace as Ye, MathUtils as ye, RGBAFormat as ke, ImageUtils as Xe, DoubleSide as Ve, PropertyBinding as le, InterpolateDiscrete as We, Scene as Se, SRGBColorSpace as He, NearestFilter as Je, NearestMipmapNearestFilter as Ke, NearestMipmapLinearFilter as $e, LinearFilter as Ze, LinearMipmapNearestFilter as Qe, LinearMipmapLinearFilter as et, ClampToEdgeWrapping as tt, RepeatWrapping as nt, MirroredRepeatWrapping as st, InterpolateLinear as it } from "three";
-import Le from "clipper-lib";
-import ae from "dxf-writer";
-import { OBJExporter as rt } from "three/examples/jsm/exporters/OBJExporter.js";
-function me() {
+import { EventDispatcher as Oe, Color as Fe, Matrix4 as Ie, Vector3 as ie, Quaternion as Ue, BufferAttribute as Z, REVISION as Ge, CompressedTexture as le, Source as ze, NoColorSpace as qe, MathUtils as fe, RGBAFormat as _e, ImageUtils as je, DoubleSide as Ye, PropertyBinding as re, InterpolateDiscrete as ke, Scene as ge, SRGBColorSpace as Xe, NearestFilter as Ve, NearestMipmapNearestFilter as We, NearestMipmapLinearFilter as He, LinearFilter as Je, LinearMipmapNearestFilter as $e, LinearMipmapLinearFilter as Ke, ClampToEdgeWrapping as Ze, RepeatWrapping as Qe, MirroredRepeatWrapping as et, InterpolateLinear as tt } from "three";
+import we from "clipper-lib";
+import se from "dxf-writer";
+import { OBJExporter as nt } from "three/examples/jsm/exporters/OBJExporter.js";
+function pe() {
   return "xxxx-xxxx-4xxx-yxxx-xxxx".replace(/[xy]/g, function(f) {
     var e = Math.random() * 16 | 0, t = f == "x" ? e : e & 3 | 8;
     return t.toString(16);
   });
 }
-class Ne extends Ge {
-  uuid = me();
+class Pe extends Oe {
+  uuid = pe();
   addEventListener(e, t, n) {
     const { once: s = !1 } = n ?? {}, i = (o) => {
       t(o), s && r();
@@ -30,7 +30,7 @@ class Ne extends Ge {
     t && (t.forEach((n) => n()), this.eventRecordStack.delete(e));
   }
 }
-class ne extends Ne {
+class Q extends Pe {
   parent;
   destroyed = !1;
   constructor(...e) {
@@ -48,7 +48,7 @@ class ne extends Ne {
     this.destroyed = !0;
   }
 }
-class ot extends Ne {
+class st extends Pe {
   static EventType = {
     ADD_COMPONENT: "addComponent"
   };
@@ -71,7 +71,7 @@ class ot extends Ne {
    * @param component 
    */
   removeComponent(e) {
-    if (e instanceof ne) {
+    if (e instanceof Q) {
       const t = this.components.indexOf(e);
       t > -1 && (this.components.splice(t, 1), this.dispatchEvent({
         type: "removeComponent",
@@ -123,10 +123,10 @@ class j {
   maxY = 0;
   get points() {
     return [
-      new g(this.minX, this.minY),
-      new g(this.maxX, this.minY),
-      new g(this.maxX, this.maxY),
-      new g(this.minX, this.maxY)
+      new w(this.minX, this.minY),
+      new w(this.maxX, this.minY),
+      new w(this.maxX, this.maxY),
+      new w(this.minX, this.maxY)
     ];
   }
   get width() {
@@ -136,7 +136,7 @@ class j {
     return this.maxY - this.minY;
   }
   get center() {
-    return new g(
+    return new w(
       this.minX + (this.maxX - this.minX) * 0.5,
       this.minY + (this.maxY - this.minY) * 0.5
     );
@@ -167,13 +167,13 @@ class j {
       return this.minX <= t.x && t.x <= this.maxX && this.minY <= t.y && t.y <= this.maxY;
     let r = Number.NEGATIVE_INFINITY, o = Number.POSITIVE_INFINITY;
     if (s !== 0) {
-      const a = (this.minX - t.x) / s, l = (this.maxX - t.x) / s;
-      r = Math.max(r, Math.min(a, l)), o = Math.min(o, Math.max(a, l));
+      const a = (this.minX - t.x) / s, c = (this.maxX - t.x) / s;
+      r = Math.max(r, Math.min(a, c)), o = Math.min(o, Math.max(a, c));
     } else if (t.x < this.minX || t.x > this.maxX)
       return !1;
     if (i !== 0) {
-      const a = (this.minY - t.y) / i, l = (this.maxY - t.y) / i;
-      r = Math.max(r, Math.min(a, l)), o = Math.min(o, Math.max(a, l));
+      const a = (this.minY - t.y) / i, c = (this.maxY - t.y) / i;
+      r = Math.max(r, Math.min(a, c)), o = Math.min(o, Math.max(a, c));
     } else if (t.y < this.minY || t.y > this.maxY)
       return !1;
     return r <= o && r <= 1 && o >= 0;
@@ -193,43 +193,43 @@ class j {
   intersectRectangle(e) {
     const t = e.points;
     let n = t[0].x, s = t[0].y, i = t[0].x, r = t[0].y;
-    for (let l = 1; l < 4; l++) {
-      const c = t[l];
-      c.x < n && (n = c.x), c.y < s && (s = c.y), c.x > i && (i = c.x), c.y > r && (r = c.y);
+    for (let c = 1; c < 4; c++) {
+      const l = t[c];
+      l.x < n && (n = l.x), l.y < s && (s = l.y), l.x > i && (i = l.x), l.y > r && (r = l.y);
     }
     if (this.maxX < n || this.minX > i || this.maxY < s || this.minY > r)
       return !1;
     const o = this.points;
-    for (let l = 0; l < 4; l++) {
-      const c = o[l], h = o[(l + 1) % 4];
+    for (let c = 0; c < 4; c++) {
+      const l = o[c], h = o[(c + 1) % 4];
       for (let d = 0; d < 4; d++) {
-        const u = t[d], p = t[(d + 1) % 4], y = (h.x - c.x) * (u.y - c.y) - (h.y - c.y) * (u.x - c.x), x = (h.x - c.x) * (p.y - c.y) - (h.y - c.y) * (p.x - c.x), S = (p.x - u.x) * (c.y - u.y) - (p.y - u.y) * (c.x - u.x), T = (p.x - u.x) * (h.y - u.y) - (p.y - u.y) * (h.x - u.x);
-        if (y * x < 0 && S * T < 0 || y === 0 && Math.min(c.x, h.x) <= u.x && u.x <= Math.max(c.x, h.x) && Math.min(c.y, h.y) <= u.y && u.y <= Math.max(c.y, h.y) || x === 0 && Math.min(c.x, h.x) <= p.x && p.x <= Math.max(c.x, h.x) && Math.min(c.y, h.y) <= p.y && p.y <= Math.max(c.y, h.y) || S === 0 && Math.min(u.x, p.x) <= c.x && c.x <= Math.max(u.x, p.x) && Math.min(u.y, p.y) <= c.y && c.y <= Math.max(u.y, p.y) || T === 0 && Math.min(u.x, p.x) <= h.x && h.x <= Math.max(u.x, p.x) && Math.min(u.y, p.y) <= h.y && h.y <= Math.max(u.y, p.y))
+        const u = t[d], p = t[(d + 1) % 4], x = (h.x - l.x) * (u.y - l.y) - (h.y - l.y) * (u.x - l.x), y = (h.x - l.x) * (p.y - l.y) - (h.y - l.y) * (p.x - l.x), m = (p.x - u.x) * (l.y - u.y) - (p.y - u.y) * (l.x - u.x), M = (p.x - u.x) * (h.y - u.y) - (p.y - u.y) * (h.x - u.x);
+        if (x * y < 0 && m * M < 0 || x === 0 && Math.min(l.x, h.x) <= u.x && u.x <= Math.max(l.x, h.x) && Math.min(l.y, h.y) <= u.y && u.y <= Math.max(l.y, h.y) || y === 0 && Math.min(l.x, h.x) <= p.x && p.x <= Math.max(l.x, h.x) && Math.min(l.y, h.y) <= p.y && p.y <= Math.max(l.y, h.y) || m === 0 && Math.min(u.x, p.x) <= l.x && l.x <= Math.max(u.x, p.x) && Math.min(u.y, p.y) <= l.y && l.y <= Math.max(u.y, p.y) || M === 0 && Math.min(u.x, p.x) <= h.x && h.x <= Math.max(u.x, p.x) && Math.min(u.y, p.y) <= h.y && h.y <= Math.max(u.y, p.y))
           return !0;
       }
     }
-    for (let l = 0; l < 4; l++) {
-      const c = t[l];
-      if (c.x >= this.minX && c.x <= this.maxX && c.y >= this.minY && c.y <= this.maxY)
+    for (let c = 0; c < 4; c++) {
+      const l = t[c];
+      if (l.x >= this.minX && l.x <= this.maxX && l.y >= this.minY && l.y <= this.maxY)
         return !0;
     }
-    const a = (l) => {
-      let c = 0;
+    const a = (c) => {
+      let l = 0;
       for (let h = 0; h < 4; h++) {
-        const d = t[h], u = t[(h + 1) % 4], p = (u.x - d.x) * (l.y - d.y) - (u.y - d.y) * (l.x - d.x);
+        const d = t[h], u = t[(h + 1) % 4], p = (u.x - d.x) * (c.y - d.y) - (u.y - d.y) * (c.x - d.x);
         if (p === 0) {
-          const y = Math.abs(u.x - d.x) > 1e-10 ? u.x - d.x : u.y - d.y, x = y ? (l.x - d.x) / y : 0;
-          if (x >= 0 && x <= 1) return !0;
+          const x = Math.abs(u.x - d.x) > 1e-10 ? u.x - d.x : u.y - d.y, y = x ? (c.x - d.x) / x : 0;
+          if (y >= 0 && y <= 1) return !0;
         } else {
-          const y = p > 0 ? 1 : -1;
-          if (c === 0) c = y;
-          else if (c !== y) return !1;
+          const x = p > 0 ? 1 : -1;
+          if (l === 0) l = x;
+          else if (l !== x) return !1;
         }
       }
       return !0;
     };
-    for (let l = 0; l < 4; l++)
-      if (a(o[l])) return !0;
+    for (let c = 0; c < 4; c++)
+      if (a(o[c])) return !0;
     return !1;
   }
   /**
@@ -336,7 +336,136 @@ class j {
     );
   }
 }
-class ue {
+class oe {
+  map = /* @__PURE__ */ new Map();
+  targetMap = /* @__PURE__ */ new Map();
+  gridSize;
+  constructor(e = 2) {
+    this.gridSize = e;
+  }
+  /**
+   * 插入
+   * @param point 
+   * @param userData 
+   */
+  insert(e, t) {
+    if (!e || isNaN(e.x) || isNaN(e.y))
+      throw new Error("无效的点坐标");
+    this.targetMap.has(e) && this.remove(e);
+    const n = this.getGridId(e);
+    this.map.has(n) || this.map.set(n, /* @__PURE__ */ new Set());
+    const s = this.map.get(n), i = { point: e, userData: t };
+    s.add(i), e.userData.pointVirtualGrid = { set: s, target: i }, this.targetMap.set(e, { set: s, target: i });
+  }
+  /**
+   * 批量加入
+   * @param points 
+   */
+  insertBatch(e) {
+    for (const { point: t, userData: n } of e)
+      this.insert(t, n);
+  }
+  /** 移除点
+   * @param point 
+   */
+  remove(e) {
+    if (this.targetMap.has(e)) {
+      const { target: t, set: n } = this.targetMap.get(e);
+      n && (n.delete(t), delete e?.userData?.pointVirtualGridMap, this.targetMap.delete(e));
+    }
+  }
+  /**
+   * 获取通过坐标，获取唯一网格索引
+   * @param point 
+   * @returns 
+   */
+  getGridId(e) {
+    const t = Math.ceil(e.x / this.gridSize), n = Math.ceil(e.y / this.gridSize);
+    return `${t}.${n}`;
+  }
+  /**
+   * 
+   * @param gridId 
+   * @returns 
+   */
+  decodeGridId(e) {
+    const [t, n] = e.split(".").map(Number);
+    return new w(t, n);
+  }
+  /**
+   * 查询与矩形相交的点
+   * @param rectangle 矩形
+   * @returns 相交的节点数组
+   */
+  queryRect(e) {
+    const t = e.toBox(), n = Math.ceil(t.minX / this.gridSize), s = Math.ceil(t.maxX / this.gridSize), i = Math.ceil(t.minY / this.gridSize), r = Math.ceil(t.maxY / this.gridSize);
+    for (let o = n; o <= s; o++)
+      for (let a = i; a <= r; a++) {
+        const c = `${o}.${a}`;
+        if (!this.map.has(c)) continue;
+        this.map.get(c)?.forEach((h) => {
+          e.containsPoint(h.point);
+        });
+      }
+  }
+  /**
+   * 查询与圆形区域相交的点
+   * @param pos 圆心
+   * @param radius 半径
+   * @returns 相交的节点数组
+   */
+  queryCircle(e, t) {
+    const n = new j(e.x - t, e.x + t, e.y - t, e.y + t), s = Math.ceil(n.minX / this.gridSize), i = Math.ceil(n.maxX / this.gridSize), r = Math.ceil(n.minY / this.gridSize), o = Math.ceil(n.maxY / this.gridSize), a = [];
+    for (let c = s; c <= i; c++)
+      for (let l = r; l <= o; l++) {
+        const h = `${c}.${l}`;
+        if (!this.map.has(h)) continue;
+        this.map.get(h)?.forEach((u) => {
+          e.distance(u.point) <= t && a.push(u);
+        });
+      }
+    return a;
+  }
+  /**
+   * 查询与包围盒相交的点
+   * @param box2 包围盒
+   * @returns 相交的节点数组
+   */
+  queryBox(e) {
+    const t = Math.ceil(e.minX / this.gridSize), n = Math.ceil(e.maxX / this.gridSize), s = Math.ceil(e.minY / this.gridSize), i = Math.ceil(e.maxY / this.gridSize), r = [];
+    for (let o = t; o <= n; o++)
+      for (let a = s; a <= i; a++) {
+        const c = `${o}.${a}`;
+        if (!this.map.has(c)) continue;
+        this.map.get(c)?.forEach((h) => {
+          e.containsPoint(h.point) && r.push(h);
+        });
+      }
+    return r;
+  }
+  /**
+   * 查找相同点
+   * @param point 
+   */
+  queryPoint(e) {
+    const t = this.getGridId(e), n = [];
+    return this.map.has(t) && this.map.get(t)?.forEach((i) => {
+      e.equal(i.point) && n.push(i);
+    }), n;
+  }
+  /**
+   * 查找点自己
+   * @param point 
+   */
+  queryPointSelf(e) {
+    if (this.targetMap.has(e)) {
+      const { target: t } = this.targetMap.get(e);
+      return t;
+    }
+    return null;
+  }
+}
+class ce {
   points;
   get p0() {
     return this.points[0];
@@ -359,7 +488,7 @@ class ue {
   path2D(e) {
     return this.points.flatMap((t, n) => {
       const s = this.points[(n + 1) % this.points.length];
-      return e && e(new g(t.x, t.y), new g(s.x, s.y)), [t.x, t.y, s.x, s.y];
+      return e && e(new w(t.x, t.y), new w(s.x, s.y)), [t.x, t.y, s.x, s.y];
     });
   }
   createGeometry() {
@@ -387,14 +516,14 @@ class ue {
       throw new Error("LineSegment must have exactly 2 points");
     const [t, n] = e.points, s = n.x - t.x, i = n.y - t.y;
     for (let r = 0; r < 4; r++) {
-      const o = this.points[r], a = this.points[(r + 1) % 4], l = a.x - o.x, c = a.y - o.y, h = s * c - i * l;
+      const o = this.points[r], a = this.points[(r + 1) % 4], c = a.x - o.x, l = a.y - o.y, h = s * l - i * c;
       if (h === 0) {
-        if ((t.x - o.x) * c - (t.y - o.y) * l !== 0) continue;
-        const u = l * l + c * c, p = ((t.x - o.x) * l + (t.y - o.y) * c) / u, y = ((n.x - o.x) * l + (n.y - o.y) * c) / u;
-        if (Math.max(p, y) >= 0 && Math.min(p, y) <= 1)
+        if ((t.x - o.x) * l - (t.y - o.y) * c !== 0) continue;
+        const u = c * c + l * l, p = ((t.x - o.x) * c + (t.y - o.y) * l) / u, x = ((n.x - o.x) * c + (n.y - o.y) * l) / u;
+        if (Math.max(p, x) >= 0 && Math.min(p, x) <= 1)
           return !0;
       } else {
-        const d = ((o.x - t.x) * c - (o.y - t.y) * l) / h, u = ((o.x - t.x) * i - (o.y - t.y) * s) / h;
+        const d = ((o.x - t.x) * l - (o.y - t.y) * c) / h, u = ((o.x - t.x) * i - (o.y - t.y) * s) / h;
         if (d >= 0 && d <= 1 && u >= 0 && u <= 1)
           return !0;
       }
@@ -412,12 +541,12 @@ class ue {
     const t = (n) => {
       let s = 0;
       for (let i = 0; i < 4; i++) {
-        const r = this.points[i], o = this.points[(i + 1) % 4], a = { x: o.x - r.x, y: o.y - r.y }, l = { x: n.x - r.x, y: n.y - r.y }, c = a.x * l.y - a.y * l.x;
-        if (c === 0) {
+        const r = this.points[i], o = this.points[(i + 1) % 4], a = { x: o.x - r.x, y: o.y - r.y }, c = { x: n.x - r.x, y: n.y - r.y }, l = a.x * c.y - a.y * c.x;
+        if (l === 0) {
           const h = a.x !== 0 ? (n.x - r.x) / a.x : (n.y - r.y) / a.y;
           if (h >= 0 && h <= 1) return !0;
         } else {
-          const h = c > 0 ? 1 : -1;
+          const h = l > 0 ? 1 : -1;
           if (s === 0 && (s = h), s !== h) return !1;
         }
       }
@@ -486,21 +615,21 @@ class ue {
    * @returns 
    */
   static fromByLineSegment(e, t = 0.1, n = !1, s = 0.5) {
-    const i = e.points[0], r = e.points[1], o = r.normal(i), a = n ? r.direction(i).mutiplyScalar(t * s) : g.zero(), l = n ? i.direction(r).mutiplyScalar(t * s) : g.zero(), c = o.x * t * 0.5, h = o.y * t * 0.5;
-    return new ue([
-      new g(i.x + c, i.y + h).add(l),
-      new g(r.x + c, r.y + h).add(a),
-      new g(r.x - c, r.y - h).add(a),
-      new g(i.x - c, i.y - h).add(l)
+    const i = e.points[0], r = e.points[1], o = r.normal(i), a = n ? r.direction(i).mutiplyScalar(t * s) : w.zero(), c = n ? i.direction(r).mutiplyScalar(t * s) : w.zero(), l = o.x * t * 0.5, h = o.y * t * 0.5;
+    return new ce([
+      new w(i.x + l, i.y + h).add(c),
+      new w(r.x + l, r.y + h).add(a),
+      new w(r.x - l, r.y - h).add(a),
+      new w(i.x - l, i.y - h).add(c)
     ]);
   }
 }
-class N {
-  points = [new g(), new g()];
+class R {
+  points = [new w(), new w()];
   userData = {};
   // line: any
   get center() {
-    return new g(
+    return new w(
       this.points[0].x + (this.points[1].x - this.points[0].x) * 0.5,
       this.points[0].y + (this.points[1].y - this.points[0].y) * 0.5
     );
@@ -511,7 +640,7 @@ class N {
   get end() {
     return this.points[1];
   }
-  constructor(e = new g(), t = new g()) {
+  constructor(e = new w(), t = new w()) {
     this.points = [e, t];
   }
   set(e, t) {
@@ -597,15 +726,15 @@ class N {
    * @returns {Rectangle}
    */
   expandToRectangle(e = 0.1, t = "all") {
-    const n = this.start, s = this.end, i = s.normal(n), r = t === "bothSides" ? g.zero() : s.direction(n).mutiplyScalar(e * 0.5), o = t === "bothSides" ? g.zero() : n.direction(s).mutiplyScalar(e * 0.5), a = i.x * e * 0.5, l = i.y * e * 0.5, c = [
+    const n = this.start, s = this.end, i = s.normal(n), r = t === "bothSides" ? w.zero() : s.direction(n).mutiplyScalar(e * 0.5), o = t === "bothSides" ? w.zero() : n.direction(s).mutiplyScalar(e * 0.5), a = i.x * e * 0.5, c = i.y * e * 0.5, l = [
       // 第一条线
-      new g(n.x + a, n.y + l).add(o),
-      new g(s.x + a, s.y + l).add(r),
+      new w(n.x + a, n.y + c).add(o),
+      new w(s.x + a, s.y + c).add(r),
       // 第二条线
-      new g(n.x - a, n.y - l).add(o),
-      new g(s.x - a, s.y - l).add(r)
+      new w(n.x - a, n.y - c).add(o),
+      new w(s.x - a, s.y - c).add(r)
     ];
-    return new ue([0, 1, 3, 2].map((h) => c[h]));
+    return new ce([0, 1, 3, 2].map((h) => l[h]));
   }
   /**
    * 计算线段的长度
@@ -642,24 +771,24 @@ class N {
   projectLineSegment(e) {
     if (e.points.length !== 2 || this.points.length !== 2)
       throw new Error("每条线段必须由两个点定义");
-    const [t, n] = e.points, [s, i] = this.points, r = new g(i.x - s.x, i.y - s.y);
+    const [t, n] = e.points, [s, i] = this.points, r = new w(i.x - s.x, i.y - s.y);
     if (r.x === 0 && r.y === 0)
       throw new Error("投影目标线段的两个点不能重合");
     const o = (p) => {
-      const y = new g(p.x - s.x, p.y - s.y), x = r.x * r.x + r.y * r.y, T = (y.x * r.x + y.y * r.y) / x, G = s.x + T * r.x, E = s.y + T * r.y;
-      return new g(G, E);
+      const x = new w(p.x - s.x, p.y - s.y), y = r.x * r.x + r.y * r.y, M = (x.x * r.x + x.y * r.y) / y, T = s.x + M * r.x, g = s.y + M * r.y;
+      return new w(T, g);
     };
-    let a = o(t), l = o(n);
-    const c = (p) => {
-      const y = new g(p.x - s.x, p.y - s.y), x = r.x * r.x + r.y * r.y;
-      return (y.x * r.x + y.y * r.y) / x;
+    let a = o(t), c = o(n);
+    const l = (p) => {
+      const x = new w(p.x - s.x, p.y - s.y), y = r.x * r.x + r.y * r.y;
+      return (x.x * r.x + x.y * r.y) / y;
     };
-    let h = c(a), d = c(l);
+    let h = l(a), d = l(c);
     const u = (p) => {
-      const y = Math.max(0, Math.min(1, p)), x = s.x + y * r.x, S = s.y + y * r.y;
-      return new g(x, S);
+      const x = Math.max(0, Math.min(1, p)), y = s.x + x * r.x, m = s.y + x * r.y;
+      return new w(y, m);
     };
-    return (h < 0 || h > 1) && (a = u(h)), (d < 0 || d > 1) && (l = u(d)), a.x === l.x && a.y === l.y ? new N(a, a) : new N(a, l);
+    return (h < 0 || h > 1) && (a = u(h)), (d < 0 || d > 1) && (c = u(d)), a.x === c.x && a.y === c.y ? new R(a, a) : new R(a, c);
   }
   /**
    * 计算一条线段在另一条直线上的投影
@@ -668,19 +797,19 @@ class N {
    * @returns 投影并裁剪后的线段
    */
   projectPoint(e, t = !0) {
-    const [n, s] = this.points, i = new g(s.x - n.x, s.y - n.y);
+    const [n, s] = this.points, i = new w(s.x - n.x, s.y - n.y);
     if (i.x === 0 && i.y === 0)
       throw new Error("投影目标线段的两个点不能重合");
-    let o = ((c) => {
-      const h = new g(c.x - n.x, c.y - n.y), d = i.x * i.x + i.y * i.y, p = (h.x * i.x + h.y * i.y) / d, y = n.x + p * i.x, x = n.y + p * i.y;
-      return new g(y, x);
+    let o = ((l) => {
+      const h = new w(l.x - n.x, l.y - n.y), d = i.x * i.x + i.y * i.y, p = (h.x * i.x + h.y * i.y) / d, x = n.x + p * i.x, y = n.y + p * i.y;
+      return new w(x, y);
     })(e);
     if (!t) return o;
-    let l = ((c) => {
-      const h = new g(c.x - n.x, c.y - n.y), d = i.x * i.x + i.y * i.y;
+    let c = ((l) => {
+      const h = new w(l.x - n.x, l.y - n.y), d = i.x * i.x + i.y * i.y;
       return (h.x * i.x + h.y * i.y) / d;
     })(o);
-    return l < 0 || l > 1 ? null : o;
+    return c < 0 || c > 1 ? null : o;
   }
   /**
    * 判断线段是否与另一条线段相交（包含共用端点或部分重合的情况）
@@ -690,14 +819,14 @@ class N {
    */
   intersectLineSegment(e, t = !0) {
     const n = this.start, s = this.end, i = e.start, r = e.end;
-    function o(u, p, y) {
-      return (p.x - u.x) * (y.y - u.y) - (p.y - u.y) * (y.x - u.x);
+    function o(u, p, x) {
+      return (p.x - u.x) * (x.y - u.y) - (p.y - u.y) * (x.x - u.x);
     }
-    function a(u, p, y) {
-      return Math.min(p.x, y.x) - 1e-10 <= u.x && u.x <= Math.max(p.x, y.x) + 1e-10 && Math.min(p.y, y.y) - 1e-10 <= u.y && u.y <= Math.max(p.y, y.y) + 1e-10;
+    function a(u, p, x) {
+      return Math.min(p.x, x.x) - 1e-10 <= u.x && u.x <= Math.max(p.x, x.x) + 1e-10 && Math.min(p.y, x.y) - 1e-10 <= u.y && u.y <= Math.max(p.y, x.y) + 1e-10;
     }
-    const l = o(n, s, i), c = o(n, s, r), h = o(i, r, n), d = o(i, r, s);
-    return !!(l * c < 0 && h * d < 0 || t && (Math.abs(l) < 1e-10 && a(i, n, s) || Math.abs(c) < 1e-10 && a(r, n, s) || Math.abs(h) < 1e-10 && a(n, i, r) || Math.abs(d) < 1e-10 && a(s, i, r)));
+    const c = o(n, s, i), l = o(n, s, r), h = o(i, r, n), d = o(i, r, s);
+    return !!(c * l < 0 && h * d < 0 || t && (Math.abs(c) < 1e-10 && a(i, n, s) || Math.abs(l) < 1e-10 && a(r, n, s) || Math.abs(h) < 1e-10 && a(n, i, r) || Math.abs(d) < 1e-10 && a(s, i, r)));
   }
   /**
    * 判断一个点是否在线段上（含端点）
@@ -717,8 +846,8 @@ class N {
     const t = this.start, n = this.end, s = e.start, i = e.end, r = (t.x - n.x) * (s.y - i.y) - (t.y - n.y) * (s.x - i.x);
     if (Math.abs(r) < 1e-10)
       return null;
-    const o = ((t.x - s.x) * (s.y - i.y) - (t.y - s.y) * (s.x - i.x)) / r, a = t.x + o * (n.x - t.x), l = t.y + o * (n.y - t.y);
-    return new g(a, l);
+    const o = ((t.x - s.x) * (s.y - i.y) - (t.y - s.y) * (s.x - i.x)) / r, a = t.x + o * (n.x - t.x), c = t.y + o * (n.y - t.y);
+    return new w(a, c);
   }
   /**
    * 获取两条线段夹角
@@ -784,17 +913,17 @@ class N {
     if (this.intersectLineSegment(e))
       return 0;
     const t = (n, s) => {
-      const i = s.start, r = s.end, o = r.x - i.x, a = r.y - i.y, l = o * o + a * a;
-      if (l < 1e-10)
+      const i = s.start, r = s.end, o = r.x - i.x, a = r.y - i.y, c = o * o + a * a;
+      if (c < 1e-10)
         return n.distance(i);
-      const c = ((n.x - i.x) * o + (n.y - i.y) * a) / l;
-      if (c < 0)
+      const l = ((n.x - i.x) * o + (n.y - i.y) * a) / c;
+      if (l < 0)
         return n.distance(i);
-      if (c > 1)
+      if (l > 1)
         return n.distance(r);
       {
-        const h = i.x + c * o, d = i.y + c * a;
-        return n.distance(new g(h, d));
+        const h = i.x + l * o, d = i.y + l * a;
+        return n.distance(new w(h, d));
       }
     };
     return Math.min(
@@ -810,14 +939,14 @@ class N {
    * @returns 
    */
   areLinesCoincident(e) {
-    const t = this.start, n = this.end, s = e.start, i = e.end, r = (n.y - t.y) / (n.x - t.x), o = t.y - r * t.x, a = (i.y - s.y) / (i.x - s.x), l = s.y - a * s.x;
-    return !isFinite(r) && !isFinite(a) ? t.x === s.x && n.x === s.x : Math.abs(r - a) < 1e-3 && Math.abs(o - l) < 1e-3;
+    const t = this.start, n = this.end, s = e.start, i = e.end, r = (n.y - t.y) / (n.x - t.x), o = t.y - r * t.x, a = (i.y - s.y) / (i.x - s.x), c = s.y - a * s.x;
+    return !isFinite(r) && !isFinite(a) ? t.x === s.x && n.x === s.x : Math.abs(r - a) < 1e-3 && Math.abs(o - c) < 1e-3;
   }
   /** 克隆
    * @returns 
    */
   clone() {
-    const e = new N(
+    const e = new R(
       this.points[0].clone(),
       this.points[1].clone()
     );
@@ -836,8 +965,74 @@ class N {
     }
     return s;
   }
+  /** 对平行并且共线线段分组
+   * @param selectLines 
+   */
+  static groupBySamePointAndParallel(e) {
+    const t = new oe();
+    e.forEach((r) => r.points.forEach((o) => t.insert(o, r)));
+    const n = /* @__PURE__ */ new Set();
+    function s(r, o, a) {
+      if (o.has(r)) return;
+      const c = t.queryPoint(r.start).filter((u) => u.userData !== r && r.parallel(u.userData, 0.1)), l = t.queryPoint(r.end).filter((u) => u.userData !== r && r.parallel(u.userData, 0.1)), h = c[0]?.userData, d = l[0]?.userData;
+      return h && !a.has(h) && (a.add(h), s(h, o, a)), d && !a.has(d) && (a.add(d), s(d, o, a)), o.add(r), a;
+    }
+    const i = [];
+    for (let r = 0; r < e.length; r++) {
+      const o = e[r];
+      if (n.has(o)) continue;
+      const a = s(o, n, /* @__PURE__ */ new Set([o]));
+      a && i.push([...a]);
+    }
+    return i;
+  }
+  /** 合并平行线段
+   * @param lines
+   * @returns 
+   */
+  static mergeLines(...e) {
+    if (e.length === 1) return e[0];
+    const t = [];
+    e.forEach((u) => {
+      t.push(u.start.clone(), u.end.clone());
+    });
+    const n = e[0].direction().normalize();
+    let s = 1 / 0, i = -1 / 0, r = 0, o = 0;
+    t.forEach((u) => {
+      const p = u.x * n.x + u.y * n.y;
+      s = Math.min(s, p), i = Math.max(i, p), r += u.x, o += u.y;
+    });
+    const a = new w(r / t.length, o / t.length), c = a.x * n.x + a.y * n.y, l = new w(a.x + (s - c) * n.x, a.y + (s - c) * n.y), h = new w(a.x + (i - c) * n.x, a.y + (i - c) * n.y), d = new R(l, h);
+    return e.forEach((u) => u.userData.fittedLine = d), d;
+  }
+  /** 合并满足平行的线段
+   * @param selectLines 
+   */
+  static autoMergeLines(e) {
+    const t = this.groupBySamePointAndParallel(e), n = [], s = [];
+    return t.forEach((i) => {
+      const r = this.mergeLines(...i);
+      r && (n.push(r), s.push(...i));
+    }), e.push(...n), {
+      lines: e.filter((i) => !s.includes(i)),
+      newLines: n,
+      deleteLines: s
+    };
+  }
+  /** 去重
+   * @param lines 
+   * @returns 
+   */
+  static deduplication(e) {
+    const t = /* @__PURE__ */ new Set(), n = [];
+    for (const s of e) {
+      const i = s.start, r = s.end, o = `${i.x.toFixed(10)}_${i.y.toFixed(10)}`, a = `${r.x.toFixed(10)}_${r.y.toFixed(10)}`, c = o < a ? `${o}_${a}` : `${a}_${o}`;
+      t.has(c) || (t.add(c), n.push(s));
+    }
+    return n;
+  }
 }
-class g {
+class w {
   x;
   y;
   get X() {
@@ -954,7 +1149,7 @@ class g {
    */
   normal(e) {
     const t = this.x - e.x, n = this.y - e.y, s = Math.sqrt(t * t + n * n), i = -n / s, r = t / s;
-    return new g(i, r);
+    return new w(i, r);
   }
   /**
    * 获取由传入的点到该点的单位方向向量
@@ -964,14 +1159,14 @@ class g {
    */
   direction(e) {
     const t = this.x - e.x, n = this.y - e.y, s = Math.sqrt(t * t + n * n);
-    return s === 0 ? new g(0, 0) : new g(t / s, n / s);
+    return s === 0 ? new w(0, 0) : new w(t / s, n / s);
   }
   /** 展开为线
    * @param direction 
    * @param length 
    */
   expandAsLine(e, t, n) {
-    const s = new N(
+    const s = new R(
       this.clone(),
       this.clone().add(e.clone().multiplyScalar(t))
     );
@@ -1033,7 +1228,7 @@ class g {
    * @returns 
    */
   clone() {
-    return new g(this.x, this.y);
+    return new w(this.x, this.y);
   }
   /**
    * 克隆
@@ -1050,13 +1245,13 @@ class g {
     };
   }
   static from(e) {
-    return Array.isArray(e) ? new g(e[0], e[1]) : "x" in e && "y" in e ? new g(e.x, e.y) : "X" in e && "Y" in e ? new g(e.X, e.Y) : this.zero();
+    return Array.isArray(e) ? new w(e[0], e[1]) : "x" in e && "y" in e ? new w(e.x, e.y) : "X" in e && "Y" in e ? new w(e.X, e.Y) : this.zero();
   }
   static zero() {
-    return new g(0, 0);
+    return new w(0, 0);
   }
 }
-async function se(f, e = !0) {
+async function ee(f, e = !0) {
   if (typeof global < "u" && typeof require < "u")
     return require(f);
   {
@@ -1067,7 +1262,7 @@ async function se(f, e = !0) {
     return e && (t = t.default), t;
   }
 }
-class Z {
+class J {
   bounds;
   // 包围盒
   capacity;
@@ -1084,14 +1279,19 @@ class Z {
   // 存储的节点
   color = [Math.random(), Math.random(), Math.random()];
   // 颜色
-  constructor(e, t = 8, n = 10, s = 1) {
-    this.bounds = e, this.capacity = t, this.depth = s, this.maxDepth = n;
+  targetMap;
+  constructor(e, t = 8, n = 10, s = 1, i = /* @__PURE__ */ new Map()) {
+    this.bounds = e, this.capacity = t, this.depth = s, this.maxDepth = n, this.targetMap = i;
   }
   /**
    * 插入线段节点
    * @param node 线段节点
    */
   insert(e) {
+    if (e instanceof R) {
+      this.insert({ line: e, userData: {} });
+      return;
+    }
     if (!this.isLeaf) {
       const t = this.getQuadrant(e.line);
       if (t !== -1) {
@@ -1099,13 +1299,13 @@ class Z {
         return;
       }
     }
-    if (this.nodes.push(e), e.parent = this, this.isLeaf && this.nodes.length > this.capacity && this.depth < this.maxDepth) {
+    if (this.nodes.push(e), this.targetMap.set(e.line, e), e.parent = this, this.isLeaf && this.nodes.length > this.capacity && this.depth < this.maxDepth) {
       this.subdivide();
       const t = this.nodes;
       this.nodes = [];
       for (const n of t) {
         const s = this.getQuadrant(n.line);
-        s !== -1 ? this.children[s].insert(n) : (n.parent = this, this.nodes.push(n));
+        s !== -1 ? this.children[s].insert(n) : (n.parent = this, this.nodes.push(n), this.targetMap.set(e.line, e));
       }
     }
   }
@@ -1113,8 +1313,18 @@ class Z {
    * @param node 
    */
   remove(e) {
+    if (e instanceof R) {
+      e = this.targetMap.get(e), e && this.remove(e);
+      return;
+    }
     const t = e.parent?.nodes.indexOf(e);
-    t > -1 && e.parent?.nodes.splice(t, 1);
+    t > -1 && (e.parent?.nodes.splice(t, 1), this.targetMap.delete(e.line));
+  }
+  /** 移除
+   * @param node 
+   */
+  update(e) {
+    this.remove(e), this.insert(e);
   }
   /**
    * 获取线段所属的象限
@@ -1133,26 +1343,30 @@ class Z {
     if (!this.isLeaf) return;
     this.isLeaf = !1, this.children = [];
     const e = (this.bounds.minX + this.bounds.maxX) / 2, t = (this.bounds.minY + this.bounds.maxY) / 2;
-    this.children[0] = new Z(
+    this.children[0] = new J(
       new j(this.bounds.minX, e, this.bounds.minY, t),
       this.capacity,
       this.maxDepth,
-      this.depth + 1
-    ), this.children[1] = new Z(
+      this.depth + 1,
+      this.targetMap
+    ), this.children[1] = new J(
       new j(e, this.bounds.maxX, this.bounds.minY, t),
       this.capacity,
       this.maxDepth,
-      this.depth + 1
-    ), this.children[2] = new Z(
+      this.depth + 1,
+      this.targetMap
+    ), this.children[2] = new J(
       new j(this.bounds.minX, e, t, this.bounds.maxY),
       this.capacity,
       this.maxDepth,
-      this.depth + 1
-    ), this.children[3] = new Z(
+      this.depth + 1,
+      this.targetMap
+    ), this.children[3] = new J(
       new j(e, this.bounds.maxX, t, this.bounds.maxY),
       this.capacity,
       this.maxDepth,
-      this.depth + 1
+      this.depth + 1,
+      this.targetMap
     );
   }
   /**
@@ -1187,11 +1401,11 @@ class Z {
     if (!this.bounds.intersectBox(s))
       return n;
     for (const i of this.nodes) {
-      const [r, o] = i.line.points, a = o.x - r.x, l = o.y - r.y, c = a * a + l * l;
-      let h = ((e.x - r.x) * a + (e.y - r.y) * l) / c;
+      const [r, o] = i.line.points, a = o.x - r.x, c = o.y - r.y, l = a * a + c * c;
+      let h = ((e.x - r.x) * a + (e.y - r.y) * c) / l;
       h = Math.max(0, Math.min(1, h));
-      const d = r.x + h * a, u = r.y + h * l;
-      e.distance(new g(d, u)) <= t && n.push(i);
+      const d = r.x + h * a, u = r.y + h * c;
+      e.distance(new w(d, u)) <= t && n.push(i);
     }
     if (!this.isLeaf)
       for (const i of this.children)
@@ -1259,136 +1473,7 @@ class Z {
     })), e;
   }
 }
-class ge {
-  map = /* @__PURE__ */ new Map();
-  targetMap = /* @__PURE__ */ new Map();
-  gridSize;
-  constructor(e = 2) {
-    this.gridSize = e;
-  }
-  /**
-   * 插入
-   * @param point 
-   * @param userData 
-   */
-  insert(e, t) {
-    if (!e || isNaN(e.x) || isNaN(e.y))
-      throw new Error("无效的点坐标");
-    this.targetMap.has(e) && this.remove(e);
-    const n = this.getGridId(e);
-    this.map.has(n) || this.map.set(n, /* @__PURE__ */ new Set());
-    const s = this.map.get(n), i = { point: e, userData: t };
-    s.add(i), e.userData.pointVirtualGrid = { set: s, target: i }, this.targetMap.set(e, { set: s, target: i });
-  }
-  /**
-   * 批量加入
-   * @param points 
-   */
-  insertBatch(e) {
-    for (const { point: t, userData: n } of e)
-      this.insert(t, n);
-  }
-  /** 移除点
-   * @param point 
-   */
-  remove(e) {
-    if (this.targetMap.has(e)) {
-      const { target: t, set: n } = this.targetMap.get(e);
-      n && (n.delete(t), delete e?.userData?.pointVirtualGridMap, this.targetMap.delete(e));
-    }
-  }
-  /**
-   * 获取通过坐标，获取唯一网格索引
-   * @param point 
-   * @returns 
-   */
-  getGridId(e) {
-    const t = Math.ceil(e.x / this.gridSize), n = Math.ceil(e.y / this.gridSize);
-    return `${t}.${n}`;
-  }
-  /**
-   * 
-   * @param gridId 
-   * @returns 
-   */
-  decodeGridId(e) {
-    const [t, n] = e.split(".").map(Number);
-    return new g(t, n);
-  }
-  /**
-   * 查询与矩形相交的点
-   * @param rectangle 矩形
-   * @returns 相交的节点数组
-   */
-  queryRect(e) {
-    const t = e.toBox(), n = Math.ceil(t.minX / this.gridSize), s = Math.ceil(t.maxX / this.gridSize), i = Math.ceil(t.minY / this.gridSize), r = Math.ceil(t.maxY / this.gridSize);
-    for (let o = n; o <= s; o++)
-      for (let a = i; a <= r; a++) {
-        const l = `${o}.${a}`;
-        if (!this.map.has(l)) continue;
-        this.map.get(l)?.forEach((h) => {
-          e.containsPoint(h.point);
-        });
-      }
-  }
-  /**
-   * 查询与圆形区域相交的点
-   * @param pos 圆心
-   * @param radius 半径
-   * @returns 相交的节点数组
-   */
-  queryCircle(e, t) {
-    const n = new j(e.x - t, e.x + t, e.y - t, e.y + t), s = Math.ceil(n.minX / this.gridSize), i = Math.ceil(n.maxX / this.gridSize), r = Math.ceil(n.minY / this.gridSize), o = Math.ceil(n.maxY / this.gridSize), a = [];
-    for (let l = s; l <= i; l++)
-      for (let c = r; c <= o; c++) {
-        const h = `${l}.${c}`;
-        if (!this.map.has(h)) continue;
-        this.map.get(h)?.forEach((u) => {
-          e.distance(u.point) <= t && a.push(u);
-        });
-      }
-    return a;
-  }
-  /**
-   * 查询与包围盒相交的点
-   * @param box2 包围盒
-   * @returns 相交的节点数组
-   */
-  queryBox(e) {
-    const t = Math.ceil(e.minX / this.gridSize), n = Math.ceil(e.maxX / this.gridSize), s = Math.ceil(e.minY / this.gridSize), i = Math.ceil(e.maxY / this.gridSize), r = [];
-    for (let o = t; o <= n; o++)
-      for (let a = s; a <= i; a++) {
-        const l = `${o}.${a}`;
-        if (!this.map.has(l)) continue;
-        this.map.get(l)?.forEach((h) => {
-          e.containsPoint(h.point) && r.push(h);
-        });
-      }
-    return r;
-  }
-  /**
-   * 查找相同点
-   * @param point 
-   */
-  queryPoint(e) {
-    const t = this.getGridId(e), n = [];
-    return this.map.has(t) && this.map.get(t)?.forEach((i) => {
-      e.equal(i.point) && n.push(i);
-    }), n;
-  }
-  /**
-   * 查找点自己
-   * @param point 
-   */
-  queryPointSelf(e) {
-    if (this.targetMap.has(e)) {
-      const { target: t } = this.targetMap.get(e);
-      return t;
-    }
-    return null;
-  }
-}
-const at = {
+const it = {
   Unitless: 1,
   // 无单位，1米 = 1（无单位）
   Inches: 39.37007874015748,
@@ -1432,19 +1517,19 @@ const at = {
   Parsecs: 3240779289666404e-32
   // 秒差距，1米 ≈ 0.00000000000000003240779289666404秒差距
 };
-function Ee(f) {
+function Me(f) {
   const e = [];
   for (let t = 0; t < f.length; t++)
-    e.push(new N(
+    e.push(new R(
       f[t].clone(),
       f[(t + 1) % f.length].clone()
     ));
   return e;
 }
-function De(f) {
+function Se(f) {
   return f.flatMap((e, t) => (t === f.length - 1 && [...e.points, f[0].points[0]], [e.points[0]]));
 }
-class $ extends ne {
+class W extends Q {
   static name = "Dxf";
   shortLine = 0.04;
   width = 0.04;
@@ -1490,21 +1575,21 @@ class $ extends ne {
   preprocessing(e, t = !1, n) {
     let s = [], i = -1;
     const r = [];
-    e.forEach(({ start: a, end: l, ...c }, h) => {
-      r.push(a.z ?? 0, l.z ?? 0);
-      const d = new N(
-        g.from(a),
-        g.from(l)
+    e.forEach(({ start: a, end: c, ...l }, h) => {
+      r.push(a.z ?? 0, c.z ?? 0);
+      const d = new R(
+        w.from(a),
+        w.from(c)
       );
-      d.userData = c, s.push(d), c.isVerticalReferenceLine && (i = h);
-    }), this.originalZAverage = r.reduce((a, l) => a + l, 0) / r.length, i === -1 && (i = N.maxLengthLineIndex(s, (a) => !a.userData.insetionArr?.length));
+      d.userData = l, s.push(d), l.isVerticalReferenceLine && (i = h);
+    }), this.originalZAverage = r.reduce((a, c) => a + c, 0) / r.length, i === -1 && (i = R.maxLengthLineIndex(s, (a) => !a.userData.insetionArr?.length));
     const o = s[i];
-    return o.userData.isVerticalReferenceLine = !0, e[i].isVerticalReferenceLine = !0, t && (s = $.axisAlignmentCorrection.call(this, s, o, n), e = this.lineDataToOriginalData(s)), this.dispatchEvent({
+    return o.userData.isVerticalReferenceLine = !0, e[i].isVerticalReferenceLine = !0, t && (s = W.axisAlignmentCorrection.call(this, s, o, n), e = this.lineDataToOriginalData(s)), this.dispatchEvent({
       type: "preprocessing",
       data: e,
       setData(a) {
-        s = a.map(({ start: l, end: c, ...h }) => {
-          const d = new N(g.from(l), g.from(c));
+        s = a.map(({ start: c, end: l, ...h }) => {
+          const d = new R(w.from(c), w.from(l));
           return d.userData = h, d;
         }), e = a;
       }
@@ -1521,10 +1606,10 @@ class $ extends ne {
   async set(e, t = this.width, n = this.scale, s = !1, i) {
     if (typeof e == "string")
       if (typeof global < "u") {
-        const { default: l } = await import(
+        const { default: c } = await import(
           /* @vite-ignore */
           "fs"
-        ), c = l.readFileSync(e), h = JSON.parse(c.toString("utf-8"));
+        ), l = c.readFileSync(e), h = JSON.parse(l.toString("utf-8"));
         return this.set(h, t, n, s);
       } else
         throw new Error("非node环境不允许使用路径");
@@ -1532,17 +1617,17 @@ class $ extends ne {
     const r = this.preprocessing(e, s, i);
     e = r.data, this.lineSegments = r.lineSegments, this.originalData = e;
     const o = [];
-    this.data = e.map(({ start: a, end: l, insetionArr: c, isDoor: h = !1 }, d) => {
-      o.push(a.z ?? 0, l.z ?? 0);
+    this.data = e.map(({ start: a, end: c, insetionArr: l, isDoor: h = !1 }, d) => {
+      o.push(a.z ?? 0, c.z ?? 0);
       const u = this.lineSegments[d];
       return [
         u.points[0],
         u.points[1],
-        (c ?? []).map((p) => p.index),
+        (l ?? []).map((p) => p.index),
         h,
         d
       ];
-    }), this.originalZAverage = o.reduce((a, l) => a + l, 0) / o.length, this.computedOriginalSize(e, this.originalBox), this.dispatchEvent({
+    }), this.originalZAverage = o.reduce((a, c) => a + c, 0) / o.length, this.computedOriginalSize(e, this.originalBox), this.dispatchEvent({
       type: "setDta",
       originalData: this.originalData,
       data: this.data
@@ -1557,10 +1642,10 @@ class $ extends ne {
    */
   createGroups() {
     const e = [], t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Map(), i = (r, o, a = -1) => {
-      const [l, c, h, d] = this.data[r];
+      const [c, l, h, d] = this.data[r];
       if (t.add(r), d)
         return s.has(r) || s.set(r, []), s.get(r)?.push(a), n.add(this.data[r]);
-      o.push([l, c]), h.forEach((u) => {
+      o.push([c, l]), h.forEach((u) => {
         t.has(u) || i(u, o, r);
       });
     };
@@ -1589,10 +1674,10 @@ class $ extends ne {
     function n(i, r) {
       const [o, a] = e[i];
       t[i] = !0, r.push(a);
-      for (let l = 0; l < e.length; l++) {
-        const [c, h] = e[l];
-        if (!t[l] && Math.abs(a.x - c.x) < 1e-6 && Math.abs(a.y - c.y) < 1e-6)
-          return n(l, r);
+      for (let c = 0; c < e.length; c++) {
+        const [l, h] = e[c];
+        if (!t[c] && Math.abs(a.x - l.x) < 1e-6 && Math.abs(a.y - l.y) < 1e-6)
+          return n(c, r);
       }
     }
     const s = [];
@@ -1630,8 +1715,8 @@ class $ extends ne {
       if (s.distance(i) < this.width * 0.5) {
         let o = 0;
         for (let a = n + 1; a < e.length; a++) {
-          const l = e[a - 1], c = e[a];
-          if (l.distance(c) < this.width * 0.8) o++;
+          const c = e[a - 1], l = e[a];
+          if (c.distance(l) < this.width * 0.8) o++;
           else break;
         }
         o === 0 && n + o === e.length - 1 || n == 1 && o === 1 || (o === 3 ? (t.push(e[n + 1]), n += o) : o === 5 ? (t.push(e[n + 2]), n += o) : t.push(i));
@@ -1653,7 +1738,7 @@ class $ extends ne {
         break;
       }
     }
-    const t = this.mergeSameDirectionLine(Ee(e)), n = [t[0]];
+    const t = this.mergeSameDirectionLine(Me(e)), n = [t[0]];
     for (let s = 1; s < t.length; s++) {
       const i = t[s], r = t[(t.length + s - 1) % t.length];
       if (i.length() > this.width * 0.9) {
@@ -1668,7 +1753,7 @@ class $ extends ne {
       const a = t[s + 2];
       a && r.includedAngle(a) < 2 ? (s = s + 2, n.push(a)) : n.push(i);
     }
-    return n.length > 3 ? De(this.mergeSameDirectionLine(n)) : [];
+    return n.length > 3 ? Se(this.mergeSameDirectionLine(n)) : [];
   }
   /**
    * 移除短线段
@@ -1676,48 +1761,48 @@ class $ extends ne {
    * @param path 
    */
   removeShortLine(e, t = this.shortLine) {
-    const n = Ee(e), s = [], i = Math.PI / 180;
+    const n = Me(e), s = [], i = Math.PI / 180;
     for (let r = 0; r < n.length; r++) {
-      const o = n[r], a = o.length(), l = r;
+      const o = n[r], a = o.length(), c = r;
       if (a > t || s.length === 0) {
         s.push(o);
         continue;
       }
-      let c = n[++r];
+      let l = n[++r];
       const h = s[s.length - 1], d = h.direction();
       for (; r < n.length; ) {
-        const p = d.angleBetween(c.direction()) / i;
-        if (c.length() <= t || p < 4 || p > 176)
-          c = n[++r];
+        const p = d.angleBetween(l.direction()) / i;
+        if (l.length() <= t || p < 4 || p > 176)
+          l = n[++r];
         else break;
       }
-      if (!c) continue;
+      if (!l) continue;
       const u = n[r - 1];
       if (h.length() > u.length()) {
-        const p = h.getIntersection(c);
+        const p = h.getIntersection(l);
         if (p) {
-          const y = h.points[1].clone(), x = c.points[0].clone();
-          h.points[1].copy(p), c.points[0].copy(p), h.length() < this.width ? (h.points[1].copy(y), c.points[0].copy(y)) : c.length() < this.width && (h.points[1].copy(x), c.points[0].copy(x));
+          const x = h.points[1].clone(), y = l.points[0].clone();
+          h.points[1].copy(p), l.points[0].copy(p), h.length() < this.width ? (h.points[1].copy(x), l.points[0].copy(x)) : l.length() < this.width && (h.points[1].copy(y), l.points[0].copy(y));
         } else
-          h.points[1].copy(c.points[0]);
-        s.push(c);
+          h.points[1].copy(l.points[0]);
+        s.push(l);
       } else
-        r = l;
+        r = c;
     }
-    return s.length > 3 ? De(s) : [];
+    return s.length > 3 ? Se(s) : [];
   }
   /** 线偏移
    * @description 使用 ClipperLib 对每个点组进行线偏移处理，生成具有指定宽度的墙体路径
    */
-  lineOffset(e = $.EndType.etOpenSquare, t = $.JoinType.jtMiter, n = 1e4) {
-    let s = new Le.Paths();
-    const i = new Le.ClipperOffset(20, 0.25);
+  lineOffset(e = W.EndType.etOpenSquare, t = W.JoinType.jtMiter, n = 1e4) {
+    let s = new we.Paths();
+    const i = new we.ClipperOffset(20, 0.25);
     return this.pointsGroups.forEach((r) => {
-      const o = this.lineTopology(r).map((a) => a.map((l) => l.clone().mutiplyScalar(n)));
+      const o = this.lineTopology(r).map((a) => a.map((c) => c.clone().mutiplyScalar(n)));
       i.AddPaths(o, t, e);
     }), i.Execute(s, this.width / 2 * n), this.wallsGroup = s.map((r) => {
-      let o = r.map((a) => g.from(a).divisionScalar(n));
-      return o = this.lineSegmentStraightening(o), e == $.EndType.etOpenSquare && (o = this.squareRemoveBurr(o)), o;
+      let o = r.map((a) => w.from(a).divisionScalar(n));
+      return o = this.lineSegmentStraightening(o), e == W.EndType.etOpenSquare && (o = this.squareRemoveBurr(o)), o;
     }), this.dispatchEvent({
       type: "lineOffset",
       wallsGroup: this.wallsGroup
@@ -1743,22 +1828,22 @@ class $ extends ne {
    */
   getArcAngleRange(e, t, n) {
     const s = t.x - e.x, i = t.y - e.y, r = n.x - e.x, o = n.y - e.y;
-    let a = Math.atan2(i, s), l = Math.atan2(o, r);
-    a = a < 0 ? a + 2 * Math.PI : a, l = l < 0 ? l + 2 * Math.PI : l;
-    let c, h;
-    return Math.abs(l - a) <= Math.PI ? (c = Math.min(a, l), h = Math.max(a, l)) : (c = Math.max(a, l), h = Math.min(a, l) + 2 * Math.PI), [c / (Math.PI / 180), h / (Math.PI / 180)];
+    let a = Math.atan2(i, s), c = Math.atan2(o, r);
+    a = a < 0 ? a + 2 * Math.PI : a, c = c < 0 ? c + 2 * Math.PI : c;
+    let l, h;
+    return Math.abs(c - a) <= Math.PI ? (l = Math.min(a, c), h = Math.max(a, c)) : (l = Math.max(a, c), h = Math.min(a, c) + 2 * Math.PI), [l / (Math.PI / 180), h / (Math.PI / 180)];
   }
   /**
    * 线段数据转为原始json数据
    */
   lineDataToOriginalData(e, t) {
-    return $.lineDataToOriginalData(e, this.originalZAverage, t);
+    return W.lineDataToOriginalData(e, this.originalZAverage, t);
   }
   /**
    * 转为绘制数据
    */
   toDrawDataJson(e = "Millimeters") {
-    const t = at[e], n = {
+    const t = it[e], n = {
       unit: e,
       line: [],
       arc: [],
@@ -1769,62 +1854,62 @@ class $ extends ne {
       scale: t
     };
     let s = "white";
-    function i(l, c) {
-      n.line.push([l.x * t, l.y * t, c.x * t, c.y * t, s]);
+    function i(c, l) {
+      n.line.push([c.x * t, c.y * t, l.x * t, l.y * t, s]);
     }
-    function r(l, c, h, d) {
+    function r(c, l, h, d) {
       n.arc.push([
-        l.x * t,
-        l.y * t,
-        c * t,
+        c.x * t,
+        c.y * t,
+        l * t,
         h,
         d,
         s
       ]);
     }
-    for (let l = 0; l < this.originalData.length; l++) {
-      const c = this.originalData[l];
-      if (c.isVerticalReferenceLine) {
-        n.dimensionLine.push([c.start.x * t, c.start.y * t, c.end.x * t, c.end.y * t]);
+    for (let c = 0; c < this.originalData.length; c++) {
+      const l = this.originalData[c];
+      if (l.isVerticalReferenceLine) {
+        n.dimensionLine.push([l.start.x * t, l.start.y * t, l.end.x * t, l.end.y * t]);
         break;
       }
     }
-    this.wallsGroup.forEach((l) => {
-      for (let c = 0; c < l.length; c++) {
-        const h = l[c], d = c === l.length - 1 ? 0 : c + 1, u = l[d];
+    this.wallsGroup.forEach((c) => {
+      for (let l = 0; l < c.length; l++) {
+        const h = c[l], d = l === c.length - 1 ? 0 : l + 1, u = c[d];
         i(h, u);
       }
     });
     const o = this.width * 0.2, a = [];
-    return this.doorLineSegment.forEach((l) => {
-      if (l.length() < 0.4) return;
-      const c = l.clone().expansion(-this.width * 0.5);
-      if (s = "cyan", c.length() < 1.2) {
-        c.expansion(-o * 0.5);
-        const h = l.normal();
-        let d = new N(
-          c.start.clone(),
-          c.start.clone().add(h.clone().multiplyScalar(c.length()))
+    return this.doorLineSegment.forEach((c) => {
+      if (c.length() < 0.4) return;
+      const l = c.clone().expansion(-this.width * 0.5);
+      if (s = "cyan", l.length() < 1.2) {
+        l.expansion(-o * 0.5);
+        const h = c.normal();
+        let d = new R(
+          l.start.clone(),
+          l.start.clone().add(h.clone().multiplyScalar(l.length()))
         );
-        const u = d.clone().directionMove(d.normal(), c.length() * -0.5).expandToRectangle(c.length(), "bothSides");
-        for (let E = 0; E < a.length; E++)
-          if (a[E].intersectRectangle(u)) {
-            d = new N(
-              c.start.clone(),
-              c.start.clone().add(h.clone().multiplyScalar(-c.length()))
+        const u = d.clone().directionMove(d.normal(), l.length() * -0.5).expandToRectangle(l.length(), "bothSides");
+        for (let g = 0; g < a.length; g++)
+          if (a[g].intersectRectangle(u)) {
+            d = new R(
+              l.start.clone(),
+              l.start.clone().add(h.clone().multiplyScalar(-l.length()))
             );
             break;
           }
-        d.expansion(-o * 0.5).expandToRectangle(this.width * 0.2, "bothSides").path2D((E, R) => i(E, R));
-        const p = c.length(), y = d.length(), x = (p ** 2 + y ** 2) / (2 * y), S = d.end.clone().add(d.direction().multiplyScalar(-x)), [T, G] = this.getArcAngleRange(S, c.end, d.end);
-        r(S, x, Math.min(T, G), Math.max(T, G)), a.push(u);
+        d.expansion(-o * 0.5).expandToRectangle(this.width * 0.2, "bothSides").path2D((g, L) => i(g, L));
+        const p = l.length(), x = d.length(), y = (p ** 2 + x ** 2) / (2 * x), m = d.end.clone().add(d.direction().multiplyScalar(-y)), [M, T] = this.getArcAngleRange(m, l.end, d.end);
+        r(m, y, Math.min(M, T), Math.max(M, T)), a.push(u);
       } else
-        c.clone().expansion(-this.width * 0.5).expandToRectangle(this.width).path2D((h, d) => i(h, d)), c.clone().directionMove(c.normal(), o * 0.5).directionMove(c.direction(), o * 0.5).expansion(-c.length() * 0.45, "end").forward(o * 0.5).expandToRectangle(o).path2D((h, d) => i(h, d)), c.clone().directionMove(c.normal(), -o * 0.5).directionMove(c.direction(), -o * 0.5).expansion(-c.length() * 0.45, "start").forward(-o * 0.5).expandToRectangle(o).path2D((h, d) => i(h, d));
-    }), s = "yellow", this.lineSegments.forEach((l) => {
-      if (!l.userData.isWindow) return !1;
-      Array.isArray(l.userData.drawWindow) && l.userData.drawWindow.forEach((c) => {
-        const { p: h, width: d } = c, u = g.from(h), p = u.clone().add(l.direction().multiplyScalar(d * 0.5)), y = u.clone().add(l.direction().multiplyScalar(-d * 0.5)), x = new N(p, y);
-        i(x.start, x.end), x.expandToRectangle(this.width, "bothSides").path2D((S, T) => i(S, T));
+        l.clone().expansion(-this.width * 0.5).expandToRectangle(this.width).path2D((h, d) => i(h, d)), l.clone().directionMove(l.normal(), o * 0.5).directionMove(l.direction(), o * 0.5).expansion(-l.length() * 0.45, "end").forward(o * 0.5).expandToRectangle(o).path2D((h, d) => i(h, d)), l.clone().directionMove(l.normal(), -o * 0.5).directionMove(l.direction(), -o * 0.5).expansion(-l.length() * 0.45, "start").forward(-o * 0.5).expandToRectangle(o).path2D((h, d) => i(h, d));
+    }), s = "yellow", this.lineSegments.forEach((c) => {
+      if (!c.userData.isWindow) return !1;
+      Array.isArray(c.userData.drawWindow) && c.userData.drawWindow.forEach((l) => {
+        const { p: h, width: d } = l, u = w.from(h), p = u.clone().add(c.direction().multiplyScalar(d * 0.5)), x = u.clone().add(c.direction().multiplyScalar(-d * 0.5)), y = new R(p, x);
+        i(y.start, y.end), y.expandToRectangle(this.width, "bothSides").path2D((m, M) => i(m, M));
       });
     }), n;
   }
@@ -1838,8 +1923,8 @@ class $ extends ne {
     if (typeof window < "u")
       i = document.createElement("canvas");
     else if (typeof global < "u") {
-      const { createCanvas: l } = await se("canvas");
-      i = l();
+      const { createCanvas: c } = await ee("canvas");
+      i = c();
     } else
       throw new Error("创建画布失败");
     const r = 2 * s.scale, o = {
@@ -1849,17 +1934,17 @@ class $ extends ne {
     };
     i.width = s.width + r * 2, i.height = s.height + r * 2;
     const a = i.getContext("2d");
-    return n && (a.fillStyle = n, a.fillRect(0, 0, i.width, i.height)), a.translate(s.width * 0.5 + r, s.height * 0.5 + r), a.scale(1, -1), s.line.forEach(([l, c, h, d, u]) => {
-      a.strokeStyle = o[u], a.beginPath(), a.moveTo(l, c), a.lineTo(h, d), a.closePath(), a.stroke();
-    }), s.arc.forEach(([l, c, h, d, u, p]) => {
-      a.strokeStyle = o[p], a.beginPath(), a.arc(l, c, h, d * (Math.PI / 180), u * (Math.PI / 180)), a.stroke();
-    }), a.beginPath(), s.dimensionLine.forEach((l) => {
-      let [c, h, d, u] = l;
-      const p = Math.min(h, u), y = Math.max(h, u), x = (i.width * 0.5 - 0.4 * s.scale) * (c < 0 ? -1 : 1), S = (y - p) * 0.45;
-      a.fillStyle = "#fff", a.font = `${0.15 * s.scale}px Arial`, a.textAlign = "center", a.textBaseline = "middle", a.save(), a.translate(x, p + (y - p) * 0.5), a.scale(1, -1), a.fillText((y - p).toFixed(2) + "cm", 0, 0), a.restore(), a.moveTo(x - 0.1 * s.scale, p), a.lineTo(x + 0.1 * s.scale, p), a.moveTo(x, p), a.lineTo(x, S + p), a.moveTo(x, y), a.lineTo(x, y - S), a.moveTo(x - 0.1 * s.scale, y), a.lineTo(x + 0.1 * s.scale, y);
-    }), a.closePath(), a.strokeStyle = "#fff", a.stroke(), "toBlob" in i ? new Promise((l) => {
-      i.toBlob((c) => {
-        l(c);
+    return n && (a.fillStyle = n, a.fillRect(0, 0, i.width, i.height)), a.translate(s.width * 0.5 + r, s.height * 0.5 + r), a.scale(1, -1), s.line.forEach(([c, l, h, d, u]) => {
+      a.strokeStyle = o[u], a.beginPath(), a.moveTo(c, l), a.lineTo(h, d), a.closePath(), a.stroke();
+    }), s.arc.forEach(([c, l, h, d, u, p]) => {
+      a.strokeStyle = o[p], a.beginPath(), a.arc(c, l, h, d * (Math.PI / 180), u * (Math.PI / 180)), a.stroke();
+    }), a.beginPath(), s.dimensionLine.forEach((c) => {
+      let [l, h, d, u] = c;
+      const p = Math.min(h, u), x = Math.max(h, u), y = (i.width * 0.5 - 0.4 * s.scale) * (l < 0 ? -1 : 1), m = (x - p) * 0.45;
+      a.fillStyle = "#fff", a.font = `${0.15 * s.scale}px Arial`, a.textAlign = "center", a.textBaseline = "middle", a.save(), a.translate(y, p + (x - p) * 0.5), a.scale(1, -1), a.fillText((x - p).toFixed(2) + "cm", 0, 0), a.restore(), a.moveTo(y - 0.1 * s.scale, p), a.lineTo(y + 0.1 * s.scale, p), a.moveTo(y, p), a.lineTo(y, m + p), a.moveTo(y, x), a.lineTo(y, x - m), a.moveTo(y - 0.1 * s.scale, x), a.lineTo(y + 0.1 * s.scale, x);
+    }), a.closePath(), a.strokeStyle = "#fff", a.stroke(), "toBlob" in i ? new Promise((c) => {
+      i.toBlob((l) => {
+        c(l);
       }, t, 1);
     }) : i.toBuffer(t, { quality: 1 });
   }
@@ -1867,15 +1952,15 @@ class $ extends ne {
    * 将点json结构转换为Dxf string
    */
   toDxfString(e = "Millimeters") {
-    const t = new ae();
-    t.setUnits(e), t.addLayer("cyan", ae.ACI.CYAN, "DOTTED"), t.addLayer("yellow", ae.ACI.YELLOW, "DOTTED"), t.addLayer("white", ae.ACI.WHITE, "DOTTED");
+    const t = new se();
+    t.setUnits(e), t.addLayer("cyan", se.ACI.CYAN, "DOTTED"), t.addLayer("yellow", se.ACI.YELLOW, "DOTTED"), t.addLayer("white", se.ACI.WHITE, "DOTTED");
     const n = this.toDrawDataJson();
     return n.line.forEach((s) => {
-      let [i, r, o, a, l] = s;
-      t.setActiveLayer(l), t.drawLine(i, r, o, a);
+      let [i, r, o, a, c] = s;
+      t.setActiveLayer(c), t.drawLine(i, r, o, a);
     }), n.arc.forEach((s) => {
-      const [i, r, o, a, l, c] = s;
-      t.setActiveLayer(c), t.drawArc(i, r, o, a, l);
+      const [i, r, o, a, c, l] = s;
+      t.setActiveLayer(l), t.drawArc(i, r, o, a, c);
     }), t.toDxfString();
   }
   /**
@@ -1894,7 +1979,7 @@ class $ extends ne {
     if (typeof window < "u") {
       const n = new Blob([t], { type: "application/json" }), s = document.createElement("a");
       s.href = URL.createObjectURL(n), s.download = e, s.click();
-    } else typeof global < "u" && (await se("fs", !1)).writeFileSync(e, t);
+    } else typeof global < "u" && (await ee("fs", !1)).writeFileSync(e, t);
   }
   /**
    * 下载
@@ -1904,7 +1989,7 @@ class $ extends ne {
     if (typeof window < "u") {
       const n = this.toDxfBlob(t), s = document.createElement("a");
       s.href = URL.createObjectURL(n), s.download = e + ".dxf", s.click();
-    } else typeof global < "u" && (await se("fs", !1)).writeFileSync(e, this.toDxfString(t));
+    } else typeof global < "u" && (await ee("fs", !1)).writeFileSync(e, this.toDxfString(t));
   }
   /**
    * 下载
@@ -1916,7 +2001,7 @@ class $ extends ne {
     if (typeof window < "u") {
       const i = document.createElement("a");
       i.href = URL.createObjectURL(s), i.download = e, i.click();
-    } else typeof global < "u" ? (await se("fs", !1)).writeFileSync(e, s) : console.error("图片下载失败");
+    } else typeof global < "u" ? (await ee("fs", !1)).writeFileSync(e, s) : console.error("图片下载失败");
     return !0;
   }
   /**
@@ -1925,14 +2010,17 @@ class $ extends ne {
    * @returns 
    */
   computedOriginalSize(e, t = new j(0, 0, 0, 0)) {
-    const n = e.flatMap((l) => [l.start.x, l.end.x]), s = e.flatMap((l) => [l.start.y, l.end.y]), i = Math.min(...n), r = Math.min(...s), o = Math.max(...n), a = Math.max(...s);
+    const n = e.flatMap((c) => [c.start.x, c.end.x]), s = e.flatMap((c) => [c.start.y, c.end.y]), i = Math.min(...n), r = Math.min(...s), o = Math.max(...n), a = Math.max(...s);
     return t.set(i, r, o, a), t;
   }
+  get boundaryExtension() {
+    return W.boundaryExtension.bind(this);
+  }
   /**
    * 线段数据转为原始json数据
    */
   static lineDataToOriginalData(e, t = 0, n) {
-    return n || (n = new Z(j.fromByLineSegment(...e)), e.forEach((s) => n?.insert({ line: s, userData: void 0 }))), e.map((s) => {
+    return n || (n = new J(j.fromByLineSegment(...e)), e.forEach((s) => n?.insert({ line: s, userData: void 0 }))), e.map((s) => {
       const i = s.userData, r = i.drawWindow, o = n.queryLineSegment(s).filter((a) => a.line !== s && !a.userData?.isDoor).map((a) => ({ index: e.indexOf(a.line) }));
       return {
         start: s.start.toJson(t),
@@ -1961,13 +2049,13 @@ class $ extends ne {
     let n = 0;
     return e.flatMap((i) => {
       const r = i.map((o, a) => {
-        const l = a === i.length - 1 ? 0 : a + 1, c = i[l];
+        const c = a === i.length - 1 ? 0 : a + 1, l = i[c];
         return {
           start: { x: o.x, y: o.y },
-          end: { x: c.x, y: c.y },
+          end: { x: l.x, y: l.y },
           insetionArr: [
             {
-              index: l + n
+              index: c + n
             }
           ]
         };
@@ -1975,6 +2063,48 @@ class $ extends ne {
       return n += i.length, t || (r.pop(), r[r.length - 1].insetionArr.length = 0, n--), r;
     });
   }
+  /** 根据交点，对线段进行裁剪
+   * @param this
+   * @param lines
+   */
+  static lineSegmentClipping(e) {
+    const t = new J(j.fromByLineSegment(...e));
+    return e.forEach((n) => t.insert({ line: n, userData: void 0 })), e.flatMap((n) => {
+      const s = t.queryLineSegment(n, !0).map((i) => {
+        if (i.line === n) return;
+        const r = i.line.getIntersection(n);
+        if (!(!r || n.start.equal(r) || n.end.equal(r)))
+          return r;
+      }).filter((i) => !!i);
+      if (s.length) {
+        const i = n.clone();
+        s.sort((o, a) => i.start.distance(o) - i.start.distance(a));
+        const r = s.map((o) => {
+          const a = i.clone();
+          return a.set(i.start.clone(), o), i.start.copy(o), i.userData.isWindow && (a.userData.isWindow = !0, a.userData.drawWindow = i.userData.drawWindow?.filter((c) => a.isPointOnSegment(w.from(c.p))) ?? []), a;
+        });
+        return i.userData.drawWindow = i.userData.drawWindow?.filter((o) => i.isPointOnSegment(w.from(o.p))) ?? [], [...r, i];
+      }
+      return n;
+    }).filter((n) => n.length() > 0.03);
+  }
+  /**
+   * 重新计算窗户
+   * @param windowLines 
+   */
+  static recomputedWindow(...e) {
+    e.forEach((t) => {
+      const n = t.direction();
+      t.userData.drawWindow?.forEach((s) => {
+        const i = w.from(s.p), r = t.projectPoint(
+          i.clone().add(n.clone().multiplyScalar(s.width * 0.5))
+        ), o = t.projectPoint(
+          i.clone().add(n.clone().multiplyScalar(s.width * -0.5))
+        ), a = new R(r, o), c = a.center;
+        s.p = new z.Vector3(c?.x ?? 0, c?.y ?? 0, s.p.z);
+      });
+    });
+  }
   /**
    * 轴对齐垂直修正
    * @param lines 待调整线段组
@@ -1983,272 +2113,239 @@ class $ extends ne {
    */
   static axisAlignmentCorrection(e, t, n) {
     const { principalAxisThreshold: s = 0.3, crossAxistThreshold: i = 0.06, snapThreshold: r = 0.2 } = n ?? {};
-    function o(D, b) {
-      const L = [];
-      for (let M = 0; M < D.length; M++) {
-        const m = D[M], w = /* @__PURE__ */ new Map();
-        m.userData.isDoor || m.points.forEach((I) => {
-          if (b.queryPoint(I).length > 1) return;
-          const A = b.queryCircle(I, 0.4).filter((F) => {
-            const v = F.userData;
-            if (v === m || !m.parallel(v, 25)) return !1;
-            if (b.queryPoint(F.point).length > 1) return;
-            const _ = new N(I, F.point), q = new N(m.start === I ? m.end : m.start, v.start === F.point ? v.end : v.start);
-            if (!_.intersectLineSegment(q)) return !1;
-            const Y = I.distance(F.point);
-            return Y < 1e-3 ? !1 : (w.set(F.point, Y), !0);
-          }).sort((F, v) => {
-            const _ = w.get(F.point), q = w.get(v.point);
-            return _ - q;
+    function o(b, v) {
+      const E = [];
+      for (let A = 0; A < b.length; A++) {
+        const S = b[A], D = /* @__PURE__ */ new Map();
+        S.userData.isDoor || S.points.forEach((C) => {
+          if (v.queryPoint(C).length > 1) return;
+          const I = v.queryCircle(C, 0.4).filter((U) => {
+            const B = U.userData;
+            if (B === S || !S.parallel(B, 25)) return !1;
+            if (v.queryPoint(U.point).length > 1) return;
+            const q = new R(C, U.point), _ = new R(S.start === C ? S.end : S.start, B.start === U.point ? B.end : B.start);
+            if (!q.intersectLineSegment(_)) return !1;
+            const H = C.distance(U.point);
+            return H < 1e-3 ? !1 : (D.set(U.point, H), !0);
+          }).sort((U, B) => {
+            const q = D.get(U.point), _ = D.get(B.point);
+            return q - _;
           });
-          if (A.length === 0) return;
-          const B = A[0].userData;
-          L.push(new N(m.projectLineSegment(B).center, B.projectLineSegment(m).center));
+          if (I.length === 0) return;
+          const G = I[0].userData;
+          E.push(new R(S.projectLineSegment(G).center, G.projectLineSegment(S).center));
         });
       }
-      return [...D, ...L];
+      return [...b, ...E];
     }
-    function a(D) {
-      const b = new ge(), L = new Z(j.fromByLineSegment(...D)), M = [];
-      return D.forEach((m) => {
-        m.userData.isDoor ? M.push(m) : (m.points.forEach((w) => b.insert(w, m)), L.insert({ line: m, userData: void 0 }));
-      }), M.forEach((m) => {
-        const w = b.queryPoint(m.start), I = b.queryPoint(m.end);
-        w.length ? m.userData.startIntersection = w[0].userData : m.userData.startIntersection = L.queryPoint(m.start)[0]?.line, I.length ? m.userData.endIntersection = I[0].userData : m.userData.endIntersection = L.queryPoint(m.end)[0]?.line;
-      }), D = o(D, b), D;
+    function a(b) {
+      const v = new oe(), E = new J(j.fromByLineSegment(...b)), A = [];
+      return b.forEach((S) => {
+        S.userData.isDoor ? A.push(S) : (S.points.forEach((D) => v.insert(D, S)), E.insert({ line: S, userData: void 0 }));
+      }), A.forEach((S) => {
+        const D = v.queryPoint(S.start), C = v.queryPoint(S.end);
+        D.length ? S.userData.startIntersection = D[0].userData : S.userData.startIntersection = E.queryPoint(S.start)[0]?.line, C.length ? S.userData.endIntersection = C[0].userData : S.userData.endIntersection = E.queryPoint(S.end)[0]?.line;
+      }), b = o(b, v), b;
     }
-    function l(D) {
-      const b = new Z(j.fromByLineSegment(...D));
-      D.forEach((M) => {
-        M.userData.isDoor || b.insert({ line: M, userData: void 0 });
+    function c(b) {
+      const v = new J(j.fromByLineSegment(...b));
+      b.forEach((A) => {
+        A.userData.isDoor || v.insert({ line: A, userData: void 0 });
       });
-      const L = /* @__PURE__ */ new Map();
-      for (let M = 0; M < D.length; M++) {
-        const m = D[M];
-        L.set(m, b.queryLineSegment(m).filter((w) => w.line !== m).map((w) => w.line));
+      const E = /* @__PURE__ */ new Map();
+      for (let A = 0; A < b.length; A++) {
+        const S = b[A];
+        E.set(S, v.queryLineSegment(S).filter((D) => D.line !== S && !D.line.isParallel(S)).map((D) => D.line));
       }
-      return L;
+      return E;
     }
-    function c(D, b) {
-      const L = [D], M = [], m = [], w = [];
-      for (let I = 0; I < b.length; I++) {
-        const A = b[I];
-        if (D !== A)
-          if (A.userData.isWindow && w.push(A), A.parallel(D, 45)) {
-            const B = Math.atan2(A.end.y - A.start.y, A.end.x - A.start.x);
-            let v = Math.atan2(D.end.y - D.start.y, D.end.x - D.start.x) - B;
-            for (; v > Math.PI; ) v -= 2 * Math.PI;
-            for (; v < -Math.PI; ) v += 2 * Math.PI;
-            const _ = A.center;
-            A.start.rotate(_, v), A.end.rotate(_, v), A.userData.isDoor ? m.push(A) : L.push(A);
+    function l(b, v) {
+      const E = [b], A = [], S = [], D = [];
+      for (let C = 0; C < v.length; C++) {
+        const I = v[C];
+        if (b !== I)
+          if (I.userData.isWindow && D.push(I), I.parallel(b, 45)) {
+            const G = Math.atan2(I.end.y - I.start.y, I.end.x - I.start.x);
+            let B = Math.atan2(b.end.y - b.start.y, b.end.x - b.start.x) - G;
+            for (; B > Math.PI; ) B -= 2 * Math.PI;
+            for (; B < -Math.PI; ) B += 2 * Math.PI;
+            const q = I.center;
+            I.start.rotate(q, B), I.end.rotate(q, B), I.userData.isDoor ? S.push(I) : E.push(I);
           } else {
-            const B = Math.atan2(A.end.y - A.start.y, A.end.x - A.start.x), F = Math.atan2(D.end.y - D.start.y, D.end.x - D.start.x);
-            let v = F + Math.PI / 2 - B, _ = F - Math.PI / 2 - B;
-            for (; v > Math.PI; ) v -= 2 * Math.PI;
-            for (; v < -Math.PI; ) v += 2 * Math.PI;
-            for (; _ > Math.PI; ) _ -= 2 * Math.PI;
-            for (; _ < -Math.PI; ) _ += 2 * Math.PI;
-            const q = Math.abs(v) < Math.abs(_) ? v : _, Y = A.center;
-            A.start.rotate(Y, q), A.end.rotate(Y, q), A.userData.isDoor ? m.push(A) : M.push(A);
+            const G = Math.atan2(I.end.y - I.start.y, I.end.x - I.start.x), U = Math.atan2(b.end.y - b.start.y, b.end.x - b.start.x);
+            let B = U + Math.PI / 2 - G, q = U - Math.PI / 2 - G;
+            for (; B > Math.PI; ) B -= 2 * Math.PI;
+            for (; B < -Math.PI; ) B += 2 * Math.PI;
+            for (; q > Math.PI; ) q -= 2 * Math.PI;
+            for (; q < -Math.PI; ) q += 2 * Math.PI;
+            const _ = Math.abs(B) < Math.abs(q) ? B : q, H = I.center;
+            I.start.rotate(H, _), I.end.rotate(H, _), I.userData.isDoor ? S.push(I) : A.push(I);
           }
       }
-      return { parallelLines: L, verticalLines: M, doorLines: m, windowLines: w };
+      return { parallelLines: E, verticalLines: A, doorLines: S, windowLines: D };
     }
-    function h(D, b, L) {
-      const M = [];
-      D.forEach((I) => {
-        const A = L.projectPoint(I.start, !1);
-        A && (A.userData = I, M.push(A));
-      }), M.sort((I, A) => A.distance(L.start) - I.distance(L.start));
-      const m = [], w = [];
-      for (let I = 0; I < M.length; I++) {
-        const A = M[I];
-        if (I === 0) {
-          w.push(A);
+    function h(b, v, E) {
+      const A = [];
+      b.forEach((C) => {
+        const I = E.projectPoint(C.start, !1);
+        I && (I.userData = C, A.push(I));
+      }), A.sort((C, I) => I.distance(E.start) - C.distance(E.start));
+      const S = [], D = [];
+      for (let C = 0; C < A.length; C++) {
+        const I = A[C];
+        if (C === 0) {
+          D.push(I);
           continue;
         }
-        M[I - 1].distance(A) < i || (m.push([...w]), w.length = 0), w.push(A), I === M.length - 1 && m.push(w);
+        A[C - 1].distance(I) < i || (S.push([...D]), D.length = 0), D.push(I), C === A.length - 1 && S.push(D);
       }
-      return m.flatMap((I) => {
-        const A = I.flatMap((_) => {
-          const q = _.userData;
-          return q.points.map((Y) => {
-            const Q = b.projectPoint(Y, !1);
-            return Q.userData = q, Q;
+      return S.flatMap((C) => {
+        const I = C.flatMap((q) => {
+          const _ = q.userData;
+          return _.points.map((H) => {
+            const te = v.projectPoint(H, !1);
+            return te.userData = _, te;
           });
         });
-        A.sort((_, q) => _.distance(b.start) - q.distance(b.start));
-        const B = /* @__PURE__ */ new Map(), F = [], v = [];
-        return A.forEach((_, q) => {
-          B.size === 0 && q > 0 && A[q - 1].distance(_) > s && (F.push([...v]), v.length = 0), B.set(_.userData, (B.get(_.userData) ?? 0) + 1);
-          for (const Y of B.values()) if (Y !== 2) return;
-          v.push(...B.keys()), B.clear();
-        }), F.push([...v]), F;
+        I.sort((q, _) => q.distance(v.start) - _.distance(v.start));
+        const G = /* @__PURE__ */ new Map(), U = [], B = [];
+        return I.forEach((q, _) => {
+          G.size === 0 && _ > 0 && I[_ - 1].distance(q) > s && (U.push([...B]), B.length = 0), G.set(q.userData, (G.get(q.userData) ?? 0) + 1);
+          for (const H of G.values()) if (H !== 2) return;
+          B.push(...G.keys()), G.clear();
+        }), U.push([...B]), U;
       });
     }
-    function d(D, b) {
-      const L = /* @__PURE__ */ new Set();
-      return D.forEach((M) => {
-        for (let m = 1; m < M.length; m++) {
-          const w = M[m], I = M[m - 1];
-          [...b.get(w) ?? [], ...b.get(I) ?? []].forEach((B) => {
-            B.sameEndpointAsStart(w) && B.sameEndpointAsEnd(I) && B.sameEndpointAsStart(I) && B.sameEndpointAsEnd(w) && L.add(B);
+    function d(b, v) {
+      const E = /* @__PURE__ */ new Set();
+      return b.forEach((A) => {
+        for (let S = 1; S < A.length; S++) {
+          const D = A[S], C = A[S - 1];
+          [...v.get(D) ?? [], ...v.get(C) ?? []].forEach((G) => {
+            (G.sameEndpointAsStart(D) && G.sameEndpointAsEnd(C) || G.sameEndpointAsStart(C) && G.sameEndpointAsEnd(D)) && E.add(G);
           });
         }
-      }), D.map((M) => M.filter((m) => !L.has(m)));
+      }), b.map((A) => A.filter((S) => !E.has(S)));
     }
-    function u(D, b = 0.1) {
-      return D.map((L) => {
-        if (L.length === 0) return;
-        if (L.length === 1) return L[0];
-        const M = [];
-        L.forEach((K) => {
-          M.push(K.start.clone(), K.end.clone());
-        });
-        const m = L[0].direction().normalize();
-        let w = 1 / 0, I = -1 / 0, A = 0, B = 0;
-        M.forEach((K) => {
-          const re = K.x * m.x + K.y * m.y;
-          w = Math.min(w, re), I = Math.max(I, re), A += K.x, B += K.y;
+    function u(b, v = 0.1) {
+      return b.map((E) => {
+        if (E.length === 0) return;
+        if (E.length === 1) return E[0];
+        const A = [];
+        E.forEach((U) => A.push(U.start.clone(), U.end.clone()));
+        const S = R.mergeLines(...E);
+        let D = 1 / 0, C = -1 / 0;
+        const I = E[0].normal().normalize();
+        D = 1 / 0, C = -1 / 0, A.forEach((U) => {
+          const B = U.x * I.x + U.y * I.y;
+          D = Math.min(D, B), C = Math.max(C, B);
         });
-        const F = new g(A / M.length, B / M.length), v = F.x * m.x + F.y * m.y, _ = new g(F.x + (w - v) * m.x, F.y + (w - v) * m.y), q = new g(F.x + (I - v) * m.x, F.y + (I - v) * m.y), Y = new N(_, q), Q = L[0].normal().normalize();
-        w = 1 / 0, I = -1 / 0, M.forEach((K) => {
-          const re = K.x * Q.x + K.y * Q.y;
-          w = Math.min(w, re), I = Math.max(I, re);
-        });
-        const ie = I - w;
-        return ie >= b && (Y.userData.wallWidth = ie), L.forEach((K) => K.userData.fittedLine = Y), Y;
-      }).filter((L) => !!L);
+        const G = C - D;
+        return G >= v && (S.userData.wallWidth = G), E.forEach((U) => U.userData.fittedLine = S), S;
+      }).filter((E) => !!E);
     }
-    function p(D) {
-      const b = new Z(j.fromByLineSegment(...D)), L = /* @__PURE__ */ new Map();
-      D.forEach((m) => {
-        L.set(m, { line: m, userData: void 0 }), b.insert(L.get(m));
+    function p(b) {
+      const v = new J(j.fromByLineSegment(...b)), E = /* @__PURE__ */ new Map();
+      b.forEach((S) => {
+        E.set(S, { line: S, userData: void 0 }), v.insert(E.get(S));
       });
-      const M = new N();
-      for (let m = 0; m < D.length; m++) {
-        const w = D[m];
-        if (w.userData.isAdsorbed) continue;
-        const I = w.direction().multiplyScalar(r), [A, B] = w.points.map((F) => {
-          M.set(F, F), M.start.add(I), M.end.add(I.multiplyScalar(-1));
-          const v = /* @__PURE__ */ new Map(), _ = b.queryRect(M.expandToRectangle(0.1, "bothSides")).filter((q) => q.line !== w).map((q) => {
-            const Y = q.line.getIntersection(M);
-            return v.set(q.line, Y), q.line;
-          }).sort((q, Y) => {
-            const Q = v.get(q), ie = v.get(Y);
-            return Q && ie ? Q.distance(F) - ie.distance(F) : 0;
+      const A = new R();
+      for (let S = 0; S < b.length; S++) {
+        const D = b[S];
+        if (D.userData.isAdsorbed) continue;
+        const C = D.direction().multiplyScalar(r), [I, G] = D.points.map((U) => {
+          A.set(U, U), A.start.add(C), A.end.add(C.multiplyScalar(-1));
+          const B = /* @__PURE__ */ new Map(), q = v.queryRect(A.expandToRectangle(0.1, "bothSides")).filter((_) => _.line !== D).map((_) => {
+            const H = _.line.getIntersection(A);
+            return B.set(_.line, H), _.line;
+          }).sort((_, H) => {
+            const te = B.get(_), me = B.get(H);
+            return te && me ? te.distance(U) - me.distance(U) : 0;
           });
-          return _.length ? v.get(_[0]) : void 0;
+          return q.length ? B.get(q[0]) : void 0;
         });
-        if (A && B) {
-          if (A.equal(B)) {
-            const F = w.start.distance(A), v = w.end.distance(B);
-            F < v ? w.directionMove(w.start.direction(w.end), F) : w.directionMove(w.end.direction(w.start), v);
+        if (I && G) {
+          if (I.equal(G)) {
+            const U = D.start.distance(I), B = D.end.distance(G);
+            U < B ? D.directionMove(D.start.direction(D.end), U) : D.directionMove(D.end.direction(D.start), B);
           } else
-            w.start.copy(A), w.end.copy(B);
-          w.userData.isAdsorbed = !0;
-        } else A ? w.start.copy(A) : B && w.end.copy(B);
-        b.remove(L.get(w)), b.insert(L.get(w));
+            D.start.copy(I), D.end.copy(G);
+          D.userData.isAdsorbed = !0;
+        } else I ? D.start.copy(I) : G && D.end.copy(G);
+        v.remove(E.get(D)), v.insert(E.get(D));
       }
-      return D.filter((m) => m.length() > 1e-3);
+      return b.filter((S) => S.length() > 1e-3);
     }
-    function y(D) {
-      for (let b = 0; b < D.length; b++) {
-        const L = D[b], M = L.userData.fittedLine;
-        if (M) {
-          const m = L.direction();
-          M.userData.isWindow = !0, M.userData.drawWindow = M.userData.drawWindow ?? [], L.userData.drawWindow?.forEach((w) => {
-            const I = g.from(w.p), A = M.projectPoint(
-              I.clone().add(m.clone().multiplyScalar(w.width * 0.5))
-            ), B = M.projectPoint(
-              I.clone().add(m.clone().multiplyScalar(w.width * -0.5))
-            ), F = new N(A, B), v = F.center;
-            M.userData.drawWindow?.push({
-              p: new z.Vector3(v?.x ?? 0, v?.y ?? 0, w.p.z),
-              width: F.length(),
-              full: w.full
+    function x(b) {
+      for (let v = 0; v < b.length; v++) {
+        const E = b[v], A = E.userData.fittedLine;
+        if (A) {
+          const S = E.direction();
+          A.userData.isWindow = !0, A.userData.drawWindow = A.userData.drawWindow ?? [], E.userData.drawWindow?.forEach((D) => {
+            const C = w.from(D.p), I = A.projectPoint(
+              C.clone().add(S.clone().multiplyScalar(D.width * 0.5))
+            ), G = A.projectPoint(
+              C.clone().add(S.clone().multiplyScalar(D.width * -0.5))
+            ), U = new R(I, G), B = U.center;
+            A.userData.drawWindow?.push({
+              p: new z.Vector3(B?.x ?? 0, B?.y ?? 0, D.p.z),
+              width: U.length(),
+              full: D.full
             });
           });
         }
       }
     }
-    function x(D) {
-      for (let b = 0; b < D.length; b++) {
-        const L = D[b];
-        let { endIntersection: M, startIntersection: m } = L.userData;
-        if (!(!M || !m)) {
-          if (m.userData.fittedLine && (m = m.userData.fittedLine), M.userData.fittedLine && (M = M.userData.fittedLine), L.isParallel(m))
-            L.start.distance(m.start) < L.start.distance(m.end) ? L.start.copy(m.start) : L.start.copy(m.end);
+    function y(b) {
+      for (let v = 0; v < b.length; v++) {
+        const E = b[v];
+        let { endIntersection: A, startIntersection: S } = E.userData;
+        if (!(!A || !S)) {
+          if (S.userData.fittedLine && (S = S.userData.fittedLine), A.userData.fittedLine && (A = A.userData.fittedLine), E.isParallel(S))
+            E.start.distance(S.start) < E.start.distance(S.end) ? E.start.copy(S.start) : E.start.copy(S.end);
           else {
-            const w = m.projectPoint(L.start);
-            w && L.start.copy(w);
+            const D = S.projectPoint(E.start);
+            D && E.start.copy(D);
           }
-          if (L.isParallel(M))
-            L.end.distance(M.start) < L.end.distance(M.end) ? L.end.copy(M.start) : L.end.copy(M.end);
+          if (E.isParallel(A))
+            E.end.distance(A.start) < E.end.distance(A.end) ? E.end.copy(A.start) : E.end.copy(A.end);
           else {
-            const w = M.projectPoint(L.end);
-            w && L.end.copy(w);
+            const D = A.projectPoint(E.end);
+            D && E.end.copy(D);
           }
         }
       }
-      return D;
+      return b;
     }
-    function S(D) {
-      const b = new Z(j.fromByLineSegment(...D));
-      return D.forEach((L) => b.insert({ line: L, userData: void 0 })), D.flatMap((L) => {
-        const M = b.queryLineSegment(L, !0).map((m) => {
-          if (m.line === L) return;
-          const w = m.line.getIntersection(L);
-          if (!(!w || L.start.equal(w) || L.end.equal(w)))
-            return w;
-        }).filter((m) => !!m);
-        if (M.length) {
-          const m = L.clone();
-          M.sort((I, A) => m.start.distance(I) - m.start.distance(A));
-          const w = M.map((I) => {
-            const A = m.clone();
-            return A.set(m.start.clone(), I), m.start.copy(I), m.userData.isWindow && (A.userData.isWindow = !0, A.userData.drawWindow = m.userData.drawWindow?.filter((B) => A.isPointOnSegment(g.from(B.p))) ?? []), A;
-          });
-          return m.userData.drawWindow = m.userData.drawWindow?.filter((I) => m.isPointOnSegment(g.from(I.p))) ?? [], [...w, m];
-        }
-        return L;
-      }).filter((L) => L.length() > 0.03);
-    }
-    e = a(e.map((D) => D.clone()));
-    const T = l(e), { parallelLines: G, verticalLines: E, doorLines: R, windowLines: U } = c(t, e), P = t.normal(), O = t.center, X = t.direction(), k = new N(
-      O.clone().add(P.clone().multiplyScalar(-1e3)),
-      O.clone().add(P.clone().multiplyScalar(1e3))
-    ), W = new N(
-      O.clone().add(X.clone().multiplyScalar(-1e3)),
-      O.clone().add(X.clone().multiplyScalar(1e3))
+    e = a(e.map((b) => b.clone()));
+    const m = c(e), { parallelLines: M, verticalLines: T, doorLines: g, windowLines: L } = l(t, e), O = t.normal(), P = t.center, N = t.direction(), Y = new R(
+      P.clone().add(O.clone().multiplyScalar(-1e3)),
+      P.clone().add(O.clone().multiplyScalar(1e3))
+    ), k = new R(
+      P.clone().add(N.clone().multiplyScalar(-1e3)),
+      P.clone().add(N.clone().multiplyScalar(1e3))
     );
-    let J = [
-      ...h.call(this, G, W, k),
-      ...h.call(this, E, k, W)
+    let V = [
+      ...h.call(this, M, k, Y),
+      ...h.call(this, T, Y, k)
     ];
-    J = d(J, T);
-    let V = u(J);
-    return V = p.call(this, V), V = p.call(this, V), y(U), x(R), V = S.call(this, V), V.push(...R), V;
+    V = d(V, m);
+    let X = u(V);
+    return X = p.call(this, X), X = p.call(this, X), x(L), y(g), X = W.lineSegmentClipping.call(this, X), X.push(...g), X;
   }
-  /** 
+  /** 查找外墙
    * @param lines 
    * @param trajectoryPoints
    * @returns 
    */
   static findExteriorWall(e, t, n = 0.4) {
-    const s = new Z(j.fromByLineSegment(...e));
+    const s = new J(j.fromByLineSegment(...e));
     return e.forEach((i) => s.insert({ line: i, userData: void 0 })), e = e.filter((i) => {
       const r = i.center, o = /* @__PURE__ */ new Set();
       for (const a of t) {
         if (o.size === 2) break;
-        const l = new N(r, a);
-        if (!s.queryLineSegment(l).filter((h) => {
-          if (h.line === i) return !1;
-          if (h.line.isParallel(i)) {
-            if (i.getMinLength(h.line) < n) return !1;
-          } else if (h.line.sameEndpoint(i) && h.line.length() < n) return !1;
-          return !0;
-        }).length) {
+        const c = new R(r, a);
+        if (!s.queryLineSegment(c).filter((h) => !(h.line === i || h.line.parallel(i) && i.getMinLength(h.line) < n && h.line.projectLineSegment(i).length() / i.length() > 0.6)).length) {
           const h = i.pointPosition(a);
           h !== "on" && o.add(h);
         }
@@ -2261,36 +2358,90 @@ class $ extends ne {
    * @param trajectoryPoints 
    */
   static boundaryExtension(e, t, n = 0.1) {
-    const s = Object.keys(t).map((c) => g.from(t[c])), i = [];
-    let r = e.map(({ start: c, end: h, ...d }) => {
-      const u = new N(g.from(c), g.from(h));
-      return u.userData = d, i.push(c.z ?? 0, h.z ?? 0), u;
+    function s(m, M) {
+      return M.queryLineSegment(m).filter((T) => T.line !== m).map(({ line: T }) => {
+        const g = { resultLine: T, type: "intersect", direction: "vertical", point: null, newLine: null };
+        m.sameEndpoint(T) && (g.type = "endpoint"), m.parallel(T) && (g.direction = "parallel");
+        const L = m.getSameEndpoint(T);
+        if (L) g.point = L[1];
+        else {
+          const O = T.getIntersection(m);
+          O && (g.point = T.start.equal(O) ? T.start : T.end);
+        }
+        return g;
+      });
+    }
+    function i(m) {
+      const M = m.userData.expandDirect;
+      if (M === "left") {
+        const T = m.getLeftDirection();
+        m.directionMove(T, n * 0.5);
+      } else if (M === "right") {
+        const T = m.getRightDirection();
+        m.directionMove(T, n * 0.5);
+      }
+    }
+    function r({ resultLine: m, type: M, direction: T, point: g }, L, O, P) {
+      if (M === "intersect")
+        g && g.copy(L.projectPoint(g) ?? g);
+      else if (T === "vertical") {
+        if (g) {
+          const N = L.projectPoint(g, !1);
+          g.copy(N), L.isPointOnSegment(N) || (L.start.distance(N) < L.end.distance(N) ? P.push(new R(N.clone(), L.start.clone())) : P.push(new R(N.clone(), L.end.clone())));
+        }
+      } else if (!d.includes(m) && g) {
+        let N = L.projectPoint(g, !1), Y;
+        if (L.start.distance(g) < L.end.distance(g) ? Y = L.start : Y = L.end, N) {
+          P.push(new R(g.clone(), N.clone()));
+          const k = new R(N.clone(), Y.clone());
+          k.length() && P.push(k);
+        }
+      }
+      O.update(m);
+    }
+    const o = Object.keys(t).map((m) => w.from(t[m])), a = [];
+    let c = e.map(({ start: m, end: M, ...T }) => {
+      const g = new R(w.from(m), w.from(M));
+      return g.userData = T, a.push(m.z ?? 0, M.z ?? 0), g;
     });
-    const o = i.reduce((c, h) => c + h, 0) / i.length, a = $.findExteriorWall(r, s), l = a.filter((c) => c.userData.expandDirect);
-    return r = r.filter((c) => !(a.includes(c) && !c.userData.expandDirect)), l.forEach((c) => {
-      const h = c.userData.expandDirect;
-      if (h === "left") {
-        const d = c.getLeftDirection();
-        c.directionMove(d, n * 0.5);
-      } else if (h === "right") {
-        const d = c.getRightDirection();
-        c.directionMove(d, n * 0.5);
+    const l = a.reduce((m, M) => m + M, 0) / a.length, h = W.findExteriorWall(c, o);
+    let d = h.filter((m) => m.userData.expandDirect);
+    c = c.filter((m) => !h.includes(m)), c.push(...d);
+    const u = R.groupBySamePointAndParallel(d), p = new J(j.fromByLineSegment(...c));
+    c.forEach((m) => m.userData.isDoor || p.insert(m));
+    const x = u.map((m) => m.flatMap((M) => s(M, p))), y = [];
+    return u.flatMap((m, M) => (m.forEach((g) => (i(g), p.update(g))), x[M].filter((g) => {
+      if (!d.includes(g.resultLine)) {
+        let L;
+        return Object.defineProperty(g, "newLine", {
+          get() {
+            return L || (L = R.mergeLines(...m)), L;
+          }
+        }), !0;
       }
-    }), $.lineDataToOriginalData(r, o);
+      r(g, R.mergeLines(...m), p, y);
+    }))).reduce((m, M) => (m.has(M.resultLine) || m.set(M.resultLine, []), m.get(M.resultLine)?.push(M), m), /* @__PURE__ */ new Map()).forEach((m) => {
+      m.reduce((M, T) => (M.has(T.point) || M.set(T.point, []), M.get(T.point)?.push(T), M), /* @__PURE__ */ new Map()).forEach((M) => {
+        const T = /* @__PURE__ */ new Set();
+        for (let g = 0; g < M.length; g++) {
+          const L = M[g];
+          T.has(L.point) || (r(L, L.newLine, p, y), T.add(L.point));
+        }
+      });
+    }), c.push(...R.deduplication(y)), c.forEach((m) => m.userData.isWindow && W.recomputedWindow(m)), c = W.lineSegmentClipping(c), c = R.deduplication(c), W.lineDataToOriginalData(c, l);
   }
-  boundaryExtension = $.boundaryExtension;
 }
-function we(f) {
+function ye(f) {
   if (f === null || typeof f != "object") return f;
   if (f instanceof Date) return new Date(f.getTime());
-  if (Array.isArray(f)) return f.map(we);
+  if (Array.isArray(f)) return f.map(ye);
   const e = {};
   for (const t in f)
-    Object.prototype.hasOwnProperty.call(f, t) && (e[t] = we(f[t]));
+    Object.prototype.hasOwnProperty.call(f, t) && (e[t] = ye(f[t]));
   return e;
 }
-const ee = new N();
-class ct extends $ {
+const K = new R();
+class rt extends W {
   static name = "AngleCorrectionDxf";
   angle = 0;
   onAddFromParent(e) {
@@ -2299,43 +2450,43 @@ class ct extends $ {
   async update() {
     const e = this.parent, t = e.findComponentByName("Dxf"), n = e.findComponentByName("LineAnalysis");
     let s = 0, i = null;
-    for (let l = 0; l < t.originalData.length; l++) {
-      const c = t.originalData[l];
-      if (ee.start.copy(c.start), ee.end.copy(c.end), c.isVerticalReferenceLine) {
-        const [h, d] = c.start.y < c.end.y ? [ee.start, ee.end] : [ee.end, ee.start];
-        s = -new N(h, d).direction().angleBetween(new g(0, 1), "angle", "360"), i = null;
+    for (let c = 0; c < t.originalData.length; c++) {
+      const l = t.originalData[c];
+      if (K.start.copy(l.start), K.end.copy(l.end), l.isVerticalReferenceLine) {
+        const [h, d] = l.start.y < l.end.y ? [K.start, K.end] : [K.end, K.start];
+        s = -new R(h, d).direction().angleBetween(new w(0, 1), "angle", "360"), i = null;
         break;
       }
-      (!i || ee.length() > i.length()) && (i = ee.clone(), i.userData.index = l);
+      (!i || K.length() > i.length()) && (i = K.clone(), i.userData.index = c);
     }
     if (i) {
       t.originalData[i.userData.index].isVerticalReferenceLine = !0;
-      const [l, c] = i.start.y < i.end.y ? [i.start, i.end] : [i.end, i.start];
-      s = -new N(l, c).direction().angleBetween(new g(0, 1), "angle", "360");
+      const [c, l] = i.start.y < i.end.y ? [i.start, i.end] : [i.end, i.start];
+      s = -new R(c, l).direction().angleBetween(new w(0, 1), "angle", "360");
     }
-    const r = t.originalBox.center, o = g.zero(), a = t.originalData.map((l) => {
-      const c = o.copy(l.start).division(r).rotate(g.zero(), s * (Math.PI / 180)).toJson(l.start.z), h = o.copy(l.end).division(r).rotate(g.zero(), s * (Math.PI / 180)).toJson(l.end.z), d = Object.assign(we(l), { start: c, end: h });
+    const r = t.originalBox.center, o = w.zero(), a = t.originalData.map((c) => {
+      const l = o.copy(c.start).division(r).rotate(w.zero(), s * (Math.PI / 180)).toJson(c.start.z), h = o.copy(c.end).division(r).rotate(w.zero(), s * (Math.PI / 180)).toJson(c.end.z), d = Object.assign(ye(c), { start: l, end: h });
       return d.drawWindow && d.drawWindow.forEach((u) => {
-        u.p = o.copy(u.p).division(r).rotate(g.zero(), s * (Math.PI / 180)).toJson(u.p.z);
+        u.p = o.copy(u.p).division(r).rotate(w.zero(), s * (Math.PI / 180)).toJson(u.p.z);
       }), d;
     });
-    n.appendLineSegmentList.forEach((l) => {
-      const c = l.clone();
-      c.start.division(r).rotate(g.zero(), s * (Math.PI / 180)), c.end.division(r).rotate(g.zero(), s * (Math.PI / 180)), a.push({
-        start: c.start.toJson(t.originalZAverage),
-        end: c.end.toJson(t.originalZAverage),
+    n.appendLineSegmentList.forEach((c) => {
+      const l = c.clone();
+      l.start.division(r).rotate(w.zero(), s * (Math.PI / 180)), l.end.division(r).rotate(w.zero(), s * (Math.PI / 180)), a.push({
+        start: l.start.toJson(t.originalZAverage),
+        end: l.end.toJson(t.originalZAverage),
         insetionArr: [],
-        length: c.length()
+        length: l.length()
       });
-    }), await this.set(a, t.width, t.scale), this.lineOffset(), this.doorLineSegment = t.doorLineSegment.map((l) => {
-      const c = l.clone();
-      return c.start.division(r).rotate(g.zero(), s * (Math.PI / 180)), c.end.division(r).rotate(g.zero(), s * (Math.PI / 180)), c;
+    }), await this.set(a, t.width, t.scale), this.lineOffset(), this.doorLineSegment = t.doorLineSegment.map((c) => {
+      const l = c.clone();
+      return l.start.division(r).rotate(w.zero(), s * (Math.PI / 180)), l.end.division(r).rotate(w.zero(), s * (Math.PI / 180)), l;
     }), this.angle = s, this.dispatchEvent({
       type: "updateData"
     });
   }
 }
-class Ce extends ne {
+class Re extends Q {
   static name = "Variable";
   originalLineVisible = !0;
   dxfVisible = !0;
@@ -2362,13 +2513,13 @@ class Ce extends ne {
     if (e in this) return this[e];
   }
 }
-class lt {
+class ot {
   // 所有可查找的点位
   possibleDoorPoints = [];
   doorPoint = [];
   dxf;
   // 包含所有点的虚拟网格
-  pointVirtualGrid = new ge();
+  pointVirtualGrid = new oe();
   // 只包含可查找点的虚拟网格
   findPointVirtualGrid;
   quadtree;
@@ -2381,7 +2532,7 @@ class lt {
   lineAnalysis;
   continueFind = !0;
   constructor(e) {
-    if (this.lineAnalysis = e, this.dxf = e.Dxf, this.findPointVirtualGrid = new ge(), this.quadtree = e.quadtree, this.resultList = e.resultList, this.lineSegments = e.lineSegmentList, this.dxf.doorLineSegment.length = 0, this.lineSegments.forEach((n) => {
+    if (this.lineAnalysis = e, this.dxf = e.Dxf, this.findPointVirtualGrid = new oe(), this.quadtree = e.quadtree, this.resultList = e.resultList, this.lineSegments = e.lineSegmentList, this.dxf.doorLineSegment.length = 0, this.lineSegments.forEach((n) => {
       this.pointVirtualGrid.insert(n.start, n), this.pointVirtualGrid.insert(n.end, n);
     }), this.doorPoint = this.getDoorPoint(), !this.continueFind) return;
     const t = this.searchDoubleLinePoint();
@@ -2396,32 +2547,32 @@ class lt {
   search(e, t = [], n = 0.6, s = this.doorSearchDistance, i = this.doorSearchNearAngle) {
     const r = this.dxf, o = this.searchNearby(e, t, s, i);
     o.push(
-      ...e.map((l) => {
-        const c = this.searchAlongDirection(l, s);
-        if (c) return {
-          start: l.point,
-          end: c.point
+      ...e.map((c) => {
+        const l = this.searchAlongDirection(c, s);
+        if (l) return {
+          start: c.point,
+          end: l.point
         };
-        const h = this.searchAlongNormalDirection(l, s);
+        const h = this.searchAlongNormalDirection(c, s);
         if (h) return {
-          start: l.point,
+          start: c.point,
           end: h.point
         };
-      }).filter((l) => !!l && l.start.distance(l.end) < s)
+      }).filter((c) => !!c && c.start.distance(c.end) < s)
     );
     const a = [];
-    return o.forEach((l) => {
-      const c = new N(l?.start, l?.end), h = c.length();
+    return o.forEach((c) => {
+      const l = new R(c?.start, c?.end), h = l.length();
       if (h < n) return;
-      const d = c.normal(), u = c.direction(), p = (h - r.width * 2) / 2;
-      for (let y = 0; y < 3; y++) {
-        const x = c.start.clone().add(u.clone().multiplyScalar(r.width + p * y)), S = new N(
-          x,
-          x.clone().add(d.clone().multiplyScalar(1))
+      const d = l.normal(), u = l.direction(), p = (h - r.width * 2) / 2;
+      for (let x = 0; x < 3; x++) {
+        const y = l.start.clone().add(u.clone().multiplyScalar(r.width + p * x)), m = new R(
+          y,
+          y.clone().add(d.clone().multiplyScalar(1))
         );
-        if (S.directionMove(d, -0.5), this.quadtree.queryLineSegment(S).length) return;
+        if (m.directionMove(d, -0.5), this.quadtree.queryLineSegment(m).length) return;
       }
-      a.push(c);
+      a.push(l);
     }), a;
   }
   /** 添加可查找点的过滤规则
@@ -2439,7 +2590,7 @@ class lt {
     return this.lineSegments.forEach((t) => {
       t.points.forEach((n, s) => {
         for (let r = 0; r < this._pointsExcludeRule.length; r++) if (this._pointsExcludeRule[r](t, n, s)) return;
-        this.pointVirtualGrid.queryPoint(n).filter((r) => r.userData !== t).length === 0 && e.push({ line: t, point: n, uuid: me() });
+        this.pointVirtualGrid.queryPoint(n).filter((r) => r.userData !== t).length === 0 && e.push({ line: t, point: n, uuid: pe() });
       });
     }), e;
   }
@@ -2451,21 +2602,21 @@ class lt {
     return t.doors.forEach((s) => {
       const i = t.lineSegments[s[4]], r = t.originalData[s[4]];
       if (r.drawDoorData) {
-        const o = g.from(r.drawDoorData.start), a = g.from(r.drawDoorData.n), l = n.queryPoint(o).filter((c) => {
-          if (c.userData === i) return !1;
-          const h = c.userData, d = h.direction();
+        const o = w.from(r.drawDoorData.start), a = w.from(r.drawDoorData.n), c = n.queryPoint(o).filter((l) => {
+          if (l.userData === i) return !1;
+          const h = l.userData, d = h.direction();
           h.start.equal(o) && d.multiplyScalar(-1);
           const u = a.angleBetween(d, "angle");
           return u > 80 || u < 10;
         });
-        l.length && e.push({
-          line: l[0].userData,
+        c.length && e.push({
+          line: c[0].userData,
           point: o,
-          uuid: me()
+          uuid: pe()
         });
       } else if (r.doorDirectConnection) {
         this.continueFind = !1;
-        const o = new N(g.from(r.start), g.from(r.end));
+        const o = new R(w.from(r.start), w.from(r.end));
         o.userData = {
           doorDirectConnection: !0,
           isDoor: !0
@@ -2481,8 +2632,8 @@ class lt {
   searchDoubleLinePoint() {
     const e = /* @__PURE__ */ new Map();
     return this.resultList.flatMap((t) => {
-      const n = this.lineSegments[t.sourceIndex], s = this.lineSegments[t.targetIndex], i = s.projectPoint(n.start), r = s.projectPoint(n.end), o = n.projectPoint(s.start), a = n.projectPoint(s.end), l = i && r ? -1 : i ? 0 : r ? 1 : -1, c = o && a ? -1 : o ? 0 : a ? 1 : -1;
-      e.has(t.sourceIndex) ? e.get(t.sourceIndex) != l && e.set(t.sourceIndex, -1) : e.set(t.sourceIndex, l), e.has(t.targetIndex) ? e.get(t.targetIndex) != c && e.set(t.targetIndex, -1) : e.set(t.targetIndex, c);
+      const n = this.lineSegments[t.sourceIndex], s = this.lineSegments[t.targetIndex], i = s.projectPoint(n.start), r = s.projectPoint(n.end), o = n.projectPoint(s.start), a = n.projectPoint(s.end), c = i && r ? -1 : i ? 0 : r ? 1 : -1, l = o && a ? -1 : o ? 0 : a ? 1 : -1;
+      e.has(t.sourceIndex) ? e.get(t.sourceIndex) != c && e.set(t.sourceIndex, -1) : e.set(t.sourceIndex, c), e.has(t.targetIndex) ? e.get(t.targetIndex) != l && e.set(t.targetIndex, -1) : e.set(t.targetIndex, l);
     }), e;
   }
   /** 查找方案一：最近点查找
@@ -2495,94 +2646,94 @@ class lt {
    */
   searchNearby(e, t = [], n = this.doorSearchDistance, s = this.doorSearchNearAngle) {
     const i = this.findPointVirtualGrid, r = this.quadtree;
-    function o({ point: x, line: S }, T, G) {
-      const E = S.direction();
-      S.start === x && E.multiplyScalar(-1);
-      const R = i.queryCircle(x, n).filter((P) => P.userData !== S).sort((P, O) => P.point.distance(x) - O.point.distance(x)), U = [];
-      for (let P = 0; P < R.length; P++) {
-        const O = t.findIndex((D) => D.point === R[P].point), X = e[T].uuid, k = t[O].uuid;
-        if (G.has(`${X}.${k}`)) continue;
-        G.add(`${X}.${k}`), G.add(`${k}.${X}`);
-        const W = R[P].point, J = new N(x.clone(), W.clone());
-        if (J.direction().angleBetween(E, "angle") < s) {
-          const D = e[O].line.direction();
-          R[P].userData.start.equal(R[P].point) && D.multiplyScalar(-1), J.direction().multiplyScalar(-1).angleBetween(D, "angle") < s && (r.queryLineSegment(J).length || U.push({
-            findData: R[P],
+    function o({ point: y, line: m }, M, T) {
+      const g = m.direction();
+      m.start === y && g.multiplyScalar(-1);
+      const L = i.queryCircle(y, n).filter((P) => P.userData !== m).sort((P, N) => P.point.distance(y) - N.point.distance(y)), O = [];
+      for (let P = 0; P < L.length; P++) {
+        const N = t.findIndex((v) => v.point === L[P].point), Y = e[M].uuid, k = t[N].uuid;
+        if (T.has(`${Y}.${k}`)) continue;
+        T.add(`${Y}.${k}`), T.add(`${k}.${Y}`);
+        const V = L[P].point, X = new R(y.clone(), V.clone());
+        if (X.direction().angleBetween(g, "angle") < s) {
+          const v = e[N].line.direction();
+          L[P].userData.start.equal(L[P].point) && v.multiplyScalar(-1), X.direction().multiplyScalar(-1).angleBetween(v, "angle") < s && (r.queryLineSegment(X).length || O.push({
+            findData: L[P],
             findUuid: k,
-            doorLine: J,
-            doorUuid: X
+            doorLine: X,
+            doorUuid: Y
           }));
         }
       }
-      return U;
+      return O;
     }
-    function a(x, S, T, G, E) {
-      G.add(x);
-      const R = [];
-      E && R.push(E);
-      for (let U = 0; U < T.length; U++) {
-        const P = T[U];
-        if (S.has(P.findUuid)) {
-          const O = S.get(P.findUuid);
-          a(P.findUuid, S, O, G, P) && R.push(P);
-        } else R.push(P);
+    function a(y, m, M, T, g) {
+      T.add(y);
+      const L = [];
+      g && L.push(g);
+      for (let O = 0; O < M.length; O++) {
+        const P = M[O];
+        if (m.has(P.findUuid)) {
+          const N = m.get(P.findUuid);
+          a(P.findUuid, m, N, T, P) && L.push(P);
+        } else L.push(P);
       }
-      return R.sort((U, P) => U.doorLine.length() - P.doorLine.length()), E && R[0] === E ? (T.splice(0), !0) : (T.splice(1), !1);
+      return L.sort((O, P) => O.doorLine.length() - P.doorLine.length()), g && L[0] === g ? (M.splice(0), !0) : (M.splice(1), !1);
     }
-    const l = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map();
-    e.map((x, S) => {
-      const T = o(x, S, l);
-      T.length && c.set(x.uuid, T);
-    }), l.clear();
+    const c = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Map();
+    e.map((y, m) => {
+      const M = o(y, m, c);
+      M.length && l.set(y.uuid, M);
+    }), c.clear();
     const h = /* @__PURE__ */ new Map();
-    c.forEach((x, S) => {
-      if (!l.has(S) && x.length && a(S, c, x, l), x.length) {
-        const T = x[0];
-        h.has(T.doorUuid) || h.set(T.doorUuid, []), h.get(T.doorUuid)?.push(T), h.has(T.findUuid) || h.set(T.findUuid, []), h.get(T.findUuid)?.push(T);
+    l.forEach((y, m) => {
+      if (!c.has(m) && y.length && a(m, l, y, c), y.length) {
+        const M = y[0];
+        h.has(M.doorUuid) || h.set(M.doorUuid, []), h.get(M.doorUuid)?.push(M), h.has(M.findUuid) || h.set(M.findUuid, []), h.get(M.findUuid)?.push(M);
       }
     });
     const d = /* @__PURE__ */ new Set();
-    h.forEach((x) => {
-      if (x.length > 1) {
-        x.sort((S, T) => S.doorLine.length() - T.doorLine.length());
-        for (let S = 1; S < x.length; S++) d.add(x[S]);
+    h.forEach((y) => {
+      if (y.length > 1) {
+        y.sort((m, M) => m.doorLine.length() - M.doorLine.length());
+        for (let m = 1; m < y.length; m++) d.add(y[m]);
       }
     });
     const u = [], p = [];
-    c.forEach((x) => {
-      if (x.length) {
-        const S = x[0];
-        d.has(S) || (u.push(S), p.push(S.doorUuid, S.findUuid));
+    l.forEach((y) => {
+      if (y.length) {
+        const m = y[0];
+        d.has(m) || (u.push(m), p.push(m.doorUuid, m.findUuid));
       }
     });
-    const y = [];
-    return u.forEach((x) => {
-      const S = e.findIndex((O) => O.uuid === x.doorUuid), T = t.findIndex((O) => O.uuid === x.findUuid), G = e[S].point.clone(), E = t[T].point.clone(), R = this.findLongLineSegment(e[S].line), U = this.findLongLineSegment(t[T].line), P = R.projectPoint(E);
+    const x = [];
+    return u.forEach((y) => {
+      const m = e.findIndex((N) => N.uuid === y.doorUuid), M = t.findIndex((N) => N.uuid === y.findUuid), T = e[m].point.clone(), g = t[M].point.clone(), L = this.findLongLineSegment(e[m].line), O = this.findLongLineSegment(t[M].line), P = L.projectPoint(g);
       if (P) {
-        G.copy(P);
-        const O = new N(G, E), X = U.includedAngle(O);
-        (X < 10 || X > 170 || Math.abs(90 - X) < 10) && y.push({
-          start: G,
-          end: E
+        T.copy(P);
+        const N = new R(T, g), Y = O.includedAngle(N);
+        (Y < 10 || Y > 170 || Math.abs(90 - Y) < 10) && x.push({
+          start: T,
+          end: g
         });
       } else {
-        const O = U.projectPoint(G);
-        O && E.copy(O);
-        const X = new N(G, E), k = R.includedAngle(X);
-        (k < 10 || k > 170 || Math.abs(90 - k) < 10) && y.push({
-          start: G,
-          end: E
+        const N = O.projectPoint(T);
+        N && g.copy(N);
+        const Y = new R(T, g), k = L.includedAngle(Y);
+        (k < 10 || k > 170 || Math.abs(90 - k) < 10) && x.push({
+          start: T,
+          end: g
         });
       }
     }), t.splice(
       0,
       t.length,
-      ...t.filter((x) => p.indexOf(x.uuid) === -1)
+      ...t.filter((y) => p.indexOf(y.uuid) === -1)
     ), e.splice(
       0,
       e.length,
-      ...e.filter((x) => p.indexOf(x.uuid) === -1)
-    ), y;
+      ...e.filter((y) => p.indexOf(y.uuid) === -1)
+    ), x;
   }
   /** 方案二： 沿方向查找
    * @description 
@@ -2592,14 +2743,14 @@ class lt {
   searchAlongDirection({ point: e, line: t }, n = this.doorSearchDistance) {
     const s = this.quadtree, i = t.direction();
     t.start === e && i.multiplyScalar(-1);
-    const r = e.clone().add(i.clone().multiplyScalar(n)), o = new N(e.clone(), r), a = s.queryLineSegment(o).map((l) => ({
-      point: l.line.getIntersection(o),
-      line: l.line
-    })).filter((l) => l.point).sort((l, c) => e.distance(l.point) - e.distance(c.point));
+    const r = e.clone().add(i.clone().multiplyScalar(n)), o = new R(e.clone(), r), a = s.queryLineSegment(o).map((c) => ({
+      point: c.line.getIntersection(o),
+      line: c.line
+    })).filter((c) => c.point).sort((c, l) => e.distance(c.point) - e.distance(l.point));
     if (a.length) {
-      const l = a[0];
-      if (Math.abs(90 - l.line.direction().angleBetween(i, "angle")) < 5)
-        return l;
+      const c = a[0];
+      if (Math.abs(90 - c.line.direction().angleBetween(i, "angle")) < 5)
+        return c;
     }
   }
   /** 方案三： 沿法线方向查找
@@ -2611,16 +2762,16 @@ class lt {
   searchAlongNormalDirection({ point: e, line: t }, n = this.doorSearchDistance) {
     const s = this.pointVirtualGrid, i = this.quadtree, r = t.direction(), o = t.start.normal(t.end), a = t.start.clone();
     t.start === e && r.multiplyScalar(-1), t.start === e && a.copy(t.end);
-    const l = s.queryPoint(a).filter((d) => d.userData !== t);
-    for (let d = 0; d < l.length; d++) {
-      const u = l[d], p = u.userData, y = p.direction();
-      if (p.start === u.point && r.multiplyScalar(-1), y.angleBetween(o) / (Math.PI / 180) > 90) {
+    const c = s.queryPoint(a).filter((d) => d.userData !== t);
+    for (let d = 0; d < c.length; d++) {
+      const u = c[d], p = u.userData, x = p.direction();
+      if (p.start === u.point && r.multiplyScalar(-1), x.angleBetween(o) / (Math.PI / 180) > 90) {
         o.multiplyScalar(-1);
         break;
       }
     }
-    const c = new N(e.clone(), e.clone().add(o.multiplyScalar(n))), h = i.queryLineSegment(c).map((d) => ({
-      point: d.line.getIntersection(c),
+    const l = new R(e.clone(), e.clone().add(o.multiplyScalar(n))), h = i.queryLineSegment(l).map((d) => ({
+      point: d.line.getIntersection(l),
       line: d.line
     })).filter((d) => d.point).sort((d, u) => e.distance(d.point) - e.distance(u.point));
     if (h.length) {
@@ -2653,7 +2804,7 @@ class lt {
     return t;
   }
 }
-class ht extends ne {
+class at extends Q {
   static name = "LineAnalysis";
   Dxf = null;
   Variable = null;
@@ -2667,7 +2818,7 @@ class ht extends ne {
    * @param parent 
    */
   onAddFromParent(e) {
-    this.Dxf = e.findComponentByType($), this.Variable = this.parent?.findComponentByType(Ce), this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this)), this.Dxf.addEventListener("createGroup", this.doorsAnalysis.bind(this));
+    this.Dxf = e.findComponentByType(W), this.Variable = this.parent?.findComponentByType(Re), this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this)), this.Dxf.addEventListener("createGroup", this.doorsAnalysis.bind(this));
   }
   /**
    * 
@@ -2681,11 +2832,11 @@ class ht extends ne {
     return {
       points: [
         // 第一条线
-        new g(e.x + o, e.y + a).add(r),
-        new g(t.x + o, t.y + a).add(i),
+        new w(e.x + o, e.y + a).add(r),
+        new w(t.x + o, t.y + a).add(i),
         // 第二条线
-        new g(e.x - o, e.y - a).add(r),
-        new g(t.x - o, t.y - a).add(i)
+        new w(e.x - o, e.y - a).add(r),
+        new w(t.x - o, t.y - a).add(i)
       ],
       indices: [0, 1, 1, 3, 3, 2, 2, 0],
       rectIndices: [0, 1, 3, 2, 0]
@@ -2699,7 +2850,7 @@ class ht extends ne {
    */
   addData(e, t) {
     const n = this.Dxf;
-    n.data.push([e.clone(), t.clone(), [], !1, n.data.length]), this.appendLineSegmentList.push(new N(e.clone(), t.clone()));
+    n.data.push([e.clone(), t.clone(), [], !1, n.data.length]), this.appendLineSegmentList.push(new R(e.clone(), t.clone()));
   }
   /** 结果分析创建矩形
    * @param result 
@@ -2707,14 +2858,14 @@ class ht extends ne {
   createRectangle(e) {
     const t = this.Dxf, n = e.project, s = e.project2;
     n.includedAngle(s) > 135 && (s.points = [s.points[1], s.points[0]]), this.addData(n.points[0], s.points[0]), this.addData(n.points[1], s.points[1]);
-    const i = n.points[0].distance(s.points[0]), r = n.points[1].distance(s.points[1]), o = Math.ceil(Math.max(i, r) / t.width), a = i / o, l = r / o, c = s.points[0].direction(n.points[0]), h = s.points[1].direction(n.points[1]), d = n.points[0].clone(), u = n.points[1].clone(), p = u.direction(d);
+    const i = n.points[0].distance(s.points[0]), r = n.points[1].distance(s.points[1]), o = Math.ceil(Math.max(i, r) / t.width), a = i / o, c = r / o, l = s.points[0].direction(n.points[0]), h = s.points[1].direction(n.points[1]), d = n.points[0].clone(), u = n.points[1].clone(), p = u.direction(d);
     p.multiplyScalar(t.width * 0.5);
-    const y = d.clone().add(p), x = u.clone().add(p.multiplyScalar(-1)), S = d.direction(u), T = y.direction(x);
-    if (!(S.x > 0 && T.x < 0 || S.x < 0 && T.x > 0 || S.y > 0 && T.y < 0 || S.y < 0 && T.y > 0)) {
-      d.set(y.x, y.y), u.set(x.x, x.y);
-      for (let G = 1; G < o; G++) {
-        const E = c.clone().multiplyScalar(a * G), R = h.clone().multiplyScalar(l * G), U = d.clone().add(E), P = u.clone().add(R);
-        this.addData(U, P);
+    const x = d.clone().add(p), y = u.clone().add(p.multiplyScalar(-1)), m = d.direction(u), M = x.direction(y);
+    if (!(m.x > 0 && M.x < 0 || m.x < 0 && M.x > 0 || m.y > 0 && M.y < 0 || m.y < 0 && M.y > 0)) {
+      d.set(x.x, x.y), u.set(y.x, y.y);
+      for (let T = 1; T < o; T++) {
+        const g = l.clone().multiplyScalar(a * T), L = h.clone().multiplyScalar(c * T), O = d.clone().add(g), P = u.clone().add(L);
+        this.addData(O, P);
       }
     }
   }
@@ -2724,7 +2875,7 @@ class ht extends ne {
    */
   buildQuadtree() {
     const e = this.Dxf, t = [];
-    this.quadtree = new Z(e.originalBox, 2), e.lineSegments.forEach((n) => {
+    this.quadtree = new J(e.originalBox, 2), e.lineSegments.forEach((n) => {
       n.userData?.isDoor || (this.quadtree?.insert({
         line: n,
         userData: t.length
@@ -2741,12 +2892,12 @@ class ht extends ne {
     this.buildQuadtree();
     const e = this.quadtree, t = this.lineSegmentList, n = /* @__PURE__ */ new Set(), s = [];
     t.forEach((i, r) => {
-      const o = t[r], a = ue.fromByLineSegment(o, this.width * 2, !1, -0.01);
-      e.queryRect(a).map((c) => c.userData).filter((c) => c !== r).forEach((c) => {
+      const o = t[r], a = ce.fromByLineSegment(o, this.width * 2, !1, -0.01);
+      e.queryRect(a).map((l) => l.userData).filter((l) => l !== r).forEach((l) => {
         try {
-          if (n.has(`${r}-${c}`) || n.has(`${c}-${r}`)) return;
-          const h = this.projectionAnalysis(c, r, o, t);
-          h && s.push(h), n.add(`${r}-${c}`);
+          if (n.has(`${r}-${l}`) || n.has(`${l}-${r}`)) return;
+          const h = this.projectionAnalysis(l, r, o, t);
+          h && s.push(h), n.add(`${r}-${l}`);
         } catch {
         }
       });
@@ -2761,23 +2912,23 @@ class ht extends ne {
   projectionAnalysis(e, t, n, s) {
     const i = s[e], r = n.direction(), o = i.direction(), a = r.angleBetween(o) / (Math.PI / 180);
     if (a < this.errorAngle || a > 180 - this.errorAngle) {
-      let l;
-      const c = i.projectLineSegment(n), h = n.projectLineSegment(i);
-      return c.getLength() > h.getLength() ? l = {
+      let c;
+      const l = i.projectLineSegment(n), h = n.projectLineSegment(i);
+      return l.getLength() > h.getLength() ? c = {
         target: i,
         targetIndex: e,
         source: n,
         sourceIndex: t,
-        project: c,
+        project: l,
         project2: h
-      } : l = {
+      } : c = {
         target: n,
         targetIndex: t,
         source: i,
         sourceIndex: e,
         project: h,
-        project2: c
-      }, !l || l.project.getLength() < 0.2 || l.project2.getLength() < 0.2 ? void 0 : l;
+        project2: l
+      }, !c || c.project.getLength() < 0.2 || c.project2.getLength() < 0.2 ? void 0 : c;
     }
   }
   doorSearchNearAngle = 110;
@@ -2785,54 +2936,52 @@ class ht extends ne {
   doors = [];
   DoorsAnalysis;
   doorsAnalysis() {
-    this.DoorsAnalysis = new lt(this), this.dispatchEvent({
+    this.DoorsAnalysis = new ot(this), this.dispatchEvent({
       type: "analysisCompleted"
     });
   }
 }
-class ut extends ne {
+class ct extends Q {
   static name = "ThreeVJia";
   lineSegments = [];
   onAddFromParent() {
     (this.parent?.findComponentByName("AngleCorrectionDxf")).addEventListener("updateData", async () => this.updateData());
   }
   updateData() {
-    const e = this.parent?.findComponentByName("LineAnalysis"), t = this.parent?.findComponentByName("Dxf");
-    this.parent?.findComponentByName("Renderer");
-    const n = this.parent?.findComponentByName("AngleCorrectionDxf"), s = /* @__PURE__ */ new Map();
+    const e = this.parent?.findComponentByName("LineAnalysis"), t = this.parent?.findComponentByName("Dxf"), n = this.parent?.findComponentByName("AngleCorrectionDxf"), s = /* @__PURE__ */ new Map();
     let i = [...t.lineSegments], r = [], o = [];
-    e.resultList.forEach((c) => {
-      const h = s.get(c.target) ?? [], d = s.get(c.source) ?? [], u = c.project.clone(), p = c.project2.clone();
-      u.includedAngle(p) > 135 && (p.points = [p.points[1], p.points[0]]), h.push(...u.points), d.push(...p.points), s.set(c.target, h), s.set(c.source, d);
-      const y = new N(u.start, p.start), x = new N(u.end, p.end), S = new N(y.center, x.center);
-      S.userData.wallWidth = Math.max(y.length(), x.length()), r.push(S);
+    e.resultList.forEach((l) => {
+      const h = s.get(l.target) ?? [], d = s.get(l.source) ?? [], u = l.project.clone(), p = l.project2.clone();
+      u.includedAngle(p) > 135 && (p.points = [p.points[1], p.points[0]]), h.push(...u.points), d.push(...p.points), s.set(l.target, h), s.set(l.source, d);
+      const x = new R(u.start, p.start), y = new R(u.end, p.end), m = new R(x.center, y.center);
+      m.userData.wallWidth = Math.max(x.length(), y.length()), r.push(m);
     });
     const a = [];
-    i = i.filter((c) => {
-      if (o.indexOf(c) > -1) return !1;
-      if (s.has(c)) {
-        const h = s.get(c), d = c.clone();
+    i = i.filter((l) => {
+      if (o.indexOf(l) > -1) return !1;
+      if (s.has(l)) {
+        const h = s.get(l), d = l.clone();
         if (h) {
           for (let p = 0; p < h.length; p += 2) {
-            const y = h[p], x = h[p + 1];
-            y.userData.length = y.distance(d.start), x.userData.length = x.distance(d.start), y.userData.type = "start", x.userData.type = "end", d.start.distance(y) > d.start.distance(x) && (h[p] = x, h[p + 1] = y, y.userData.type = "end", x.userData.type = "start");
+            const x = h[p], y = h[p + 1];
+            x.userData.length = x.distance(d.start), y.userData.length = y.distance(d.start), x.userData.type = "start", y.userData.type = "end", d.start.distance(x) > d.start.distance(y) && (h[p] = y, h[p + 1] = x, x.userData.type = "end", y.userData.type = "start");
           }
-          h.sort((p, y) => p.userData.length - y.userData.length);
+          h.sort((p, x) => p.userData.length - x.userData.length);
           const u = [];
           for (let p = 0; p < h.length; p++) {
-            const y = h[p];
-            y.userData.type === "start" ? (u.length === 0 && (a.push(new N(d.start.clone(), y.clone())), d.start.copy(y)), u.push("start")) : (u.pop(), u.length === 0 && d.start.copy(y));
+            const x = h[p];
+            x.userData.type === "start" ? (u.length === 0 && (a.push(new R(d.start.clone(), x.clone())), d.start.copy(x)), u.push("start")) : (u.pop(), u.length === 0 && d.start.copy(x));
           }
           a.push(d);
         }
         return !1;
       }
       return !0;
-    }), i.push(...r), i.push(...a.filter((c) => c.length() > 0.05));
-    const l = t.box.center;
-    i = i.map((c) => {
-      const h = c.clone();
-      return h.start.rotate(l, n.angle * (Math.PI / 180)), h.end.rotate(l, n.angle * (Math.PI / 180)), h;
+    }), i.push(...r), i.push(...a.filter((l) => l.length() > 0.05));
+    const c = t.box.center;
+    i = i.map((l) => {
+      const h = l.clone();
+      return h.start.rotate(c, n.angle * (Math.PI / 180)), h.end.rotate(c, n.angle * (Math.PI / 180)), h;
     }), this.lineSegments = i;
   }
   toJson() {
@@ -2879,7 +3028,7 @@ class ut extends ne {
           };
         if (s.userData.isWindow)
           return s.userData.drawWindow.map((i) => {
-            const r = g.from(i.p), o = r.clone().add(
+            const r = w.from(i.p), o = r.clone().add(
               s.direction().multiplyScalar(i.width * 0.5)
             ), a = r.clone().add(
               s.direction().multiplyScalar(-i.width * 0.5)
@@ -2912,10 +3061,10 @@ class ut extends ne {
     if (typeof window < "u") {
       const t = new Blob([JSON.stringify(this.toJson())]), n = document.createElement("a");
       n.href = URL.createObjectURL(t), n.download = e, n.click();
-    } else typeof global < "u" && (await se("fs", !1)).writeFileSync(e, JSON.stringify(this.toJson()));
+    } else typeof global < "u" && (await ee("fs", !1)).writeFileSync(e, JSON.stringify(this.toJson()));
   }
 }
-class dt extends ot {
+class lt extends st {
   Dxf;
   AngleCorrectionDxf;
   Variable;
@@ -2926,7 +3075,7 @@ class dt extends ot {
    * @param scale 原始数据缩放比例
    */
   constructor(e = 0.1, t = 1) {
-    super(), this.environment = typeof window < "u" ? "browser" : typeof global < "u" ? "node" : "unknown", this.wallWidth = e, this.Dxf = new $(this.wallWidth, t), this.AngleCorrectionDxf = new ct(), this.Variable = new Ce(), this.addComponent(this.Variable), this.addComponent(this.Dxf), this.addComponent(new ht()), this.addComponent(this.AngleCorrectionDxf), this.addComponent(new ut());
+    super(), this.environment = typeof window < "u" ? "browser" : typeof global < "u" ? "node" : "unknown", this.wallWidth = e, this.Dxf = new W(this.wallWidth, t), this.AngleCorrectionDxf = new rt(), this.Variable = new Re(), this.addComponent(this.Variable), this.addComponent(this.Dxf), this.addComponent(new at()), this.addComponent(this.AngleCorrectionDxf), this.addComponent(new ct());
   }
   usePlugin(e) {
     return typeof e == "function" && e.call(this, this), this;
@@ -2939,7 +3088,7 @@ class dt extends ot {
     });
   }
 }
-const Ae = {
+const Le = {
   POSITION: [
     "byte",
     "byte normalized",
@@ -2967,36 +3116,36 @@ const Ae = {
     "unsigned short"
   ]
 };
-class he {
+class ae {
   constructor() {
     this.textureUtils = null, this.pluginCallbacks = [], this.register(function(e) {
-      return new Et(e);
+      return new Mt(e);
     }), this.register(function(e) {
-      return new Dt(e);
+      return new St(e);
     }), this.register(function(e) {
-      return new It(e);
+      return new At(e);
     }), this.register(function(e) {
-      return new Rt(e);
+      return new Tt(e);
     }), this.register(function(e) {
-      return new Pt(e);
+      return new bt(e);
     }), this.register(function(e) {
-      return new vt(e);
+      return new It(e);
     }), this.register(function(e) {
-      return new At(e);
+      return new Lt(e);
     }), this.register(function(e) {
-      return new Tt(e);
+      return new Et(e);
     }), this.register(function(e) {
-      return new bt(e);
+      return new Dt(e);
     }), this.register(function(e) {
-      return new Nt(e);
+      return new Pt(e);
     }), this.register(function(e) {
-      return new Ct(e);
+      return new Rt(e);
     }), this.register(function(e) {
-      return new Bt(e);
+      return new vt(e);
     }), this.register(function(e) {
-      return new Ot(e);
+      return new Nt(e);
     }), this.register(function(e) {
-      return new Ft(e);
+      return new Ct(e);
     });
   }
   register(e) {
@@ -3009,7 +3158,7 @@ class he {
     return this.textureUtils = e, this;
   }
   parse(e, t, n, s) {
-    const i = new Lt(), r = [];
+    const i = new wt(), r = [];
     for (let o = 0, a = this.pluginCallbacks.length; o < a; o++)
       r.push(this.pluginCallbacks[o](i));
     i.setPlugins(r), i.setTextureUtils(this.textureUtils), i.writeAsync(e, t, s).catch(n);
@@ -3021,7 +3170,7 @@ class he {
     });
   }
 }
-const C = {
+const F = {
   POINTS: 0,
   LINES: 1,
   LINE_LOOP: 2,
@@ -3045,34 +3194,34 @@ const C = {
   CLAMP_TO_EDGE: 33071,
   MIRRORED_REPEAT: 33648,
   REPEAT: 10497
-}, fe = "KHR_mesh_quantization", H = {};
-H[Je] = C.NEAREST;
-H[Ke] = C.NEAREST_MIPMAP_NEAREST;
-H[$e] = C.NEAREST_MIPMAP_LINEAR;
-H[Ze] = C.LINEAR;
-H[Qe] = C.LINEAR_MIPMAP_NEAREST;
-H[et] = C.LINEAR_MIPMAP_LINEAR;
-H[tt] = C.CLAMP_TO_EDGE;
-H[nt] = C.REPEAT;
-H[st] = C.MIRRORED_REPEAT;
-const Te = {
+}, he = "KHR_mesh_quantization", $ = {};
+$[Ve] = F.NEAREST;
+$[We] = F.NEAREST_MIPMAP_NEAREST;
+$[He] = F.NEAREST_MIPMAP_LINEAR;
+$[Je] = F.LINEAR;
+$[$e] = F.LINEAR_MIPMAP_NEAREST;
+$[Ke] = F.LINEAR_MIPMAP_LINEAR;
+$[Ze] = F.CLAMP_TO_EDGE;
+$[Qe] = F.REPEAT;
+$[et] = F.MIRRORED_REPEAT;
+const Ee = {
   scale: "scale",
   position: "translation",
   quaternion: "rotation",
   morphTargetInfluences: "weights"
-}, ft = new ze(), be = 12, pt = 1179937895, xt = 2, Ie = 8, yt = 1313821514, mt = 5130562;
-function oe(f, e) {
+}, ht = new Fe(), De = 12, ut = 1179937895, dt = 2, Ae = 8, ft = 1313821514, pt = 5130562;
+function ne(f, e) {
   return f.length === e.length && f.every(function(t, n) {
     return t === e[n];
   });
 }
-function gt(f) {
+function yt(f) {
   return new TextEncoder().encode(f).buffer;
 }
-function wt(f) {
-  return oe(f.elements, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+function xt(f) {
+  return ne(f.elements, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 }
-function Mt(f, e, t) {
+function mt(f, e, t) {
   const n = {
     min: new Array(f.itemSize).fill(Number.POSITIVE_INFINITY),
     max: new Array(f.itemSize).fill(Number.NEGATIVE_INFINITY)
@@ -3080,15 +3229,15 @@ function Mt(f, e, t) {
   for (let s = e; s < e + t; s++)
     for (let i = 0; i < f.itemSize; i++) {
       let r;
-      f.itemSize > 4 ? r = f.array[s * f.itemSize + i] : (i === 0 ? r = f.getX(s) : i === 1 ? r = f.getY(s) : i === 2 ? r = f.getZ(s) : i === 3 && (r = f.getW(s)), f.normalized === !0 && (r = ye.normalize(r, f.array))), n.min[i] = Math.min(n.min[i], r), n.max[i] = Math.max(n.max[i], r);
+      f.itemSize > 4 ? r = f.array[s * f.itemSize + i] : (i === 0 ? r = f.getX(s) : i === 1 ? r = f.getY(s) : i === 2 ? r = f.getZ(s) : i === 3 && (r = f.getW(s)), f.normalized === !0 && (r = fe.normalize(r, f.array))), n.min[i] = Math.min(n.min[i], r), n.max[i] = Math.max(n.max[i], r);
     }
   return n;
 }
-function Be(f) {
+function ve(f) {
   return Math.ceil(f / 4) * 4;
 }
-function pe(f, e = 0) {
-  const t = Be(f.byteLength);
+function ue(f, e = 0) {
+  const t = ve(f.byteLength);
   if (t !== f.byteLength) {
     const n = new Uint8Array(t);
     if (n.set(new Uint8Array(f)), e !== 0)
@@ -3098,10 +3247,10 @@ function pe(f, e = 0) {
   }
   return f;
 }
-function Re() {
+function Te() {
   return typeof document > "u" && typeof OffscreenCanvas < "u" ? new OffscreenCanvas(1, 1) : document.createElement("canvas");
 }
-function St(f, e) {
+function gt(f, e) {
   if (typeof OffscreenCanvas < "u" && f instanceof OffscreenCanvas) {
     let t;
     return e === "image/jpeg" ? t = 0.92 : e === "image/webp" && (t = 0.8), f.convertToBlob({
@@ -3111,12 +3260,12 @@ function St(f, e) {
   } else
     return new Promise((t) => f.toBlob(t, e));
 }
-class Lt {
+class wt {
   constructor() {
     this.plugins = [], this.options = {}, this.pending = [], this.buffers = [], this.byteOffset = 0, this.buffers = [], this.nodeMap = /* @__PURE__ */ new Map(), this.skins = [], this.extensionsUsed = {}, this.extensionsRequired = {}, this.uids = /* @__PURE__ */ new Map(), this.uid = 0, this.json = {
       asset: {
         version: "2.0",
-        generator: "THREE.GLTFExporter r" + qe
+        generator: "THREE.GLTFExporter r" + Ge
       }
     }, this.cache = {
       meshes: /* @__PURE__ */ new Map(),
@@ -3152,27 +3301,27 @@ class Lt {
     }, n), this.options.animations.length > 0 && (this.options.trs = !0), await this.processInputAsync(e), await Promise.all(this.pending);
     const s = this, i = s.buffers, r = s.json;
     n = s.options;
-    const o = s.extensionsUsed, a = s.extensionsRequired, l = new Blob(i, { type: "application/octet-stream" }), c = Object.keys(o), h = Object.keys(a);
-    c.length > 0 && (r.extensionsUsed = c), h.length > 0 && (r.extensionsRequired = h), r.buffers && r.buffers.length > 0 && (r.buffers[0].byteLength = l.size), n.binary === !0 ? xe(l).then(function(d) {
-      const u = pe(d), p = new DataView(new ArrayBuffer(Ie));
-      p.setUint32(0, u.byteLength, !0), p.setUint32(4, mt, !0);
-      const y = pe(gt(JSON.stringify(r)), 32), x = new DataView(new ArrayBuffer(Ie));
-      x.setUint32(0, y.byteLength, !0), x.setUint32(4, yt, !0);
-      const S = new ArrayBuffer(be), T = new DataView(S);
-      T.setUint32(0, pt, !0), T.setUint32(4, xt, !0);
-      const G = be + x.byteLength + y.byteLength + p.byteLength + u.byteLength;
-      T.setUint32(8, G, !0);
-      const E = new Blob([
-        S,
-        x,
+    const o = s.extensionsUsed, a = s.extensionsRequired, c = new Blob(i, { type: "application/octet-stream" }), l = Object.keys(o), h = Object.keys(a);
+    l.length > 0 && (r.extensionsUsed = l), h.length > 0 && (r.extensionsRequired = h), r.buffers && r.buffers.length > 0 && (r.buffers[0].byteLength = c.size), n.binary === !0 ? de(c).then(function(d) {
+      const u = ue(d), p = new DataView(new ArrayBuffer(Ae));
+      p.setUint32(0, u.byteLength, !0), p.setUint32(4, pt, !0);
+      const x = ue(yt(JSON.stringify(r)), 32), y = new DataView(new ArrayBuffer(Ae));
+      y.setUint32(0, x.byteLength, !0), y.setUint32(4, ft, !0);
+      const m = new ArrayBuffer(De), M = new DataView(m);
+      M.setUint32(0, ut, !0), M.setUint32(4, dt, !0);
+      const T = De + y.byteLength + x.byteLength + p.byteLength + u.byteLength;
+      M.setUint32(8, T, !0);
+      const g = new Blob([
+        m,
         y,
+        x,
         p,
         u
       ], { type: "application/octet-stream" });
-      xe(E).then((R) => {
-        t(R);
+      de(g).then((L) => {
+        t(L);
       });
-    }) : r.buffers && r.buffers.length > 0 ? Ut(l).then((d) => {
+    }) : r.buffers && r.buffers.length > 0 ? Bt(c).then((d) => {
       r.buffers[0].uri = d, t(r);
     }) : t(r);
   }
@@ -3220,7 +3369,7 @@ class Lt {
    */
   isNormalizedNormalAttribute(e) {
     if (this.cache.attributesNormalized.has(e)) return !1;
-    const n = new ce();
+    const n = new ie();
     for (let s = 0, i = e.count; s < i; s++)
       if (Math.abs(n.fromBufferAttribute(e, s).length() - 1) > 5e-4) return !1;
     return !0;
@@ -3235,7 +3384,7 @@ class Lt {
   createNormalizedNormalAttribute(e) {
     const t = this.cache;
     if (t.attributesNormalized.has(e)) return t.attributesNormalized.get(e);
-    const n = e.clone(), s = new ce();
+    const n = e.clone(), s = new ie();
     for (let i = 0, r = n.count; i < r; i++)
       s.fromBufferAttribute(n, i), s.x === 0 && s.y === 0 && s.z === 0 ? s.setX(1) : s.normalize(), n.setXYZ(i, s.x, s.y, s.z);
     return t.attributesNormalized.set(e, n), n;
@@ -3255,35 +3404,35 @@ class Lt {
   async buildMetalRoughTextureAsync(e, t) {
     if (e === t) return e;
     function n(u) {
-      return u.colorSpace === He ? function(y) {
-        return y < 0.04045 ? y * 0.0773993808 : Math.pow(y * 0.9478672986 + 0.0521327014, 2.4);
-      } : function(y) {
-        return y;
+      return u.colorSpace === Xe ? function(x) {
+        return x < 0.04045 ? x * 0.0773993808 : Math.pow(x * 0.9478672986 + 0.0521327014, 2.4);
+      } : function(x) {
+        return x;
       };
     }
-    e instanceof de && (e = await this.decompressTextureAsync(e)), t instanceof de && (t = await this.decompressTextureAsync(t));
-    const s = e ? e.image : null, i = t ? t.image : null, r = Math.max(s ? s.width : 0, i ? i.width : 0), o = Math.max(s ? s.height : 0, i ? i.height : 0), a = Re();
+    e instanceof le && (e = await this.decompressTextureAsync(e)), t instanceof le && (t = await this.decompressTextureAsync(t));
+    const s = e ? e.image : null, i = t ? t.image : null, r = Math.max(s ? s.width : 0, i ? i.width : 0), o = Math.max(s ? s.height : 0, i ? i.height : 0), a = Te();
     a.width = r, a.height = o;
-    const l = a.getContext("2d", {
+    const c = a.getContext("2d", {
       willReadFrequently: !0
     });
-    l.fillStyle = "#00ffff", l.fillRect(0, 0, r, o);
-    const c = l.getImageData(0, 0, r, o);
+    c.fillStyle = "#00ffff", c.fillRect(0, 0, r, o);
+    const l = c.getImageData(0, 0, r, o);
     if (s) {
-      l.drawImage(s, 0, 0, r, o);
-      const u = n(e), p = l.getImageData(0, 0, r, o).data;
-      for (let y = 2; y < p.length; y += 4)
-        c.data[y] = u(p[y] / 256) * 256;
+      c.drawImage(s, 0, 0, r, o);
+      const u = n(e), p = c.getImageData(0, 0, r, o).data;
+      for (let x = 2; x < p.length; x += 4)
+        l.data[x] = u(p[x] / 256) * 256;
     }
     if (i) {
-      l.drawImage(i, 0, 0, r, o);
-      const u = n(t), p = l.getImageData(0, 0, r, o).data;
-      for (let y = 1; y < p.length; y += 4)
-        c.data[y] = u(p[y] / 256) * 256;
+      c.drawImage(i, 0, 0, r, o);
+      const u = n(t), p = c.getImageData(0, 0, r, o).data;
+      for (let x = 1; x < p.length; x += 4)
+        l.data[x] = u(p[x] / 256) * 256;
     }
-    l.putImageData(c, 0, 0);
+    c.putImageData(l, 0, 0);
     const d = (e || t).clone();
-    return d.source = new je(a), d.colorSpace = Ye, d.channel = (e || t).channel, e && t && e.channel !== t.channel && console.warn("THREE.GLTFExporter: UV channels for metalnessMap and roughnessMap textures must match."), console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures."), d;
+    return d.source = new ze(a), d.colorSpace = qe, d.channel = (e || t).channel, e && t && e.channel !== t.channel && console.warn("THREE.GLTFExporter: UV channels for metalnessMap and roughnessMap textures must match."), console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures."), d;
   }
   async decompressTextureAsync(e, t = 1 / 0) {
     if (this.textureUtils === null)
@@ -3313,34 +3462,34 @@ class Lt {
     r.bufferViews || (r.bufferViews = []);
     let o;
     switch (t) {
-      case C.BYTE:
-      case C.UNSIGNED_BYTE:
+      case F.BYTE:
+      case F.UNSIGNED_BYTE:
         o = 1;
         break;
-      case C.SHORT:
-      case C.UNSIGNED_SHORT:
+      case F.SHORT:
+      case F.UNSIGNED_SHORT:
         o = 2;
         break;
       default:
         o = 4;
     }
     let a = e.itemSize * o;
-    i === C.ARRAY_BUFFER && (a = Math.ceil(a / 4) * 4);
-    const l = Be(s * a), c = new DataView(new ArrayBuffer(l));
+    i === F.ARRAY_BUFFER && (a = Math.ceil(a / 4) * 4);
+    const c = ve(s * a), l = new DataView(new ArrayBuffer(c));
     let h = 0;
     for (let p = n; p < n + s; p++) {
-      for (let y = 0; y < e.itemSize; y++) {
-        let x;
-        e.itemSize > 4 ? x = e.array[p * e.itemSize + y] : (y === 0 ? x = e.getX(p) : y === 1 ? x = e.getY(p) : y === 2 ? x = e.getZ(p) : y === 3 && (x = e.getW(p)), e.normalized === !0 && (x = ye.normalize(x, e.array))), t === C.FLOAT ? c.setFloat32(h, x, !0) : t === C.INT ? c.setInt32(h, x, !0) : t === C.UNSIGNED_INT ? c.setUint32(h, x, !0) : t === C.SHORT ? c.setInt16(h, x, !0) : t === C.UNSIGNED_SHORT ? c.setUint16(h, x, !0) : t === C.BYTE ? c.setInt8(h, x) : t === C.UNSIGNED_BYTE && c.setUint8(h, x), h += o;
+      for (let x = 0; x < e.itemSize; x++) {
+        let y;
+        e.itemSize > 4 ? y = e.array[p * e.itemSize + x] : (x === 0 ? y = e.getX(p) : x === 1 ? y = e.getY(p) : x === 2 ? y = e.getZ(p) : x === 3 && (y = e.getW(p)), e.normalized === !0 && (y = fe.normalize(y, e.array))), t === F.FLOAT ? l.setFloat32(h, y, !0) : t === F.INT ? l.setInt32(h, y, !0) : t === F.UNSIGNED_INT ? l.setUint32(h, y, !0) : t === F.SHORT ? l.setInt16(h, y, !0) : t === F.UNSIGNED_SHORT ? l.setUint16(h, y, !0) : t === F.BYTE ? l.setInt8(h, y) : t === F.UNSIGNED_BYTE && l.setUint8(h, y), h += o;
       }
       h % a !== 0 && (h += a - h % a);
     }
     const d = {
-      buffer: this.processBuffer(c.buffer),
+      buffer: this.processBuffer(l.buffer),
       byteOffset: this.byteOffset,
-      byteLength: l
+      byteLength: c
     };
-    return i !== void 0 && (d.target = i), i === C.ARRAY_BUFFER && (d.byteStride = a), this.byteOffset += l, r.bufferViews.push(d), {
+    return i !== void 0 && (d.target = i), i === F.ARRAY_BUFFER && (d.byteStride = a), this.byteOffset += c, r.bufferViews.push(d), {
       id: r.bufferViews.length - 1,
       byteLength: 0
     };
@@ -3353,8 +3502,8 @@ class Lt {
   processBufferViewImage(e) {
     const t = this, n = t.json;
     return n.bufferViews || (n.bufferViews = []), new Promise(async function(s) {
-      xe(e).then((i) => {
-        const r = pe(i), o = {
+      de(e).then((i) => {
+        const r = ue(i), o = {
           buffer: t.processBuffer(r),
           byteOffset: t.byteOffset,
           byteLength: r.byteLength
@@ -3382,28 +3531,28 @@ class Lt {
     };
     let o;
     if (e.array.constructor === Float32Array)
-      o = C.FLOAT;
+      o = F.FLOAT;
     else if (e.array.constructor === Int32Array)
-      o = C.INT;
+      o = F.INT;
     else if (e.array.constructor === Uint32Array)
-      o = C.UNSIGNED_INT;
+      o = F.UNSIGNED_INT;
     else if (e.array.constructor === Int16Array)
-      o = C.SHORT;
+      o = F.SHORT;
     else if (e.array.constructor === Uint16Array)
-      o = C.UNSIGNED_SHORT;
+      o = F.UNSIGNED_SHORT;
     else if (e.array.constructor === Int8Array)
-      o = C.BYTE;
+      o = F.BYTE;
     else if (e.array.constructor === Uint8Array)
-      o = C.UNSIGNED_BYTE;
+      o = F.UNSIGNED_BYTE;
     else
       throw new Error("THREE.GLTFExporter: Unsupported bufferAttribute component type: " + e.array.constructor.name);
     if (n === void 0 && (n = 0), (s === void 0 || s === 1 / 0) && (s = e.count), s === 0) return null;
-    const a = Mt(e, n, s);
-    let l;
-    t !== void 0 && (l = e === t.index ? C.ELEMENT_ARRAY_BUFFER : C.ARRAY_BUFFER);
-    const c = this.processBufferView(e, o, n, s, l), h = {
-      bufferView: c.id,
-      byteOffset: c.byteOffset,
+    const a = mt(e, n, s);
+    let c;
+    t !== void 0 && (c = e === t.index ? F.ELEMENT_ARRAY_BUFFER : F.ARRAY_BUFFER);
+    const l = this.processBufferView(e, o, n, s, c), h = {
+      bufferView: l.id,
+      byteOffset: l.byteOffset,
       componentType: o,
       count: s,
       max: a.max,
@@ -3422,33 +3571,33 @@ class Lt {
    */
   processImage(e, t, n, s = "image/png") {
     if (e !== null) {
-      const i = this, r = i.cache, o = i.json, a = i.options, l = i.pending;
+      const i = this, r = i.cache, o = i.json, a = i.options, c = i.pending;
       r.images.has(e) || r.images.set(e, {});
-      const c = r.images.get(e), h = s + ":flipY/" + n.toString();
-      if (c[h] !== void 0) return c[h];
+      const l = r.images.get(e), h = s + ":flipY/" + n.toString();
+      if (l[h] !== void 0) return l[h];
       o.images || (o.images = []);
-      const d = { mimeType: s }, u = Re();
+      const d = { mimeType: s }, u = Te();
       u.width = Math.min(e.width, a.maxTextureSize), u.height = Math.min(e.height, a.maxTextureSize);
       const p = u.getContext("2d", {
         willReadFrequently: !0
       });
       if (n === !0 && (p.translate(0, u.height), p.scale(1, -1)), e.data !== void 0) {
-        t !== ke && console.error("GLTFExporter: Only RGBAFormat is supported.", t), (e.width > a.maxTextureSize || e.height > a.maxTextureSize) && console.warn("GLTFExporter: Image size is bigger than maxTextureSize", e);
-        const x = new Uint8ClampedArray(e.height * e.width * 4);
-        for (let S = 0; S < x.length; S += 4)
-          x[S + 0] = e.data[S + 0], x[S + 1] = e.data[S + 1], x[S + 2] = e.data[S + 2], x[S + 3] = e.data[S + 3];
-        p.putImageData(new ImageData(x, e.width, e.height), 0, 0);
+        t !== _e && console.error("GLTFExporter: Only RGBAFormat is supported.", t), (e.width > a.maxTextureSize || e.height > a.maxTextureSize) && console.warn("GLTFExporter: Image size is bigger than maxTextureSize", e);
+        const y = new Uint8ClampedArray(e.height * e.width * 4);
+        for (let m = 0; m < y.length; m += 4)
+          y[m + 0] = e.data[m + 0], y[m + 1] = e.data[m + 1], y[m + 2] = e.data[m + 2], y[m + 3] = e.data[m + 3];
+        p.putImageData(new ImageData(y, e.width, e.height), 0, 0);
       } else if (typeof HTMLImageElement < "u" && e instanceof HTMLImageElement || typeof HTMLCanvasElement < "u" && e instanceof HTMLCanvasElement || typeof ImageBitmap < "u" && e instanceof ImageBitmap || typeof OffscreenCanvas < "u" && e instanceof OffscreenCanvas)
         p.drawImage(e, 0, 0, u.width, u.height);
       else
         throw new Error("THREE.GLTFExporter: Invalid image type. Use HTMLImageElement, HTMLCanvasElement, ImageBitmap or OffscreenCanvas.");
-      a.binary === !0 ? l.push(
-        St(u, s).then((x) => i.processBufferViewImage(x)).then((x) => {
-          d.bufferView = x;
+      a.binary === !0 ? c.push(
+        gt(u, s).then((y) => i.processBufferViewImage(y)).then((y) => {
+          d.bufferView = y;
         })
-      ) : d.uri = Xe.getDataURL(u, s);
-      const y = o.images.push(d) - 1;
-      return c[h] = y, y;
+      ) : d.uri = je.getDataURL(u, s);
+      const x = o.images.push(d) - 1;
+      return l[h] = x, x;
     } else
       throw new Error("THREE.GLTFExporter: No valid image data found. Unable to process texture.");
   }
@@ -3461,10 +3610,10 @@ class Lt {
     const t = this.json;
     t.samplers || (t.samplers = []);
     const n = {
-      magFilter: H[e.magFilter],
-      minFilter: H[e.minFilter],
-      wrapS: H[e.wrapS],
-      wrapT: H[e.wrapT]
+      magFilter: $[e.magFilter],
+      minFilter: $[e.minFilter],
+      wrapS: $[e.wrapS],
+      wrapT: $[e.wrapT]
     };
     return t.samplers.push(n) - 1;
   }
@@ -3476,15 +3625,15 @@ class Lt {
   async processTextureAsync(e) {
     const n = this.options, s = this.cache, i = this.json;
     if (s.textures.has(e)) return s.textures.get(e);
-    i.textures || (i.textures = []), e instanceof de && (e = await this.decompressTextureAsync(e, n.maxTextureSize));
+    i.textures || (i.textures = []), e instanceof le && (e = await this.decompressTextureAsync(e, n.maxTextureSize));
     let r = e.userData.mimeType;
     r === "image/webp" && (r = "image/png");
     const o = {
       sampler: this.processSampler(e),
       source: this.processImage(e.image, e.format, e.flipY, r)
     };
-    e.name && (o.name = e.name), await this._invokeAllAsync(async function(l) {
-      l.writeTexture && await l.writeTexture(e, o);
+    e.name && (o.name = e.name), await this._invokeAllAsync(async function(c) {
+      c.writeTexture && await c.writeTexture(e, o);
     });
     const a = i.textures.push(o) - 1;
     return s.textures.set(e, a), a;
@@ -3503,7 +3652,7 @@ class Lt {
     const s = { pbrMetallicRoughness: {} };
     e.isMeshStandardMaterial !== !0 && e.isMeshBasicMaterial !== !0 && console.warn("GLTFExporter: Use MeshStandardMaterial or MeshBasicMaterial for best results.");
     const i = e.color.toArray().concat([e.opacity]);
-    if (oe(i, [1, 1, 1, 1]) || (s.pbrMetallicRoughness.baseColorFactor = i), e.isMeshStandardMaterial ? (s.pbrMetallicRoughness.metallicFactor = e.metalness, s.pbrMetallicRoughness.roughnessFactor = e.roughness) : (s.pbrMetallicRoughness.metallicFactor = 0, s.pbrMetallicRoughness.roughnessFactor = 1), e.metalnessMap || e.roughnessMap) {
+    if (ne(i, [1, 1, 1, 1]) || (s.pbrMetallicRoughness.baseColorFactor = i), e.isMeshStandardMaterial ? (s.pbrMetallicRoughness.metallicFactor = e.metalness, s.pbrMetallicRoughness.roughnessFactor = e.roughness) : (s.pbrMetallicRoughness.metallicFactor = 0, s.pbrMetallicRoughness.roughnessFactor = 1), e.metalnessMap || e.roughnessMap) {
       const o = await this.buildMetalRoughTextureAsync(e.metalnessMap, e.roughnessMap), a = {
         index: await this.processTextureAsync(o),
         texCoord: o.channel
@@ -3520,11 +3669,11 @@ class Lt {
     if (e.emissive) {
       const o = e.emissive;
       if (Math.max(o.r, o.g, o.b) > 0 && (s.emissiveFactor = e.emissive.toArray()), e.emissiveMap) {
-        const l = {
+        const c = {
           index: await this.processTextureAsync(e.emissiveMap),
           texCoord: e.emissiveMap.channel
         };
-        this.applyTextureTransform(l, e.emissiveMap), s.emissiveTexture = l;
+        this.applyTextureTransform(c, e.emissiveMap), s.emissiveTexture = c;
       }
     }
     if (e.normalMap) {
@@ -3541,7 +3690,7 @@ class Lt {
       };
       e.aoMapIntensity !== 1 && (o.strength = e.aoMapIntensity), this.applyTextureTransform(o, e.aoMap), s.occlusionTexture = o;
     }
-    e.transparent ? s.alphaMode = "BLEND" : e.alphaTest > 0 && (s.alphaMode = "MASK", s.alphaCutoff = e.alphaTest), e.side === Ve && (s.doubleSided = !0), e.name !== "" && (s.name = e.name), this.serializeUserData(e, s), await this._invokeAllAsync(async function(o) {
+    e.transparent ? s.alphaMode = "BLEND" : e.alphaTest > 0 && (s.alphaMode = "MASK", s.alphaCutoff = e.alphaTest), e.side === Ye && (s.doubleSided = !0), e.name !== "" && (s.name = e.name), this.serializeUserData(e, s), await this._invokeAllAsync(async function(o) {
       o.writeMaterialAsync && await o.writeMaterialAsync(e, s);
     });
     const r = n.materials.push(s) - 1;
@@ -3555,16 +3704,16 @@ class Lt {
   async processMeshAsync(e) {
     const t = this.cache, n = this.json, s = [e.geometry.uuid];
     if (Array.isArray(e.material))
-      for (let E = 0, R = e.material.length; E < R; E++)
-        s.push(e.material[E].uuid);
+      for (let g = 0, L = e.material.length; g < L; g++)
+        s.push(e.material[g].uuid);
     else
       s.push(e.material.uuid);
     const i = s.join(":");
     if (t.meshes.has(i)) return t.meshes.get(i);
     const r = e.geometry;
     let o;
-    e.isLineSegments ? o = C.LINES : e.isLineLoop ? o = C.LINE_LOOP : e.isLine ? o = C.LINE_STRIP : e.isPoints ? o = C.POINTS : o = e.material.wireframe ? C.LINES : C.TRIANGLES;
-    const a = {}, l = {}, c = [], h = [], d = {
+    e.isLineSegments ? o = F.LINES : e.isLineLoop ? o = F.LINE_LOOP : e.isLine ? o = F.LINE_STRIP : e.isPoints ? o = F.POINTS : o = e.material.wireframe ? F.LINES : F.TRIANGLES;
+    const a = {}, c = {}, l = [], h = [], d = {
       uv: "TEXCOORD_0",
       uv1: "TEXCOORD_1",
       uv2: "TEXCOORD_2",
@@ -3575,76 +3724,76 @@ class Lt {
     }, u = r.getAttribute("normal");
     u !== void 0 && !this.isNormalizedNormalAttribute(u) && (console.warn("THREE.GLTFExporter: Creating normalized normal attribute from the non-normalized one."), r.setAttribute("normal", this.createNormalizedNormalAttribute(u)));
     let p = null;
-    for (let E in r.attributes) {
-      if (E.slice(0, 5) === "morph") continue;
-      const R = r.attributes[E];
-      if (E = d[E] || E.toUpperCase(), /^(POSITION|NORMAL|TANGENT|TEXCOORD_\d+|COLOR_\d+|JOINTS_\d+|WEIGHTS_\d+)$/.test(E) || (E = "_" + E), t.attributes.has(this.getUID(R))) {
-        l[E] = t.attributes.get(this.getUID(R));
+    for (let g in r.attributes) {
+      if (g.slice(0, 5) === "morph") continue;
+      const L = r.attributes[g];
+      if (g = d[g] || g.toUpperCase(), /^(POSITION|NORMAL|TANGENT|TEXCOORD_\d+|COLOR_\d+|JOINTS_\d+|WEIGHTS_\d+)$/.test(g) || (g = "_" + g), t.attributes.has(this.getUID(L))) {
+        c[g] = t.attributes.get(this.getUID(L));
         continue;
       }
       p = null;
-      const P = R.array;
-      E === "JOINTS_0" && !(P instanceof Uint16Array) && !(P instanceof Uint8Array) ? (console.warn('GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.'), p = new te(new Uint16Array(P), R.itemSize, R.normalized)) : (P instanceof Uint32Array || P instanceof Int32Array) && !E.startsWith("_") && (console.warn(`GLTFExporter: Attribute "${E}" converted to type FLOAT.`), p = he.Utils.toFloat32BufferAttribute(R));
-      const O = this.processAccessor(p || R, r);
-      O !== null && (E.startsWith("_") || this.detectMeshQuantization(E, R), l[E] = O, t.attributes.set(this.getUID(R), O));
+      const P = L.array;
+      g === "JOINTS_0" && !(P instanceof Uint16Array) && !(P instanceof Uint8Array) ? (console.warn('GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.'), p = new Z(new Uint16Array(P), L.itemSize, L.normalized)) : (P instanceof Uint32Array || P instanceof Int32Array) && !g.startsWith("_") && (console.warn(`GLTFExporter: Attribute "${g}" converted to type FLOAT.`), p = ae.Utils.toFloat32BufferAttribute(L));
+      const N = this.processAccessor(p || L, r);
+      N !== null && (g.startsWith("_") || this.detectMeshQuantization(g, L), c[g] = N, t.attributes.set(this.getUID(L), N));
     }
-    if (u !== void 0 && r.setAttribute("normal", u), Object.keys(l).length === 0) return null;
+    if (u !== void 0 && r.setAttribute("normal", u), Object.keys(c).length === 0) return null;
     if (e.morphTargetInfluences !== void 0 && e.morphTargetInfluences.length > 0) {
-      const E = [], R = [], U = {};
+      const g = [], L = [], O = {};
       if (e.morphTargetDictionary !== void 0)
         for (const P in e.morphTargetDictionary)
-          U[e.morphTargetDictionary[P]] = P;
+          O[e.morphTargetDictionary[P]] = P;
       for (let P = 0; P < e.morphTargetInfluences.length; ++P) {
-        const O = {};
-        let X = !1;
+        const N = {};
+        let Y = !1;
         for (const k in r.morphAttributes) {
           if (k !== "position" && k !== "normal") {
-            X || (console.warn("GLTFExporter: Only POSITION and NORMAL morph are supported."), X = !0);
+            Y || (console.warn("GLTFExporter: Only POSITION and NORMAL morph are supported."), Y = !0);
             continue;
           }
-          const W = r.morphAttributes[k][P], J = k.toUpperCase(), V = r.attributes[k];
-          if (t.attributes.has(this.getUID(W, !0))) {
-            O[J] = t.attributes.get(this.getUID(W, !0));
+          const V = r.morphAttributes[k][P], X = k.toUpperCase(), b = r.attributes[k];
+          if (t.attributes.has(this.getUID(V, !0))) {
+            N[X] = t.attributes.get(this.getUID(V, !0));
             continue;
           }
-          const D = W.clone();
+          const v = V.clone();
           if (!r.morphTargetsRelative)
-            for (let b = 0, L = W.count; b < L; b++)
-              for (let M = 0; M < W.itemSize; M++)
-                M === 0 && D.setX(b, W.getX(b) - V.getX(b)), M === 1 && D.setY(b, W.getY(b) - V.getY(b)), M === 2 && D.setZ(b, W.getZ(b) - V.getZ(b)), M === 3 && D.setW(b, W.getW(b) - V.getW(b));
-          O[J] = this.processAccessor(D, r), t.attributes.set(this.getUID(V, !0), O[J]);
+            for (let E = 0, A = V.count; E < A; E++)
+              for (let S = 0; S < V.itemSize; S++)
+                S === 0 && v.setX(E, V.getX(E) - b.getX(E)), S === 1 && v.setY(E, V.getY(E) - b.getY(E)), S === 2 && v.setZ(E, V.getZ(E) - b.getZ(E)), S === 3 && v.setW(E, V.getW(E) - b.getW(E));
+          N[X] = this.processAccessor(v, r), t.attributes.set(this.getUID(b, !0), N[X]);
         }
-        h.push(O), E.push(e.morphTargetInfluences[P]), e.morphTargetDictionary !== void 0 && R.push(U[P]);
+        h.push(N), g.push(e.morphTargetInfluences[P]), e.morphTargetDictionary !== void 0 && L.push(O[P]);
       }
-      a.weights = E, R.length > 0 && (a.extras = {}, a.extras.targetNames = R);
+      a.weights = g, L.length > 0 && (a.extras = {}, a.extras.targetNames = L);
     }
-    const y = Array.isArray(e.material);
-    if (y && r.groups.length === 0) return null;
-    let x = !1;
-    if (y && r.index === null) {
-      const E = [];
-      for (let R = 0, U = r.attributes.position.count; R < U; R++)
-        E[R] = R;
-      r.setIndex(E), x = !0;
+    const x = Array.isArray(e.material);
+    if (x && r.groups.length === 0) return null;
+    let y = !1;
+    if (x && r.index === null) {
+      const g = [];
+      for (let L = 0, O = r.attributes.position.count; L < O; L++)
+        g[L] = L;
+      r.setIndex(g), y = !0;
     }
-    const S = y ? e.material : [e.material], T = y ? r.groups : [{ materialIndex: 0, start: void 0, count: void 0 }];
-    for (let E = 0, R = T.length; E < R; E++) {
-      const U = {
+    const m = x ? e.material : [e.material], M = x ? r.groups : [{ materialIndex: 0, start: void 0, count: void 0 }];
+    for (let g = 0, L = M.length; g < L; g++) {
+      const O = {
         mode: o,
-        attributes: l
+        attributes: c
       };
-      if (this.serializeUserData(r, U), h.length > 0 && (U.targets = h), r.index !== null) {
-        let O = this.getUID(r.index);
-        (T[E].start !== void 0 || T[E].count !== void 0) && (O += ":" + T[E].start + ":" + T[E].count), t.attributes.has(O) ? U.indices = t.attributes.get(O) : (U.indices = this.processAccessor(r.index, r, T[E].start, T[E].count), t.attributes.set(O, U.indices)), U.indices === null && delete U.indices;
+      if (this.serializeUserData(r, O), h.length > 0 && (O.targets = h), r.index !== null) {
+        let N = this.getUID(r.index);
+        (M[g].start !== void 0 || M[g].count !== void 0) && (N += ":" + M[g].start + ":" + M[g].count), t.attributes.has(N) ? O.indices = t.attributes.get(N) : (O.indices = this.processAccessor(r.index, r, M[g].start, M[g].count), t.attributes.set(N, O.indices)), O.indices === null && delete O.indices;
       }
-      const P = await this.processMaterialAsync(S[T[E].materialIndex]);
-      P !== null && (U.material = P), c.push(U);
+      const P = await this.processMaterialAsync(m[M[g].materialIndex]);
+      P !== null && (O.material = P), l.push(O);
     }
-    x === !0 && r.setIndex(null), a.primitives = c, n.meshes || (n.meshes = []), await this._invokeAllAsync(function(E) {
-      E.writeMesh && E.writeMesh(e, a);
+    y === !0 && r.setIndex(null), a.primitives = l, n.meshes || (n.meshes = []), await this._invokeAllAsync(function(g) {
+      g.writeMesh && g.writeMesh(e, a);
     });
-    const G = n.meshes.push(a) - 1;
-    return t.meshes.set(i, G), G;
+    const T = n.meshes.push(a) - 1;
+    return t.meshes.set(i, T), T;
   }
   /**
    * If a vertex attribute with a
@@ -3658,7 +3807,7 @@ class Lt {
    * @param {THREE.BufferAttribute} attribute
    */
   detectMeshQuantization(e, t) {
-    if (this.extensionsUsed[fe]) return;
+    if (this.extensionsUsed[he]) return;
     let n;
     switch (t.array.constructor) {
       case Int8Array:
@@ -3678,7 +3827,7 @@ class Lt {
     }
     t.normalized && (n += " normalized");
     const s = e.split("_", 1)[0];
-    Ae[s] && Ae[s].includes(n) && (this.extensionsUsed[fe] = !0, this.extensionsRequired[fe] = !0);
+    Le[s] && Le[s].includes(n) && (this.extensionsUsed[he] = !0, this.extensionsRequired[he] = !0);
   }
   /**
    * Process camera
@@ -3698,7 +3847,7 @@ class Lt {
       znear: e.near < 0 ? 0 : e.near
     } : s.perspective = {
       aspectRatio: e.aspect,
-      yfov: ye.degToRad(e.fov),
+      yfov: fe.degToRad(e.fov),
       zfar: e.far <= 0 ? 1e-3 : e.far,
       znear: e.near < 0 ? 0 : e.near
     }, e.name !== "" && (s.name = e.type), t.cameras.push(s) - 1;
@@ -3715,24 +3864,24 @@ class Lt {
    */
   processAnimation(e, t) {
     const n = this.json, s = this.nodeMap;
-    n.animations || (n.animations = []), e = he.Utils.mergeMorphTargetTracks(e.clone(), t);
+    n.animations || (n.animations = []), e = ae.Utils.mergeMorphTargetTracks(e.clone(), t);
     const i = e.tracks, r = [], o = [];
-    for (let l = 0; l < i.length; ++l) {
-      const c = i[l], h = le.parseTrackName(c.name);
-      let d = le.findNode(t, h.nodeName);
-      const u = Te[h.propertyName];
+    for (let c = 0; c < i.length; ++c) {
+      const l = i[c], h = re.parseTrackName(l.name);
+      let d = re.findNode(t, h.nodeName);
+      const u = Ee[h.propertyName];
       if (h.objectName === "bones" && (d.isSkinnedMesh === !0 ? d = d.skeleton.getBoneByName(h.objectIndex) : d = void 0), !d || !u) {
-        console.warn('THREE.GLTFExporter: Could not export animation track "%s".', c.name);
+        console.warn('THREE.GLTFExporter: Could not export animation track "%s".', l.name);
         continue;
       }
       const p = 1;
-      let y = c.values.length / c.times.length;
-      u === Te.morphTargetInfluences && (y /= d.morphTargetInfluences.length);
-      let x;
-      c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === !0 ? (x = "CUBICSPLINE", y /= 3) : c.getInterpolation() === We ? x = "STEP" : x = "LINEAR", o.push({
-        input: this.processAccessor(new te(c.times, p)),
-        output: this.processAccessor(new te(c.values, y)),
-        interpolation: x
+      let x = l.values.length / l.times.length;
+      u === Ee.morphTargetInfluences && (x /= d.morphTargetInfluences.length);
+      let y;
+      l.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === !0 ? (y = "CUBICSPLINE", x /= 3) : l.getInterpolation() === ke ? y = "STEP" : y = "LINEAR", o.push({
+        input: this.processAccessor(new Z(l.times, p)),
+        output: this.processAccessor(new Z(l.values, x)),
+        interpolation: y
       }), r.push({
         sampler: o.length - 1,
         target: {
@@ -3757,11 +3906,11 @@ class Lt {
     if (i === void 0) return null;
     const r = e.skeleton.bones[0];
     if (r === void 0) return null;
-    const o = [], a = new Float32Array(i.bones.length * 16), l = new ve();
+    const o = [], a = new Float32Array(i.bones.length * 16), c = new Ie();
     for (let h = 0; h < i.bones.length; ++h)
-      o.push(n.get(i.bones[h])), l.copy(i.boneInverses[h]), l.multiply(e.bindMatrix).toArray(a, h * 16);
+      o.push(n.get(i.bones[h])), c.copy(i.boneInverses[h]), c.multiply(e.bindMatrix).toArray(a, h * 16);
     return t.skins === void 0 && (t.skins = []), t.skins.push({
-      inverseBindMatrices: this.processAccessor(new te(a, 16)),
+      inverseBindMatrices: this.processAccessor(new Z(a, 16)),
       joints: o,
       skeleton: n.get(r)
     }), s.skin = t.skins.length - 1;
@@ -3776,10 +3925,10 @@ class Lt {
     t.nodes || (t.nodes = []);
     const i = {};
     if (n.trs) {
-      const o = e.quaternion.toArray(), a = e.position.toArray(), l = e.scale.toArray();
-      oe(o, [0, 0, 0, 1]) || (i.rotation = o), oe(a, [0, 0, 0]) || (i.translation = a), oe(l, [1, 1, 1]) || (i.scale = l);
+      const o = e.quaternion.toArray(), a = e.position.toArray(), c = e.scale.toArray();
+      ne(o, [0, 0, 0, 1]) || (i.rotation = o), ne(a, [0, 0, 0]) || (i.translation = a), ne(c, [1, 1, 1]) || (i.scale = c);
     } else
-      e.matrixAutoUpdate && e.updateMatrix(), wt(e.matrix) === !1 && (i.matrix = e.matrix.elements);
+      e.matrixAutoUpdate && e.updateMatrix(), xt(e.matrix) === !1 && (i.matrix = e.matrix.elements);
     if (e.name !== "" && (i.name = String(e.name)), this.serializeUserData(e, i), e.isMesh || e.isLine || e.isPoints) {
       const o = await this.processMeshAsync(e);
       o !== null && (i.mesh = o);
@@ -3788,10 +3937,10 @@ class Lt {
     const r = t.nodes.push(i) - 1;
     if (s.set(e, r), e.children.length > 0) {
       const o = [];
-      for (let a = 0, l = e.children.length; a < l; a++) {
-        const c = e.children[a];
-        if (c.visible || n.onlyVisible === !1) {
-          const h = await this.processNodeAsync(c);
+      for (let a = 0, c = e.children.length; a < c; a++) {
+        const l = e.children[a];
+        if (l.visible || n.onlyVisible === !1) {
+          const h = await this.processNodeAsync(l);
           h !== null && o.push(h);
         }
       }
@@ -3814,8 +3963,8 @@ class Lt {
     for (let r = 0, o = e.children.length; r < o; r++) {
       const a = e.children[r];
       if (a.visible || n.onlyVisible === !1) {
-        const l = await this.processNodeAsync(a);
-        l !== null && i.push(l);
+        const c = await this.processNodeAsync(a);
+        c !== null && i.push(c);
       }
     }
     i.length > 0 && (s.nodes = i), this.serializeUserData(e, s);
@@ -3825,7 +3974,7 @@ class Lt {
    * @param {Array<THREE.Object3D>} objects List of objects to process
    */
   async processObjectsAsync(e) {
-    const t = new Se();
+    const t = new ge();
     t.name = "AuxScene";
     for (let n = 0; n < e.length; n++)
       t.children.push(e[n]);
@@ -3841,7 +3990,7 @@ class Lt {
     });
     const n = [];
     for (let s = 0; s < e.length; s++)
-      e[s] instanceof Se ? await this.processSceneAsync(e[s]) : n.push(e[s]);
+      e[s] instanceof ge ? await this.processSceneAsync(e[s]) : n.push(e[s]);
     n.length > 0 && await this.processObjectsAsync(n);
     for (let s = 0; s < this.skins.length; ++s)
       this.processSkin(this.skins[s]);
@@ -3856,7 +4005,7 @@ class Lt {
       await e(this.plugins[t]);
   }
 }
-class Et {
+class Mt {
   constructor(e) {
     this.writer = e, this.name = "KHR_lights_punctual";
   }
@@ -3872,7 +4021,7 @@ class Et {
     o.push(r), t.extensions = t.extensions || {}, t.extensions[this.name] = { light: o.length - 1 };
   }
 }
-class Dt {
+class St {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_unlit";
   }
@@ -3882,7 +4031,7 @@ class Dt {
     t.extensions = t.extensions || {}, t.extensions[this.name] = {}, s[this.name] = !0, t.pbrMetallicRoughness.metallicFactor = 0, t.pbrMetallicRoughness.roughnessFactor = 0.9;
   }
 }
-class At {
+class Lt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_clearcoat";
   }
@@ -3913,7 +4062,7 @@ class At {
     t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Tt {
+class Et {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_dispersion";
   }
@@ -3923,7 +4072,7 @@ class Tt {
     i.dispersion = e.dispersion, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class bt {
+class Dt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_iridescence";
   }
@@ -3947,7 +4096,7 @@ class bt {
     t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class It {
+class At {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_transmission";
   }
@@ -3964,7 +4113,7 @@ class It {
     t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Rt {
+class Tt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_volume";
   }
@@ -3981,7 +4130,7 @@ class Rt {
     e.attenuationDistance !== 1 / 0 && (i.attenuationDistance = e.attenuationDistance), i.attenuationColor = e.attenuationColor.toArray(), t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Pt {
+class bt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_ior";
   }
@@ -3991,12 +4140,12 @@ class Pt {
     i.ior = e.ior, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class vt {
+class It {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_specular";
   }
   async writeMaterialAsync(e, t) {
-    if (!e.isMeshPhysicalMaterial || e.specularIntensity === 1 && e.specularColor.equals(ft) && !e.specularIntensityMap && !e.specularColorMap) return;
+    if (!e.isMeshPhysicalMaterial || e.specularIntensity === 1 && e.specularColor.equals(ht) && !e.specularIntensityMap && !e.specularColorMap) return;
     const n = this.writer, s = n.extensionsUsed, i = {};
     if (e.specularIntensityMap) {
       const r = {
@@ -4015,7 +4164,7 @@ class vt {
     i.specularFactor = e.specularIntensity, i.specularColorFactor = e.specularColor.toArray(), t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Nt {
+class Pt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_sheen";
   }
@@ -4039,7 +4188,7 @@ class Nt {
     i.sheenRoughnessFactor = e.sheenRoughness, i.sheenColorFactor = e.sheenColor.toArray(), t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Ct {
+class Rt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_anisotropy";
   }
@@ -4053,7 +4202,7 @@ class Ct {
     i.anisotropyStrength = e.anisotropy, i.anisotropyRotation = e.anisotropyRotation, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Bt {
+class vt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_emissive_strength";
   }
@@ -4063,7 +4212,7 @@ class Bt {
     i.emissiveStrength = e.emissiveIntensity, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Ot {
+class Nt {
   constructor(e) {
     this.writer = e, this.name = "EXT_materials_bump";
   }
@@ -4080,24 +4229,24 @@ class Ot {
     i.bumpFactor = e.bumpScale, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Ft {
+class Ct {
   constructor(e) {
     this.writer = e, this.name = "EXT_mesh_gpu_instancing";
   }
   writeNode(e, t) {
     if (!e.isInstancedMesh) return;
-    const n = this.writer, s = e, i = new Float32Array(s.count * 3), r = new Float32Array(s.count * 4), o = new Float32Array(s.count * 3), a = new ve(), l = new ce(), c = new _e(), h = new ce();
+    const n = this.writer, s = e, i = new Float32Array(s.count * 3), r = new Float32Array(s.count * 4), o = new Float32Array(s.count * 3), a = new Ie(), c = new ie(), l = new Ue(), h = new ie();
     for (let u = 0; u < s.count; u++)
-      s.getMatrixAt(u, a), a.decompose(l, c, h), l.toArray(i, u * 3), c.toArray(r, u * 4), h.toArray(o, u * 3);
+      s.getMatrixAt(u, a), a.decompose(c, l, h), c.toArray(i, u * 3), l.toArray(r, u * 4), h.toArray(o, u * 3);
     const d = {
-      TRANSLATION: n.processAccessor(new te(i, 3)),
-      ROTATION: n.processAccessor(new te(r, 4)),
-      SCALE: n.processAccessor(new te(o, 3))
+      TRANSLATION: n.processAccessor(new Z(i, 3)),
+      ROTATION: n.processAccessor(new Z(r, 4)),
+      SCALE: n.processAccessor(new Z(o, 3))
     };
     s.instanceColor && (d._COLOR_0 = n.processAccessor(s.instanceColor)), t.extensions = t.extensions || {}, t.extensions[this.name] = { attributes: d }, n.extensionsUsed[this.name] = !0, n.extensionsRequired[this.name] = !0;
   }
 }
-he.Utils = {
+ae.Utils = {
   insertKeyframe: function(f, e) {
     const n = f.getValueSize(), s = new f.TimeBufferType(f.times.length + 1), i = new f.ValueBufferType(f.values.length + n), r = f.createInterpolant(new f.ValueBufferType(n));
     let o;
@@ -4127,7 +4276,7 @@ he.Utils = {
     const t = [], n = {}, s = f.tracks;
     for (let i = 0; i < s.length; ++i) {
       let r = s[i];
-      const o = le.parseTrackName(r.name), a = le.findNode(e, o.nodeName);
+      const o = re.parseTrackName(r.name), a = re.findNode(e, o.nodeName);
       if (o.propertyName !== "morphTargetInfluences" || o.propertyIndex === void 0) {
         t.push(r);
         continue;
@@ -4135,33 +4284,33 @@ he.Utils = {
       if (r.createInterpolant !== r.InterpolantFactoryMethodDiscrete && r.createInterpolant !== r.InterpolantFactoryMethodLinear) {
         if (r.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline)
           throw new Error("THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.");
-        console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead."), r = r.clone(), r.setInterpolation(it);
+        console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead."), r = r.clone(), r.setInterpolation(tt);
       }
-      const l = a.morphTargetInfluences.length, c = a.morphTargetDictionary[o.propertyIndex];
-      if (c === void 0)
+      const c = a.morphTargetInfluences.length, l = a.morphTargetDictionary[o.propertyIndex];
+      if (l === void 0)
         throw new Error("THREE.GLTFExporter: Morph target name not found: " + o.propertyIndex);
       let h;
       if (n[a.uuid] === void 0) {
         h = r.clone();
-        const u = new h.ValueBufferType(l * h.times.length);
+        const u = new h.ValueBufferType(c * h.times.length);
         for (let p = 0; p < h.times.length; p++)
-          u[p * l + c] = h.values[p];
+          u[p * c + l] = h.values[p];
         h.name = (o.nodeName || "") + ".morphTargetInfluences", h.values = u, n[a.uuid] = h, t.push(h);
         continue;
       }
       const d = r.createInterpolant(new r.ValueBufferType(1));
       h = n[a.uuid];
       for (let u = 0; u < h.times.length; u++)
-        h.values[u * l + c] = d.evaluate(h.times[u]);
+        h.values[u * c + l] = d.evaluate(h.times[u]);
       for (let u = 0; u < r.times.length; u++) {
         const p = this.insertKeyframe(h, r.times[u]);
-        h.values[p * l + c] = r.values[u];
+        h.values[p * c + l] = r.values[u];
       }
     }
     return f.tracks = t, f;
   },
   toFloat32BufferAttribute: function(f) {
-    const e = new te(new Float32Array(f.count * f.itemSize), f.itemSize, !1);
+    const e = new Z(new Float32Array(f.count * f.itemSize), f.itemSize, !1);
     if (!f.normalized && !f.isInterleavedBufferAttribute)
       return e.array.set(f.array), e;
     for (let t = 0, n = f.count; t < n; t++)
@@ -4170,7 +4319,7 @@ he.Utils = {
     return e;
   }
 };
-async function Ut(f) {
+async function Bt(f) {
   if (typeof FileReader > "u") {
     const e = await f.arrayBuffer(), n = Buffer.from(e).toString("base64");
     return `data:${f.type};base64,${n}`;
@@ -4180,7 +4329,7 @@ async function Ut(f) {
       n.onload = () => e(n.result), n.onerror = () => t(new Error("Failed to read Blob as Data URL")), n.readAsDataURL(f);
     });
 }
-async function xe(f) {
+async function de(f) {
   if (typeof f.arrayBuffer == "function")
     return await f.arrayBuffer();
   if (typeof FileReader < "u")
@@ -4193,23 +4342,23 @@ async function xe(f) {
     return e.buffer.slice(e.byteOffset, e.byteOffset + e.byteLength);
   }
 }
-const Gt = new rt(), zt = new he();
-function _t(f, e, t = 0.1) {
+const Ot = new nt(), Ft = new ae();
+function Ut(f, e, t = 0.1) {
   const n = e.normal(f), s = e.direction(f).mutiplyScalar(t * 0.5), i = f.direction(e).mutiplyScalar(t * 0.5), r = n.x * t * 0.5, o = n.y * t * 0.5;
   return {
     points: [
       // 第一条线
-      new g(f.x + r, f.y + o).add(i),
-      new g(e.x + r, e.y + o).add(s),
+      new w(f.x + r, f.y + o).add(i),
+      new w(e.x + r, e.y + o).add(s),
       // 第二条线
-      new g(f.x - r, f.y - o).add(i),
-      new g(e.x - r, e.y - o).add(s)
+      new w(f.x - r, f.y - o).add(i),
+      new w(e.x - r, e.y - o).add(s)
     ],
     indices: [0, 1, 1, 3, 3, 2, 2, 0],
     rectIndices: [0, 1, 3, 2, 0]
   };
 }
-class Oe extends ne {
+class Ne extends Q {
   static name = "WhiteModel";
   Dxf = null;
   Variable = null;
@@ -4239,18 +4388,18 @@ class Oe extends ne {
         new z.LineSegments(new z.EdgesGeometry(i), new z.LineBasicMaterial({ color: 0 }))
       );
     }), e.originalData.map(({ start: n, end: s, insetionArr: i }) => {
-      const r = new g(n.x, n.y).mutiplyScalar(e.scale), o = new g(s.x, s.y).mutiplyScalar(e.scale), { points: a, indices: l, rectIndices: c } = _t(r, o, e.width);
+      const r = new w(n.x, n.y).mutiplyScalar(e.scale), o = new w(s.x, s.y).mutiplyScalar(e.scale), { points: a, indices: c, rectIndices: l } = Ut(r, o, e.width);
       return {
         points: a,
-        indices: l,
-        rectIndices: c,
+        indices: c,
+        rectIndices: l,
         insetions: (i ?? []).map((h) => h.index)
       };
     }).forEach((n) => {
       const s = new z.Shape();
       n.rectIndices.forEach((o, a) => {
-        const l = n.points[o];
-        a === 0 ? s.moveTo(l.x, l.y) : s.lineTo(l.x, l.y);
+        const c = n.points[o];
+        a === 0 ? s.moveTo(c.x, c.y) : s.lineTo(c.x, c.y);
       });
       const i = new z.ExtrudeGeometry(s, {
         depth: 2.8,
@@ -4272,7 +4421,7 @@ class Oe extends ne {
   toOBJ() {
     return new Promise((e) => {
       this.material.opacity = 1, this.material.needsUpdate = !0, setTimeout(() => {
-        e(Gt.parse(this.whiteModelGroup)), this.material.opacity = 0.8, this.material.transparent = !0;
+        e(Ot.parse(this.whiteModelGroup)), this.material.opacity = 0.8, this.material.transparent = !0;
       }, 20);
     });
   }
@@ -4284,7 +4433,7 @@ class Oe extends ne {
   toGltf(e = !0) {
     return new Promise((t) => {
       this.material.opacity = 1, this.material.needsUpdate = !0, setTimeout(async () => {
-        zt.parse(this.whiteModelGroup.children, (n) => {
+        Ft.parse(this.whiteModelGroup.children, (n) => {
           t(n), this.material.opacity = 0.8, this.material.transparent = !0;
         }, () => {
           t(void 0);
@@ -4325,7 +4474,7 @@ class Oe extends ne {
       n.href = URL.createObjectURL(t), n.download = e, n.click();
     } else if (typeof global < "u") {
       const t = await this.toOBJ();
-      t && (await se("fs", !1)).writeFileSync(e, t);
+      t && (await ee("fs", !1)).writeFileSync(e, t);
     }
   }
   /**
@@ -4341,11 +4490,11 @@ class Oe extends ne {
       s.href = URL.createObjectURL(n), s.download = e, s.click();
     } else if (typeof global < "u") {
       const n = await this.toGltf(t);
-      n && (await se("fs", !1)).writeFileSync(e, t ? Buffer.from(n) : JSON.stringify(n));
+      n && (await ee("fs", !1)).writeFileSync(e, t ? Buffer.from(n) : JSON.stringify(n));
     }
   }
 }
-class Fe extends ne {
+class Ce extends Q {
   static name = "DetailsPoint";
   Dxf = null;
   WhiteModel = null;
@@ -4422,7 +4571,7 @@ class Fe extends ne {
     }, 50);
   }
 }
-class Ue extends ne {
+class Be extends Q {
   static name = "DxfLineModel";
   dxfLineModel = new z.LineSegments();
   dxfDoorsLineModel = new z.LineSegments();
@@ -4445,38 +4594,38 @@ class Ue extends ne {
     });
   }
 }
-const qt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const Gt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  DetailsPoint: Fe,
-  DxfLineModel: Ue,
-  WhiteModel: Oe
+  DetailsPoint: Ce,
+  DxfLineModel: Be,
+  WhiteModel: Ne
 }, Symbol.toStringTag, { value: "Module" }));
-function Pe(f, e = {}) {
+function be(f, e = {}) {
   const {
     detailsPoint: t = !0,
     whiteModel: n = !0,
     dxfLineModel: s = !0
   } = e;
-  s && f.addComponent(new Ue()), n && f.addComponent(new Oe()), t && f.addComponent(new Fe());
+  s && f.addComponent(new Be()), n && f.addComponent(new Ne()), t && f.addComponent(new Ce());
 }
-const jt = Object.assign(Pe, {
+const zt = Object.assign(be, {
   create(f = {}) {
-    return (e) => Pe(e, f);
+    return (e) => be(e, f);
   }
-}), Yt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}), qt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  ModelDataPlugin: jt,
-  components: qt
+  ModelDataPlugin: zt,
+  components: Gt
 }, Symbol.toStringTag, { value: "Module" }));
-function kt() {
+function _t() {
   return import("./index2.js");
 }
-function Xt() {
+function jt() {
   return import("./index3.js");
 }
-let Me = null;
-async function $t(f, e, t = !1, n) {
-  const s = await Promise.resolve().then(() => Yt), i = await kt(), r = await Xt(), o = new dt().usePlugin(s.ModelDataPlugin.create({
+let xe = null;
+async function Ht(f, e, t = !1, n) {
+  const s = await Promise.resolve().then(() => qt), i = await _t(), r = await jt(), o = new lt().usePlugin(s.ModelDataPlugin.create({
     detailsPoint: !1,
     whiteModel: !0
   })).usePlugin(i.RenderPlugin.create({
@@ -4486,12 +4635,12 @@ async function $t(f, e, t = !1, n) {
     orbitControls: t,
     camera: e
   })).usePlugin(r.Editor.create({ viewPermission: n })), a = o.findComponentByType(i.components.DomContainer);
-  return a && f.appendChild(a.domElement), Me = o, {
+  return a && f.appendChild(a.domElement), xe = o, {
     dxfSystem: o,
-    getFileAll: () => Vt(o)
+    getFileAll: () => Yt(o)
   };
 }
-async function Vt(f = Me) {
+async function Yt(f = xe) {
   const e = f.findComponentByName("WhiteModel"), t = new File([await f.AngleCorrectionDxf.toDxfImageBlob()], "img.jpg", { type: "image/jpeg" }), n = new File([f.Dxf.toDxfBlob()], "dxf.dxf", { type: "application/dxf" }), s = new File([f.AngleCorrectionDxf.toDxfBlob()], "dxf.dxf", { type: "application/dxf" }), i = new File([await e.toOBJBlob()], "model.obj", { type: "application/octet-stream" }), r = new File([await e.toGltfBlob(!0)], "model.glb", { type: "application/octet-stream" }), o = new File([await e.toGltfBlob(!1)], "model.gltf", { type: "application/json" }), a = new File([JSON.stringify(f.Dxf.originalData)], "json.json", { type: "application/json" });
   return {
     dxf: n,
@@ -4503,27 +4652,27 @@ async function Vt(f = Me) {
     correctionDxf: s
   };
 }
-function Zt() {
-  return Me;
+function Jt() {
+  return xe;
 }
 export {
   j as B,
-  ne as C,
-  dt as D,
-  Ne as E,
-  N as L,
-  jt as M,
-  g as P,
-  Z as Q,
-  ut as T,
-  Ce as V,
-  Oe as W,
-  Fe as a,
-  ge as b,
-  $ as c,
-  $t as d,
-  Zt as e,
-  Vt as g,
-  qt as i,
-  me as u
+  Q as C,
+  lt as D,
+  Pe as E,
+  R as L,
+  zt as M,
+  w as P,
+  J as Q,
+  ct as T,
+  Re as V,
+  Ne as W,
+  Ce as a,
+  oe as b,
+  W as c,
+  Ht as d,
+  Jt as e,
+  Yt as g,
+  Gt as i,
+  pe as u
 };