build-dxf 0.0.20-23 → 0.0.20-25

package/src/build.js

@@ -1,70 +1,55 @@
-import * as THREE from "three";
-import { EventDispatcher as EventDispatcher$1 } from "three";
-import ClipperLib from "clipper-lib";
-import Drawing from "dxf-writer";
-import { OBJExporter } from "three/examples/jsm/exporters/OBJExporter.js";
-import { GLTFExporter } from "three/examples/jsm/exporters/GLTFExporter.js";
-function uuid() {
-  return "xxxx-xxxx-4xxx-yxxx-xxxx".replace(/[xy]/g, function(c) {
-    var r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
-    return v.toString(16);
+import * as M from "three";
+import { EventDispatcher as tt } from "three";
+import F from "clipper-lib";
+import R from "dxf-writer";
+import { OBJExporter as et } from "three/examples/jsm/exporters/OBJExporter.js";
+import { GLTFExporter as nt } from "three/examples/jsm/exporters/GLTFExporter.js";
+function N() {
+  return "xxxx-xxxx-4xxx-yxxx-xxxx".replace(/[xy]/g, function(y) {
+    var t = Math.random() * 16 | 0, e = y == "x" ? t : t & 3 | 8;
+    return e.toString(16);
   });
 }
-class EventDispatcher extends EventDispatcher$1 {
-  uuid = uuid();
-  addEventListener(type, listener, option) {
-    const { once = false } = option ?? {};
-    const callBack = (event) => {
-      listener(event);
-      once && canceCallBack();
-    };
-    const canceCallBack = () => this.removeEventListener(type, callBack);
-    super.addEventListener(type, callBack);
-    return canceCallBack;
+class $ extends tt {
+  uuid = N();
+  addEventListener(t, e, n) {
+    const { once: i = !1 } = n ?? {}, s = (r) => {
+      e(r), i && o();
+    }, o = () => this.removeEventListener(t, s);
+    return super.addEventListener(t, s), o;
   }
   eventRecordStack = /* @__PURE__ */ new Map();
-  addEventRecord(name, ...cancels) {
-    if (!this.eventRecordStack.has(name)) this.eventRecordStack.set(name, []);
-    cancels.forEach((cancel) => {
-      this.eventRecordStack.get(name)?.push(cancel);
+  addEventRecord(t, ...e) {
+    this.eventRecordStack.has(t) || this.eventRecordStack.set(t, []), e.forEach((i) => {
+      this.eventRecordStack.get(t)?.push(i);
     });
-    const add = (cancel) => {
-      this.addEventRecord(name, cancel);
-      return { add };
-    };
-    return { add };
+    const n = (i) => (this.addEventRecord(t, i), { add: n });
+    return { add: n };
   }
-  canceEventRecord(name) {
-    const list = this.eventRecordStack.get(name);
-    if (list) {
-      list.forEach((cancel) => cancel());
-      this.eventRecordStack.delete(name);
-    }
+  canceEventRecord(t) {
+    const e = this.eventRecordStack.get(t);
+    e && (e.forEach((n) => n()), this.eventRecordStack.delete(t));
   }
 }
-class Component extends EventDispatcher {
+class j extends $ {
   parent;
-  destroyed = false;
-  constructor(...arg) {
-    super();
-    this.addEventListener("addFromParent", (e) => {
-      this.parent = e.parent;
-      this.onAddFromParent(e.parent);
-    });
-    this.addEventListener("removeFromParent", (e) => {
-      this.parent = void 0;
-      this.onRemoveFromParent(e.parent);
+  destroyed = !1;
+  constructor(...t) {
+    super(), this.addEventListener("addFromParent", (e) => {
+      this.parent = e.parent, this.onAddFromParent(e.parent);
+    }), this.addEventListener("removeFromParent", (e) => {
+      this.parent = void 0, this.onRemoveFromParent(e.parent);
     });
   }
-  onAddFromParent(parent) {
+  onAddFromParent(t) {
   }
-  onRemoveFromParent(parent) {
+  onRemoveFromParent(t) {
   }
   destroy() {
-    this.destroyed = true;
+    this.destroyed = !0;
   }
 }
-class ComponentManager extends EventDispatcher {
+class it extends $ {
   static EventType = {
     ADD_COMPONENT: "addComponent"
   };
@@ -73,75 +58,66 @@ class ComponentManager extends EventDispatcher {
    * 添加组件
    * @param component 
    */
-  addComponent(component) {
-    if (component) {
-      this.components.push(component);
-      this.dispatchEvent({
-        type: "addComponent",
-        component
-      });
-      component.dispatchEvent({
-        type: "addFromParent",
-        parent: this
-      });
-    }
-    return this;
+  addComponent(t) {
+    return t && (this.components.push(t), this.dispatchEvent({
+      type: "addComponent",
+      component: t
+    }), t.dispatchEvent({
+      type: "addFromParent",
+      parent: this
+    })), this;
   }
   /**
    * 移除组件
    * @param component 
    */
-  removeComponent(component) {
-    if (component instanceof Component) {
-      const index2 = this.components.indexOf(component);
-      if (index2 > -1) {
-        this.components.splice(index2, 1);
-        this.dispatchEvent({
-          type: "removeComponent",
-          component
-        });
-        component.dispatchEvent({
-          type: "removeFromParent",
-          parent: this
-        });
-      }
+  removeComponent(t) {
+    if (t instanceof j) {
+      const e = this.components.indexOf(t);
+      e > -1 && (this.components.splice(e, 1), this.dispatchEvent({
+        type: "removeComponent",
+        component: t
+      }), t.dispatchEvent({
+        type: "removeFromParent",
+        parent: this
+      }));
     }
   }
   /**
    * 查找符合条件的第一个组件
    * @param callBack 
    */
-  findComponent(predicate) {
-    for (let i = 0; i < this.components.length; i++) {
-      const component = this.components[i];
-      if (predicate(component, i)) return component;
+  findComponent(t) {
+    for (let e = 0; e < this.components.length; e++) {
+      const n = this.components[e];
+      if (t(n, e)) return n;
     }
   }
   /**
    * 查找所有符合条件的组件
    * @param callBack 
    */
-  findComponents(predicate) {
-    return this.components.filter(predicate);
+  findComponents(t) {
+    return this.components.filter(t);
   }
   /**
    * 
    * @param type 
    */
-  findComponentByType(type) {
-    const component = this.findComponent((c) => c instanceof type);
-    return component ? component : null;
+  findComponentByType(t) {
+    const e = this.findComponent((n) => n instanceof t);
+    return e || null;
   }
   /**
    * 
    * @param type 
    */
-  findComponentByName(name) {
-    const component = this.findComponent((c) => c.constructor.name === name);
-    return component ? component : null;
+  findComponentByName(t) {
+    const e = this.findComponent((n) => n.constructor.name === t);
+    return e || null;
   }
 }
-class Point {
+class f {
   x;
   y;
   get X() {
@@ -156,39 +132,32 @@ class Point {
    * @param x 
    * @param y 
    */
-  constructor(x = 0, y = 0) {
-    this.x = x;
-    this.y = y;
+  constructor(t = 0, e = 0) {
+    this.x = t, this.y = e;
   }
-  set(x, y) {
-    this.x = x;
-    this.y = y;
-    return this;
+  set(t, e) {
+    return this.x = t, this.y = e, this;
   }
-  setX(x) {
-    this.x = x;
-    return this;
+  setX(t) {
+    return this.x = t, this;
   }
-  setY(y) {
-    this.y = y;
-    return this;
+  setY(t) {
+    return this.y = t, this;
   }
   /**
    * 
    * @param point 
    * @returns 
    */
-  equal(point) {
-    return point.x === this.x && point.y === this.y;
+  equal(t) {
+    return t.x === this.x && t.y === this.y;
   }
   /**
    * 
    * @param arr 
    */
-  setByArray(arr) {
-    this.x = arr[0];
-    this.y = arr[1];
-    return this;
+  setByArray(t) {
+    return this.x = t[0], this.y = t[1], this;
   }
   /**
    * 
@@ -200,25 +169,19 @@ class Point {
    * multiplyScalar
    * @param scalar 
    */
-  mutiplyScalar(scalar) {
-    this.x *= scalar;
-    this.y *= scalar;
-    return this;
+  mutiplyScalar(t) {
+    return this.x *= t, this.y *= t, this;
   }
-  multiplyScalar(scalar) {
-    this.x *= scalar;
-    this.y *= scalar;
-    return this;
+  multiplyScalar(t) {
+    return this.x *= t, this.y *= t, this;
   }
   /**
    * 
    * @param scalar 
    * @returns 
    */
-  divisionScalar(scalar) {
-    this.x /= scalar;
-    this.y /= scalar;
-    return this;
+  divisionScalar(t) {
+    return this.x /= t, this.y /= t, this;
   }
   /**
    * 减法
@@ -226,10 +189,8 @@ class Point {
    * @param point
    * @returns 
    */
-  division(point) {
-    this.x -= point.x;
-    this.y -= point.y;
-    return this;
+  division(t) {
+    return this.x -= t.x, this.y -= t.y, this;
   }
   /**
    * 加法
@@ -237,19 +198,24 @@ class Point {
    * @param point 
    * @returns 
    */
-  add(point) {
-    this.x += point.x;
-    this.y += point.y;
-    return this;
+  add(t) {
+    return this.x += t.x, this.y += t.y, this;
+  }
+  /**
+   * 绕point旋转angle
+   * @param point 
+   * @param angle 旋转角度，单位为弧度
+   */
+  rotate(t, e) {
+    const n = this.x - t.x, i = this.y - t.y, s = Math.cos(e), o = Math.sin(e), r = n * s - i * o, c = n * o + i * s;
+    return this.x = r + t.x, this.y = c + t.y, this;
   }
   /**
    * 保留小数位数
    * @param count 
    */
-  fixed(count) {
-    this.x = Number(this.x.toFixed(count));
-    this.y = Number(this.y.toFixed(count));
-    return this;
+  fixed(t) {
+    return this.x = Number(this.x.toFixed(t)), this.y = Number(this.y.toFixed(t)), this;
   }
   /**
    * 归一化
@@ -257,11 +223,8 @@ class Point {
    * @returns 
    */
   normalize() {
-    const length = Math.sqrt(this.x * this.x + this.y * this.y);
-    if (length === 0) return this;
-    this.x /= length;
-    this.y /= length;
-    return this;
+    const t = Math.sqrt(this.x * this.x + this.y * this.y);
+    return t === 0 ? this : (this.x /= t, this.y /= t, this);
   }
   /**
    * 获取单位法向量
@@ -269,13 +232,9 @@ class Point {
    * @param point 
    * @returns 
    */
-  normal(point) {
-    const dx = this.x - point.x;
-    const dy = this.y - point.y;
-    const length = Math.sqrt(dx * dx + dy * dy);
-    const nx = -dy / length;
-    const ny = dx / length;
-    return new Point(nx, ny);
+  normal(t) {
+    const e = this.x - t.x, n = this.y - t.y, i = Math.sqrt(e * e + n * n), s = -n / i, o = e / i;
+    return new f(s, o);
   }
   /**
    * 获取由传入的点到该点的单位方向向量
@@ -283,12 +242,9 @@ class Point {
    * @param point 
    * @returns 
    */
-  direction(point) {
-    const dx = this.x - point.x;
-    const dy = this.y - point.y;
-    const length = Math.sqrt(dx * dx + dy * dy);
-    if (length === 0) return new Point(0, 0);
-    return new Point(dx / length, dy / length);
+  direction(t) {
+    const e = this.x - t.x, n = this.y - t.y, i = Math.sqrt(e * e + n * n);
+    return i === 0 ? new f(0, 0) : new f(e / i, n / i);
   }
   /**
    * 计算模长
@@ -302,8 +258,8 @@ class Point {
    * @param point 
    * @returns 
    */
-  dot(point) {
-    return this.x * point.x + this.y * point.y;
+  dot(t) {
+    return this.x * t.x + this.y * t.y;
   }
   /** 求两个点叉积
    * @description 如果叉积大于 0，a 到 b 为逆时针方向。
@@ -311,8 +267,8 @@ class Point {
    * @param point 
    * @returns 
    */
-  cross(point) {
-    return this.x * point.y - this.y * this.x;
+  cross(t) {
+    return this.x * t.y - this.y * this.x;
   }
   /** 计算两个向量夹角
    * @description 公式：a · b = |a| × |b| × cosθ
@@ -320,34 +276,25 @@ class Point {
    * @param point 
    * @returns 
    */
-  angleBetween(point, type = "radian", angle = "180") {
-    const dotProduct = this.dot(point);
-    const magnitude1 = this.magnitude();
-    const magnitude2 = point.magnitude();
-    if (magnitude1 === 0 || magnitude2 === 0) return 0;
-    const cosTheta = dotProduct / (magnitude1 * magnitude2);
-    const clampedCosTheta = Math.max(-1, Math.min(1, cosTheta));
-    if (type === "radian") return Math.acos(clampedCosTheta);
-    if (type === "cos") return clampedCosTheta;
-    if (angle === "180" || this.cross(point) < 0) return Math.acos(clampedCosTheta) / (Math.PI / 180);
-    return 360 - Math.acos(clampedCosTheta) / (Math.PI / 180);
+  angleBetween(t, e = "radian", n = "180") {
+    const i = this.dot(t), s = this.magnitude(), o = t.magnitude();
+    if (s === 0 || o === 0) return 0;
+    const r = i / (s * o), c = Math.max(-1, Math.min(1, r));
+    return e === "radian" ? Math.acos(c) : e === "cos" ? c : n === "180" || this.cross(t) < 0 ? Math.acos(c) / (Math.PI / 180) : 360 - Math.acos(c) / (Math.PI / 180);
   }
   /** 获取向量长度
    */
   length() {
-    const magnitude = Math.sqrt(this.x * this.x + this.y * this.y);
-    if (Math.abs(magnitude - Math.round(magnitude)) < 1e-9) {
-      return Math.round(magnitude);
-    }
-    return magnitude;
+    const t = Math.sqrt(this.x * this.x + this.y * this.y);
+    return Math.abs(t - Math.round(t)) < 1e-9 ? Math.round(t) : t;
   }
   /**
    * 获取两个点长度
    * @param point 
    */
-  distance(point) {
+  distance(t) {
     return Math.sqrt(
-      (this.x - point.x) * (this.x - point.x) + (this.y - point.y) * (this.y - point.y)
+      (this.x - t.x) * (this.x - t.x) + (this.y - t.y) * (this.y - t.y)
     );
   }
   /**
@@ -355,47 +302,40 @@ class Point {
    * @returns 
    */
   clone() {
-    return new Point(this.x, this.y);
+    return new f(this.x, this.y);
   }
   /**
    * 克隆
    * @returns 
    */
-  copy(p) {
-    this.x = p.x ?? 0;
-    this.y = p.y ?? 0;
+  copy(t) {
+    return this.x = t.x ?? 0, this.y = t.y ?? 0, this;
   }
-  toJson() {
+  toJson(t = 0) {
     return {
       x: this.x,
-      y: this.y
+      y: this.y,
+      z: t
     };
   }
-  static from(arr) {
-    if (Array.isArray(arr)) {
-      return new Point(arr[0], arr[1]);
-    } else if ("x" in arr && "y" in arr) {
-      return new Point(arr.x, arr.y);
-    } else if ("X" in arr && "Y" in arr) {
-      return new Point(arr.X, arr.Y);
-    }
-    return this.zero();
+  static from(t) {
+    return Array.isArray(t) ? new f(t[0], t[1]) : "x" in t && "y" in t ? new f(t.x, t.y) : "X" in t && "Y" in t ? new f(t.X, t.Y) : this.zero();
   }
   static zero() {
-    return new Point(0, 0);
+    return new f(0, 0);
   }
 }
-class Box2 {
+class v {
   minX = 0;
   maxX = 0;
   minY = 0;
   maxY = 0;
   get points() {
     return [
-      new Point(this.minX, this.minY),
-      new Point(this.maxX, this.minY),
-      new Point(this.maxX, this.maxY),
-      new Point(this.minX, this.maxY)
+      new f(this.minX, this.minY),
+      new f(this.maxX, this.minY),
+      new f(this.maxX, this.maxY),
+      new f(this.minX, this.maxY)
     ];
   }
   get width() {
@@ -405,163 +345,122 @@ class Box2 {
     return this.maxY - this.minY;
   }
   get center() {
-    return new Point(
+    return new f(
       this.minX + (this.maxX - this.minX) * 0.5,
       this.minY + (this.maxY - this.minY) * 0.5
     );
   }
-  constructor(minX = 0, maxX = 0, minY = 0, maxY = 0) {
-    this.minX = minX;
-    this.maxX = maxX;
-    this.minY = minY;
-    this.maxY = maxY;
+  constructor(t = 0, e = 0, n = 0, i = 0) {
+    this.minX = t, this.maxX = e, this.minY = n, this.maxY = i;
   }
   /**
    * 
    * @param z 
    * @returns 
    */
-  getPaths3D(z = 0) {
-    const points = this.points, list = [];
-    points.forEach((p, i) => {
-      const nextP = points[(i + 1) % points.length];
-      list.push(p.x, p.y, z);
-      list.push(nextP.x, nextP.y, z);
-    });
-    return list;
+  getPaths3D(t = 0) {
+    const e = this.points, n = [];
+    return e.forEach((i, s) => {
+      const o = e[(s + 1) % e.length];
+      n.push(i.x, i.y, t), n.push(o.x, o.y, t);
+    }), n;
   }
   /**
    * 判断线段是与包围盒相交
    * @description Liang-Barsky算法的变种
    * @param line 
    */
-  intersectLineSegment(line) {
-    const p1 = line.points[0];
-    const p2 = line.points[1];
-    const dx = p2.x - p1.x;
-    const dy = p2.y - p1.y;
-    if (dx === 0 && dy === 0) {
-      return this.minX <= p1.x && p1.x <= this.maxX && this.minY <= p1.y && p1.y <= this.maxY;
-    }
-    let tNear = Number.NEGATIVE_INFINITY;
-    let tFar = Number.POSITIVE_INFINITY;
-    if (dx !== 0) {
-      const tx1 = (this.minX - p1.x) / dx;
-      const tx2 = (this.maxX - p1.x) / dx;
-      tNear = Math.max(tNear, Math.min(tx1, tx2));
-      tFar = Math.min(tFar, Math.max(tx1, tx2));
-    } else if (p1.x < this.minX || p1.x > this.maxX) {
-      return false;
-    }
-    if (dy !== 0) {
-      const ty1 = (this.minY - p1.y) / dy;
-      const ty2 = (this.maxY - p1.y) / dy;
-      tNear = Math.max(tNear, Math.min(ty1, ty2));
-      tFar = Math.min(tFar, Math.max(ty1, ty2));
-    } else if (p1.y < this.minY || p1.y > this.maxY) {
-      return false;
-    }
-    return tNear <= tFar && tNear <= 1 && tFar >= 0;
+  intersectLineSegment(t) {
+    const e = t.points[0], n = t.points[1], i = n.x - e.x, s = n.y - e.y;
+    if (i === 0 && s === 0)
+      return this.minX <= e.x && e.x <= this.maxX && this.minY <= e.y && e.y <= this.maxY;
+    let o = Number.NEGATIVE_INFINITY, r = Number.POSITIVE_INFINITY;
+    if (i !== 0) {
+      const c = (this.minX - e.x) / i, a = (this.maxX - e.x) / i;
+      o = Math.max(o, Math.min(c, a)), r = Math.min(r, Math.max(c, a));
+    } else if (e.x < this.minX || e.x > this.maxX)
+      return !1;
+    if (s !== 0) {
+      const c = (this.minY - e.y) / s, a = (this.maxY - e.y) / s;
+      o = Math.max(o, Math.min(c, a)), r = Math.min(r, Math.max(c, a));
+    } else if (e.y < this.minY || e.y > this.maxY)
+      return !1;
+    return o <= r && o <= 1 && r >= 0;
   }
   /**
    * 判断线段是在包围盒内
    * @param line 
    */
-  containsLineSegment(line) {
-    const [p1, p2] = line.points;
-    return this.minX <= p1.x && p1.x <= this.maxX && this.minY <= p1.y && p1.y <= this.maxY && this.minX <= p2.x && p2.x <= this.maxX && this.minY <= p2.y && p2.y <= this.maxY;
+  containsLineSegment(t) {
+    const [e, n] = t.points;
+    return this.minX <= e.x && e.x <= this.maxX && this.minY <= e.y && e.y <= this.maxY && this.minX <= n.x && n.x <= this.maxX && this.minY <= n.y && n.y <= this.maxY;
   }
   /**
    * 判断矩形与包围盒相交
    * @param rectangle 
    */
-  intersectRectangle(rectangle) {
-    const isPointInBox = (p) => this.minX <= p.x && p.x <= this.maxX && this.minY <= p.y && p.y <= this.maxY;
-    const isPointInRect = (point) => {
-      let sign = 0;
-      for (let i = 0; i < 4; i++) {
-        const p1 = rectangle.points[i];
-        const p2 = rectangle.points[(i + 1) % 4];
-        const edge = { x: p2.x - p1.x, y: p2.y - p1.y };
-        const toPoint = { x: point.x - p1.x, y: point.y - p1.y };
-        const cross = edge.x * toPoint.y - edge.y * toPoint.x;
-        if (cross === 0) {
-          const t = edge.x !== 0 ? (point.x - p1.x) / edge.x : (point.y - p1.y) / edge.y;
-          if (t >= 0 && t <= 1) return true;
+  intersectRectangle(t) {
+    const e = (o) => this.minX <= o.x && o.x <= this.maxX && this.minY <= o.y && o.y <= this.maxY, n = (o) => {
+      let r = 0;
+      for (let c = 0; c < 4; c++) {
+        const a = t.points[c], h = t.points[(c + 1) % 4], l = { x: h.x - a.x, y: h.y - a.y }, d = { x: o.x - a.x, y: o.y - a.y }, p = l.x * d.y - l.y * d.x;
+        if (p === 0) {
+          const m = l.x !== 0 ? (o.x - a.x) / l.x : (o.y - a.y) / l.y;
+          if (m >= 0 && m <= 1) return !0;
         } else {
-          const currentSign = cross > 0 ? 1 : -1;
-          if (sign === 0) sign = currentSign;
-          if (sign !== currentSign) return false;
+          const m = p > 0 ? 1 : -1;
+          if (r === 0 && (r = m), r !== m) return !1;
         }
       }
-      return true;
-    };
-    const doIntersect = (l1p1, l1p2, l2p1, l2p2) => {
-      const orientation = (p, q, r) => {
-        const val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-        if (val === 0) return 0;
-        return val > 0 ? 1 : 2;
-      };
-      const onSegment = (p, q, r) => {
-        return Math.min(p.x, r.x) <= q.x && q.x <= Math.max(p.x, r.x) && Math.min(p.y, r.y) <= q.y && q.y <= Math.max(p.y, r.y);
-      };
-      const o1 = orientation(l1p1, l1p2, l2p1);
-      const o2 = orientation(l1p1, l1p2, l2p2);
-      const o3 = orientation(l2p1, l2p2, l1p1);
-      const o4 = orientation(l2p1, l2p2, l1p2);
-      if (o1 !== o2 && o3 !== o4) return true;
-      if (o1 === 0 && onSegment(l1p1, l2p1, l1p2)) return true;
-      if (o2 === 0 && onSegment(l1p1, l2p2, l1p2)) return true;
-      if (o3 === 0 && onSegment(l2p1, l1p1, l2p2)) return true;
-      if (o4 === 0 && onSegment(l2p1, l1p2, l2p2)) return true;
-      return false;
-    };
-    const boxPoints = this.points;
-    for (let i = 0; i < 4; i++) {
-      const bp1 = boxPoints[i];
-      const bp2 = boxPoints[(i + 1) % 4];
-      for (let j = 0; j < 4; j++) {
-        const rp1 = rectangle.points[j];
-        const rp2 = rectangle.points[(j + 1) % 4];
-        if (doIntersect(bp1, bp2, rp1, rp2)) return true;
+      return !0;
+    }, i = (o, r, c, a) => {
+      const h = (u, x, w) => {
+        const S = (x.y - u.y) * (w.x - x.x) - (x.x - u.x) * (w.y - x.y);
+        return S === 0 ? 0 : S > 0 ? 1 : 2;
+      }, l = (u, x, w) => Math.min(u.x, w.x) <= x.x && x.x <= Math.max(u.x, w.x) && Math.min(u.y, w.y) <= x.y && x.y <= Math.max(u.y, w.y), d = h(o, r, c), p = h(o, r, a), m = h(c, a, o), g = h(c, a, r);
+      return !!(d !== p && m !== g || d === 0 && l(o, c, r) || p === 0 && l(o, a, r) || m === 0 && l(c, o, a) || g === 0 && l(c, r, a));
+    }, s = this.points;
+    for (let o = 0; o < 4; o++) {
+      const r = s[o], c = s[(o + 1) % 4];
+      for (let a = 0; a < 4; a++) {
+        const h = t.points[a], l = t.points[(a + 1) % 4];
+        if (i(r, c, h, l)) return !0;
       }
     }
-    for (let p of rectangle.points) {
-      if (isPointInBox(p)) return true;
-    }
-    for (let p of boxPoints) {
-      if (isPointInRect(p)) return true;
-    }
-    return false;
+    for (let o of t.points)
+      if (e(o)) return !0;
+    for (let o of s)
+      if (n(o)) return !0;
+    return !1;
   }
   /**
    * 判断矩形是在包围盒内
    * @param rectangle 
    */
-  containsRectangle(rectangle) {
-    return rectangle.points.every(
-      (p) => this.minX <= p.x && p.x <= this.maxX && this.minY <= p.y && p.y <= this.maxY
+  containsRectangle(t) {
+    return t.points.every(
+      (e) => this.minX <= e.x && e.x <= this.maxX && this.minY <= e.y && e.y <= this.maxY
     );
   }
   /**
    * 判断包围盒与包围盒相交
    * @param box 
    */
-  intersectBox(box) {
-    return !(this.maxX < box.minX || this.minX > box.maxX || this.maxY < box.minY || this.minY > box.maxY);
+  intersectBox(t) {
+    return !(this.maxX < t.minX || this.minX > t.maxX || this.maxY < t.minY || this.minY > t.maxY);
   }
   /**
    * 判断包围盒是在包围盒内
    * @param box 
    */
-  containsBox(box) {
-    return this.minX <= box.minX && box.maxX <= this.maxX && this.minY <= box.minY && box.maxY <= this.maxY;
+  containsBox(t) {
+    return this.minX <= t.minX && t.maxX <= this.maxX && this.minY <= t.minY && t.maxY <= this.maxY;
   }
   /** 判断点是在包围盒内
    * @param point 
    */
-  containsPoint(point) {
-    return point.x >= this.minX && point.x <= this.maxX && point.y >= this.minY && point.y <= this.maxY;
+  containsPoint(t) {
+    return t.x >= this.minX && t.x <= this.maxX && t.y >= this.minY && t.y <= this.maxY;
   }
   /**
    * 
@@ -571,12 +470,8 @@ class Box2 {
    * @param maxY 
    * @returns 
    */
-  set(minX, minY, maxX, maxY) {
-    this.minX = minX;
-    this.minY = minY;
-    this.maxX = maxX;
-    this.maxY = maxY;
-    return this;
+  set(t, e, n, i) {
+    return this.minX = t, this.minY = e, this.maxX = n, this.maxY = i, this;
   }
   /**
    * 
@@ -585,57 +480,55 @@ class Box2 {
    * @param mode 
    * @returns 
    */
-  scaleSize(maxWidth, maxHeight, mode = "min") {
-    const scaleX = maxWidth / this.width;
-    const scaleY = maxHeight / this.height;
-    return Math[mode](scaleX, scaleY);
+  scaleSize(t, e, n = "min") {
+    const i = t / this.width, s = e / this.height;
+    return Math[n](i, s);
   }
   /**
    * 
    * @param scalar 
    * @returns 
    */
-  multiplyScalar(scalar) {
-    this.minX *= scalar;
-    this.minY *= scalar;
-    this.maxX *= scalar;
-    this.maxY *= scalar;
-    return this;
+  multiplyScalar(t) {
+    return this.minX *= t, this.minY *= t, this.maxX *= t, this.maxY *= t, this;
   }
-  expansion(w) {
-    this.minX -= w;
-    this.minY -= w;
-    this.maxX += w;
-    this.maxY += w;
-    return this;
+  expansion(t) {
+    return this.minX -= t, this.minY -= t, this.maxX += t, this.maxY += t, this;
   }
   /**
    * 
    * @returns 
    */
   clone() {
-    return new Box2(this.minX, this.maxX, this.minY, this.maxY);
+    return new v(this.minX, this.maxX, this.minY, this.maxY);
   }
   /**
    * 
    * @param points 
    * @returns 
    */
-  static fromByPoints(...points) {
-    const xList = [], yList = [];
-    points.forEach((p) => {
-      xList.push(p.x);
-      yList.push(p.y);
-    });
-    return new Box2(
-      Math.min(...xList),
-      Math.max(...xList),
-      Math.min(...yList),
-      Math.max(...yList)
+  static fromByPoints(...t) {
+    const e = [], n = [];
+    return t.forEach((i) => {
+      e.push(i.x), n.push(i.y);
+    }), new v(
+      Math.min(...e),
+      Math.max(...e),
+      Math.min(...n),
+      Math.max(...n)
     );
   }
 }
-class Rectangle {
+function z(y) {
+  if (y === null || typeof y != "object") return y;
+  if (y instanceof Date) return new Date(y.getTime());
+  if (Array.isArray(y)) return y.map(z);
+  const t = {};
+  for (const e in y)
+    Object.prototype.hasOwnProperty.call(y, e) && (t[e] = z(y[e]));
+  return t;
+}
+class O {
   points;
   get p0() {
     return this.points[0];
@@ -650,16 +543,15 @@ class Rectangle {
     return this.points[3];
   }
   get path() {
-    return this.points.flatMap((p, i) => {
-      const np = this.points[(i + 1) % this.points.length];
-      return [p.x, p.y, 0, np.x, np.y, 0];
+    return this.points.flatMap((t, e) => {
+      const n = this.points[(e + 1) % this.points.length];
+      return [t.x, t.y, 0, n.x, n.y, 0];
     });
   }
-  path2D(callback) {
-    return this.points.flatMap((p, i) => {
-      const np = this.points[(i + 1) % this.points.length];
-      callback && callback(new Point(p.x, p.y), new Point(np.x, np.y));
-      return [p.x, p.y, np.x, np.y];
+  path2D(t) {
+    return this.points.flatMap((e, n) => {
+      const i = this.points[(n + 1) % this.points.length];
+      return t && t(new f(e.x, e.y), new f(i.x, i.y)), [e.x, e.y, i.x, i.y];
     });
   }
   createGeometry() {
@@ -670,85 +562,58 @@ class Rectangle {
       this.p2,
       this.p0,
       this.p3
-    ].flatMap((p) => [p.x, p.y, 0]);
+    ].flatMap((t) => [t.x, t.y, 0]);
   }
-  constructor(points) {
-    if (points.length !== 4) {
+  constructor(t) {
+    if (t.length !== 4)
       throw new Error("Rectangle must be defined by exactly 4 points");
-    }
-    this.points = points;
+    this.points = t;
   }
   /**
    * 判断线段是否与矩形相交
    * @param line 线段
    * @returns 是否与矩形相交
    */
-  intersectLineSegment(line) {
-    if (line.points.length !== 2) {
+  intersectLineSegment(t) {
+    if (t.points.length !== 2)
       throw new Error("LineSegment must have exactly 2 points");
-    }
-    const [p1, p2] = line.points;
-    const doIntersect = (l1p1, l1p2, l2p1, l2p2) => {
-      const orientation = (p, q, r) => {
-        const val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-        if (val === 0) return 0;
-        return val > 0 ? 1 : 2;
-      };
-      const onSegment = (p, q, r) => {
-        return Math.min(p.x, r.x) <= q.x && q.x <= Math.max(p.x, r.x) && Math.min(p.y, r.y) <= q.y && q.y <= Math.max(p.y, r.y);
-      };
-      const o1 = orientation(l1p1, l1p2, l2p1);
-      const o2 = orientation(l1p1, l1p2, l2p2);
-      const o3 = orientation(l2p1, l2p2, l1p1);
-      const o4 = orientation(l2p1, l2p2, l1p2);
-      if (o1 !== o2 && o3 !== o4) return true;
-      if (o1 === 0 && onSegment(l1p1, l2p1, l1p2)) return true;
-      if (o2 === 0 && onSegment(l1p1, l2p2, l1p2)) return true;
-      if (o3 === 0 && onSegment(l2p1, l1p1, l2p2)) return true;
-      if (o4 === 0 && onSegment(l2p1, l1p2, l2p2)) return true;
-      return false;
+    const [e, n] = t.points, i = (s, o, r, c) => {
+      const a = (g, u, x) => {
+        const w = (u.y - g.y) * (x.x - u.x) - (u.x - g.x) * (x.y - u.y);
+        return w === 0 ? 0 : w > 0 ? 1 : 2;
+      }, h = (g, u, x) => Math.min(g.x, x.x) <= u.x && u.x <= Math.max(g.x, x.x) && Math.min(g.y, x.y) <= u.y && u.y <= Math.max(g.y, x.y), l = a(s, o, r), d = a(s, o, c), p = a(r, c, s), m = a(r, c, o);
+      return !!(l !== d && p !== m || l === 0 && h(s, r, o) || d === 0 && h(s, c, o) || p === 0 && h(r, s, c) || m === 0 && h(r, o, c));
     };
-    for (let i = 0; i < 4; i++) {
-      const rectP1 = this.points[i];
-      const rectP2 = this.points[(i + 1) % 4];
-      if (doIntersect(p1, p2, rectP1, rectP2)) {
-        return true;
-      }
-    }
-    if (this.containsLineSegment(line)) {
-      return true;
+    for (let s = 0; s < 4; s++) {
+      const o = this.points[s], r = this.points[(s + 1) % 4];
+      if (i(e, n, o, r))
+        return !0;
     }
-    return false;
+    return !!this.containsLineSegment(t);
   }
   /**
    * 判断线段是否完全位于矩形内部
    * @param line 线段
    * @returns 是否完全在矩形内部
    */
-  containsLineSegment(line) {
-    if (line.points.length !== 2) {
+  containsLineSegment(t) {
+    if (t.points.length !== 2)
       throw new Error("LineSegment must have exactly 2 points");
-    }
-    const isPointInRectangle = (point) => {
-      let sign = 0;
-      for (let i = 0; i < 4; i++) {
-        const p1 = this.points[i];
-        const p2 = this.points[(i + 1) % 4];
-        const edge = { x: p2.x - p1.x, y: p2.y - p1.y };
-        const toPoint = { x: point.x - p1.x, y: point.y - p1.y };
-        const cross = edge.x * toPoint.y - edge.y * toPoint.x;
-        if (cross === 0) {
-          const t = edge.x !== 0 ? (point.x - p1.x) / edge.x : (point.y - p1.y) / edge.y;
-          if (t >= 0 && t <= 1) return true;
+    const e = (n) => {
+      let i = 0;
+      for (let s = 0; s < 4; s++) {
+        const o = this.points[s], r = this.points[(s + 1) % 4], c = { x: r.x - o.x, y: r.y - o.y }, a = { x: n.x - o.x, y: n.y - o.y }, h = c.x * a.y - c.y * a.x;
+        if (h === 0) {
+          const l = c.x !== 0 ? (n.x - o.x) / c.x : (n.y - o.y) / c.y;
+          if (l >= 0 && l <= 1) return !0;
         } else {
-          const currentSign = cross > 0 ? 1 : -1;
-          if (sign === 0) sign = currentSign;
-          if (sign !== currentSign) return false;
+          const l = h > 0 ? 1 : -1;
+          if (i === 0 && (i = l), i !== l) return !1;
         }
       }
-      return true;
+      return !0;
     };
-    return isPointInRectangle(line.points[0]) && isPointInRectangle(line.points[1]);
+    return e(t.points[0]) && e(t.points[1]);
   }
   /**
    * 判断矩形是否与矩形相交
@@ -756,64 +621,53 @@ class Rectangle {
    * @param rectangle 矩形
    * @returns 是否与矩形相交
    */
-  intersectRectangle(rectangle) {
-    const axes = [];
-    for (let i = 0; i < 4; i++) {
-      const p1 = this.points[i];
-      const p2 = this.points[(i + 1) % 4];
-      axes.push(p1.normal(p2));
+  intersectRectangle(t) {
+    const e = [];
+    for (let s = 0; s < 4; s++) {
+      const o = this.points[s], r = this.points[(s + 1) % 4];
+      e.push(o.normal(r));
     }
-    for (let i = 0; i < 4; i++) {
-      const p1 = rectangle.points[i];
-      const p2 = rectangle.points[(i + 1) % 4];
-      axes.push(p1.normal(p2));
+    for (let s = 0; s < 4; s++) {
+      const o = t.points[s], r = t.points[(s + 1) % 4];
+      e.push(o.normal(r));
     }
-    function projectRectangle(rect, axis) {
-      const projections = rect.points.map((point) => point.dot(axis));
-      return [Math.min(...projections), Math.max(...projections)];
+    function n(s, o) {
+      const r = s.points.map((c) => c.dot(o));
+      return [Math.min(...r), Math.max(...r)];
     }
-    function isProjectionOverlap(proj1, proj2) {
-      return proj1[0] < proj2[1] && proj2[0] < proj1[1];
+    function i(s, o) {
+      return s[0] < o[1] && o[0] < s[1];
     }
-    for (const axis of axes) {
-      const proj1 = projectRectangle(this, axis);
-      const proj2 = projectRectangle(rectangle, axis);
-      if (!isProjectionOverlap(proj1, proj2)) {
-        return false;
-      }
+    for (const s of e) {
+      const o = n(this, s), r = n(t, s);
+      if (!i(o, r))
+        return !1;
     }
-    return true;
+    return !0;
   }
   /**
    * 判断点是否完全位于矩形内部
    * @param point 
    */
-  containsPoint(point) {
-    let positiveCount = 0;
-    let negativeCount = 0;
+  containsPoint(t) {
+    let e = 0, n = 0;
     for (let i = 0; i < 4; i++) {
-      const p1 = this.points[i];
-      const p2 = this.points[(i + 1) % 4];
-      const cross = (p2.x - p1.x) * (point.y - p1.y) - (p2.y - p1.y) * (point.x - p1.x);
-      if (cross > 0) positiveCount++;
-      else if (cross < 0) negativeCount++;
-      else return false;
+      const s = this.points[i], o = this.points[(i + 1) % 4], r = (o.x - s.x) * (t.y - s.y) - (o.y - s.y) * (t.x - s.x);
+      if (r > 0) e++;
+      else if (r < 0) n++;
+      else return !1;
     }
-    return positiveCount === 4 || negativeCount === 4;
+    return e === 4 || n === 4;
   }
   /**
    * 
    * @returns 
    */
   toBox() {
-    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-    this.points.forEach((p) => {
-      maxX = Math.max(p.x, maxX);
-      minX = Math.min(p.x, minX);
-      maxY = Math.max(p.x, maxY);
-      minY = Math.min(p.x, minY);
-    });
-    return new Box2(minX, maxX, minY, maxY);
+    let t = 1 / 0, e = -1 / 0, n = 1 / 0, i = -1 / 0;
+    return this.points.forEach((s) => {
+      e = Math.max(s.x, e), t = Math.min(s.x, t), i = Math.max(s.x, i), n = Math.min(s.x, n);
+    }), new v(t, e, n, i);
   }
   /**
    * 
@@ -821,24 +675,22 @@ class Rectangle {
    * @param width 
    * @returns 
    */
-  static fromByLineSegment(line, width = 0.1, horizontal = false, hScale = 0.5) {
-    const p1 = line.points[0], p2 = line.points[1], normal = p2.normal(p1), pDirect = horizontal ? p2.direction(p1).mutiplyScalar(width * hScale) : Point.zero(), nDirect = horizontal ? p1.direction(p2).mutiplyScalar(width * hScale) : Point.zero();
-    const offsetX = normal.x * width * 0.5;
-    const offsetY = normal.y * width * 0.5;
-    return new Rectangle([
-      new Point(p1.x + offsetX, p1.y + offsetY).add(nDirect),
-      new Point(p2.x + offsetX, p2.y + offsetY).add(pDirect),
-      new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect),
-      new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect)
+  static fromByLineSegment(t, e = 0.1, n = !1, i = 0.5) {
+    const s = t.points[0], o = t.points[1], r = o.normal(s), c = n ? o.direction(s).mutiplyScalar(e * i) : f.zero(), a = n ? s.direction(o).mutiplyScalar(e * i) : f.zero(), h = r.x * e * 0.5, l = r.y * e * 0.5;
+    return new O([
+      new f(s.x + h, s.y + l).add(a),
+      new f(o.x + h, o.y + l).add(c),
+      new f(o.x - h, o.y - l).add(c),
+      new f(s.x - h, s.y - l).add(a)
     ]);
   }
 }
-class LineSegment {
-  points = [new Point(), new Point()];
+class b {
+  points = [new f(), new f()];
   userData = {};
   line;
   get center() {
-    return new Point(
+    return new f(
       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
     );
@@ -849,71 +701,84 @@ class LineSegment {
   get end() {
     return this.points[1];
   }
-  constructor(p1 = new Point(), p2 = new Point()) {
-    this.points = [p1, p2];
+  constructor(t = new f(), e = new f()) {
+    this.points = [t, e];
+  }
+  set(t, e) {
+    return this.start.copy(t), this.end.copy(e), this;
+  }
+  /**
+   * 是否有相同端点
+   * @param line 
+   * @returns 
+   */
+  sameEndpoint(t) {
+    return this.start.equal(t.start) || this.start.equal(t.end) || this.end.equal(t.start) || this.end.equal(t.end);
+  }
+  /**
+   * 相同端点是否为开始
+   * @param line 
+   * @returns 
+   */
+  sameEndpointAsStart(t) {
+    return this.start.equal(t.start) || this.start.equal(t.end);
+  }
+  /**
+   * 相同端点是否为结束
+   * @param line 
+   * @returns 
+   */
+  sameEndpointAsEnd(t) {
+    return this.end.equal(t.start) || this.end.equal(t.end);
   }
   /** 膨胀
    * @description 向线段的两个端点分别膨胀 width
    * @param width 
    */
-  expansion(width, direction = "all") {
-    const step = this.direction().multiplyScalar(width);
-    if (direction === "end" || direction === "all") this.end.add(step);
-    if (direction === "start" || direction === "all") this.start.add(step.multiplyScalar(-1));
-    return this;
+  expansion(t, e = "all") {
+    const n = this.direction().multiplyScalar(t);
+    return (e === "end" || e === "all") && this.end.add(n), (e === "start" || e === "all") && this.start.add(n.multiplyScalar(-1)), this;
   }
   /** 向前
    * @description 向前移动 width
    * @param width 
    */
-  forward(width) {
-    const step = this.direction().multiplyScalar(width);
-    this.start.add(step);
-    this.end.add(step);
-    return this;
+  forward(t) {
+    const e = this.direction().multiplyScalar(t);
+    return this.start.add(e), this.end.add(e), this;
   }
   /** 向前
    * @description 向前移动 width
    * @param width 
    */
-  backward(width) {
-    const step = this.direction().multiplyScalar(-width);
-    this.start.add(step);
-    this.end.add(step);
-    return this;
+  backward(t) {
+    const e = this.direction().multiplyScalar(-t);
+    return this.start.add(e), this.end.add(e), this;
   }
   /**
    * 向指定方向平移
    * @param direct 
    * @param size 
    */
-  directionMove(direct, size) {
-    const step = direct.clone().multiplyScalar(size);
-    this.start.add(step);
-    this.end.add(step);
-    return this;
+  directionMove(t, e) {
+    const n = t.clone().multiplyScalar(e);
+    return this.start.add(n), this.end.add(n), this;
   }
   /** 膨胀为矩形
    * 
    * @param width 
    * @returns {Rectangle}
    */
-  expandToRectangle(width = 0.1, direct = "all") {
-    const p1 = this.start, p2 = this.end;
-    const normal = p2.normal(p1);
-    const pDirect = direct === "bothSides" ? Point.zero() : p2.direction(p1).mutiplyScalar(width * 0.5);
-    const nDirect = direct === "bothSides" ? Point.zero() : p1.direction(p2).mutiplyScalar(width * 0.5);
-    const offsetX = normal.x * width * 0.5;
-    const offsetY = normal.y * width * 0.5;
-    const point = [
+  expandToRectangle(t = 0.1, e = "all") {
+    const n = this.start, i = this.end, s = i.normal(n), o = e === "bothSides" ? f.zero() : i.direction(n).mutiplyScalar(t * 0.5), r = e === "bothSides" ? f.zero() : n.direction(i).mutiplyScalar(t * 0.5), c = s.x * t * 0.5, a = s.y * t * 0.5, h = [
       // 第一条线
-      new Point(p1.x + offsetX, p1.y + offsetY).add(nDirect),
-      new Point(p2.x + offsetX, p2.y + offsetY).add(pDirect),
+      new f(n.x + c, n.y + a).add(r),
+      new f(i.x + c, i.y + a).add(o),
       // 第二条线
-      new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect),
-      new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect)
+      new f(n.x - c, n.y - a).add(r),
+      new f(i.x - c, i.y - a).add(o)
     ];
-    return new Rectangle([0, 1, 3, 2].map((i) => point[i]));
+    return new O([0, 1, 3, 2].map((l) => h[l]));
   }
   /**
    * 计算线段的长度
@@ -947,50 +812,27 @@ class LineSegment {
    * @param line 要投影的线段
    * @returns 投影并裁剪后的线段
    */
-  projectLineSegment(line) {
-    if (line.points.length !== 2 || this.points.length !== 2) {
+  projectLineSegment(t) {
+    if (t.points.length !== 2 || this.points.length !== 2)
       throw new Error("每条线段必须由两个点定义");
-    }
-    const [p1, p2] = line.points;
-    const [q1, q2] = this.points;
-    const dir = new Point(q2.x - q1.x, q2.y - q1.y);
-    if (dir.x === 0 && dir.y === 0) {
+    const [e, n] = t.points, [i, s] = this.points, o = new f(s.x - i.x, s.y - i.y);
+    if (o.x === 0 && o.y === 0)
       throw new Error("投影目标线段的两个点不能重合");
-    }
-    const projectPoint = (point) => {
-      const pq = new Point(point.x - q1.x, point.y - q1.y);
-      const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
-      const dotProduct = pq.x * dir.x + pq.y * dir.y;
-      const t = dotProduct / dirLengthSquared;
-      const projX = q1.x + t * dir.x;
-      const projY = q1.y + t * dir.y;
-      return new Point(projX, projY);
+    const r = (m) => {
+      const g = new f(m.x - i.x, m.y - i.y), u = o.x * o.x + o.y * o.y, w = (g.x * o.x + g.y * o.y) / u, S = i.x + w * o.x, L = i.y + w * o.y;
+      return new f(S, L);
     };
-    let projP1 = projectPoint(p1);
-    let projP2 = projectPoint(p2);
-    const getT = (point) => {
-      const pq = new Point(point.x - q1.x, point.y - q1.y);
-      const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
-      return (pq.x * dir.x + pq.y * dir.y) / dirLengthSquared;
+    let c = r(e), a = r(n);
+    const h = (m) => {
+      const g = new f(m.x - i.x, m.y - i.y), u = o.x * o.x + o.y * o.y;
+      return (g.x * o.x + g.y * o.y) / u;
     };
-    let t1 = getT(projP1);
-    let t2 = getT(projP2);
-    const clampPoint = (t) => {
-      const clampedT = Math.max(0, Math.min(1, t));
-      const x = q1.x + clampedT * dir.x;
-      const y = q1.y + clampedT * dir.y;
-      return new Point(x, y);
+    let l = h(c), d = h(a);
+    const p = (m) => {
+      const g = Math.max(0, Math.min(1, m)), u = i.x + g * o.x, x = i.y + g * o.y;
+      return new f(u, x);
     };
-    if (t1 < 0 || t1 > 1) {
-      projP1 = clampPoint(t1);
-    }
-    if (t2 < 0 || t2 > 1) {
-      projP2 = clampPoint(t2);
-    }
-    if (projP1.x === projP2.x && projP1.y === projP2.y) {
-      return new LineSegment(projP1, projP1);
-    }
-    return new LineSegment(projP1, projP2);
+    return (l < 0 || l > 1) && (c = p(l)), (d < 0 || d > 1) && (a = p(d)), c.x === a.x && c.y === a.y ? new b(c, c) : new b(c, a);
   }
   /**
    * 计算一条线段在另一条直线上的投影
@@ -998,155 +840,107 @@ class LineSegment {
    * @param clip 是否裁剪超出目标线段的部分，默认裁剪
    * @returns 投影并裁剪后的线段
    */
-  projectPoint(p1, clip = true) {
-    const [q1, q2] = this.points;
-    const dir = new Point(q2.x - q1.x, q2.y - q1.y);
-    if (dir.x === 0 && dir.y === 0) {
+  projectPoint(t, e = !0) {
+    const [n, i] = this.points, s = new f(i.x - n.x, i.y - n.y);
+    if (s.x === 0 && s.y === 0)
       throw new Error("投影目标线段的两个点不能重合");
-    }
-    const projectPoint = (point) => {
-      const pq = new Point(point.x - q1.x, point.y - q1.y);
-      const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
-      const dotProduct = pq.x * dir.x + pq.y * dir.y;
-      const t = dotProduct / dirLengthSquared;
-      const projX = q1.x + t * dir.x;
-      const projY = q1.y + t * dir.y;
-      return new Point(projX, projY);
-    };
-    let projP1 = projectPoint(p1);
-    if (!clip) return projP1;
-    const getT = (point) => {
-      const pq = new Point(point.x - q1.x, point.y - q1.y);
-      const dirLengthSquared = dir.x * dir.x + dir.y * dir.y;
-      return (pq.x * dir.x + pq.y * dir.y) / dirLengthSquared;
-    };
-    let t1 = getT(projP1);
-    if (t1 < 0 || t1 > 1) {
-      return null;
-    }
-    return projP1;
+    let r = ((h) => {
+      const l = new f(h.x - n.x, h.y - n.y), d = s.x * s.x + s.y * s.y, m = (l.x * s.x + l.y * s.y) / d, g = n.x + m * s.x, u = n.y + m * s.y;
+      return new f(g, u);
+    })(t);
+    if (!e) return r;
+    let a = ((h) => {
+      const l = new f(h.x - n.x, h.y - n.y), d = s.x * s.x + s.y * s.y;
+      return (l.x * s.x + l.y * s.y) / d;
+    })(r);
+    return a < 0 || a > 1 ? null : r;
   }
   /**
    * 判断线段是否与另一条线段相交（包含共用端点或部分重合的情况）
    * @param line 
    */
-  intersectLineSegment(line) {
-    const p1 = this.start;
-    const p2 = this.end;
-    const p3 = line.start;
-    const p4 = line.end;
-    function crossProduct(a, b, c) {
-      return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
-    }
-    function isPointOnSegment(pt, segStart, segEnd) {
-      return Math.min(segStart.x, segEnd.x) - 1e-10 <= pt.x && pt.x <= Math.max(segStart.x, segEnd.x) + 1e-10 && Math.min(segStart.y, segEnd.y) - 1e-10 <= pt.y && pt.y <= Math.max(segStart.y, segEnd.y) + 1e-10;
-    }
-    const d1 = crossProduct(p1, p2, p3);
-    const d2 = crossProduct(p1, p2, p4);
-    const d3 = crossProduct(p3, p4, p1);
-    const d4 = crossProduct(p3, p4, p2);
-    if (d1 * d2 < 0 && d3 * d4 < 0) {
-      return true;
+  intersectLineSegment(t) {
+    const e = this.start, n = this.end, i = t.start, s = t.end;
+    function o(d, p, m) {
+      return (p.x - d.x) * (m.y - d.y) - (p.y - d.y) * (m.x - d.x);
     }
-    if (Math.abs(d1) < 1e-10 && isPointOnSegment(p3, p1, p2)) {
-      return true;
+    function r(d, p, m) {
+      return Math.min(p.x, m.x) - 1e-10 <= d.x && d.x <= Math.max(p.x, m.x) + 1e-10 && Math.min(p.y, m.y) - 1e-10 <= d.y && d.y <= Math.max(p.y, m.y) + 1e-10;
     }
-    if (Math.abs(d2) < 1e-10 && isPointOnSegment(p4, p1, p2)) {
-      return true;
-    }
-    if (Math.abs(d3) < 1e-10 && isPointOnSegment(p1, p3, p4)) {
-      return true;
-    }
-    if (Math.abs(d4) < 1e-10 && isPointOnSegment(p2, p3, p4)) {
-      return true;
-    }
-    return false;
+    const c = o(e, n, i), a = o(e, n, s), h = o(i, s, e), l = o(i, s, n);
+    return !!(c * a < 0 && h * l < 0 || Math.abs(c) < 1e-10 && r(i, e, n) || Math.abs(a) < 1e-10 && r(s, e, n) || Math.abs(h) < 1e-10 && r(e, i, s) || Math.abs(l) < 1e-10 && r(n, i, s));
   }
   /**
    * 获取交点
    * @param line 
    * @returns 
    */
-  getIntersection(line) {
-    const p1 = this.start;
-    const p2 = this.end;
-    const p3 = line.start;
-    const p4 = line.end;
-    const denom = (p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x);
-    if (Math.abs(denom) < 1e-10) {
+  getIntersection(t) {
+    const e = this.start, n = this.end, i = t.start, s = t.end, o = (e.x - n.x) * (i.y - s.y) - (e.y - n.y) * (i.x - s.x);
+    if (Math.abs(o) < 1e-10)
       return null;
-    }
-    const t = ((p1.x - p3.x) * (p3.y - p4.y) - (p1.y - p3.y) * (p3.x - p4.x)) / denom;
-    const x = p1.x + t * (p2.x - p1.x);
-    const y = p1.y + t * (p2.y - p1.y);
-    return new Point(x, y);
+    const r = ((e.x - i.x) * (i.y - s.y) - (e.y - i.y) * (i.x - s.x)) / o, c = e.x + r * (n.x - e.x), a = e.y + r * (n.y - e.y);
+    return new f(c, a);
   }
   /**
    * 获取两条线段夹角
    * @param line 
    */
-  includedAngle(line) {
-    const d1 = this.direction(), d2 = line.direction();
-    return d1.angleBetween(d2) / (Math.PI / 180);
+  includedAngle(t) {
+    const e = this.direction(), n = t.direction();
+    return e.angleBetween(n) / (Math.PI / 180);
   }
   /**
    * 两条线段方向是否一致
    * @param line 
    */
-  directionEqual(line, errAngle = 0.1) {
-    return this.includedAngle(line) < errAngle;
+  directionEqual(t, e = 0.1) {
+    return this.includedAngle(t) < e;
   }
   /**
    * 两条线段方向相反否一致
    * @param line 
    */
-  directionOpposite(line, errAngle = 0.1) {
-    return 180 - this.includedAngle(line) < errAngle;
+  directionOpposite(t, e = 0.1) {
+    return 180 - this.includedAngle(t) < e;
   }
   /**
    * 判断两条线是否平行
    * @param line 
    */
-  isParallel(line, errAngle = 4) {
-    const angle = this.includedAngle(line);
-    return angle < errAngle || angle > 180 - errAngle;
+  isParallel(t, e = 4) {
+    const n = this.includedAngle(t);
+    return n < e || n > 180 - e;
   }
   /**
    * 判断两条直线是否重合
    * @param line 
    * @returns 
    */
-  areLinesCoincident(line) {
-    const p1 = this.start, p2 = this.end, p3 = line.start, p4 = line.end;
-    const m1 = (p2.y - p1.y) / (p2.x - p1.x);
-    const b1 = p1.y - m1 * p1.x;
-    const m2 = (p4.y - p3.y) / (p4.x - p3.x);
-    const b2 = p3.y - m2 * p3.x;
-    if (!isFinite(m1) && !isFinite(m2)) {
-      return p1.x === p3.x && p2.x === p3.x;
-    }
-    return Math.abs(m1 - m2) < 1e-3 && Math.abs(b1 - b2) < 1e-3;
+  areLinesCoincident(t) {
+    const e = this.start, n = this.end, i = t.start, s = t.end, o = (n.y - e.y) / (n.x - e.x), r = e.y - o * e.x, c = (s.y - i.y) / (s.x - i.x), a = i.y - c * i.x;
+    return !isFinite(o) && !isFinite(c) ? e.x === i.x && n.x === i.x : Math.abs(o - c) < 1e-3 && Math.abs(r - a) < 1e-3;
   }
   clone() {
-    return new LineSegment(
+    const t = new b(
       this.points[0].clone(),
       this.points[1].clone()
     );
+    return t.userData = { ...this.userData }, t;
   }
 }
-async function include(path, exportDefault = true) {
-  if (typeof global !== "undefined" && typeof require !== "undefined") {
-    return require(path);
-  } else {
-    let pack = await import(
+async function G(y, t = !0) {
+  if (typeof global < "u" && typeof require < "u")
+    return require(y);
+  {
+    let e = await import(
       /* @vite-ignore */
-      path
+      y
     );
-    if (exportDefault) pack = pack.default;
-    return pack;
+    return t && (e = e.default), e;
   }
 }
-const units = {
+const st = {
   Unitless: 1,
   // 无单位，1米 = 1（无单位）
   Inches: 39.37007874015748,
@@ -1190,31 +984,27 @@ const units = {
   Parsecs: 3240779289666404e-32
   // 秒差距，1米 ≈ 0.00000000000000003240779289666404秒差距
 };
-function pathToLines(path) {
-  const lineSegments = [];
-  for (let i = 0; i < path.length; i++) {
-    lineSegments.push(new LineSegment(
-      path[i].clone(),
-      path[(i + 1) % path.length].clone()
+function k(y) {
+  const t = [];
+  for (let e = 0; e < y.length; e++)
+    t.push(new b(
+      y[e].clone(),
+      y[(e + 1) % y.length].clone()
     ));
-  }
-  return lineSegments;
+  return t;
 }
-function linesToPath(lineSegments) {
-  return lineSegments.flatMap((line, index2) => {
-    if (index2 === lineSegments.length - 1) [...line.points, lineSegments[0].points[0]];
-    return [line.points[0]];
-  });
+function J(y) {
+  return y.flatMap((t, e) => (e === y.length - 1 && [...t.points, y[0].points[0]], [t.points[0]]));
 }
-class Dxf extends Component {
+class X extends j {
   static name = "Dxf";
   shortLine = 0.04;
   width = 0.04;
   scale = 1;
   originalData = [];
   data = [];
-  originalBox = new Box2(0, 0, 0, 0);
-  box = new Box2(0, 0, 0, 0);
+  originalBox = new v(0, 0, 0, 0);
+  box = new v(0, 0, 0, 0);
   pointsGroups = [];
   wallsGroup = [];
   doors = [];
@@ -1243,11 +1033,8 @@ class Dxf extends Component {
    * @param width 墙体宽度
    * @param scale 缩放比例
    */
-  constructor(width = 0.04, scale = 1) {
-    super();
-    this.width = width;
-    this.scale = scale;
-    this.shortLine = width * 0.4;
+  constructor(t = 0.04, e = 1) {
+    super(), this.width = t, this.scale = e, this.shortLine = t * 0.4;
   }
   /**
    * 设置
@@ -1255,52 +1042,36 @@ class Dxf extends Component {
    * @param width 
    * @param scale 
    */
-  async set(data, width = this.width, scale = this.scale) {
-    if (typeof data === "string") {
-      if (typeof global !== "undefined") {
-        const packageName = "fs";
-        const { default: fs } = await import(
+  async set(t, e = this.width, n = this.scale) {
+    if (typeof t == "string")
+      if (typeof global < "u") {
+        const { default: o } = await import(
           /* @vite-ignore */
-          packageName
-        );
-        const buffer = fs.readFileSync(data);
-        const json = JSON.parse(buffer.toString("utf-8"));
-        return this.set(json, width, scale);
-      } else {
+          "fs"
+        ), r = o.readFileSync(t), c = JSON.parse(r.toString("utf-8"));
+        return this.set(c, e, n);
+      } else
         throw new Error("非node环境不允许使用路径");
-      }
-    }
-    this.scale = scale;
-    this.width = width;
-    this.originalData = data;
-    this.lineSegments.length = 0;
-    const zList = [];
-    this.data = data.map(({ start, end, insetionArr, isDoor = false, isWindow, drawDoorData }, index2) => {
-      zList.push(start.z ?? 0, end.z ?? 0);
-      const lineSegment = new LineSegment(
-        Point.from(start).mutiplyScalar(scale),
-        Point.from(end).mutiplyScalar(scale)
+    this.scale = n, this.width = e, this.originalData = t, this.lineSegments.length = 0;
+    const i = [];
+    this.data = t.map(({ start: s, end: o, insetionArr: r, isDoor: c = !1, ...a }, h) => {
+      i.push(s.z ?? 0, o.z ?? 0);
+      const l = new b(
+        f.from(s).mutiplyScalar(n),
+        f.from(o).mutiplyScalar(n)
       );
-      lineSegment.userData = { isDoor, isWindow, drawDoorData };
-      this.lineSegments.push(lineSegment);
-      return [
-        lineSegment.points[0],
-        lineSegment.points[1],
-        (insetionArr ?? []).map((i) => i.index),
-        isDoor,
-        index2
+      return l.userData = { isDoor: c, ...a }, this.lineSegments.push(l), [
+        l.points[0],
+        l.points[1],
+        (r ?? []).map((d) => d.index),
+        c,
+        h
       ];
-    });
-    this.originalZAverage = zList.reduce((count, num) => count + num, 0) / zList.length;
-    this.computedOriginalSize(data, this.originalBox);
-    this.dispatchEvent({
+    }), this.originalZAverage = i.reduce((s, o) => s + o, 0) / i.length, this.computedOriginalSize(t, this.originalBox), this.dispatchEvent({
       type: "setDta",
       originalData: this.originalData,
       data: this.data
-    });
-    this.createGroups();
-    this.computedSize();
-    this.dispatchEvent({
+    }), this.createGroups(), this.computedSize(), this.dispatchEvent({
       type: "createGroup",
       groups: this.pointsGroups
     });
@@ -1310,32 +1081,20 @@ class Dxf extends Component {
    * @returns 
    */
   createGroups() {
-    const groups = [], visited = /* @__PURE__ */ new Set(), doorSet = /* @__PURE__ */ new Set(), doorVisitedRecord = /* @__PURE__ */ new Map();
-    const dfs = (index2, group, preIndex = -1) => {
-      const [start, end, insetionArr, isDoor] = this.data[index2];
-      visited.add(index2);
-      if (isDoor) {
-        if (!doorVisitedRecord.has(index2)) doorVisitedRecord.set(index2, []);
-        doorVisitedRecord.get(index2)?.push(preIndex);
-        return doorSet.add(this.data[index2]);
-      }
-      group.push([start, end]);
-      insetionArr.forEach((i) => {
-        if (!visited.has(i)) {
-          dfs(i, group, index2);
-        }
+    const t = [], e = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map(), s = (o, r, c = -1) => {
+      const [a, h, l, d] = this.data[o];
+      if (e.add(o), d)
+        return i.has(o) || i.set(o, []), i.get(o)?.push(c), n.add(this.data[o]);
+      r.push([a, h]), l.forEach((p) => {
+        e.has(p) || s(p, r, o);
       });
     };
-    this.data.forEach((_, index2) => {
-      if (!visited.has(index2)) {
-        const group = [];
-        dfs(index2, group);
-        groups.push(group);
+    return this.data.forEach((o, r) => {
+      if (!e.has(r)) {
+        const c = [];
+        s(r, c), t.push(c);
       }
-    });
-    this.doors = [...doorSet];
-    this.pointsGroups = groups;
-    return groups;
+    }), this.doors = [...n], this.pointsGroups = t, t;
   }
   /** 计算当前墙体数据的边界框
    * @description 根据分组数据pointsGroups，计算包围盒， pointsGroups数据为缩放后数据。
@@ -1343,224 +1102,163 @@ class Dxf extends Component {
    * @returns 
    */
   computedSize() {
-    const xArr = this.pointsGroups.flatMap((points) => points.flatMap((p) => [p[0].x, p[1].x]));
-    const yArr = this.pointsGroups.flatMap((points) => points.flatMap((p) => [p[0].y, p[1].y]));
-    const minX = Math.min(...xArr);
-    const minY = Math.min(...yArr);
-    const maxX = Math.max(...xArr);
-    const maxY = Math.max(...yArr);
-    this.box.set(minX, minY, maxX, maxY);
-    return this.box;
+    const t = this.pointsGroups.flatMap((r) => r.flatMap((c) => [c[0].x, c[1].x])), e = this.pointsGroups.flatMap((r) => r.flatMap((c) => [c[0].y, c[1].y])), n = Math.min(...t), i = Math.min(...e), s = Math.max(...t), o = Math.max(...e);
+    return this.box.set(n, i, s, o), this.box;
   }
   /** 线路拓扑
    * @description 处理线路拓扑，使线路有序链接，形成长路径
    * @param lines 
    */
-  lineTopology(lines) {
-    const visited = [];
-    function dfs(index2, linePath) {
-      const [_0, a2] = lines[index2];
-      visited[index2] = true;
-      linePath.push(a2);
-      for (let i = 0; i < lines.length; i++) {
-        const [b1, _1] = lines[i];
-        if (!visited[i]) {
-          if (Math.abs(a2.x - b1.x) < 1e-6 && Math.abs(a2.y - b1.y) < 1e-6) {
-            return dfs(i, linePath);
-          }
-        }
+  lineTopology(t) {
+    const e = [];
+    function n(s, o) {
+      const [r, c] = t[s];
+      e[s] = !0, o.push(c);
+      for (let a = 0; a < t.length; a++) {
+        const [h, l] = t[a];
+        if (!e[a] && Math.abs(c.x - h.x) < 1e-6 && Math.abs(c.y - h.y) < 1e-6)
+          return n(a, o);
       }
     }
-    const linePaths = [];
-    for (let i = 0; i < lines.length; i++) {
-      if (!visited[i]) {
-        const linePath = [lines[i][0]];
-        dfs(i, linePath);
-        linePaths.push(linePath);
+    const i = [];
+    for (let s = 0; s < t.length; s++)
+      if (!e[s]) {
+        const o = [t[s][0]];
+        n(s, o), i.push(o);
       }
-    }
-    return linePaths;
+    return i;
   }
   /** 合并方向相同的线段
    * @param lines 
    * @param errAngle 
    */
-  mergeSameDirectionLine(lines, errAngle = 3) {
-    if (lines[0].includedAngle(lines[lines.length - 1]) < 0.1) {
-      const line = lines.pop();
-      line.end.copy(lines[0].end);
-      lines.splice(0, 1, line);
+  mergeSameDirectionLine(t, e = 3) {
+    if (t[0].includedAngle(t[t.length - 1]) < 0.1) {
+      const i = t.pop();
+      i.end.copy(t[0].end), t.splice(0, 1, i);
     }
-    const filterLines = [lines[0]];
-    for (let i = 1; i < lines.length; i++) {
-      const line = lines[i];
-      const preLine = lines[i - 1];
-      if (preLine.includedAngle(line) < errAngle) {
-        preLine.end.copy(line.end);
-      } else {
-        filterLines.push(line);
-      }
+    const n = [t[0]];
+    for (let i = 1; i < t.length; i++) {
+      const s = t[i], o = t[i - 1];
+      o.includedAngle(s) < e ? o.end.copy(s.end) : n.push(s);
     }
-    return filterLines;
+    return n;
   }
   /** etOpenRound 去除毛刺
    * @description 检查连续的短线段数量，去除合并后产生的毛刺
    */
-  squareRemoveBurr(path) {
-    if (path.length < 3) return path;
-    const filterLines = [path[0]];
-    for (let i = 1; i < path.length; i++) {
-      const prev = path[i - 1];
-      const curr = path[i];
-      const len = prev.distance(curr);
-      if (len < this.width * 0.5) {
-        let count = 0;
-        for (let j = i + 1; j < path.length; j++) {
-          const prev2 = path[j - 1];
-          const curr2 = path[j];
-          const len2 = prev2.distance(curr2);
-          if (len2 < this.width * 0.8) count++;
+  squareRemoveBurr(t) {
+    if (t.length < 3) return t;
+    const e = [t[0]];
+    for (let n = 1; n < t.length; n++) {
+      const i = t[n - 1], s = t[n];
+      if (i.distance(s) < this.width * 0.5) {
+        let r = 0;
+        for (let c = n + 1; c < t.length; c++) {
+          const a = t[c - 1], h = t[c];
+          if (a.distance(h) < this.width * 0.8) r++;
           else break;
         }
-        if (count === 0 && i + count === path.length - 1) ;
-        else if (i == 1 && count === 1) ;
-        else if (count === 3) {
-          filterLines.push(path[i + 1]);
-          i += count;
-        } else if (count === 5) {
-          filterLines.push(path[i + 2]);
-          i += count;
-        } else {
-          filterLines.push(curr);
-        }
-      } else {
-        filterLines.push(curr);
-      }
+        r === 0 && n + r === t.length - 1 || n == 1 && r === 1 || (r === 3 ? (e.push(t[n + 1]), n += r) : r === 5 ? (e.push(t[n + 2]), n += r) : e.push(s));
+      } else
+        e.push(s);
     }
-    return filterLines;
+    return e;
   }
   /**
    * 线段矫直, 线段中心突刺
    * @description 突变长度小于墙体宽度，该线段可能为突起线段，
    * @description 判断后续第2线段与上一条线段是否方向相同，相同就为突刺
    */
-  lineSegmentStraightening(path) {
-    for (let i = 0; i < path.length; i++) {
-      const p1 = path[i];
-      const p2 = path[(i + 1) % path.length];
-      if (p1.distance(p2) > this.shortLine) {
-        path.push(...path.slice(0, i + 1));
-        path.splice(0, i + 1);
+  lineSegmentStraightening(t) {
+    for (let i = 0; i < t.length; i++) {
+      const s = t[i], o = t[(i + 1) % t.length];
+      if (s.distance(o) > this.shortLine) {
+        t.push(...t.slice(0, i + 1)), t.splice(0, i + 1);
         break;
       }
     }
-    const lines = this.mergeSameDirectionLine(pathToLines(path)), filterLines = [lines[0]];
-    for (let i = 1; i < lines.length; i++) {
-      const line = lines[i];
-      const preLine = lines[(lines.length + i - 1) % lines.length];
-      if (line.length() > this.width * 0.9) {
-        filterLines.push(line);
+    const e = this.mergeSameDirectionLine(k(t)), n = [e[0]];
+    for (let i = 1; i < e.length; i++) {
+      const s = e[i], o = e[(e.length + i - 1) % e.length];
+      if (s.length() > this.width * 0.9) {
+        n.push(s);
         continue;
       }
-      const line1 = lines[i + 1];
-      if (line1 && line1.length() > this.width * 0.9) {
-        filterLines.push(line);
-        filterLines.push(line1);
-        i = i + 1;
+      const r = e[i + 1];
+      if (r && r.length() > this.width * 0.9) {
+        n.push(s), n.push(r), i = i + 1;
         continue;
       }
-      const line2 = lines[i + 2];
-      if (line2 && preLine.includedAngle(line2) < 2) {
-        i = i + 2;
-        filterLines.push(line2);
-      } else filterLines.push(line);
+      const c = e[i + 2];
+      c && o.includedAngle(c) < 2 ? (i = i + 2, n.push(c)) : n.push(s);
     }
-    return filterLines.length > 3 ? linesToPath(this.mergeSameDirectionLine(filterLines)) : [];
+    return n.length > 3 ? J(this.mergeSameDirectionLine(n)) : [];
   }
   /**
    * 移除短线段
    * @todo 根据线段两端线段长度，选取参照物_|▔▔
    * @param path 
    */
-  removeShortLine(path, shortLine = this.shortLine) {
-    const lines = pathToLines(path), filterLines = [], PI_1 = Math.PI / 180;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i], len = line.length(), currentIndex = i;
-      if (len > shortLine || filterLines.length === 0) {
-        filterLines.push(line);
+  removeShortLine(t, e = this.shortLine) {
+    const n = k(t), i = [], s = Math.PI / 180;
+    for (let o = 0; o < n.length; o++) {
+      const r = n[o], c = r.length(), a = o;
+      if (c > e || i.length === 0) {
+        i.push(r);
         continue;
       }
-      let nextline = lines[++i];
-      const preLine = filterLines[filterLines.length - 1], d1 = preLine.direction();
-      while (i < lines.length) {
-        const angle = d1.angleBetween(nextline.direction()) / PI_1;
-        if (nextline.length() <= shortLine || angle < 4 || angle > 180 - 4) {
-          nextline = lines[++i];
-        } else break;
-      }
-      if (!nextline) continue;
-      const targetLine = lines[i - 1];
-      if (preLine.length() > targetLine.length()) {
-        const intersectPoint = preLine.getIntersection(nextline);
-        if (intersectPoint) {
-          const p0 = preLine.points[1].clone(), p1 = nextline.points[0].clone();
-          preLine.points[1].copy(intersectPoint);
-          nextline.points[0].copy(intersectPoint);
-          if (preLine.length() < this.width) {
-            preLine.points[1].copy(p0);
-            nextline.points[0].copy(p0);
-          } else if (nextline.length() < this.width) {
-            preLine.points[1].copy(p1);
-            nextline.points[0].copy(p1);
-          }
-        } else {
-          preLine.points[1].copy(nextline.points[0]);
-        }
-        filterLines.push(nextline);
-      } else {
-        i = currentIndex;
+      let h = n[++o];
+      const l = i[i.length - 1], d = l.direction();
+      for (; o < n.length; ) {
+        const m = d.angleBetween(h.direction()) / s;
+        if (h.length() <= e || m < 4 || m > 176)
+          h = n[++o];
+        else break;
       }
-    }
-    return filterLines.length > 3 ? linesToPath(filterLines) : [];
+      if (!h) continue;
+      const p = n[o - 1];
+      if (l.length() > p.length()) {
+        const m = l.getIntersection(h);
+        if (m) {
+          const g = l.points[1].clone(), u = h.points[0].clone();
+          l.points[1].copy(m), h.points[0].copy(m), l.length() < this.width ? (l.points[1].copy(g), h.points[0].copy(g)) : h.length() < this.width && (l.points[1].copy(u), h.points[0].copy(u));
+        } else
+          l.points[1].copy(h.points[0]);
+        i.push(h);
+      } else
+        o = a;
+    }
+    return i.length > 3 ? J(i) : [];
   }
   /** 线偏移
    * @description 使用 ClipperLib 对每个点组进行线偏移处理，生成具有指定宽度的墙体路径
    */
-  lineOffset(endType = Dxf.EndType.etOpenSquare, joinType = Dxf.JoinType.jtMiter, scale = 1e4) {
-    let solutions = new ClipperLib.Paths();
-    const offset = new ClipperLib.ClipperOffset(20, 0.25);
-    this.pointsGroups.forEach((points) => {
-      const linePaths = this.lineTopology(points).map((linePath) => linePath.map((p) => p.clone().mutiplyScalar(scale)));
-      offset.AddPaths(linePaths, joinType, endType);
-    });
-    offset.Execute(solutions, this.width / 2 * scale);
-    this.wallsGroup = solutions.map((ps) => {
-      let path = ps.map((p) => Point.from(p).divisionScalar(scale));
-      path = this.lineSegmentStraightening(path);
-      if (endType == Dxf.EndType.etOpenSquare) path = this.squareRemoveBurr(path);
-      path = this.removeShortLine(path);
-      return path;
-    });
-    this.dispatchEvent({
+  lineOffset(t = X.EndType.etOpenSquare, e = X.JoinType.jtMiter, n = 1e4) {
+    let i = new F.Paths();
+    const s = new F.ClipperOffset(20, 0.25);
+    return this.pointsGroups.forEach((o) => {
+      const r = this.lineTopology(o).map((c) => c.map((a) => a.clone().mutiplyScalar(n)));
+      s.AddPaths(r, e, t);
+    }), s.Execute(i, this.width / 2 * n), this.wallsGroup = i.map((o) => {
+      let r = o.map((c) => f.from(c).divisionScalar(n));
+      return r = this.lineSegmentStraightening(r), t == X.EndType.etOpenSquare && (r = this.squareRemoveBurr(r)), r = this.removeShortLine(r), r;
+    }), this.dispatchEvent({
       type: "lineOffset",
       wallsGroup: this.wallsGroup
-    });
-    return this.wallsGroup;
+    }), this.wallsGroup;
   }
   /**
    * 将点云结构转换为Float32Array
    */
-  to3DArray(scale, z = this.originalZAverage) {
-    const array = [];
-    this.wallsGroup.forEach((points) => {
-      for (let i = 0; i < points.length; i++) {
-        const point1 = points[i];
-        const nextIndex = i === points.length - 1 ? 0 : i + 1;
-        const point2 = points[nextIndex];
-        array.push(point1.X * scale, point1.Y * scale, z, point2.X * scale, point2.Y * scale, z);
+  to3DArray(t, e = this.originalZAverage) {
+    const n = [];
+    return this.wallsGroup.forEach((i) => {
+      for (let s = 0; s < i.length; s++) {
+        const o = i[s], r = s === i.length - 1 ? 0 : s + 1, c = i[r];
+        n.push(o.X * t, o.Y * t, e, c.X * t, c.Y * t, e);
       }
-    });
-    return new Float32Array(array);
+    }), new Float32Array(n);
   }
   /** 获取角度范围
    * @param center 
@@ -1568,196 +1266,273 @@ class Dxf extends Component {
    * @param p2 
    * @returns 
    */
-  getArcAngleRange(center, p1, p2) {
-    const x1 = p1.x - center.x;
-    const y1 = p1.y - center.y;
-    const x2 = p2.x - center.x;
-    const y2 = p2.y - center.y;
-    let angle1 = Math.atan2(y1, x1);
-    let angle2 = Math.atan2(y2, x2);
-    angle1 = angle1 < 0 ? angle1 + 2 * Math.PI : angle1;
-    angle2 = angle2 < 0 ? angle2 + 2 * Math.PI : angle2;
-    let r1, r2;
-    const diff = Math.abs(angle2 - angle1);
-    if (diff <= Math.PI) {
-      r1 = Math.min(angle1, angle2);
-      r2 = Math.max(angle1, angle2);
-    } else {
-      r1 = Math.max(angle1, angle2);
-      r2 = Math.min(angle1, angle2) + 2 * Math.PI;
-    }
-    return [r1 / (Math.PI / 180), r2 / (Math.PI / 180)];
-  }
-  /**
-   * 将点云结构转换为string
-   */
-  toDxfString(unit = "Millimeters") {
-    const d = new Drawing();
-    d.setUnits("Millimeters");
-    const s = units[unit];
-    function drawLine(p1, p2) {
-      d.drawLine(p1.X * s, p1.Y * s, p2.X * s, p2.Y * s);
+  getArcAngleRange(t, e, n) {
+    const i = e.x - t.x, s = e.y - t.y, o = n.x - t.x, r = n.y - t.y;
+    let c = Math.atan2(s, i), a = Math.atan2(r, o);
+    c = c < 0 ? c + 2 * Math.PI : c, a = a < 0 ? a + 2 * Math.PI : a;
+    let h, l;
+    return Math.abs(a - c) <= Math.PI ? (h = Math.min(c, a), l = Math.max(c, a)) : (h = Math.max(c, a), l = Math.min(c, a) + 2 * Math.PI), [h / (Math.PI / 180), l / (Math.PI / 180)];
+  }
+  /**
+   * 转为绘制数据
+   */
+  toDrawDataJson(t = "Millimeters") {
+    const e = st[t], n = {
+      unit: t,
+      line: [],
+      arc: [],
+      dimensionLine: [],
+      center: this.box.center.toJson(),
+      width: this.box.width * e,
+      height: this.box.height * e,
+      scale: e
+    };
+    let i = "white";
+    function s(a, h) {
+      n.line.push([a.X * e, a.Y * e, h.X * e, h.Y * e, i]);
+    }
+    function o(a, h, l, d) {
+      n.arc.push([
+        a.x * e,
+        a.y * e,
+        h * e,
+        l,
+        d,
+        i
+      ]);
+    }
+    for (let a = 0; a < this.originalData.length; a++) {
+      const h = this.originalData[a];
+      if (h.isVerticalReferenceLine) {
+        n.dimensionLine.push([h.start.x * e, h.start.y * e, h.end.x * e, h.end.y * e]);
+        break;
+      }
     }
-    this.wallsGroup.forEach((points) => {
-      for (let i = 0; i < points.length; i++) {
-        const point1 = points[i];
-        const nextIndex = i === points.length - 1 ? 0 : i + 1;
-        const point2 = points[nextIndex];
-        drawLine(point1, point2);
+    this.wallsGroup.forEach((a) => {
+      for (let h = 0; h < a.length; h++) {
+        const l = a[h], d = h === a.length - 1 ? 0 : h + 1, p = a[d];
+        s(l, p);
       }
     });
-    const doorThickness = this.width * 0.2;
-    const list = [];
-    d.addLayer("l_cyan", Drawing.ACI.CYAN, "DOTTED");
-    this.doorLineSegment.forEach((lineSegment) => {
-      if (lineSegment.length() < 0.4) return;
-      const line = lineSegment.clone().expansion(-this.width * 0.5);
-      d.setActiveLayer("l_cyan");
-      if (line.length() < 1.2) {
-        line.expansion(-doorThickness * 0.5);
-        const normal = lineSegment.normal();
-        let door = new LineSegment(
-          line.start.clone(),
-          line.start.clone().add(normal.clone().multiplyScalar(line.length()))
+    const r = this.width * 0.2, c = [];
+    return this.doorLineSegment.forEach((a) => {
+      if (a.length() < 0.4) return;
+      const h = a.clone().expansion(-this.width * 0.5);
+      if (i = "cyan", h.length() < 1.2) {
+        h.expansion(-r * 0.5);
+        const l = a.normal();
+        let d = new b(
+          h.start.clone(),
+          h.start.clone().add(l.clone().multiplyScalar(h.length()))
         );
-        const box = door.clone().directionMove(door.normal(), line.length() * -0.5).expandToRectangle(line.length(), "bothSides");
-        for (let j = 0; j < list.length; j++) {
-          if (list[j].intersectRectangle(box)) {
-            door = new LineSegment(
-              line.start.clone(),
-              line.start.clone().add(normal.clone().multiplyScalar(-line.length()))
+        const p = d.clone().directionMove(d.normal(), h.length() * -0.5).expandToRectangle(h.length(), "bothSides");
+        for (let L = 0; L < c.length; L++)
+          if (c[L].intersectRectangle(p)) {
+            d = new b(
+              h.start.clone(),
+              h.start.clone().add(l.clone().multiplyScalar(-h.length()))
             );
             break;
           }
-        }
-        door.expansion(-doorThickness * 0.5).expandToRectangle(this.width * 0.2, "bothSides").path2D((p1, p2) => drawLine(p1, p2));
-        const a = line.length(), b = door.length(), r = (a ** 2 + b ** 2) / (2 * b), center = door.end.clone().add(door.direction().multiplyScalar(-r)), [startAngle, endAngle] = this.getArcAngleRange(center, line.end, door.end);
-        d.drawArc(center.x * s, center.y * s, r * s, Math.min(startAngle, endAngle), Math.max(startAngle, endAngle));
-        list.push(box);
-      } else {
-        line.clone().expansion(-this.width * 0.5).expandToRectangle(this.width).path2D((p1, p2) => drawLine(p1, p2));
-        line.clone().directionMove(line.normal(), doorThickness * 0.5).directionMove(line.direction(), doorThickness * 0.5).expansion(-line.length() * 0.45, "end").forward(doorThickness * 0.5).expandToRectangle(doorThickness).path2D((p1, p2) => drawLine(p1, p2));
-        line.clone().directionMove(line.normal(), -doorThickness * 0.5).directionMove(line.direction(), -doorThickness * 0.5).expansion(-line.length() * 0.45, "start").forward(-doorThickness * 0.5).expandToRectangle(doorThickness).path2D((p1, p2) => drawLine(p1, p2));
-      }
-    });
-    d.addLayer("l_yellow", Drawing.ACI.YELLOW, "DOTTED");
-    d.setActiveLayer("l_yellow");
-    this.lineSegments.forEach((line) => {
-      if (!line.userData.isWindow) return false;
-      if (Array.isArray(line.userData.drawDoorData)) {
-        line.userData.drawDoorData.forEach((w) => {
-          const { p, width } = w;
-          const center = Point.from(p);
-          const start = center.clone().add(line.direction().multiplyScalar(width * 0.5));
-          const end = center.clone().add(line.direction().multiplyScalar(-width * 0.5));
-          const blinds = new LineSegment(start, end);
-          drawLine(blinds.start, blinds.end);
-          blinds.expandToRectangle(this.width, "bothSides").path2D((p1, p2) => drawLine(p1, p2));
-        });
-      }
-    });
-    return d.toDxfString();
+        d.expansion(-r * 0.5).expandToRectangle(this.width * 0.2, "bothSides").path2D((L, P) => s(L, P));
+        const m = h.length(), g = d.length(), u = (m ** 2 + g ** 2) / (2 * g), x = d.end.clone().add(d.direction().multiplyScalar(-u)), [w, S] = this.getArcAngleRange(x, h.end, d.end);
+        o(x, u, Math.min(w, S), Math.max(w, S)), c.push(p);
+      } else
+        h.clone().expansion(-this.width * 0.5).expandToRectangle(this.width).path2D((l, d) => s(l, d)), h.clone().directionMove(h.normal(), r * 0.5).directionMove(h.direction(), r * 0.5).expansion(-h.length() * 0.45, "end").forward(r * 0.5).expandToRectangle(r).path2D((l, d) => s(l, d)), h.clone().directionMove(h.normal(), -r * 0.5).directionMove(h.direction(), -r * 0.5).expansion(-h.length() * 0.45, "start").forward(-r * 0.5).expandToRectangle(r).path2D((l, d) => s(l, d));
+    }), i = "yellow", this.lineSegments.forEach((a) => {
+      if (!a.userData.isWindow) return !1;
+      Array.isArray(a.userData.drawWindow) && a.userData.drawWindow.forEach((h) => {
+        const { p: l, width: d } = h, p = f.from(l), m = p.clone().add(a.direction().multiplyScalar(d * 0.5)), g = p.clone().add(a.direction().multiplyScalar(-d * 0.5)), u = new b(m, g);
+        s(u.start, u.end), u.expandToRectangle(this.width, "bothSides").path2D((x, w) => s(x, w));
+      });
+    }), n;
+  }
+  /**
+   * 
+   * @param type 
+   */
+  async toDxfImageBlob(t = "Centimeters", e = "image/jpeg", n = "#000") {
+    const i = this.toDrawDataJson(t);
+    let s;
+    if (typeof window < "u")
+      s = document.createElement("canvas");
+    else if (typeof global < "u") {
+      const { createCanvas: a } = await G("canvas");
+      s = a();
+    } else
+      throw new Error("创建画布失败");
+    const o = 2 * i.scale, r = {
+      cyan: "cyan",
+      yellow: "yellow",
+      white: "white"
+    };
+    s.width = i.width + o * 2, s.height = i.height + o * 2;
+    const c = s.getContext("2d");
+    return n && (c.fillStyle = n, c.fillRect(0, 0, s.width, s.height)), c.translate(i.width * 0.5 + o, i.height * 0.5 + o), i.line.forEach(([a, h, l, d, p]) => {
+      c.strokeStyle = r[p], c.beginPath(), c.moveTo(a, h), c.lineTo(l, d), c.closePath(), c.stroke();
+    }), i.arc.forEach(([a, h, l, d, p, m]) => {
+      c.strokeStyle = r[m], c.beginPath(), c.arc(a, h, l, d * (Math.PI / 180), p * (Math.PI / 180)), c.stroke();
+    }), c.beginPath(), i.dimensionLine.forEach((a) => {
+      let [h, l, d, p] = a;
+      const m = Math.min(l, p), g = Math.max(l, p), u = (s.width * 0.5 - 0.4 * i.scale) * (h < 0 ? -1 : 1), x = (g - m) * 0.45;
+      c.fillStyle = "#fff", c.font = `${0.15 * i.scale}px Arial`, c.textAlign = "center", c.textBaseline = "middle", c.fillText((g - m).toFixed(2) + "cm", u, m + (g - m) * 0.5), c.moveTo(u - 0.1 * i.scale, m), c.lineTo(u + 0.1 * i.scale, m), c.moveTo(u, m), c.lineTo(u, x + m), c.moveTo(u, g), c.lineTo(u, g - x), c.moveTo(u - 0.1 * i.scale, g), c.lineTo(u + 0.1 * i.scale, g);
+    }), c.closePath(), c.strokeStyle = "#fff", c.stroke(), "toBlob" in s ? new Promise((a) => {
+      s.toBlob((h) => {
+        a(h);
+      }, e, 1);
+    }) : s.toBuffer(e, { quality: 1 });
+  }
+  /**
+   * 将点json结构转换为Dxf string
+   */
+  toDxfString(t = "Millimeters") {
+    const e = new R();
+    e.setUnits(t), e.addLayer("cyan", R.ACI.CYAN, "DOTTED"), e.addLayer("yellow", R.ACI.YELLOW, "DOTTED"), e.addLayer("white", R.ACI.WHITE, "DOTTED");
+    const n = this.toDrawDataJson();
+    return n.line.forEach((i) => {
+      let [s, o, r, c, a] = i;
+      e.setActiveLayer(a), e.drawLine(s, o, r, c);
+    }), n.arc.forEach((i) => {
+      const [s, o, r, c, a, h] = i;
+      e.setActiveLayer(h), e.drawArc(s, o, r, c, a);
+    }), e.toDxfString();
   }
   /**
    * 将点云结构转换为DXF格式
    * @returns 
    */
-  toDxfBlob(unit = "Millimeters") {
-    const blob = new Blob([this.toDxfString(unit)]);
-    return blob;
+  toDxfBlob(t = "Millimeters") {
+    return new Blob([this.toDxfString(t)]);
   }
   /**
    * 下载
    * @param filename 
    */
-  async download(filename, unit = "Millimeters") {
-    if (typeof window !== "undefined") {
-      const blob = this.toDxfBlob(unit);
-      const a = document.createElement("a");
-      a.href = URL.createObjectURL(blob);
-      a.download = filename + ".dxf";
-      a.click();
-    } else if (typeof global !== "undefined") {
-      const fs = await include("fs", false);
-      fs.writeFileSync(filename, this.toDxfString(unit));
-    }
+  async download(t, e = "Millimeters") {
+    if (typeof window < "u") {
+      const n = this.toDxfBlob(e), i = document.createElement("a");
+      i.href = URL.createObjectURL(n), i.download = t + ".dxf", i.click();
+    } else typeof global < "u" && (await G("fs", !1)).writeFileSync(t, this.toDxfString(e));
+  }
+  /**
+   * 下载
+   * @param filename 
+   */
+  async downloadImage(t, e = "Centimeters", n = "image/jpeg") {
+    const i = await this.toDxfImageBlob(e, n);
+    if (!i) return !1;
+    if (typeof window < "u") {
+      const s = document.createElement("a");
+      s.href = URL.createObjectURL(i), s.download = t, s.click();
+    } else typeof global < "u" ? (await G("fs", !1)).writeFileSync(t, i) : console.error("图片下载失败");
+    return !0;
   }
   /**
    * 计算原始数据的边界框
    * @description 计算所有线段的起点和终点的最小最大值，形成一个边界框
    * @returns 
    */
-  computedOriginalSize(data, originalBox = new Box2(0, 0, 0, 0)) {
-    const xArr = data.flatMap((item) => [item.start.x, item.end.x]);
-    const yArr = data.flatMap((item) => [item.start.y, item.end.y]);
-    const minX = Math.min(...xArr);
-    const minY = Math.min(...yArr);
-    const maxX = Math.max(...xArr);
-    const maxY = Math.max(...yArr);
-    originalBox.set(minX, minY, maxX, maxY);
-    return originalBox;
+  computedOriginalSize(t, e = new v(0, 0, 0, 0)) {
+    const n = t.flatMap((a) => [a.start.x, a.end.x]), i = t.flatMap((a) => [a.start.y, a.end.y]), s = Math.min(...n), o = Math.min(...i), r = Math.max(...n), c = Math.max(...i);
+    return e.set(s, o, r, c), e;
   }
   /**
    * 创建数据
    * @param pointsGroups 
    * @returns 
    */
-  static createData(pointsGroups, sealed = true) {
-    let count = 0;
-    const data = pointsGroups.flatMap((points) => {
-      const lines = points.map((point, index2) => {
-        const nextIndex = index2 === points.length - 1 ? 0 : index2 + 1;
-        const nextPoint = points[nextIndex];
+  static createData(t, e = !0) {
+    let n = 0;
+    return t.flatMap((s) => {
+      const o = s.map((r, c) => {
+        const a = c === s.length - 1 ? 0 : c + 1, h = s[a];
         return {
-          start: { x: point.x, y: point.y },
-          end: { x: nextPoint.x, y: nextPoint.y },
+          start: { x: r.x, y: r.y },
+          end: { x: h.x, y: h.y },
           insetionArr: [
             {
-              index: nextIndex + count
+              index: a + n
             }
           ]
         };
       });
-      count += points.length;
-      if (!sealed) {
-        lines.pop();
-        lines[lines.length - 1].insetionArr.length = 0;
-        count--;
+      return n += s.length, e || (o.pop(), o[o.length - 1].insetionArr.length = 0, n--), o;
+    });
+  }
+}
+const I = new b();
+class ot extends X {
+  static name = "AngleCorrectionDxf";
+  onAddFromParent(t) {
+    t.findComponentByName("LineAnalysis").addEventListener("analysisCompleted", async () => this.update());
+  }
+  async update() {
+    const t = this.parent, e = t.findComponentByName("Dxf"), n = t.findComponentByName("LineAnalysis");
+    let i = 0, s = null;
+    for (let a = 0; a < e.originalData.length; a++) {
+      const h = e.originalData[a];
+      if (I.start.copy(h.start), I.end.copy(h.end), h.isVerticalReferenceLine) {
+        const [l, d] = h.start.y < h.end.y ? [I.start, I.end] : [I.end, I.start];
+        i = -new b(l, d).direction().angleBetween(new f(0, 1), "angle", "360"), s = null;
+        break;
       }
-      return lines;
+      (!s || I.length() > s.length()) && (s = I.clone(), s.userData.index = a);
+    }
+    if (s) {
+      e.originalData[s.userData.index].isVerticalReferenceLine = !0;
+      const [a, h] = s.start.y < s.end.y ? [s.start, s.end] : [s.end, s.start];
+      i = -new b(a, h).direction().angleBetween(new f(0, 1), "angle", "360");
+    }
+    const o = e.originalBox.center, r = f.zero(), c = e.originalData.map((a) => {
+      const h = r.copy(a.start).division(o).rotate(f.zero(), i * (Math.PI / 180)).toJson(a.start.z), l = r.copy(a.end).division(o).rotate(f.zero(), i * (Math.PI / 180)).toJson(a.end.z), d = Object.assign(z(a), { start: h, end: l });
+      return d.drawWindow && d.drawWindow.forEach((p) => {
+        p.p = r.copy(p.p).division(o).rotate(f.zero(), i * (Math.PI / 180)).toJson(p.p.z), p.p.y = -p.p.y;
+      }), d;
+    });
+    n.appendLineSegmentList.forEach((a) => {
+      const h = a.clone();
+      h.start.division(o).rotate(f.zero(), i * (Math.PI / 180)), h.end.division(o).rotate(f.zero(), i * (Math.PI / 180)), c.push({
+        start: h.start.toJson(e.originalZAverage),
+        end: h.end.toJson(e.originalZAverage),
+        insetionArr: [],
+        length: h.length()
+      });
+    }), c.forEach((a) => {
+      a.start.y = -a.start.y, a.end.y = -a.end.y;
+    }), await this.set(c, e.width, e.scale), this.lineOffset(), this.doorLineSegment = e.doorLineSegment.map((a) => {
+      const h = a.clone();
+      return h.start.division(o).rotate(f.zero(), i * (Math.PI / 180)), h.end.division(o).rotate(f.zero(), i * (Math.PI / 180)), h.start.y = -h.start.y, h.end.y = -h.end.y, h;
     });
-    return data;
   }
 }
-class Variable extends Component {
+class _ extends j {
   static name = "Variable";
-  originalLineVisible = true;
-  dxfVisible = true;
-  whiteModelVisible = true;
-  isLook = false;
+  originalLineVisible = !0;
+  dxfVisible = !0;
+  whiteModelVisible = !0;
+  isLook = !1;
   currentWheel = 0;
   pointerMove = { x: 0, y: 0 };
   currentKeyUp = "";
   currentKeyDown = "";
   currentMouseUp = "";
   currentMouseDown = "";
-  focus = false;
-  set(key, value) {
-    if (key in this) {
-      const oldValue = this[key];
-      this[key] = value;
-      this.dispatchEvent({
-        type: key,
-        value,
-        oldValue
+  focus = !1;
+  set(t, e) {
+    if (t in this) {
+      const n = this[t];
+      this[t] = e, this.dispatchEvent({
+        type: t,
+        value: e,
+        oldValue: n
       });
     }
   }
-  get(key) {
-    if (key in this) return this[key];
+  get(t) {
+    if (t in this) return this[t];
   }
 }
-class Quadtree {
+class q {
   bounds;
   // 包围盒
   capacity;
@@ -1766,7 +1541,7 @@ class Quadtree {
   // 最大深度
   depth;
   // 当前深度
-  isLeaf = true;
+  isLeaf = !0;
   // 是否为叶子节点
   children = null;
   // 子节点数组
@@ -1774,110 +1549,72 @@ class Quadtree {
   // 存储的节点
   color = [Math.random(), Math.random(), Math.random()];
   // 颜色
-  constructor(bounds, capacity = 8, maxDepth = 10, depth = 1) {
-    this.bounds = bounds;
-    this.capacity = capacity;
-    this.depth = depth;
-    this.maxDepth = maxDepth;
+  constructor(t, e = 8, n = 10, i = 1) {
+    this.bounds = t, this.capacity = e, this.depth = i, this.maxDepth = n;
   }
   /**
    * 插入线段节点
    * @param node 线段节点
    */
-  insert(node) {
+  insert(t) {
     if (!this.isLeaf) {
-      const quadrant = this.getQuadrant(node.line);
-      if (quadrant !== -1) {
-        this.children[quadrant].insert(node);
+      const e = this.getQuadrant(t.line);
+      if (e !== -1) {
+        this.children[e].insert(t);
         return;
       }
     }
-    this.nodes.push(node);
-    node.parent = this;
-    if (this.isLeaf && this.nodes.length > this.capacity && this.depth < this.maxDepth) {
+    if (this.nodes.push(t), t.parent = this, this.isLeaf && this.nodes.length > this.capacity && this.depth < this.maxDepth) {
       this.subdivide();
-      const nodes = this.nodes;
+      const e = this.nodes;
       this.nodes = [];
-      for (const n of nodes) {
-        const quadrant = this.getQuadrant(n.line);
-        if (quadrant !== -1) {
-          this.children[quadrant].insert(n);
-        } else {
-          n.parent = this;
-          this.nodes.push(n);
-        }
+      for (const n of e) {
+        const i = this.getQuadrant(n.line);
+        i !== -1 ? this.children[i].insert(n) : (n.parent = this, this.nodes.push(n));
       }
     }
   }
   /** 移除
    * @param node 
    */
-  remove(node) {
-    const index2 = node.parent?.nodes.indexOf(node);
-    if (index2 > -1) {
-      node.parent?.nodes.splice(index2, 1);
-    }
+  remove(t) {
+    const e = t.parent?.nodes.indexOf(t);
+    e > -1 && t.parent?.nodes.splice(e, 1);
   }
   /**
    * 获取线段所属的象限
    * @param line 线段
    * @returns 象限索引（0:西北,1:东北,2:西南,3:东南）或-1（跨多个象限）
    */
-  getQuadrant(line) {
-    const intersectsNW = this.children[0].bounds.intersectLineSegment(line);
-    const intersectsNE = this.children[1].bounds.intersectLineSegment(line);
-    const intersectsSW = this.children[2].bounds.intersectLineSegment(line);
-    const intersectsSE = this.children[3].bounds.intersectLineSegment(line);
-    let count = 0;
-    let quadrant = -1;
-    if (intersectsNW) {
-      count++;
-      quadrant = 0;
-    }
-    if (intersectsNE) {
-      count++;
-      quadrant = 1;
-    }
-    if (intersectsSW) {
-      count++;
-      quadrant = 2;
-    }
-    if (intersectsSE) {
-      count++;
-      quadrant = 3;
-    }
-    if (count === 1) return quadrant;
-    return -1;
+  getQuadrant(t) {
+    const e = this.children[0].bounds.intersectLineSegment(t), n = this.children[1].bounds.intersectLineSegment(t), i = this.children[2].bounds.intersectLineSegment(t), s = this.children[3].bounds.intersectLineSegment(t);
+    let o = 0, r = -1;
+    return e && (o++, r = 0), n && (o++, r = 1), i && (o++, r = 2), s && (o++, r = 3), o === 1 ? r : -1;
   }
   /**
    * 细分当前节点为四个子节点
    */
   subdivide() {
     if (!this.isLeaf) return;
-    this.isLeaf = false;
-    this.children = [];
-    const midX = (this.bounds.minX + this.bounds.maxX) / 2;
-    const midY = (this.bounds.minY + this.bounds.maxY) / 2;
-    this.children[0] = new Quadtree(
-      new Box2(this.bounds.minX, midX, this.bounds.minY, midY),
+    this.isLeaf = !1, this.children = [];
+    const t = (this.bounds.minX + this.bounds.maxX) / 2, e = (this.bounds.minY + this.bounds.maxY) / 2;
+    this.children[0] = new q(
+      new v(this.bounds.minX, t, this.bounds.minY, e),
       this.capacity,
       this.maxDepth,
       this.depth + 1
-    );
-    this.children[1] = new Quadtree(
-      new Box2(midX, this.bounds.maxX, this.bounds.minY, midY),
+    ), this.children[1] = new q(
+      new v(t, this.bounds.maxX, this.bounds.minY, e),
       this.capacity,
       this.maxDepth,
       this.depth + 1
-    );
-    this.children[2] = new Quadtree(
-      new Box2(this.bounds.minX, midX, midY, this.bounds.maxY),
+    ), this.children[2] = new q(
+      new v(this.bounds.minX, t, e, this.bounds.maxY),
       this.capacity,
       this.maxDepth,
       this.depth + 1
-    );
-    this.children[3] = new Quadtree(
-      new Box2(midX, this.bounds.maxX, midY, this.bounds.maxY),
+    ), this.children[3] = new q(
+      new v(t, this.bounds.maxX, e, this.bounds.maxY),
       this.capacity,
       this.maxDepth,
       this.depth + 1
@@ -1888,22 +1625,16 @@ class Quadtree {
    * @param box2 包围盒
    * @returns 相交的节点数组
    */
-  queryBox(box2) {
-    const result = [];
-    if (!this.bounds.intersectBox(box2)) {
-      return result;
-    }
-    for (const node of this.nodes) {
-      if (box2.intersectLineSegment(node.line)) {
-        result.push(node);
-      }
-    }
-    if (!this.isLeaf) {
-      for (const child of this.children) {
-        result.push(...child.queryBox(box2));
-      }
-    }
-    return result;
+  queryBox(t) {
+    const e = [];
+    if (!this.bounds.intersectBox(t))
+      return e;
+    for (const n of this.nodes)
+      t.intersectLineSegment(n.line) && e.push(n);
+    if (!this.isLeaf)
+      for (const n of this.children)
+        e.push(...n.queryBox(t));
+    return e;
   }
   /**
    * 查询与圆形区域相交的线段节点
@@ -1911,81 +1642,58 @@ class Quadtree {
    * @param radius 半径
    * @returns 相交的节点数组
    */
-  queryCircle(pos, radius) {
-    const result = [];
-    const circleBox = new Box2(
-      pos.x - radius,
-      pos.x + radius,
-      pos.y - radius,
-      pos.y + radius
+  queryCircle(t, e) {
+    const n = [], i = new v(
+      t.x - e,
+      t.x + e,
+      t.y - e,
+      t.y + e
     );
-    if (!this.bounds.intersectBox(circleBox)) {
-      return result;
-    }
-    for (const node of this.nodes) {
-      const [p1, p2] = node.line.points;
-      const dx = p2.x - p1.x;
-      const dy = p2.y - p1.y;
-      const l2 = dx * dx + dy * dy;
-      let t = ((pos.x - p1.x) * dx + (pos.y - p1.y) * dy) / l2;
-      t = Math.max(0, Math.min(1, t));
-      const closestX = p1.x + t * dx;
-      const closestY = p1.y + t * dy;
-      const distance = pos.distance(new Point(closestX, closestY));
-      if (distance <= radius) {
-        result.push(node);
-      }
-    }
-    if (!this.isLeaf) {
-      for (const child of this.children) {
-        result.push(...child.queryCircle(pos, radius));
-      }
+    if (!this.bounds.intersectBox(i))
+      return n;
+    for (const s of this.nodes) {
+      const [o, r] = s.line.points, c = r.x - o.x, a = r.y - o.y, h = c * c + a * a;
+      let l = ((t.x - o.x) * c + (t.y - o.y) * a) / h;
+      l = Math.max(0, Math.min(1, l));
+      const d = o.x + l * c, p = o.y + l * a;
+      t.distance(new f(d, p)) <= e && n.push(s);
     }
-    return result;
+    if (!this.isLeaf)
+      for (const s of this.children)
+        n.push(...s.queryCircle(t, e));
+    return n;
   }
   /**
    * 查询与矩形相交的线段节点
    * @param rectangle 矩形
    * @returns 相交的节点数组
    */
-  queryRect(rectangle) {
-    const result = [];
-    if (!this.bounds.intersectRectangle(rectangle)) {
-      return result;
-    }
-    for (const node of this.nodes) {
-      if (rectangle.intersectLineSegment(node.line)) {
-        result.push(node);
-      }
-    }
-    if (!this.isLeaf) {
-      for (const child of this.children) {
-        result.push(...child.queryRect(rectangle));
-      }
-    }
-    return result;
+  queryRect(t) {
+    const e = [];
+    if (!this.bounds.intersectRectangle(t))
+      return e;
+    for (const n of this.nodes)
+      t.intersectLineSegment(n.line) && e.push(n);
+    if (!this.isLeaf)
+      for (const n of this.children)
+        e.push(...n.queryRect(t));
+    return e;
   }
   /**
    * 查询与线段相交的线段节点
    * @param lineSegment 线段
    * @returns 相交的节点数组
    */
-  queryLineSegment(lineSegment) {
-    const result = [];
-    if (!this.bounds.intersectLineSegment(lineSegment)) {
-      return result;
-    }
-    for (const node of this.nodes) {
-      if (lineSegment.intersectLineSegment(node.line)) {
-        result.push(node);
-      }
-    }
-    if (!this.isLeaf) {
-      for (const child of this.children) {
-        result.push(...child.queryLineSegment(lineSegment));
-      }
-    }
-    return result;
+  queryLineSegment(t) {
+    const e = [];
+    if (!this.bounds.intersectLineSegment(t))
+      return e;
+    for (const n of this.nodes)
+      t.intersectLineSegment(n.line) && e.push(n);
+    if (!this.isLeaf)
+      for (const n of this.children)
+        e.push(...n.queryLineSegment(t));
+    return e;
   }
   /**
    * 包围盒转换为数组
@@ -1993,96 +1701,80 @@ class Quadtree {
    * @param colors 
    * @returns 
    */
-  boundsToArray(array = [], colors, recursion = true) {
-    if (!this.isLeaf && recursion) {
-      this.children?.forEach((child) => child.boundsToArray(array, colors));
-    }
-    array.push(...this.bounds.points.flatMap((p, i, array2) => {
-      const np = array2[(i + 1) % array2.length];
-      colors?.push(...this.color);
-      colors?.push(...this.color);
-      return [p.x, p.y, 0, np.x, np.y, 0];
-    }));
-    return array;
+  boundsToArray(t = [], e, n = !0) {
+    return !this.isLeaf && n && this.children?.forEach((i) => i.boundsToArray(t, e)), t.push(...this.bounds.points.flatMap((i, s, o) => {
+      const r = o[(s + 1) % o.length];
+      return e?.push(...this.color), e?.push(...this.color), [i.x, i.y, 0, r.x, r.y, 0];
+    })), t;
   }
 }
-class PointVirtualGrid {
+class U {
   map = /* @__PURE__ */ new Map();
   gridSize;
-  constructor(gridSize = 2) {
-    this.gridSize = gridSize;
+  constructor(t = 2) {
+    this.gridSize = t;
   }
   /**
    * 插入
    * @param point 
    * @param userData 
    */
-  insert(point, userData) {
-    if (!point || isNaN(point.x) || isNaN(point.y)) {
+  insert(t, e) {
+    if (!t || isNaN(t.x) || isNaN(t.y))
       throw new Error("无效的点坐标");
-    }
-    const id = this.getGridId(point);
-    if (!this.map.has(id)) this.map.set(id, /* @__PURE__ */ new Set());
-    const set = this.map.get(id);
-    const target = { point, userData };
-    set.add(target);
-    point.userData.pointVirtualGrid = { set, target };
+    const n = this.getGridId(t);
+    this.map.has(n) || this.map.set(n, /* @__PURE__ */ new Set());
+    const i = this.map.get(n), s = { point: t, userData: e };
+    i.add(s), t.userData.pointVirtualGrid = { set: i, target: s };
   }
   /**
    * 批量加入
    * @param points 
    */
-  insertBatch(points) {
-    for (const { point, userData } of points) {
-      this.insert(point, userData);
-    }
+  insertBatch(t) {
+    for (const { point: e, userData: n } of t)
+      this.insert(e, n);
   }
   /** 移除点
    * @param point 
    */
-  remove(point) {
-    const { set, target } = point?.userData?.pointVirtualGrid;
-    if (set) {
-      set.delete(target);
-      delete point?.userData?.pointVirtualGridMap;
-    }
+  remove(t) {
+    const { set: e, target: n } = t?.userData?.pointVirtualGrid;
+    e && (e.delete(n), delete t?.userData?.pointVirtualGridMap);
   }
   /**
    * 获取通过坐标，获取唯一网格索引
    * @param point 
    * @returns 
    */
-  getGridId(point) {
-    const i = Math.ceil(point.x / this.gridSize), j = Math.ceil(point.y / this.gridSize);
-    return `${i}.${j}`;
+  getGridId(t) {
+    const e = Math.ceil(t.x / this.gridSize), n = Math.ceil(t.y / this.gridSize);
+    return `${e}.${n}`;
   }
   /**
    * 
    * @param gridId 
    * @returns 
    */
-  decodeGridId(gridId) {
-    const [i, j] = gridId.split(".").map(Number);
-    return new Point(i, j);
+  decodeGridId(t) {
+    const [e, n] = t.split(".").map(Number);
+    return new f(e, n);
   }
   /**
    * 查询与矩形相交的点
    * @param rectangle 矩形
    * @returns 相交的节点数组
    */
-  queryRect(rectangle) {
-    const box2 = rectangle.toBox();
-    const minI = Math.ceil(box2.minX / this.gridSize), maxI = Math.ceil(box2.maxX / this.gridSize), minJ = Math.ceil(box2.minY / this.gridSize), maxJ = Math.ceil(box2.maxY / this.gridSize);
-    for (let i = minI; i <= maxI; i++) {
-      for (let j = minJ; j <= maxJ; j++) {
-        const id = `${i}.${j}`;
-        if (!this.map.has(id)) continue;
-        const set = this.map.get(id);
-        set?.forEach((item) => {
-          if (rectangle.containsPoint(item.point)) ;
+  queryRect(t) {
+    const e = t.toBox(), n = Math.ceil(e.minX / this.gridSize), i = Math.ceil(e.maxX / this.gridSize), s = Math.ceil(e.minY / this.gridSize), o = Math.ceil(e.maxY / this.gridSize);
+    for (let r = n; r <= i; r++)
+      for (let c = s; c <= o; c++) {
+        const a = `${r}.${c}`;
+        if (!this.map.has(a)) continue;
+        this.map.get(a)?.forEach((l) => {
+          t.containsPoint(l.point);
         });
       }
-    }
   }
   /**
    * 查询与圆形区域相交的点
@@ -2090,62 +1782,53 @@ class PointVirtualGrid {
    * @param radius 半径
    * @returns 相交的节点数组
    */
-  queryCircle(pos, radius) {
-    const box2 = new Box2(pos.x - radius, pos.x + radius, pos.y - radius, pos.y + radius);
-    const minI = Math.ceil(box2.minX / this.gridSize), maxI = Math.ceil(box2.maxX / this.gridSize), minJ = Math.ceil(box2.minY / this.gridSize), maxJ = Math.ceil(box2.maxY / this.gridSize), list = [];
-    for (let i = minI; i <= maxI; i++) {
-      for (let j = minJ; j <= maxJ; j++) {
-        const id = `${i}.${j}`;
-        if (!this.map.has(id)) continue;
-        const set = this.map.get(id);
-        set?.forEach((item) => {
-          if (pos.distance(item.point) <= radius) list.push(item);
+  queryCircle(t, e) {
+    const n = new v(t.x - e, t.x + e, t.y - e, t.y + e), i = Math.ceil(n.minX / this.gridSize), s = Math.ceil(n.maxX / this.gridSize), o = Math.ceil(n.minY / this.gridSize), r = Math.ceil(n.maxY / this.gridSize), c = [];
+    for (let a = i; a <= s; a++)
+      for (let h = o; h <= r; h++) {
+        const l = `${a}.${h}`;
+        if (!this.map.has(l)) continue;
+        this.map.get(l)?.forEach((p) => {
+          t.distance(p.point) <= e && c.push(p);
         });
       }
-    }
-    return list;
+    return c;
   }
   /**
    * 查询与包围盒相交的点
    * @param box2 包围盒
    * @returns 相交的节点数组
    */
-  queryBox(box2) {
-    const minI = Math.ceil(box2.minX / this.gridSize), maxI = Math.ceil(box2.maxX / this.gridSize), minJ = Math.ceil(box2.minY / this.gridSize), maxJ = Math.ceil(box2.maxY / this.gridSize), list = [];
-    for (let i = minI; i <= maxI; i++) {
-      for (let j = minJ; j <= maxJ; j++) {
-        const id = `${i}.${j}`;
-        if (!this.map.has(id)) continue;
-        const set = this.map.get(id);
-        set?.forEach((item) => {
-          if (box2.containsPoint(item.point)) list.push(item);
+  queryBox(t) {
+    const e = Math.ceil(t.minX / this.gridSize), n = Math.ceil(t.maxX / this.gridSize), i = Math.ceil(t.minY / this.gridSize), s = Math.ceil(t.maxY / this.gridSize), o = [];
+    for (let r = e; r <= n; r++)
+      for (let c = i; c <= s; c++) {
+        const a = `${r}.${c}`;
+        if (!this.map.has(a)) continue;
+        this.map.get(a)?.forEach((l) => {
+          t.containsPoint(l.point) && o.push(l);
         });
       }
-    }
-    return list;
+    return o;
   }
   /**
    * 查找相同点
    * @param point 
    */
-  queryPoint(point) {
-    const id = this.getGridId(point), list = [];
-    if (this.map.has(id)) {
-      const set = this.map.get(id);
-      set?.forEach((item) => {
-        if (point.equal(item.point)) list.push(item);
-      });
-    }
-    return list;
+  queryPoint(t) {
+    const e = this.getGridId(t), n = [];
+    return this.map.has(e) && this.map.get(e)?.forEach((s) => {
+      t.equal(s.point) && n.push(s);
+    }), n;
   }
 }
-class DoorsAnalysis {
+class rt {
   // 所有可查找的点位
   possibleDoorPoints = [];
   doorPoint = [];
   dxf;
   // 包含所有点的虚拟网格
-  pointVirtualGrid = new PointVirtualGrid();
+  pointVirtualGrid = new U();
   // 只包含可查找点的虚拟网格
   findPointVirtualGrid;
   quadtree;
@@ -2156,158 +1839,111 @@ class DoorsAnalysis {
   doorSearchDistance = 2;
   doors = [];
   lineAnalysis;
-  continueFind = true;
-  constructor(lineAnalysis) {
-    this.lineAnalysis = lineAnalysis;
-    this.dxf = lineAnalysis.Dxf;
-    this.findPointVirtualGrid = new PointVirtualGrid();
-    this.quadtree = lineAnalysis.quadtree;
-    this.resultList = lineAnalysis.resultList;
-    this.lineSegments = lineAnalysis.lineSegmentList;
-    this.dxf.doorLineSegment.length = 0;
-    this.lineSegments.forEach((line) => {
-      this.pointVirtualGrid.insert(line.start, line);
-      this.pointVirtualGrid.insert(line.end, line);
-    });
-    this.doorPoint = this.getDoorPoint();
-    if (!this.continueFind) return;
-    const excludeIndexMap = this.searchDoubleLinePoint();
-    this.addPointsExcludeRule((line, _2, pointIndex) => {
-      const index2 = this.lineSegments.indexOf(line);
-      const excludeMode = excludeIndexMap.get(index2);
-      if (typeof excludeMode === "number") {
-        return excludeMode === -1 || excludeMode === pointIndex;
-      }
-      return false;
-    });
-    this.addPointsExcludeRule((_1, point) => {
-      return !!this.doorPoint.find((p1) => p1.point.equal(point));
-    });
-    this.possibleDoorPoints = this.getPossiblePoints();
-    this.possibleDoorPoints.forEach((p) => this.findPointVirtualGrid.insert(p.point, p.line));
-    this.handle();
+  continueFind = !0;
+  constructor(t) {
+    if (this.lineAnalysis = t, this.dxf = t.Dxf, this.findPointVirtualGrid = new U(), this.quadtree = t.quadtree, this.resultList = t.resultList, this.lineSegments = t.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 e = this.searchDoubleLinePoint();
+    this.addPointsExcludeRule((n, i, s) => {
+      const o = this.lineSegments.indexOf(n), r = e.get(o);
+      return typeof r == "number" ? r === -1 || r === s : !1;
+    }), this.addPointsExcludeRule((n, i) => !!this.doorPoint.find((s) => s.point.equal(i))), this.possibleDoorPoints = this.getPossiblePoints(), this.possibleDoorPoints.forEach((n) => this.findPointVirtualGrid.insert(n.point, n.line)), this.handle();
   }
   handle() {
-    this.dxf.doorLineSegment.push(...this.search(this.doorPoint, this.possibleDoorPoints, 0.5));
-    if (this.doorPoint.length < 2) this.dxf.doorLineSegment.push(...this.search(this.possibleDoorPoints, this.possibleDoorPoints, 0.6));
-  }
-  search(doorPoints, possibleDoorPoints = [], minDoorWidth = 0.6, doorSearchDistance = this.doorSearchDistance, doorSearchNearAngle = this.doorSearchNearAngle) {
-    const dxf = this.dxf;
-    const doors = this.searchNearby(doorPoints, possibleDoorPoints, doorSearchDistance, doorSearchNearAngle);
-    doors.push(
-      ...doorPoints.map((item) => {
-        const res2 = this.searchAlongDirection(item, doorSearchDistance);
-        if (res2) return {
-          start: item.point,
-          end: res2.point
+    this.dxf.doorLineSegment.push(...this.search(this.doorPoint, this.possibleDoorPoints, 0.5)), this.doorPoint.length < 2 && this.dxf.doorLineSegment.push(...this.search(this.possibleDoorPoints, this.possibleDoorPoints, 0.6));
+  }
+  search(t, e = [], n = 0.6, i = this.doorSearchDistance, s = this.doorSearchNearAngle) {
+    const o = this.dxf, r = this.searchNearby(t, e, i, s);
+    r.push(
+      ...t.map((a) => {
+        const h = this.searchAlongDirection(a, i);
+        if (h) return {
+          start: a.point,
+          end: h.point
         };
-        const res3 = this.searchAlongNormalDirection(item, doorSearchDistance);
-        if (res3) return {
-          start: item.point,
-          end: res3.point
+        const l = this.searchAlongNormalDirection(a, i);
+        if (l) return {
+          start: a.point,
+          end: l.point
         };
-      }).filter((i) => !!i && i.start.distance(i.end) < doorSearchDistance)
+      }).filter((a) => !!a && a.start.distance(a.end) < i)
     );
-    const doorLineSegment = [];
-    doors.forEach((p) => {
-      const line = new LineSegment(p?.start, p?.end);
-      const len = line.length();
-      if (len < minDoorWidth) return;
-      const normal = line.normal(), direction = line.direction(), step = (len - dxf.width * 2) / 2;
-      for (let i = 0; i < 3; i++) {
-        const point = line.start.clone().add(direction.clone().multiplyScalar(dxf.width + step * i));
-        const rLine = new LineSegment(
-          point,
-          point.clone().add(normal.clone().multiplyScalar(1))
+    const c = [];
+    return r.forEach((a) => {
+      const h = new b(a?.start, a?.end), l = h.length();
+      if (l < n) return;
+      const d = h.normal(), p = h.direction(), m = (l - o.width * 2) / 2;
+      for (let g = 0; g < 3; g++) {
+        const u = h.start.clone().add(p.clone().multiplyScalar(o.width + m * g)), x = new b(
+          u,
+          u.clone().add(d.clone().multiplyScalar(1))
         );
-        rLine.directionMove(normal, -0.5);
-        const res = this.quadtree.queryLineSegment(rLine);
-        if (res.length) return;
+        if (x.directionMove(d, -0.5), this.quadtree.queryLineSegment(x).length) return;
       }
-      doorLineSegment.push(line);
-    });
-    return doorLineSegment;
+      c.push(h);
+    }), c;
   }
   /** 添加可查找点的过滤规则
    * @param rule 
    */
-  addPointsExcludeRule(rule) {
-    this._pointsExcludeRule.push(rule);
+  addPointsExcludeRule(t) {
+    this._pointsExcludeRule.push(t);
   }
   _pointsExcludeRule = [];
   /**
    * 查找所有可能为门的点位
    */
   getPossiblePoints() {
-    const doorPoints = [];
-    this.lineSegments.forEach((line) => {
-      line.points.forEach((p, j) => {
-        for (let i = 0; i < this._pointsExcludeRule.length; i++) if (this._pointsExcludeRule[i](line, p, j)) return;
-        const res = this.pointVirtualGrid.queryPoint(p).filter((d) => d.userData !== line);
-        if (res.length === 0) {
-          doorPoints.push({ line, point: p, uuid: uuid() });
-        }
+    const t = [];
+    return this.lineSegments.forEach((e) => {
+      e.points.forEach((n, i) => {
+        for (let o = 0; o < this._pointsExcludeRule.length; o++) if (this._pointsExcludeRule[o](e, n, i)) return;
+        this.pointVirtualGrid.queryPoint(n).filter((o) => o.userData !== e).length === 0 && t.push({ line: e, point: n, uuid: N() });
       });
-    });
-    return doorPoints;
+    }), t;
   }
   /**
    * 查找已知为门的点位
    */
   getDoorPoint() {
-    const doorPoints = [], dxf = this.dxf, pointVirtualGrid = this.pointVirtualGrid;
-    dxf.doors.forEach((item) => {
-      const doorLine = dxf.lineSegments[item[4]];
-      const doorData = dxf.originalData[item[4]];
-      if (doorData.drawDoorData) {
-        const point = Point.from(doorData.drawDoorData.start);
-        const direct = Point.from(doorData.drawDoorData.n);
-        const resList = pointVirtualGrid.queryPoint(point).filter((res) => {
-          if (res.userData === doorLine) return false;
-          const line = res.userData;
-          const direct2 = line.direction();
-          if (line.start.equal(point)) direct2.multiplyScalar(-1);
-          const angle = direct.angleBetween(direct2, "angle");
-          return angle > 80 || angle < 10;
+    const t = [], e = this.dxf, n = this.pointVirtualGrid;
+    return e.doors.forEach((i) => {
+      const s = e.lineSegments[i[4]], o = e.originalData[i[4]];
+      if (o.drawDoorData) {
+        const r = f.from(o.drawDoorData.start), c = f.from(o.drawDoorData.n), a = n.queryPoint(r).filter((h) => {
+          if (h.userData === s) return !1;
+          const l = h.userData, d = l.direction();
+          l.start.equal(r) && d.multiplyScalar(-1);
+          const p = c.angleBetween(d, "angle");
+          return p > 80 || p < 10;
         });
-        if (resList.length) {
-          doorPoints.push({
-            line: resList[0].userData,
-            point,
-            uuid: uuid()
-          });
-        }
-      } else if (doorData.doorDirectConnection) {
-        this.continueFind = false;
-        const line = new LineSegment(Point.from(doorData.start), Point.from(doorData.end));
-        line.userData = {
-          doorDirectConnection: true,
-          isDoor: true
-        };
-        this.dxf.doorLineSegment.push(line);
-      } else {
-        console.warn(`门的线段顺序${item[4]} 没有drawDoorData属性`);
-      }
-    });
-    console.log("门点位数量：", doorPoints.length);
-    return doorPoints;
+        a.length && t.push({
+          line: a[0].userData,
+          point: r,
+          uuid: N()
+        });
+      } else if (o.doorDirectConnection) {
+        this.continueFind = !1;
+        const r = new b(f.from(o.start), f.from(o.end));
+        r.userData = {
+          doorDirectConnection: !0,
+          isDoor: !0
+        }, this.dxf.doorLineSegment.push(r);
+      } else
+        console.warn(`门的线段顺序${i[4]} 没有drawDoorData属性`);
+    }), t;
   }
   /**
    * 查找双线墙的点位
    * @returns 
    */
   searchDoubleLinePoint() {
-    const excludeIndexMap = /* @__PURE__ */ new Map();
-    this.resultList.flatMap((p) => {
-      const line0 = this.lineSegments[p.sourceIndex], line1 = this.lineSegments[p.targetIndex], start0 = line1.projectPoint(line0.start), end0 = line1.projectPoint(line0.end), start1 = line0.projectPoint(line1.start), end1 = line0.projectPoint(line1.end), mode0 = start0 && end0 ? -1 : start0 ? 0 : end0 ? 1 : -1, mode1 = start1 && end1 ? -1 : start1 ? 0 : end1 ? 1 : -1;
-      if (excludeIndexMap.has(p.sourceIndex)) {
-        if (excludeIndexMap.get(p.sourceIndex) != mode0) excludeIndexMap.set(p.sourceIndex, -1);
-      } else excludeIndexMap.set(p.sourceIndex, mode0);
-      if (excludeIndexMap.has(p.targetIndex)) {
-        if (excludeIndexMap.get(p.targetIndex) != mode1) excludeIndexMap.set(p.targetIndex, -1);
-      } else excludeIndexMap.set(p.targetIndex, mode1);
-    });
-    return excludeIndexMap;
+    const t = /* @__PURE__ */ new Map();
+    return this.resultList.flatMap((e) => {
+      const n = this.lineSegments[e.sourceIndex], i = this.lineSegments[e.targetIndex], s = i.projectPoint(n.start), o = i.projectPoint(n.end), r = n.projectPoint(i.start), c = n.projectPoint(i.end), a = s && o ? -1 : s ? 0 : o ? 1 : -1, h = r && c ? -1 : r ? 0 : c ? 1 : -1;
+      t.has(e.sourceIndex) ? t.get(e.sourceIndex) != a && t.set(e.sourceIndex, -1) : t.set(e.sourceIndex, a), t.has(e.targetIndex) ? t.get(e.targetIndex) != h && t.set(e.targetIndex, -1) : t.set(e.targetIndex, h);
+    }), t;
   }
   /** 查找方案一：最近点查找
    * @description 以点为圆心，查找半径内符合角度的点
@@ -2317,160 +1953,113 @@ class DoorsAnalysis {
    * @param doorSearchNearAngle 查找的角度
    * @returns 
    */
-  searchNearby(doorPoints, possibleDoorPoints = [], doorSearchDistance = this.doorSearchDistance, doorSearchNearAngle = this.doorSearchNearAngle) {
-    const findPointVirtualGrid = this.findPointVirtualGrid, quadtree = this.quadtree;
-    function find({ point, line }, doorIndex, record2) {
-      const direct = line.direction();
-      if (line.start === point) direct.multiplyScalar(-1);
-      const res = findPointVirtualGrid.queryCircle(point, doorSearchDistance).filter((r) => r.userData !== line).sort((a, b) => a.point.distance(point) - b.point.distance(point));
-      const list = [];
-      for (let i = 0; i < res.length; i++) {
-        const doorIndex2 = possibleDoorPoints.findIndex((p) => p.point === res[i].point);
-        const id1 = doorPoints[doorIndex].uuid, id2 = possibleDoorPoints[doorIndex2].uuid;
-        if (record2.has(`${id1}.${id2}`)) continue;
-        record2.add(`${id1}.${id2}`);
-        record2.add(`${id2}.${id1}`);
-        const targetPoint = res[i].point, line2 = new LineSegment(point.clone(), targetPoint.clone()), angle = line2.direction().angleBetween(direct, "angle");
-        if (angle < doorSearchNearAngle) {
-          const direct2 = doorPoints[doorIndex2].line.direction();
-          const line22 = res[i].userData;
-          if (line22.start.equal(res[i].point)) direct2.multiplyScalar(-1);
-          const angle2 = line2.direction().multiplyScalar(-1).angleBetween(direct2, "angle");
-          if (angle2 < doorSearchNearAngle) {
-            if (!quadtree.queryLineSegment(line2).length) {
-              list.push({
-                findData: res[i],
-                findUuid: id2,
-                doorLine: line2,
-                doorUuid: id1
-              });
-            }
-          }
+  searchNearby(t, e = [], n = this.doorSearchDistance, i = this.doorSearchNearAngle) {
+    const s = this.findPointVirtualGrid, o = this.quadtree;
+    function r({ point: u, line: x }, w, S) {
+      const L = x.direction();
+      x.start === u && L.multiplyScalar(-1);
+      const P = s.queryCircle(u, n).filter((D) => D.userData !== x).sort((D, E) => D.point.distance(u) - E.point.distance(u)), A = [];
+      for (let D = 0; D < P.length; D++) {
+        const E = e.findIndex((T) => T.point === P[D].point), B = t[w].uuid, Y = e[E].uuid;
+        if (S.has(`${B}.${Y}`)) continue;
+        S.add(`${B}.${Y}`), S.add(`${Y}.${B}`);
+        const Q = P[D].point, C = new b(u.clone(), Q.clone());
+        if (C.direction().angleBetween(L, "angle") < i) {
+          const T = t[E].line.direction();
+          P[D].userData.start.equal(P[D].point) && T.multiplyScalar(-1), C.direction().multiplyScalar(-1).angleBetween(T, "angle") < i && (o.queryLineSegment(C).length || A.push({
+            findData: P[D],
+            findUuid: Y,
+            doorLine: C,
+            doorUuid: B
+          }));
         }
       }
-      return list;
-    }
-    function deepSearchNearHandle(uuid2, snFindRecord2, list, record2, other) {
-      record2.add(uuid2);
-      const newList = [];
-      if (other) newList.push(other);
-      for (let i = 0; i < list.length; i++) {
-        const item = list[i];
-        if (snFindRecord2.has(item.findUuid)) {
-          const list2 = snFindRecord2.get(item.findUuid);
-          if (deepSearchNearHandle(item.findUuid, snFindRecord2, list2, record2, item)) newList.push(item);
-        } else newList.push(item);
+      return A;
+    }
+    function c(u, x, w, S, L) {
+      S.add(u);
+      const P = [];
+      L && P.push(L);
+      for (let A = 0; A < w.length; A++) {
+        const D = w[A];
+        if (x.has(D.findUuid)) {
+          const E = x.get(D.findUuid);
+          c(D.findUuid, x, E, S, D) && P.push(D);
+        } else P.push(D);
       }
-      newList.sort((a, b) => a.doorLine.length() - b.doorLine.length());
-      if (other && newList[0] === other) {
-        list.splice(0);
-        return true;
+      return P.sort((A, D) => A.doorLine.length() - D.doorLine.length()), L && P[0] === L ? (w.splice(0), !0) : (w.splice(1), !1);
+    }
+    const a = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Map();
+    t.map((u, x) => {
+      const w = r(u, x, a);
+      w.length && h.set(u.uuid, w);
+    }), a.clear();
+    const l = /* @__PURE__ */ new Map();
+    h.forEach((u, x) => {
+      if (!a.has(x) && u.length && c(x, h, u, a), u.length) {
+        const w = u[0];
+        l.has(w.doorUuid) || l.set(w.doorUuid, []), l.get(w.doorUuid)?.push(w), l.has(w.findUuid) || l.set(w.findUuid, []), l.get(w.findUuid)?.push(w);
       }
-      list.splice(1);
-      return false;
-    }
-    const record = /* @__PURE__ */ new Set();
-    const snFindRecord = /* @__PURE__ */ new Map();
-    doorPoints.map((p, index2) => {
-      const list = find(p, index2, record);
-      if (list.length) snFindRecord.set(p.uuid, list);
     });
-    record.clear();
-    const temMap = /* @__PURE__ */ new Map();
-    snFindRecord.forEach((list, key) => {
-      if (!record.has(key) && list.length) {
-        deepSearchNearHandle(key, snFindRecord, list, record);
-      }
-      if (list.length) {
-        const item = list[0];
-        if (!temMap.has(item.doorUuid)) temMap.set(item.doorUuid, []);
-        temMap.get(item.doorUuid)?.push(item);
-        if (!temMap.has(item.findUuid)) temMap.set(item.findUuid, []);
-        temMap.get(item.findUuid)?.push(item);
+    const d = /* @__PURE__ */ new Set();
+    l.forEach((u) => {
+      if (u.length > 1) {
+        u.sort((x, w) => x.doorLine.length() - w.doorLine.length());
+        for (let x = 1; x < u.length; x++) d.add(u[x]);
       }
     });
-    const deleteSet = /* @__PURE__ */ new Set();
-    temMap.forEach((list) => {
-      if (list.length > 1) {
-        list.sort((a, b) => a.doorLine.length() - b.doorLine.length());
-        for (let i = 1; i < list.length; i++) deleteSet.add(list[i]);
+    const p = [], m = [];
+    h.forEach((u) => {
+      if (u.length) {
+        const x = u[0];
+        d.has(x) || (p.push(x), m.push(x.doorUuid, x.findUuid));
       }
     });
-    const searchNearRasult = [], removeDoorPointsUuid = [];
-    snFindRecord.forEach((list) => {
-      if (list.length) {
-        const item = list[0];
-        if (!deleteSet.has(item)) {
-          searchNearRasult.push(item);
-          removeDoorPointsUuid.push(item.doorUuid, item.findUuid);
-        }
-      }
-    });
-    const doors = [];
-    searchNearRasult.forEach((item) => {
-      const doorIndex = doorPoints.findIndex((p2) => p2.uuid === item.doorUuid);
-      const findDoorIndex = possibleDoorPoints.findIndex((p2) => p2.uuid === item.findUuid);
-      const start = doorPoints[doorIndex].point.clone();
-      const end = possibleDoorPoints[findDoorIndex].point.clone();
-      const startLine = this.findLongLineSegment(doorPoints[doorIndex].line);
-      const endLine = this.findLongLineSegment(possibleDoorPoints[findDoorIndex].line);
-      const p = startLine.projectPoint(end);
-      if (p) {
-        start.copy(p);
-        const l = new LineSegment(start, end);
-        const angle = endLine.includedAngle(l);
-        if (angle < 10 || angle > 170 || Math.abs(90 - angle) < 10) {
-          doors.push({
-            start,
-            end
-          });
-        }
+    const g = [];
+    return p.forEach((u) => {
+      const x = t.findIndex((E) => E.uuid === u.doorUuid), w = e.findIndex((E) => E.uuid === u.findUuid), S = t[x].point.clone(), L = e[w].point.clone(), P = this.findLongLineSegment(t[x].line), A = this.findLongLineSegment(e[w].line), D = P.projectPoint(L);
+      if (D) {
+        S.copy(D);
+        const E = new b(S, L), B = A.includedAngle(E);
+        (B < 10 || B > 170 || Math.abs(90 - B) < 10) && g.push({
+          start: S,
+          end: L
+        });
       } else {
-        const p2 = endLine.projectPoint(start);
-        if (p2) end.copy(p2);
-        const l = new LineSegment(start, end);
-        const angle = startLine.includedAngle(l);
-        if (angle < 10 || angle > 170 || Math.abs(90 - angle) < 10) {
-          doors.push({
-            start,
-            end
-          });
-        }
+        const E = A.projectPoint(S);
+        E && L.copy(E);
+        const B = new b(S, L), Y = P.includedAngle(B);
+        (Y < 10 || Y > 170 || Math.abs(90 - Y) < 10) && g.push({
+          start: S,
+          end: L
+        });
       }
-    });
-    possibleDoorPoints.splice(
+    }), e.splice(
       0,
-      possibleDoorPoints.length,
-      ...possibleDoorPoints.filter((p) => removeDoorPointsUuid.indexOf(p.uuid) === -1)
-    );
-    doorPoints.splice(
+      e.length,
+      ...e.filter((u) => m.indexOf(u.uuid) === -1)
+    ), t.splice(
       0,
-      doorPoints.length,
-      ...doorPoints.filter((p) => removeDoorPointsUuid.indexOf(p.uuid) === -1)
-    );
-    return doors;
+      t.length,
+      ...t.filter((u) => m.indexOf(u.uuid) === -1)
+    ), g;
   }
   /** 方案二： 沿方向查找
    * @description 
    * @param param0 
    * @returns 
    */
-  searchAlongDirection({ point, line }, doorSearchDistance = this.doorSearchDistance) {
-    const quadtree = this.quadtree;
-    const direct = line.direction();
-    if (line.start === point) direct.multiplyScalar(-1);
-    const endPoint = point.clone().add(direct.clone().multiplyScalar(doorSearchDistance)), rline = new LineSegment(point.clone(), endPoint), result = quadtree.queryLineSegment(rline).map((l) => {
-      const res = l.line.getIntersection(rline);
-      return {
-        point: res,
-        line: l.line
-      };
-    }).filter((i) => i.point).sort((a, b) => point.distance(a.point) - point.distance(b.point));
-    if (result.length) {
-      const item = result[0];
-      if (Math.abs(90 - item.line.direction().angleBetween(direct, "angle")) < 5) {
-        return item;
-      }
+  searchAlongDirection({ point: t, line: e }, n = this.doorSearchDistance) {
+    const i = this.quadtree, s = e.direction();
+    e.start === t && s.multiplyScalar(-1);
+    const o = t.clone().add(s.clone().multiplyScalar(n)), r = new b(t.clone(), o), c = i.queryLineSegment(r).map((a) => ({
+      point: a.line.getIntersection(r),
+      line: a.line
+    })).filter((a) => a.point).sort((a, h) => t.distance(a.point) - t.distance(h.point));
+    if (c.length) {
+      const a = c[0];
+      if (Math.abs(90 - a.line.direction().angleBetween(s, "angle")) < 5)
+        return a;
     }
   }
   /** 方案三： 沿法线方向查找
@@ -2479,35 +2068,25 @@ class DoorsAnalysis {
    * @param doorSearchDistance 
    * @returns 
    */
-  searchAlongNormalDirection({ point, line }, doorSearchDistance = this.doorSearchDistance) {
-    const pointVirtualGrid = this.pointVirtualGrid, quadtree = this.quadtree, direct = line.direction(), normal = line.start.normal(line.end), prePoint = line.start.clone();
-    if (line.start === point) direct.multiplyScalar(-1);
-    if (line.start === point) prePoint.copy(line.end);
-    const result = pointVirtualGrid.queryPoint(prePoint).filter((r) => r.userData !== line);
-    for (let i = 0; i < result.length; i++) {
-      const element = result[i];
-      const l = element.userData;
-      const d1 = l.direction();
-      if (l.start === element.point) direct.multiplyScalar(-1);
-      const angle = d1.angleBetween(normal) / (Math.PI / 180);
-      if (angle > 90) {
-        normal.multiplyScalar(-1);
+  searchAlongNormalDirection({ point: t, line: e }, n = this.doorSearchDistance) {
+    const i = this.pointVirtualGrid, s = this.quadtree, o = e.direction(), r = e.start.normal(e.end), c = e.start.clone();
+    e.start === t && o.multiplyScalar(-1), e.start === t && c.copy(e.end);
+    const a = i.queryPoint(c).filter((d) => d.userData !== e);
+    for (let d = 0; d < a.length; d++) {
+      const p = a[d], m = p.userData, g = m.direction();
+      if (m.start === p.point && o.multiplyScalar(-1), g.angleBetween(r) / (Math.PI / 180) > 90) {
+        r.multiplyScalar(-1);
         break;
       }
     }
-    const rline3 = new LineSegment(point.clone(), point.clone().add(normal.multiplyScalar(doorSearchDistance)));
-    const r3 = quadtree.queryLineSegment(rline3).map((l) => {
-      const res = l.line.getIntersection(rline3);
-      return {
-        point: res,
-        line: l.line
-      };
-    }).filter((i) => i.point).sort((a, b) => point.distance(a.point) - point.distance(b.point));
-    if (r3.length) {
-      const item = r3[0];
-      if (Math.abs(90 - item.line.direction().angleBetween(normal, "angle")) < 5) {
-        return item;
-      }
+    const h = new b(t.clone(), t.clone().add(r.multiplyScalar(n))), l = s.queryLineSegment(h).map((d) => ({
+      point: d.line.getIntersection(h),
+      line: d.line
+    })).filter((d) => d.point).sort((d, p) => t.distance(d.point) - t.distance(p.point));
+    if (l.length) {
+      const d = l[0];
+      if (Math.abs(90 - d.line.direction().angleBetween(r, "angle")) < 5)
+        return d;
     }
   }
   /**
@@ -2515,37 +2094,31 @@ class DoorsAnalysis {
    * @param line 
    * @returns 
    */
-  findLongLineSegment(line) {
-    const resLine = line.clone();
-    const res1 = this.pointVirtualGrid.queryPoint(line.start);
-    const res2 = this.pointVirtualGrid.queryPoint(line.end);
-    for (let i = 0; i < res1.length; i++) {
-      const { userData: line2 } = res1[i];
-      if (line2 === line) continue;
-      if (line2 && line2.directionEqual(line)) {
-        if (line2.start.equal(line.start)) resLine.start.copy(line2.end);
-        else resLine.start.copy(line2.start);
+  findLongLineSegment(t) {
+    const e = t.clone(), n = this.pointVirtualGrid.queryPoint(t.start), i = this.pointVirtualGrid.queryPoint(t.end);
+    for (let s = 0; s < n.length; s++) {
+      const { userData: o } = n[s];
+      if (o !== t && o && o.directionEqual(t)) {
+        o.start.equal(t.start) ? e.start.copy(o.end) : e.start.copy(o.start);
         break;
       }
     }
-    for (let i = 0; i < res2.length; i++) {
-      const { userData: line2 } = res2[i];
-      if (line2 === line) continue;
-      if (line2 && line2.directionEqual(line)) {
-        if (line2.end.equal(line.end)) resLine.end.copy(line2.start);
-        else resLine.end.copy(line2.end);
+    for (let s = 0; s < i.length; s++) {
+      const { userData: o } = i[s];
+      if (o !== t && o && o.directionEqual(t)) {
+        o.end.equal(t.end) ? e.end.copy(o.start) : e.end.copy(o.end);
         break;
       }
     }
-    return resLine;
+    return e;
   }
 }
-class LineAnalysis extends Component {
+class at extends j {
   static name = "LineAnalysis";
   Dxf = null;
   Variable = null;
   lineSegmentList = [];
-  container = new THREE.Group();
+  container = new M.Group();
   // 误差角度
   errorAngle = 4;
   width = 0.4;
@@ -2553,11 +2126,8 @@ class LineAnalysis extends Component {
    * 
    * @param parent 
    */
-  onAddFromParent(parent) {
-    this.Dxf = parent.findComponentByType(Dxf);
-    this.Variable = this.parent?.findComponentByType(Variable);
-    this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this));
-    this.Dxf.addEventListener("createGroup", this.doorsAnalysis.bind(this));
+  onAddFromParent(t) {
+    this.Dxf = t.findComponentByType(X), this.Variable = this.parent?.findComponentByType(_), this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this)), this.Dxf.addEventListener("createGroup", this.doorsAnalysis.bind(this));
   }
   /**
    * 
@@ -2566,20 +2136,16 @@ class LineAnalysis extends Component {
    * @param width 
    * @returns 
    */
-  expandLineSegment(p1, p2, width = 0.1) {
-    const normal = p2.normal(p1);
-    const pDirect = p2.direction(p1).mutiplyScalar(width * 0.5);
-    const nDirect = p1.direction(p2).mutiplyScalar(width * 0.5);
-    const offsetX = normal.x * width * 0.5;
-    const offsetY = normal.y * width * 0.5;
+  expandLineSegment(t, e, n = 0.1) {
+    const i = e.normal(t), s = e.direction(t).mutiplyScalar(n * 0.5), o = t.direction(e).mutiplyScalar(n * 0.5), r = i.x * n * 0.5, c = i.y * n * 0.5;
     return {
       points: [
         // 第一条线
-        new Point(p1.x + offsetX, p1.y + offsetY).add(nDirect),
-        new Point(p2.x + offsetX, p2.y + offsetY).add(pDirect),
+        new f(t.x + r, t.y + c).add(o),
+        new f(e.x + r, e.y + c).add(s),
         // 第二条线
-        new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect),
-        new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect)
+        new f(t.x - r, t.y - c).add(o),
+        new f(e.x - r, e.y - c).add(s)
       ],
       indices: [0, 1, 1, 3, 3, 2, 2, 0],
       rectIndices: [0, 1, 3, 2, 0]
@@ -2591,31 +2157,25 @@ class LineAnalysis extends Component {
    * @param p1 
    * @param p2 
    */
-  addData(p1, p2) {
-    const dxf = this.Dxf;
-    dxf.data.push([p1.clone(), p2.clone(), [], false, dxf.data.length]);
-    this.appendLineSegmentList.push(new LineSegment(p1.clone(), p2.clone()));
+  addData(t, e) {
+    const n = this.Dxf;
+    n.data.push([t.clone(), e.clone(), [], !1, n.data.length]), this.appendLineSegmentList.push(new b(t.clone(), e.clone()));
   }
   /** 结果分析创建矩形
    * @param result 
    */
-  createRectangle(result) {
-    const dxf = this.Dxf;
-    const project0 = result.project, project1 = result.project2;
-    if (project0.includedAngle(project1) > 135) {
-      project1.points = [project1.points[1], project1.points[0]];
-    }
-    this.addData(project0.points[0], project1.points[0]);
-    this.addData(project0.points[1], project1.points[1]);
-    const leftHeight = project0.points[0].distance(project1.points[0]), rightHeight = project0.points[1].distance(project1.points[1]), count = Math.ceil(Math.max(leftHeight, rightHeight) / dxf.width), leftFragment = leftHeight / count, rightFragment = rightHeight / count, leftDirection = project1.points[0].direction(project0.points[0]), rightDirection = project1.points[1].direction(project0.points[1]), leftP = project0.points[0].clone(), rightP = project0.points[1].clone(), direction = rightP.direction(leftP);
-    direction.multiplyScalar(dxf.width * 0.5);
-    const _leftP = leftP.clone().add(direction), _rightP = rightP.clone().add(direction.multiplyScalar(-1)), d1 = leftP.direction(rightP), d2 = _leftP.direction(_rightP);
-    if (d1.x > 0 && d2.x < 0 || d1.x < 0 && d2.x > 0 || d1.y > 0 && d2.y < 0 || d1.y < 0 && d2.y > 0) return;
-    leftP.set(_leftP.x, _leftP.y);
-    rightP.set(_rightP.x, _rightP.y);
-    for (let i = 1; i < count; i++) {
-      const left = leftDirection.clone().multiplyScalar(leftFragment * i), right = rightDirection.clone().multiplyScalar(rightFragment * i), p1 = leftP.clone().add(left), p2 = rightP.clone().add(right);
-      this.addData(p1, p2);
+  createRectangle(t) {
+    const e = this.Dxf, n = t.project, i = t.project2;
+    n.includedAngle(i) > 135 && (i.points = [i.points[1], i.points[0]]), this.addData(n.points[0], i.points[0]), this.addData(n.points[1], i.points[1]);
+    const s = n.points[0].distance(i.points[0]), o = n.points[1].distance(i.points[1]), r = Math.ceil(Math.max(s, o) / e.width), c = s / r, a = o / r, h = i.points[0].direction(n.points[0]), l = i.points[1].direction(n.points[1]), d = n.points[0].clone(), p = n.points[1].clone(), m = p.direction(d);
+    m.multiplyScalar(e.width * 0.5);
+    const g = d.clone().add(m), u = p.clone().add(m.multiplyScalar(-1)), x = d.direction(p), w = g.direction(u);
+    if (!(x.x > 0 && w.x < 0 || x.x < 0 && w.x > 0 || x.y > 0 && w.y < 0 || x.y < 0 && w.y > 0)) {
+      d.set(g.x, g.y), p.set(u.x, u.y);
+      for (let S = 1; S < r; S++) {
+        const L = h.clone().multiplyScalar(c * S), P = l.clone().multiplyScalar(a * S), A = d.clone().add(L), D = p.clone().add(P);
+        this.addData(A, D);
+      }
     }
   }
   quadtree;
@@ -2623,18 +2183,13 @@ class LineAnalysis extends Component {
    * 构建线段四叉树，快速查找，
    */
   buildQuadtree() {
-    const dxf = this.Dxf;
-    const lineSegmentList = [];
-    this.quadtree = new Quadtree(dxf.originalBox, 2);
-    dxf.lineSegments.forEach((lineSegment) => {
-      if (lineSegment.userData?.isDoor) return;
-      this.quadtree?.insert({
-        line: lineSegment,
-        userData: lineSegmentList.length
-      });
-      lineSegmentList.push(lineSegment);
-    });
-    this.lineSegmentList = lineSegmentList;
+    const t = this.Dxf, e = [];
+    this.quadtree = new q(t.originalBox, 2), t.lineSegments.forEach((n) => {
+      n.userData?.isDoor || (this.quadtree?.insert({
+        line: n,
+        userData: e.length
+      }), e.push(n));
+    }), this.lineSegmentList = e;
   }
   resultList = [];
   mergeWallLines = [];
@@ -2644,24 +2199,18 @@ class LineAnalysis extends Component {
    */
   lineAnalysis() {
     this.buildQuadtree();
-    const quadtree = this.quadtree;
-    const lineSegmentList = this.lineSegmentList;
-    const visited = /* @__PURE__ */ new Set(), resultList = [];
-    lineSegmentList.forEach((_0, i) => {
-      const sourceLineSegment = lineSegmentList[i], rectangle = Rectangle.fromByLineSegment(sourceLineSegment, this.width * 2, false, -0.01), ids = quadtree.queryRect(rectangle).map((i2) => i2.userData).filter((index2) => index2 !== i);
-      ids.forEach((id) => {
+    const t = this.quadtree, e = this.lineSegmentList, n = /* @__PURE__ */ new Set(), i = [];
+    e.forEach((s, o) => {
+      const r = e[o], c = O.fromByLineSegment(r, this.width * 2, !1, -0.01);
+      t.queryRect(c).map((h) => h.userData).filter((h) => h !== o).forEach((h) => {
         try {
-          if (visited.has(`${i}-${id}`) || visited.has(`${id}-${i}`)) return;
-          const res = this.projectionAnalysis(id, i, sourceLineSegment, lineSegmentList);
-          if (res) resultList.push(res);
-          visited.add(`${i}-${id}`);
-        } catch (error) {
+          if (n.has(`${o}-${h}`) || n.has(`${h}-${o}`)) return;
+          const l = this.projectionAnalysis(h, o, r, e);
+          l && i.push(l), n.add(`${o}-${h}`);
+        } catch {
         }
       });
-    });
-    this.appendLineSegmentList.length = 0;
-    resultList.forEach(this.createRectangle.bind(this));
-    this.resultList = resultList;
+    }), this.appendLineSegmentList.length = 0, i.forEach(this.createRectangle.bind(this)), this.resultList = i;
   }
   /** 线段投影分析
    * @param index 
@@ -2669,43 +2218,40 @@ class LineAnalysis extends Component {
    * @param lineSegmentList 
    * @returns 
    */
-  projectionAnalysis(index2, sourceIndex, sourceLineSegment, lineSegmentList) {
-    const temLineSegment = lineSegmentList[index2], direct = sourceLineSegment.direction(), temDirect = temLineSegment.direction(), angle = direct.angleBetween(temDirect) / (Math.PI / 180);
-    if (angle < this.errorAngle || angle > 180 - this.errorAngle) {
-      let data;
-      const p1 = temLineSegment.projectLineSegment(sourceLineSegment), p2 = sourceLineSegment.projectLineSegment(temLineSegment);
-      if (p1.getLength() > p2.getLength()) {
-        data = {
-          target: temLineSegment,
-          targetIndex: index2,
-          source: sourceLineSegment,
-          sourceIndex,
-          project: p1,
-          project2: p2
-        };
-      } else {
-        data = {
-          target: sourceLineSegment,
-          targetIndex: sourceIndex,
-          source: temLineSegment,
-          sourceIndex: index2,
-          project: p2,
-          project2: p1
-        };
-      }
-      if (!data || data.project.getLength() < 0.2 || data.project2.getLength() < 0.2) return;
-      return data;
+  projectionAnalysis(t, e, n, i) {
+    const s = i[t], o = n.direction(), r = s.direction(), c = o.angleBetween(r) / (Math.PI / 180);
+    if (c < this.errorAngle || c > 180 - this.errorAngle) {
+      let a;
+      const h = s.projectLineSegment(n), l = n.projectLineSegment(s);
+      return h.getLength() > l.getLength() ? a = {
+        target: s,
+        targetIndex: t,
+        source: n,
+        sourceIndex: e,
+        project: h,
+        project2: l
+      } : a = {
+        target: n,
+        targetIndex: e,
+        source: s,
+        sourceIndex: t,
+        project: l,
+        project2: h
+      }, !a || a.project.getLength() < 0.2 || a.project2.getLength() < 0.2 ? void 0 : a;
     }
   }
   doorSearchNearAngle = 110;
   doorSearchDistance = 2;
   doors = [];
   doorsAnalysis() {
-    new DoorsAnalysis(this);
+    new rt(this), this.dispatchEvent({
+      type: "analysisCompleted"
+    });
   }
 }
-class DxfSystem extends ComponentManager {
+class ct extends it {
   Dxf;
+  AngleCorrectionDxf;
   Variable;
   wallWidth;
   environment;
@@ -2713,116 +2259,87 @@ class DxfSystem extends ComponentManager {
    * @param wallWidth 输出墙壁厚度，该墙壁厚度不受缩放影响
    * @param scale 原始数据缩放比例
    */
-  constructor(wallWidth = 0.1, scale = 1) {
-    super();
-    this.environment = typeof window !== "undefined" ? "browser" : typeof global !== "undefined" ? "node" : "unknown";
-    this.wallWidth = wallWidth;
-    this.Dxf = new Dxf(this.wallWidth, scale);
-    this.Variable = new Variable();
-    this.addComponent(this.Variable);
-    this.addComponent(this.Dxf);
-    this.addComponent(new LineAnalysis());
+  constructor(t = 0.1, e = 1) {
+    super(), this.environment = typeof window < "u" ? "browser" : typeof global < "u" ? "node" : "unknown", this.wallWidth = t, this.Dxf = new X(this.wallWidth, e), this.AngleCorrectionDxf = new ot(), this.Variable = new _(), this.addComponent(this.Variable), this.addComponent(this.Dxf), this.addComponent(new at()), this.addComponent(this.AngleCorrectionDxf);
   }
-  usePlugin(plugin) {
-    if (typeof plugin === "function") plugin.call(this, this);
-    return this;
+  usePlugin(t) {
+    return typeof t == "function" && t.call(this, this), this;
   }
   destroy() {
-    [...this.components].forEach((com) => {
-      com.destroy();
-    });
-    [...this.components].forEach((com) => {
-      this.removeComponent(com);
+    [...this.components].forEach((t) => {
+      t.destroy();
+    }), [...this.components].forEach((t) => {
+      this.removeComponent(t);
     });
   }
 }
-const exporter = new OBJExporter();
-const glbExporter = new GLTFExporter();
-function lineSqueezing(p1, p2, width = 0.1) {
-  const normal = p2.normal(p1);
-  const pDirect = p2.direction(p1).mutiplyScalar(width * 0.5);
-  const nDirect = p1.direction(p2).mutiplyScalar(width * 0.5);
-  const offsetX = normal.x * width * 0.5;
-  const offsetY = normal.y * width * 0.5;
+const ht = new et(), lt = new nt();
+function dt(y, t, e = 0.1) {
+  const n = t.normal(y), i = t.direction(y).mutiplyScalar(e * 0.5), s = y.direction(t).mutiplyScalar(e * 0.5), o = n.x * e * 0.5, r = n.y * e * 0.5;
   return {
     points: [
       // 第一条线
-      new Point(p1.x + offsetX, p1.y + offsetY).add(nDirect),
-      new Point(p2.x + offsetX, p2.y + offsetY).add(pDirect),
+      new f(y.x + o, y.y + r).add(s),
+      new f(t.x + o, t.y + r).add(i),
       // 第二条线
-      new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect),
-      new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect)
+      new f(y.x - o, y.y - r).add(s),
+      new f(t.x - o, t.y - r).add(i)
     ],
     indices: [0, 1, 1, 3, 3, 2, 2, 0],
     rectIndices: [0, 1, 3, 2, 0]
   };
 }
-class WhiteModel extends Component {
+class H extends j {
   static name = "WhiteModel";
   Dxf = null;
   Variable = null;
   // dxf数据白模
-  whiteModelGroup = new THREE.Group();
+  whiteModelGroup = new M.Group();
   // dxf数据白模边缘线
-  whiteModelLineGroup = new THREE.Group();
+  whiteModelLineGroup = new M.Group();
   // 原始数据白模
-  originalWhiteMode = new THREE.Group();
-  material = new THREE.MeshBasicMaterial({ color: 16777215, transparent: true, opacity: 0.8, side: THREE.DoubleSide });
-  onAddFromParent(parent) {
-    this.Dxf = parent.findComponentByName("Dxf");
-    this.Variable = parent.findComponentByName("Variable");
-    this.originalWhiteMode.visible = false;
-    this.Dxf?.addEventListener("lineOffset", () => {
+  originalWhiteMode = new M.Group();
+  material = new M.MeshBasicMaterial({ color: 16777215, transparent: !0, opacity: 0.8, side: M.DoubleSide });
+  onAddFromParent(t) {
+    this.Dxf = t.findComponentByName("Dxf"), this.Variable = t.findComponentByName("Variable"), this.originalWhiteMode.visible = !1, this.Dxf?.addEventListener("lineOffset", () => {
       this.updateModel();
     });
   }
   updateModel() {
-    this.Variable?.set("whiteModelVisible", false);
-    const dxf = this.Dxf;
-    this.originalWhiteMode.clear();
-    this.whiteModelGroup.clear();
-    this.whiteModelLineGroup.clear();
-    this.whiteModelGroup.add(this.whiteModelLineGroup);
-    this.whiteModelGroup.position.z = dxf.originalZAverage;
-    this.originalWhiteMode.position.z = dxf.originalZAverage;
-    dxf.wallsGroup.forEach((points) => {
-      const shape = new THREE.Shape();
-      points.forEach((p, i) => i === 0 ? shape.moveTo(p.x / dxf.scale, p.y / dxf.scale) : shape.lineTo(p.x / dxf.scale, p.y / dxf.scale));
-      const geometry = new THREE.ExtrudeGeometry(shape, {
+    this.Variable?.set("whiteModelVisible", !1);
+    const t = this.Dxf;
+    this.originalWhiteMode.clear(), this.whiteModelGroup.clear(), this.whiteModelLineGroup.clear(), this.whiteModelGroup.add(this.whiteModelLineGroup), this.whiteModelGroup.position.z = t.originalZAverage, this.originalWhiteMode.position.z = t.originalZAverage, t.wallsGroup.forEach((n) => {
+      const i = new M.Shape();
+      n.forEach((r, c) => c === 0 ? i.moveTo(r.x / t.scale, r.y / t.scale) : i.lineTo(r.x / t.scale, r.y / t.scale));
+      const s = new M.ExtrudeGeometry(i, {
         depth: 2.8,
         bevelSize: 0
-      });
-      const mesh = new THREE.Mesh(geometry, this.material);
-      this.whiteModelGroup.add(mesh);
-      this.whiteModelLineGroup.add(
-        new THREE.LineSegments(new THREE.EdgesGeometry(geometry), new THREE.LineBasicMaterial({ color: 0 }))
+      }), o = new M.Mesh(s, this.material);
+      this.whiteModelGroup.add(o), this.whiteModelLineGroup.add(
+        new M.LineSegments(new M.EdgesGeometry(s), new M.LineBasicMaterial({ color: 0 }))
       );
-    });
-    const walls = dxf.originalData.map(({ start, end, insetionArr }) => {
-      const startVec3 = new Point(start.x, start.y).mutiplyScalar(dxf.scale), endVec3 = new Point(end.x, end.y).mutiplyScalar(dxf.scale), { points, indices, rectIndices } = lineSqueezing(startVec3, endVec3, dxf.width);
+    }), t.originalData.map(({ start: n, end: i, insetionArr: s }) => {
+      const o = new f(n.x, n.y).mutiplyScalar(t.scale), r = new f(i.x, i.y).mutiplyScalar(t.scale), { points: c, indices: a, rectIndices: h } = dt(o, r, t.width);
       return {
-        points,
-        indices,
-        rectIndices,
-        insetions: (insetionArr ?? []).map((insetion) => insetion.index)
+        points: c,
+        indices: a,
+        rectIndices: h,
+        insetions: (s ?? []).map((l) => l.index)
       };
-    });
-    walls.forEach((wall) => {
-      const shape = new THREE.Shape();
-      wall.rectIndices.forEach((index2, i) => {
-        const p = wall.points[index2];
-        if (i === 0) shape.moveTo(p.x, p.y);
-        else shape.lineTo(p.x, p.y);
+    }).forEach((n) => {
+      const i = new M.Shape();
+      n.rectIndices.forEach((r, c) => {
+        const a = n.points[r];
+        c === 0 ? i.moveTo(a.x, a.y) : i.lineTo(a.x, a.y);
       });
-      const geometry = new THREE.ExtrudeGeometry(shape, {
+      const s = new M.ExtrudeGeometry(i, {
         depth: 2.8,
         bevelSize: 0
       });
-      if (geometry.attributes.position.array.filter((num) => Number.isNaN(num)).length) return;
-      const mesh = new THREE.Mesh(geometry);
-      this.originalWhiteMode?.add(mesh);
-    });
-    this.dispatchEvent({
+      if (s.attributes.position.array.filter((r) => Number.isNaN(r)).length) return;
+      const o = new M.Mesh(s);
+      this.originalWhiteMode?.add(o);
+    }), this.dispatchEvent({
       type: "updateModel",
       originalWhiteMode: this.originalWhiteMode,
       whiteModelGroup: this.whiteModelGroup
@@ -2833,13 +2350,9 @@ class WhiteModel extends Component {
    * @returns 
    */
   toOBJ() {
-    return new Promise((resolve) => {
-      this.material.opacity = 1;
-      this.material.needsUpdate = true;
-      setTimeout(() => {
-        resolve(exporter.parse(this.whiteModelGroup));
-        this.material.opacity = 0.8;
-        this.material.transparent = true;
+    return new Promise((t) => {
+      this.material.opacity = 1, this.material.needsUpdate = !0, setTimeout(() => {
+        t(ht.parse(this.whiteModelGroup)), this.material.opacity = 0.8, this.material.transparent = !0;
       }, 20);
     });
   }
@@ -2848,38 +2361,28 @@ class WhiteModel extends Component {
    * @param binary 
    * @returns 
    */
-  toGltf(binary = true) {
-    return new Promise((resolve) => {
-      this.material.opacity = 1;
-      this.material.needsUpdate = true;
-      setTimeout(async () => {
-        if (typeof window === "object") {
-          glbExporter.parse(this.whiteModelGroup.children, (gltf) => {
-            resolve(gltf);
-            this.material.opacity = 0.8;
-            this.material.transparent = true;
+  toGltf(t = !0) {
+    return new Promise((e) => {
+      this.material.opacity = 1, this.material.needsUpdate = !0, setTimeout(async () => {
+        if (typeof window == "object")
+          lt.parse(this.whiteModelGroup.children, (n) => {
+            e(n), this.material.opacity = 0.8, this.material.transparent = !0;
           }, () => {
-            resolve(void 0);
+            e(void 0);
           }, {
-            binary
+            binary: t
           });
-        } else if (typeof global !== "function") {
+        else if (typeof global != "function")
           try {
-            const obj2gltf = await include("obj2gltf", true);
-            const fs = await include("fs", false);
-            const obj = await this.toOBJ();
-            fs.writeFileSync(this.uuid, obj);
-            const result = await obj2gltf(this.uuid, {
-              binary
+            const n = await G("obj2gltf", !0), i = await G("fs", !1), s = await this.toOBJ();
+            i.writeFileSync(this.uuid, s);
+            const o = await n(this.uuid, {
+              binary: t
             });
-            fs.unlinkSync(this.uuid);
-            if (binary) resolve(result);
-            else resolve(JSON.stringify(result));
-          } catch (error) {
-            resolve(void 0);
-            console.log(error);
+            i.unlinkSync(this.uuid), e(t ? o : JSON.stringify(o));
+          } catch (n) {
+            e(void 0), console.log(n);
           }
-        }
       }, 20);
     });
   }
@@ -2888,40 +2391,33 @@ class WhiteModel extends Component {
    * @returns 
    */
   async toOBJBlob() {
-    const buffer = await this.toOBJ();
-    if (buffer) {
-      return new Blob([buffer], { type: "application/octet-stream" });
-    }
+    const t = await this.toOBJ();
+    if (t)
+      return new Blob([t], { type: "application/octet-stream" });
   }
   /**
    * 转为 GltfBlob
    * @returns 
    */
-  async toGltfBlob(binary = true) {
-    const buffer = await this.toGltf(binary);
-    if (buffer) {
-      return new Blob([buffer], { type: "application/octet-stream" });
-    }
+  async toGltfBlob(t = !0) {
+    const e = await this.toGltf(t);
+    if (e)
+      return new Blob([e], { type: "application/octet-stream" });
   }
   /**
    * 下载 OBJ
    * @param filename 
    * @returns 
    */
-  async downloadOBJ(filename) {
-    if (typeof window !== "undefined") {
-      const blob = await this.toOBJBlob();
-      if (!blob) return;
-      const a = document.createElement("a");
-      a.href = URL.createObjectURL(blob);
-      a.download = filename;
-      a.click();
-    } else if (typeof global !== "undefined") {
-      const buffer = await this.toOBJ();
-      if (buffer) {
-        const fs = await include("fs", false);
-        fs.writeFileSync(filename, buffer);
-      }
+  async downloadOBJ(t) {
+    if (typeof window < "u") {
+      const e = await this.toOBJBlob();
+      if (!e) return;
+      const n = document.createElement("a");
+      n.href = URL.createObjectURL(e), n.download = t, n.click();
+    } else if (typeof global < "u") {
+      const e = await this.toOBJ();
+      e && (await G("fs", !1)).writeFileSync(t, e);
     }
   }
   /**
@@ -2929,24 +2425,19 @@ class WhiteModel extends Component {
    * @param filename 
    * @returns 
    */
-  async downloadGltf(filename, binary = true) {
-    if (typeof window !== "undefined") {
-      const blob = await this.toGltfBlob(binary);
-      if (!blob) return;
-      const a = document.createElement("a");
-      a.href = URL.createObjectURL(blob);
-      a.download = filename;
-      a.click();
-    } else if (typeof global !== "undefined") {
-      const buffer = await this.toGltf(binary);
-      if (buffer) {
-        const fs = await include("fs", false);
-        fs.writeFileSync(filename, binary ? buffer : Buffer.from(buffer));
-      }
+  async downloadGltf(t, e = !0) {
+    if (typeof window < "u") {
+      const n = await this.toGltfBlob(e);
+      if (!n) return;
+      const i = document.createElement("a");
+      i.href = URL.createObjectURL(n), i.download = t, i.click();
+    } else if (typeof global < "u") {
+      const n = await this.toGltf(e);
+      n && (await G("fs", !1)).writeFileSync(t, e ? n : Buffer.from(n));
     }
   }
 }
-class DetailsPoint extends Component {
+class Z extends j {
   static name = "DetailsPoint";
   Dxf = null;
   WhiteModel = null;
@@ -2954,10 +2445,8 @@ class DetailsPoint extends Component {
   desPoints = [];
   raylines = [];
   data = [];
-  onAddFromParent(parent) {
-    this.Dxf = parent.findComponentByName("Dxf");
-    this.Variable = parent.findComponentByName("Variable");
-    this.Dxf?.addEventListener("setDta", () => {
+  onAddFromParent(t) {
+    this.Dxf = t.findComponentByName("Dxf"), this.Variable = t.findComponentByName("Variable"), this.Dxf?.addEventListener("setDta", () => {
       this.updateModel();
     });
   }
@@ -2965,37 +2454,29 @@ class DetailsPoint extends Component {
    * 设置值
    * @param data 
    */
-  async set(data) {
-    if (typeof data === "string") {
-      if (typeof global !== "undefined") {
-        const packageName = "fs";
-        const { default: fs } = await import(
+  async set(t) {
+    if (typeof t == "string")
+      if (typeof global < "u") {
+        const { default: n } = await import(
           /* @vite-ignore */
-          packageName
-        );
-        const buffer = fs.readFileSync(data);
-        const json = JSON.parse(buffer.toString("utf-8"));
-        this.set(json);
+          "fs"
+        ), i = n.readFileSync(t), s = JSON.parse(i.toString("utf-8"));
+        this.set(s);
         return;
-      } else {
+      } else
         throw new Error("非node环境不允许使用路径");
-      }
-    }
-    this.data = data;
-    this.updateModel();
+    this.data = t, this.updateModel();
   }
   /**
    * 设置射线辅助
    */
-  racasterHelper(position, direction, far) {
-    this.raylines.push([
-      position.clone(),
-      position.clone().add(direction.clone().multiplyScalar(far))
-    ]);
-    direction.z = 0;
+  racasterHelper(t, e, n) {
     this.raylines.push([
-      position.clone(),
-      position.clone().add(direction.clone().multiplyScalar(far))
+      t.clone(),
+      t.clone().add(e.clone().multiplyScalar(n))
+    ]), e.z = 0, this.raylines.push([
+      t.clone(),
+      t.clone().add(e.clone().multiplyScalar(n))
     ]);
   }
   _timer = null;
@@ -3003,161 +2484,134 @@ class DetailsPoint extends Component {
    * 更新模型
    */
   updateModel() {
-    if (this._timer) clearTimeout(this._timer);
-    this._timer = setTimeout(() => {
+    this._timer && clearTimeout(this._timer), this._timer = setTimeout(() => {
       this._timer = null;
-      const whiteModel = this.parent?.findComponentByName("WhiteModel");
-      this.raylines.length = 0;
-      this.desPoints.length = 0;
-      this.data.forEach((item) => {
-        const position = new THREE.Vector3(
-          item.position.x,
-          item.position.y,
-          item.position.z
-        );
-        const direction = new THREE.Vector3(
-          item.direction.x,
-          item.direction.y,
-          item.direction.z
-        );
-        const far = 100;
-        this.racasterHelper(position, direction, far);
-        direction.z = 0;
-        const raycaster = new THREE.Raycaster(position, direction, 0, far);
-        const list = raycaster.intersectObject(whiteModel.originalWhiteMode);
-        if (list.length) {
-          const { point } = list[0];
+      const t = this.parent?.findComponentByName("WhiteModel");
+      this.raylines.length = 0, this.desPoints.length = 0, this.data.forEach((e) => {
+        const n = new M.Vector3(
+          e.position.x,
+          e.position.y,
+          e.position.z
+        ), i = new M.Vector3(
+          e.direction.x,
+          e.direction.y,
+          e.direction.z
+        ), s = 100;
+        this.racasterHelper(n, i, s), i.z = 0;
+        const r = new M.Raycaster(n, i, 0, s).intersectObject(t.originalWhiteMode);
+        if (r.length) {
+          const { point: c } = r[0];
           this.desPoints.push({
-            message: item.desc,
-            position,
-            intersection: point
+            message: e.desc,
+            position: n,
+            intersection: c
           });
         }
-      });
-      this.dispatchEvent({
+      }), this.dispatchEvent({
         type: "handleSuccess",
         desPoints: this.desPoints
       });
     }, 50);
   }
 }
-class DxfLineModel extends Component {
+class K extends j {
   static name = "DxfLineModel";
-  dxfLineModel = new THREE.LineSegments();
-  dxfDoorsLineModel = new THREE.LineSegments();
-  dxfModelGroup = new THREE.Group();
-  onAddFromParent(parent) {
-    const dxf = parent.findComponentByName("Dxf");
-    this.dxfModelGroup.add(this.dxfLineModel);
-    this.dxfModelGroup.add(this.dxfDoorsLineModel);
-    this.dxfDoorsLineModel.material = new THREE.LineBasicMaterial({ color: 16776960, vertexColors: true });
-    dxf?.addEventListener("lineOffset", () => this.updateMode());
+  dxfLineModel = new M.LineSegments();
+  dxfDoorsLineModel = new M.LineSegments();
+  dxfModelGroup = new M.Group();
+  onAddFromParent(t) {
+    const e = t.findComponentByName("Dxf");
+    this.dxfModelGroup.add(this.dxfLineModel), this.dxfModelGroup.add(this.dxfDoorsLineModel), this.dxfDoorsLineModel.material = new M.LineBasicMaterial({ color: 16776960, vertexColors: !0 }), e?.addEventListener("lineOffset", () => this.updateMode());
   }
   updateMode() {
-    const dxf = this.parent?.findComponentByName("Dxf");
+    const t = this.parent?.findComponentByName("Dxf");
     this.dxfLineModel.clear();
-    const dxfArray = dxf.to3DArray(1 / dxf.scale, 0);
-    this.dxfLineModel.geometry = new THREE.BufferGeometry().setAttribute("position", new THREE.BufferAttribute(dxfArray, 3, true));
-    const doorsArray = new Float32Array(
-      dxf.doorLineSegment.flatMap(({ start, end }) => [start.x, start.y, 0, end.x, end.y, 0])
-    ).map((n) => n / dxf.scale);
-    const doorsColorArray = new Float32Array(dxf.doorLineSegment.flatMap(() => [1, 0, 0, 0, 1, 0]));
-    this.dxfDoorsLineModel.geometry = new THREE.BufferGeometry().setAttribute("position", new THREE.BufferAttribute(doorsArray, 3, true)).setAttribute("color", new THREE.BufferAttribute(doorsColorArray, 3));
-    this.dxfModelGroup.position.z = dxf.originalZAverage;
-    this.dispatchEvent({
+    const e = t.to3DArray(1 / t.scale, 0);
+    this.dxfLineModel.geometry = new M.BufferGeometry().setAttribute("position", new M.BufferAttribute(e, 3, !0));
+    const n = new Float32Array(
+      t.doorLineSegment.flatMap(({ start: s, end: o }) => [s.x, s.y, 0, o.x, o.y, 0])
+    ).map((s) => s / t.scale), i = new Float32Array(t.doorLineSegment.flatMap(() => [1, 0, 0, 0, 1, 0]));
+    this.dxfDoorsLineModel.geometry = new M.BufferGeometry().setAttribute("position", new M.BufferAttribute(n, 3, !0)).setAttribute("color", new M.BufferAttribute(i, 3)), this.dxfModelGroup.position.z = t.originalZAverage, this.dispatchEvent({
       type: "modelUpdate",
       model: this.dxfModelGroup
     });
   }
 }
-const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const ut = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  DetailsPoint,
-  DxfLineModel,
-  WhiteModel
+  DetailsPoint: Z,
+  DxfLineModel: K,
+  WhiteModel: H
 }, Symbol.toStringTag, { value: "Module" }));
-function ModelDataPlugin_(dxfSystem, option = {}) {
+function W(y, t = {}) {
   const {
-    detailsPoint = true,
-    whiteModel = true,
-    dxfLineModel = true
-  } = option;
-  dxfLineModel && dxfSystem.addComponent(new DxfLineModel());
-  whiteModel && dxfSystem.addComponent(new WhiteModel());
-  detailsPoint && dxfSystem.addComponent(new DetailsPoint());
+    detailsPoint: e = !0,
+    whiteModel: n = !0,
+    dxfLineModel: i = !0
+  } = t;
+  i && y.addComponent(new K()), n && y.addComponent(new H()), e && y.addComponent(new Z());
 }
-const ModelDataPlugin = Object.assign(ModelDataPlugin_, {
-  create(option = {}) {
-    return (dxfSystem) => ModelDataPlugin_(dxfSystem, option);
+const ft = Object.assign(W, {
+  create(y = {}) {
+    return (t) => W(t, y);
   }
-});
-const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}), pt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  ModelDataPlugin,
-  components: index$1
+  ModelDataPlugin: ft,
+  components: ut
 }, Symbol.toStringTag, { value: "Module" }));
-function loadRenderPlugin() {
+function mt() {
   return import("./index2.js");
 }
-function loadEditorPlugin() {
+function xt() {
   return import("./index3.js");
 }
-let gloabalDxfSystem = null;
-async function createEditor(dom, camera, orbitControls = false, viewPermission) {
-  const mp = await Promise.resolve().then(() => index);
-  const rp = await loadRenderPlugin();
-  const editor = await loadEditorPlugin();
-  const dxfSystem = new DxfSystem().usePlugin(mp.ModelDataPlugin.create({
-    detailsPoint: false,
-    whiteModel: true
-  })).usePlugin(rp.RenderPlugin.create({
-    originalLine: false,
-    modelData: false,
-    detailsPoint: false,
-    orbitControls,
-    camera
-  })).usePlugin(editor.Editor.create({ viewPermission }));
-  const domContainer = dxfSystem.findComponentByType(rp.components.DomContainer);
-  domContainer && dom.appendChild(domContainer.domElement);
-  gloabalDxfSystem = dxfSystem;
-  return {
-    dxfSystem,
-    getFileAll: () => getFileAll(dxfSystem)
+let V = null;
+async function Et(y, t, e = !1, n) {
+  const i = await Promise.resolve().then(() => pt), s = await mt(), o = await xt(), r = new ct().usePlugin(i.ModelDataPlugin.create({
+    detailsPoint: !1,
+    whiteModel: !0
+  })).usePlugin(s.RenderPlugin.create({
+    originalLine: !1,
+    modelData: !1,
+    detailsPoint: !1,
+    orbitControls: e,
+    camera: t
+  })).usePlugin(o.Editor.create({ viewPermission: n })), c = r.findComponentByType(s.components.DomContainer);
+  return c && y.appendChild(c.domElement), V = r, {
+    dxfSystem: r,
+    getFileAll: () => yt(r)
   };
 }
-async function getFileAll(dxfSystem = gloabalDxfSystem) {
-  const whiteModel = dxfSystem.findComponentByName("WhiteModel");
-  const dxf = new File([dxfSystem.Dxf.toDxfBlob()], "dxf.dxf", { type: "application/dxf" });
-  const obj = new File([await whiteModel.toOBJBlob()], "model.obj", { type: "application/octet-stream" });
-  const glb = new File([await whiteModel.toGltfBlob(true)], "model.glb", { type: "application/octet-stream" });
-  const gltf = new File([await whiteModel.toGltfBlob(false)], "model.gltf", { type: "application/json" });
-  const json = new File([JSON.stringify(dxfSystem.Dxf.originalData)], "json.json", { type: "application/json" });
+async function yt(y = V) {
+  const t = y.findComponentByName("WhiteModel"), e = new File([await y.AngleCorrectionDxf.toDxfImageBlob()], "img.jpg", { type: "image/jpeg" }), n = new File([y.Dxf.toDxfBlob()], "dxf.dxf", { type: "application/dxf" }), i = new File([await t.toOBJBlob()], "model.obj", { type: "application/octet-stream" }), s = new File([await t.toGltfBlob(!0)], "model.glb", { type: "application/octet-stream" }), o = new File([await t.toGltfBlob(!1)], "model.gltf", { type: "application/json" }), r = new File([JSON.stringify(y.Dxf.originalData)], "json.json", { type: "application/json" });
   return {
-    dxf,
-    obj,
-    glb,
-    gltf,
-    json
+    dxf: n,
+    obj: i,
+    glb: s,
+    gltf: o,
+    json: r,
+    jpg: e
   };
 }
-function getGlobalDxfSystem() {
-  return gloabalDxfSystem;
+function At() {
+  return V;
 }
 export {
-  Box2 as B,
-  Component as C,
-  DxfSystem as D,
-  EventDispatcher as E,
-  LineSegment as L,
-  ModelDataPlugin as M,
-  Point as P,
-  Quadtree as Q,
-  Variable as V,
-  WhiteModel as W,
-  DetailsPoint as a,
-  PointVirtualGrid as b,
-  createEditor as c,
-  getGlobalDxfSystem as d,
-  getFileAll as g,
-  index$1 as i
+  v as B,
+  j as C,
+  ct as D,
+  $ as E,
+  b as L,
+  ft as M,
+  f as P,
+  q as Q,
+  _ as V,
+  H as W,
+  Z as a,
+  U as b,
+  Et as c,
+  At as d,
+  yt as g,
+  ut as i
 };