build-dxf 0.0.32 → 0.0.34

package/src/build.js

@@ -1,16 +1,16 @@
-import * as G from "three";
-import { EventDispatcher as Ie, Color as Re, Matrix4 as Se, Vector3 as Z, Quaternion as Pe, BufferAttribute as k, REVISION as Ne, CompressedTexture as ne, Source as ve, NoColorSpace as Ce, MathUtils as oe, RGBAFormat as Be, ImageUtils as Oe, DoubleSide as Ge, PropertyBinding as Q, InterpolateDiscrete as Fe, Scene as ue, SRGBColorSpace as Ue, NearestFilter as _e, NearestMipmapNearestFilter as ze, NearestMipmapLinearFilter as qe, LinearFilter as je, LinearMipmapNearestFilter as Ye, LinearMipmapLinearFilter as Ve, ClampToEdgeWrapping as ke, RepeatWrapping as Xe, MirroredRepeatWrapping as We, InterpolateLinear as He } from "three";
-import de from "clipper-lib";
-import $ from "dxf-writer";
-import { OBJExporter as Je } from "three/examples/jsm/exporters/OBJExporter.js";
-function ae() {
-  return "xxxx-xxxx-4xxx-yxxx-xxxx".replace(/[xy]/g, function(d) {
-    var e = Math.random() * 16 | 0, t = d == "x" ? e : e & 3 | 8;
+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() {
+  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 Le extends Ie {
-  uuid = ae();
+class Ne extends Ge {
+  uuid = me();
   addEventListener(e, t, n) {
     const { once: s = !1 } = n ?? {}, i = (o) => {
       t(o), s && r();
@@ -30,7 +30,7 @@ class Le extends Ie {
     t && (t.forEach((n) => n()), this.eventRecordStack.delete(e));
   }
 }
-class W extends Le {
+class ne extends Ne {
   parent;
   destroyed = !1;
   constructor(...e) {
@@ -48,7 +48,7 @@ class W extends Le {
     this.destroyed = !0;
   }
 }
-class Ke extends Le {
+class ot extends Ne {
   static EventType = {
     ADD_COMPONENT: "addComponent"
   };
@@ -71,7 +71,7 @@ class Ke extends Le {
    * @param component 
    */
   removeComponent(e) {
-    if (e instanceof W) {
+    if (e instanceof ne) {
       const t = this.components.indexOf(e);
       t > -1 && (this.components.splice(t, 1), this.dispatchEvent({
         type: "removeComponent",
@@ -116,225 +116,17 @@ class Ke extends Le {
     return t || null;
   }
 }
-class w {
-  x;
-  y;
-  get X() {
-    return this.x;
-  }
-  get Y() {
-    return this.y;
-  }
-  userData = {};
-  /**
-   * 
-   * @param x 
-   * @param y 
-   */
-  constructor(e = 0, t = 0) {
-    this.x = e, this.y = t;
-  }
-  set(e, t) {
-    return this.x = e, this.y = t, this;
-  }
-  setX(e) {
-    return this.x = e, this;
-  }
-  setY(e) {
-    return this.y = e, this;
-  }
-  /**
-   * 
-   * @param point 
-   * @returns 
-   */
-  equal(e) {
-    return Math.abs(e.x - this.x) < 1e-9 && Math.abs(e.y - this.y) < 1e-9;
-  }
-  /**
-   * 
-   * @param arr 
-   */
-  setByArray(e) {
-    return this.x = e[0], this.y = e[1], this;
-  }
-  /**
-   * 
-   */
-  toArray() {
-    return [this.x, this.y];
-  }
-  /**
-   * multiplyScalar
-   * @param scalar 
-   */
-  mutiplyScalar(e) {
-    return this.x *= e, this.y *= e, this;
-  }
-  multiplyScalar(e) {
-    return this.x *= e, this.y *= e, this;
-  }
-  /**
-   * 
-   * @param scalar 
-   * @returns 
-   */
-  divisionScalar(e) {
-    return this.x /= e, this.y /= e, this;
-  }
-  /**
-   * 减法
-   * @description 将当前点的坐标减去指定点的坐标
-   * @param point
-   * @returns 
-   */
-  division(e) {
-    return this.x -= e.x, this.y -= e.y, this;
-  }
-  /**
-   * 加法
-   * @description 将当前点的坐标加上指定点的坐标
-   * @param point 
-   * @returns 
-   */
-  add(e) {
-    return this.x += e.x, this.y += e.y, this;
-  }
-  /**
-   * 绕point旋转angle
-   * @param point 
-   * @param angle 旋转角度，单位为弧度
-   */
-  rotate(e, t) {
-    const n = this.x - e.x, s = this.y - e.y, i = Math.cos(t), r = Math.sin(t), o = n * i - s * r, a = n * r + s * i;
-    return this.x = o + e.x, this.y = a + e.y, this;
-  }
-  /**
-   * 保留小数位数
-   * @param count 
-   */
-  fixed(e) {
-    return this.x = Number(this.x.toFixed(e)), this.y = Number(this.y.toFixed(e)), this;
-  }
-  /**
-   * 归一化
-   * @description 将当前点的坐标归一化为单位向量
-   * @returns 
-   */
-  normalize() {
-    const e = Math.sqrt(this.x * this.x + this.y * this.y);
-    return e === 0 ? this : (this.x /= e, this.y /= e, this);
-  }
-  /**
-   * 获取单位法向量
-   * @description 计算当前点到指定点的方向向量，并返回逆时针旋转90度后的单位法向量
-   * @param point 
-   * @returns 
-   */
-  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 w(i, r);
-  }
-  /**
-   * 获取由传入的点到该点的单位方向向量
-   * @description 计算当前点到指定点的方向向量，并返回单位方向
-   * @param point 
-   * @returns 
-   */
-  direction(e) {
-    const t = this.x - e.x, n = this.y - e.y, s = Math.sqrt(t * t + n * n);
-    return s === 0 ? new w(0, 0) : new w(t / s, n / s);
-  }
-  /**
-   * 计算模长
-   * @returns 
-   */
-  magnitude() {
-    return Math.sqrt(this.x * this.x + this.y * this.y);
-  }
-  /**
-   * 计算点点积
-   * @param point 
-   * @returns 
-   */
-  dot(e) {
-    return this.x * e.x + this.y * e.y;
-  }
-  /** 求两个点叉积
-   * @description 如果叉积大于 0，a 到 b 为逆时针方向。
-   * @description 如果叉积小于 0，a 到 b 为顺时针方向。
-   * @param point 
-   * @returns 
-   */
-  cross(e) {
-    return this.x * e.y - this.y * this.x;
-  }
-  /** 计算两个向量夹角
-   * @description 公式：a · b = |a| × |b| × cosθ
-   * @description 结果为0（0度），两个向量方向一致，结果为3.1415926（180度， PI），两个向量方向相反
-   * @param point 
-   * @returns 
-   */
-  angleBetween(e, t = "radian", n = "180") {
-    const s = this.dot(e), i = this.magnitude(), r = e.magnitude();
-    if (i === 0 || r === 0) return 0;
-    const o = s / (i * r), a = Math.max(-1, Math.min(1, o));
-    return t === "radian" ? Math.acos(a) : t === "cos" ? a : n === "180" || this.cross(e) < 0 ? Math.acos(a) / (Math.PI / 180) : 360 - Math.acos(a) / (Math.PI / 180);
-  }
-  /** 获取向量长度
-   */
-  length() {
-    const e = Math.sqrt(this.x * this.x + this.y * this.y);
-    return Math.abs(e - Math.round(e)) < 1e-9 ? Math.round(e) : e;
-  }
-  /**
-   * 获取两个点长度
-   * @param point 
-   */
-  distance(e) {
-    return Math.sqrt(
-      (this.x - e.x) * (this.x - e.x) + (this.y - e.y) * (this.y - e.y)
-    );
-  }
-  /**
-   * 克隆
-   * @returns 
-   */
-  clone() {
-    return new w(this.x, this.y);
-  }
-  /**
-   * 克隆
-   * @returns 
-   */
-  copy(e) {
-    return this.x = e.x ?? 0, this.y = e.y ?? 0, this;
-  }
-  toJson(e = 0) {
-    return {
-      x: this.x,
-      y: this.y,
-      z: e
-    };
-  }
-  static from(e) {
-    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 w(0, 0);
-  }
-}
-class _ {
+class j {
   minX = 0;
   maxX = 0;
   minY = 0;
   maxY = 0;
   get points() {
     return [
-      new w(this.minX, this.minY),
-      new w(this.maxX, this.minY),
-      new w(this.maxX, this.maxY),
-      new w(this.minX, this.maxY)
+      new g(this.minX, this.minY),
+      new g(this.maxX, this.minY),
+      new g(this.maxX, this.maxY),
+      new g(this.minX, this.maxY)
     ];
   }
   get width() {
@@ -344,7 +136,7 @@ class _ {
     return this.maxY - this.minY;
   }
   get center() {
-    return new w(
+    return new g(
       this.minX + (this.maxX - this.minX) * 0.5,
       this.minY + (this.maxY - this.minY) * 0.5
     );
@@ -410,9 +202,9 @@ class _ {
     const o = this.points;
     for (let l = 0; l < 4; l++) {
       const c = o[l], h = o[(l + 1) % 4];
-      for (let f = 0; f < 4; f++) {
-        const u = t[f], p = t[(f + 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), b = (p.x - u.x) * (h.y - u.y) - (p.y - u.y) * (h.x - u.x);
-        if (y * x < 0 && S * b < 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) || b === 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))
+      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))
           return !0;
       }
     }
@@ -424,9 +216,9 @@ class _ {
     const a = (l) => {
       let c = 0;
       for (let h = 0; h < 4; h++) {
-        const f = t[h], u = t[(h + 1) % 4], p = (u.x - f.x) * (l.y - f.y) - (u.y - f.y) * (l.x - f.x);
+        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);
         if (p === 0) {
-          const y = Math.abs(u.x - f.x) > 1e-10 ? u.x - f.x : u.y - f.y, x = y ? (l.x - f.x) / y : 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;
         } else {
           const y = p > 0 ? 1 : -1;
@@ -507,7 +299,7 @@ class _ {
    * @returns 
    */
   clone() {
-    return new _(this.minX, this.maxX, this.minY, this.maxY);
+    return new j(this.minX, this.maxX, this.minY, this.maxY);
   }
   /**
    * 
@@ -518,7 +310,7 @@ class _ {
     const t = [], n = [];
     return e.forEach((s) => {
       t.push(s.x), n.push(s.y);
-    }), new _(
+    }), new j(
       Math.min(...t),
       Math.max(...t),
       Math.min(...n),
@@ -536,7 +328,7 @@ class _ {
       s?.points?.forEach((i) => {
         t.push(i.x), n.push(i.y);
       });
-    }), new _(
+    }), new j(
       Math.min(...t),
       Math.max(...t),
       Math.min(...n),
@@ -544,151 +336,30 @@ class _ {
     );
   }
 }
-class ce {
-  map = /* @__PURE__ */ new Map();
-  gridSize;
-  constructor(e = 2) {
-    this.gridSize = e;
+class ue {
+  points;
+  get p0() {
+    return this.points[0];
   }
-  /**
-   * 插入
-   * @param point 
-   * @param userData 
-   */
-  insert(e, t) {
-    if (!e || isNaN(e.x) || isNaN(e.y))
-      throw new Error("无效的点坐标");
-    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 };
+  get p1() {
+    return this.points[1];
   }
-  /**
-   * 批量加入
-   * @param points 
-   */
-  insertBatch(e) {
-    for (const { point: t, userData: n } of e)
-      this.insert(t, n);
+  get p2() {
+    return this.points[2];
   }
-  /** 移除点
-   * @param point 
-   */
-  remove(e) {
-    const { set: t, target: n } = e?.userData?.pointVirtualGrid ?? {};
-    t && (t.delete(n), delete e?.userData?.pointVirtualGridMap);
+  get p3() {
+    return this.points[3];
   }
-  /**
-   * 获取通过坐标，获取唯一网格索引
-   * @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 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 _(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) {
-    return e.userData.pointVirtualGrid && e.userData.pointVirtualGrid.target ? e.userData.pointVirtualGrid.target : null;
-  }
-}
-class te {
-  points;
-  get p0() {
-    return this.points[0];
-  }
-  get p1() {
-    return this.points[1];
-  }
-  get p2() {
-    return this.points[2];
-  }
-  get p3() {
-    return this.points[3];
-  }
-  get path() {
-    return this.points.flatMap((e, t) => {
-      const n = this.points[(t + 1) % this.points.length];
-      return [e.x, e.y, 0, n.x, n.y, 0];
-    });
+  get path() {
+    return this.points.flatMap((e, t) => {
+      const n = this.points[(t + 1) % this.points.length];
+      return [e.x, e.y, 0, n.x, n.y, 0];
+    });
   }
   path2D(e) {
     return this.points.flatMap((t, n) => {
       const s = this.points[(n + 1) % this.points.length];
-      return e && e(new w(t.x, t.y), new w(s.x, s.y)), [t.x, t.y, s.x, s.y];
+      return e && e(new g(t.x, t.y), new g(s.x, s.y)), [t.x, t.y, s.x, s.y];
     });
   }
   createGeometry() {
@@ -723,8 +394,8 @@ class te {
         if (Math.max(p, y) >= 0 && Math.min(p, y) <= 1)
           return !0;
       } else {
-        const f = ((o.x - t.x) * c - (o.y - t.y) * l) / h, u = ((o.x - t.x) * i - (o.y - t.y) * s) / h;
-        if (f >= 0 && f <= 1 && u >= 0 && u <= 1)
+        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;
+        if (d >= 0 && d <= 1 && u >= 0 && u <= 1)
           return !0;
       }
     }
@@ -806,7 +477,7 @@ class te {
     let e = 1 / 0, t = -1 / 0, n = 1 / 0, s = -1 / 0;
     return this.points.forEach((i) => {
       t = Math.max(i.x, t), e = Math.min(i.x, e), s = Math.max(i.x, s), n = Math.min(i.x, n);
-    }), new _(e, t, n, s);
+    }), new j(e, t, n, s);
   }
   /**
    * 
@@ -815,197 +486,21 @@ class te {
    * @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) : w.zero(), l = n ? i.direction(r).mutiplyScalar(t * s) : w.zero(), c = o.x * t * 0.5, h = o.y * t * 0.5;
-    return new te([
-      new w(i.x + c, i.y + h).add(l),
-      new w(r.x + c, r.y + h).add(a),
-      new w(r.x - c, r.y - h).add(a),
-      new w(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) : 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)
     ]);
   }
 }
-class Y {
-  bounds;
-  // 包围盒
-  capacity;
-  // 节点容量
-  maxDepth;
-  // 最大深度
-  depth;
-  // 当前深度
-  isLeaf = !0;
-  // 是否为叶子节点
-  children = null;
-  // 子节点数组
-  nodes = [];
-  // 存储的节点
-  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;
-  }
-  /**
-   * 插入线段节点
-   * @param node 线段节点
-   */
-  insert(e) {
-    if (!this.isLeaf) {
-      const t = this.getQuadrant(e.line);
-      if (t !== -1) {
-        this.children[t].insert(e);
-        return;
-      }
-    }
-    if (this.nodes.push(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));
-      }
-    }
-  }
-  /** 移除
-   * @param node 
-   */
-  remove(e) {
-    const t = e.parent?.nodes.indexOf(e);
-    t > -1 && e.parent?.nodes.splice(t, 1);
-  }
-  /**
-   * 获取线段所属的象限
-   * @param line 线段
-   * @returns 象限索引（0:西北,1:东北,2:西南,3:东南）或-1（跨多个象限）
-   */
-  getQuadrant(e) {
-    const t = this.children[0].bounds.intersectLineSegment(e), n = this.children[1].bounds.intersectLineSegment(e), s = this.children[2].bounds.intersectLineSegment(e), i = this.children[3].bounds.intersectLineSegment(e);
-    let r = 0, o = -1;
-    return t && (r++, o = 0), n && (r++, o = 1), s && (r++, o = 2), i && (r++, o = 3), r === 1 ? o : -1;
-  }
-  /**
-   * 细分当前节点为四个子节点
-   */
-  subdivide() {
-    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 Y(
-      new _(this.bounds.minX, e, this.bounds.minY, t),
-      this.capacity,
-      this.maxDepth,
-      this.depth + 1
-    ), this.children[1] = new Y(
-      new _(e, this.bounds.maxX, this.bounds.minY, t),
-      this.capacity,
-      this.maxDepth,
-      this.depth + 1
-    ), this.children[2] = new Y(
-      new _(this.bounds.minX, e, t, this.bounds.maxY),
-      this.capacity,
-      this.maxDepth,
-      this.depth + 1
-    ), this.children[3] = new Y(
-      new _(e, this.bounds.maxX, t, this.bounds.maxY),
-      this.capacity,
-      this.maxDepth,
-      this.depth + 1
-    );
-  }
-  /**
-   * 查询与包围盒相交的线段节点
-   * @param box2 包围盒
-   * @returns 相交的节点数组
-   */
-  queryBox(e) {
-    const t = [];
-    if (!this.bounds.intersectBox(e))
-      return t;
-    for (const n of this.nodes)
-      e.intersectLineSegment(n.line) && t.push(n);
-    if (!this.isLeaf)
-      for (const n of this.children)
-        t.push(...n.queryBox(e));
-    return t;
-  }
-  /**
-   * 查询与圆形区域相交的线段节点
-   * @param pos 圆心
-   * @param radius 半径
-   * @returns 相交的节点数组
-   */
-  queryCircle(e, t) {
-    const n = [], s = new _(
-      e.x - t,
-      e.x + t,
-      e.y - t,
-      e.y + t
-    );
-    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;
-      h = Math.max(0, Math.min(1, h));
-      const f = r.x + h * a, u = r.y + h * l;
-      e.distance(new w(f, u)) <= t && n.push(i);
-    }
-    if (!this.isLeaf)
-      for (const i of this.children)
-        n.push(...i.queryCircle(e, t));
-    return n.sort((i) => i.line.length()), n;
-  }
-  /**
-   * 查询与矩形相交的线段节点
-   * @param rectangle 矩形
-   * @returns 相交的节点数组
-   */
-  queryRect(e) {
-    const t = [];
-    if (!this.bounds.intersectRectangle(e))
-      return t;
-    for (const n of this.nodes)
-      e.intersectLineSegment(n.line) && t.push(n);
-    if (!this.isLeaf)
-      for (const n of this.children)
-        t.push(...n.queryRect(e));
-    return t;
-  }
-  /**
-   * 查询与线段相交的线段节点
-   * @param lineSegment 线段
-   * @returns 相交的节点数组
-   */
-  queryLineSegment(e, t = !0) {
-    const n = [];
-    if (!this.bounds.intersectLineSegment(e))
-      return n;
-    for (const s of this.nodes)
-      e.intersectLineSegment(s.line, t) && n.push(s);
-    if (!this.isLeaf)
-      for (const s of this.children)
-        n.push(...s.queryLineSegment(e));
-    return n;
-  }
-  /**
-   * 包围盒转换为数组
-   * @param array 
-   * @param colors 
-   * @returns 
-   */
-  boundsToArray(e = [], t, n = !0) {
-    return !this.isLeaf && n && this.children?.forEach((s) => s.boundsToArray(e, t)), e.push(...this.bounds.points.flatMap((s, i, r) => {
-      const o = r[(i + 1) % r.length];
-      return t?.push(...this.color), t?.push(...this.color), [s.x, s.y, 0, o.x, o.y, 0];
-    })), e;
-  }
-}
-class B {
-  points = [new w(), new w()];
+class N {
+  points = [new g(), new g()];
   userData = {};
   // line: any
   get center() {
-    return new w(
+    return new g(
       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
     );
@@ -1016,7 +511,7 @@ class B {
   get end() {
     return this.points[1];
   }
-  constructor(e = new w(), t = new w()) {
+  constructor(e = new g(), t = new g()) {
     this.points = [e, t];
   }
   set(e, t) {
@@ -1102,15 +597,15 @@ class B {
    * @returns {Rectangle}
    */
   expandToRectangle(e = 0.1, t = "all") {
-    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, l = i.y * e * 0.5, c = [
+    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 = [
       // 第一条线
-      new w(n.x + a, n.y + l).add(o),
-      new w(s.x + a, s.y + l).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 - l).add(o),
-      new w(s.x - a, s.y - l).add(r)
+      new g(n.x - a, n.y - l).add(o),
+      new g(s.x - a, s.y - l).add(r)
     ];
-    return new te([0, 1, 3, 2].map((h) => c[h]));
+    return new ue([0, 1, 3, 2].map((h) => c[h]));
   }
   /**
    * 计算线段的长度
@@ -1147,24 +642,24 @@ class B {
   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 w(i.x - s.x, i.y - s.y);
+    const [t, n] = e.points, [s, i] = this.points, r = new g(i.x - s.x, i.y - s.y);
     if (r.x === 0 && r.y === 0)
       throw new Error("投影目标线段的两个点不能重合");
     const o = (p) => {
-      const y = new w(p.x - s.x, p.y - s.y), x = r.x * r.x + r.y * r.y, b = (y.x * r.x + y.y * r.y) / x, C = s.x + b * r.x, m = s.y + b * r.y;
-      return new w(C, m);
+      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);
     };
     let a = o(t), l = o(n);
     const c = (p) => {
-      const y = new w(p.x - s.x, p.y - s.y), x = r.x * r.x + r.y * r.y;
+      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 h = c(a), f = c(l);
+    let h = c(a), d = c(l);
     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 w(x, S);
+      return new g(x, S);
     };
-    return (h < 0 || h > 1) && (a = u(h)), (f < 0 || f > 1) && (l = u(f)), a.x === l.x && a.y === l.y ? new B(a, a) : new B(a, l);
+    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);
   }
   /**
    * 计算一条线段在另一条直线上的投影
@@ -1173,138 +668,727 @@ class B {
    * @returns 投影并裁剪后的线段
    */
   projectPoint(e, t = !0) {
-    const [n, s] = this.points, i = new w(s.x - n.x, s.y - n.y);
+    const [n, s] = this.points, i = new g(s.x - n.x, s.y - n.y);
     if (i.x === 0 && i.y === 0)
       throw new Error("投影目标线段的两个点不能重合");
     let o = ((c) => {
-      const h = new w(c.x - n.x, c.y - n.y), f = i.x * i.x + i.y * i.y, p = (h.x * i.x + h.y * i.y) / f, y = n.x + p * i.x, x = n.y + p * i.y;
-      return new w(y, x);
+      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);
     })(e);
     if (!t) return o;
     let l = ((c) => {
-      const h = new w(c.x - n.x, c.y - n.y), f = i.x * i.x + i.y * i.y;
-      return (h.x * i.x + h.y * i.y) / f;
+      const h = new g(c.x - n.x, c.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;
   }
   /**
-   * 判断线段是否与另一条线段相交（包含共用端点或部分重合的情况）
-   * @param line 
-   * @param endpoint 是否包含端点相交
+   * 判断线段是否与另一条线段相交（包含共用端点或部分重合的情况）
+   * @param line 
+   * @param endpoint 是否包含端点相交
+   * @returns 
+   */
+  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 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;
+    }
+    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)));
+  }
+  /**
+   * 判断一个点是否在线段上（含端点）
+   * @param pt 要判断的点
+   * @returns 如果点在当前线段上返回 true，否则返回 false
+   */
+  containsPoint(e) {
+    const t = e.distance(this.start), n = e.distance(this.end), s = this.getLength();
+    return Math.abs(t + n - s) < 1e-10;
+  }
+  /**
+   * 获取交点
+   * @param line 
+   * @returns 
+   */
+  getIntersection(e) {
+    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);
+  }
+  /**
+   * 获取两条线段夹角
+   * @param line 
+   */
+  includedAngle(e) {
+    const t = this.direction(), n = e.direction();
+    return t.angleBetween(n) / (Math.PI / 180);
+  }
+  /**
+   * 两条线段方向是否一致
+   * @param line 
+   */
+  directionEqual(e, t = 0.1) {
+    return this.includedAngle(e) < t;
+  }
+  /**
+   * 两条线段是否平行
+   * @param line 
+   */
+  parallel(e, t = 1) {
+    const n = this.includedAngle(e);
+    return n < t || n > 180 - t;
+  }
+  /**
+   * 两条线段方向相反否一致
+   * @param line 
+   */
+  directionOpposite(e, t = 0.1) {
+    return 180 - this.includedAngle(e) < t;
+  }
+  /**
+   * 判断两条线是否平行
+   * @param line 
+   */
+  isParallel(e, t = 4) {
+    const n = this.includedAngle(e);
+    return n < t || n > 180 - t;
+  }
+  /** 判断点在当前线段的左边还是右边，或者线段上
+   * @param point 
+   */
+  pointPosition(e) {
+    const t = this.start, n = this.end, s = (n.x - t.x) * (e.y - t.y) - (n.y - t.y) * (e.x - t.x);
+    return Math.abs(s) < 1e-10 ? "on" : s > 0 ? "left" : "right";
+  }
+  /** 
+   * @returns 
+   */
+  getRightDirection() {
+    return this.normal();
+  }
+  /**
+   * 
+   * @returns 
+   */
+  getLeftDirection() {
+    return this.normal().multiplyScalar(-1);
+  }
+  /** @param line 获取两条线段之间的最短距离
+   */
+  getMinLength(e) {
+    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)
+        return n.distance(i);
+      const c = ((n.x - i.x) * o + (n.y - i.y) * a) / l;
+      if (c < 0)
+        return n.distance(i);
+      if (c > 1)
+        return n.distance(r);
+      {
+        const h = i.x + c * o, d = i.y + c * a;
+        return n.distance(new g(h, d));
+      }
+    };
+    return Math.min(
+      t(this.start, e),
+      t(this.end, e),
+      t(e.start, this),
+      t(e.end, this)
+    );
+  }
+  /**
+   * 判断两条直线是否重合
+   * @param line 
+   * @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;
+  }
+  /** 克隆
+   * @returns 
+   */
+  clone() {
+    const e = new N(
+      this.points[0].clone(),
+      this.points[1].clone()
+    );
+    return e.userData = { ...this.userData }, e;
+  }
+  /**
+   * 获取最长线段
+   * @param lines 
+   */
+  static maxLengthLineIndex(e, t) {
+    let n = 0, s = -1;
+    for (let i = 0; i < e.length; i++) {
+      if (t && t(e[i])) continue;
+      const r = e[i].length();
+      r > n && (n = r, s = i);
+    }
+    return s;
+  }
+}
+class g {
+  x;
+  y;
+  get X() {
+    return this.x;
+  }
+  get Y() {
+    return this.y;
+  }
+  userData = {};
+  /**
+   * 
+   * @param x 
+   * @param y 
+   */
+  constructor(e = 0, t = 0) {
+    this.x = e, this.y = t;
+  }
+  set(e, t) {
+    return this.x = e, this.y = t, this;
+  }
+  setX(e) {
+    return this.x = e, this;
+  }
+  setY(e) {
+    return this.y = e, this;
+  }
+  /**
+   * 
+   * @param point 
+   * @returns 
+   */
+  equal(e) {
+    return Math.abs(e.x - this.x) < 1e-9 && Math.abs(e.y - this.y) < 1e-9;
+  }
+  /**
+   * 
+   * @param arr 
+   */
+  setByArray(e) {
+    return this.x = e[0], this.y = e[1], this;
+  }
+  /**
+   * 
+   */
+  toArray() {
+    return [this.x, this.y];
+  }
+  /**
+   * multiplyScalar
+   * @param scalar 
+   */
+  mutiplyScalar(e) {
+    return this.x *= e, this.y *= e, this;
+  }
+  multiplyScalar(e) {
+    return this.x *= e, this.y *= e, this;
+  }
+  /**
+   * 
+   * @param scalar 
+   * @returns 
+   */
+  divisionScalar(e) {
+    return this.x /= e, this.y /= e, this;
+  }
+  /**
+   * 减法
+   * @description 将当前点的坐标减去指定点的坐标
+   * @param point
+   * @returns 
+   */
+  division(e) {
+    return this.x -= e.x, this.y -= e.y, this;
+  }
+  /**
+   * 加法
+   * @description 将当前点的坐标加上指定点的坐标
+   * @param point 
+   * @returns 
+   */
+  add(e) {
+    return this.x += e.x, this.y += e.y, this;
+  }
+  /**
+   * 绕point旋转angle
+   * @param point 
+   * @param angle 旋转角度，单位为弧度
+   */
+  rotate(e, t) {
+    const n = this.x - e.x, s = this.y - e.y, i = Math.cos(t), r = Math.sin(t), o = n * i - s * r, a = n * r + s * i;
+    return this.x = o + e.x, this.y = a + e.y, this;
+  }
+  /**
+   * 保留小数位数
+   * @param count 
+   */
+  fixed(e) {
+    return this.x = Number(this.x.toFixed(e)), this.y = Number(this.y.toFixed(e)), this;
+  }
+  /**
+   * 归一化
+   * @description 将当前点的坐标归一化为单位向量
+   * @returns 
+   */
+  normalize() {
+    const e = Math.sqrt(this.x * this.x + this.y * this.y);
+    return e === 0 ? this : (this.x /= e, this.y /= e, this);
+  }
+  /**
+   * 获取单位法向量
+   * @description 计算当前点到指定点的方向向量，并返回逆时针旋转90度后的单位法向量
+   * @param point 
+   * @returns 
+   */
+  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);
+  }
+  /**
+   * 获取由传入的点到该点的单位方向向量
+   * @description 计算当前点到指定点的方向向量，并返回单位方向
+   * @param point 
+   * @returns 
+   */
+  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);
+  }
+  /** 展开为线
+   * @param direction 
+   * @param length 
+   */
+  expandAsLine(e, t, n) {
+    const s = new N(
+      this.clone(),
+      this.clone().add(e.clone().multiplyScalar(t))
+    );
+    return s.userData = n, s;
+  }
+  /**
+   * 计算模长
+   * @returns 
+   */
+  magnitude() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  /**
+   * 计算点点积
+   * @param point 
+   * @returns 
+   */
+  dot(e) {
+    return this.x * e.x + this.y * e.y;
+  }
+  /** 求两个点叉积
+   * @description 如果叉积大于 0，a 到 b 为逆时针方向。
+   * @description 如果叉积小于 0，a 到 b 为顺时针方向。
+   * @param point 
+   * @returns 
+   */
+  cross(e) {
+    return this.x * e.y - this.y * this.x;
+  }
+  /** 计算两个向量夹角
+   * @description 公式：a · b = |a| × |b| × cosθ
+   * @description 结果为0（0度），两个向量方向一致，结果为3.1415926（180度， PI），两个向量方向相反
+   * @param point 
+   * @returns 
+   */
+  angleBetween(e, t = "radian", n = "180") {
+    const s = this.dot(e), i = this.magnitude(), r = e.magnitude();
+    if (i === 0 || r === 0) return 0;
+    const o = s / (i * r), a = Math.max(-1, Math.min(1, o));
+    return t === "radian" ? Math.acos(a) : t === "cos" ? a : n === "180" || this.cross(e) < 0 ? Math.acos(a) / (Math.PI / 180) : 360 - Math.acos(a) / (Math.PI / 180);
+  }
+  /** 获取向量长度
+   */
+  length() {
+    const e = Math.sqrt(this.x * this.x + this.y * this.y);
+    return Math.abs(e - Math.round(e)) < 1e-9 ? Math.round(e) : e;
+  }
+  /**
+   * 获取两个点长度
+   * @param point 
+   */
+  distance(e) {
+    return Math.sqrt(
+      (this.x - e.x) * (this.x - e.x) + (this.y - e.y) * (this.y - e.y)
+    );
+  }
+  /**
+   * 克隆
+   * @returns 
+   */
+  clone() {
+    return new g(this.x, this.y);
+  }
+  /**
+   * 克隆
+   * @returns 
+   */
+  copy(e) {
+    return this.x = e.x ?? 0, this.y = e.y ?? 0, this;
+  }
+  toJson(e = 0) {
+    return {
+      x: this.x,
+      y: this.y,
+      z: e
+    };
+  }
+  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();
+  }
+  static zero() {
+    return new g(0, 0);
+  }
+}
+async function se(f, e = !0) {
+  if (typeof global < "u" && typeof require < "u")
+    return require(f);
+  {
+    let t = await import(
+      /* @vite-ignore */
+      f
+    );
+    return e && (t = t.default), t;
+  }
+}
+class Z {
+  bounds;
+  // 包围盒
+  capacity;
+  // 节点容量
+  maxDepth;
+  // 最大深度
+  depth;
+  // 当前深度
+  isLeaf = !0;
+  // 是否为叶子节点
+  children = null;
+  // 子节点数组
+  nodes = [];
+  // 存储的节点
+  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;
+  }
+  /**
+   * 插入线段节点
+   * @param node 线段节点
+   */
+  insert(e) {
+    if (!this.isLeaf) {
+      const t = this.getQuadrant(e.line);
+      if (t !== -1) {
+        this.children[t].insert(e);
+        return;
+      }
+    }
+    if (this.nodes.push(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));
+      }
+    }
+  }
+  /** 移除
+   * @param node 
+   */
+  remove(e) {
+    const t = e.parent?.nodes.indexOf(e);
+    t > -1 && e.parent?.nodes.splice(t, 1);
+  }
+  /**
+   * 获取线段所属的象限
+   * @param line 线段
+   * @returns 象限索引（0:西北,1:东北,2:西南,3:东南）或-1（跨多个象限）
+   */
+  getQuadrant(e) {
+    const t = this.children[0].bounds.intersectLineSegment(e), n = this.children[1].bounds.intersectLineSegment(e), s = this.children[2].bounds.intersectLineSegment(e), i = this.children[3].bounds.intersectLineSegment(e);
+    let r = 0, o = -1;
+    return t && (r++, o = 0), n && (r++, o = 1), s && (r++, o = 2), i && (r++, o = 3), r === 1 ? o : -1;
+  }
+  /**
+   * 细分当前节点为四个子节点
+   */
+  subdivide() {
+    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(
+      new j(this.bounds.minX, e, this.bounds.minY, t),
+      this.capacity,
+      this.maxDepth,
+      this.depth + 1
+    ), this.children[1] = new Z(
+      new j(e, this.bounds.maxX, this.bounds.minY, t),
+      this.capacity,
+      this.maxDepth,
+      this.depth + 1
+    ), this.children[2] = new Z(
+      new j(this.bounds.minX, e, t, this.bounds.maxY),
+      this.capacity,
+      this.maxDepth,
+      this.depth + 1
+    ), this.children[3] = new Z(
+      new j(e, this.bounds.maxX, t, this.bounds.maxY),
+      this.capacity,
+      this.maxDepth,
+      this.depth + 1
+    );
+  }
+  /**
+   * 查询与包围盒相交的线段节点
+   * @param box2 包围盒
+   * @returns 相交的节点数组
+   */
+  queryBox(e) {
+    const t = [];
+    if (!this.bounds.intersectBox(e))
+      return t;
+    for (const n of this.nodes)
+      e.intersectLineSegment(n.line) && t.push(n);
+    if (!this.isLeaf)
+      for (const n of this.children)
+        t.push(...n.queryBox(e));
+    return t;
+  }
+  /**
+   * 查询与圆形区域相交的线段节点
+   * @param pos 圆心
+   * @param radius 半径
+   * @returns 相交的节点数组
+   */
+  queryCircle(e, t) {
+    const n = [], s = new j(
+      e.x - t,
+      e.x + t,
+      e.y - t,
+      e.y + t
+    );
+    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;
+      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);
+    }
+    if (!this.isLeaf)
+      for (const i of this.children)
+        n.push(...i.queryCircle(e, t));
+    return n.sort((i) => i.line.length()), n;
+  }
+  /**
+   * 查询与点相交的线段节点
+   * @param point 圆心
+   * @returns 相交的节点数组
+   */
+  queryPoint(e) {
+    const t = [];
+    if (e.x < this.bounds.minX || e.x > this.bounds.maxX || e.y < this.bounds.minY || e.y > this.bounds.maxY)
+      return t;
+    for (const n of this.nodes)
+      n.line.isPointOnSegment(e) && t.push(n);
+    if (!this.isLeaf)
+      for (const n of this.children)
+        t.push(...n.queryPoint(e));
+    return t;
+  }
+  /**
+   * 查询与矩形相交的线段节点
+   * @param rectangle 矩形
+   * @returns 相交的节点数组
+   */
+  queryRect(e) {
+    const t = [];
+    if (!this.bounds.intersectRectangle(e))
+      return t;
+    for (const n of this.nodes)
+      e.intersectLineSegment(n.line) && t.push(n);
+    if (!this.isLeaf)
+      for (const n of this.children)
+        t.push(...n.queryRect(e));
+    return t;
+  }
+  /**
+   * 查询与线段相交的线段节点
+   * @param lineSegment 线段
+   * @returns 相交的节点数组
+   */
+  queryLineSegment(e, t = !0) {
+    const n = [];
+    if (!this.bounds.intersectLineSegment(e))
+      return n;
+    for (const s of this.nodes)
+      e.intersectLineSegment(s.line, t) && n.push(s);
+    if (!this.isLeaf)
+      for (const s of this.children)
+        n.push(...s.queryLineSegment(e));
+    return n;
+  }
+  /**
+   * 包围盒转换为数组
+   * @param array 
+   * @param colors 
    * @returns 
    */
-  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 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;
-    }
-    const l = o(n, s, i), c = o(n, s, r), h = o(i, r, n), f = o(i, r, s);
-    return !!(l * c < 0 && h * f < 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(f) < 1e-10 && a(s, i, r)));
+  boundsToArray(e = [], t, n = !0) {
+    return !this.isLeaf && n && this.children?.forEach((s) => s.boundsToArray(e, t)), e.push(...this.bounds.points.flatMap((s, i, r) => {
+      const o = r[(i + 1) % r.length];
+      return t?.push(...this.color), t?.push(...this.color), [s.x, s.y, 0, o.x, o.y, 0];
+    })), e;
+  }
+}
+class ge {
+  map = /* @__PURE__ */ new Map();
+  targetMap = /* @__PURE__ */ new Map();
+  gridSize;
+  constructor(e = 2) {
+    this.gridSize = e;
   }
   /**
-   * 判断一个点是否在线段上（含端点）
-   * @param pt 要判断的点
-   * @returns 如果点在当前线段上返回 true，否则返回 false
+   * 插入
+   * @param point 
+   * @param userData 
    */
-  containsPoint(e) {
-    const t = e.distance(this.start), n = e.distance(this.end), s = this.getLength();
-    return Math.abs(t + n - s) < 1e-10;
+  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 line 
-   * @returns 
+   * 批量加入
+   * @param points 
    */
-  getIntersection(e) {
-    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 w(a, l);
+  insertBatch(e) {
+    for (const { point: t, userData: n } of e)
+      this.insert(t, n);
   }
-  /**
-   * 获取两条线段夹角
-   * @param line 
+  /** 移除点
+   * @param point 
    */
-  includedAngle(e) {
-    const t = this.direction(), n = e.direction();
-    return t.angleBetween(n) / (Math.PI / 180);
+  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 line 
+   * 获取通过坐标，获取唯一网格索引
+   * @param point 
+   * @returns 
    */
-  directionEqual(e, t = 0.1) {
-    return this.includedAngle(e) < t;
+  getGridId(e) {
+    const t = Math.ceil(e.x / this.gridSize), n = Math.ceil(e.y / this.gridSize);
+    return `${t}.${n}`;
   }
   /**
-   * 两条线段是否平行
-   * @param line 
+   * 
+   * @param gridId 
+   * @returns 
    */
-  parallel(e, t = 1) {
-    const n = this.includedAngle(e);
-    return n < t || n > 180 - t;
+  decodeGridId(e) {
+    const [t, n] = e.split(".").map(Number);
+    return new g(t, n);
   }
   /**
-   * 两条线段方向相反否一致
-   * @param line 
+   * 查询与矩形相交的点
+   * @param rectangle 矩形
+   * @returns 相交的节点数组
    */
-  directionOpposite(e, t = 0.1) {
-    return 180 - this.includedAngle(e) < t;
+  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 line 
+   * 查询与圆形区域相交的点
+   * @param pos 圆心
+   * @param radius 半径
+   * @returns 相交的节点数组
    */
-  isParallel(e, t = 4) {
-    const n = this.includedAngle(e);
-    return n < t || n > 180 - t;
+  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 line 
-   * @returns 
+   * 查询与包围盒相交的点
+   * @param box2 包围盒
+   * @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;
+  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;
   }
-  clone() {
-    const e = new B(
-      this.points[0].clone(),
-      this.points[1].clone()
-    );
-    return e.userData = { ...this.userData }, e;
+  /**
+   * 查找相同点
+   * @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 lines 
+   * 查找点自己
+   * @param point 
    */
-  static maxLengthLineIndex(e, t) {
-    let n = 0, s = -1;
-    for (let i = 0; i < e.length; i++) {
-      if (t && t(e[i])) continue;
-      const r = e[i].length();
-      r > n && (n = r, s = i);
+  queryPointSelf(e) {
+    if (this.targetMap.has(e)) {
+      const { target: t } = this.targetMap.get(e);
+      return t;
     }
-    return s;
-  }
-}
-async function H(d, e = !0) {
-  if (typeof global < "u" && typeof require < "u")
-    return require(d);
-  {
-    let t = await import(
-      /* @vite-ignore */
-      d
-    );
-    return e && (t = t.default), t;
+    return null;
   }
 }
-const $e = {
+const at = {
   Unitless: 1,
   // 无单位，1米 = 1（无单位）
   Inches: 39.37007874015748,
@@ -1348,27 +1432,27 @@ const $e = {
   Parsecs: 3240779289666404e-32
   // 秒差距，1米 ≈ 0.00000000000000003240779289666404秒差距
 };
-function fe(d) {
+function Ee(f) {
   const e = [];
-  for (let t = 0; t < d.length; t++)
-    e.push(new B(
-      d[t].clone(),
-      d[(t + 1) % d.length].clone()
+  for (let t = 0; t < f.length; t++)
+    e.push(new N(
+      f[t].clone(),
+      f[(t + 1) % f.length].clone()
     ));
   return e;
 }
-function pe(d) {
-  return d.flatMap((e, t) => (t === d.length - 1 && [...e.points, d[0].points[0]], [e.points[0]]));
+function De(f) {
+  return f.flatMap((e, t) => (t === f.length - 1 && [...e.points, f[0].points[0]], [e.points[0]]));
 }
-class X extends W {
+class $ extends ne {
   static name = "Dxf";
   shortLine = 0.04;
   width = 0.04;
   scale = 1;
   originalData = [];
   data = [];
-  originalBox = new _(0, 0, 0, 0);
-  box = new _(0, 0, 0, 0);
+  originalBox = new j(0, 0, 0, 0);
+  box = new j(0, 0, 0, 0);
   pointsGroups = [];
   wallsGroup = [];
   doors = [];
@@ -1393,7 +1477,6 @@ class X extends W {
     return this.lineSegments;
   }
   /**初始化
-   * @param data 点云数据
    * @param width 墙体宽度
    * @param scale 缩放比例
    */
@@ -1404,60 +1487,62 @@ class X extends W {
    * 预处理数据
    * @param data 
    */
-  preprocessing(e, t = !1) {
-    const n = [];
-    let s = -1;
-    e.forEach(({ start: r, end: o, ...a }, l) => {
-      const c = new B(
-        w.from(r),
-        w.from(o)
+  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)
       );
-      c.userData = a, n.push(c), a.isVerticalReferenceLine && (s = l);
-    }), s === -1 && (s = B.maxLengthLineIndex(n, (r) => !r.userData.insetionArr?.length));
-    const i = n[s];
-    if (i.userData.isVerticalReferenceLine = !0, e[s].isVerticalReferenceLine = !0, t) {
-      const r = X.axisAlignmentCorrection(n, i);
-      return s = B.maxLengthLineIndex(r, (o) => !o.userData.insetionArr?.length), r[s].userData.isVerticalReferenceLine = !0, {
-        lineSegments: r,
-        data: this.lineDataToOriginalData(r)
-      };
-    }
-    return {
-      lineSegments: n,
-      data: e
-    };
+      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));
+    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({
+      type: "preprocessing",
+      data: e,
+      setData(a) {
+        s = a.map(({ start: l, end: c, ...h }) => {
+          const d = new N(g.from(l), g.from(c));
+          return d.userData = h, d;
+        }), e = a;
+      }
+    }), { lineSegments: s, data: e };
   }
-  /**
-   * 设置
-   * @param data 
-   * @param width 
-   * @param scale 
+  /** 设置
+   * @param data 房屋结构数据，node环境可以为路径
+   * @param width 墙体宽度
+   * @param scale 缩放比例
+   * @param axisAlignmentCorrection 需要执行轴对称垂直纠正
+   * @param option 
+   * @returns 
    */
-  async set(e, t = this.width, n = this.scale, s = !1) {
+  async set(e, t = this.width, n = this.scale, s = !1, i) {
     if (typeof e == "string")
       if (typeof global < "u") {
-        const { default: a } = await import(
+        const { default: l } = await import(
           /* @vite-ignore */
           "fs"
-        ), l = a.readFileSync(e), c = JSON.parse(l.toString("utf-8"));
-        return this.set(c, t, n, s);
+        ), c = l.readFileSync(e), h = JSON.parse(c.toString("utf-8"));
+        return this.set(h, t, n, s);
       } else
         throw new Error("非node环境不允许使用路径");
     this.scale = n, this.width = t;
-    const i = this.preprocessing(e, s);
-    e = i.data, this.lineSegments = i.lineSegments, this.originalData = e;
-    const r = [];
-    this.data = e.map(({ start: o, end: a, insetionArr: l, isDoor: c = !1 }, h) => {
-      r.push(o.z ?? 0, a.z ?? 0);
-      const f = this.lineSegments[h];
+    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);
+      const u = this.lineSegments[d];
       return [
-        f.points[0],
-        f.points[1],
-        (l ?? []).map((u) => u.index),
-        c,
-        h
+        u.points[0],
+        u.points[1],
+        (c ?? []).map((p) => p.index),
+        h,
+        d
       ];
-    }), this.originalZAverage = r.reduce((o, a) => o + a, 0) / r.length, this.computedOriginalSize(e, this.originalBox), this.dispatchEvent({
+    }), this.originalZAverage = o.reduce((a, l) => a + l, 0) / o.length, this.computedOriginalSize(e, this.originalBox), this.dispatchEvent({
       type: "setDta",
       originalData: this.originalData,
       data: this.data
@@ -1472,8 +1557,8 @@ class X extends W {
    */
   createGroups() {
     const e = [], t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Map(), i = (r, o, a = -1) => {
-      const [l, c, h, f] = this.data[r];
-      if (t.add(r), f)
+      const [l, c, 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) => {
         t.has(u) || i(u, o, r);
@@ -1568,7 +1653,7 @@ class X extends W {
         break;
       }
     }
-    const t = this.mergeSameDirectionLine(fe(e)), n = [t[0]];
+    const t = this.mergeSameDirectionLine(Ee(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) {
@@ -1583,7 +1668,7 @@ class X extends W {
       const a = t[s + 2];
       a && r.includedAngle(a) < 2 ? (s = s + 2, n.push(a)) : n.push(i);
     }
-    return n.length > 3 ? pe(this.mergeSameDirectionLine(n)) : [];
+    return n.length > 3 ? De(this.mergeSameDirectionLine(n)) : [];
   }
   /**
    * 移除短线段
@@ -1591,7 +1676,7 @@ class X extends W {
    * @param path 
    */
   removeShortLine(e, t = this.shortLine) {
-    const n = fe(e), s = [], i = Math.PI / 180;
+    const n = Ee(e), s = [], i = Math.PI / 180;
     for (let r = 0; r < n.length; r++) {
       const o = n[r], a = o.length(), l = r;
       if (a > t || s.length === 0) {
@@ -1599,9 +1684,9 @@ class X extends W {
         continue;
       }
       let c = n[++r];
-      const h = s[s.length - 1], f = h.direction();
+      const h = s[s.length - 1], d = h.direction();
       for (; r < n.length; ) {
-        const p = f.angleBetween(c.direction()) / i;
+        const p = d.angleBetween(c.direction()) / i;
         if (c.length() <= t || p < 4 || p > 176)
           c = n[++r];
         else break;
@@ -1619,20 +1704,20 @@ class X extends W {
       } else
         r = l;
     }
-    return s.length > 3 ? pe(s) : [];
+    return s.length > 3 ? De(s) : [];
   }
   /** 线偏移
    * @description 使用 ClipperLib 对每个点组进行线偏移处理，生成具有指定宽度的墙体路径
    */
-  lineOffset(e = X.EndType.etOpenSquare, t = X.JoinType.jtMiter, n = 1e4) {
-    let s = new de.Paths();
-    const i = new de.ClipperOffset(20, 0.25);
+  lineOffset(e = $.EndType.etOpenSquare, t = $.JoinType.jtMiter, n = 1e4) {
+    let s = new Le.Paths();
+    const i = new Le.ClipperOffset(20, 0.25);
     return this.pointsGroups.forEach((r) => {
       const o = this.lineTopology(r).map((a) => a.map((l) => l.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) => w.from(a).divisionScalar(n));
-      return o = this.lineSegmentStraightening(o), e == X.EndType.etOpenSquare && (o = this.squareRemoveBurr(o)), o;
+      let o = r.map((a) => g.from(a).divisionScalar(n));
+      return o = this.lineSegmentStraightening(o), e == $.EndType.etOpenSquare && (o = this.squareRemoveBurr(o)), o;
     }), this.dispatchEvent({
       type: "lineOffset",
       wallsGroup: this.wallsGroup
@@ -1667,31 +1752,13 @@ class X extends W {
    * 线段数据转为原始json数据
    */
   lineDataToOriginalData(e, t) {
-    return t || (t = new Y(_.fromByLineSegment(...e)), e.forEach((n) => t?.insert({ line: n, userData: void 0 }))), e.map((n) => {
-      const s = n.userData, i = s.drawWindow, r = t.queryLineSegment(n).filter((o) => o.line !== n && !o.userData?.isDoor).map((o) => ({ index: e.indexOf(o.line) }));
-      return {
-        start: n.start.toJson(this.originalZAverage),
-        end: n.end.toJson(this.originalZAverage),
-        insetionArr: r,
-        isDoor: s.isDoor,
-        doorDirectConnection: s.isDoor,
-        length: n.length(),
-        isWindow: s.isWindow,
-        isVerticalReferenceLine: s.isVerticalReferenceLine,
-        wallWidth: n.userData.wallWidth,
-        drawWindow: i && i.map((o) => ({
-          p: { x: o.p.x, y: o.p.y, z: o.p.z },
-          width: o.width,
-          full: o.full
-        }))
-      };
-    });
+    return $.lineDataToOriginalData(e, this.originalZAverage, t);
   }
   /**
    * 转为绘制数据
    */
   toDrawDataJson(e = "Millimeters") {
-    const t = $e[e], n = {
+    const t = at[e], n = {
       unit: e,
       line: [],
       arc: [],
@@ -1705,13 +1772,13 @@ class X extends W {
     function i(l, c) {
       n.line.push([l.x * t, l.y * t, c.x * t, c.y * t, s]);
     }
-    function r(l, c, h, f) {
+    function r(l, c, h, d) {
       n.arc.push([
         l.x * t,
         l.y * t,
         c * t,
         h,
-        f,
+        d,
         s
       ]);
     }
@@ -1724,7 +1791,7 @@ class X extends W {
     }
     this.wallsGroup.forEach((l) => {
       for (let c = 0; c < l.length; c++) {
-        const h = l[c], f = c === l.length - 1 ? 0 : c + 1, u = l[f];
+        const h = l[c], d = c === l.length - 1 ? 0 : c + 1, u = l[d];
         i(h, u);
       }
     });
@@ -1735,29 +1802,29 @@ class X extends W {
       if (s = "cyan", c.length() < 1.2) {
         c.expansion(-o * 0.5);
         const h = l.normal();
-        let f = new B(
+        let d = new N(
           c.start.clone(),
           c.start.clone().add(h.clone().multiplyScalar(c.length()))
         );
-        const u = f.clone().directionMove(f.normal(), c.length() * -0.5).expandToRectangle(c.length(), "bothSides");
-        for (let m = 0; m < a.length; m++)
-          if (a[m].intersectRectangle(u)) {
-            f = new B(
+        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()))
             );
             break;
           }
-        f.expansion(-o * 0.5).expandToRectangle(this.width * 0.2, "bothSides").path2D((m, E) => i(m, E));
-        const p = c.length(), y = f.length(), x = (p ** 2 + y ** 2) / (2 * y), S = f.end.clone().add(f.direction().multiplyScalar(-x)), [b, C] = this.getArcAngleRange(S, c.end, f.end);
-        r(S, x, Math.min(b, C), Math.max(b, C)), a.push(u);
+        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);
       } else
-        c.clone().expansion(-this.width * 0.5).expandToRectangle(this.width).path2D((h, f) => i(h, f)), 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, f) => i(h, f)), 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, f) => i(h, f));
+        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: f } = c, u = w.from(h), p = u.clone().add(l.direction().multiplyScalar(f * 0.5)), y = u.clone().add(l.direction().multiplyScalar(-f * 0.5)), x = new B(p, y);
-        i(x.start, x.end), x.expandToRectangle(this.width, "bothSides").path2D((S, b) => i(S, b));
+        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));
       });
     }), n;
   }
@@ -1771,7 +1838,7 @@ class X extends W {
     if (typeof window < "u")
       i = document.createElement("canvas");
     else if (typeof global < "u") {
-      const { createCanvas: l } = await H("canvas");
+      const { createCanvas: l } = await se("canvas");
       i = l();
     } else
       throw new Error("创建画布失败");
@@ -1782,12 +1849,12 @@ class X extends W {
     };
     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, f, u]) => {
-      a.strokeStyle = o[u], a.beginPath(), a.moveTo(l, c), a.lineTo(h, f), a.closePath(), a.stroke();
-    }), s.arc.forEach(([l, c, h, f, u, p]) => {
-      a.strokeStyle = o[p], a.beginPath(), a.arc(l, c, h, f * (Math.PI / 180), u * (Math.PI / 180)), a.stroke();
+    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, f, u] = 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) => {
@@ -1800,8 +1867,8 @@ class X extends W {
    * 将点json结构转换为Dxf string
    */
   toDxfString(e = "Millimeters") {
-    const t = new $();
-    t.setUnits(e), t.addLayer("cyan", $.ACI.CYAN, "DOTTED"), t.addLayer("yellow", $.ACI.YELLOW, "DOTTED"), t.addLayer("white", $.ACI.WHITE, "DOTTED");
+    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 n = this.toDrawDataJson();
     return n.line.forEach((s) => {
       let [i, r, o, a, l] = s;
@@ -1827,7 +1894,7 @@ class X extends W {
     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 H("fs", !1)).writeFileSync(e, t);
+    } else typeof global < "u" && (await se("fs", !1)).writeFileSync(e, t);
   }
   /**
    * 下载
@@ -1837,7 +1904,7 @@ class X extends W {
     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 H("fs", !1)).writeFileSync(e, this.toDxfString(t));
+    } else typeof global < "u" && (await se("fs", !1)).writeFileSync(e, this.toDxfString(t));
   }
   /**
    * 下载
@@ -1849,7 +1916,7 @@ class X extends W {
     if (typeof window < "u") {
       const i = document.createElement("a");
       i.href = URL.createObjectURL(s), i.download = e, i.click();
-    } else typeof global < "u" ? (await H("fs", !1)).writeFileSync(e, s) : console.error("图片下载失败");
+    } else typeof global < "u" ? (await se("fs", !1)).writeFileSync(e, s) : console.error("图片下载失败");
     return !0;
   }
   /**
@@ -1857,10 +1924,34 @@ class X extends W {
    * @description 计算所有线段的起点和终点的最小最大值，形成一个边界框
    * @returns 
    */
-  computedOriginalSize(e, t = new _(0, 0, 0, 0)) {
+  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);
     return t.set(i, r, o, a), t;
   }
+  /**
+   * 线段数据转为原始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) => {
+      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),
+        end: s.end.toJson(t),
+        insetionArr: o,
+        isDoor: i.isDoor,
+        doorDirectConnection: i.isDoor,
+        length: s.length(),
+        isWindow: i.isWindow,
+        isVerticalReferenceLine: i.isVerticalReferenceLine,
+        wallWidth: s.userData.wallWidth,
+        drawWindow: r && r.map((a) => ({
+          p: { x: a.p.x, y: a.p.y, z: a.p.z },
+          width: a.width,
+          full: a.full
+        }))
+      };
+    });
+  }
   /**
    * 创建数据
    * @param pointsGroups 
@@ -1890,218 +1981,316 @@ class X extends W {
    * @param targettLine 轴线段
    * @returns 
    */
-  static axisAlignmentCorrection(e, t) {
-    function n(m) {
-      const E = new ce();
-      m.forEach((M) => M.userData.isDoor || M.points.forEach((g) => E.insert(g, M)));
+  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 < m.length; M++) {
-        const g = m[M], D = /* @__PURE__ */ new Map();
-        g.userData.isDoor || g.points.forEach((T) => {
-          if (E.queryPoint(T).length > 1) return;
-          const A = E.queryCircle(T, 0.4).filter((R) => {
-            const I = R.userData;
-            if (I === g || !g.parallel(I, 25)) return !1;
-            if (E.queryPoint(R.point).length > 1) return;
-            const N = new B(T, R.point), F = new B(g.start === T ? g.end : g.start, I.start === R.point ? I.end : I.start);
-            if (!N.intersectLineSegment(F)) return !1;
-            const O = T.distance(R.point);
-            return O < 1e-3 ? !1 : (D.set(R.point, O), !0);
-          }).sort((R, I) => {
-            const N = D.get(R.point), F = D.get(I.point);
-            return N - F;
+      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;
           });
           if (A.length === 0) return;
-          const P = A[0].userData;
-          L.push(new B(g.projectLineSegment(P).center, P.projectLineSegment(g).center));
+          const B = A[0].userData;
+          L.push(new N(m.projectLineSegment(B).center, B.projectLineSegment(m).center));
         });
       }
-      return [...m, ...L];
+      return [...D, ...L];
     }
-    function s(m, E) {
-      const L = [m], M = [], g = [], D = [];
-      for (let T = 0; T < E.length; T++) {
-        const A = E[T];
-        if (m !== A) {
-          if (A.userData.isDoor) {
-            g.push(A);
-            continue;
-          }
-          if (A.userData.isWindow && D.push(A), A.parallel(m, 45)) {
-            const P = Math.atan2(A.end.y - A.start.y, A.end.x - A.start.x);
-            let I = Math.atan2(m.end.y - m.start.y, m.end.x - m.start.x) - P;
-            for (; I > Math.PI; ) I -= 2 * Math.PI;
-            for (; I < -Math.PI; ) I += 2 * Math.PI;
-            const N = A.center;
-            A.start.rotate(N, I), A.end.rotate(N, I), L.push(A);
+    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 l(D) {
+      const b = new Z(j.fromByLineSegment(...D));
+      D.forEach((M) => {
+        M.userData.isDoor || b.insert({ line: M, 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));
+      }
+      return L;
+    }
+    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);
           } else {
-            const P = Math.atan2(A.end.y - A.start.y, A.end.x - A.start.x), R = Math.atan2(m.end.y - m.start.y, m.end.x - m.start.x);
-            let I = R + Math.PI / 2 - P, N = R - Math.PI / 2 - P;
-            for (; I > Math.PI; ) I -= 2 * Math.PI;
-            for (; I < -Math.PI; ) I += 2 * Math.PI;
-            for (; N > Math.PI; ) N -= 2 * Math.PI;
-            for (; N < -Math.PI; ) N += 2 * Math.PI;
-            const F = Math.abs(I) < Math.abs(N) ? I : N, O = A.center;
-            A.start.rotate(O, F), A.end.rotate(O, F), M.push(A);
+            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);
           }
-        }
       }
-      return { parallelLines: L, verticalLines: M, doorLines: g, windowLines: D };
+      return { parallelLines: L, verticalLines: M, doorLines: m, windowLines: w };
     }
-    function i(m, E, L, M = 0.3, g = 0.06) {
-      const D = [];
-      m.forEach((P) => {
-        const R = L.projectPoint(P.start, !1);
-        R && (R.userData = P, D.push(R));
-      }), D.sort((P, R) => R.distance(L.start) - P.distance(L.start));
-      const T = [], A = [];
-      for (let P = 0; P < D.length; P++) {
-        const R = D[P];
-        if (P === 0) {
-          A.push(R);
+    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);
           continue;
         }
-        D[P - 1].distance(R) < g || (T.push([...A]), A.length = 0), A.push(R), P === D.length - 1 && T.push(A);
+        M[I - 1].distance(A) < i || (m.push([...w]), w.length = 0), w.push(A), I === M.length - 1 && m.push(w);
       }
-      return T.flatMap((P) => {
-        const R = P.flatMap((O) => {
-          const z = O.userData;
-          return z.points.map((j) => {
-            const U = E.projectPoint(j, !1);
-            return U.userData = z, U;
+      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;
           });
         });
-        R.sort((O, z) => O.distance(E.start) - z.distance(E.start));
-        const I = /* @__PURE__ */ new Map(), N = [], F = [];
-        return R.forEach((O, z) => {
-          I.size === 0 && z > 0 && R[z - 1].distance(O) > M && (N.push([...F]), F.length = 0), I.set(O.userData, (I.get(O.userData) ?? 0) + 1);
-          for (const j of I.values()) if (j !== 2) return;
-          F.push(...I.keys()), I.clear();
-        }), N.push([...F]), N;
+        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;
       });
     }
-    function r(m, E = 0.1) {
-      return m.map((L) => {
+    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);
+          });
+        }
+      }), D.map((M) => M.filter((m) => !L.has(m)));
+    }
+    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((U) => {
-          M.push(U.start.clone(), U.end.clone());
+        L.forEach((K) => {
+          M.push(K.start.clone(), K.end.clone());
         });
-        const g = L[0].direction().normalize();
-        let D = 1 / 0, T = -1 / 0, A = 0, P = 0;
-        M.forEach((U) => {
-          const J = U.x * g.x + U.y * g.y;
-          D = Math.min(D, J), T = Math.max(T, J), A += U.x, P += U.y;
+        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;
         });
-        const R = new w(A / M.length, P / M.length), I = R.x * g.x + R.y * g.y, N = new w(R.x + (D - I) * g.x, R.y + (D - I) * g.y), F = new w(R.x + (T - I) * g.x, R.y + (T - I) * g.y), O = new B(N, F), z = L[0].normal().normalize();
-        D = 1 / 0, T = -1 / 0, M.forEach((U) => {
-          const J = U.x * z.x + U.y * z.y;
-          D = Math.min(D, J), T = Math.max(T, J);
+        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 j = T - D;
-        return j >= E && (O.userData.wallWidth = j), L.forEach((U) => U.userData.fittedLine = O), O;
+        const ie = I - w;
+        return ie >= b && (Y.userData.wallWidth = ie), L.forEach((K) => K.userData.fittedLine = Y), Y;
       }).filter((L) => !!L);
     }
-    function o(m, E = 0.2) {
-      const L = new Y(_.fromByLineSegment(...m)), M = /* @__PURE__ */ new Map();
-      m.forEach((D) => {
-        M.set(D, { line: D, userData: void 0 }), L.insert(M.get(D));
+    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));
       });
-      const g = new B();
-      for (let D = 0; D < m.length; D++) {
-        const T = m[D];
-        if (T.userData.isAdsorbed) continue;
-        const A = T.direction().multiplyScalar(E), [P, R] = T.points.map((I) => {
-          g.set(I, I), g.start.add(A), g.end.add(A.multiplyScalar(-1));
-          const N = /* @__PURE__ */ new Map(), F = L.queryRect(g.expandToRectangle(0.1, "bothSides")).filter((O) => O.line !== T).map((O) => {
-            const z = O.line.getIntersection(g);
-            return N.set(O.line, z), O.line;
-          }).sort((O, z) => {
-            const j = N.get(O), U = N.get(z);
-            return j && U ? j.distance(I) - U.distance(I) : 0;
+      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;
           });
-          return F.length ? N.get(F[0]) : void 0;
+          return _.length ? v.get(_[0]) : void 0;
         });
-        if (P && R) {
-          if (P.equal(R)) {
-            const I = T.start.distance(P), N = T.end.distance(R);
-            I < N ? T.directionMove(T.start.direction(T.end), I) : T.directionMove(T.end.direction(T.start), N);
+        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);
           } else
-            T.start.copy(P), T.end.copy(R);
-          T.userData.isAdsorbed = !0;
-        } else P ? T.start.copy(P) : R && T.end.copy(R);
-        L.remove(M.get(T)), L.insert(M.get(T));
+            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));
       }
-      return m.filter((D) => D.length() > 1e-3);
+      return D.filter((m) => m.length() > 1e-3);
     }
-    function a(m) {
-      for (let E = 0; E < m.length; E++) {
-        const L = m[E], M = L.userData.fittedLine;
+    function y(D) {
+      for (let b = 0; b < D.length; b++) {
+        const L = D[b], M = L.userData.fittedLine;
         if (M) {
-          const g = L.direction();
-          M.userData.isWindow = !0, M.userData.drawWindow = M.userData.drawWindow ?? [], L.userData.drawWindow?.forEach((D) => {
-            const T = w.from(D.p), A = M.projectPoint(
-              T.clone().add(g.clone().multiplyScalar(D.width * 0.5))
-            ), P = M.projectPoint(
-              T.clone().add(g.clone().multiplyScalar(D.width * -0.5))
-            ), R = new B(A, P), I = R.center;
+          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 G.Vector3(I?.x ?? 0, I?.y ?? 0, D.p.z),
-              width: R.length(),
-              full: D.full
+              p: new z.Vector3(v?.x ?? 0, v?.y ?? 0, w.p.z),
+              width: F.length(),
+              full: w.full
             });
           });
         }
       }
     }
-    function l(m) {
-      const E = new Y(_.fromByLineSegment(...m));
-      return m.forEach((L) => E.insert({ line: L, userData: void 0 })), m.flatMap((L) => {
-        const M = E.queryLineSegment(L, !0).map((g) => {
-          if (g.line === L) return;
-          const D = g.line.getIntersection(L);
-          if (!(!D || L.start.equal(D) || L.end.equal(D)))
-            return D;
-        }).filter((g) => !!g);
+    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);
+          else {
+            const w = m.projectPoint(L.start);
+            w && L.start.copy(w);
+          }
+          if (L.isParallel(M))
+            L.end.distance(M.start) < L.end.distance(M.end) ? L.end.copy(M.start) : L.end.copy(M.end);
+          else {
+            const w = M.projectPoint(L.end);
+            w && L.end.copy(w);
+          }
+        }
+      }
+      return D;
+    }
+    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 g = L.clone();
-          M.sort((T, A) => g.start.distance(T) - g.start.distance(A));
-          const D = M.map((T) => {
-            const A = g.clone();
-            return A.set(g.start.clone(), T), g.start.copy(T), g.userData.isWindow && (A.userData.isWindow = !0, A.userData.drawWindow = g.userData.drawWindow?.filter((P) => A.isPointOnSegment(w.from(P.p))) ?? []), A;
+          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 g.userData.drawWindow = g.userData.drawWindow?.filter((T) => g.isPointOnSegment(w.from(T.p))) ?? [], [...D, g];
+          return m.userData.drawWindow = m.userData.drawWindow?.filter((I) => m.isPointOnSegment(g.from(I.p))) ?? [], [...w, m];
         }
         return L;
-      }).filter((L) => L.length() > 0.05);
+      }).filter((L) => L.length() > 0.03);
     }
-    e = n(e);
-    const { parallelLines: c, verticalLines: h, doorLines: f, windowLines: u } = s(t, e.map((m) => m.clone())), p = t.normal(), y = t.center, x = t.direction(), S = new B(
-      y.clone().add(p.clone().multiplyScalar(-1e3)),
-      y.clone().add(p.clone().multiplyScalar(1e3))
-    ), b = new B(
-      y.clone().add(x.clone().multiplyScalar(-1e3)),
-      y.clone().add(x.clone().multiplyScalar(1e3))
+    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))
     );
-    let C = r([
-      ...i.call(this, c, b, S),
-      ...i.call(this, h, S, b)
-    ]);
-    return C = o.call(this, C), C = o.call(this, C), a(u), C = l.call(this, C), [...C, ...f];
+    let J = [
+      ...h.call(this, G, W, k),
+      ...h.call(this, E, k, W)
+    ];
+    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;
+  }
+  /** 
+   * @param lines 
+   * @param trajectoryPoints
+   * @returns 
+   */
+  static findExteriorWall(e, t, n = 0.4) {
+    const s = new Z(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 h = i.pointPosition(a);
+          h !== "on" && o.add(h);
+        }
+      }
+      if (i.userData.expandDirect = [...o][0], o.size < 2) return !0;
+    }), e;
+  }
+  /** 边线外扩
+   * @param lines 
+   * @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;
+    });
+    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);
+      }
+    }), $.lineDataToOriginalData(r, o);
   }
+  boundaryExtension = $.boundaryExtension;
 }
-function le(d) {
-  if (d === null || typeof d != "object") return d;
-  if (d instanceof Date) return new Date(d.getTime());
-  if (Array.isArray(d)) return d.map(le);
+function we(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);
   const e = {};
-  for (const t in d)
-    Object.prototype.hasOwnProperty.call(d, t) && (e[t] = le(d[t]));
+  for (const t in f)
+    Object.prototype.hasOwnProperty.call(f, t) && (e[t] = we(f[t]));
   return e;
 }
-const V = new B();
-class Ze extends X {
+const ee = new N();
+class ct extends $ {
   static name = "AngleCorrectionDxf";
   angle = 0;
   onAddFromParent(e) {
@@ -2112,27 +2301,27 @@ class Ze extends X {
     let s = 0, i = null;
     for (let l = 0; l < t.originalData.length; l++) {
       const c = t.originalData[l];
-      if (V.start.copy(c.start), V.end.copy(c.end), c.isVerticalReferenceLine) {
-        const [h, f] = c.start.y < c.end.y ? [V.start, V.end] : [V.end, V.start];
-        s = -new B(h, f).direction().angleBetween(new w(0, 1), "angle", "360"), i = null;
+      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;
         break;
       }
-      (!i || V.length() > i.length()) && (i = V.clone(), i.userData.index = l);
+      (!i || ee.length() > i.length()) && (i = ee.clone(), i.userData.index = l);
     }
     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 B(l, c).direction().angleBetween(new w(0, 1), "angle", "360");
+      s = -new N(l, c).direction().angleBetween(new g(0, 1), "angle", "360");
     }
-    const r = t.originalBox.center, o = w.zero(), a = t.originalData.map((l) => {
-      const c = o.copy(l.start).division(r).rotate(w.zero(), s * (Math.PI / 180)).toJson(l.start.z), h = o.copy(l.end).division(r).rotate(w.zero(), s * (Math.PI / 180)).toJson(l.end.z), f = Object.assign(le(l), { start: c, end: h });
-      return f.drawWindow && f.drawWindow.forEach((u) => {
-        u.p = o.copy(u.p).division(r).rotate(w.zero(), s * (Math.PI / 180)).toJson(u.p.z);
-      }), f;
+    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 });
+      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);
+      }), d;
     });
     n.appendLineSegmentList.forEach((l) => {
       const c = l.clone();
-      c.start.division(r).rotate(w.zero(), s * (Math.PI / 180)), c.end.division(r).rotate(w.zero(), s * (Math.PI / 180)), a.push({
+      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),
         insetionArr: [],
@@ -2140,13 +2329,13 @@ class Ze extends X {
       });
     }), 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(w.zero(), s * (Math.PI / 180)), c.end.division(r).rotate(w.zero(), s * (Math.PI / 180)), c;
+      return c.start.division(r).rotate(g.zero(), s * (Math.PI / 180)), c.end.division(r).rotate(g.zero(), s * (Math.PI / 180)), c;
     }), this.angle = s, this.dispatchEvent({
       type: "updateData"
     });
   }
 }
-class Ee extends W {
+class Ce extends ne {
   static name = "Variable";
   originalLineVisible = !0;
   dxfVisible = !0;
@@ -2173,13 +2362,13 @@ class Ee extends W {
     if (e in this) return this[e];
   }
 }
-class Qe {
+class lt {
   // 所有可查找的点位
   possibleDoorPoints = [];
   doorPoint = [];
   dxf;
   // 包含所有点的虚拟网格
-  pointVirtualGrid = new ce();
+  pointVirtualGrid = new ge();
   // 只包含可查找点的虚拟网格
   findPointVirtualGrid;
   quadtree;
@@ -2192,7 +2381,7 @@ class Qe {
   lineAnalysis;
   continueFind = !0;
   constructor(e) {
-    if (this.lineAnalysis = e, this.dxf = e.Dxf, this.findPointVirtualGrid = new ce(), 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 ge(), 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();
@@ -2222,15 +2411,15 @@ class Qe {
     );
     const a = [];
     return o.forEach((l) => {
-      const c = new B(l?.start, l?.end), h = c.length();
+      const c = new N(l?.start, l?.end), h = c.length();
       if (h < n) return;
-      const f = c.normal(), u = c.direction(), p = (h - r.width * 2) / 2;
+      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 B(
+        const x = c.start.clone().add(u.clone().multiplyScalar(r.width + p * y)), S = new N(
           x,
-          x.clone().add(f.clone().multiplyScalar(1))
+          x.clone().add(d.clone().multiplyScalar(1))
         );
-        if (S.directionMove(f, -0.5), this.quadtree.queryLineSegment(S).length) return;
+        if (S.directionMove(d, -0.5), this.quadtree.queryLineSegment(S).length) return;
       }
       a.push(c);
     }), a;
@@ -2250,7 +2439,7 @@ class Qe {
     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: ae() });
+        this.pointVirtualGrid.queryPoint(n).filter((r) => r.userData !== t).length === 0 && e.push({ line: t, point: n, uuid: me() });
       });
     }), e;
   }
@@ -2262,21 +2451,21 @@ class Qe {
     return t.doors.forEach((s) => {
       const i = t.lineSegments[s[4]], r = t.originalData[s[4]];
       if (r.drawDoorData) {
-        const o = w.from(r.drawDoorData.start), a = w.from(r.drawDoorData.n), l = n.queryPoint(o).filter((c) => {
+        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, f = h.direction();
-          h.start.equal(o) && f.multiplyScalar(-1);
-          const u = a.angleBetween(f, "angle");
+          const h = c.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,
           point: o,
-          uuid: ae()
+          uuid: me()
         });
       } else if (r.doorDirectConnection) {
         this.continueFind = !1;
-        const o = new B(w.from(r.start), w.from(r.end));
+        const o = new N(g.from(r.start), g.from(r.end));
         o.userData = {
           doorDirectConnection: !0,
           isDoor: !0
@@ -2306,83 +2495,83 @@ class Qe {
    */
   searchNearby(e, t = [], n = this.doorSearchDistance, s = this.doorSearchNearAngle) {
     const i = this.findPointVirtualGrid, r = this.quadtree;
-    function o({ point: x, line: S }, b, C) {
-      const m = S.direction();
-      S.start === x && m.multiplyScalar(-1);
-      const E = i.queryCircle(x, n).filter((M) => M.userData !== S).sort((M, g) => M.point.distance(x) - g.point.distance(x)), L = [];
-      for (let M = 0; M < E.length; M++) {
-        const g = t.findIndex((I) => I.point === E[M].point), D = e[b].uuid, T = t[g].uuid;
-        if (C.has(`${D}.${T}`)) continue;
-        C.add(`${D}.${T}`), C.add(`${T}.${D}`);
-        const A = E[M].point, P = new B(x.clone(), A.clone());
-        if (P.direction().angleBetween(m, "angle") < s) {
-          const I = e[g].line.direction();
-          E[M].userData.start.equal(E[M].point) && I.multiplyScalar(-1), P.direction().multiplyScalar(-1).angleBetween(I, "angle") < s && (r.queryLineSegment(P).length || L.push({
-            findData: E[M],
-            findUuid: T,
-            doorLine: P,
-            doorUuid: D
+    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],
+            findUuid: k,
+            doorLine: J,
+            doorUuid: X
           }));
         }
       }
-      return L;
+      return U;
     }
-    function a(x, S, b, C, m) {
-      C.add(x);
-      const E = [];
-      m && E.push(m);
-      for (let L = 0; L < b.length; L++) {
-        const M = b[L];
-        if (S.has(M.findUuid)) {
-          const g = S.get(M.findUuid);
-          a(M.findUuid, S, g, C, M) && E.push(M);
-        } else E.push(M);
+    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);
       }
-      return E.sort((L, M) => L.doorLine.length() - M.doorLine.length()), m && E[0] === m ? (b.splice(0), !0) : (b.splice(1), !1);
+      return R.sort((U, P) => U.doorLine.length() - P.doorLine.length()), E && R[0] === E ? (T.splice(0), !0) : (T.splice(1), !1);
     }
     const l = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map();
     e.map((x, S) => {
-      const b = o(x, S, l);
-      b.length && c.set(x.uuid, b);
+      const T = o(x, S, l);
+      T.length && c.set(x.uuid, T);
     }), l.clear();
     const h = /* @__PURE__ */ new Map();
     c.forEach((x, S) => {
       if (!l.has(S) && x.length && a(S, c, x, l), x.length) {
-        const b = x[0];
-        h.has(b.doorUuid) || h.set(b.doorUuid, []), h.get(b.doorUuid)?.push(b), h.has(b.findUuid) || h.set(b.findUuid, []), h.get(b.findUuid)?.push(b);
+        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);
       }
     });
-    const f = /* @__PURE__ */ new Set();
+    const d = /* @__PURE__ */ new Set();
     h.forEach((x) => {
       if (x.length > 1) {
-        x.sort((S, b) => S.doorLine.length() - b.doorLine.length());
-        for (let S = 1; S < x.length; S++) f.add(x[S]);
+        x.sort((S, T) => S.doorLine.length() - T.doorLine.length());
+        for (let S = 1; S < x.length; S++) d.add(x[S]);
       }
     });
     const u = [], p = [];
     c.forEach((x) => {
       if (x.length) {
         const S = x[0];
-        f.has(S) || (u.push(S), p.push(S.doorUuid, S.findUuid));
+        d.has(S) || (u.push(S), p.push(S.doorUuid, S.findUuid));
       }
     });
     const y = [];
     return u.forEach((x) => {
-      const S = e.findIndex((g) => g.uuid === x.doorUuid), b = t.findIndex((g) => g.uuid === x.findUuid), C = e[S].point.clone(), m = t[b].point.clone(), E = this.findLongLineSegment(e[S].line), L = this.findLongLineSegment(t[b].line), M = E.projectPoint(m);
-      if (M) {
-        C.copy(M);
-        const g = new B(C, m), D = L.includedAngle(g);
-        (D < 10 || D > 170 || Math.abs(90 - D) < 10) && y.push({
-          start: C,
-          end: m
+      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);
+      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
         });
       } else {
-        const g = L.projectPoint(C);
-        g && m.copy(g);
-        const D = new B(C, m), T = E.includedAngle(D);
-        (T < 10 || T > 170 || Math.abs(90 - T) < 10) && y.push({
-          start: C,
-          end: m
+        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
         });
       }
     }), t.splice(
@@ -2403,7 +2592,7 @@ class Qe {
   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 B(e.clone(), r), a = s.queryLineSegment(o).map((l) => ({
+    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));
@@ -2422,22 +2611,22 @@ class Qe {
   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((f) => f.userData !== t);
-    for (let f = 0; f < l.length; f++) {
-      const u = l[f], p = u.userData, y = p.direction();
+    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) {
         o.multiplyScalar(-1);
         break;
       }
     }
-    const c = new B(e.clone(), e.clone().add(o.multiplyScalar(n))), h = i.queryLineSegment(c).map((f) => ({
-      point: f.line.getIntersection(c),
-      line: f.line
-    })).filter((f) => f.point).sort((f, u) => e.distance(f.point) - e.distance(u.point));
+    const c = new N(e.clone(), e.clone().add(o.multiplyScalar(n))), h = i.queryLineSegment(c).map((d) => ({
+      point: d.line.getIntersection(c),
+      line: d.line
+    })).filter((d) => d.point).sort((d, u) => e.distance(d.point) - e.distance(u.point));
     if (h.length) {
-      const f = h[0];
-      if (Math.abs(90 - f.line.direction().angleBetween(o, "angle")) < 5)
-        return f;
+      const d = h[0];
+      if (Math.abs(90 - d.line.direction().angleBetween(o, "angle")) < 5)
+        return d;
     }
   }
   /**
@@ -2464,12 +2653,12 @@ class Qe {
     return t;
   }
 }
-class et extends W {
+class ht extends ne {
   static name = "LineAnalysis";
   Dxf = null;
   Variable = null;
   lineSegmentList = [];
-  container = new G.Group();
+  container = new z.Group();
   // 误差角度
   errorAngle = 4;
   width = 0.4;
@@ -2478,7 +2667,7 @@ class et extends W {
    * @param parent 
    */
   onAddFromParent(e) {
-    this.Dxf = e.findComponentByType(X), this.Variable = this.parent?.findComponentByType(Ee), this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this)), this.Dxf.addEventListener("createGroup", this.doorsAnalysis.bind(this));
+    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));
   }
   /**
    * 
@@ -2492,11 +2681,11 @@ class et extends W {
     return {
       points: [
         // 第一条线
-        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)
+        new g(e.x - o, e.y - a).add(r),
+        new g(t.x - o, t.y - a).add(i)
       ],
       indices: [0, 1, 1, 3, 3, 2, 2, 0],
       rectIndices: [0, 1, 3, 2, 0]
@@ -2510,7 +2699,7 @@ class et extends W {
    */
   addData(e, t) {
     const n = this.Dxf;
-    n.data.push([e.clone(), t.clone(), [], !1, n.data.length]), this.appendLineSegmentList.push(new B(e.clone(), t.clone()));
+    n.data.push([e.clone(), t.clone(), [], !1, n.data.length]), this.appendLineSegmentList.push(new N(e.clone(), t.clone()));
   }
   /** 结果分析创建矩形
    * @param result 
@@ -2518,14 +2707,14 @@ class et extends W {
   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]), f = n.points[0].clone(), u = n.points[1].clone(), p = u.direction(f);
+    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);
     p.multiplyScalar(t.width * 0.5);
-    const y = f.clone().add(p), x = u.clone().add(p.multiplyScalar(-1)), S = f.direction(u), b = y.direction(x);
-    if (!(S.x > 0 && b.x < 0 || S.x < 0 && b.x > 0 || S.y > 0 && b.y < 0 || S.y < 0 && b.y > 0)) {
-      f.set(y.x, y.y), u.set(x.x, x.y);
-      for (let C = 1; C < o; C++) {
-        const m = c.clone().multiplyScalar(a * C), E = h.clone().multiplyScalar(l * C), L = f.clone().add(m), M = u.clone().add(E);
-        this.addData(L, M);
+    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);
       }
     }
   }
@@ -2535,7 +2724,7 @@ class et extends W {
    */
   buildQuadtree() {
     const e = this.Dxf, t = [];
-    this.quadtree = new Y(e.originalBox, 2), e.lineSegments.forEach((n) => {
+    this.quadtree = new Z(e.originalBox, 2), e.lineSegments.forEach((n) => {
       n.userData?.isDoor || (this.quadtree?.insert({
         line: n,
         userData: t.length
@@ -2552,7 +2741,7 @@ class et extends W {
     this.buildQuadtree();
     const e = this.quadtree, t = this.lineSegmentList, n = /* @__PURE__ */ new Set(), s = [];
     t.forEach((i, r) => {
-      const o = t[r], a = te.fromByLineSegment(o, this.width * 2, !1, -0.01);
+      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) => {
         try {
           if (n.has(`${r}-${c}`) || n.has(`${c}-${r}`)) return;
@@ -2596,12 +2785,12 @@ class et extends W {
   doors = [];
   DoorsAnalysis;
   doorsAnalysis() {
-    this.DoorsAnalysis = new Qe(this), this.dispatchEvent({
+    this.DoorsAnalysis = new lt(this), this.dispatchEvent({
       type: "analysisCompleted"
     });
   }
 }
-class tt extends W {
+class ut extends ne {
   static name = "ThreeVJia";
   lineSegments = [];
   onAddFromParent() {
@@ -2613,28 +2802,28 @@ class tt extends W {
     const 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) ?? [], f = 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), f.push(...p.points), s.set(c.target, h), s.set(c.source, f);
-      const y = new B(u.start, p.start), x = new B(u.end, p.end), S = new B(y.center, x.center);
+      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);
     });
     const a = [];
     i = i.filter((c) => {
       if (o.indexOf(c) > -1) return !1;
       if (s.has(c)) {
-        const h = s.get(c), f = c.clone();
+        const h = s.get(c), d = c.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(f.start), x.userData.length = x.distance(f.start), y.userData.type = "start", x.userData.type = "end", f.start.distance(y) > f.start.distance(x) && (h[p] = x, h[p + 1] = y, y.userData.type = "end", x.userData.type = "start");
+            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");
           }
           h.sort((p, y) => p.userData.length - y.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 B(f.start.clone(), y.clone())), f.start.copy(y)), u.push("start")) : (u.pop(), u.length === 0 && f.start.copy(y));
+            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));
           }
-          a.push(f);
+          a.push(d);
         }
         return !1;
       }
@@ -2690,7 +2879,7 @@ class tt extends W {
           };
         if (s.userData.isWindow)
           return s.userData.drawWindow.map((i) => {
-            const r = w.from(i.p), o = r.clone().add(
+            const r = g.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)
@@ -2723,10 +2912,10 @@ class tt extends W {
     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 H("fs", !1)).writeFileSync(e, JSON.stringify(this.toJson()));
+    } else typeof global < "u" && (await se("fs", !1)).writeFileSync(e, JSON.stringify(this.toJson()));
   }
 }
-class nt extends Ke {
+class dt extends ot {
   Dxf;
   AngleCorrectionDxf;
   Variable;
@@ -2737,7 +2926,7 @@ class nt extends Ke {
    * @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 X(this.wallWidth, t), this.AngleCorrectionDxf = new Ze(), this.Variable = new Ee(), this.addComponent(this.Variable), this.addComponent(this.Dxf), this.addComponent(new et()), this.addComponent(this.AngleCorrectionDxf), this.addComponent(new tt());
+    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());
   }
   usePlugin(e) {
     return typeof e == "function" && e.call(this, this), this;
@@ -2750,7 +2939,7 @@ class nt extends Ke {
     });
   }
 }
-const xe = {
+const Ae = {
   POSITION: [
     "byte",
     "byte normalized",
@@ -2778,36 +2967,36 @@ const xe = {
     "unsigned short"
   ]
 };
-class ee {
+class he {
   constructor() {
     this.textureUtils = null, this.pluginCallbacks = [], this.register(function(e) {
-      return new ft(e);
+      return new Et(e);
     }), this.register(function(e) {
-      return new pt(e);
+      return new Dt(e);
     }), this.register(function(e) {
-      return new gt(e);
+      return new It(e);
     }), this.register(function(e) {
-      return new wt(e);
+      return new Rt(e);
     }), this.register(function(e) {
-      return new Mt(e);
+      return new Pt(e);
     }), this.register(function(e) {
-      return new St(e);
+      return new vt(e);
     }), this.register(function(e) {
-      return new xt(e);
+      return new At(e);
     }), this.register(function(e) {
-      return new yt(e);
+      return new Tt(e);
     }), this.register(function(e) {
-      return new mt(e);
+      return new bt(e);
     }), this.register(function(e) {
-      return new Lt(e);
+      return new Nt(e);
     }), this.register(function(e) {
-      return new Et(e);
+      return new Ct(e);
     }), this.register(function(e) {
-      return new Tt(e);
+      return new Bt(e);
     }), this.register(function(e) {
-      return new At(e);
+      return new Ot(e);
     }), this.register(function(e) {
-      return new Dt(e);
+      return new Ft(e);
     });
   }
   register(e) {
@@ -2820,7 +3009,7 @@ class ee {
     return this.textureUtils = e, this;
   }
   parse(e, t, n, s) {
-    const i = new dt(), r = [];
+    const i = new Lt(), 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);
@@ -2832,7 +3021,7 @@ class ee {
     });
   }
 }
-const v = {
+const C = {
   POINTS: 0,
   LINES: 1,
   LINE_LOOP: 2,
@@ -2856,78 +3045,78 @@ const v = {
   CLAMP_TO_EDGE: 33071,
   MIRRORED_REPEAT: 33648,
   REPEAT: 10497
-}, se = "KHR_mesh_quantization", q = {};
-q[_e] = v.NEAREST;
-q[ze] = v.NEAREST_MIPMAP_NEAREST;
-q[qe] = v.NEAREST_MIPMAP_LINEAR;
-q[je] = v.LINEAR;
-q[Ye] = v.LINEAR_MIPMAP_NEAREST;
-q[Ve] = v.LINEAR_MIPMAP_LINEAR;
-q[ke] = v.CLAMP_TO_EDGE;
-q[Xe] = v.REPEAT;
-q[We] = v.MIRRORED_REPEAT;
-const ye = {
+}, 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 = {
   scale: "scale",
   position: "translation",
   quaternion: "rotation",
   morphTargetInfluences: "weights"
-}, st = new Re(), me = 12, it = 1179937895, rt = 2, ge = 8, ot = 1313821514, at = 5130562;
-function K(d, e) {
-  return d.length === e.length && d.every(function(t, n) {
+}, ft = new ze(), be = 12, pt = 1179937895, xt = 2, Ie = 8, yt = 1313821514, mt = 5130562;
+function oe(f, e) {
+  return f.length === e.length && f.every(function(t, n) {
     return t === e[n];
   });
 }
-function ct(d) {
-  return new TextEncoder().encode(d).buffer;
+function gt(f) {
+  return new TextEncoder().encode(f).buffer;
 }
-function lt(d) {
-  return K(d.elements, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+function wt(f) {
+  return oe(f.elements, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 }
-function ht(d, e, t) {
+function Mt(f, e, t) {
   const n = {
-    min: new Array(d.itemSize).fill(Number.POSITIVE_INFINITY),
-    max: new Array(d.itemSize).fill(Number.NEGATIVE_INFINITY)
+    min: new Array(f.itemSize).fill(Number.POSITIVE_INFINITY),
+    max: new Array(f.itemSize).fill(Number.NEGATIVE_INFINITY)
   };
   for (let s = e; s < e + t; s++)
-    for (let i = 0; i < d.itemSize; i++) {
+    for (let i = 0; i < f.itemSize; i++) {
       let r;
-      d.itemSize > 4 ? r = d.array[s * d.itemSize + i] : (i === 0 ? r = d.getX(s) : i === 1 ? r = d.getY(s) : i === 2 ? r = d.getZ(s) : i === 3 && (r = d.getW(s)), d.normalized === !0 && (r = oe.normalize(r, d.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 = ye.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 Te(d) {
-  return Math.ceil(d / 4) * 4;
+function Be(f) {
+  return Math.ceil(f / 4) * 4;
 }
-function ie(d, e = 0) {
-  const t = Te(d.byteLength);
-  if (t !== d.byteLength) {
+function pe(f, e = 0) {
+  const t = Be(f.byteLength);
+  if (t !== f.byteLength) {
     const n = new Uint8Array(t);
-    if (n.set(new Uint8Array(d)), e !== 0)
-      for (let s = d.byteLength; s < t; s++)
+    if (n.set(new Uint8Array(f)), e !== 0)
+      for (let s = f.byteLength; s < t; s++)
         n[s] = e;
     return n.buffer;
   }
-  return d;
+  return f;
 }
-function we() {
+function Re() {
   return typeof document > "u" && typeof OffscreenCanvas < "u" ? new OffscreenCanvas(1, 1) : document.createElement("canvas");
 }
-function ut(d, e) {
-  if (typeof OffscreenCanvas < "u" && d instanceof OffscreenCanvas) {
+function St(f, e) {
+  if (typeof OffscreenCanvas < "u" && f instanceof OffscreenCanvas) {
     let t;
-    return e === "image/jpeg" ? t = 0.92 : e === "image/webp" && (t = 0.8), d.convertToBlob({
+    return e === "image/jpeg" ? t = 0.92 : e === "image/webp" && (t = 0.8), f.convertToBlob({
       type: e,
       quality: t
     });
   } else
-    return new Promise((t) => d.toBlob(t, e));
+    return new Promise((t) => f.toBlob(t, e));
 }
-class dt {
+class Lt {
   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" + Ne
+        generator: "THREE.GLTFExporter r" + qe
       }
     }, this.cache = {
       meshes: /* @__PURE__ */ new Map(),
@@ -2964,27 +3153,27 @@ class dt {
     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 ? re(l).then(function(f) {
-      const u = ie(f), p = new DataView(new ArrayBuffer(ge));
-      p.setUint32(0, u.byteLength, !0), p.setUint32(4, at, !0);
-      const y = ie(ct(JSON.stringify(r)), 32), x = new DataView(new ArrayBuffer(ge));
-      x.setUint32(0, y.byteLength, !0), x.setUint32(4, ot, !0);
-      const S = new ArrayBuffer(me), b = new DataView(S);
-      b.setUint32(0, it, !0), b.setUint32(4, rt, !0);
-      const C = me + x.byteLength + y.byteLength + p.byteLength + u.byteLength;
-      b.setUint32(8, C, !0);
-      const m = new Blob([
+    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,
         y,
         p,
         u
       ], { type: "application/octet-stream" });
-      re(m).then((E) => {
-        t(E);
+      xe(E).then((R) => {
+        t(R);
       });
-    }) : r.buffers && r.buffers.length > 0 ? bt(l).then((f) => {
-      r.buffers[0].uri = f, t(r);
+    }) : r.buffers && r.buffers.length > 0 ? Ut(l).then((d) => {
+      r.buffers[0].uri = d, t(r);
     }) : t(r);
   }
   /**
@@ -3031,7 +3220,7 @@ class dt {
    */
   isNormalizedNormalAttribute(e) {
     if (this.cache.attributesNormalized.has(e)) return !1;
-    const n = new Z();
+    const n = new ce();
     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;
@@ -3046,7 +3235,7 @@ class dt {
   createNormalizedNormalAttribute(e) {
     const t = this.cache;
     if (t.attributesNormalized.has(e)) return t.attributesNormalized.get(e);
-    const n = e.clone(), s = new Z();
+    const n = e.clone(), s = new ce();
     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;
@@ -3066,14 +3255,14 @@ class dt {
   async buildMetalRoughTextureAsync(e, t) {
     if (e === t) return e;
     function n(u) {
-      return u.colorSpace === Ue ? function(y) {
+      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;
       };
     }
-    e instanceof ne && (e = await this.decompressTextureAsync(e)), t instanceof ne && (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 = we();
+    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();
     a.width = r, a.height = o;
     const l = a.getContext("2d", {
       willReadFrequently: !0
@@ -3093,8 +3282,8 @@ class dt {
         c.data[y] = u(p[y] / 256) * 256;
     }
     l.putImageData(c, 0, 0);
-    const f = (e || t).clone();
-    return f.source = new ve(a), f.colorSpace = Ce, f.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."), f;
+    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;
   }
   async decompressTextureAsync(e, t = 1 / 0) {
     if (this.textureUtils === null)
@@ -3124,34 +3313,34 @@ class dt {
     r.bufferViews || (r.bufferViews = []);
     let o;
     switch (t) {
-      case v.BYTE:
-      case v.UNSIGNED_BYTE:
+      case C.BYTE:
+      case C.UNSIGNED_BYTE:
         o = 1;
         break;
-      case v.SHORT:
-      case v.UNSIGNED_SHORT:
+      case C.SHORT:
+      case C.UNSIGNED_SHORT:
         o = 2;
         break;
       default:
         o = 4;
     }
     let a = e.itemSize * o;
-    i === v.ARRAY_BUFFER && (a = Math.ceil(a / 4) * 4);
-    const l = Te(s * a), c = new DataView(new ArrayBuffer(l));
+    i === C.ARRAY_BUFFER && (a = Math.ceil(a / 4) * 4);
+    const l = Be(s * a), c = new DataView(new ArrayBuffer(l));
     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 = oe.normalize(x, e.array))), t === v.FLOAT ? c.setFloat32(h, x, !0) : t === v.INT ? c.setInt32(h, x, !0) : t === v.UNSIGNED_INT ? c.setUint32(h, x, !0) : t === v.SHORT ? c.setInt16(h, x, !0) : t === v.UNSIGNED_SHORT ? c.setUint16(h, x, !0) : t === v.BYTE ? c.setInt8(h, x) : t === v.UNSIGNED_BYTE && c.setUint8(h, x), h += o;
+        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;
       }
       h % a !== 0 && (h += a - h % a);
     }
-    const f = {
+    const d = {
       buffer: this.processBuffer(c.buffer),
       byteOffset: this.byteOffset,
       byteLength: l
     };
-    return i !== void 0 && (f.target = i), i === v.ARRAY_BUFFER && (f.byteStride = a), this.byteOffset += l, r.bufferViews.push(f), {
+    return i !== void 0 && (d.target = i), i === C.ARRAY_BUFFER && (d.byteStride = a), this.byteOffset += l, r.bufferViews.push(d), {
       id: r.bufferViews.length - 1,
       byteLength: 0
     };
@@ -3164,8 +3353,8 @@ class dt {
   processBufferViewImage(e) {
     const t = this, n = t.json;
     return n.bufferViews || (n.bufferViews = []), new Promise(async function(s) {
-      re(e).then((i) => {
-        const r = ie(i), o = {
+      xe(e).then((i) => {
+        const r = pe(i), o = {
           buffer: t.processBuffer(r),
           byteOffset: t.byteOffset,
           byteLength: r.byteLength
@@ -3193,25 +3382,25 @@ class dt {
     };
     let o;
     if (e.array.constructor === Float32Array)
-      o = v.FLOAT;
+      o = C.FLOAT;
     else if (e.array.constructor === Int32Array)
-      o = v.INT;
+      o = C.INT;
     else if (e.array.constructor === Uint32Array)
-      o = v.UNSIGNED_INT;
+      o = C.UNSIGNED_INT;
     else if (e.array.constructor === Int16Array)
-      o = v.SHORT;
+      o = C.SHORT;
     else if (e.array.constructor === Uint16Array)
-      o = v.UNSIGNED_SHORT;
+      o = C.UNSIGNED_SHORT;
     else if (e.array.constructor === Int8Array)
-      o = v.BYTE;
+      o = C.BYTE;
     else if (e.array.constructor === Uint8Array)
-      o = v.UNSIGNED_BYTE;
+      o = C.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 = ht(e, n, s);
+    const a = Mt(e, n, s);
     let l;
-    t !== void 0 && (l = e === t.index ? v.ELEMENT_ARRAY_BUFFER : v.ARRAY_BUFFER);
+    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,
@@ -3238,13 +3427,13 @@ class dt {
       const c = r.images.get(e), h = s + ":flipY/" + n.toString();
       if (c[h] !== void 0) return c[h];
       o.images || (o.images = []);
-      const f = { mimeType: s }, u = we();
+      const d = { mimeType: s }, u = Re();
       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 !== Be && 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);
+        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];
@@ -3254,11 +3443,11 @@ class dt {
       else
         throw new Error("THREE.GLTFExporter: Invalid image type. Use HTMLImageElement, HTMLCanvasElement, ImageBitmap or OffscreenCanvas.");
       a.binary === !0 ? l.push(
-        ut(u, s).then((x) => i.processBufferViewImage(x)).then((x) => {
-          f.bufferView = x;
+        St(u, s).then((x) => i.processBufferViewImage(x)).then((x) => {
+          d.bufferView = x;
         })
-      ) : f.uri = Oe.getDataURL(u, s);
-      const y = o.images.push(f) - 1;
+      ) : d.uri = Xe.getDataURL(u, s);
+      const y = o.images.push(d) - 1;
       return c[h] = y, y;
     } else
       throw new Error("THREE.GLTFExporter: No valid image data found. Unable to process texture.");
@@ -3272,10 +3461,10 @@ class dt {
     const t = this.json;
     t.samplers || (t.samplers = []);
     const n = {
-      magFilter: q[e.magFilter],
-      minFilter: q[e.minFilter],
-      wrapS: q[e.wrapS],
-      wrapT: q[e.wrapT]
+      magFilter: H[e.magFilter],
+      minFilter: H[e.minFilter],
+      wrapS: H[e.wrapS],
+      wrapT: H[e.wrapT]
     };
     return t.samplers.push(n) - 1;
   }
@@ -3287,7 +3476,7 @@ class dt {
   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 ne && (e = await this.decompressTextureAsync(e, n.maxTextureSize));
+    i.textures || (i.textures = []), e instanceof de && (e = await this.decompressTextureAsync(e, n.maxTextureSize));
     let r = e.userData.mimeType;
     r === "image/webp" && (r = "image/png");
     const o = {
@@ -3314,7 +3503,7 @@ class dt {
     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 (K(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 (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) {
       const o = await this.buildMetalRoughTextureAsync(e.metalnessMap, e.roughnessMap), a = {
         index: await this.processTextureAsync(o),
         texCoord: o.channel
@@ -3352,7 +3541,7 @@ class dt {
       };
       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 === Ge && (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 === Ve && (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;
@@ -3366,16 +3555,16 @@ class dt {
   async processMeshAsync(e) {
     const t = this.cache, n = this.json, s = [e.geometry.uuid];
     if (Array.isArray(e.material))
-      for (let m = 0, E = e.material.length; m < E; m++)
-        s.push(e.material[m].uuid);
+      for (let E = 0, R = e.material.length; E < R; E++)
+        s.push(e.material[E].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 = v.LINES : e.isLineLoop ? o = v.LINE_LOOP : e.isLine ? o = v.LINE_STRIP : e.isPoints ? o = v.POINTS : o = e.material.wireframe ? v.LINES : v.TRIANGLES;
-    const a = {}, l = {}, c = [], h = [], f = {
+    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 = {
       uv: "TEXCOORD_0",
       uv1: "TEXCOORD_1",
       uv2: "TEXCOORD_2",
@@ -3386,76 +3575,76 @@ class dt {
     }, 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 m in r.attributes) {
-      if (m.slice(0, 5) === "morph") continue;
-      const E = r.attributes[m];
-      if (m = f[m] || m.toUpperCase(), /^(POSITION|NORMAL|TANGENT|TEXCOORD_\d+|COLOR_\d+|JOINTS_\d+|WEIGHTS_\d+)$/.test(m) || (m = "_" + m), t.attributes.has(this.getUID(E))) {
-        l[m] = t.attributes.get(this.getUID(E));
+    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));
         continue;
       }
       p = null;
-      const M = E.array;
-      m === "JOINTS_0" && !(M instanceof Uint16Array) && !(M instanceof Uint8Array) ? (console.warn('GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.'), p = new k(new Uint16Array(M), E.itemSize, E.normalized)) : (M instanceof Uint32Array || M instanceof Int32Array) && !m.startsWith("_") && (console.warn(`GLTFExporter: Attribute "${m}" converted to type FLOAT.`), p = ee.Utils.toFloat32BufferAttribute(E));
-      const g = this.processAccessor(p || E, r);
-      g !== null && (m.startsWith("_") || this.detectMeshQuantization(m, E), l[m] = g, t.attributes.set(this.getUID(E), g));
+      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));
     }
     if (u !== void 0 && r.setAttribute("normal", u), Object.keys(l).length === 0) return null;
     if (e.morphTargetInfluences !== void 0 && e.morphTargetInfluences.length > 0) {
-      const m = [], E = [], L = {};
+      const E = [], R = [], U = {};
       if (e.morphTargetDictionary !== void 0)
-        for (const M in e.morphTargetDictionary)
-          L[e.morphTargetDictionary[M]] = M;
-      for (let M = 0; M < e.morphTargetInfluences.length; ++M) {
-        const g = {};
-        let D = !1;
-        for (const T in r.morphAttributes) {
-          if (T !== "position" && T !== "normal") {
-            D || (console.warn("GLTFExporter: Only POSITION and NORMAL morph are supported."), D = !0);
+        for (const P in e.morphTargetDictionary)
+          U[e.morphTargetDictionary[P]] = P;
+      for (let P = 0; P < e.morphTargetInfluences.length; ++P) {
+        const O = {};
+        let X = !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);
             continue;
           }
-          const A = r.morphAttributes[T][M], P = T.toUpperCase(), R = r.attributes[T];
-          if (t.attributes.has(this.getUID(A, !0))) {
-            g[P] = t.attributes.get(this.getUID(A, !0));
+          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));
             continue;
           }
-          const I = A.clone();
+          const D = W.clone();
           if (!r.morphTargetsRelative)
-            for (let N = 0, F = A.count; N < F; N++)
-              for (let O = 0; O < A.itemSize; O++)
-                O === 0 && I.setX(N, A.getX(N) - R.getX(N)), O === 1 && I.setY(N, A.getY(N) - R.getY(N)), O === 2 && I.setZ(N, A.getZ(N) - R.getZ(N)), O === 3 && I.setW(N, A.getW(N) - R.getW(N));
-          g[P] = this.processAccessor(I, r), t.attributes.set(this.getUID(R, !0), g[P]);
+            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]);
         }
-        h.push(g), m.push(e.morphTargetInfluences[M]), e.morphTargetDictionary !== void 0 && E.push(L[M]);
+        h.push(O), E.push(e.morphTargetInfluences[P]), e.morphTargetDictionary !== void 0 && R.push(U[P]);
       }
-      a.weights = m, E.length > 0 && (a.extras = {}, a.extras.targetNames = E);
+      a.weights = E, R.length > 0 && (a.extras = {}, a.extras.targetNames = R);
     }
     const y = Array.isArray(e.material);
     if (y && r.groups.length === 0) return null;
     let x = !1;
     if (y && r.index === null) {
-      const m = [];
-      for (let E = 0, L = r.attributes.position.count; E < L; E++)
-        m[E] = E;
-      r.setIndex(m), x = !0;
+      const E = [];
+      for (let R = 0, U = r.attributes.position.count; R < U; R++)
+        E[R] = R;
+      r.setIndex(E), x = !0;
     }
-    const S = y ? e.material : [e.material], b = y ? r.groups : [{ materialIndex: 0, start: void 0, count: void 0 }];
-    for (let m = 0, E = b.length; m < E; m++) {
-      const L = {
+    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 = {
         mode: o,
         attributes: l
       };
-      if (this.serializeUserData(r, L), h.length > 0 && (L.targets = h), r.index !== null) {
-        let g = this.getUID(r.index);
-        (b[m].start !== void 0 || b[m].count !== void 0) && (g += ":" + b[m].start + ":" + b[m].count), t.attributes.has(g) ? L.indices = t.attributes.get(g) : (L.indices = this.processAccessor(r.index, r, b[m].start, b[m].count), t.attributes.set(g, L.indices)), L.indices === null && delete L.indices;
+      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;
       }
-      const M = await this.processMaterialAsync(S[b[m].materialIndex]);
-      M !== null && (L.material = M), c.push(L);
+      const P = await this.processMaterialAsync(S[T[E].materialIndex]);
+      P !== null && (U.material = P), c.push(U);
     }
-    x === !0 && r.setIndex(null), a.primitives = c, n.meshes || (n.meshes = []), await this._invokeAllAsync(function(m) {
-      m.writeMesh && m.writeMesh(e, a);
+    x === !0 && r.setIndex(null), a.primitives = c, n.meshes || (n.meshes = []), await this._invokeAllAsync(function(E) {
+      E.writeMesh && E.writeMesh(e, a);
     });
-    const C = n.meshes.push(a) - 1;
-    return t.meshes.set(i, C), C;
+    const G = n.meshes.push(a) - 1;
+    return t.meshes.set(i, G), G;
   }
   /**
    * If a vertex attribute with a
@@ -3469,7 +3658,7 @@ class dt {
    * @param {THREE.BufferAttribute} attribute
    */
   detectMeshQuantization(e, t) {
-    if (this.extensionsUsed[se]) return;
+    if (this.extensionsUsed[fe]) return;
     let n;
     switch (t.array.constructor) {
       case Int8Array:
@@ -3489,7 +3678,7 @@ class dt {
     }
     t.normalized && (n += " normalized");
     const s = e.split("_", 1)[0];
-    xe[s] && xe[s].includes(n) && (this.extensionsUsed[se] = !0, this.extensionsRequired[se] = !0);
+    Ae[s] && Ae[s].includes(n) && (this.extensionsUsed[fe] = !0, this.extensionsRequired[fe] = !0);
   }
   /**
    * Process camera
@@ -3509,7 +3698,7 @@ class dt {
       znear: e.near < 0 ? 0 : e.near
     } : s.perspective = {
       aspectRatio: e.aspect,
-      yfov: oe.degToRad(e.fov),
+      yfov: ye.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;
@@ -3526,28 +3715,28 @@ class dt {
    */
   processAnimation(e, t) {
     const n = this.json, s = this.nodeMap;
-    n.animations || (n.animations = []), e = ee.Utils.mergeMorphTargetTracks(e.clone(), t);
+    n.animations || (n.animations = []), e = he.Utils.mergeMorphTargetTracks(e.clone(), t);
     const i = e.tracks, r = [], o = [];
     for (let l = 0; l < i.length; ++l) {
-      const c = i[l], h = Q.parseTrackName(c.name);
-      let f = Q.findNode(t, h.nodeName);
-      const u = ye[h.propertyName];
-      if (h.objectName === "bones" && (f.isSkinnedMesh === !0 ? f = f.skeleton.getBoneByName(h.objectIndex) : f = void 0), !f || !u) {
+      const c = i[l], h = le.parseTrackName(c.name);
+      let d = le.findNode(t, h.nodeName);
+      const u = Te[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);
         continue;
       }
       const p = 1;
       let y = c.values.length / c.times.length;
-      u === ye.morphTargetInfluences && (y /= f.morphTargetInfluences.length);
+      u === Te.morphTargetInfluences && (y /= d.morphTargetInfluences.length);
       let x;
-      c.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === !0 ? (x = "CUBICSPLINE", y /= 3) : c.getInterpolation() === Fe ? x = "STEP" : x = "LINEAR", o.push({
-        input: this.processAccessor(new k(c.times, p)),
-        output: this.processAccessor(new k(c.values, y)),
+      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
       }), r.push({
         sampler: o.length - 1,
         target: {
-          node: s.get(f),
+          node: s.get(d),
           path: u
         }
       });
@@ -3568,11 +3757,11 @@ class dt {
     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 Se();
+    const o = [], a = new Float32Array(i.bones.length * 16), l = new ve();
     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);
     return t.skins === void 0 && (t.skins = []), t.skins.push({
-      inverseBindMatrices: this.processAccessor(new k(a, 16)),
+      inverseBindMatrices: this.processAccessor(new te(a, 16)),
       joints: o,
       skeleton: n.get(r)
     }), s.skin = t.skins.length - 1;
@@ -3588,9 +3777,9 @@ class dt {
     const i = {};
     if (n.trs) {
       const o = e.quaternion.toArray(), a = e.position.toArray(), l = e.scale.toArray();
-      K(o, [0, 0, 0, 1]) || (i.rotation = o), K(a, [0, 0, 0]) || (i.translation = a), K(l, [1, 1, 1]) || (i.scale = l);
+      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);
     } else
-      e.matrixAutoUpdate && e.updateMatrix(), lt(e.matrix) === !1 && (i.matrix = e.matrix.elements);
+      e.matrixAutoUpdate && e.updateMatrix(), wt(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);
@@ -3636,7 +3825,7 @@ class dt {
    * @param {Array<THREE.Object3D>} objects List of objects to process
    */
   async processObjectsAsync(e) {
-    const t = new ue();
+    const t = new Se();
     t.name = "AuxScene";
     for (let n = 0; n < e.length; n++)
       t.children.push(e[n]);
@@ -3652,7 +3841,7 @@ class dt {
     });
     const n = [];
     for (let s = 0; s < e.length; s++)
-      e[s] instanceof ue ? await this.processSceneAsync(e[s]) : n.push(e[s]);
+      e[s] instanceof Se ? 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]);
@@ -3667,7 +3856,7 @@ class dt {
       await e(this.plugins[t]);
   }
 }
-class ft {
+class Et {
   constructor(e) {
     this.writer = e, this.name = "KHR_lights_punctual";
   }
@@ -3683,7 +3872,7 @@ class ft {
     o.push(r), t.extensions = t.extensions || {}, t.extensions[this.name] = { light: o.length - 1 };
   }
 }
-class pt {
+class Dt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_unlit";
   }
@@ -3693,7 +3882,7 @@ class pt {
     t.extensions = t.extensions || {}, t.extensions[this.name] = {}, s[this.name] = !0, t.pbrMetallicRoughness.metallicFactor = 0, t.pbrMetallicRoughness.roughnessFactor = 0.9;
   }
 }
-class xt {
+class At {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_clearcoat";
   }
@@ -3724,7 +3913,7 @@ class xt {
     t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class yt {
+class Tt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_dispersion";
   }
@@ -3734,7 +3923,7 @@ class yt {
     i.dispersion = e.dispersion, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class mt {
+class bt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_iridescence";
   }
@@ -3758,7 +3947,7 @@ class mt {
     t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class gt {
+class It {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_transmission";
   }
@@ -3775,7 +3964,7 @@ class gt {
     t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class wt {
+class Rt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_volume";
   }
@@ -3792,7 +3981,7 @@ class wt {
     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 Mt {
+class Pt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_ior";
   }
@@ -3802,12 +3991,12 @@ class Mt {
     i.ior = e.ior, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class St {
+class vt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_specular";
   }
   async writeMaterialAsync(e, t) {
-    if (!e.isMeshPhysicalMaterial || e.specularIntensity === 1 && e.specularColor.equals(st) && !e.specularIntensityMap && !e.specularColorMap) return;
+    if (!e.isMeshPhysicalMaterial || e.specularIntensity === 1 && e.specularColor.equals(ft) && !e.specularIntensityMap && !e.specularColorMap) return;
     const n = this.writer, s = n.extensionsUsed, i = {};
     if (e.specularIntensityMap) {
       const r = {
@@ -3826,7 +4015,7 @@ class St {
     i.specularFactor = e.specularIntensity, i.specularColorFactor = e.specularColor.toArray(), t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Lt {
+class Nt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_sheen";
   }
@@ -3850,7 +4039,7 @@ class Lt {
     i.sheenRoughnessFactor = e.sheenRoughness, i.sheenColorFactor = e.sheenColor.toArray(), t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Et {
+class Ct {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_anisotropy";
   }
@@ -3864,7 +4053,7 @@ class Et {
     i.anisotropyStrength = e.anisotropy, i.anisotropyRotation = e.anisotropyRotation, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Tt {
+class Bt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_emissive_strength";
   }
@@ -3874,7 +4063,7 @@ class Tt {
     i.emissiveStrength = e.emissiveIntensity, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class At {
+class Ot {
   constructor(e) {
     this.writer = e, this.name = "EXT_materials_bump";
   }
@@ -3891,54 +4080,54 @@ class At {
     i.bumpFactor = e.bumpScale, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Dt {
+class Ft {
   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 Se(), l = new Z(), c = new Pe(), h = new Z();
+    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();
     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);
-    const f = {
-      TRANSLATION: n.processAccessor(new k(i, 3)),
-      ROTATION: n.processAccessor(new k(r, 4)),
-      SCALE: n.processAccessor(new k(o, 3))
+    const d = {
+      TRANSLATION: n.processAccessor(new te(i, 3)),
+      ROTATION: n.processAccessor(new te(r, 4)),
+      SCALE: n.processAccessor(new te(o, 3))
     };
-    s.instanceColor && (f._COLOR_0 = n.processAccessor(s.instanceColor)), t.extensions = t.extensions || {}, t.extensions[this.name] = { attributes: f }, n.extensionsUsed[this.name] = !0, n.extensionsRequired[this.name] = !0;
+    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;
   }
 }
-ee.Utils = {
-  insertKeyframe: function(d, e) {
-    const n = d.getValueSize(), s = new d.TimeBufferType(d.times.length + 1), i = new d.ValueBufferType(d.values.length + n), r = d.createInterpolant(new d.ValueBufferType(n));
+he.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;
-    if (d.times.length === 0) {
+    if (f.times.length === 0) {
       s[0] = e;
       for (let a = 0; a < n; a++)
         i[a] = 0;
       o = 0;
-    } else if (e < d.times[0]) {
-      if (Math.abs(d.times[0] - e) < 1e-3) return 0;
-      s[0] = e, s.set(d.times, 1), i.set(r.evaluate(e), 0), i.set(d.values, n), o = 0;
-    } else if (e > d.times[d.times.length - 1]) {
-      if (Math.abs(d.times[d.times.length - 1] - e) < 1e-3)
-        return d.times.length - 1;
-      s[s.length - 1] = e, s.set(d.times, 0), i.set(d.values, 0), i.set(r.evaluate(e), d.values.length), o = s.length - 1;
+    } else if (e < f.times[0]) {
+      if (Math.abs(f.times[0] - e) < 1e-3) return 0;
+      s[0] = e, s.set(f.times, 1), i.set(r.evaluate(e), 0), i.set(f.values, n), o = 0;
+    } else if (e > f.times[f.times.length - 1]) {
+      if (Math.abs(f.times[f.times.length - 1] - e) < 1e-3)
+        return f.times.length - 1;
+      s[s.length - 1] = e, s.set(f.times, 0), i.set(f.values, 0), i.set(r.evaluate(e), f.values.length), o = s.length - 1;
     } else
-      for (let a = 0; a < d.times.length; a++) {
-        if (Math.abs(d.times[a] - e) < 1e-3) return a;
-        if (d.times[a] < e && d.times[a + 1] > e) {
-          s.set(d.times.slice(0, a + 1), 0), s[a + 1] = e, s.set(d.times.slice(a + 1), a + 2), i.set(d.values.slice(0, (a + 1) * n), 0), i.set(r.evaluate(e), (a + 1) * n), i.set(d.values.slice((a + 1) * n), (a + 2) * n), o = a + 1;
+      for (let a = 0; a < f.times.length; a++) {
+        if (Math.abs(f.times[a] - e) < 1e-3) return a;
+        if (f.times[a] < e && f.times[a + 1] > e) {
+          s.set(f.times.slice(0, a + 1), 0), s[a + 1] = e, s.set(f.times.slice(a + 1), a + 2), i.set(f.values.slice(0, (a + 1) * n), 0), i.set(r.evaluate(e), (a + 1) * n), i.set(f.values.slice((a + 1) * n), (a + 2) * n), o = a + 1;
           break;
         }
       }
-    return d.times = s, d.values = i, o;
+    return f.times = s, f.values = i, o;
   },
-  mergeMorphTargetTracks: function(d, e) {
-    const t = [], n = {}, s = d.tracks;
+  mergeMorphTargetTracks: function(f, e) {
+    const t = [], n = {}, s = f.tracks;
     for (let i = 0; i < s.length; ++i) {
       let r = s[i];
-      const o = Q.parseTrackName(r.name), a = Q.findNode(e, o.nodeName);
+      const o = le.parseTrackName(r.name), a = le.findNode(e, o.nodeName);
       if (o.propertyName !== "morphTargetInfluences" || o.propertyIndex === void 0) {
         t.push(r);
         continue;
@@ -3946,7 +4135,7 @@ ee.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(He);
+        console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead."), r = r.clone(), r.setInterpolation(it);
       }
       const l = a.morphTargetInfluences.length, c = a.morphTargetDictionary[o.propertyIndex];
       if (c === void 0)
@@ -3960,77 +4149,77 @@ ee.Utils = {
         h.name = (o.nodeName || "") + ".morphTargetInfluences", h.values = u, n[a.uuid] = h, t.push(h);
         continue;
       }
-      const f = r.createInterpolant(new r.ValueBufferType(1));
+      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] = f.evaluate(h.times[u]);
+        h.values[u * l + c] = 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];
       }
     }
-    return d.tracks = t, d;
+    return f.tracks = t, f;
   },
-  toFloat32BufferAttribute: function(d) {
-    const e = new k(new Float32Array(d.count * d.itemSize), d.itemSize, !1);
-    if (!d.normalized && !d.isInterleavedBufferAttribute)
-      return e.array.set(d.array), e;
-    for (let t = 0, n = d.count; t < n; t++)
-      for (let s = 0; s < d.itemSize; s++)
-        e.setComponent(t, s, d.getComponent(t, s));
+  toFloat32BufferAttribute: function(f) {
+    const e = new te(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++)
+      for (let s = 0; s < f.itemSize; s++)
+        e.setComponent(t, s, f.getComponent(t, s));
     return e;
   }
 };
-async function bt(d) {
+async function Ut(f) {
   if (typeof FileReader > "u") {
-    const e = await d.arrayBuffer(), n = Buffer.from(e).toString("base64");
-    return `data:${d.type};base64,${n}`;
+    const e = await f.arrayBuffer(), n = Buffer.from(e).toString("base64");
+    return `data:${f.type};base64,${n}`;
   } else
     return new Promise((e, t) => {
       const n = new FileReader();
-      n.onload = () => e(n.result), n.onerror = () => t(new Error("Failed to read Blob as Data URL")), n.readAsDataURL(d);
+      n.onload = () => e(n.result), n.onerror = () => t(new Error("Failed to read Blob as Data URL")), n.readAsDataURL(f);
     });
 }
-async function re(d) {
-  if (typeof d.arrayBuffer == "function")
-    return await d.arrayBuffer();
+async function xe(f) {
+  if (typeof f.arrayBuffer == "function")
+    return await f.arrayBuffer();
   if (typeof FileReader < "u")
     return new Promise((e, t) => {
       const n = new FileReader();
-      n.onload = () => e(n.result), n.onerror = () => t(n.error), n.readAsArrayBuffer(d);
+      n.onload = () => e(n.result), n.onerror = () => t(n.error), n.readAsArrayBuffer(f);
     });
   {
-    const e = Buffer.from(await d.text());
+    const e = Buffer.from(await f.text());
     return e.buffer.slice(e.byteOffset, e.byteOffset + e.byteLength);
   }
 }
-const It = new Je(), Rt = new ee();
-function Pt(d, e, t = 0.1) {
-  const n = e.normal(d), s = e.direction(d).mutiplyScalar(t * 0.5), i = d.direction(e).mutiplyScalar(t * 0.5), r = n.x * t * 0.5, o = n.y * t * 0.5;
+const Gt = new rt(), zt = new he();
+function _t(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 w(d.x + r, d.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(d.x - r, d.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)
     ],
     indices: [0, 1, 1, 3, 3, 2, 2, 0],
     rectIndices: [0, 1, 3, 2, 0]
   };
 }
-class Ae extends W {
+class Oe extends ne {
   static name = "WhiteModel";
   Dxf = null;
   Variable = null;
   // dxf数据白模
-  whiteModelGroup = new G.Group();
+  whiteModelGroup = new z.Group();
   // dxf数据白模边缘线
-  whiteModelLineGroup = new G.Group();
+  whiteModelLineGroup = new z.Group();
   // 原始数据白模
-  originalWhiteMode = new G.Group();
-  material = new G.MeshStandardMaterial({ color: 16777215, transparent: !0, opacity: 0.8, side: G.DoubleSide });
+  originalWhiteMode = new z.Group();
+  material = new z.MeshStandardMaterial({ color: 16777215, transparent: !0, opacity: 0.8, side: z.DoubleSide });
   onAddFromParent(e) {
     this.Dxf = e.findComponentByName("Dxf"), this.Variable = e.findComponentByName("Variable"), this.originalWhiteMode.visible = !1, this.Dxf?.addEventListener("lineOffset", () => {
       this.updateModel();
@@ -4040,17 +4229,17 @@ class Ae extends W {
     this.Variable?.set("whiteModelVisible", !1);
     const e = this.Dxf;
     this.originalWhiteMode.clear(), this.whiteModelGroup.clear(), this.whiteModelLineGroup.clear(), this.whiteModelGroup.add(this.whiteModelLineGroup), this.whiteModelGroup.position.z = e.originalZAverage, this.originalWhiteMode.position.z = e.originalZAverage, e.wallsGroup.forEach((n) => {
-      const s = new G.Shape();
+      const s = new z.Shape();
       n.forEach((o, a) => a === 0 ? s.moveTo(o.x / e.scale, o.y / e.scale) : s.lineTo(o.x / e.scale, o.y / e.scale));
-      const i = new G.ExtrudeGeometry(s, {
+      const i = new z.ExtrudeGeometry(s, {
         depth: 2.8,
         bevelSize: 0
-      }), r = new G.Mesh(i, this.material);
+      }), r = new z.Mesh(i, this.material);
       this.whiteModelGroup.add(r), this.whiteModelLineGroup.add(
-        new G.LineSegments(new G.EdgesGeometry(i), new G.LineBasicMaterial({ color: 0 }))
+        new z.LineSegments(new z.EdgesGeometry(i), new z.LineBasicMaterial({ color: 0 }))
       );
     }), e.originalData.map(({ start: n, end: s, insetionArr: i }) => {
-      const r = new w(n.x, n.y).mutiplyScalar(e.scale), o = new w(s.x, s.y).mutiplyScalar(e.scale), { points: a, indices: l, rectIndices: c } = Pt(r, o, e.width);
+      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);
       return {
         points: a,
         indices: l,
@@ -4058,17 +4247,17 @@ class Ae extends W {
         insetions: (i ?? []).map((h) => h.index)
       };
     }).forEach((n) => {
-      const s = new G.Shape();
+      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 i = new G.ExtrudeGeometry(s, {
+      const i = new z.ExtrudeGeometry(s, {
         depth: 2.8,
         bevelSize: 0
       });
       if (i.attributes.position.array.filter((o) => Number.isNaN(o)).length) return;
-      const r = new G.Mesh(i);
+      const r = new z.Mesh(i);
       this.originalWhiteMode?.add(r);
     }), this.dispatchEvent({
       type: "updateModel",
@@ -4083,7 +4272,7 @@ class Ae extends W {
   toOBJ() {
     return new Promise((e) => {
       this.material.opacity = 1, this.material.needsUpdate = !0, setTimeout(() => {
-        e(It.parse(this.whiteModelGroup)), this.material.opacity = 0.8, this.material.transparent = !0;
+        e(Gt.parse(this.whiteModelGroup)), this.material.opacity = 0.8, this.material.transparent = !0;
       }, 20);
     });
   }
@@ -4095,7 +4284,7 @@ class Ae extends W {
   toGltf(e = !0) {
     return new Promise((t) => {
       this.material.opacity = 1, this.material.needsUpdate = !0, setTimeout(async () => {
-        Rt.parse(this.whiteModelGroup.children, (n) => {
+        zt.parse(this.whiteModelGroup.children, (n) => {
           t(n), this.material.opacity = 0.8, this.material.transparent = !0;
         }, () => {
           t(void 0);
@@ -4136,7 +4325,7 @@ class Ae extends W {
       n.href = URL.createObjectURL(t), n.download = e, n.click();
     } else if (typeof global < "u") {
       const t = await this.toOBJ();
-      t && (await H("fs", !1)).writeFileSync(e, t);
+      t && (await se("fs", !1)).writeFileSync(e, t);
     }
   }
   /**
@@ -4152,11 +4341,11 @@ class Ae extends W {
       s.href = URL.createObjectURL(n), s.download = e, s.click();
     } else if (typeof global < "u") {
       const n = await this.toGltf(t);
-      n && (await H("fs", !1)).writeFileSync(e, t ? Buffer.from(n) : JSON.stringify(n));
+      n && (await se("fs", !1)).writeFileSync(e, t ? Buffer.from(n) : JSON.stringify(n));
     }
   }
 }
-class De extends W {
+class Fe extends ne {
   static name = "DetailsPoint";
   Dxf = null;
   WhiteModel = null;
@@ -4207,17 +4396,17 @@ class De extends W {
       this._timer = null;
       const e = this.parent?.findComponentByName("WhiteModel");
       this.raylines.length = 0, this.desPoints.length = 0, this.data.forEach((t) => {
-        const n = new G.Vector3(
+        const n = new z.Vector3(
           t.position.x,
           t.position.y,
           t.position.z
-        ), s = new G.Vector3(
+        ), s = new z.Vector3(
           t.direction.x,
           t.direction.y,
           t.direction.z
         ), i = 100;
         this.racasterHelper(n, s, i), s.z = 0;
-        const o = new G.Raycaster(n, s, 0, i).intersectObject(e.originalWhiteMode);
+        const o = new z.Raycaster(n, s, 0, i).intersectObject(e.originalWhiteMode);
         if (o.length) {
           const { point: a } = o[0];
           this.desPoints.push({
@@ -4233,61 +4422,61 @@ class De extends W {
     }, 50);
   }
 }
-class be extends W {
+class Ue extends ne {
   static name = "DxfLineModel";
-  dxfLineModel = new G.LineSegments();
-  dxfDoorsLineModel = new G.LineSegments();
-  dxfModelGroup = new G.Group();
+  dxfLineModel = new z.LineSegments();
+  dxfDoorsLineModel = new z.LineSegments();
+  dxfModelGroup = new z.Group();
   onAddFromParent(e) {
     const t = e.findComponentByName("Dxf");
-    this.dxfModelGroup.add(this.dxfLineModel), this.dxfModelGroup.add(this.dxfDoorsLineModel), this.dxfDoorsLineModel.material = new G.LineBasicMaterial({ color: 16776960, vertexColors: !0 }), t?.addEventListener("lineOffset", () => this.updateMode());
+    this.dxfModelGroup.add(this.dxfLineModel), this.dxfModelGroup.add(this.dxfDoorsLineModel), this.dxfDoorsLineModel.material = new z.LineBasicMaterial({ color: 16776960, vertexColors: !0 }), t?.addEventListener("lineOffset", () => this.updateMode());
   }
   updateMode() {
     const e = this.parent?.findComponentByName("Dxf");
     this.dxfLineModel.clear();
     const t = e.to3DArray(1 / e.scale, 0);
-    this.dxfLineModel.geometry = new G.BufferGeometry().setAttribute("position", new G.BufferAttribute(t, 3, !0));
+    this.dxfLineModel.geometry = new z.BufferGeometry().setAttribute("position", new z.BufferAttribute(t, 3, !0));
     const n = new Float32Array(
       e.doorLineSegment.flatMap(({ start: i, end: r }) => [i.x, i.y, 0, r.x, r.y, 0])
     ).map((i) => i / e.scale), s = new Float32Array(e.doorLineSegment.flatMap(() => [1, 0, 0, 0, 1, 0]));
-    this.dxfDoorsLineModel.geometry = new G.BufferGeometry().setAttribute("position", new G.BufferAttribute(n, 3, !0)).setAttribute("color", new G.BufferAttribute(s, 3)), this.dxfModelGroup.position.z = e.originalZAverage, this.dispatchEvent({
+    this.dxfDoorsLineModel.geometry = new z.BufferGeometry().setAttribute("position", new z.BufferAttribute(n, 3, !0)).setAttribute("color", new z.BufferAttribute(s, 3)), this.dxfModelGroup.position.z = e.originalZAverage, this.dispatchEvent({
       type: "modelUpdate",
       model: this.dxfModelGroup
     });
   }
 }
-const Nt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const qt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  DetailsPoint: De,
-  DxfLineModel: be,
-  WhiteModel: Ae
+  DetailsPoint: Fe,
+  DxfLineModel: Ue,
+  WhiteModel: Oe
 }, Symbol.toStringTag, { value: "Module" }));
-function Me(d, e = {}) {
+function Pe(f, e = {}) {
   const {
     detailsPoint: t = !0,
     whiteModel: n = !0,
     dxfLineModel: s = !0
   } = e;
-  s && d.addComponent(new be()), n && d.addComponent(new Ae()), t && d.addComponent(new De());
+  s && f.addComponent(new Ue()), n && f.addComponent(new Oe()), t && f.addComponent(new Fe());
 }
-const vt = Object.assign(Me, {
-  create(d = {}) {
-    return (e) => Me(e, d);
+const jt = Object.assign(Pe, {
+  create(f = {}) {
+    return (e) => Pe(e, f);
   }
-}), Ct = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}), Yt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  ModelDataPlugin: vt,
-  components: Nt
+  ModelDataPlugin: jt,
+  components: qt
 }, Symbol.toStringTag, { value: "Module" }));
-function Bt() {
+function kt() {
   return import("./index2.js");
 }
-function Ot() {
+function Xt() {
   return import("./index3.js");
 }
-let he = null;
-async function qt(d, e, t = !1, n) {
-  const s = await Promise.resolve().then(() => Ct), i = await Bt(), r = await Ot(), o = new nt().usePlugin(s.ModelDataPlugin.create({
+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({
     detailsPoint: !1,
     whiteModel: !0
   })).usePlugin(i.RenderPlugin.create({
@@ -4297,13 +4486,13 @@ async function qt(d, e, t = !1, n) {
     orbitControls: t,
     camera: e
   })).usePlugin(r.Editor.create({ viewPermission: n })), a = o.findComponentByType(i.components.DomContainer);
-  return a && d.appendChild(a.domElement), he = o, {
+  return a && f.appendChild(a.domElement), Me = o, {
     dxfSystem: o,
-    getFileAll: () => Gt(o)
+    getFileAll: () => Vt(o)
   };
 }
-async function Gt(d = he) {
-  const e = d.findComponentByName("WhiteModel"), t = new File([await d.AngleCorrectionDxf.toDxfImageBlob()], "img.jpg", { type: "image/jpeg" }), n = new File([d.Dxf.toDxfBlob()], "dxf.dxf", { type: "application/dxf" }), s = new File([d.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(d.Dxf.originalData)], "json.json", { type: "application/json" });
+async function Vt(f = Me) {
+  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,
     obj: i,
@@ -4314,27 +4503,27 @@ async function Gt(d = he) {
     correctionDxf: s
   };
 }
-function jt() {
-  return he;
+function Zt() {
+  return Me;
 }
 export {
-  _ as B,
-  W as C,
-  nt as D,
-  Le as E,
-  B as L,
-  vt as M,
-  w as P,
-  Y as Q,
-  tt as T,
-  Ee as V,
-  Ae as W,
-  De as a,
-  ce as b,
-  X as c,
-  qt as d,
-  jt as e,
-  Gt as g,
-  Nt as i,
-  ae as u
+  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
 };