build-dxf 0.0.32 → 0.0.33

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() {
+import * as U from "three";
+import { EventDispatcher as Pe, Color as ve, Matrix4 as Ae, Vector3 as ee, Quaternion as Ne, BufferAttribute as H, REVISION as Ce, CompressedTexture as ie, Source as Be, NoColorSpace as Oe, MathUtils as ce, RGBAFormat as Fe, ImageUtils as Ue, DoubleSide as Ge, PropertyBinding as te, InterpolateDiscrete as _e, Scene as fe, SRGBColorSpace as ze, NearestFilter as qe, NearestMipmapNearestFilter as je, NearestMipmapLinearFilter as Ye, LinearFilter as Xe, LinearMipmapNearestFilter as ke, LinearMipmapLinearFilter as Ve, ClampToEdgeWrapping as We, RepeatWrapping as He, MirroredRepeatWrapping as Je, InterpolateLinear as Ke } from "three";
+import pe from "clipper-lib";
+import Q from "dxf-writer";
+import { OBJExporter as $e } from "three/examples/jsm/exporters/OBJExporter.js";
+function le() {
   return "xxxx-xxxx-4xxx-yxxx-xxxx".replace(/[xy]/g, function(d) {
     var e = Math.random() * 16 | 0, t = d == "x" ? e : e & 3 | 8;
     return t.toString(16);
   });
 }
-class Le extends Ie {
-  uuid = ae();
+class Ee extends Pe {
+  uuid = le();
   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 J extends Ee {
   parent;
   destroyed = !1;
   constructor(...e) {
@@ -48,7 +48,7 @@ class W extends Le {
     this.destroyed = !0;
   }
 }
-class Ke extends Le {
+class Ze extends Ee {
   static EventType = {
     ADD_COMPONENT: "addComponent"
   };
@@ -71,7 +71,7 @@ class Ke extends Le {
    * @param component 
    */
   removeComponent(e) {
-    if (e instanceof W) {
+    if (e instanceof J) {
       const t = this.components.indexOf(e);
       t > -1 && (this.components.splice(t, 1), this.dispatchEvent({
         type: "removeComponent",
@@ -116,214 +116,6 @@ 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 _ {
   minX = 0;
   maxX = 0;
@@ -411,8 +203,8 @@ class _ {
     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))
+        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), R = (p.x - u.x) * (h.y - u.y) - (p.y - u.y) * (h.x - u.x);
+        if (y * x < 0 && S * R < 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) || R === 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;
       }
     }
@@ -544,146 +336,25 @@ class _ {
     );
   }
 }
-class ce {
-  map = /* @__PURE__ */ new Map();
-  gridSize;
-  constructor(e = 2) {
-    this.gridSize = e;
+class se {
+  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) => {
@@ -799,32 +470,554 @@ class te {
     return t === 4 || n === 4;
   }
   /**
-   * 
+   * 
+   * @returns 
+   */
+  toBox() {
+    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);
+  }
+  /**
+   * 
+   * @param line 
+   * @param width 
+   * @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 se([
+      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)
+    ]);
+  }
+}
+class B {
+  points = [new w(), new w()];
+  userData = {};
+  // line: any
+  get center() {
+    return new w(
+      this.points[0].x + (this.points[1].x - this.points[0].x) * 0.5,
+      this.points[0].y + (this.points[1].y - this.points[0].y) * 0.5
+    );
+  }
+  get start() {
+    return this.points[0];
+  }
+  get end() {
+    return this.points[1];
+  }
+  constructor(e = new w(), t = new w()) {
+    this.points = [e, t];
+  }
+  set(e, t) {
+    return this.start.copy(e), this.end.copy(t), this;
+  }
+  /**
+   * 是否有相同端点
+   * @param line 
+   * @returns 
+   */
+  sameEndpoint(e) {
+    return this.start.equal(e.start) || this.start.equal(e.end) || this.end.equal(e.start) || this.end.equal(e.end);
+  }
+  /**
+   * 相同端点是否为开始
+   * @param line 
+   * @returns 
+   */
+  sameEndpointAsStart(e) {
+    return this.start.equal(e.start) || this.start.equal(e.end);
+  }
+  /**
+   * 获取共线点
+   * @param line 
+   * @returns 
+   */
+  getSameEndpoint(e) {
+    return this.start.equal(e.start) ? [this.start, e.start] : this.start.equal(e.end) ? [this.start, e.end] : this.end.equal(e.start) ? [this.end, e.start] : this.end.equal(e.end) ? [this.end, e.end] : null;
+  }
+  /**
+   * 判断一个点是否在当前线段上（包含端点）
+   * @param point 要判断的点
+   * @returns 如果点在当前线段上则返回 true，否则返回 false
+   */
+  isPointOnSegment(e) {
+    const { start: t, end: n } = this, s = (e.y - t.y) * (n.x - t.x) - (e.x - t.x) * (n.y - t.y);
+    return Math.abs(s) > 1e-10 ? !1 : (e.x - t.x) * (e.x - n.x) + (e.y - t.y) * (e.y - n.y) <= 1e-10;
+  }
+  /**
+   * 相同端点是否为结束
+   * @param line 
+   * @returns 
+   */
+  sameEndpointAsEnd(e) {
+    return this.end.equal(e.start) || this.end.equal(e.end);
+  }
+  /** 膨胀
+   * @description 向线段的两个端点分别膨胀 width
+   * @param width 
+   */
+  expansion(e, t = "all") {
+    const n = this.direction().multiplyScalar(e);
+    return (t === "end" || t === "all") && this.end.add(n), (t === "start" || t === "all") && this.start.add(n.multiplyScalar(-1)), this;
+  }
+  /** 向前
+   * @description 向前移动 width
+   * @param width 
+   */
+  forward(e) {
+    const t = this.direction().multiplyScalar(e);
+    return this.start.add(t), this.end.add(t), this;
+  }
+  /** 向前
+   * @description 向前移动 width
+   * @param width 
+   */
+  backward(e) {
+    const t = this.direction().multiplyScalar(-e);
+    return this.start.add(t), this.end.add(t), this;
+  }
+  /**
+   * 向指定方向平移
+   * @param direct 
+   * @param size 
+   */
+  directionMove(e, t) {
+    const n = e.clone().multiplyScalar(t);
+    return this.start.add(n), this.end.add(n), this;
+  }
+  /** 膨胀为矩形
+   * 
+   * @param width 
+   * @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 = [
+      // 第一条线
+      new w(n.x + a, n.y + l).add(o),
+      new w(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)
+    ];
+    return new se([0, 1, 3, 2].map((h) => c[h]));
+  }
+  /**
+   * 计算线段的长度
+   * @returns 线段的长度
+   */
+  getLength() {
+    return this.points[0].distance(this.points[1]);
+  }
+  /**
+   * 获取方向
+   * @returns 
+   */
+  direction() {
+    return this.points[1].direction(this.points[0]);
+  }
+  /**
+   * 获取发向量
+   */
+  normal() {
+    return this.points[1].normal(this.points[0]);
+  }
+  /**
+   * 线段长度
+   * @returns 
+   */
+  length() {
+    return this.points[1].distance(this.points[0]);
+  }
+  /**
+   * 计算一条线段在另一条直线上的投影，并裁剪超出目标线段的部分
+   * @param line 要投影的线段
+   * @returns 投影并裁剪后的线段
+   */
+  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);
+    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, R = (y.x * r.x + y.y * r.y) / x, F = s.x + R * r.x, A = s.y + R * r.y;
+      return new w(F, A);
+    };
+    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;
+      return (y.x * r.x + y.y * r.y) / x;
+    };
+    let h = c(a), f = 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 (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);
+  }
+  /**
+   * 计算一条线段在另一条直线上的投影
+   * @param p1 要投影的点
+   * @param clip 是否裁剪超出目标线段的部分，默认裁剪
+   * @returns 投影并裁剪后的线段
+   */
+  projectPoint(e, t = !0) {
+    const [n, s] = this.points, i = new w(s.x - n.x, s.y - n.y);
+    if (i.x === 0 && i.y === 0)
+      throw new Error("投影目标线段的两个点不能重合");
+    let o = ((c) => {
+      const h = new 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);
+    })(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;
+    })(o);
+    return l < 0 || l > 1 ? null : o;
+  }
+  /**
+   * 判断线段是否与另一条线段相交（包含共用端点或部分重合的情况）
+   * @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), 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)));
+  }
+  /**
+   * 判断一个点是否在线段上（含端点）
+   * @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 w(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 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;
+  }
+  clone() {
+    const e = new B(
+      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 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);
+  }
+  /** 展开为线
+   * @param direction 
+   * @param length 
+   */
+  expandAsLine(e, t) {
+    return new B(
+      this.clone(),
+      this.clone().add(e.clone().multiplyScalar(t))
+    );
+  }
+  /**
+   * 计算模长
+   * @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 
    */
-  toBox() {
-    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);
+  clone() {
+    return new w(this.x, this.y);
   }
   /**
-   * 
-   * @param line 
-   * @param width 
+   * 克隆
    * @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)
-    ]);
+  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);
+  }
+}
+async function K(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;
   }
 }
-class Y {
+class X {
   bounds;
   // 包围盒
   capacity;
@@ -890,22 +1083,22 @@ class Y {
     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(
+    this.children[0] = new X(
       new _(this.bounds.minX, e, this.bounds.minY, t),
       this.capacity,
       this.maxDepth,
       this.depth + 1
-    ), this.children[1] = new Y(
+    ), this.children[1] = new X(
       new _(e, this.bounds.maxX, this.bounds.minY, t),
       this.capacity,
       this.maxDepth,
       this.depth + 1
-    ), this.children[2] = new Y(
+    ), this.children[2] = new X(
       new _(this.bounds.minX, e, t, this.bounds.maxY),
       this.capacity,
       this.maxDepth,
       this.depth + 1
-    ), this.children[3] = new Y(
+    ), this.children[3] = new X(
       new _(e, this.bounds.maxX, t, this.bounds.maxY),
       this.capacity,
       this.maxDepth,
@@ -955,6 +1148,22 @@ class Y {
         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 矩形
@@ -985,326 +1194,151 @@ class Y {
     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()];
-  userData = {};
-  // line: any
-  get center() {
-    return new w(
-      this.points[0].x + (this.points[1].x - this.points[0].x) * 0.5,
-      this.points[0].y + (this.points[1].y - this.points[0].y) * 0.5
-    );
-  }
-  get start() {
-    return this.points[0];
-  }
-  get end() {
-    return this.points[1];
-  }
-  constructor(e = new w(), t = new w()) {
-    this.points = [e, t];
-  }
-  set(e, t) {
-    return this.start.copy(e), this.end.copy(t), this;
-  }
-  /**
-   * 是否有相同端点
-   * @param line 
-   * @returns 
-   */
-  sameEndpoint(e) {
-    return this.start.equal(e.start) || this.start.equal(e.end) || this.end.equal(e.start) || this.end.equal(e.end);
-  }
-  /**
-   * 相同端点是否为开始
-   * @param line 
-   * @returns 
-   */
-  sameEndpointAsStart(e) {
-    return this.start.equal(e.start) || this.start.equal(e.end);
-  }
-  /**
-   * 获取共线点
-   * @param line 
-   * @returns 
-   */
-  getSameEndpoint(e) {
-    return this.start.equal(e.start) ? [this.start, e.start] : this.start.equal(e.end) ? [this.start, e.end] : this.end.equal(e.start) ? [this.end, e.start] : this.end.equal(e.end) ? [this.end, e.end] : null;
-  }
-  /**
-   * 判断一个点是否在当前线段上（包含端点）
-   * @param point 要判断的点
-   * @returns 如果点在当前线段上则返回 true，否则返回 false
-   */
-  isPointOnSegment(e) {
-    const { start: t, end: n } = this, s = (e.y - t.y) * (n.x - t.x) - (e.x - t.x) * (n.y - t.y);
-    return Math.abs(s) > 1e-10 ? !1 : (e.x - t.x) * (e.x - n.x) + (e.y - t.y) * (e.y - n.y) <= 1e-10;
-  }
-  /**
-   * 相同端点是否为结束
-   * @param line 
-   * @returns 
-   */
-  sameEndpointAsEnd(e) {
-    return this.end.equal(e.start) || this.end.equal(e.end);
-  }
-  /** 膨胀
-   * @description 向线段的两个端点分别膨胀 width
-   * @param width 
-   */
-  expansion(e, t = "all") {
-    const n = this.direction().multiplyScalar(e);
-    return (t === "end" || t === "all") && this.end.add(n), (t === "start" || t === "all") && this.start.add(n.multiplyScalar(-1)), this;
-  }
-  /** 向前
-   * @description 向前移动 width
-   * @param width 
-   */
-  forward(e) {
-    const t = this.direction().multiplyScalar(e);
-    return this.start.add(t), this.end.add(t), this;
-  }
-  /** 向前
-   * @description 向前移动 width
-   * @param width 
-   */
-  backward(e) {
-    const t = this.direction().multiplyScalar(-e);
-    return this.start.add(t), this.end.add(t), this;
-  }
-  /**
-   * 向指定方向平移
-   * @param direct 
-   * @param size 
-   */
-  directionMove(e, t) {
-    const n = e.clone().multiplyScalar(t);
-    return this.start.add(n), this.end.add(n), this;
-  }
-  /** 膨胀为矩形
-   * 
-   * @param width 
-   * @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 = [
-      // 第一条线
-      new w(n.x + a, n.y + l).add(o),
-      new w(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)
-    ];
-    return new te([0, 1, 3, 2].map((h) => c[h]));
-  }
-  /**
-   * 计算线段的长度
-   * @returns 线段的长度
-   */
-  getLength() {
-    return this.points[0].distance(this.points[1]);
-  }
-  /**
-   * 获取方向
-   * @returns 
-   */
-  direction() {
-    return this.points[1].direction(this.points[0]);
-  }
-  /**
-   * 获取发向量
-   */
-  normal() {
-    return this.points[1].normal(this.points[0]);
-  }
-  /**
-   * 线段长度
-   * @returns 
-   */
-  length() {
-    return this.points[1].distance(this.points[0]);
-  }
-  /**
-   * 计算一条线段在另一条直线上的投影，并裁剪超出目标线段的部分
-   * @param line 要投影的线段
-   * @returns 投影并裁剪后的线段
-   */
-  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);
-    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);
-    };
-    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;
-      return (y.x * r.x + y.y * r.y) / x;
-    };
-    let h = c(a), f = 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 (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);
-  }
-  /**
-   * 计算一条线段在另一条直线上的投影
-   * @param p1 要投影的点
-   * @param clip 是否裁剪超出目标线段的部分，默认裁剪
-   * @returns 投影并裁剪后的线段
-   */
-  projectPoint(e, t = !0) {
-    const [n, s] = this.points, i = new w(s.x - n.x, s.y - n.y);
-    if (i.x === 0 && i.y === 0)
-      throw new Error("投影目标线段的两个点不能重合");
-    let o = ((c) => {
-      const h = new 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);
-    })(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;
-    })(o);
-    return l < 0 || l > 1 ? null : o;
+    return n;
   }
   /**
-   * 判断线段是否与另一条线段相交（包含共用端点或部分重合的情况）
-   * @param line 
-   * @param endpoint 是否包含端点相交
+   * 包围盒转换为数组
+   * @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 he {
+  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 w(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 _(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 Qe = {
   Unitless: 1,
   // 无单位，1米 = 1（无单位）
   Inches: 39.37007874015748,
@@ -1348,7 +1382,7 @@ const $e = {
   Parsecs: 3240779289666404e-32
   // 秒差距，1米 ≈ 0.00000000000000003240779289666404秒差距
 };
-function fe(d) {
+function xe(d) {
   const e = [];
   for (let t = 0; t < d.length; t++)
     e.push(new B(
@@ -1357,10 +1391,10 @@ function fe(d) {
     ));
   return e;
 }
-function pe(d) {
+function ye(d) {
   return d.flatMap((e, t) => (t === d.length - 1 && [...e.points, d[0].points[0]], [e.points[0]]));
 }
-class X extends W {
+class V extends J {
   static name = "Dxf";
   shortLine = 0.04;
   width = 0.04;
@@ -1407,19 +1441,21 @@ class X extends W {
   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)
+    const i = [];
+    e.forEach(({ start: o, end: a, ...l }, c) => {
+      i.push(o.z ?? 0, a.z ?? 0);
+      const h = new B(
+        w.from(o),
+        w.from(a)
       );
-      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)
+      h.userData = l, n.push(h), l.isVerticalReferenceLine && (s = c);
+    }), this.originalZAverage = i.reduce((o, a) => o + a, 0) / i.length, s === -1 && (s = B.maxLengthLineIndex(n, (o) => !o.userData.insetionArr?.length));
+    const r = n[s];
+    if (r.userData.isVerticalReferenceLine = !0, e[s].isVerticalReferenceLine = !0, t) {
+      let o = V.axisAlignmentCorrection.call(this, n, r);
+      return {
+        lineSegments: o,
+        data: this.lineDataToOriginalData(o)
       };
     }
     return {
@@ -1568,7 +1604,7 @@ class X extends W {
         break;
       }
     }
-    const t = this.mergeSameDirectionLine(fe(e)), n = [t[0]];
+    const t = this.mergeSameDirectionLine(xe(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 +1619,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 ? ye(this.mergeSameDirectionLine(n)) : [];
   }
   /**
    * 移除短线段
@@ -1591,7 +1627,7 @@ class X extends W {
    * @param path 
    */
   removeShortLine(e, t = this.shortLine) {
-    const n = fe(e), s = [], i = Math.PI / 180;
+    const n = xe(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) {
@@ -1619,20 +1655,20 @@ class X extends W {
       } else
         r = l;
     }
-    return s.length > 3 ? pe(s) : [];
+    return s.length > 3 ? ye(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 = V.EndType.etOpenSquare, t = V.JoinType.jtMiter, n = 1e4) {
+    let s = new pe.Paths();
+    const i = new pe.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;
+      return o = this.lineSegmentStraightening(o), e == V.EndType.etOpenSquare && (o = this.squareRemoveBurr(o)), o;
     }), this.dispatchEvent({
       type: "lineOffset",
       wallsGroup: this.wallsGroup
@@ -1667,7 +1703,7 @@ 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) => {
+    return t || (t = new X(_.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),
@@ -1691,7 +1727,7 @@ class X extends W {
    * 转为绘制数据
    */
   toDrawDataJson(e = "Millimeters") {
-    const t = $e[e], n = {
+    const t = Qe[e], n = {
       unit: e,
       line: [],
       arc: [],
@@ -1740,24 +1776,24 @@ class X extends W {
           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)) {
+        for (let A = 0; A < a.length; A++)
+          if (a[A].intersectRectangle(u)) {
             f = new B(
               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);
+        f.expansion(-o * 0.5).expandToRectangle(this.width * 0.2, "bothSides").path2D((A, P) => i(A, P));
+        const p = c.length(), y = f.length(), x = (p ** 2 + y ** 2) / (2 * y), S = f.end.clone().add(f.direction().multiplyScalar(-x)), [R, F] = this.getArcAngleRange(S, c.end, f.end);
+        r(S, x, Math.min(R, F), Math.max(R, F)), 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));
     }), 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));
+        i(x.start, x.end), x.expandToRectangle(this.width, "bothSides").path2D((S, R) => i(S, R));
       });
     }), n;
   }
@@ -1771,7 +1807,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 K("canvas");
       i = l();
     } else
       throw new Error("创建画布失败");
@@ -1800,8 +1836,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 Q();
+    t.setUnits(e), t.addLayer("cyan", Q.ACI.CYAN, "DOTTED"), t.addLayer("yellow", Q.ACI.YELLOW, "DOTTED"), t.addLayer("white", Q.ACI.WHITE, "DOTTED");
     const n = this.toDrawDataJson();
     return n.line.forEach((s) => {
       let [i, r, o, a, l] = s;
@@ -1827,7 +1863,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 K("fs", !1)).writeFileSync(e, t);
   }
   /**
    * 下载
@@ -1837,7 +1873,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 K("fs", !1)).writeFileSync(e, this.toDxfString(t));
   }
   /**
    * 下载
@@ -1849,7 +1885,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 K("fs", !1)).writeFileSync(e, s) : console.error("图片下载失败");
     return !0;
   }
   /**
@@ -1891,217 +1927,291 @@ class X extends W {
    * @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)));
-      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;
+    function n(M, L) {
+      const g = [];
+      for (let b = 0; b < M.length; b++) {
+        const m = M[b], E = /* @__PURE__ */ new Map();
+        m.userData.isDoor || m.points.forEach((T) => {
+          if (L.queryPoint(T).length > 1) return;
+          const I = L.queryCircle(T, 0.4).filter((D) => {
+            const v = D.userData;
+            if (v === m || !m.parallel(v, 25)) return !1;
+            if (L.queryPoint(D.point).length > 1) return;
+            const O = new B(T, D.point), q = new B(m.start === T ? m.end : m.start, v.start === D.point ? v.end : v.start);
+            if (!O.intersectLineSegment(q)) return !1;
+            const G = T.distance(D.point);
+            return G < 1e-3 ? !1 : (E.set(D.point, G), !0);
+          }).sort((D, v) => {
+            const O = E.get(D.point), q = E.get(v.point);
+            return O - q;
           });
-          if (A.length === 0) return;
-          const P = A[0].userData;
-          L.push(new B(g.projectLineSegment(P).center, P.projectLineSegment(g).center));
+          if (I.length === 0) return;
+          const N = I[0].userData;
+          g.push(new B(m.projectLineSegment(N).center, N.projectLineSegment(m).center));
         });
       }
-      return [...m, ...L];
+      return [...M, ...g];
     }
-    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 s(M) {
+      const L = new he(), g = new X(_.fromByLineSegment(...M)), b = [];
+      return M.forEach((m) => {
+        m.userData.isDoor ? b.push(m) : (m.points.forEach((E) => L.insert(E, m)), g.insert({ line: m, userData: void 0 }));
+      }), b.forEach((m) => {
+        const E = L.queryPoint(m.start), T = L.queryPoint(m.end);
+        E.length ? m.userData.startIntersection = E[0].userData : m.userData.startIntersection = g.queryPoint(m.start)[0]?.line, T.length ? m.userData.endIntersection = T[0].userData : m.userData.endIntersection = g.queryPoint(m.end)[0]?.line;
+      }), M = n(M, L), M;
+    }
+    function i(M, L) {
+      const g = [M], b = [], m = [], E = [];
+      for (let T = 0; T < L.length; T++) {
+        const I = L[T];
+        if (M !== I)
+          if (I.userData.isWindow && E.push(I), I.parallel(M, 45)) {
+            const N = Math.atan2(I.end.y - I.start.y, I.end.x - I.start.x);
+            let v = Math.atan2(M.end.y - M.start.y, M.end.x - M.start.x) - N;
+            for (; v > Math.PI; ) v -= 2 * Math.PI;
+            for (; v < -Math.PI; ) v += 2 * Math.PI;
+            const O = I.center;
+            I.start.rotate(O, v), I.end.rotate(O, v), I.userData.isDoor ? m.push(I) : g.push(I);
           } 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 N = Math.atan2(I.end.y - I.start.y, I.end.x - I.start.x), D = Math.atan2(M.end.y - M.start.y, M.end.x - M.start.x);
+            let v = D + Math.PI / 2 - N, O = D - Math.PI / 2 - N;
+            for (; v > Math.PI; ) v -= 2 * Math.PI;
+            for (; v < -Math.PI; ) v += 2 * Math.PI;
+            for (; O > Math.PI; ) O -= 2 * Math.PI;
+            for (; O < -Math.PI; ) O += 2 * Math.PI;
+            const q = Math.abs(v) < Math.abs(O) ? v : O, G = I.center;
+            I.start.rotate(G, q), I.end.rotate(G, q), I.userData.isDoor ? m.push(I) : b.push(I);
           }
-        }
       }
-      return { parallelLines: L, verticalLines: M, doorLines: g, windowLines: D };
+      return { parallelLines: g, verticalLines: b, doorLines: m, windowLines: E };
     }
-    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 r(M, L, g, b = 0.3, m = 0.1) {
+      const E = [];
+      M.forEach((N) => {
+        const D = g.projectPoint(N.start, !1);
+        D && (D.userData = N, E.push(D));
+      }), E.sort((N, D) => D.distance(g.start) - N.distance(g.start));
+      const T = [], I = [];
+      for (let N = 0; N < E.length; N++) {
+        const D = E[N];
+        if (N === 0) {
+          I.push(D);
           continue;
         }
-        D[P - 1].distance(R) < g || (T.push([...A]), A.length = 0), A.push(R), P === D.length - 1 && T.push(A);
+        E[N - 1].distance(D) < m || (T.push([...I]), I.length = 0), I.push(D), N === E.length - 1 && T.push(I);
       }
-      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 T.flatMap((N) => {
+        const D = N.flatMap((G) => {
+          const j = G.userData;
+          return j.points.map((k) => {
+            const z = L.projectPoint(k, !1);
+            return z.userData = j, z;
           });
         });
-        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;
+        D.sort((G, j) => G.distance(L.start) - j.distance(L.start));
+        const v = /* @__PURE__ */ new Map(), O = [], q = [];
+        return D.forEach((G, j) => {
+          v.size === 0 && j > 0 && D[j - 1].distance(G) > b && (O.push([...q]), q.length = 0), v.set(G.userData, (v.get(G.userData) ?? 0) + 1);
+          for (const k of v.values()) if (k !== 2) return;
+          q.push(...v.keys()), v.clear();
+        }), O.push([...q]), O;
       });
     }
-    function r(m, E = 0.1) {
-      return m.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());
+    function o(M, L = 0.1) {
+      return M.map((g) => {
+        if (g.length === 0) return;
+        if (g.length === 1) return g[0];
+        const b = [];
+        g.forEach((z) => {
+          b.push(z.start.clone(), z.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 = g[0].direction().normalize();
+        let E = 1 / 0, T = -1 / 0, I = 0, N = 0;
+        b.forEach((z) => {
+          const $ = z.x * m.x + z.y * m.y;
+          E = Math.min(E, $), T = Math.max(T, $), I += z.x, N += z.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 D = new w(I / b.length, N / b.length), v = D.x * m.x + D.y * m.y, O = new w(D.x + (E - v) * m.x, D.y + (E - v) * m.y), q = new w(D.x + (T - v) * m.x, D.y + (T - v) * m.y), G = new B(O, q), j = g[0].normal().normalize();
+        E = 1 / 0, T = -1 / 0, b.forEach((z) => {
+          const $ = z.x * j.x + z.y * j.y;
+          E = Math.min(E, $), T = Math.max(T, $);
         });
-        const j = T - D;
-        return j >= E && (O.userData.wallWidth = j), L.forEach((U) => U.userData.fittedLine = O), O;
-      }).filter((L) => !!L);
+        const k = T - E;
+        return k >= L && (G.userData.wallWidth = k), g.forEach((z) => z.userData.fittedLine = G), G;
+      }).filter((g) => !!g);
     }
-    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 a(M, L = 0.2) {
+      const g = new X(_.fromByLineSegment(...M)), b = /* @__PURE__ */ new Map();
+      M.forEach((E) => {
+        b.set(E, { line: E, userData: void 0 }), g.insert(b.get(E));
       });
-      const g = new B();
-      for (let D = 0; D < m.length; D++) {
-        const T = m[D];
+      const m = new B();
+      for (let E = 0; E < M.length; E++) {
+        const T = M[E];
         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 I = T.direction().multiplyScalar(L), [N, D] = T.points.map((v) => {
+          m.set(v, v), m.start.add(I), m.end.add(I.multiplyScalar(-1));
+          const O = /* @__PURE__ */ new Map(), q = g.queryRect(m.expandToRectangle(0.1, "bothSides")).filter((G) => G.line !== T).map((G) => {
+            const j = G.line.getIntersection(m);
+            return O.set(G.line, j), G.line;
+          }).sort((G, j) => {
+            const k = O.get(G), z = O.get(j);
+            return k && z ? k.distance(v) - z.distance(v) : 0;
           });
-          return F.length ? N.get(F[0]) : void 0;
+          return q.length ? O.get(q[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 (N && D) {
+          if (N.equal(D)) {
+            const v = T.start.distance(N), O = T.end.distance(D);
+            v < O ? T.directionMove(T.start.direction(T.end), v) : T.directionMove(T.end.direction(T.start), O);
           } else
-            T.start.copy(P), T.end.copy(R);
+            T.start.copy(N), T.end.copy(D);
           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));
+        } else N ? T.start.copy(N) : D && T.end.copy(D);
+        g.remove(b.get(T)), g.insert(b.get(T));
       }
-      return m.filter((D) => D.length() > 1e-3);
+      return M.filter((E) => E.length() > 1e-3);
     }
-    function a(m) {
-      for (let E = 0; E < m.length; E++) {
-        const L = m[E], 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;
-            M.userData.drawWindow?.push({
-              p: new G.Vector3(I?.x ?? 0, I?.y ?? 0, D.p.z),
-              width: R.length(),
-              full: D.full
+    function l(M) {
+      for (let L = 0; L < M.length; L++) {
+        const g = M[L], b = g.userData.fittedLine;
+        if (b) {
+          const m = g.direction();
+          b.userData.isWindow = !0, b.userData.drawWindow = b.userData.drawWindow ?? [], g.userData.drawWindow?.forEach((E) => {
+            const T = w.from(E.p), I = b.projectPoint(
+              T.clone().add(m.clone().multiplyScalar(E.width * 0.5))
+            ), N = b.projectPoint(
+              T.clone().add(m.clone().multiplyScalar(E.width * -0.5))
+            ), D = new B(I, N), v = D.center;
+            b.userData.drawWindow?.push({
+              p: new U.Vector3(v?.x ?? 0, v?.y ?? 0, E.p.z),
+              width: D.length(),
+              full: E.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);
-        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;
+    function c(M) {
+      for (let L = 0; L < M.length; L++) {
+        const g = M[L];
+        let { endIntersection: b, startIntersection: m } = g.userData;
+        if (!(!b || !m)) {
+          if (m.userData.fittedLine && (m = m.userData.fittedLine), b.userData.fittedLine && (b = b.userData.fittedLine), g.isParallel(m))
+            g.start.distance(m.start) < g.start.distance(m.end) ? g.start.copy(m.start) : g.start.copy(m.end);
+          else {
+            const E = m.projectPoint(g.start);
+            E && g.start.copy(E);
+          }
+          if (g.isParallel(b))
+            g.end.distance(b.start) < g.end.distance(b.end) ? g.end.copy(b.start) : g.end.copy(b.end);
+          else {
+            const E = b.projectPoint(g.end);
+            E && g.end.copy(E);
+          }
+        }
+      }
+      return M;
+    }
+    function h(M) {
+      const L = new X(_.fromByLineSegment(...M));
+      return M.forEach((g) => L.insert({ line: g, userData: void 0 })), M.flatMap((g) => {
+        const b = L.queryLineSegment(g, !0).map((m) => {
+          if (m.line === g) return;
+          const E = m.line.getIntersection(g);
+          if (!(!E || g.start.equal(E) || g.end.equal(E)))
+            return E;
+        }).filter((m) => !!m);
+        if (b.length) {
+          const m = g.clone();
+          b.sort((T, I) => m.start.distance(T) - m.start.distance(I));
+          const E = b.map((T) => {
+            const I = m.clone();
+            return I.set(m.start.clone(), T), m.start.copy(T), m.userData.isWindow && (I.userData.isWindow = !0, I.userData.drawWindow = m.userData.drawWindow?.filter((N) => I.isPointOnSegment(w.from(N.p))) ?? []), I;
           });
-          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((T) => m.isPointOnSegment(w.from(T.p))) ?? [], [...E, m];
         }
-        return L;
-      }).filter((L) => L.length() > 0.05);
+        return g;
+      }).filter((g) => g.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 = s(e.map((M) => M.clone()));
+    const { parallelLines: f, verticalLines: u, doorLines: p, windowLines: y } = i(t, e), x = t.normal(), S = t.center, R = t.direction(), F = new B(
+      S.clone().add(x.clone().multiplyScalar(-1e3)),
+      S.clone().add(x.clone().multiplyScalar(1e3))
+    ), A = new B(
+      S.clone().add(R.clone().multiplyScalar(-1e3)),
+      S.clone().add(R.clone().multiplyScalar(1e3))
     );
-    let C = r([
-      ...i.call(this, c, b, S),
-      ...i.call(this, h, S, b)
+    let P = o([
+      ...r.call(this, f, A, F),
+      ...r.call(this, u, F, A)
     ]);
-    return C = o.call(this, C), C = o.call(this, C), a(u), C = l.call(this, C), [...C, ...f];
+    return P = a.call(this, P), P = a.call(this, P), l(y), c(p), P = h.call(this, P), P.push(...p), P;
+  }
+  /** 
+   * @param lines 
+   * @param trajectoryPositions 
+   * @returns 
+   */
+  static excessLineSegments(e, t) {
+    const n = new X(_.fromByLineSegment(...e));
+    return e.forEach((s) => n.insert({ line: s, userData: void 0 })), e = e.filter((s) => {
+      const i = s.center;
+      for (const r of t) {
+        const o = new B(i, r);
+        if (!n.queryLineSegment(o).filter((l) => l.line !== s).length) return !1;
+      }
+      return !0;
+    }), e.filter((s) => {
+      const i = n.queryLineSegment(s).filter((r) => r.line !== s);
+      for (let r = 0; r < i.length; r++) {
+        const o = i[r];
+        if (e.indexOf(o.line) === -1) return !1;
+      }
+      return !0;
+    });
+  }
+  /** 边线外扩
+   * @param lines 
+   * @param trajectory 
+   */
+  static boundaryExtension(e, t) {
+    const s = this.parent?.findComponentByName("Renderer"), i = V.excessLineSegments(e, t);
+    e = e.filter((o) => i.indexOf(o) === -1);
+    const r = new X(_.fromByLineSegment(...e));
+    e.forEach((o) => o.userData.isDoor || r.insert({ line: o, userData: void 0 }));
+    for (let o = 0; o < e.length; o++) {
+      if (e[o].userData.isDoor) continue;
+      const a = e[o], l = a.direction(), c = a.normal(), h = a.center, f = 20;
+      if ([
+        h.expandAsLine(c, f),
+        h.expandAsLine(c, -f),
+        a.start.expandAsLine(l, -f),
+        a.start.expandAsLine(c, f),
+        a.start.expandAsLine(c, -f),
+        a.end.expandAsLine(l, f),
+        a.end.expandAsLine(c, f),
+        a.end.expandAsLine(c, -f)
+      ].filter((y) => (y.directionMove(y.direction(), 1e-3), r.queryLineSegment(y, !1).filter((x) => x.line !== a).length === 0)).length) {
+        const y = s.createLineSegments([a], 0, { color: 16711680 });
+        y.position.z = 1e-3;
+      }
+    }
+    return e;
   }
 }
-function le(d) {
+function ue(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);
+  if (Array.isArray(d)) return d.map(ue);
   const e = {};
   for (const t in d)
-    Object.prototype.hasOwnProperty.call(d, t) && (e[t] = le(d[t]));
+    Object.prototype.hasOwnProperty.call(d, t) && (e[t] = ue(d[t]));
   return e;
 }
-const V = new B();
-class Ze extends X {
+const W = new B();
+class et extends V {
   static name = "AngleCorrectionDxf";
   angle = 0;
   onAddFromParent(e) {
@@ -2112,12 +2222,12 @@ 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];
+      if (W.start.copy(c.start), W.end.copy(c.end), c.isVerticalReferenceLine) {
+        const [h, f] = c.start.y < c.end.y ? [W.start, W.end] : [W.end, W.start];
         s = -new B(h, f).direction().angleBetween(new w(0, 1), "angle", "360"), i = null;
         break;
       }
-      (!i || V.length() > i.length()) && (i = V.clone(), i.userData.index = l);
+      (!i || W.length() > i.length()) && (i = W.clone(), i.userData.index = l);
     }
     if (i) {
       t.originalData[i.userData.index].isVerticalReferenceLine = !0;
@@ -2125,7 +2235,7 @@ class Ze extends X {
       s = -new B(l, c).direction().angleBetween(new w(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 });
+      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(ue(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;
@@ -2146,7 +2256,7 @@ class Ze extends X {
     });
   }
 }
-class Ee extends W {
+class Te extends J {
   static name = "Variable";
   originalLineVisible = !0;
   dxfVisible = !0;
@@ -2173,13 +2283,13 @@ class Ee extends W {
     if (e in this) return this[e];
   }
 }
-class Qe {
+class tt {
   // 所有可查找的点位
   possibleDoorPoints = [];
   doorPoint = [];
   dxf;
   // 包含所有点的虚拟网格
-  pointVirtualGrid = new ce();
+  pointVirtualGrid = new he();
   // 只包含可查找点的虚拟网格
   findPointVirtualGrid;
   quadtree;
@@ -2192,7 +2302,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 he(), 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();
@@ -2250,7 +2360,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: le() });
       });
     }), e;
   }
@@ -2272,7 +2382,7 @@ class Qe {
         l.length && e.push({
           line: l[0].userData,
           point: o,
-          uuid: ae()
+          uuid: le()
         });
       } else if (r.doorDirectConnection) {
         this.continueFind = !1;
@@ -2306,56 +2416,56 @@ 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 }, R, F) {
+      const A = S.direction();
+      S.start === x && A.multiplyScalar(-1);
+      const P = i.queryCircle(x, n).filter((L) => L.userData !== S).sort((L, g) => L.point.distance(x) - g.point.distance(x)), M = [];
+      for (let L = 0; L < P.length; L++) {
+        const g = t.findIndex((N) => N.point === P[L].point), b = e[R].uuid, m = t[g].uuid;
+        if (F.has(`${b}.${m}`)) continue;
+        F.add(`${b}.${m}`), F.add(`${m}.${b}`);
+        const E = P[L].point, T = new B(x.clone(), E.clone());
+        if (T.direction().angleBetween(A, "angle") < s) {
+          const N = e[g].line.direction();
+          P[L].userData.start.equal(P[L].point) && N.multiplyScalar(-1), T.direction().multiplyScalar(-1).angleBetween(N, "angle") < s && (r.queryLineSegment(T).length || M.push({
+            findData: P[L],
+            findUuid: m,
+            doorLine: T,
+            doorUuid: b
           }));
         }
       }
-      return L;
+      return M;
     }
-    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, R, F, A) {
+      F.add(x);
+      const P = [];
+      A && P.push(A);
+      for (let M = 0; M < R.length; M++) {
+        const L = R[M];
+        if (S.has(L.findUuid)) {
+          const g = S.get(L.findUuid);
+          a(L.findUuid, S, g, F, L) && P.push(L);
+        } else P.push(L);
       }
-      return E.sort((L, M) => L.doorLine.length() - M.doorLine.length()), m && E[0] === m ? (b.splice(0), !0) : (b.splice(1), !1);
+      return P.sort((M, L) => M.doorLine.length() - L.doorLine.length()), A && P[0] === A ? (R.splice(0), !0) : (R.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 R = o(x, S, l);
+      R.length && c.set(x.uuid, R);
     }), 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 R = x[0];
+        h.has(R.doorUuid) || h.set(R.doorUuid, []), h.get(R.doorUuid)?.push(R), h.has(R.findUuid) || h.set(R.findUuid, []), h.get(R.findUuid)?.push(R);
       }
     });
     const f = /* @__PURE__ */ new Set();
     h.forEach((x) => {
       if (x.length > 1) {
-        x.sort((S, b) => S.doorLine.length() - b.doorLine.length());
+        x.sort((S, R) => S.doorLine.length() - R.doorLine.length());
         for (let S = 1; S < x.length; S++) f.add(x[S]);
       }
     });
@@ -2368,21 +2478,21 @@ class Qe {
     });
     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((g) => g.uuid === x.doorUuid), R = t.findIndex((g) => g.uuid === x.findUuid), F = e[S].point.clone(), A = t[R].point.clone(), P = this.findLongLineSegment(e[S].line), M = this.findLongLineSegment(t[R].line), L = P.projectPoint(A);
+      if (L) {
+        F.copy(L);
+        const g = new B(F, A), b = M.includedAngle(g);
+        (b < 10 || b > 170 || Math.abs(90 - b) < 10) && y.push({
+          start: F,
+          end: A
         });
       } 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 g = M.projectPoint(F);
+        g && A.copy(g);
+        const b = new B(F, A), m = P.includedAngle(b);
+        (m < 10 || m > 170 || Math.abs(90 - m) < 10) && y.push({
+          start: F,
+          end: A
         });
       }
     }), t.splice(
@@ -2464,12 +2574,12 @@ class Qe {
     return t;
   }
 }
-class et extends W {
+class nt extends J {
   static name = "LineAnalysis";
   Dxf = null;
   Variable = null;
   lineSegmentList = [];
-  container = new G.Group();
+  container = new U.Group();
   // 误差角度
   errorAngle = 4;
   width = 0.4;
@@ -2478,7 +2588,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(V), this.Variable = this.parent?.findComponentByType(Te), this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this)), this.Dxf.addEventListener("createGroup", this.doorsAnalysis.bind(this));
   }
   /**
    * 
@@ -2520,12 +2630,12 @@ class et extends W {
     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);
     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)) {
+    const y = f.clone().add(p), x = u.clone().add(p.multiplyScalar(-1)), S = f.direction(u), R = y.direction(x);
+    if (!(S.x > 0 && R.x < 0 || S.x < 0 && R.x > 0 || S.y > 0 && R.y < 0 || S.y < 0 && R.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);
+      for (let F = 1; F < o; F++) {
+        const A = c.clone().multiplyScalar(a * F), P = h.clone().multiplyScalar(l * F), M = f.clone().add(A), L = u.clone().add(P);
+        this.addData(M, L);
       }
     }
   }
@@ -2535,7 +2645,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 X(e.originalBox, 2), e.lineSegments.forEach((n) => {
       n.userData?.isDoor || (this.quadtree?.insert({
         line: n,
         userData: t.length
@@ -2552,7 +2662,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 = se.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 +2706,12 @@ class et extends W {
   doors = [];
   DoorsAnalysis;
   doorsAnalysis() {
-    this.DoorsAnalysis = new Qe(this), this.dispatchEvent({
+    this.DoorsAnalysis = new tt(this), this.dispatchEvent({
       type: "analysisCompleted"
     });
   }
 }
-class tt extends W {
+class st extends J {
   static name = "ThreeVJia";
   lineSegments = [];
   onAddFromParent() {
@@ -2723,10 +2833,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 K("fs", !1)).writeFileSync(e, JSON.stringify(this.toJson()));
   }
 }
-class nt extends Ke {
+class it extends Ze {
   Dxf;
   AngleCorrectionDxf;
   Variable;
@@ -2737,7 +2847,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 V(this.wallWidth, t), this.AngleCorrectionDxf = new et(), this.Variable = new Te(), this.addComponent(this.Variable), this.addComponent(this.Dxf), this.addComponent(new nt()), this.addComponent(this.AngleCorrectionDxf), this.addComponent(new st());
   }
   usePlugin(e) {
     return typeof e == "function" && e.call(this, this), this;
@@ -2750,7 +2860,7 @@ class nt extends Ke {
     });
   }
 }
-const xe = {
+const me = {
   POSITION: [
     "byte",
     "byte normalized",
@@ -2778,36 +2888,36 @@ const xe = {
     "unsigned short"
   ]
 };
-class ee {
+class ne {
   constructor() {
     this.textureUtils = null, this.pluginCallbacks = [], this.register(function(e) {
-      return new ft(e);
-    }), this.register(function(e) {
-      return new pt(e);
-    }), this.register(function(e) {
-      return new gt(e);
+      return new xt(e);
     }), this.register(function(e) {
-      return new wt(e);
+      return new yt(e);
     }), this.register(function(e) {
       return new Mt(e);
     }), this.register(function(e) {
-      return new St(e);
+      return new Lt(e);
     }), this.register(function(e) {
-      return new xt(e);
+      return new St(e);
     }), this.register(function(e) {
-      return new yt(e);
+      return new At(e);
     }), this.register(function(e) {
       return new mt(e);
     }), this.register(function(e) {
-      return new Lt(e);
+      return new gt(e);
+    }), this.register(function(e) {
+      return new wt(e);
     }), this.register(function(e) {
       return new Et(e);
     }), this.register(function(e) {
       return new Tt(e);
-    }), this.register(function(e) {
-      return new At(e);
     }), this.register(function(e) {
       return new Dt(e);
+    }), this.register(function(e) {
+      return new bt(e);
+    }), this.register(function(e) {
+      return new It(e);
     });
   }
   register(e) {
@@ -2820,7 +2930,7 @@ class ee {
     return this.textureUtils = e, this;
   }
   parse(e, t, n, s) {
-    const i = new dt(), r = [];
+    const i = new pt(), 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 +2942,7 @@ class ee {
     });
   }
 }
-const v = {
+const C = {
   POINTS: 0,
   LINES: 1,
   LINE_LOOP: 2,
@@ -2856,34 +2966,34 @@ 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 = {
+}, re = "KHR_mesh_quantization", Y = {};
+Y[qe] = C.NEAREST;
+Y[je] = C.NEAREST_MIPMAP_NEAREST;
+Y[Ye] = C.NEAREST_MIPMAP_LINEAR;
+Y[Xe] = C.LINEAR;
+Y[ke] = C.LINEAR_MIPMAP_NEAREST;
+Y[Ve] = C.LINEAR_MIPMAP_LINEAR;
+Y[We] = C.CLAMP_TO_EDGE;
+Y[He] = C.REPEAT;
+Y[Je] = C.MIRRORED_REPEAT;
+const ge = {
   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) {
+}, rt = new ve(), we = 12, ot = 1179937895, at = 2, Me = 8, ct = 1313821514, lt = 5130562;
+function Z(d, e) {
   return d.length === e.length && d.every(function(t, n) {
     return t === e[n];
   });
 }
-function ct(d) {
+function ht(d) {
   return new TextEncoder().encode(d).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 ut(d) {
+  return Z(d.elements, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 }
-function ht(d, e, t) {
+function dt(d, e, t) {
   const n = {
     min: new Array(d.itemSize).fill(Number.POSITIVE_INFINITY),
     max: new Array(d.itemSize).fill(Number.NEGATIVE_INFINITY)
@@ -2891,15 +3001,15 @@ function ht(d, e, t) {
   for (let s = e; s < e + t; s++)
     for (let i = 0; i < d.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);
+      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 = ce.normalize(r, d.array))), n.min[i] = Math.min(n.min[i], r), n.max[i] = Math.max(n.max[i], r);
     }
   return n;
 }
-function Te(d) {
+function De(d) {
   return Math.ceil(d / 4) * 4;
 }
-function ie(d, e = 0) {
-  const t = Te(d.byteLength);
+function oe(d, e = 0) {
+  const t = De(d.byteLength);
   if (t !== d.byteLength) {
     const n = new Uint8Array(t);
     if (n.set(new Uint8Array(d)), e !== 0)
@@ -2909,10 +3019,10 @@ function ie(d, e = 0) {
   }
   return d;
 }
-function we() {
+function Le() {
   return typeof document > "u" && typeof OffscreenCanvas < "u" ? new OffscreenCanvas(1, 1) : document.createElement("canvas");
 }
-function ut(d, e) {
+function ft(d, e) {
   if (typeof OffscreenCanvas < "u" && d instanceof OffscreenCanvas) {
     let t;
     return e === "image/jpeg" ? t = 0.92 : e === "image/webp" && (t = 0.8), d.convertToBlob({
@@ -2922,12 +3032,12 @@ function ut(d, e) {
   } else
     return new Promise((t) => d.toBlob(t, e));
 }
-class dt {
+class pt {
   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" + Ce
       }
     }, this.cache = {
       meshes: /* @__PURE__ */ new Map(),
@@ -2964,26 +3074,26 @@ 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 ? ae(l).then(function(f) {
+      const u = oe(f), p = new DataView(new ArrayBuffer(Me));
+      p.setUint32(0, u.byteLength, !0), p.setUint32(4, lt, !0);
+      const y = oe(ht(JSON.stringify(r)), 32), x = new DataView(new ArrayBuffer(Me));
+      x.setUint32(0, y.byteLength, !0), x.setUint32(4, ct, !0);
+      const S = new ArrayBuffer(we), R = new DataView(S);
+      R.setUint32(0, ot, !0), R.setUint32(4, at, !0);
+      const F = we + x.byteLength + y.byteLength + p.byteLength + u.byteLength;
+      R.setUint32(8, F, !0);
+      const A = new Blob([
         S,
         x,
         y,
         p,
         u
       ], { type: "application/octet-stream" });
-      re(m).then((E) => {
-        t(E);
+      ae(A).then((P) => {
+        t(P);
       });
-    }) : r.buffers && r.buffers.length > 0 ? bt(l).then((f) => {
+    }) : r.buffers && r.buffers.length > 0 ? Rt(l).then((f) => {
       r.buffers[0].uri = f, t(r);
     }) : t(r);
   }
@@ -3031,7 +3141,7 @@ class dt {
    */
   isNormalizedNormalAttribute(e) {
     if (this.cache.attributesNormalized.has(e)) return !1;
-    const n = new Z();
+    const n = new ee();
     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 +3156,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 ee();
     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 +3176,14 @@ class dt {
   async buildMetalRoughTextureAsync(e, t) {
     if (e === t) return e;
     function n(u) {
-      return u.colorSpace === Ue ? function(y) {
+      return u.colorSpace === ze ? 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 ie && (e = await this.decompressTextureAsync(e)), t instanceof ie && (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 = Le();
     a.width = r, a.height = o;
     const l = a.getContext("2d", {
       willReadFrequently: !0
@@ -3094,7 +3204,7 @@ class dt {
     }
     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;
+    return f.source = new Be(a), f.colorSpace = Oe, 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;
   }
   async decompressTextureAsync(e, t = 1 / 0) {
     if (this.textureUtils === null)
@@ -3124,25 +3234,25 @@ 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 = De(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 = ce.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);
     }
@@ -3151,7 +3261,7 @@ class dt {
       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 && (f.target = i), i === C.ARRAY_BUFFER && (f.byteStride = a), this.byteOffset += l, r.bufferViews.push(f), {
       id: r.bufferViews.length - 1,
       byteLength: 0
     };
@@ -3164,8 +3274,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 = {
+      ae(e).then((i) => {
+        const r = oe(i), o = {
           buffer: t.processBuffer(r),
           byteOffset: t.byteOffset,
           byteLength: r.byteLength
@@ -3193,25 +3303,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 = dt(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 +3348,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 f = { mimeType: s }, u = Le();
       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 !== Fe && 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,10 +3364,10 @@ 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) => {
+        ft(u, s).then((x) => i.processBufferViewImage(x)).then((x) => {
           f.bufferView = x;
         })
-      ) : f.uri = Oe.getDataURL(u, s);
+      ) : f.uri = Ue.getDataURL(u, s);
       const y = o.images.push(f) - 1;
       return c[h] = y, y;
     } else
@@ -3272,10 +3382,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: Y[e.magFilter],
+      minFilter: Y[e.minFilter],
+      wrapS: Y[e.wrapS],
+      wrapT: Y[e.wrapT]
     };
     return t.samplers.push(n) - 1;
   }
@@ -3287,7 +3397,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 ie && (e = await this.decompressTextureAsync(e, n.maxTextureSize));
     let r = e.userData.mimeType;
     r === "image/webp" && (r = "image/png");
     const o = {
@@ -3314,7 +3424,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 (Z(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
@@ -3366,15 +3476,15 @@ 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 A = 0, P = e.material.length; A < P; A++)
+        s.push(e.material[A].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;
+    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 = [], f = {
       uv: "TEXCOORD_0",
       uv1: "TEXCOORD_1",
@@ -3386,76 +3496,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 A in r.attributes) {
+      if (A.slice(0, 5) === "morph") continue;
+      const P = r.attributes[A];
+      if (A = f[A] || A.toUpperCase(), /^(POSITION|NORMAL|TANGENT|TEXCOORD_\d+|COLOR_\d+|JOINTS_\d+|WEIGHTS_\d+)$/.test(A) || (A = "_" + A), t.attributes.has(this.getUID(P))) {
+        l[A] = t.attributes.get(this.getUID(P));
         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 L = P.array;
+      A === "JOINTS_0" && !(L instanceof Uint16Array) && !(L instanceof Uint8Array) ? (console.warn('GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.'), p = new H(new Uint16Array(L), P.itemSize, P.normalized)) : (L instanceof Uint32Array || L instanceof Int32Array) && !A.startsWith("_") && (console.warn(`GLTFExporter: Attribute "${A}" converted to type FLOAT.`), p = ne.Utils.toFloat32BufferAttribute(P));
+      const g = this.processAccessor(p || P, r);
+      g !== null && (A.startsWith("_") || this.detectMeshQuantization(A, P), l[A] = g, t.attributes.set(this.getUID(P), g));
     }
     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 A = [], P = [], M = {};
       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) {
+        for (const L in e.morphTargetDictionary)
+          M[e.morphTargetDictionary[L]] = L;
+      for (let L = 0; L < e.morphTargetInfluences.length; ++L) {
         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);
+        let b = !1;
+        for (const m in r.morphAttributes) {
+          if (m !== "position" && m !== "normal") {
+            b || (console.warn("GLTFExporter: Only POSITION and NORMAL morph are supported."), b = !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 E = r.morphAttributes[m][L], T = m.toUpperCase(), I = r.attributes[m];
+          if (t.attributes.has(this.getUID(E, !0))) {
+            g[T] = t.attributes.get(this.getUID(E, !0));
             continue;
           }
-          const I = A.clone();
+          const N = E.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 D = 0, v = E.count; D < v; D++)
+              for (let O = 0; O < E.itemSize; O++)
+                O === 0 && N.setX(D, E.getX(D) - I.getX(D)), O === 1 && N.setY(D, E.getY(D) - I.getY(D)), O === 2 && N.setZ(D, E.getZ(D) - I.getZ(D)), O === 3 && N.setW(D, E.getW(D) - I.getW(D));
+          g[T] = this.processAccessor(N, r), t.attributes.set(this.getUID(I, !0), g[T]);
         }
-        h.push(g), m.push(e.morphTargetInfluences[M]), e.morphTargetDictionary !== void 0 && E.push(L[M]);
+        h.push(g), A.push(e.morphTargetInfluences[L]), e.morphTargetDictionary !== void 0 && P.push(M[L]);
       }
-      a.weights = m, E.length > 0 && (a.extras = {}, a.extras.targetNames = E);
+      a.weights = A, P.length > 0 && (a.extras = {}, a.extras.targetNames = P);
     }
     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 A = [];
+      for (let P = 0, M = r.attributes.position.count; P < M; P++)
+        A[P] = P;
+      r.setIndex(A), 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], R = y ? r.groups : [{ materialIndex: 0, start: void 0, count: void 0 }];
+    for (let A = 0, P = R.length; A < P; A++) {
+      const M = {
         mode: o,
         attributes: l
       };
-      if (this.serializeUserData(r, L), h.length > 0 && (L.targets = h), r.index !== null) {
+      if (this.serializeUserData(r, M), h.length > 0 && (M.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;
+        (R[A].start !== void 0 || R[A].count !== void 0) && (g += ":" + R[A].start + ":" + R[A].count), t.attributes.has(g) ? M.indices = t.attributes.get(g) : (M.indices = this.processAccessor(r.index, r, R[A].start, R[A].count), t.attributes.set(g, M.indices)), M.indices === null && delete M.indices;
       }
-      const M = await this.processMaterialAsync(S[b[m].materialIndex]);
-      M !== null && (L.material = M), c.push(L);
+      const L = await this.processMaterialAsync(S[R[A].materialIndex]);
+      L !== null && (M.material = L), c.push(M);
     }
-    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(A) {
+      A.writeMesh && A.writeMesh(e, a);
     });
-    const C = n.meshes.push(a) - 1;
-    return t.meshes.set(i, C), C;
+    const F = n.meshes.push(a) - 1;
+    return t.meshes.set(i, F), F;
   }
   /**
    * If a vertex attribute with a
@@ -3469,7 +3579,7 @@ class dt {
    * @param {THREE.BufferAttribute} attribute
    */
   detectMeshQuantization(e, t) {
-    if (this.extensionsUsed[se]) return;
+    if (this.extensionsUsed[re]) return;
     let n;
     switch (t.array.constructor) {
       case Int8Array:
@@ -3489,7 +3599,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);
+    me[s] && me[s].includes(n) && (this.extensionsUsed[re] = !0, this.extensionsRequired[re] = !0);
   }
   /**
    * Process camera
@@ -3509,7 +3619,7 @@ class dt {
       znear: e.near < 0 ? 0 : e.near
     } : s.perspective = {
       aspectRatio: e.aspect,
-      yfov: oe.degToRad(e.fov),
+      yfov: ce.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,23 +3636,23 @@ 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 = ne.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];
+      const c = i[l], h = te.parseTrackName(c.name);
+      let f = te.findNode(t, h.nodeName);
+      const u = ge[h.propertyName];
       if (h.objectName === "bones" && (f.isSkinnedMesh === !0 ? f = f.skeleton.getBoneByName(h.objectIndex) : f = void 0), !f || !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 === ge.morphTargetInfluences && (y /= f.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() === _e ? x = "STEP" : x = "LINEAR", o.push({
+        input: this.processAccessor(new H(c.times, p)),
+        output: this.processAccessor(new H(c.values, y)),
         interpolation: x
       }), r.push({
         sampler: o.length - 1,
@@ -3568,11 +3678,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 Ae();
     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 H(a, 16)),
       joints: o,
       skeleton: n.get(r)
     }), s.skin = t.skins.length - 1;
@@ -3588,9 +3698,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);
+      Z(o, [0, 0, 0, 1]) || (i.rotation = o), Z(a, [0, 0, 0]) || (i.translation = a), Z(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(), ut(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 +3746,7 @@ class dt {
    * @param {Array<THREE.Object3D>} objects List of objects to process
    */
   async processObjectsAsync(e) {
-    const t = new ue();
+    const t = new fe();
     t.name = "AuxScene";
     for (let n = 0; n < e.length; n++)
       t.children.push(e[n]);
@@ -3652,7 +3762,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 fe ? 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 +3777,7 @@ class dt {
       await e(this.plugins[t]);
   }
 }
-class ft {
+class xt {
   constructor(e) {
     this.writer = e, this.name = "KHR_lights_punctual";
   }
@@ -3683,7 +3793,7 @@ class ft {
     o.push(r), t.extensions = t.extensions || {}, t.extensions[this.name] = { light: o.length - 1 };
   }
 }
-class pt {
+class yt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_unlit";
   }
@@ -3693,7 +3803,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 mt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_clearcoat";
   }
@@ -3724,7 +3834,7 @@ class xt {
     t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class yt {
+class gt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_dispersion";
   }
@@ -3734,7 +3844,7 @@ class yt {
     i.dispersion = e.dispersion, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class mt {
+class wt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_iridescence";
   }
@@ -3758,7 +3868,7 @@ class mt {
     t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class gt {
+class Mt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_transmission";
   }
@@ -3775,7 +3885,7 @@ class gt {
     t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class wt {
+class Lt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_volume";
   }
@@ -3792,7 +3902,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 St {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_ior";
   }
@@ -3802,12 +3912,12 @@ class Mt {
     i.ior = e.ior, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class St {
+class At {
   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(rt) && !e.specularIntensityMap && !e.specularColorMap) return;
     const n = this.writer, s = n.extensionsUsed, i = {};
     if (e.specularIntensityMap) {
       const r = {
@@ -3826,7 +3936,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 Et {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_sheen";
   }
@@ -3850,7 +3960,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 Tt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_anisotropy";
   }
@@ -3864,7 +3974,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 Dt {
   constructor(e) {
     this.writer = e, this.name = "KHR_materials_emissive_strength";
   }
@@ -3874,7 +3984,7 @@ class Tt {
     i.emissiveStrength = e.emissiveIntensity, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class At {
+class bt {
   constructor(e) {
     this.writer = e, this.name = "EXT_materials_bump";
   }
@@ -3891,24 +4001,24 @@ class At {
     i.bumpFactor = e.bumpScale, t.extensions = t.extensions || {}, t.extensions[this.name] = i, s[this.name] = !0;
   }
 }
-class Dt {
+class It {
   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 Ae(), l = new ee(), c = new Ne(), h = new ee();
     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))
+      TRANSLATION: n.processAccessor(new H(i, 3)),
+      ROTATION: n.processAccessor(new H(r, 4)),
+      SCALE: n.processAccessor(new H(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;
   }
 }
-ee.Utils = {
+ne.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));
     let o;
@@ -3938,7 +4048,7 @@ ee.Utils = {
     const t = [], n = {}, s = d.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 = te.parseTrackName(r.name), a = te.findNode(e, o.nodeName);
       if (o.propertyName !== "morphTargetInfluences" || o.propertyIndex === void 0) {
         t.push(r);
         continue;
@@ -3946,7 +4056,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(Ke);
       }
       const l = a.morphTargetInfluences.length, c = a.morphTargetDictionary[o.propertyIndex];
       if (c === void 0)
@@ -3972,7 +4082,7 @@ ee.Utils = {
     return d.tracks = t, d;
   },
   toFloat32BufferAttribute: function(d) {
-    const e = new k(new Float32Array(d.count * d.itemSize), d.itemSize, !1);
+    const e = new H(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++)
@@ -3981,7 +4091,7 @@ ee.Utils = {
     return e;
   }
 };
-async function bt(d) {
+async function Rt(d) {
   if (typeof FileReader > "u") {
     const e = await d.arrayBuffer(), n = Buffer.from(e).toString("base64");
     return `data:${d.type};base64,${n}`;
@@ -3991,7 +4101,7 @@ async function bt(d) {
       n.onload = () => e(n.result), n.onerror = () => t(new Error("Failed to read Blob as Data URL")), n.readAsDataURL(d);
     });
 }
-async function re(d) {
+async function ae(d) {
   if (typeof d.arrayBuffer == "function")
     return await d.arrayBuffer();
   if (typeof FileReader < "u")
@@ -4004,8 +4114,8 @@ async function re(d) {
     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 Pt = new $e(), vt = new ne();
+function Nt(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;
   return {
     points: [
@@ -4020,17 +4130,17 @@ function Pt(d, e, t = 0.1) {
     rectIndices: [0, 1, 3, 2, 0]
   };
 }
-class Ae extends W {
+class be extends J {
   static name = "WhiteModel";
   Dxf = null;
   Variable = null;
   // dxf数据白模
-  whiteModelGroup = new G.Group();
+  whiteModelGroup = new U.Group();
   // dxf数据白模边缘线
-  whiteModelLineGroup = new G.Group();
+  whiteModelLineGroup = new U.Group();
   // 原始数据白模
-  originalWhiteMode = new G.Group();
-  material = new G.MeshStandardMaterial({ color: 16777215, transparent: !0, opacity: 0.8, side: G.DoubleSide });
+  originalWhiteMode = new U.Group();
+  material = new U.MeshStandardMaterial({ color: 16777215, transparent: !0, opacity: 0.8, side: U.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 +4150,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 U.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 U.ExtrudeGeometry(s, {
         depth: 2.8,
         bevelSize: 0
-      }), r = new G.Mesh(i, this.material);
+      }), r = new U.Mesh(i, this.material);
       this.whiteModelGroup.add(r), this.whiteModelLineGroup.add(
-        new G.LineSegments(new G.EdgesGeometry(i), new G.LineBasicMaterial({ color: 0 }))
+        new U.LineSegments(new U.EdgesGeometry(i), new U.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 w(n.x, n.y).mutiplyScalar(e.scale), o = new w(s.x, s.y).mutiplyScalar(e.scale), { points: a, indices: l, rectIndices: c } = Nt(r, o, e.width);
       return {
         points: a,
         indices: l,
@@ -4058,17 +4168,17 @@ class Ae extends W {
         insetions: (i ?? []).map((h) => h.index)
       };
     }).forEach((n) => {
-      const s = new G.Shape();
+      const s = new U.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 U.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 U.Mesh(i);
       this.originalWhiteMode?.add(r);
     }), this.dispatchEvent({
       type: "updateModel",
@@ -4083,7 +4193,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(Pt.parse(this.whiteModelGroup)), this.material.opacity = 0.8, this.material.transparent = !0;
       }, 20);
     });
   }
@@ -4095,7 +4205,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) => {
+        vt.parse(this.whiteModelGroup.children, (n) => {
           t(n), this.material.opacity = 0.8, this.material.transparent = !0;
         }, () => {
           t(void 0);
@@ -4136,7 +4246,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 K("fs", !1)).writeFileSync(e, t);
     }
   }
   /**
@@ -4152,11 +4262,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 K("fs", !1)).writeFileSync(e, t ? Buffer.from(n) : JSON.stringify(n));
     }
   }
 }
-class De extends W {
+class Ie extends J {
   static name = "DetailsPoint";
   Dxf = null;
   WhiteModel = null;
@@ -4207,17 +4317,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 U.Vector3(
           t.position.x,
           t.position.y,
           t.position.z
-        ), s = new G.Vector3(
+        ), s = new U.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 U.Raycaster(n, s, 0, i).intersectObject(e.originalWhiteMode);
         if (o.length) {
           const { point: a } = o[0];
           this.desPoints.push({
@@ -4233,61 +4343,61 @@ class De extends W {
     }, 50);
   }
 }
-class be extends W {
+class Re extends J {
   static name = "DxfLineModel";
-  dxfLineModel = new G.LineSegments();
-  dxfDoorsLineModel = new G.LineSegments();
-  dxfModelGroup = new G.Group();
+  dxfLineModel = new U.LineSegments();
+  dxfDoorsLineModel = new U.LineSegments();
+  dxfModelGroup = new U.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 U.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 U.BufferGeometry().setAttribute("position", new U.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 U.BufferGeometry().setAttribute("position", new U.BufferAttribute(n, 3, !0)).setAttribute("color", new U.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 Ct = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  DetailsPoint: De,
-  DxfLineModel: be,
-  WhiteModel: Ae
+  DetailsPoint: Ie,
+  DxfLineModel: Re,
+  WhiteModel: be
 }, Symbol.toStringTag, { value: "Module" }));
-function Me(d, e = {}) {
+function Se(d, 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 && d.addComponent(new Re()), n && d.addComponent(new be()), t && d.addComponent(new Ie());
 }
-const vt = Object.assign(Me, {
+const Bt = Object.assign(Se, {
   create(d = {}) {
-    return (e) => Me(e, d);
+    return (e) => Se(e, d);
   }
-}), Ct = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}), Ot = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  ModelDataPlugin: vt,
-  components: Nt
+  ModelDataPlugin: Bt,
+  components: Ct
 }, Symbol.toStringTag, { value: "Module" }));
-function Bt() {
+function Ft() {
   return import("./index2.js");
 }
-function Ot() {
+function Ut() {
   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 de = null;
+async function Yt(d, e, t = !1, n) {
+  const s = await Promise.resolve().then(() => Ot), i = await Ft(), r = await Ut(), o = new it().usePlugin(s.ModelDataPlugin.create({
     detailsPoint: !1,
     whiteModel: !0
   })).usePlugin(i.RenderPlugin.create({
@@ -4297,12 +4407,12 @@ 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 && d.appendChild(a.domElement), de = o, {
     dxfSystem: o,
     getFileAll: () => Gt(o)
   };
 }
-async function Gt(d = he) {
+async function Gt(d = de) {
   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" });
   return {
     dxf: n,
@@ -4314,27 +4424,27 @@ async function Gt(d = he) {
     correctionDxf: s
   };
 }
-function jt() {
-  return he;
+function Xt() {
+  return de;
 }
 export {
   _ as B,
-  W as C,
-  nt as D,
-  Le as E,
+  J as C,
+  it as D,
+  Ee as E,
   B as L,
-  vt as M,
+  Bt 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,
+  X as Q,
+  st as T,
+  Te as V,
+  be as W,
+  Ie as a,
+  he as b,
+  V as c,
+  Yt as d,
+  Xt as e,
   Gt as g,
-  Nt as i,
-  ae as u
+  Ct as i,
+  le as u
 };