build-dxf 0.0.20-15 → 0.0.20-23

package/src/build.js

@@ -1,55 +1,70 @@
-import * as M from "three";
-import { EventDispatcher as K } from "three";
-import V from "clipper-lib";
-import N from "dxf-writer";
-import { OBJExporter as Q } from "three/examples/jsm/exporters/OBJExporter.js";
-import { GLTFExporter as tt } from "three/examples/jsm/exporters/GLTFExporter.js";
-function T() {
-  return "xxxx-xxxx-4xxx-yxxx-xxxx".replace(/[xy]/g, function(g) {
-    var t = Math.random() * 16 | 0, e = g == "x" ? t : t & 3 | 8;
-    return e.toString(16);
+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);
   });
 }
-class $ extends K {
-  uuid = T();
-  addEventListener(t, e, n) {
-    const { once: i = !1 } = n ?? {}, o = (r) => {
-      e(r), i && s();
-    }, s = () => this.removeEventListener(t, o);
-    return super.addEventListener(t, o), s;
+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;
   }
   eventRecordStack = /* @__PURE__ */ new Map();
-  addEventRecord(t, ...e) {
-    this.eventRecordStack.has(t) || this.eventRecordStack.set(t, []), e.forEach((i) => {
-      this.eventRecordStack.get(t)?.push(i);
+  addEventRecord(name, ...cancels) {
+    if (!this.eventRecordStack.has(name)) this.eventRecordStack.set(name, []);
+    cancels.forEach((cancel) => {
+      this.eventRecordStack.get(name)?.push(cancel);
     });
-    const n = (i) => (this.addEventRecord(t, i), { add: n });
-    return { add: n };
+    const add = (cancel) => {
+      this.addEventRecord(name, cancel);
+      return { add };
+    };
+    return { add };
   }
-  canceEventRecord(t) {
-    const e = this.eventRecordStack.get(t);
-    e && (e.forEach((n) => n()), this.eventRecordStack.delete(t));
+  canceEventRecord(name) {
+    const list = this.eventRecordStack.get(name);
+    if (list) {
+      list.forEach((cancel) => cancel());
+      this.eventRecordStack.delete(name);
+    }
   }
 }
-class X extends $ {
+class Component extends EventDispatcher {
   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);
+  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);
     });
   }
-  onAddFromParent(t) {
+  onAddFromParent(parent) {
   }
-  onRemoveFromParent(t) {
+  onRemoveFromParent(parent) {
   }
   destroy() {
-    this.destroyed = !0;
+    this.destroyed = true;
   }
 }
-class et extends $ {
+class ComponentManager extends EventDispatcher {
   static EventType = {
     ADD_COMPONENT: "addComponent"
   };
@@ -58,66 +73,75 @@ class et extends $ {
    * 添加组件
    * @param component 
    */
-  addComponent(t) {
-    return t && (this.components.push(t), this.dispatchEvent({
-      type: "addComponent",
-      component: t
-    }), t.dispatchEvent({
-      type: "addFromParent",
-      parent: this
-    })), this;
+  addComponent(component) {
+    if (component) {
+      this.components.push(component);
+      this.dispatchEvent({
+        type: "addComponent",
+        component
+      });
+      component.dispatchEvent({
+        type: "addFromParent",
+        parent: this
+      });
+    }
+    return this;
   }
   /**
    * 移除组件
    * @param component 
    */
-  removeComponent(t) {
-    if (t instanceof X) {
-      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
-      }));
+  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
+        });
+      }
     }
   }
   /**
    * 查找符合条件的第一个组件
    * @param callBack 
    */
-  findComponent(t) {
-    for (let e = 0; e < this.components.length; e++) {
-      const n = this.components[e];
-      if (t(n, e)) return n;
+  findComponent(predicate) {
+    for (let i = 0; i < this.components.length; i++) {
+      const component = this.components[i];
+      if (predicate(component, i)) return component;
     }
   }
   /**
    * 查找所有符合条件的组件
    * @param callBack 
    */
-  findComponents(t) {
-    return this.components.filter(t);
+  findComponents(predicate) {
+    return this.components.filter(predicate);
   }
   /**
    * 
    * @param type 
    */
-  findComponentByType(t) {
-    const e = this.findComponent((n) => n instanceof t);
-    return e || null;
+  findComponentByType(type) {
+    const component = this.findComponent((c) => c instanceof type);
+    return component ? component : null;
   }
   /**
    * 
    * @param type 
    */
-  findComponentByName(t) {
-    const e = this.findComponent((n) => n.constructor.name === t);
-    return e || null;
+  findComponentByName(name) {
+    const component = this.findComponent((c) => c.constructor.name === name);
+    return component ? component : null;
   }
 }
-class f {
+class Point {
   x;
   y;
   get X() {
@@ -132,32 +156,39 @@ class f {
    * @param x 
    * @param y 
    */
-  constructor(t = 0, e = 0) {
-    this.x = t, this.y = e;
+  constructor(x = 0, y = 0) {
+    this.x = x;
+    this.y = y;
   }
-  set(t, e) {
-    return this.x = t, this.y = e, this;
+  set(x, y) {
+    this.x = x;
+    this.y = y;
+    return this;
   }
-  setX(t) {
-    return this.x = t, this;
+  setX(x) {
+    this.x = x;
+    return this;
   }
-  setY(t) {
-    return this.y = t, this;
+  setY(y) {
+    this.y = y;
+    return this;
   }
   /**
    * 
    * @param point 
    * @returns 
    */
-  equal(t) {
-    return t.x === this.x && t.y === this.y;
+  equal(point) {
+    return point.x === this.x && point.y === this.y;
   }
   /**
    * 
    * @param arr 
    */
-  setByArray(t) {
-    return this.x = t[0], this.y = t[1], this;
+  setByArray(arr) {
+    this.x = arr[0];
+    this.y = arr[1];
+    return this;
   }
   /**
    * 
@@ -169,19 +200,25 @@ class f {
    * multiplyScalar
    * @param scalar 
    */
-  mutiplyScalar(t) {
-    return this.x *= t, this.y *= t, this;
+  mutiplyScalar(scalar) {
+    this.x *= scalar;
+    this.y *= scalar;
+    return this;
   }
-  multiplyScalar(t) {
-    return this.x *= t, this.y *= t, this;
+  multiplyScalar(scalar) {
+    this.x *= scalar;
+    this.y *= scalar;
+    return this;
   }
   /**
    * 
    * @param scalar 
    * @returns 
    */
-  divisionScalar(t) {
-    return this.x /= t, this.y /= t, this;
+  divisionScalar(scalar) {
+    this.x /= scalar;
+    this.y /= scalar;
+    return this;
   }
   /**
    * 减法
@@ -189,8 +226,10 @@ class f {
    * @param point
    * @returns 
    */
-  division(t) {
-    return this.x -= t.x, this.y -= t.y, this;
+  division(point) {
+    this.x -= point.x;
+    this.y -= point.y;
+    return this;
   }
   /**
    * 加法
@@ -198,15 +237,19 @@ class f {
    * @param point 
    * @returns 
    */
-  add(t) {
-    return this.x += t.x, this.y += t.y, this;
+  add(point) {
+    this.x += point.x;
+    this.y += point.y;
+    return this;
   }
   /**
    * 保留小数位数
    * @param count 
    */
-  fixed(t) {
-    return this.x = Number(this.x.toFixed(t)), this.y = Number(this.y.toFixed(t)), this;
+  fixed(count) {
+    this.x = Number(this.x.toFixed(count));
+    this.y = Number(this.y.toFixed(count));
+    return this;
   }
   /**
    * 归一化
@@ -214,8 +257,11 @@ class f {
    * @returns 
    */
   normalize() {
-    const t = Math.sqrt(this.x * this.x + this.y * this.y);
-    return t === 0 ? this : (this.x /= t, this.y /= t, this);
+    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;
   }
   /**
    * 获取单位法向量
@@ -223,9 +269,13 @@ class f {
    * @param point 
    * @returns 
    */
-  normal(t) {
-    const e = this.x - t.x, n = this.y - t.y, i = Math.sqrt(e * e + n * n), o = -n / i, s = e / i;
-    return new f(o, s);
+  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);
   }
   /**
    * 获取由传入的点到该点的单位方向向量
@@ -233,9 +283,12 @@ class f {
    * @param point 
    * @returns 
    */
-  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);
+  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);
   }
   /**
    * 计算模长
@@ -249,8 +302,8 @@ class f {
    * @param point 
    * @returns 
    */
-  dot(t) {
-    return this.x * t.x + this.y * t.y;
+  dot(point) {
+    return this.x * point.x + this.y * point.y;
   }
   /** 求两个点叉积
    * @description 如果叉积大于 0，a 到 b 为逆时针方向。
@@ -258,8 +311,8 @@ class f {
    * @param point 
    * @returns 
    */
-  cross(t) {
-    return this.x * t.y - this.y * this.x;
+  cross(point) {
+    return this.x * point.y - this.y * this.x;
   }
   /** 计算两个向量夹角
    * @description 公式：a · b = |a| × |b| × cosθ
@@ -267,25 +320,34 @@ class f {
    * @param point 
    * @returns 
    */
-  angleBetween(t, e = "radian", n = "180") {
-    const i = this.dot(t), o = this.magnitude(), s = t.magnitude();
-    if (o === 0 || s === 0) return 0;
-    const r = i / (o * s), a = Math.max(-1, Math.min(1, r));
-    return e === "radian" ? Math.acos(a) : e === "cos" ? a : n === "180" || this.cross(t) < 0 ? Math.acos(a) / (Math.PI / 180) : 360 - Math.acos(a) / (Math.PI / 180);
+  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);
   }
   /** 获取向量长度
    */
   length() {
-    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;
+    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;
   }
   /**
    * 获取两个点长度
    * @param point 
    */
-  distance(t) {
+  distance(point) {
     return Math.sqrt(
-      (this.x - t.x) * (this.x - t.x) + (this.y - t.y) * (this.y - t.y)
+      (this.x - point.x) * (this.x - point.x) + (this.y - point.y) * (this.y - point.y)
     );
   }
   /**
@@ -293,40 +355,47 @@ class f {
    * @returns 
    */
   clone() {
-    return new f(this.x, this.y);
+    return new Point(this.x, this.y);
   }
   /**
    * 克隆
    * @returns 
    */
-  copy(t) {
-    this.x = t.x ?? 0, this.y = t.y ?? 0;
+  copy(p) {
+    this.x = p.x ?? 0;
+    this.y = p.y ?? 0;
   }
-  toJson(t = 0) {
+  toJson() {
     return {
       x: this.x,
-      y: this.y,
-      z: t
+      y: this.y
     };
   }
-  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 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 zero() {
-    return new f(0, 0);
+    return new Point(0, 0);
   }
 }
-class A {
+class Box2 {
   minX = 0;
   maxX = 0;
   minY = 0;
   maxY = 0;
   get points() {
     return [
-      new f(this.minX, this.minY),
-      new f(this.maxX, this.minY),
-      new f(this.maxX, this.maxY),
-      new f(this.minX, this.maxY)
+      new Point(this.minX, this.minY),
+      new Point(this.maxX, this.minY),
+      new Point(this.maxX, this.maxY),
+      new Point(this.minX, this.maxY)
     ];
   }
   get width() {
@@ -336,122 +405,163 @@ class A {
     return this.maxY - this.minY;
   }
   get center() {
-    return new f(
+    return new Point(
       this.minX + (this.maxX - this.minX) * 0.5,
       this.minY + (this.maxY - this.minY) * 0.5
     );
   }
-  constructor(t = 0, e = 0, n = 0, i = 0) {
-    this.minX = t, this.maxX = e, this.minY = n, this.maxY = i;
+  constructor(minX = 0, maxX = 0, minY = 0, maxY = 0) {
+    this.minX = minX;
+    this.maxX = maxX;
+    this.minY = minY;
+    this.maxY = maxY;
   }
   /**
    * 
    * @param z 
    * @returns 
    */
-  getPaths3D(t = 0) {
-    const e = this.points, n = [];
-    return e.forEach((i, o) => {
-      const s = e[(o + 1) % e.length];
-      n.push(i.x, i.y, t), n.push(s.x, s.y, t);
-    }), n;
+  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;
   }
   /**
    * 判断线段是与包围盒相交
    * @description Liang-Barsky算法的变种
    * @param line 
    */
-  intersectLineSegment(t) {
-    const e = t.points[0], n = t.points[1], i = n.x - e.x, o = n.y - e.y;
-    if (i === 0 && o === 0)
-      return this.minX <= e.x && e.x <= this.maxX && this.minY <= e.y && e.y <= this.maxY;
-    let s = Number.NEGATIVE_INFINITY, r = Number.POSITIVE_INFINITY;
-    if (i !== 0) {
-      const a = (this.minX - e.x) / i, c = (this.maxX - e.x) / i;
-      s = Math.max(s, Math.min(a, c)), r = Math.min(r, Math.max(a, c));
-    } else if (e.x < this.minX || e.x > this.maxX)
-      return !1;
-    if (o !== 0) {
-      const a = (this.minY - e.y) / o, c = (this.maxY - e.y) / o;
-      s = Math.max(s, Math.min(a, c)), r = Math.min(r, Math.max(a, c));
-    } else if (e.y < this.minY || e.y > this.maxY)
-      return !1;
-    return s <= r && s <= 1 && r >= 0;
+  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;
   }
   /**
    * 判断线段是在包围盒内
    * @param line 
    */
-  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;
+  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;
   }
   /**
    * 判断矩形与包围盒相交
    * @param rectangle 
    */
-  intersectRectangle(t) {
-    const e = (s) => this.minX <= s.x && s.x <= this.maxX && this.minY <= s.y && s.y <= this.maxY, n = (s) => {
-      let r = 0;
-      for (let a = 0; a < 4; a++) {
-        const c = t.points[a], h = t.points[(a + 1) % 4], l = { x: h.x - c.x, y: h.y - c.y }, d = { x: s.x - c.x, y: s.y - c.y }, x = l.x * d.y - l.y * d.x;
-        if (x === 0) {
-          const p = l.x !== 0 ? (s.x - c.x) / l.x : (s.y - c.y) / l.y;
-          if (p >= 0 && p <= 1) return !0;
+  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;
         } else {
-          const p = x > 0 ? 1 : -1;
-          if (r === 0 && (r = p), r !== p) return !1;
+          const currentSign = cross > 0 ? 1 : -1;
+          if (sign === 0) sign = currentSign;
+          if (sign !== currentSign) return false;
         }
       }
-      return !0;
-    }, i = (s, r, a, c) => {
-      const h = (u, m, y) => {
-        const S = (m.y - u.y) * (y.x - m.x) - (m.x - u.x) * (y.y - m.y);
-        return S === 0 ? 0 : S > 0 ? 1 : 2;
-      }, l = (u, m, y) => Math.min(u.x, y.x) <= m.x && m.x <= Math.max(u.x, y.x) && Math.min(u.y, y.y) <= m.y && m.y <= Math.max(u.y, y.y), d = h(s, r, a), x = h(s, r, c), p = h(a, c, s), w = h(a, c, r);
-      return !!(d !== x && p !== w || d === 0 && l(s, a, r) || x === 0 && l(s, c, r) || p === 0 && l(a, s, c) || w === 0 && l(a, r, c));
-    }, o = this.points;
-    for (let s = 0; s < 4; s++) {
-      const r = o[s], a = o[(s + 1) % 4];
-      for (let c = 0; c < 4; c++) {
-        const h = t.points[c], l = t.points[(c + 1) % 4];
-        if (i(r, a, h, l)) return !0;
+      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;
       }
     }
-    for (let s of t.points)
-      if (e(s)) return !0;
-    for (let s of o)
-      if (n(s)) return !0;
-    return !1;
+    for (let p of rectangle.points) {
+      if (isPointInBox(p)) return true;
+    }
+    for (let p of boxPoints) {
+      if (isPointInRect(p)) return true;
+    }
+    return false;
   }
   /**
    * 判断矩形是在包围盒内
    * @param rectangle 
    */
-  containsRectangle(t) {
-    return t.points.every(
-      (e) => this.minX <= e.x && e.x <= this.maxX && this.minY <= e.y && e.y <= this.maxY
+  containsRectangle(rectangle) {
+    return rectangle.points.every(
+      (p) => this.minX <= p.x && p.x <= this.maxX && this.minY <= p.y && p.y <= this.maxY
     );
   }
   /**
    * 判断包围盒与包围盒相交
    * @param box 
    */
-  intersectBox(t) {
-    return !(this.maxX < t.minX || this.minX > t.maxX || this.maxY < t.minY || this.minY > t.maxY);
+  intersectBox(box) {
+    return !(this.maxX < box.minX || this.minX > box.maxX || this.maxY < box.minY || this.minY > box.maxY);
   }
   /**
    * 判断包围盒是在包围盒内
    * @param box 
    */
-  containsBox(t) {
-    return this.minX <= t.minX && t.maxX <= this.maxX && this.minY <= t.minY && t.maxY <= this.maxY;
+  containsBox(box) {
+    return this.minX <= box.minX && box.maxX <= this.maxX && this.minY <= box.minY && box.maxY <= this.maxY;
   }
   /** 判断点是在包围盒内
    * @param point 
    */
-  containsPoint(t) {
-    return t.x >= this.minX && t.x <= this.maxX && t.y >= this.minY && t.y <= this.maxY;
+  containsPoint(point) {
+    return point.x >= this.minX && point.x <= this.maxX && point.y >= this.minY && point.y <= this.maxY;
   }
   /**
    * 
@@ -461,8 +571,12 @@ class A {
    * @param maxY 
    * @returns 
    */
-  set(t, e, n, i) {
-    return this.minX = t, this.minY = e, this.maxX = n, this.maxY = i, this;
+  set(minX, minY, maxX, maxY) {
+    this.minX = minX;
+    this.minY = minY;
+    this.maxX = maxX;
+    this.maxY = maxY;
+    return this;
   }
   /**
    * 
@@ -471,46 +585,57 @@ class A {
    * @param mode 
    * @returns 
    */
-  scaleSize(t, e, n = "min") {
-    const i = t / this.width, o = e / this.height;
-    return Math[n](i, o);
+  scaleSize(maxWidth, maxHeight, mode = "min") {
+    const scaleX = maxWidth / this.width;
+    const scaleY = maxHeight / this.height;
+    return Math[mode](scaleX, scaleY);
   }
   /**
    * 
    * @param scalar 
    * @returns 
    */
-  multiplyScalar(t) {
-    return this.minX *= t, this.minY *= t, this.maxX *= t, this.maxY *= t, this;
+  multiplyScalar(scalar) {
+    this.minX *= scalar;
+    this.minY *= scalar;
+    this.maxX *= scalar;
+    this.maxY *= scalar;
+    return this;
   }
-  expansion(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;
   }
   /**
    * 
    * @returns 
    */
   clone() {
-    return new A(this.minX, this.maxX, this.minY, this.maxY);
+    return new Box2(this.minX, this.maxX, this.minY, this.maxY);
   }
   /**
    * 
    * @param points 
    * @returns 
    */
-  static fromByPoints(...t) {
-    const e = [], n = [];
-    return t.forEach((i) => {
-      e.push(i.x), n.push(i.y);
-    }), new A(
-      Math.min(...e),
-      Math.max(...e),
-      Math.min(...n),
-      Math.max(...n)
+  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)
     );
   }
 }
-class C {
+class Rectangle {
   points;
   get p0() {
     return this.points[0];
@@ -525,15 +650,16 @@ class C {
     return this.points[3];
   }
   get path() {
-    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];
+    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];
     });
   }
-  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];
+  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];
     });
   }
   createGeometry() {
@@ -544,58 +670,85 @@ class C {
       this.p2,
       this.p0,
       this.p3
-    ].flatMap((t) => [t.x, t.y, 0]);
+    ].flatMap((p) => [p.x, p.y, 0]);
   }
-  constructor(t) {
-    if (t.length !== 4)
+  constructor(points) {
+    if (points.length !== 4) {
       throw new Error("Rectangle must be defined by exactly 4 points");
-    this.points = t;
+    }
+    this.points = points;
   }
   /**
    * 判断线段是否与矩形相交
    * @param line 线段
    * @returns 是否与矩形相交
    */
-  intersectLineSegment(t) {
-    if (t.points.length !== 2)
+  intersectLineSegment(line) {
+    if (line.points.length !== 2) {
       throw new Error("LineSegment must have exactly 2 points");
-    const [e, n] = t.points, i = (o, s, r, a) => {
-      const c = (w, u, m) => {
-        const y = (u.y - w.y) * (m.x - u.x) - (u.x - w.x) * (m.y - u.y);
-        return y === 0 ? 0 : y > 0 ? 1 : 2;
-      }, h = (w, u, m) => Math.min(w.x, m.x) <= u.x && u.x <= Math.max(w.x, m.x) && Math.min(w.y, m.y) <= u.y && u.y <= Math.max(w.y, m.y), l = c(o, s, r), d = c(o, s, a), x = c(r, a, o), p = c(r, a, s);
-      return !!(l !== d && x !== p || l === 0 && h(o, r, s) || d === 0 && h(o, a, s) || x === 0 && h(r, o, a) || p === 0 && h(r, s, a));
+    }
+    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;
     };
-    for (let o = 0; o < 4; o++) {
-      const s = this.points[o], r = this.points[(o + 1) % 4];
-      if (i(e, n, s, r))
-        return !0;
+    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;
+      }
     }
-    return !!this.containsLineSegment(t);
+    if (this.containsLineSegment(line)) {
+      return true;
+    }
+    return false;
   }
   /**
    * 判断线段是否完全位于矩形内部
    * @param line 线段
    * @returns 是否完全在矩形内部
    */
-  containsLineSegment(t) {
-    if (t.points.length !== 2)
+  containsLineSegment(line) {
+    if (line.points.length !== 2) {
       throw new Error("LineSegment must have exactly 2 points");
-    const e = (n) => {
-      let i = 0;
-      for (let o = 0; o < 4; o++) {
-        const s = this.points[o], r = this.points[(o + 1) % 4], a = { x: r.x - s.x, y: r.y - s.y }, c = { x: n.x - s.x, y: n.y - s.y }, h = a.x * c.y - a.y * c.x;
-        if (h === 0) {
-          const l = a.x !== 0 ? (n.x - s.x) / a.x : (n.y - s.y) / a.y;
-          if (l >= 0 && l <= 1) return !0;
+    }
+    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;
         } else {
-          const l = h > 0 ? 1 : -1;
-          if (i === 0 && (i = l), i !== l) return !1;
+          const currentSign = cross > 0 ? 1 : -1;
+          if (sign === 0) sign = currentSign;
+          if (sign !== currentSign) return false;
         }
       }
-      return !0;
+      return true;
     };
-    return e(t.points[0]) && e(t.points[1]);
+    return isPointInRectangle(line.points[0]) && isPointInRectangle(line.points[1]);
   }
   /**
    * 判断矩形是否与矩形相交
@@ -603,53 +756,64 @@ class C {
    * @param rectangle 矩形
    * @returns 是否与矩形相交
    */
-  intersectRectangle(t) {
-    const e = [];
-    for (let o = 0; o < 4; o++) {
-      const s = this.points[o], r = this.points[(o + 1) % 4];
-      e.push(s.normal(r));
+  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));
     }
-    for (let o = 0; o < 4; o++) {
-      const s = t.points[o], r = t.points[(o + 1) % 4];
-      e.push(s.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));
     }
-    function n(o, s) {
-      const r = o.points.map((a) => a.dot(s));
-      return [Math.min(...r), Math.max(...r)];
+    function projectRectangle(rect, axis) {
+      const projections = rect.points.map((point) => point.dot(axis));
+      return [Math.min(...projections), Math.max(...projections)];
     }
-    function i(o, s) {
-      return o[0] < s[1] && s[0] < o[1];
+    function isProjectionOverlap(proj1, proj2) {
+      return proj1[0] < proj2[1] && proj2[0] < proj1[1];
     }
-    for (const o of e) {
-      const s = n(this, o), r = n(t, o);
-      if (!i(s, r))
-        return !1;
+    for (const axis of axes) {
+      const proj1 = projectRectangle(this, axis);
+      const proj2 = projectRectangle(rectangle, axis);
+      if (!isProjectionOverlap(proj1, proj2)) {
+        return false;
+      }
     }
-    return !0;
+    return true;
   }
   /**
    * 判断点是否完全位于矩形内部
    * @param point 
    */
-  containsPoint(t) {
-    let e = 0, n = 0;
+  containsPoint(point) {
+    let positiveCount = 0;
+    let negativeCount = 0;
     for (let i = 0; i < 4; i++) {
-      const o = this.points[i], s = this.points[(i + 1) % 4], r = (s.x - o.x) * (t.y - o.y) - (s.y - o.y) * (t.x - o.x);
-      if (r > 0) e++;
-      else if (r < 0) n++;
-      else return !1;
+      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;
     }
-    return e === 4 || n === 4;
+    return positiveCount === 4 || negativeCount === 4;
   }
   /**
    * 
    * @returns 
    */
   toBox() {
-    let t = 1 / 0, e = -1 / 0, n = 1 / 0, i = -1 / 0;
-    return this.points.forEach((o) => {
-      e = Math.max(o.x, e), t = Math.min(o.x, t), i = Math.max(o.x, i), n = Math.min(o.x, n);
-    }), new A(t, e, n, i);
+    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);
   }
   /**
    * 
@@ -657,22 +821,24 @@ class C {
    * @param width 
    * @returns 
    */
-  static fromByLineSegment(t, e = 0.1, n = !1, i = 0.5) {
-    const o = t.points[0], s = t.points[1], r = s.normal(o), a = n ? s.direction(o).mutiplyScalar(e * i) : f.zero(), c = n ? o.direction(s).mutiplyScalar(e * i) : f.zero(), h = r.x * e * 0.5, l = r.y * e * 0.5;
-    return new C([
-      new f(o.x + h, o.y + l).add(c),
-      new f(s.x + h, s.y + l).add(a),
-      new f(s.x - h, s.y - l).add(a),
-      new f(o.x - h, o.y - l).add(c)
+  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)
     ]);
   }
 }
-class b {
-  points = [new f(), new f()];
+class LineSegment {
+  points = [new Point(), new Point()];
   userData = {};
   line;
   get center() {
-    return new f(
+    return new Point(
       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
     );
@@ -683,84 +849,71 @@ class b {
   get end() {
     return this.points[1];
   }
-  constructor(t = new f(), e = new f()) {
-    this.points = [t, e];
-  }
-  set(t, e) {
-    this.start.copy(t), this.end.copy(e);
-  }
-  /**
-   * 是否有相同端点
-   * @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);
+  constructor(p1 = new Point(), p2 = new Point()) {
+    this.points = [p1, p2];
   }
   /** 膨胀
    * @description 向线段的两个端点分别膨胀 width
    * @param width 
    */
-  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;
+  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;
   }
   /** 向前
    * @description 向前移动 width
    * @param width 
    */
-  forward(t) {
-    const e = this.direction().multiplyScalar(t);
-    return this.start.add(e), this.end.add(e), this;
+  forward(width) {
+    const step = this.direction().multiplyScalar(width);
+    this.start.add(step);
+    this.end.add(step);
+    return this;
   }
   /** 向前
    * @description 向前移动 width
    * @param width 
    */
-  backward(t) {
-    const e = this.direction().multiplyScalar(-t);
-    return this.start.add(e), this.end.add(e), this;
+  backward(width) {
+    const step = this.direction().multiplyScalar(-width);
+    this.start.add(step);
+    this.end.add(step);
+    return this;
   }
   /**
    * 向指定方向平移
    * @param direct 
    * @param size 
    */
-  directionMove(t, e) {
-    const n = t.clone().multiplyScalar(e);
-    return this.start.add(n), this.end.add(n), this;
+  directionMove(direct, size) {
+    const step = direct.clone().multiplyScalar(size);
+    this.start.add(step);
+    this.end.add(step);
+    return this;
   }
   /** 膨胀为矩形
    * 
    * @param width 
    * @returns {Rectangle}
    */
-  expandToRectangle(t = 0.1, e = "all") {
-    const n = this.start, i = this.end, o = i.normal(n), s = e === "bothSides" ? f.zero() : i.direction(n).mutiplyScalar(t * 0.5), r = e === "bothSides" ? f.zero() : n.direction(i).mutiplyScalar(t * 0.5), a = o.x * t * 0.5, c = o.y * t * 0.5, h = [
+  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 = [
       // 第一条线
-      new f(n.x + a, n.y + c).add(r),
-      new f(i.x + a, i.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(n.x - a, n.y - c).add(r),
-      new f(i.x - a, i.y - c).add(s)
+      new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect),
+      new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect)
     ];
-    return new C([0, 1, 3, 2].map((l) => h[l]));
+    return new Rectangle([0, 1, 3, 2].map((i) => point[i]));
   }
   /**
    * 计算线段的长度
@@ -794,27 +947,50 @@ class b {
    * @param line 要投影的线段
    * @returns 投影并裁剪后的线段
    */
-  projectLineSegment(t) {
-    if (t.points.length !== 2 || this.points.length !== 2)
+  projectLineSegment(line) {
+    if (line.points.length !== 2 || this.points.length !== 2) {
       throw new Error("每条线段必须由两个点定义");
-    const [e, n] = t.points, [i, o] = this.points, s = new f(o.x - i.x, o.y - i.y);
-    if (s.x === 0 && s.y === 0)
+    }
+    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) {
       throw new Error("投影目标线段的两个点不能重合");
-    const r = (p) => {
-      const w = new f(p.x - i.x, p.y - i.y), u = s.x * s.x + s.y * s.y, y = (w.x * s.x + w.y * s.y) / u, S = i.x + y * s.x, D = i.y + y * s.y;
-      return new f(S, D);
+    }
+    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 a = r(e), c = r(n);
-    const h = (p) => {
-      const w = new f(p.x - i.x, p.y - i.y), u = s.x * s.x + s.y * s.y;
-      return (w.x * s.x + w.y * s.y) / u;
+    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 l = h(a), d = h(c);
-    const x = (p) => {
-      const w = Math.max(0, Math.min(1, p)), u = i.x + w * s.x, m = i.y + w * s.y;
-      return new f(u, m);
+    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);
     };
-    return (l < 0 || l > 1) && (a = x(l)), (d < 0 || d > 1) && (c = x(d)), a.x === c.x && a.y === c.y ? new b(a, a) : new b(a, c);
+    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);
   }
   /**
    * 计算一条线段在另一条直线上的投影
@@ -822,106 +998,155 @@ class b {
    * @param clip 是否裁剪超出目标线段的部分，默认裁剪
    * @returns 投影并裁剪后的线段
    */
-  projectPoint(t, e = !0) {
-    const [n, i] = this.points, o = new f(i.x - n.x, i.y - n.y);
-    if (o.x === 0 && o.y === 0)
+  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) {
       throw new Error("投影目标线段的两个点不能重合");
-    let r = ((h) => {
-      const l = new f(h.x - n.x, h.y - n.y), d = o.x * o.x + o.y * o.y, p = (l.x * o.x + l.y * o.y) / d, w = n.x + p * o.x, u = n.y + p * o.y;
-      return new f(w, u);
-    })(t);
-    if (!e) return r;
-    let c = ((h) => {
-      const l = new f(h.x - n.x, h.y - n.y), d = o.x * o.x + o.y * o.y;
-      return (l.x * o.x + l.y * o.y) / d;
-    })(r);
-    return c < 0 || c > 1 ? null : r;
+    }
+    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;
   }
   /**
    * 判断线段是否与另一条线段相交（包含共用端点或部分重合的情况）
    * @param line 
    */
-  intersectLineSegment(t) {
-    const e = this.start, n = this.end, i = t.start, o = t.end;
-    function s(d, x, p) {
-      return (x.x - d.x) * (p.y - d.y) - (x.y - d.y) * (p.x - d.x);
+  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;
+    }
+    if (Math.abs(d1) < 1e-10 && isPointOnSegment(p3, p1, p2)) {
+      return true;
     }
-    function r(d, x, p) {
-      return Math.min(x.x, p.x) - 1e-10 <= d.x && d.x <= Math.max(x.x, p.x) + 1e-10 && Math.min(x.y, p.y) - 1e-10 <= d.y && d.y <= Math.max(x.y, p.y) + 1e-10;
+    if (Math.abs(d2) < 1e-10 && isPointOnSegment(p4, p1, p2)) {
+      return true;
     }
-    const a = s(e, n, i), c = s(e, n, o), h = s(i, o, e), l = s(i, o, n);
-    return !!(a * c < 0 && h * l < 0 || Math.abs(a) < 1e-10 && r(i, e, n) || Math.abs(c) < 1e-10 && r(o, e, n) || Math.abs(h) < 1e-10 && r(e, i, o) || Math.abs(l) < 1e-10 && r(n, i, o));
+    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;
   }
   /**
    * 获取交点
    * @param line 
    * @returns 
    */
-  getIntersection(t) {
-    const e = this.start, n = this.end, i = t.start, o = t.end, s = (e.x - n.x) * (i.y - o.y) - (e.y - n.y) * (i.x - o.x);
-    if (Math.abs(s) < 1e-10)
+  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) {
       return null;
-    const r = ((e.x - i.x) * (i.y - o.y) - (e.y - i.y) * (i.x - o.x)) / s, a = e.x + r * (n.x - e.x), c = e.y + r * (n.y - e.y);
-    return new f(a, c);
+    }
+    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);
   }
   /**
    * 获取两条线段夹角
    * @param line 
    */
-  includedAngle(t) {
-    const e = this.direction(), n = t.direction();
-    return e.angleBetween(n) / (Math.PI / 180);
+  includedAngle(line) {
+    const d1 = this.direction(), d2 = line.direction();
+    return d1.angleBetween(d2) / (Math.PI / 180);
   }
   /**
    * 两条线段方向是否一致
    * @param line 
    */
-  directionEqual(t, e = 0.1) {
-    return this.includedAngle(t) < e;
+  directionEqual(line, errAngle = 0.1) {
+    return this.includedAngle(line) < errAngle;
   }
   /**
    * 两条线段方向相反否一致
    * @param line 
    */
-  directionOpposite(t, e = 0.1) {
-    return 180 - this.includedAngle(t) < e;
+  directionOpposite(line, errAngle = 0.1) {
+    return 180 - this.includedAngle(line) < errAngle;
   }
   /**
    * 判断两条线是否平行
    * @param line 
    */
-  isParallel(t, e = 4) {
-    const n = this.includedAngle(t);
-    return n < e || n > 180 - e;
+  isParallel(line, errAngle = 4) {
+    const angle = this.includedAngle(line);
+    return angle < errAngle || angle > 180 - errAngle;
   }
   /**
    * 判断两条直线是否重合
    * @param line 
    * @returns 
    */
-  areLinesCoincident(t) {
-    const e = this.start, n = this.end, i = t.start, o = t.end, s = (n.y - e.y) / (n.x - e.x), r = e.y - s * e.x, a = (o.y - i.y) / (o.x - i.x), c = i.y - a * i.x;
-    return !isFinite(s) && !isFinite(a) ? e.x === i.x && n.x === i.x : Math.abs(s - a) < 1e-3 && Math.abs(r - c) < 1e-3;
+  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;
   }
   clone() {
-    return new b(
+    return new LineSegment(
       this.points[0].clone(),
       this.points[1].clone()
     );
   }
 }
-async function q(g, t = !0) {
-  if (typeof global < "u" && typeof require < "u")
-    return require(g);
-  {
-    let e = await import(
+async function include(path, exportDefault = true) {
+  if (typeof global !== "undefined" && typeof require !== "undefined") {
+    return require(path);
+  } else {
+    let pack = await import(
       /* @vite-ignore */
-      g
+      path
     );
-    return t && (e = e.default), e;
+    if (exportDefault) pack = pack.default;
+    return pack;
   }
 }
-const nt = {
+const units = {
   Unitless: 1,
   // 无单位，1米 = 1（无单位）
   Inches: 39.37007874015748,
@@ -965,27 +1190,31 @@ const nt = {
   Parsecs: 3240779289666404e-32
   // 秒差距，1米 ≈ 0.00000000000000003240779289666404秒差距
 };
-function F(g) {
-  const t = [];
-  for (let e = 0; e < g.length; e++)
-    t.push(new b(
-      g[e].clone(),
-      g[(e + 1) % g.length].clone()
+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()
     ));
-  return t;
+  }
+  return lineSegments;
 }
-function z(g) {
-  return g.flatMap((t, e) => (e === g.length - 1 && [...t.points, g[0].points[0]], [t.points[0]]));
+function linesToPath(lineSegments) {
+  return lineSegments.flatMap((line, index2) => {
+    if (index2 === lineSegments.length - 1) [...line.points, lineSegments[0].points[0]];
+    return [line.points[0]];
+  });
 }
-class I extends X {
+class Dxf extends Component {
   static name = "Dxf";
   shortLine = 0.04;
   width = 0.04;
   scale = 1;
   originalData = [];
   data = [];
-  originalBox = new A(0, 0, 0, 0);
-  box = new A(0, 0, 0, 0);
+  originalBox = new Box2(0, 0, 0, 0);
+  box = new Box2(0, 0, 0, 0);
   pointsGroups = [];
   wallsGroup = [];
   doors = [];
@@ -1014,8 +1243,11 @@ class I extends X {
    * @param width 墙体宽度
    * @param scale 缩放比例
    */
-  constructor(t = 0.04, e = 1) {
-    super(), this.width = t, this.scale = e, this.shortLine = t * 0.4;
+  constructor(width = 0.04, scale = 1) {
+    super();
+    this.width = width;
+    this.scale = scale;
+    this.shortLine = width * 0.4;
   }
   /**
    * 设置
@@ -1023,36 +1255,52 @@ class I extends X {
    * @param width 
    * @param scale 
    */
-  async set(t, e = this.width, n = this.scale) {
-    if (typeof t == "string")
-      if (typeof global < "u") {
-        const { default: s } = await import(
+  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(
           /* @vite-ignore */
-          "fs"
-        ), r = s.readFileSync(t), a = JSON.parse(r.toString("utf-8"));
-        return this.set(a, e, n);
-      } else
+          packageName
+        );
+        const buffer = fs.readFileSync(data);
+        const json = JSON.parse(buffer.toString("utf-8"));
+        return this.set(json, width, scale);
+      } else {
         throw new Error("非node环境不允许使用路径");
-    this.scale = n, this.width = e, this.originalData = t, this.lineSegments.length = 0;
-    const i = [];
-    this.data = t.map(({ start: o, end: s, insetionArr: r, isDoor: a = !1, isWindow: c, drawDoorData: h }, l) => {
-      i.push(o.z ?? 0, s.z ?? 0);
-      const d = new b(
-        f.from(o).mutiplyScalar(n),
-        f.from(s).mutiplyScalar(n)
+      }
+    }
+    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)
       );
-      return d.userData = { isDoor: a, isWindow: c, drawDoorData: h }, this.lineSegments.push(d), [
-        d.points[0],
-        d.points[1],
-        (r ?? []).map((x) => x.index),
-        a,
-        l
+      lineSegment.userData = { isDoor, isWindow, drawDoorData };
+      this.lineSegments.push(lineSegment);
+      return [
+        lineSegment.points[0],
+        lineSegment.points[1],
+        (insetionArr ?? []).map((i) => i.index),
+        isDoor,
+        index2
       ];
-    }), this.originalZAverage = i.reduce((o, s) => o + s, 0) / i.length, this.computedOriginalSize(t, this.originalBox), this.dispatchEvent({
+    });
+    this.originalZAverage = zList.reduce((count, num) => count + num, 0) / zList.length;
+    this.computedOriginalSize(data, 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
     });
@@ -1062,20 +1310,32 @@ class I extends X {
    * @returns 
    */
   createGroups() {
-    const t = [], e = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map(), o = (s, r, a = -1) => {
-      const [c, h, l, d] = this.data[s];
-      if (e.add(s), d)
-        return i.has(s) || i.set(s, []), i.get(s)?.push(a), n.add(this.data[s]);
-      r.push([c, h]), l.forEach((x) => {
-        e.has(x) || o(x, r, s);
+    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);
+        }
       });
     };
-    return this.data.forEach((s, r) => {
-      if (!e.has(r)) {
-        const a = [];
-        o(r, a), t.push(a);
+    this.data.forEach((_, index2) => {
+      if (!visited.has(index2)) {
+        const group = [];
+        dfs(index2, group);
+        groups.push(group);
       }
-    }), this.doors = [...n], this.pointsGroups = t, t;
+    });
+    this.doors = [...doorSet];
+    this.pointsGroups = groups;
+    return groups;
   }
   /** 计算当前墙体数据的边界框
    * @description 根据分组数据pointsGroups，计算包围盒， pointsGroups数据为缩放后数据。
@@ -1083,163 +1343,224 @@ class I extends X {
    * @returns 
    */
   computedSize() {
-    const t = this.pointsGroups.flatMap((r) => r.flatMap((a) => [a[0].x, a[1].x])), e = this.pointsGroups.flatMap((r) => r.flatMap((a) => [a[0].y, a[1].y])), n = Math.min(...t), i = Math.min(...e), o = Math.max(...t), s = Math.max(...e);
-    return this.box.set(n, i, o, s), this.box;
+    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;
   }
   /** 线路拓扑
    * @description 处理线路拓扑，使线路有序链接，形成长路径
    * @param lines 
    */
-  lineTopology(t) {
-    const e = [];
-    function n(o, s) {
-      const [r, a] = t[o];
-      e[o] = !0, s.push(a);
-      for (let c = 0; c < t.length; c++) {
-        const [h, l] = t[c];
-        if (!e[c] && Math.abs(a.x - h.x) < 1e-6 && Math.abs(a.y - h.y) < 1e-6)
-          return n(c, s);
+  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);
+          }
+        }
       }
     }
-    const i = [];
-    for (let o = 0; o < t.length; o++)
-      if (!e[o]) {
-        const s = [t[o][0]];
-        n(o, s), i.push(s);
+    const linePaths = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (!visited[i]) {
+        const linePath = [lines[i][0]];
+        dfs(i, linePath);
+        linePaths.push(linePath);
       }
-    return i;
+    }
+    return linePaths;
   }
   /** 合并方向相同的线段
    * @param lines 
    * @param errAngle 
    */
-  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);
+  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);
     }
-    const n = [t[0]];
-    for (let i = 1; i < t.length; i++) {
-      const o = t[i], s = t[i - 1];
-      s.includedAngle(o) < e ? s.end.copy(o.end) : n.push(o);
+    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);
+      }
     }
-    return n;
+    return filterLines;
   }
   /** etOpenRound 去除毛刺
    * @description 检查连续的短线段数量，去除合并后产生的毛刺
    */
-  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], o = t[n];
-      if (i.distance(o) < this.width * 0.5) {
-        let r = 0;
-        for (let a = n + 1; a < t.length; a++) {
-          const c = t[a - 1], h = t[a];
-          if (c.distance(h) < this.width * 0.8) r++;
+  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++;
           else break;
         }
-        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(o));
-      } else
-        e.push(o);
+        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);
+      }
     }
-    return e;
+    return filterLines;
   }
   /**
    * 线段矫直, 线段中心突刺
    * @description 突变长度小于墙体宽度，该线段可能为突起线段，
    * @description 判断后续第2线段与上一条线段是否方向相同，相同就为突刺
    */
-  lineSegmentStraightening(t) {
-    for (let i = 0; i < t.length; i++) {
-      const o = t[i], s = t[(i + 1) % t.length];
-      if (o.distance(s) > this.shortLine) {
-        t.push(...t.slice(0, i + 1)), t.splice(0, i + 1);
+  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);
         break;
       }
     }
-    const e = this.mergeSameDirectionLine(F(t)), n = [e[0]];
-    for (let i = 1; i < e.length; i++) {
-      const o = e[i], s = e[(e.length + i - 1) % e.length];
-      if (o.length() > this.width * 0.9) {
-        n.push(o);
+    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);
         continue;
       }
-      const r = e[i + 1];
-      if (r && r.length() > this.width * 0.9) {
-        n.push(o), n.push(r), i = i + 1;
+      const line1 = lines[i + 1];
+      if (line1 && line1.length() > this.width * 0.9) {
+        filterLines.push(line);
+        filterLines.push(line1);
+        i = i + 1;
         continue;
       }
-      const a = e[i + 2];
-      a && s.includedAngle(a) < 2 ? (i = i + 2, n.push(a)) : n.push(o);
+      const line2 = lines[i + 2];
+      if (line2 && preLine.includedAngle(line2) < 2) {
+        i = i + 2;
+        filterLines.push(line2);
+      } else filterLines.push(line);
     }
-    return n.length > 3 ? z(this.mergeSameDirectionLine(n)) : [];
+    return filterLines.length > 3 ? linesToPath(this.mergeSameDirectionLine(filterLines)) : [];
   }
   /**
    * 移除短线段
    * @todo 根据线段两端线段长度，选取参照物_|▔▔
    * @param path 
    */
-  removeShortLine(t, e = this.shortLine) {
-    const n = F(t), i = [], o = Math.PI / 180;
-    for (let s = 0; s < n.length; s++) {
-      const r = n[s], a = r.length(), c = s;
-      if (a > e || i.length === 0) {
-        i.push(r);
+  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);
         continue;
       }
-      let h = n[++s];
-      const l = i[i.length - 1], d = l.direction();
-      for (; s < n.length; ) {
-        const p = d.angleBetween(h.direction()) / o;
-        if (h.length() <= e || p < 4 || p > 176)
-          h = n[++s];
-        else break;
+      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 (!h) continue;
-      const x = n[s - 1];
-      if (l.length() > x.length()) {
-        const p = l.getIntersection(h);
-        if (p) {
-          const w = l.points[1].clone(), u = h.points[0].clone();
-          l.points[1].copy(p), h.points[0].copy(p), l.length() < this.width ? (l.points[1].copy(w), h.points[0].copy(w)) : 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
-        s = c;
-    }
-    return i.length > 3 ? z(i) : [];
+      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;
+      }
+    }
+    return filterLines.length > 3 ? linesToPath(filterLines) : [];
   }
   /** 线偏移
    * @description 使用 ClipperLib 对每个点组进行线偏移处理，生成具有指定宽度的墙体路径
    */
-  lineOffset(t = I.EndType.etOpenSquare, e = I.JoinType.jtMiter, n = 1e4) {
-    let i = new V.Paths();
-    const o = new V.ClipperOffset(20, 0.25);
-    return this.pointsGroups.forEach((s) => {
-      const r = this.lineTopology(s).map((a) => a.map((c) => c.clone().mutiplyScalar(n)));
-      o.AddPaths(r, e, t);
-    }), o.Execute(i, this.width / 2 * n), this.wallsGroup = i.map((s) => {
-      let r = s.map((a) => f.from(a).divisionScalar(n));
-      return r = this.lineSegmentStraightening(r), t == I.EndType.etOpenSquare && (r = this.squareRemoveBurr(r)), r = this.removeShortLine(r), r;
-    }), this.dispatchEvent({
+  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({
       type: "lineOffset",
       wallsGroup: this.wallsGroup
-    }), this.wallsGroup;
+    });
+    return this.wallsGroup;
   }
   /**
    * 将点云结构转换为Float32Array
    */
-  to3DArray(t, e = this.originalZAverage) {
-    const n = [];
-    return this.wallsGroup.forEach((i) => {
-      for (let o = 0; o < i.length; o++) {
-        const s = i[o], r = o === i.length - 1 ? 0 : o + 1, a = i[r];
-        n.push(s.X * t, s.Y * t, e, a.X * t, a.Y * t, e);
+  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);
       }
-    }), new Float32Array(n);
+    });
+    return new Float32Array(array);
   }
   /** 获取角度范围
    * @param center 
@@ -1247,140 +1568,196 @@ class I extends X {
    * @param p2 
    * @returns 
    */
-  getArcAngleRange(t, e, n) {
-    const i = e.x - t.x, o = e.y - t.y, s = n.x - t.x, r = n.y - t.y;
-    let a = Math.atan2(o, i), c = Math.atan2(r, s);
-    a = a < 0 ? a + 2 * Math.PI : a, c = c < 0 ? c + 2 * Math.PI : c;
-    let h, l;
-    return Math.abs(c - a) <= Math.PI ? (h = Math.min(a, c), l = Math.max(a, c)) : (h = Math.max(a, c), l = Math.min(a, c) + 2 * Math.PI), [h / (Math.PI / 180), l / (Math.PI / 180)];
+  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(t = "Millimeters") {
-    const e = new N();
-    e.setUnits("Millimeters");
-    const n = nt[t];
-    function i(r, a) {
-      e.drawLine(r.X * n, r.Y * n, a.X * n, a.Y * n);
-    }
-    this.wallsGroup.forEach((r) => {
-      for (let a = 0; a < r.length; a++) {
-        const c = r[a], h = a === r.length - 1 ? 0 : a + 1, l = r[h];
-        i(c, l);
+  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);
+    }
+    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);
       }
     });
-    const o = this.width * 0.2, s = [];
-    return e.addLayer("l_cyan", N.ACI.CYAN, "DOTTED"), this.doorLineSegment.forEach((r) => {
-      if (r.length() < 0.4) return;
-      const a = r.clone().expansion(-this.width * 0.5);
-      if (e.setActiveLayer("l_cyan"), a.length() < 1.2) {
-        a.expansion(-o * 0.5);
-        const c = r.normal();
-        let h = new b(
-          a.start.clone(),
-          a.start.clone().add(c.clone().multiplyScalar(a.length()))
+    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 l = h.clone().directionMove(h.normal(), a.length() * -0.5).expandToRectangle(a.length(), "bothSides");
-        for (let y = 0; y < s.length; y++)
-          if (s[y].intersectRectangle(l)) {
-            h = new b(
-              a.start.clone(),
-              a.start.clone().add(c.clone().multiplyScalar(-a.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()))
             );
             break;
           }
-        h.expansion(-o * 0.5).expandToRectangle(this.width * 0.2, "bothSides").path2D((y, S) => i(y, S));
-        const d = a.length(), x = h.length(), p = (d ** 2 + x ** 2) / (2 * x), w = h.end.clone().add(h.direction().multiplyScalar(-p)), [u, m] = this.getArcAngleRange(w, a.end, h.end);
-        e.drawArc(w.x * n, w.y * n, p * n, Math.min(u, m), Math.max(u, m)), s.push(l);
-      } else
-        a.clone().expansion(-this.width * 0.5).expandToRectangle(this.width).path2D((c, h) => i(c, h)), a.clone().directionMove(a.normal(), o * 0.5).directionMove(a.direction(), o * 0.5).expansion(-a.length() * 0.45, "end").forward(o * 0.5).expandToRectangle(o).path2D((c, h) => i(c, h)), a.clone().directionMove(a.normal(), -o * 0.5).directionMove(a.direction(), -o * 0.5).expansion(-a.length() * 0.45, "start").forward(-o * 0.5).expandToRectangle(o).path2D((c, h) => i(c, h));
-    }), e.addLayer("l_yellow", N.ACI.YELLOW, "DOTTED"), e.setActiveLayer("l_yellow"), this.lineSegments.forEach((r) => {
-      if (!r.userData.isWindow) return !1;
-      Array.isArray(r.userData.drawDoorData) && r.userData.drawDoorData.forEach((a) => {
-        const { p: c, width: h } = a, l = f.from(c), d = l.clone().add(r.direction().multiplyScalar(h * 0.5)), x = l.clone().add(r.direction().multiplyScalar(-h * 0.5)), p = new b(d, x);
-        i(p.start, p.end), p.expandToRectangle(this.width, "bothSides").path2D((w, u) => i(w, u));
-      });
-    }), e.toDxfString();
+        }
+        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();
   }
   /**
    * 将点云结构转换为DXF格式
    * @returns 
    */
-  toDxfBlob(t = "Millimeters") {
-    return new Blob([this.toDxfString(t)]);
+  toDxfBlob(unit = "Millimeters") {
+    const blob = new Blob([this.toDxfString(unit)]);
+    return blob;
   }
   /**
    * 下载
    * @param filename 
    */
-  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 q("fs", !1)).writeFileSync(t, this.toDxfString(e));
+  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));
+    }
   }
   /**
    * 计算原始数据的边界框
    * @description 计算所有线段的起点和终点的最小最大值，形成一个边界框
    * @returns 
    */
-  computedOriginalSize(t, e = new A(0, 0, 0, 0)) {
-    const n = t.flatMap((c) => [c.start.x, c.end.x]), i = t.flatMap((c) => [c.start.y, c.end.y]), o = Math.min(...n), s = Math.min(...i), r = Math.max(...n), a = Math.max(...i);
-    return e.set(o, s, r, a), e;
+  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;
   }
   /**
    * 创建数据
    * @param pointsGroups 
    * @returns 
    */
-  static createData(t, e = !0) {
-    let n = 0;
-    return t.flatMap((o) => {
-      const s = o.map((r, a) => {
-        const c = a === o.length - 1 ? 0 : a + 1, h = o[c];
+  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];
         return {
-          start: { x: r.x, y: r.y },
-          end: { x: h.x, y: h.y },
+          start: { x: point.x, y: point.y },
+          end: { x: nextPoint.x, y: nextPoint.y },
           insetionArr: [
             {
-              index: c + n
+              index: nextIndex + count
             }
           ]
         };
       });
-      return n += o.length, e || (s.pop(), s[s.length - 1].insetionArr.length = 0, n--), s;
+      count += points.length;
+      if (!sealed) {
+        lines.pop();
+        lines[lines.length - 1].insetionArr.length = 0;
+        count--;
+      }
+      return lines;
     });
+    return data;
   }
 }
-class k extends X {
+class Variable extends Component {
   static name = "Variable";
-  originalLineVisible = !0;
-  dxfVisible = !0;
-  whiteModelVisible = !0;
-  isLook = !1;
+  originalLineVisible = true;
+  dxfVisible = true;
+  whiteModelVisible = true;
+  isLook = false;
   currentWheel = 0;
   pointerMove = { x: 0, y: 0 };
   currentKeyUp = "";
   currentKeyDown = "";
   currentMouseUp = "";
   currentMouseDown = "";
-  focus = !1;
-  set(t, e) {
-    if (t in this) {
-      const n = this[t];
-      this[t] = e, this.dispatchEvent({
-        type: t,
-        value: e,
-        oldValue: n
+  focus = false;
+  set(key, value) {
+    if (key in this) {
+      const oldValue = this[key];
+      this[key] = value;
+      this.dispatchEvent({
+        type: key,
+        value,
+        oldValue
       });
     }
   }
-  get(t) {
-    if (t in this) return this[t];
+  get(key) {
+    if (key in this) return this[key];
   }
 }
-class B {
+class Quadtree {
   bounds;
   // 包围盒
   capacity;
@@ -1389,7 +1766,7 @@ class B {
   // 最大深度
   depth;
   // 当前深度
-  isLeaf = !0;
+  isLeaf = true;
   // 是否为叶子节点
   children = null;
   // 子节点数组
@@ -1397,72 +1774,110 @@ class B {
   // 存储的节点
   color = [Math.random(), Math.random(), Math.random()];
   // 颜色
-  constructor(t, e = 8, n = 10, i = 1) {
-    this.bounds = t, this.capacity = e, this.depth = i, this.maxDepth = n;
+  constructor(bounds, capacity = 8, maxDepth = 10, depth = 1) {
+    this.bounds = bounds;
+    this.capacity = capacity;
+    this.depth = depth;
+    this.maxDepth = maxDepth;
   }
   /**
    * 插入线段节点
    * @param node 线段节点
    */
-  insert(t) {
+  insert(node) {
     if (!this.isLeaf) {
-      const e = this.getQuadrant(t.line);
-      if (e !== -1) {
-        this.children[e].insert(t);
+      const quadrant = this.getQuadrant(node.line);
+      if (quadrant !== -1) {
+        this.children[quadrant].insert(node);
         return;
       }
     }
-    if (this.nodes.push(t), t.parent = this, this.isLeaf && this.nodes.length > this.capacity && this.depth < this.maxDepth) {
+    this.nodes.push(node);
+    node.parent = this;
+    if (this.isLeaf && this.nodes.length > this.capacity && this.depth < this.maxDepth) {
       this.subdivide();
-      const e = this.nodes;
+      const nodes = this.nodes;
       this.nodes = [];
-      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));
+      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);
+        }
       }
     }
   }
   /** 移除
    * @param node 
    */
-  remove(t) {
-    const e = t.parent?.nodes.indexOf(t);
-    e > -1 && t.parent?.nodes.splice(e, 1);
+  remove(node) {
+    const index2 = node.parent?.nodes.indexOf(node);
+    if (index2 > -1) {
+      node.parent?.nodes.splice(index2, 1);
+    }
   }
   /**
    * 获取线段所属的象限
    * @param line 线段
    * @returns 象限索引（0:西北,1:东北,2:西南,3:东南）或-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), o = this.children[3].bounds.intersectLineSegment(t);
-    let s = 0, r = -1;
-    return e && (s++, r = 0), n && (s++, r = 1), i && (s++, r = 2), o && (s++, r = 3), s === 1 ? r : -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;
   }
   /**
    * 细分当前节点为四个子节点
    */
   subdivide() {
     if (!this.isLeaf) return;
-    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 B(
-      new A(this.bounds.minX, t, this.bounds.minY, e),
+    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.capacity,
       this.maxDepth,
       this.depth + 1
-    ), this.children[1] = new B(
-      new A(t, this.bounds.maxX, this.bounds.minY, e),
+    );
+    this.children[1] = new Quadtree(
+      new Box2(midX, this.bounds.maxX, this.bounds.minY, midY),
       this.capacity,
       this.maxDepth,
       this.depth + 1
-    ), this.children[2] = new B(
-      new A(this.bounds.minX, t, e, this.bounds.maxY),
+    );
+    this.children[2] = new Quadtree(
+      new Box2(this.bounds.minX, midX, midY, this.bounds.maxY),
       this.capacity,
       this.maxDepth,
       this.depth + 1
-    ), this.children[3] = new B(
-      new A(t, this.bounds.maxX, e, this.bounds.maxY),
+    );
+    this.children[3] = new Quadtree(
+      new Box2(midX, this.bounds.maxX, midY, this.bounds.maxY),
       this.capacity,
       this.maxDepth,
       this.depth + 1
@@ -1473,16 +1888,22 @@ class B {
    * @param box2 包围盒
    * @returns 相交的节点数组
    */
-  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;
+  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;
   }
   /**
    * 查询与圆形区域相交的线段节点
@@ -1490,58 +1911,81 @@ class B {
    * @param radius 半径
    * @returns 相交的节点数组
    */
-  queryCircle(t, e) {
-    const n = [], i = new A(
-      t.x - e,
-      t.x + e,
-      t.y - e,
-      t.y + e
+  queryCircle(pos, radius) {
+    const result = [];
+    const circleBox = new Box2(
+      pos.x - radius,
+      pos.x + radius,
+      pos.y - radius,
+      pos.y + radius
     );
-    if (!this.bounds.intersectBox(i))
-      return n;
-    for (const o of this.nodes) {
-      const [s, r] = o.line.points, a = r.x - s.x, c = r.y - s.y, h = a * a + c * c;
-      let l = ((t.x - s.x) * a + (t.y - s.y) * c) / h;
-      l = Math.max(0, Math.min(1, l));
-      const d = s.x + l * a, x = s.y + l * c;
-      t.distance(new f(d, x)) <= e && n.push(o);
+    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.isLeaf)
-      for (const o of this.children)
-        n.push(...o.queryCircle(t, e));
-    return n;
+    return result;
   }
   /**
    * 查询与矩形相交的线段节点
    * @param rectangle 矩形
    * @returns 相交的节点数组
    */
-  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;
+  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;
   }
   /**
    * 查询与线段相交的线段节点
    * @param lineSegment 线段
    * @returns 相交的节点数组
    */
-  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;
+  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;
   }
   /**
    * 包围盒转换为数组
@@ -1549,80 +1993,96 @@ class B {
    * @param colors 
    * @returns 
    */
-  boundsToArray(t = [], e, n = !0) {
-    return !this.isLeaf && n && this.children?.forEach((i) => i.boundsToArray(t, e)), t.push(...this.bounds.points.flatMap((i, o, s) => {
-      const r = s[(o + 1) % s.length];
-      return e?.push(...this.color), e?.push(...this.color), [i.x, i.y, 0, r.x, r.y, 0];
-    })), t;
+  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;
   }
 }
-class U {
+class PointVirtualGrid {
   map = /* @__PURE__ */ new Map();
   gridSize;
-  constructor(t = 2) {
-    this.gridSize = t;
+  constructor(gridSize = 2) {
+    this.gridSize = gridSize;
   }
   /**
    * 插入
    * @param point 
    * @param userData 
    */
-  insert(t, e) {
-    if (!t || isNaN(t.x) || isNaN(t.y))
+  insert(point, userData) {
+    if (!point || isNaN(point.x) || isNaN(point.y)) {
       throw new Error("无效的点坐标");
-    const n = this.getGridId(t);
-    this.map.has(n) || this.map.set(n, /* @__PURE__ */ new Set());
-    const i = this.map.get(n), o = { point: t, userData: e };
-    i.add(o), t.userData.pointVirtualGrid = { set: i, target: o };
+    }
+    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 };
   }
   /**
    * 批量加入
    * @param points 
    */
-  insertBatch(t) {
-    for (const { point: e, userData: n } of t)
-      this.insert(e, n);
+  insertBatch(points) {
+    for (const { point, userData } of points) {
+      this.insert(point, userData);
+    }
   }
   /** 移除点
    * @param point 
    */
-  remove(t) {
-    const { set: e, target: n } = t?.userData?.pointVirtualGrid;
-    e && (e.delete(n), delete t?.userData?.pointVirtualGridMap);
+  remove(point) {
+    const { set, target } = point?.userData?.pointVirtualGrid;
+    if (set) {
+      set.delete(target);
+      delete point?.userData?.pointVirtualGridMap;
+    }
   }
   /**
    * 获取通过坐标，获取唯一网格索引
    * @param point 
    * @returns 
    */
-  getGridId(t) {
-    const e = Math.ceil(t.x / this.gridSize), n = Math.ceil(t.y / this.gridSize);
-    return `${e}.${n}`;
+  getGridId(point) {
+    const i = Math.ceil(point.x / this.gridSize), j = Math.ceil(point.y / this.gridSize);
+    return `${i}.${j}`;
   }
   /**
    * 
    * @param gridId 
    * @returns 
    */
-  decodeGridId(t) {
-    const [e, n] = t.split(".").map(Number);
-    return new f(e, n);
+  decodeGridId(gridId) {
+    const [i, j] = gridId.split(".").map(Number);
+    return new Point(i, j);
   }
   /**
    * 查询与矩形相交的点
    * @param rectangle 矩形
    * @returns 相交的节点数组
    */
-  queryRect(t) {
-    const e = t.toBox(), n = Math.ceil(e.minX / this.gridSize), i = Math.ceil(e.maxX / this.gridSize), o = Math.ceil(e.minY / this.gridSize), s = Math.ceil(e.maxY / this.gridSize);
-    for (let r = n; r <= i; r++)
-      for (let a = o; a <= s; a++) {
-        const c = `${r}.${a}`;
-        if (!this.map.has(c)) continue;
-        this.map.get(c)?.forEach((l) => {
-          t.containsPoint(l.point);
+  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)) ;
         });
       }
+    }
   }
   /**
    * 查询与圆形区域相交的点
@@ -1630,53 +2090,62 @@ class U {
    * @param radius 半径
    * @returns 相交的节点数组
    */
-  queryCircle(t, e) {
-    const n = new A(t.x - e, t.x + e, t.y - e, t.y + e), i = Math.ceil(n.minX / this.gridSize), o = Math.ceil(n.maxX / this.gridSize), s = Math.ceil(n.minY / this.gridSize), r = Math.ceil(n.maxY / this.gridSize), a = [];
-    for (let c = i; c <= o; c++)
-      for (let h = s; h <= r; h++) {
-        const l = `${c}.${h}`;
-        if (!this.map.has(l)) continue;
-        this.map.get(l)?.forEach((x) => {
-          t.distance(x.point) <= e && a.push(x);
+  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);
         });
       }
-    return a;
+    }
+    return list;
   }
   /**
    * 查询与包围盒相交的点
    * @param box2 包围盒
    * @returns 相交的节点数组
    */
-  queryBox(t) {
-    const e = Math.ceil(t.minX / this.gridSize), n = Math.ceil(t.maxX / this.gridSize), i = Math.ceil(t.minY / this.gridSize), o = Math.ceil(t.maxY / this.gridSize), s = [];
-    for (let r = e; r <= n; r++)
-      for (let a = i; a <= o; a++) {
-        const c = `${r}.${a}`;
-        if (!this.map.has(c)) continue;
-        this.map.get(c)?.forEach((l) => {
-          t.containsPoint(l.point) && s.push(l);
+  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);
         });
       }
-    return s;
+    }
+    return list;
   }
   /**
    * 查找相同点
    * @param point 
    */
-  queryPoint(t) {
-    const e = this.getGridId(t), n = [];
-    return this.map.has(e) && this.map.get(e)?.forEach((o) => {
-      t.equal(o.point) && n.push(o);
-    }), n;
+  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;
   }
 }
-class it {
+class DoorsAnalysis {
   // 所有可查找的点位
   possibleDoorPoints = [];
   doorPoint = [];
   dxf;
   // 包含所有点的虚拟网格
-  pointVirtualGrid = new U();
+  pointVirtualGrid = new PointVirtualGrid();
   // 只包含可查找点的虚拟网格
   findPointVirtualGrid;
   quadtree;
@@ -1687,111 +2156,158 @@ class it {
   doorSearchDistance = 2;
   doors = [];
   lineAnalysis;
-  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, o) => {
-      const s = this.lineSegments.indexOf(n), r = e.get(s);
-      return typeof r == "number" ? r === -1 || r === o : !1;
-    }), this.addPointsExcludeRule((n, i) => !!this.doorPoint.find((o) => o.point.equal(i))), this.possibleDoorPoints = this.getPossiblePoints(), this.possibleDoorPoints.forEach((n) => this.findPointVirtualGrid.insert(n.point, n.line)), this.handle();
+  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();
   }
   handle() {
-    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, o = this.doorSearchNearAngle) {
-    const s = this.dxf, r = this.searchNearby(t, e, i, o);
-    r.push(
-      ...t.map((c) => {
-        const h = this.searchAlongDirection(c, i);
-        if (h) return {
-          start: c.point,
-          end: h.point
+    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
         };
-        const l = this.searchAlongNormalDirection(c, i);
-        if (l) return {
-          start: c.point,
-          end: l.point
+        const res3 = this.searchAlongNormalDirection(item, doorSearchDistance);
+        if (res3) return {
+          start: item.point,
+          end: res3.point
         };
-      }).filter((c) => !!c && c.start.distance(c.end) < i)
+      }).filter((i) => !!i && i.start.distance(i.end) < doorSearchDistance)
     );
-    const a = [];
-    return r.forEach((c) => {
-      const h = new b(c?.start, c?.end), l = h.length();
-      if (l < n) return;
-      const d = h.normal(), x = h.direction(), p = (l - s.width * 2) / 2;
-      for (let w = 0; w < 3; w++) {
-        const u = h.start.clone().add(x.clone().multiplyScalar(s.width + p * w)), m = new b(
-          u,
-          u.clone().add(d.clone().multiplyScalar(1))
+    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))
         );
-        if (m.directionMove(d, -0.5), this.quadtree.queryLineSegment(m).length) return;
+        rLine.directionMove(normal, -0.5);
+        const res = this.quadtree.queryLineSegment(rLine);
+        if (res.length) return;
       }
-      a.push(h);
-    }), a;
+      doorLineSegment.push(line);
+    });
+    return doorLineSegment;
   }
   /** 添加可查找点的过滤规则
    * @param rule 
    */
-  addPointsExcludeRule(t) {
-    this._pointsExcludeRule.push(t);
+  addPointsExcludeRule(rule) {
+    this._pointsExcludeRule.push(rule);
   }
   _pointsExcludeRule = [];
   /**
    * 查找所有可能为门的点位
    */
   getPossiblePoints() {
-    const t = [];
-    return this.lineSegments.forEach((e) => {
-      e.points.forEach((n, i) => {
-        for (let s = 0; s < this._pointsExcludeRule.length; s++) if (this._pointsExcludeRule[s](e, n, i)) return;
-        this.pointVirtualGrid.queryPoint(n).filter((s) => s.userData !== e).length === 0 && t.push({ line: e, point: n, uuid: T() });
+    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() });
+        }
       });
-    }), t;
+    });
+    return doorPoints;
   }
   /**
    * 查找已知为门的点位
    */
   getDoorPoint() {
-    const t = [], e = this.dxf, n = this.pointVirtualGrid;
-    return e.doors.forEach((i) => {
-      const o = e.lineSegments[i[4]], s = e.originalData[i[4]];
-      if (s.drawDoorData) {
-        const r = f.from(s.drawDoorData.start), a = f.from(s.drawDoorData.n), c = n.queryPoint(r).filter((h) => {
-          if (h.userData === o) return !1;
-          const l = h.userData, d = l.direction();
-          l.start.equal(r) && d.multiplyScalar(-1);
-          const x = a.angleBetween(d, "angle");
-          return x > 80 || x < 10;
+    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;
         });
-        c.length && t.push({
-          line: c[0].userData,
-          point: r,
-          uuid: T()
-        });
-      } else if (s.doorDirectConnection) {
-        this.continueFind = !1;
-        const r = new b(f.from(s.start), f.from(s.end));
-        r.userData = {
-          doorDirectConnection: !0,
-          isDoor: !0
-        }, this.dxf.doorLineSegment.push(r);
-      } else
-        console.warn(`门的线段顺序${i[4]} 没有drawDoorData属性`);
-    }), t;
+        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;
   }
   /**
    * 查找双线墙的点位
    * @returns 
    */
   searchDoubleLinePoint() {
-    const t = /* @__PURE__ */ new Map();
-    return this.resultList.flatMap((e) => {
-      const n = this.lineSegments[e.sourceIndex], i = this.lineSegments[e.targetIndex], o = i.projectPoint(n.start), s = i.projectPoint(n.end), r = n.projectPoint(i.start), a = n.projectPoint(i.end), c = o && s ? -1 : o ? 0 : s ? 1 : -1, h = r && a ? -1 : r ? 0 : a ? 1 : -1;
-      t.has(e.sourceIndex) ? t.get(e.sourceIndex) != c && t.set(e.sourceIndex, -1) : t.set(e.sourceIndex, c), t.has(e.targetIndex) ? t.get(e.targetIndex) != h && t.set(e.targetIndex, -1) : t.set(e.targetIndex, h);
-    }), t;
+    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;
   }
   /** 查找方案一：最近点查找
    * @description 以点为圆心，查找半径内符合角度的点
@@ -1801,113 +2317,160 @@ class it {
    * @param doorSearchNearAngle 查找的角度
    * @returns 
    */
-  searchNearby(t, e = [], n = this.doorSearchDistance, i = this.doorSearchNearAngle) {
-    const o = this.findPointVirtualGrid, s = this.quadtree;
-    function r({ point: u, line: m }, y, S) {
-      const D = m.direction();
-      m.start === u && D.multiplyScalar(-1);
-      const P = o.queryCircle(u, n).filter((L) => L.userData !== m).sort((L, E) => L.point.distance(u) - E.point.distance(u)), v = [];
-      for (let L = 0; L < P.length; L++) {
-        const E = e.findIndex((R) => R.point === P[L].point), Y = t[y].uuid, G = e[E].uuid;
-        if (S.has(`${Y}.${G}`)) continue;
-        S.add(`${Y}.${G}`), S.add(`${G}.${Y}`);
-        const Z = P[L].point, j = new b(u.clone(), Z.clone());
-        if (j.direction().angleBetween(D, "angle") < i) {
-          const R = t[E].line.direction();
-          P[L].userData.start.equal(P[L].point) && R.multiplyScalar(-1), j.direction().multiplyScalar(-1).angleBetween(R, "angle") < i && (s.queryLineSegment(j).length || v.push({
-            findData: P[L],
-            findUuid: G,
-            doorLine: j,
-            doorUuid: Y
-          }));
+  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
+              });
+            }
+          }
         }
       }
-      return v;
-    }
-    function a(u, m, y, S, D) {
-      S.add(u);
-      const P = [];
-      D && P.push(D);
-      for (let v = 0; v < y.length; v++) {
-        const L = y[v];
-        if (m.has(L.findUuid)) {
-          const E = m.get(L.findUuid);
-          a(L.findUuid, m, E, S, L) && P.push(L);
-        } else P.push(L);
+      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);
+      }
+      newList.sort((a, b) => a.doorLine.length() - b.doorLine.length());
+      if (other && newList[0] === other) {
+        list.splice(0);
+        return true;
       }
-      return P.sort((v, L) => v.doorLine.length() - L.doorLine.length()), D && P[0] === D ? (y.splice(0), !0) : (y.splice(1), !1);
-    }
-    const c = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Map();
-    t.map((u, m) => {
-      const y = r(u, m, c);
-      y.length && h.set(u.uuid, y);
-    }), c.clear();
-    const l = /* @__PURE__ */ new Map();
-    h.forEach((u, m) => {
-      if (!c.has(m) && u.length && a(m, h, u, c), u.length) {
-        const y = u[0];
-        l.has(y.doorUuid) || l.set(y.doorUuid, []), l.get(y.doorUuid)?.push(y), l.has(y.findUuid) || l.set(y.findUuid, []), l.get(y.findUuid)?.push(y);
+      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((m, y) => m.doorLine.length() - y.doorLine.length());
-        for (let m = 1; m < u.length; m++) d.add(u[m]);
+    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 x = [], p = [];
-    h.forEach((u) => {
-      if (u.length) {
-        const m = u[0];
-        d.has(m) || (x.push(m), p.push(m.doorUuid, m.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 w = [];
-    return x.forEach((u) => {
-      const m = t.findIndex((E) => E.uuid === u.doorUuid), y = e.findIndex((E) => E.uuid === u.findUuid), S = t[m].point.clone(), D = e[y].point.clone(), P = this.findLongLineSegment(t[m].line), v = this.findLongLineSegment(e[y].line), L = P.projectPoint(D);
-      if (L) {
-        S.copy(L);
-        const E = new b(S, D), Y = v.includedAngle(E);
-        (Y < 10 || Y > 170 || Math.abs(90 - Y) < 10) && w.push({
-          start: S,
-          end: D
-        });
+    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
+          });
+        }
       } else {
-        const E = v.projectPoint(S);
-        E && D.copy(E);
-        const Y = new b(S, D), G = P.includedAngle(Y);
-        (G < 10 || G > 170 || Math.abs(90 - G) < 10) && w.push({
-          start: S,
-          end: D
-        });
+        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
+          });
+        }
       }
-    }), e.splice(
+    });
+    possibleDoorPoints.splice(
       0,
-      e.length,
-      ...e.filter((u) => p.indexOf(u.uuid) === -1)
-    ), t.splice(
+      possibleDoorPoints.length,
+      ...possibleDoorPoints.filter((p) => removeDoorPointsUuid.indexOf(p.uuid) === -1)
+    );
+    doorPoints.splice(
       0,
-      t.length,
-      ...t.filter((u) => p.indexOf(u.uuid) === -1)
-    ), w;
+      doorPoints.length,
+      ...doorPoints.filter((p) => removeDoorPointsUuid.indexOf(p.uuid) === -1)
+    );
+    return doors;
   }
   /** 方案二： 沿方向查找
    * @description 
    * @param param0 
    * @returns 
    */
-  searchAlongDirection({ point: t, line: e }, n = this.doorSearchDistance) {
-    const i = this.quadtree, o = e.direction();
-    e.start === t && o.multiplyScalar(-1);
-    const s = t.clone().add(o.clone().multiplyScalar(n)), r = new b(t.clone(), s), a = i.queryLineSegment(r).map((c) => ({
-      point: c.line.getIntersection(r),
-      line: c.line
-    })).filter((c) => c.point).sort((c, h) => t.distance(c.point) - t.distance(h.point));
-    if (a.length) {
-      const c = a[0];
-      if (Math.abs(90 - c.line.direction().angleBetween(o, "angle")) < 5)
-        return c;
+  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;
+      }
     }
   }
   /** 方案三： 沿法线方向查找
@@ -1916,25 +2479,35 @@ class it {
    * @param doorSearchDistance 
    * @returns 
    */
-  searchAlongNormalDirection({ point: t, line: e }, n = this.doorSearchDistance) {
-    const i = this.pointVirtualGrid, o = this.quadtree, s = e.direction(), r = e.start.normal(e.end), a = e.start.clone();
-    e.start === t && s.multiplyScalar(-1), e.start === t && a.copy(e.end);
-    const c = i.queryPoint(a).filter((d) => d.userData !== e);
-    for (let d = 0; d < c.length; d++) {
-      const x = c[d], p = x.userData, w = p.direction();
-      if (p.start === x.point && s.multiplyScalar(-1), w.angleBetween(r) / (Math.PI / 180) > 90) {
-        r.multiplyScalar(-1);
+  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);
         break;
       }
     }
-    const h = new b(t.clone(), t.clone().add(r.multiplyScalar(n))), l = o.queryLineSegment(h).map((d) => ({
-      point: d.line.getIntersection(h),
-      line: d.line
-    })).filter((d) => d.point).sort((d, x) => t.distance(d.point) - t.distance(x.point));
-    if (l.length) {
-      const d = l[0];
-      if (Math.abs(90 - d.line.direction().angleBetween(r, "angle")) < 5)
-        return d;
+    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;
+      }
     }
   }
   /**
@@ -1942,31 +2515,37 @@ class it {
    * @param line 
    * @returns 
    */
-  findLongLineSegment(t) {
-    const e = t.clone(), n = this.pointVirtualGrid.queryPoint(t.start), i = this.pointVirtualGrid.queryPoint(t.end);
-    for (let o = 0; o < n.length; o++) {
-      const { userData: s } = n[o];
-      if (s !== t && s && s.directionEqual(t)) {
-        s.start.equal(t.start) ? e.start.copy(s.end) : e.start.copy(s.start);
+  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);
         break;
       }
     }
-    for (let o = 0; o < i.length; o++) {
-      const { userData: s } = i[o];
-      if (s !== t && s && s.directionEqual(t)) {
-        s.end.equal(t.end) ? e.end.copy(s.start) : e.end.copy(s.end);
+    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);
         break;
       }
     }
-    return e;
+    return resLine;
   }
 }
-class st extends X {
+class LineAnalysis extends Component {
   static name = "LineAnalysis";
   Dxf = null;
   Variable = null;
   lineSegmentList = [];
-  container = new M.Group();
+  container = new THREE.Group();
   // 误差角度
   errorAngle = 4;
   width = 0.4;
@@ -1974,8 +2553,11 @@ class st extends X {
    * 
    * @param parent 
    */
-  onAddFromParent(t) {
-    this.Dxf = t.findComponentByType(I), this.Variable = this.parent?.findComponentByType(k), this.Dxf.addEventListener("setDta", this.lineAnalysis.bind(this)), this.Dxf.addEventListener("createGroup", this.doorsAnalysis.bind(this));
+  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));
   }
   /**
    * 
@@ -1984,16 +2566,20 @@ class st extends X {
    * @param width 
    * @returns 
    */
-  expandLineSegment(t, e, n = 0.1) {
-    const i = e.normal(t), o = e.direction(t).mutiplyScalar(n * 0.5), s = t.direction(e).mutiplyScalar(n * 0.5), r = i.x * n * 0.5, a = i.y * n * 0.5;
+  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;
     return {
       points: [
         // 第一条线
-        new f(t.x + r, t.y + a).add(s),
-        new f(e.x + r, e.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(t.x - r, t.y - a).add(s),
-        new f(e.x - r, e.y - a).add(o)
+        new Point(p1.x - offsetX, p1.y - offsetY).add(nDirect),
+        new Point(p2.x - offsetX, p2.y - offsetY).add(pDirect)
       ],
       indices: [0, 1, 1, 3, 3, 2, 2, 0],
       rectIndices: [0, 1, 3, 2, 0]
@@ -2005,25 +2591,31 @@ class st extends X {
    * @param p1 
    * @param p2 
    */
-  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()));
+  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()));
   }
   /** 结果分析创建矩形
    * @param result 
    */
-  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 o = n.points[0].distance(i.points[0]), s = n.points[1].distance(i.points[1]), r = Math.ceil(Math.max(o, s) / e.width), a = o / r, c = s / r, h = i.points[0].direction(n.points[0]), l = i.points[1].direction(n.points[1]), d = n.points[0].clone(), x = n.points[1].clone(), p = x.direction(d);
-    p.multiplyScalar(e.width * 0.5);
-    const w = d.clone().add(p), u = x.clone().add(p.multiplyScalar(-1)), m = d.direction(x), y = w.direction(u);
-    if (!(m.x > 0 && y.x < 0 || m.x < 0 && y.x > 0 || m.y > 0 && y.y < 0 || m.y < 0 && y.y > 0)) {
-      d.set(w.x, w.y), x.set(u.x, u.y);
-      for (let S = 1; S < r; S++) {
-        const D = h.clone().multiplyScalar(a * S), P = l.clone().multiplyScalar(c * S), v = d.clone().add(D), L = x.clone().add(P);
-        this.addData(v, L);
-      }
+  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);
     }
   }
   quadtree;
@@ -2031,13 +2623,18 @@ class st extends X {
    * 构建线段四叉树，快速查找，
    */
   buildQuadtree() {
-    const t = this.Dxf, e = [];
-    this.quadtree = new B(t.originalBox, 2), t.lineSegments.forEach((n) => {
-      n.userData?.isDoor || (this.quadtree?.insert({
-        line: n,
-        userData: e.length
-      }), e.push(n));
-    }), this.lineSegmentList = e;
+    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;
   }
   resultList = [];
   mergeWallLines = [];
@@ -2047,18 +2644,24 @@ class st extends X {
    */
   lineAnalysis() {
     this.buildQuadtree();
-    const t = this.quadtree, e = this.lineSegmentList, n = /* @__PURE__ */ new Set(), i = [];
-    e.forEach((o, s) => {
-      const r = e[s], a = C.fromByLineSegment(r, this.width * 2, !1, -0.01);
-      t.queryRect(a).map((h) => h.userData).filter((h) => h !== s).forEach((h) => {
+    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) => {
         try {
-          if (n.has(`${s}-${h}`) || n.has(`${h}-${s}`)) return;
-          const l = this.projectionAnalysis(h, s, r, e);
-          l && i.push(l), n.add(`${s}-${h}`);
-        } catch {
+          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) {
         }
       });
-    }), this.appendLineSegmentList.length = 0, i.forEach(this.createRectangle.bind(this)), this.resultList = i;
+    });
+    this.appendLineSegmentList.length = 0;
+    resultList.forEach(this.createRectangle.bind(this));
+    this.resultList = resultList;
   }
   /** 线段投影分析
    * @param index 
@@ -2066,36 +2669,42 @@ class st extends X {
    * @param lineSegmentList 
    * @returns 
    */
-  projectionAnalysis(t, e, n, i) {
-    const o = i[t], s = n.direction(), r = o.direction(), a = s.angleBetween(r) / (Math.PI / 180);
-    if (a < this.errorAngle || a > 180 - this.errorAngle) {
-      let c;
-      const h = o.projectLineSegment(n), l = n.projectLineSegment(o);
-      return h.getLength() > l.getLength() ? c = {
-        target: o,
-        targetIndex: t,
-        source: n,
-        sourceIndex: e,
-        project: h,
-        project2: l
-      } : c = {
-        target: n,
-        targetIndex: e,
-        source: o,
-        sourceIndex: t,
-        project: l,
-        project2: h
-      }, !c || c.project.getLength() < 0.2 || c.project2.getLength() < 0.2 ? void 0 : c;
+  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;
     }
   }
   doorSearchNearAngle = 110;
   doorSearchDistance = 2;
   doors = [];
   doorsAnalysis() {
-    new it(this);
+    new DoorsAnalysis(this);
   }
 }
-class ot extends et {
+class DxfSystem extends ComponentManager {
   Dxf;
   Variable;
   wallWidth;
@@ -2104,87 +2713,116 @@ class ot extends et {
    * @param wallWidth 输出墙壁厚度，该墙壁厚度不受缩放影响
    * @param scale 原始数据缩放比例
    */
-  constructor(t = 0.1, e = 1) {
-    super(), this.environment = typeof window < "u" ? "browser" : typeof global < "u" ? "node" : "unknown", this.wallWidth = t, this.Dxf = new I(this.wallWidth, e), this.Variable = new k(), this.addComponent(this.Variable), this.addComponent(this.Dxf), this.addComponent(new st());
+  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());
   }
-  usePlugin(t) {
-    return typeof t == "function" && t.call(this, this), this;
+  usePlugin(plugin) {
+    if (typeof plugin === "function") plugin.call(this, this);
+    return this;
   }
   destroy() {
-    [...this.components].forEach((t) => {
-      t.destroy();
-    }), [...this.components].forEach((t) => {
-      this.removeComponent(t);
+    [...this.components].forEach((com) => {
+      com.destroy();
+    });
+    [...this.components].forEach((com) => {
+      this.removeComponent(com);
     });
   }
 }
-const rt = new Q(), at = new tt();
-function ct(g, t, e = 0.1) {
-  const n = t.normal(g), i = t.direction(g).mutiplyScalar(e * 0.5), o = g.direction(t).mutiplyScalar(e * 0.5), s = n.x * e * 0.5, r = n.y * e * 0.5;
+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;
   return {
     points: [
       // 第一条线
-      new f(g.x + s, g.y + r).add(o),
-      new f(t.x + s, 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(g.x - s, g.y - r).add(o),
-      new f(t.x - s, 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)
     ],
     indices: [0, 1, 1, 3, 3, 2, 2, 0],
     rectIndices: [0, 1, 3, 2, 0]
   };
 }
-class J extends X {
+class WhiteModel extends Component {
   static name = "WhiteModel";
   Dxf = null;
   Variable = null;
   // dxf数据白模
-  whiteModelGroup = new M.Group();
+  whiteModelGroup = new THREE.Group();
   // dxf数据白模边缘线
-  whiteModelLineGroup = new M.Group();
+  whiteModelLineGroup = new THREE.Group();
   // 原始数据白模
-  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", () => {
+  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", () => {
       this.updateModel();
     });
   }
   updateModel() {
-    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, a) => a === 0 ? i.moveTo(r.x / t.scale, r.y / t.scale) : i.lineTo(r.x / t.scale, r.y / t.scale));
-      const o = new M.ExtrudeGeometry(i, {
+    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, {
         depth: 2.8,
         bevelSize: 0
-      }), s = new M.Mesh(o, this.material);
-      this.whiteModelGroup.add(s), this.whiteModelLineGroup.add(
-        new M.LineSegments(new M.EdgesGeometry(o), new M.LineBasicMaterial({ color: 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 }))
       );
-    }), t.originalData.map(({ start: n, end: i, insetionArr: o }) => {
-      const s = new f(n.x, n.y).mutiplyScalar(t.scale), r = new f(i.x, i.y).mutiplyScalar(t.scale), { points: a, indices: c, rectIndices: h } = ct(s, r, t.width);
+    });
+    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);
       return {
-        points: a,
-        indices: c,
-        rectIndices: h,
-        insetions: (o ?? []).map((l) => l.index)
+        points,
+        indices,
+        rectIndices,
+        insetions: (insetionArr ?? []).map((insetion) => insetion.index)
       };
-    }).forEach((n) => {
-      const i = new M.Shape();
-      n.rectIndices.forEach((r, a) => {
-        const c = n.points[r];
-        a === 0 ? i.moveTo(c.x, c.y) : i.lineTo(c.x, c.y);
+    });
+    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);
       });
-      const o = new M.ExtrudeGeometry(i, {
+      const geometry = new THREE.ExtrudeGeometry(shape, {
         depth: 2.8,
         bevelSize: 0
       });
-      if (o.attributes.position.array.filter((r) => Number.isNaN(r)).length) return;
-      const s = new M.Mesh(o);
-      this.originalWhiteMode?.add(s);
-    }), this.dispatchEvent({
+      if (geometry.attributes.position.array.filter((num) => Number.isNaN(num)).length) return;
+      const mesh = new THREE.Mesh(geometry);
+      this.originalWhiteMode?.add(mesh);
+    });
+    this.dispatchEvent({
       type: "updateModel",
       originalWhiteMode: this.originalWhiteMode,
       whiteModelGroup: this.whiteModelGroup
@@ -2195,9 +2833,13 @@ class J extends X {
    * @returns 
    */
   toOBJ() {
-    return new Promise((t) => {
-      this.material.opacity = 1, this.material.needsUpdate = !0, setTimeout(() => {
-        t(rt.parse(this.whiteModelGroup)), this.material.opacity = 0.8, this.material.transparent = !0;
+    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;
       }, 20);
     });
   }
@@ -2206,28 +2848,38 @@ class J extends X {
    * @param binary 
    * @returns 
    */
-  toGltf(t = !0) {
-    return new Promise((e) => {
-      this.material.opacity = 1, this.material.needsUpdate = !0, setTimeout(async () => {
-        if (typeof window == "object")
-          at.parse(this.whiteModelGroup.children, (n) => {
-            e(n), this.material.opacity = 0.8, this.material.transparent = !0;
+  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;
           }, () => {
-            e(void 0);
+            resolve(void 0);
           }, {
-            binary: t
+            binary
           });
-        else if (typeof global != "function")
+        } else if (typeof global !== "function") {
           try {
-            const n = await q("obj2gltf", !0), i = await q("fs", !1), o = await this.toOBJ();
-            i.writeFileSync(this.uuid, o);
-            const s = await n(this.uuid, {
-              binary: t
+            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
             });
-            i.unlinkSync(this.uuid), e(t ? s : JSON.stringify(s));
-          } catch (n) {
-            e(void 0), console.log(n);
+            fs.unlinkSync(this.uuid);
+            if (binary) resolve(result);
+            else resolve(JSON.stringify(result));
+          } catch (error) {
+            resolve(void 0);
+            console.log(error);
           }
+        }
       }, 20);
     });
   }
@@ -2236,33 +2888,40 @@ class J extends X {
    * @returns 
    */
   async toOBJBlob() {
-    const t = await this.toOBJ();
-    if (t)
-      return new Blob([t], { type: "application/octet-stream" });
+    const buffer = await this.toOBJ();
+    if (buffer) {
+      return new Blob([buffer], { type: "application/octet-stream" });
+    }
   }
   /**
    * 转为 GltfBlob
    * @returns 
    */
-  async toGltfBlob(t = !0) {
-    const e = await this.toGltf(t);
-    if (e)
-      return new Blob([e], { type: "application/octet-stream" });
+  async toGltfBlob(binary = true) {
+    const buffer = await this.toGltf(binary);
+    if (buffer) {
+      return new Blob([buffer], { type: "application/octet-stream" });
+    }
   }
   /**
    * 下载 OBJ
    * @param filename 
    * @returns 
    */
-  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 q("fs", !1)).writeFileSync(t, e);
+  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);
+      }
     }
   }
   /**
@@ -2270,19 +2929,24 @@ class J extends X {
    * @param filename 
    * @returns 
    */
-  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 q("fs", !1)).writeFileSync(t, e ? n : Buffer.from(n));
+  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));
+      }
     }
   }
 }
-class _ extends X {
+class DetailsPoint extends Component {
   static name = "DetailsPoint";
   Dxf = null;
   WhiteModel = null;
@@ -2290,8 +2954,10 @@ class _ extends X {
   desPoints = [];
   raylines = [];
   data = [];
-  onAddFromParent(t) {
-    this.Dxf = t.findComponentByName("Dxf"), this.Variable = t.findComponentByName("Variable"), this.Dxf?.addEventListener("setDta", () => {
+  onAddFromParent(parent) {
+    this.Dxf = parent.findComponentByName("Dxf");
+    this.Variable = parent.findComponentByName("Variable");
+    this.Dxf?.addEventListener("setDta", () => {
       this.updateModel();
     });
   }
@@ -2299,29 +2965,37 @@ class _ extends X {
    * 设置值
    * @param data 
    */
-  async set(t) {
-    if (typeof t == "string")
-      if (typeof global < "u") {
-        const { default: n } = await import(
+  async set(data) {
+    if (typeof data === "string") {
+      if (typeof global !== "undefined") {
+        const packageName = "fs";
+        const { default: fs } = await import(
           /* @vite-ignore */
-          "fs"
-        ), i = n.readFileSync(t), o = JSON.parse(i.toString("utf-8"));
-        this.set(o);
+          packageName
+        );
+        const buffer = fs.readFileSync(data);
+        const json = JSON.parse(buffer.toString("utf-8"));
+        this.set(json);
         return;
-      } else
+      } else {
         throw new Error("非node环境不允许使用路径");
-    this.data = t, this.updateModel();
+      }
+    }
+    this.data = data;
+    this.updateModel();
   }
   /**
    * 设置射线辅助
    */
-  racasterHelper(t, e, n) {
+  racasterHelper(position, direction, far) {
     this.raylines.push([
-      t.clone(),
-      t.clone().add(e.clone().multiplyScalar(n))
-    ]), e.z = 0, this.raylines.push([
-      t.clone(),
-      t.clone().add(e.clone().multiplyScalar(n))
+      position.clone(),
+      position.clone().add(direction.clone().multiplyScalar(far))
+    ]);
+    direction.z = 0;
+    this.raylines.push([
+      position.clone(),
+      position.clone().add(direction.clone().multiplyScalar(far))
     ]);
   }
   _timer = null;
@@ -2329,133 +3003,161 @@ class _ extends X {
    * 更新模型
    */
   updateModel() {
-    this._timer && clearTimeout(this._timer), this._timer = setTimeout(() => {
+    if (this._timer) clearTimeout(this._timer);
+    this._timer = setTimeout(() => {
       this._timer = null;
-      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
-        ), o = 100;
-        this.racasterHelper(n, i, o), i.z = 0;
-        const r = new M.Raycaster(n, i, 0, o).intersectObject(t.originalWhiteMode);
-        if (r.length) {
-          const { point: a } = r[0];
+      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];
           this.desPoints.push({
-            message: e.desc,
-            position: n,
-            intersection: a
+            message: item.desc,
+            position,
+            intersection: point
           });
         }
-      }), this.dispatchEvent({
+      });
+      this.dispatchEvent({
         type: "handleSuccess",
         desPoints: this.desPoints
       });
     }, 50);
   }
 }
-class H extends X {
+class DxfLineModel extends Component {
   static name = "DxfLineModel";
-  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());
+  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());
   }
   updateMode() {
-    const t = this.parent?.findComponentByName("Dxf");
+    const dxf = this.parent?.findComponentByName("Dxf");
     this.dxfLineModel.clear();
-    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: o, end: s }) => [o.x, o.y, 0, s.x, s.y, 0])
-    ).map((o) => o / 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({
+    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({
       type: "modelUpdate",
       model: this.dxfModelGroup
     });
   }
 }
-const ht = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  DetailsPoint: _,
-  DxfLineModel: H,
-  WhiteModel: J
+  DetailsPoint,
+  DxfLineModel,
+  WhiteModel
 }, Symbol.toStringTag, { value: "Module" }));
-function W(g, t = {}) {
+function ModelDataPlugin_(dxfSystem, option = {}) {
   const {
-    detailsPoint: e = !0,
-    whiteModel: n = !0,
-    dxfLineModel: i = !0
-  } = t;
-  i && g.addComponent(new H()), n && g.addComponent(new J()), e && g.addComponent(new _());
+    detailsPoint = true,
+    whiteModel = true,
+    dxfLineModel = true
+  } = option;
+  dxfLineModel && dxfSystem.addComponent(new DxfLineModel());
+  whiteModel && dxfSystem.addComponent(new WhiteModel());
+  detailsPoint && dxfSystem.addComponent(new DetailsPoint());
 }
-const lt = Object.assign(W, {
-  create(g = {}) {
-    return (t) => W(t, g);
+const ModelDataPlugin = Object.assign(ModelDataPlugin_, {
+  create(option = {}) {
+    return (dxfSystem) => ModelDataPlugin_(dxfSystem, option);
   }
-}), dt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+});
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  ModelDataPlugin: lt,
-  components: ht
+  ModelDataPlugin,
+  components: index$1
 }, Symbol.toStringTag, { value: "Module" }));
-function ut() {
+function loadRenderPlugin() {
   return import("./index2.js");
 }
-function ft() {
+function loadEditorPlugin() {
   return import("./index3.js");
 }
-let O = null;
-async function Dt(g, t, e = !1, n) {
-  const i = await Promise.resolve().then(() => dt), o = await ut(), s = await ft(), r = new ot().usePlugin(i.ModelDataPlugin.create({
-    detailsPoint: !1,
-    whiteModel: !0
-  })).usePlugin(o.RenderPlugin.create({
-    originalLine: !1,
-    modelData: !1,
-    detailsPoint: !1,
-    orbitControls: e,
-    camera: t
-  })).usePlugin(s.Editor.create({ viewPermission: n })), a = r.findComponentByType(o.components.DomContainer);
-  return a && g.appendChild(a.domElement), O = r, {
-    dxfSystem: r,
-    getFileAll: () => pt(r)
+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)
   };
 }
-async function pt(g = O) {
-  const t = g.findComponentByName("WhiteModel"), e = new File([g.Dxf.toDxfBlob()], "dxf.dxf", { type: "application/dxf" }), n = new File([await t.toOBJBlob()], "model.obj", { type: "application/octet-stream" }), i = new File([await t.toGltfBlob(!0)], "model.glb", { type: "application/octet-stream" }), o = new File([await t.toGltfBlob(!1)], "model.gltf", { type: "application/json" }), s = new File([JSON.stringify(g.Dxf.originalData)], "json.json", { type: "application/json" });
+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" });
   return {
-    dxf: e,
-    obj: n,
-    glb: i,
-    gltf: o,
-    json: s
+    dxf,
+    obj,
+    glb,
+    gltf,
+    json
   };
 }
-function bt() {
-  return O;
+function getGlobalDxfSystem() {
+  return gloabalDxfSystem;
 }
 export {
-  A as B,
-  X as C,
-  ot as D,
-  $ as E,
-  b as L,
-  lt as M,
-  f as P,
-  B as Q,
-  k as V,
-  J as W,
-  _ as a,
-  U as b,
-  Dt as c,
-  bt as d,
-  pt as g,
-  ht as i
+  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
 };