build-dxf 0.1.126 → 0.1.128

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "build-dxf",
-  "version": "0.1.126",
+  "version": "0.1.128",
   "description": "",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/build.js

@@ -684,54 +684,71 @@ class PointSpatialHash {
     }
     return null;
   }
-  /** 通过点，从近到远辐射查找，同一格子，不保证远近
-   * 返回第一个满足条件的目标
+  /** 通过点，从近到远按圈层搜索
+   * 同一圈内不保证距离顺序
+   * 返回第一个满足条件的圈层
    */
-  nearestSearch(point2, fn2, maxRing = 1e3) {
+  searchByRing(point2, fn2, maxRing = 1e3) {
+    let gridCount = this.map.size;
     const centerI = Math.floor(point2.x / this.gridSize);
     const centerJ = Math.floor(point2.y / this.gridSize);
-    const set2 = this.map.get(this.getGridId(centerI, centerJ));
-    if (set2) {
+    const currentCircle = [];
+    const appendGrid = (i, j) => {
+      const set2 = this.map.get(this.getGridId(i, j));
+      if (!set2) return;
+      gridCount--;
       for (const target of set2) {
-        if (fn2(target)) return target;
+        currentCircle.push({
+          point: target.point,
+          userData: target.userData,
+          distanceSq: point2.distanceSquared(target.point)
+        });
       }
+    };
+    appendGrid(centerI, centerJ);
+    if (fn2(currentCircle, 0)) {
+      return currentCircle;
     }
+    if (gridCount === 0) return null;
     for (let r2 = 1; r2 <= maxRing; r2++) {
+      currentCircle.length = 0;
       const minI = centerI - r2;
       const maxI = centerI + r2;
       const minJ = centerJ - r2;
       const maxJ = centerJ + r2;
       for (let i = minI; i <= maxI; i++) {
-        let set22 = this.map.get(this.getGridId(i, minJ));
-        if (set22) {
-          for (const target of set22) {
-            if (fn2(target)) return target;
-          }
-        }
-        set22 = this.map.get(this.getGridId(i, maxJ));
-        if (set22) {
-          for (const target of set22) {
-            if (fn2(target)) return target;
-          }
-        }
+        appendGrid(i, minJ);
+        appendGrid(i, maxJ);
       }
       for (let j = minJ + 1; j < maxJ; j++) {
-        let set22 = this.map.get(this.getGridId(minI, j));
-        if (set22) {
-          for (const target of set22) {
-            if (fn2(target)) return target;
-          }
-        }
-        set22 = this.map.get(this.getGridId(maxI, j));
-        if (set22) {
-          for (const target of set22) {
-            if (fn2(target)) return target;
-          }
-        }
+        appendGrid(minI, j);
+        appendGrid(maxI, j);
+      }
+      if (fn2(currentCircle, r2)) {
+        return currentCircle;
       }
+      if (gridCount === 0) return null;
     }
     return null;
   }
+  /** 
+   * @param point 
+   * @param excludeSelf 
+   * @returns 
+   */
+  findNearest(point2, excludeSelf = true) {
+    let nearest = null;
+    this.searchByRing(point2, (circle) => {
+      for (const item of circle) {
+        if (excludeSelf && item.point === point2) continue;
+        if (!nearest || item.distanceSq < nearest.distanceSq) {
+          nearest = item;
+        }
+      }
+      return nearest !== null;
+    });
+    return nearest;
+  }
   /** 
    * @param point 
    */
@@ -5833,299 +5850,6 @@ function smallestSurroundingRectangleByArea(geoJsonInput) {
   }
   return resultPolygon;
 }
-const tmpPoint1 = [0, 0];
-const tmpPoint2 = [0, 0];
-function lineSegmentsIntersect(p1, p2, q1, q2) {
-  const dx = p2[0] - p1[0];
-  const dy = p2[1] - p1[1];
-  const da2 = q2[0] - q1[0];
-  const db = q2[1] - q1[1];
-  if (da2 * dy - db * dx === 0) {
-    return false;
-  }
-  const s = (dx * (q1[1] - p1[1]) + dy * (p1[0] - q1[0])) / (da2 * dy - db * dx);
-  const t2 = (da2 * (p1[1] - q1[1]) + db * (q1[0] - p1[0])) / (db * dx - da2 * dy);
-  return s >= 0 && s <= 1 && t2 >= 0 && t2 <= 1;
-}
-function triangleArea(a2, b4, c) {
-  return (b4[0] - a2[0]) * (c[1] - a2[1]) - (c[0] - a2[0]) * (b4[1] - a2[1]);
-}
-function isLeft(a2, b4, c) {
-  return triangleArea(a2, b4, c) > 0;
-}
-function isLeftOn(a2, b4, c) {
-  return triangleArea(a2, b4, c) >= 0;
-}
-function isRight(a2, b4, c) {
-  return triangleArea(a2, b4, c) < 0;
-}
-function isRightOn(a2, b4, c) {
-  return triangleArea(a2, b4, c) <= 0;
-}
-function collinear(a2, b4, c, thresholdAngle) {
-  if (thresholdAngle === void 0) {
-    thresholdAngle = 0;
-  }
-  if (!thresholdAngle) {
-    return triangleArea(a2, b4, c) === 0;
-  } else {
-    const ab = tmpPoint1;
-    const bc = tmpPoint2;
-    ab[0] = b4[0] - a2[0];
-    ab[1] = b4[1] - a2[1];
-    bc[0] = c[0] - b4[0];
-    bc[1] = c[1] - b4[1];
-    const dot = ab[0] * bc[0] + ab[1] * bc[1];
-    const magA = Math.sqrt(ab[0] * ab[0] + ab[1] * ab[1]);
-    const magB = Math.sqrt(bc[0] * bc[0] + bc[1] * bc[1]);
-    const angle = Math.acos(dot / (magA * magB));
-    return angle < thresholdAngle;
-  }
-}
-function sqdist(a2, b4) {
-  const dx = b4[0] - a2[0];
-  const dy = b4[1] - a2[1];
-  return dx * dx + dy * dy;
-}
-function polygonAt(polygon2, i) {
-  const s = polygon2.length;
-  return polygon2[i < 0 ? i % s + s : i % s];
-}
-function polygonAppend(polygon2, poly, from, to2) {
-  for (let i = from; i < to2; i++) {
-    polygon2.push(poly[i]);
-  }
-}
-function makeCCW(polygon2) {
-  let br2 = 0;
-  const v2 = polygon2;
-  for (let i = 1; i < polygon2.length; ++i) {
-    if (v2[i][1] < v2[br2][1] || v2[i][1] === v2[br2][1] && v2[i][0] > v2[br2][0]) {
-      br2 = i;
-    }
-  }
-  if (!isLeft(polygonAt(polygon2, br2 - 1), polygonAt(polygon2, br2), polygonAt(polygon2, br2 + 1))) {
-    polygonReverse(polygon2);
-    return true;
-  } else {
-    return false;
-  }
-}
-function polygonReverse(polygon2) {
-  const tmp = [];
-  const N = polygon2.length;
-  for (let i = 0; i !== N; i++) {
-    tmp.push(polygon2.pop());
-  }
-  for (let i = 0; i !== N; i++) {
-    polygon2[i] = tmp[i];
-  }
-}
-function polygonIsReflex(polygon2, i) {
-  return isRight(polygonAt(polygon2, i - 1), polygonAt(polygon2, i), polygonAt(polygon2, i + 1));
-}
-function polygonCanSee2(polygon2, a2, b4) {
-  for (let i = 0; i !== polygon2.length; ++i) {
-    if (i === a2 || i === b4 || (i + 1) % polygon2.length === a2 || (i + 1) % polygon2.length === b4) {
-      continue;
-    }
-    if (lineSegmentsIntersect(polygonAt(polygon2, a2), polygonAt(polygon2, b4), polygonAt(polygon2, i), polygonAt(polygon2, i + 1))) {
-      return false;
-    }
-  }
-  return true;
-}
-function getIntersectionPoint(p1, p2, q1, q2, delta) {
-  if (delta === void 0) {
-    delta = 0;
-  }
-  const a1 = p2[1] - p1[1];
-  const b1 = p1[0] - p2[0];
-  const c1 = a1 * p1[0] + b1 * p1[1];
-  const a2 = q2[1] - q1[1];
-  const b22 = q1[0] - q2[0];
-  const c22 = a2 * q1[0] + b22 * q1[1];
-  const det = a1 * b22 - a2 * b1;
-  if (!scalarsEqual(det, 0, delta)) {
-    return [(b22 * c1 - b1 * c22) / det, (a1 * c22 - a2 * c1) / det];
-  } else {
-    return [0, 0];
-  }
-}
-function quickDecomp(polygon2, result, reflexVertices, steinerPoints, delta, maxlevel, level) {
-  if (result === void 0) {
-    result = [];
-  }
-  if (reflexVertices === void 0) {
-    reflexVertices = [];
-  }
-  if (steinerPoints === void 0) {
-    steinerPoints = [];
-  }
-  if (delta === void 0) {
-    delta = 25;
-  }
-  if (maxlevel === void 0) {
-    maxlevel = 100;
-  }
-  if (level === void 0) {
-    level = 0;
-  }
-  let upperInt = [0, 0];
-  let lowerInt = [0, 0];
-  let p2 = [0, 0];
-  let upperDist = 0;
-  let lowerDist = 0;
-  let d2 = 0;
-  let closestDist = 0;
-  let upperIndex = 0;
-  let lowerIndex = 0;
-  let closestIndex = 0;
-  const lowerPoly = [];
-  const upperPoly = [];
-  const poly = polygon2;
-  const v2 = polygon2;
-  if (v2.length < 3) {
-    return result;
-  }
-  level++;
-  if (level > maxlevel) {
-    console.warn("quickDecomp: max level (" + maxlevel + ") reached.");
-    return result;
-  }
-  for (let i = 0; i < polygon2.length; ++i) {
-    if (polygonIsReflex(poly, i)) {
-      reflexVertices.push(poly[i]);
-      upperDist = lowerDist = Number.MAX_VALUE;
-      for (let j = 0; j < polygon2.length; ++j) {
-        if (isLeft(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j)) && isRightOn(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j - 1))) {
-          p2 = getIntersectionPoint(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j), polygonAt(poly, j - 1));
-          if (isRight(polygonAt(poly, i + 1), polygonAt(poly, i), p2)) {
-            d2 = sqdist(poly[i], p2);
-            if (d2 < lowerDist) {
-              lowerDist = d2;
-              lowerInt = p2;
-              lowerIndex = j;
-            }
-          }
-        }
-        if (isLeft(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j + 1)) && isRightOn(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j))) {
-          p2 = getIntersectionPoint(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j), polygonAt(poly, j + 1));
-          if (isLeft(polygonAt(poly, i - 1), polygonAt(poly, i), p2)) {
-            d2 = sqdist(poly[i], p2);
-            if (d2 < upperDist) {
-              upperDist = d2;
-              upperInt = p2;
-              upperIndex = j;
-            }
-          }
-        }
-      }
-      if (lowerIndex === (upperIndex + 1) % polygon2.length) {
-        p2[0] = (lowerInt[0] + upperInt[0]) / 2;
-        p2[1] = (lowerInt[1] + upperInt[1]) / 2;
-        steinerPoints.push(p2);
-        if (i < upperIndex) {
-          polygonAppend(lowerPoly, poly, i, upperIndex + 1);
-          lowerPoly.push(p2);
-          upperPoly.push(p2);
-          if (lowerIndex !== 0) {
-            polygonAppend(upperPoly, poly, lowerIndex, poly.length);
-          }
-          polygonAppend(upperPoly, poly, 0, i + 1);
-        } else {
-          if (i !== 0) {
-            polygonAppend(lowerPoly, poly, i, poly.length);
-          }
-          polygonAppend(lowerPoly, poly, 0, upperIndex + 1);
-          lowerPoly.push(p2);
-          upperPoly.push(p2);
-          polygonAppend(upperPoly, poly, lowerIndex, i + 1);
-        }
-      } else {
-        if (lowerIndex > upperIndex) {
-          upperIndex += polygon2.length;
-        }
-        closestDist = Number.MAX_VALUE;
-        if (upperIndex < lowerIndex) {
-          return result;
-        }
-        for (let j = lowerIndex; j <= upperIndex; ++j) {
-          if (isLeftOn(polygonAt(poly, i - 1), polygonAt(poly, i), polygonAt(poly, j)) && isRightOn(polygonAt(poly, i + 1), polygonAt(poly, i), polygonAt(poly, j))) {
-            d2 = sqdist(polygonAt(poly, i), polygonAt(poly, j));
-            if (d2 < closestDist && polygonCanSee2(poly, i, j)) {
-              closestDist = d2;
-              closestIndex = j % polygon2.length;
-            }
-          }
-        }
-        if (i < closestIndex) {
-          polygonAppend(lowerPoly, poly, i, closestIndex + 1);
-          if (closestIndex !== 0) {
-            polygonAppend(upperPoly, poly, closestIndex, v2.length);
-          }
-          polygonAppend(upperPoly, poly, 0, i + 1);
-        } else {
-          if (i !== 0) {
-            polygonAppend(lowerPoly, poly, i, v2.length);
-          }
-          polygonAppend(lowerPoly, poly, 0, closestIndex + 1);
-          polygonAppend(upperPoly, poly, closestIndex, i + 1);
-        }
-      }
-      if (lowerPoly.length < upperPoly.length) {
-        quickDecomp(lowerPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
-        quickDecomp(upperPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
-      } else {
-        quickDecomp(upperPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
-        quickDecomp(lowerPoly, result, reflexVertices, steinerPoints, delta, maxlevel, level);
-      }
-      return result;
-    }
-  }
-  result.push(polygon2);
-  return result;
-}
-function removeCollinearPoints(polygon2, thresholdAngle) {
-  if (thresholdAngle === void 0) {
-    thresholdAngle = 0;
-  }
-  let num = 0;
-  for (let i = polygon2.length - 1; polygon2.length > 3 && i >= 0; --i) {
-    if (collinear(polygonAt(polygon2, i - 1), polygonAt(polygon2, i), polygonAt(polygon2, i + 1), thresholdAngle)) {
-      polygon2.splice(i % polygon2.length, 1);
-      num++;
-    }
-  }
-  return num;
-}
-function scalarsEqual(a2, b4, precision) {
-  if (precision === void 0) {
-    precision = 0;
-  }
-  precision = precision || 0;
-  return Math.abs(a2 - b4) <= precision;
-}
-function pointsEqual(a2, b4, precision) {
-  if (precision === void 0) {
-    precision = 0;
-  }
-  return scalarsEqual(a2[0], b4[0], precision) && scalarsEqual(a2[1], b4[1], precision);
-}
-function removeDuplicatePoints(polygon2, precision) {
-  if (precision === void 0) {
-    precision = 0;
-  }
-  for (let i = polygon2.length - 1; i >= 1; --i) {
-    const pi2 = polygon2[i];
-    for (let j = i - 1; j >= 0; --j) {
-      if (pointsEqual(pi2, polygon2[j], precision)) {
-        polygon2.splice(i, 1);
-        continue;
-      }
-    }
-  }
-}
 class Polygon extends Array {
   [Symbol.iterator]() {
     return super[Symbol.iterator]();
@@ -6444,18 +6168,6 @@ class Polygon extends Array {
     this.set(polygons[0]);
     return true;
   }
-  /** 拆分为凸包
-   * @returns 
-   */
-  splitConvexHull() {
-    const concavePolygon = this.toArrays();
-    makeCCW(concavePolygon);
-    removeDuplicatePoints(concavePolygon);
-    removeCollinearPoints(concavePolygon);
-    const optimalConvexPolygons = quickDecomp(concavePolygon);
-    if (!optimalConvexPolygons) return null;
-    return optimalConvexPolygons.map((array) => new Polygon(array.map((item) => Point.from(item))));
-  }
   /** 包围盒检测
    * @param box 
    * @returns 
@@ -7539,27 +7251,27 @@ class OBB2 extends OBB$1 {
    * @param box 
    * @param position 
    * @param rotation 
-   * @param obb 
+   * @param out 
    * @returns 
    */
-  static from(box, position, rotation, obb2 = new OBB2()) {
+  static from(box, position, rotation, out = new OBB2()) {
     if (rotation instanceof THREE.Euler) quat.setFromEuler(rotation);
     else if (rotation instanceof THREE.Quaternion) quat.copy(rotation);
     else throw new Error(`传入的旋转不是欧拉角或者四元数`);
     matrix4.compose(position, quat, scale);
-    obb2.center.copy(position);
-    obb2.halfSize.copy(box.multiplyScalar(0.5));
-    obb2.rotation.setFromMatrix4(matrix4);
-    return obb2;
+    out.center.copy(position);
+    out.halfSize.copy(box.multiplyScalar(0.5));
+    out.rotation.setFromMatrix4(matrix4);
+    return out;
   }
   /** 通过2d路径创建
    * @param path 
    * @param origin 
    * @param height 
-   * @param obb_ 
+   * @param out 
    * @returns 
    */
-  static fromByPath2D(path, origin, height, obb_ = new OBB2()) {
+  static fromByPath2D(path, origin, height, out = new OBB2()) {
     const result = smallestSurroundingRectangleByArea({
       type: "Polygon",
       coordinates: [path.map((p2) => [p2.x, p2.y])]
@@ -7574,8 +7286,8 @@ class OBB2 extends OBB$1 {
     const [x, y] = getCenter(rectangle);
     origin.x = x;
     origin.y = y;
-    const obb2 = this.from(vec3, origin, euler, obb_);
-    return obb2;
+    out = this.from(vec3, origin, euler, out);
+    return out;
   }
 }
 const matrix4 = new THREE.Matrix4(), quat = new THREE.Quaternion(), euler = new THREE.Euler(), scale = new THREE.Vector3(1, 1, 1), vec3 = new THREE.Vector3(), box3$2 = new THREE.Box3();
@@ -10833,7 +10545,9 @@ class ThreeVJiaPipeline extends Pipeline {
         console.warn(`第${i}个物品轮廓为空`);
         return;
       }
-      const itemPoly = new Polygon(contour.map((p2) => Point.from(p2).rotate(json.center, json.angle))), center = itemPoly.getCenter(), index2 = roomPloys.findIndex((poly) => poly.pointWithin(center));
+      const itemPoly = new Polygon(
+        contour.map((p2) => Point.from(p2).rotate(json.center, json.angle))
+      ), center = itemPoly.getCenter(), index2 = roomPloys.findIndex((poly) => poly.pointWithin(center));
       if (index2 < 0) return;
       try {
         const rect = itemPoly.getMinimumBoundingRectangle().map((p2) => p2.toJson2D());
@@ -11080,7 +10794,7 @@ function innerWallLine(lines, trajectory2) {
   lud.forEachPathLine((start, end, line, index2, endType, indxeList) => {
     temLine.start.copy(start);
     temLine.end.copy(end);
-    const wallWidth = line.userData.wallWidth ?? DEFAULT_WALL_WIDTH;
+    const wallWidth = DEFAULT_WALL_WIDTH;
     wallWidths[index2] = wallWidth;
     const hw = indxeList.length ? Math.max(...indxeList.map((i) => wallWidths[i])) * 0.5 : wallWidth * 0.5;
     if (index2 !== 0) {
@@ -22434,7 +22148,7 @@ class SceneAutoGenerat {
     await Promise.all(this.itemList.map(async (item) => await this.getModel(item)));
   }
   static itemParse(item) {
-    if (!Array.isArray(item.contour) || !item.contour.length) return null;
+    if (!Array.isArray(item.quadContour ?? item.contour) || !item.contour.length) return null;
     const contour = Point.fromByList(item.contour ?? []), rectangle = new Polygon(Qa(contour.map((p2) => [p2.x, p2.y])).map((p2) => Point.from(p2)));
     rectangle.pop();
     const z = item.box.min.z, height = Math.abs(item.box.max.z - z), max = rectangle.getMaxLengthInfo(), min = rectangle.getMinLengthInfo(), direction = max.start.y < max.end.y ? max.start.directionFrom(max.end) : max.end.directionFrom(max.start), shape = new THREE.Shape();

package/src/demo.d.ts

@@ -0,0 +1 @@
+export {};

package/src/index.css

@@ -137,6 +137,10 @@
   position: absolute;
 }
 
+.fixed {
+  position: fixed;
+}
+
 .relative {
   position: relative;
 }

package/src/utils/algorithms/ConstraintSystem.d.ts

@@ -0,0 +1,17 @@
+export declare class Variable {
+    value: number;
+    fixed: boolean;
+    constructor(value: number, fixed?: boolean);
+}
+export interface Constraint {
+    evaluate(): number[];
+}
+export declare class ConstraintSystem {
+    constraints: Constraint[];
+    variables: Variable[];
+    addConstraint(c: Constraint): void;
+    addVariable(v: Variable): void;
+    residuals(): number[];
+    jacobian(eps?: number): number[][];
+    solve(iterations?: number): void;
+}

package/src/utils/algorithms/OBB.d.ts

@@ -12,19 +12,19 @@ export declare class OBB extends OBB_ {
      * @param box
      * @param position
      * @param rotation
-     * @param obb
+     * @param out
      * @returns
      */
-    static from(box: THREE.Vector3, position: THREE.Vector3, rotation: THREE.Euler | THREE.Quaternion, obb?: OBB): OBB;
+    static from(box: THREE.Vector3, position: THREE.Vector3, rotation: THREE.Euler | THREE.Quaternion, out?: OBB): OBB;
     /** 通过2d路径创建
      * @param path
      * @param origin
      * @param height
-     * @param obb_
+     * @param out
      * @returns
      */
     static fromByPath2D(path: {
         x: number;
         y: number;
-    }[], origin: THREE.Vector3, height: number, obb_?: OBB): OBB;
+    }[], origin: THREE.Vector3, height: number, out?: OBB): OBB;
 }

package/src/utils/algorithms/PointSpatialHash.d.ts

@@ -10,6 +10,11 @@ type Target<T> = {
 type NodeSet<T> = Set<Target<T>>;
 export type PvgTarget<T> = Target<T>;
 export type ResultList<T = any> = Array<Target<T>>;
+export type CircleResult<T = any> = {
+    point: Point;
+    distanceSq: number;
+    userData?: T;
+};
 export declare class PointSpatialHash<T = Record<string, any>> {
     map: Map<string, NodeSet<T>>;
     gridSize: number;
@@ -109,10 +114,17 @@ export declare class PointSpatialHash<T = Record<string, any>> {
         point: Point;
         userData: T;
     } | null;
-    /** 通过点，从近到远辐射查找，同一格子，不保证远近
-     * 返回第一个满足条件的目标
+    /** 通过点，从近到远按圈层搜索
+     * 同一圈内不保证距离顺序
+     * 返回第一个满足条件的圈层
+     */
+    searchByRing(point: Point, fn: (circle: CircleResult<T>[], circleNum: number) => boolean, maxRing?: number): CircleResult<T>[] | null;
+    /**
+     * @param point
+     * @param excludeSelf
+     * @returns
      */
-    nearestSearch(point: Point, fn: (target: Target<T>) => boolean, maxRing?: number): Target<T> | null;
+    findNearest(point: Point, excludeSelf?: boolean): CircleResult<T> | null;
     /**
      * @param point
      */

package/src/utils/algorithms/Polygon.d.ts

@@ -91,10 +91,6 @@ export declare class Polygon<T = any> extends Array<Point<T>> {
      * @param polygon
      */
     difference(polygons: Polygon | Polygon[], scale?: number): boolean;
-    /** 拆分为凸包
-     * @returns
-     */
-    splitConvexHull(): Polygon<Record<string, any>>[] | null;
     /** 包围盒检测
      * @param box
      * @returns

package/src/utils/algorithms/PolygonUtils.d.ts

@@ -0,0 +1,9 @@
+import { LineSegment } from './LineSegment';
+import { Polygon } from './Polygon';
+export declare class PolygonUtils {
+    /** 拆分为凸包
+     * @returns
+     */
+    static splitConvexHull(ploy: Polygon): Polygon<Record<string, any>>[] | null;
+    static splitByLine(lines: LineSegment[], clipLine: LineSegment): LineSegment[][];
+}

package/src/utils/geometry-manager/GeometryManager.d.ts

@@ -0,0 +1,2 @@
+export declare class GeometryManager {
+}