microboard-temp 0.5.76 → 0.5.77

package/dist/esm/browser.js

@@ -36555,7 +36555,7 @@ function getNeighbors(node2, grid, obstacles) {
     { x: node2.xGrid, y: node2.yGrid + 1 }
   ];
   for (const pos of potentialNeighbors) {
-    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0) {
+    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0 && grid[pos.x] && grid[pos.x][pos.y]) {
       const newPoint = grid[pos.x][pos.y];
       if (newPoint && !obstacles.some((obstacle) => obstacle.isAlmostInside(newPoint, conf.CONNECTOR_ITEM_OFFSET - 1))) {
         neighbors.push({
@@ -36585,16 +36585,20 @@ function findCenterLine(grid, start, end, middle) {
   }
   if (width > height) {
     const centerIdx = grid.findIndex((row2) => row2[0].x === middlePoint.x || Math.abs(row2[0].x - middlePoint.x) < 0.01);
-    for (let y = 0;y < grid[0].length && centerIdx !== -1; y++) {
-      if (grid[centerIdx][y] && grid[centerIdx][y].x >= min2.x - 0.01 && grid[centerIdx][y].x <= max2.x + 0.01 && grid[centerIdx][y].y >= min2.y - 0.01 && grid[centerIdx][y].y <= max2.y + 0.01) {
-        centerLine.push(grid[centerIdx][y]);
+    if (centerIdx !== -1) {
+      for (let y = 0;y < grid[0].length; y++) {
+        if (grid[centerIdx][y] && grid[centerIdx][y].x >= min2.x - 0.01 && grid[centerIdx][y].x <= max2.x + 0.01 && grid[centerIdx][y].y >= min2.y - 0.01 && grid[centerIdx][y].y <= max2.y + 0.01) {
+          centerLine.push(grid[centerIdx][y]);
+        }
       }
     }
   } else {
     const centerIdx = grid[0].findIndex((point5) => point5.y === middlePoint.y || Math.abs(point5.y - middlePoint.y) < 0.01);
-    for (let x = 0;x < grid.length && centerIdx !== -1; x++) {
-      if (grid[x][centerIdx].x >= min2.x - 0.01 && grid[x][centerIdx].x <= max2.x + 0.01 && grid[x][centerIdx].y >= min2.y - 0.01 && grid[x][centerIdx].y <= max2.y + 0.01) {
-        centerLine.push(grid[x][centerIdx]);
+    if (centerIdx !== -1) {
+      for (let x = 0;x < grid.length; x++) {
+        if (grid[x][centerIdx] && grid[x][centerIdx].x >= min2.x - 0.01 && grid[x][centerIdx].x <= max2.x + 0.01 && grid[x][centerIdx].y >= min2.y - 0.01 && grid[x][centerIdx].y <= max2.y + 0.01) {
+          centerLine.push(grid[x][centerIdx]);
+        }
       }
     }
   }
@@ -36650,18 +36654,27 @@ function createGrid(start, end, toVisitPoints = []) {
     middlePoint: middle
   };
 }
-function findPath(start, end, grid, obstacles, newStart, newEnd) {
-  const startIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
-  const endIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
-  if (startIdx === -1 || endIdx === -1) {
-    throw new Error("Start or end point not found in the grid");
+function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
+  const startRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
+  if (startRowIndex === -1) {
+    throw new Error("Start point not found in the grid row");
+  }
+  const startPointIndex = grid[startRowIndex].findIndex((point5) => point5.barelyEqual(start));
+  if (startPointIndex === -1) {
+    throw new Error("Start point not found in the grid column");
+  }
+  const endRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
+  if (endRowIndex === -1) {
+    throw new Error("End point not found in the grid row");
+  }
+  const endPointIndex = grid[endRowIndex].findIndex((point5) => point5.barelyEqual(end));
+  if (endPointIndex === -1) {
+    throw new Error("End point not found in the grid column");
   }
-  const startPointIdx = grid[startIdx].findIndex((point5) => point5.barelyEqual(start));
-  const endPointIdx = grid[endIdx].findIndex((point5) => point5.barelyEqual(end));
   const endNode = {
     point: end,
-    xGrid: endIdx,
-    yGrid: endPointIdx,
+    xGrid: endRowIndex,
+    yGrid: endPointIndex,
     costSoFar: 0,
     heuristic: 0,
     toFinish: 0
@@ -36669,53 +36682,72 @@ function findPath(start, end, grid, obstacles, newStart, newEnd) {
   const startNode = {
     point: start,
     costSoFar: 0,
-    heuristic: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    toFinish: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    xGrid: startIdx,
-    yGrid: startPointIdx
+    heuristic: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    toFinish: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    xGrid: startRowIndex,
+    yGrid: startPointIndex
   };
   const openSet = [startNode];
   const closedSet = new Set;
   while (openSet.length > 0) {
     openSet.sort((aa, bb) => aa.toFinish - bb.toFinish);
     const current = openSet.shift();
+    const currentKey = `${current.point.x},${current.point.y}`;
     if (current.point.barelyEqual(end)) {
       const path2 = reconstructPath(current);
       return path2;
     }
-    closedSet.add(current.point);
+    closedSet.add(currentKey);
     const neighbors = getNeighbors(current, grid, obstacles);
     for (const neighbor of neighbors) {
-      if (closedSet.has(neighbor.point)) {
+      const neighborKey = `${neighbor.point.x},${neighbor.point.y}`;
+      if (closedSet.has(neighborKey) || existingPath.has(neighborKey) && !neighbor.point.barelyEqual(end)) {
         continue;
       }
       const extraCost = isChangingDirection(current, neighbor, newStart, newEnd);
-      const tentativeCost = current.costSoFar + 1;
-      if (!openSet.some((node2) => node2.point.barelyEqual(neighbor.point) && node2.costSoFar <= tentativeCost)) {
-        neighbor.costSoFar = tentativeCost + extraCost;
-        neighbor.heuristic = heuristic(neighbor, endNode);
-        neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
-        openSet.push(neighbor);
+      const pathOverlapCost = existingPath.has(neighborKey) ? 1000 : 0;
+      const tentativeCost = current.costSoFar + 1 + pathOverlapCost;
+      let existingNodeInOpenSet = openSet.find((node2) => node2.point.barelyEqual(neighbor.point));
+      if (!existingNodeInOpenSet || tentativeCost < existingNodeInOpenSet.costSoFar) {
+        if (existingNodeInOpenSet) {
+          existingNodeInOpenSet.costSoFar = tentativeCost + extraCost;
+          existingNodeInOpenSet.heuristic = heuristic(neighbor, endNode);
+          existingNodeInOpenSet.toFinish = existingNodeInOpenSet.costSoFar + existingNodeInOpenSet.heuristic;
+          existingNodeInOpenSet.parent = current;
+        } else {
+          neighbor.costSoFar = tentativeCost + extraCost;
+          neighbor.heuristic = heuristic(neighbor, endNode);
+          neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
+          openSet.push(neighbor);
+        }
       }
     }
   }
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const pathPoints = [];
+  const finalPath = [];
+  const existingPathSegments = new Set;
+  if (points.length > 0) {
+    finalPath.push(points[0]);
+    const startKey = `${points[0].x},${points[0].y}`;
+    existingPathSegments.add(startKey);
+  }
   for (let i = 0;i < points.length - 1; i += 1) {
-    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, newStart, newEnd);
-    if (segmentPath) {
-      pathPoints.push(...segmentPath.slice(0, -1));
+    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    if (segmentPath && segmentPath.length > 0) {
+      for (let j = 1;j < segmentPath.length; j++) {
+        const point5 = segmentPath[j];
+        const key = `${point5.x},${point5.y}`;
+        finalPath.push(point5);
+        existingPathSegments.add(key);
+      }
     } else {
       points.splice(i + 1, 1);
       i--;
     }
   }
-  if (pathPoints.length !== 0) {
-    pathPoints.push(points[points.length - 1]);
-  }
-  return pathPoints;
+  return finalPath;
 }
 function reducePoints(points) {
   const uniquePoints = new Map;
@@ -36726,6 +36758,12 @@ function reducePoints(points) {
     if (uniquePoints.has(key)) {
       const loopStartIndex = uniquePoints.get(key);
       result.splice(loopStartIndex + 1);
+      const removedPoints = points.slice(loopStartIndex + 1, i + 1);
+      removedPoints.forEach((p3) => {
+        uniquePoints.delete(`${p3.x},${p3.y}`);
+      });
+      uniquePoints.set(key, result.length);
+      result.push(point5);
     } else {
       uniquePoints.set(key, result.length);
       result.push(point5);
@@ -36735,19 +36773,32 @@ function reducePoints(points) {
 }
 function getLines(pathPoints) {
   const lines = [];
+  if (pathPoints.length < 2) {
+    return [];
+  }
   const reducedPoints = reducePoints(pathPoints);
+  if (reducedPoints.length < 2) {
+    return [];
+  }
   let startPoint = reducedPoints[0];
-  for (let i = 1;i < reducedPoints.length - 1; i += 1) {
+  for (let i = 1;i < reducedPoints.length; i += 1) {
     const prevPoint = reducedPoints[i - 1];
     const currPoint = reducedPoints[i];
-    const nextPoint = reducedPoints[i + 1];
-    if (prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
+    const nextPoint = i + 1 < reducedPoints.length ? reducedPoints[i + 1] : null;
+    if (!nextPoint || prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
       lines.push(new Line(startPoint, currPoint));
       startPoint = currPoint;
     }
   }
-  if (lines.length > 0) {
-    lines.push(new Line(startPoint, pathPoints[pathPoints.length - 1]));
+  if (lines.length === 0 && reducedPoints.length > 1) {
+    lines.push(new Line(reducedPoints[0], reducedPoints[reducedPoints.length - 1]));
+  } else if (lines.length > 0) {
+    const lastLine = lines[lines.length - 1];
+    const lastPointInLines = lastLine.getEndPoint();
+    const lastPointInReduced = reducedPoints[reducedPoints.length - 1];
+    if (!lastPointInLines.barelyEqual(lastPointInReduced)) {
+      lines.push(new Line(lastPointInLines, lastPointInReduced));
+    }
   }
   return lines;
 }

package/dist/esm/index.js

@@ -36548,7 +36548,7 @@ function getNeighbors(node2, grid, obstacles) {
     { x: node2.xGrid, y: node2.yGrid + 1 }
   ];
   for (const pos of potentialNeighbors) {
-    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0) {
+    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0 && grid[pos.x] && grid[pos.x][pos.y]) {
       const newPoint = grid[pos.x][pos.y];
       if (newPoint && !obstacles.some((obstacle) => obstacle.isAlmostInside(newPoint, conf.CONNECTOR_ITEM_OFFSET - 1))) {
         neighbors.push({
@@ -36578,16 +36578,20 @@ function findCenterLine(grid, start, end, middle) {
   }
   if (width > height) {
     const centerIdx = grid.findIndex((row2) => row2[0].x === middlePoint.x || Math.abs(row2[0].x - middlePoint.x) < 0.01);
-    for (let y = 0;y < grid[0].length && centerIdx !== -1; y++) {
-      if (grid[centerIdx][y] && grid[centerIdx][y].x >= min2.x - 0.01 && grid[centerIdx][y].x <= max2.x + 0.01 && grid[centerIdx][y].y >= min2.y - 0.01 && grid[centerIdx][y].y <= max2.y + 0.01) {
-        centerLine.push(grid[centerIdx][y]);
+    if (centerIdx !== -1) {
+      for (let y = 0;y < grid[0].length; y++) {
+        if (grid[centerIdx][y] && grid[centerIdx][y].x >= min2.x - 0.01 && grid[centerIdx][y].x <= max2.x + 0.01 && grid[centerIdx][y].y >= min2.y - 0.01 && grid[centerIdx][y].y <= max2.y + 0.01) {
+          centerLine.push(grid[centerIdx][y]);
+        }
       }
     }
   } else {
     const centerIdx = grid[0].findIndex((point5) => point5.y === middlePoint.y || Math.abs(point5.y - middlePoint.y) < 0.01);
-    for (let x = 0;x < grid.length && centerIdx !== -1; x++) {
-      if (grid[x][centerIdx].x >= min2.x - 0.01 && grid[x][centerIdx].x <= max2.x + 0.01 && grid[x][centerIdx].y >= min2.y - 0.01 && grid[x][centerIdx].y <= max2.y + 0.01) {
-        centerLine.push(grid[x][centerIdx]);
+    if (centerIdx !== -1) {
+      for (let x = 0;x < grid.length; x++) {
+        if (grid[x][centerIdx] && grid[x][centerIdx].x >= min2.x - 0.01 && grid[x][centerIdx].x <= max2.x + 0.01 && grid[x][centerIdx].y >= min2.y - 0.01 && grid[x][centerIdx].y <= max2.y + 0.01) {
+          centerLine.push(grid[x][centerIdx]);
+        }
       }
     }
   }
@@ -36643,18 +36647,27 @@ function createGrid(start, end, toVisitPoints = []) {
     middlePoint: middle
   };
 }
-function findPath(start, end, grid, obstacles, newStart, newEnd) {
-  const startIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
-  const endIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
-  if (startIdx === -1 || endIdx === -1) {
-    throw new Error("Start or end point not found in the grid");
+function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
+  const startRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
+  if (startRowIndex === -1) {
+    throw new Error("Start point not found in the grid row");
+  }
+  const startPointIndex = grid[startRowIndex].findIndex((point5) => point5.barelyEqual(start));
+  if (startPointIndex === -1) {
+    throw new Error("Start point not found in the grid column");
+  }
+  const endRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
+  if (endRowIndex === -1) {
+    throw new Error("End point not found in the grid row");
+  }
+  const endPointIndex = grid[endRowIndex].findIndex((point5) => point5.barelyEqual(end));
+  if (endPointIndex === -1) {
+    throw new Error("End point not found in the grid column");
   }
-  const startPointIdx = grid[startIdx].findIndex((point5) => point5.barelyEqual(start));
-  const endPointIdx = grid[endIdx].findIndex((point5) => point5.barelyEqual(end));
   const endNode = {
     point: end,
-    xGrid: endIdx,
-    yGrid: endPointIdx,
+    xGrid: endRowIndex,
+    yGrid: endPointIndex,
     costSoFar: 0,
     heuristic: 0,
     toFinish: 0
@@ -36662,53 +36675,72 @@ function findPath(start, end, grid, obstacles, newStart, newEnd) {
   const startNode = {
     point: start,
     costSoFar: 0,
-    heuristic: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    toFinish: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    xGrid: startIdx,
-    yGrid: startPointIdx
+    heuristic: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    toFinish: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    xGrid: startRowIndex,
+    yGrid: startPointIndex
   };
   const openSet = [startNode];
   const closedSet = new Set;
   while (openSet.length > 0) {
     openSet.sort((aa, bb) => aa.toFinish - bb.toFinish);
     const current = openSet.shift();
+    const currentKey = `${current.point.x},${current.point.y}`;
     if (current.point.barelyEqual(end)) {
       const path2 = reconstructPath(current);
       return path2;
     }
-    closedSet.add(current.point);
+    closedSet.add(currentKey);
     const neighbors = getNeighbors(current, grid, obstacles);
     for (const neighbor of neighbors) {
-      if (closedSet.has(neighbor.point)) {
+      const neighborKey = `${neighbor.point.x},${neighbor.point.y}`;
+      if (closedSet.has(neighborKey) || existingPath.has(neighborKey) && !neighbor.point.barelyEqual(end)) {
         continue;
       }
       const extraCost = isChangingDirection(current, neighbor, newStart, newEnd);
-      const tentativeCost = current.costSoFar + 1;
-      if (!openSet.some((node2) => node2.point.barelyEqual(neighbor.point) && node2.costSoFar <= tentativeCost)) {
-        neighbor.costSoFar = tentativeCost + extraCost;
-        neighbor.heuristic = heuristic(neighbor, endNode);
-        neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
-        openSet.push(neighbor);
+      const pathOverlapCost = existingPath.has(neighborKey) ? 1000 : 0;
+      const tentativeCost = current.costSoFar + 1 + pathOverlapCost;
+      let existingNodeInOpenSet = openSet.find((node2) => node2.point.barelyEqual(neighbor.point));
+      if (!existingNodeInOpenSet || tentativeCost < existingNodeInOpenSet.costSoFar) {
+        if (existingNodeInOpenSet) {
+          existingNodeInOpenSet.costSoFar = tentativeCost + extraCost;
+          existingNodeInOpenSet.heuristic = heuristic(neighbor, endNode);
+          existingNodeInOpenSet.toFinish = existingNodeInOpenSet.costSoFar + existingNodeInOpenSet.heuristic;
+          existingNodeInOpenSet.parent = current;
+        } else {
+          neighbor.costSoFar = tentativeCost + extraCost;
+          neighbor.heuristic = heuristic(neighbor, endNode);
+          neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
+          openSet.push(neighbor);
+        }
       }
     }
   }
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const pathPoints = [];
+  const finalPath = [];
+  const existingPathSegments = new Set;
+  if (points.length > 0) {
+    finalPath.push(points[0]);
+    const startKey = `${points[0].x},${points[0].y}`;
+    existingPathSegments.add(startKey);
+  }
   for (let i = 0;i < points.length - 1; i += 1) {
-    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, newStart, newEnd);
-    if (segmentPath) {
-      pathPoints.push(...segmentPath.slice(0, -1));
+    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    if (segmentPath && segmentPath.length > 0) {
+      for (let j = 1;j < segmentPath.length; j++) {
+        const point5 = segmentPath[j];
+        const key = `${point5.x},${point5.y}`;
+        finalPath.push(point5);
+        existingPathSegments.add(key);
+      }
     } else {
       points.splice(i + 1, 1);
       i--;
     }
   }
-  if (pathPoints.length !== 0) {
-    pathPoints.push(points[points.length - 1]);
-  }
-  return pathPoints;
+  return finalPath;
 }
 function reducePoints(points) {
   const uniquePoints = new Map;
@@ -36719,6 +36751,12 @@ function reducePoints(points) {
     if (uniquePoints.has(key)) {
       const loopStartIndex = uniquePoints.get(key);
       result.splice(loopStartIndex + 1);
+      const removedPoints = points.slice(loopStartIndex + 1, i + 1);
+      removedPoints.forEach((p3) => {
+        uniquePoints.delete(`${p3.x},${p3.y}`);
+      });
+      uniquePoints.set(key, result.length);
+      result.push(point5);
     } else {
       uniquePoints.set(key, result.length);
       result.push(point5);
@@ -36728,19 +36766,32 @@ function reducePoints(points) {
 }
 function getLines(pathPoints) {
   const lines = [];
+  if (pathPoints.length < 2) {
+    return [];
+  }
   const reducedPoints = reducePoints(pathPoints);
+  if (reducedPoints.length < 2) {
+    return [];
+  }
   let startPoint = reducedPoints[0];
-  for (let i = 1;i < reducedPoints.length - 1; i += 1) {
+  for (let i = 1;i < reducedPoints.length; i += 1) {
     const prevPoint = reducedPoints[i - 1];
     const currPoint = reducedPoints[i];
-    const nextPoint = reducedPoints[i + 1];
-    if (prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
+    const nextPoint = i + 1 < reducedPoints.length ? reducedPoints[i + 1] : null;
+    if (!nextPoint || prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
       lines.push(new Line(startPoint, currPoint));
       startPoint = currPoint;
     }
   }
-  if (lines.length > 0) {
-    lines.push(new Line(startPoint, pathPoints[pathPoints.length - 1]));
+  if (lines.length === 0 && reducedPoints.length > 1) {
+    lines.push(new Line(reducedPoints[0], reducedPoints[reducedPoints.length - 1]));
+  } else if (lines.length > 0) {
+    const lastLine = lines[lines.length - 1];
+    const lastPointInLines = lastLine.getEndPoint();
+    const lastPointInReduced = reducedPoints[reducedPoints.length - 1];
+    if (!lastPointInLines.barelyEqual(lastPointInReduced)) {
+      lines.push(new Line(lastPointInLines, lastPointInReduced));
+    }
   }
   return lines;
 }

package/dist/esm/node.js

@@ -39016,7 +39016,7 @@ function getNeighbors(node2, grid, obstacles) {
     { x: node2.xGrid, y: node2.yGrid + 1 }
   ];
   for (const pos of potentialNeighbors) {
-    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0) {
+    if (pos.x >= 0 && pos.x < grid.length && pos.y >= 0 && grid[pos.x] && grid[pos.x][pos.y]) {
       const newPoint = grid[pos.x][pos.y];
       if (newPoint && !obstacles.some((obstacle) => obstacle.isAlmostInside(newPoint, conf.CONNECTOR_ITEM_OFFSET - 1))) {
         neighbors.push({
@@ -39046,16 +39046,20 @@ function findCenterLine(grid, start, end, middle) {
   }
   if (width > height) {
     const centerIdx = grid.findIndex((row2) => row2[0].x === middlePoint.x || Math.abs(row2[0].x - middlePoint.x) < 0.01);
-    for (let y = 0;y < grid[0].length && centerIdx !== -1; y++) {
-      if (grid[centerIdx][y] && grid[centerIdx][y].x >= min2.x - 0.01 && grid[centerIdx][y].x <= max2.x + 0.01 && grid[centerIdx][y].y >= min2.y - 0.01 && grid[centerIdx][y].y <= max2.y + 0.01) {
-        centerLine.push(grid[centerIdx][y]);
+    if (centerIdx !== -1) {
+      for (let y = 0;y < grid[0].length; y++) {
+        if (grid[centerIdx][y] && grid[centerIdx][y].x >= min2.x - 0.01 && grid[centerIdx][y].x <= max2.x + 0.01 && grid[centerIdx][y].y >= min2.y - 0.01 && grid[centerIdx][y].y <= max2.y + 0.01) {
+          centerLine.push(grid[centerIdx][y]);
+        }
       }
     }
   } else {
     const centerIdx = grid[0].findIndex((point5) => point5.y === middlePoint.y || Math.abs(point5.y - middlePoint.y) < 0.01);
-    for (let x = 0;x < grid.length && centerIdx !== -1; x++) {
-      if (grid[x][centerIdx].x >= min2.x - 0.01 && grid[x][centerIdx].x <= max2.x + 0.01 && grid[x][centerIdx].y >= min2.y - 0.01 && grid[x][centerIdx].y <= max2.y + 0.01) {
-        centerLine.push(grid[x][centerIdx]);
+    if (centerIdx !== -1) {
+      for (let x = 0;x < grid.length; x++) {
+        if (grid[x][centerIdx] && grid[x][centerIdx].x >= min2.x - 0.01 && grid[x][centerIdx].x <= max2.x + 0.01 && grid[x][centerIdx].y >= min2.y - 0.01 && grid[x][centerIdx].y <= max2.y + 0.01) {
+          centerLine.push(grid[x][centerIdx]);
+        }
       }
     }
   }
@@ -39111,18 +39115,27 @@ function createGrid(start, end, toVisitPoints = []) {
     middlePoint: middle
   };
 }
-function findPath(start, end, grid, obstacles, newStart, newEnd) {
-  const startIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
-  const endIdx = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
-  if (startIdx === -1 || endIdx === -1) {
-    throw new Error("Start or end point not found in the grid");
+function findPath(start, end, grid, obstacles, existingPath, newStart, newEnd) {
+  const startRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(start)));
+  if (startRowIndex === -1) {
+    throw new Error("Start point not found in the grid row");
+  }
+  const startPointIndex = grid[startRowIndex].findIndex((point5) => point5.barelyEqual(start));
+  if (startPointIndex === -1) {
+    throw new Error("Start point not found in the grid column");
+  }
+  const endRowIndex = grid.findIndex((row2) => row2.some((point5) => point5.barelyEqual(end)));
+  if (endRowIndex === -1) {
+    throw new Error("End point not found in the grid row");
+  }
+  const endPointIndex = grid[endRowIndex].findIndex((point5) => point5.barelyEqual(end));
+  if (endPointIndex === -1) {
+    throw new Error("End point not found in the grid column");
   }
-  const startPointIdx = grid[startIdx].findIndex((point5) => point5.barelyEqual(start));
-  const endPointIdx = grid[endIdx].findIndex((point5) => point5.barelyEqual(end));
   const endNode = {
     point: end,
-    xGrid: endIdx,
-    yGrid: endPointIdx,
+    xGrid: endRowIndex,
+    yGrid: endPointIndex,
     costSoFar: 0,
     heuristic: 0,
     toFinish: 0
@@ -39130,53 +39143,72 @@ function findPath(start, end, grid, obstacles, newStart, newEnd) {
   const startNode = {
     point: start,
     costSoFar: 0,
-    heuristic: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    toFinish: heuristic({ point: start, xGrid: startIdx, yGrid: startPointIdx }, endNode),
-    xGrid: startIdx,
-    yGrid: startPointIdx
+    heuristic: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    toFinish: heuristic({ point: start, xGrid: startRowIndex, yGrid: startPointIndex }, endNode),
+    xGrid: startRowIndex,
+    yGrid: startPointIndex
   };
   const openSet = [startNode];
   const closedSet = new Set;
   while (openSet.length > 0) {
     openSet.sort((aa, bb) => aa.toFinish - bb.toFinish);
     const current = openSet.shift();
+    const currentKey = `${current.point.x},${current.point.y}`;
     if (current.point.barelyEqual(end)) {
       const path2 = reconstructPath(current);
       return path2;
     }
-    closedSet.add(current.point);
+    closedSet.add(currentKey);
     const neighbors = getNeighbors(current, grid, obstacles);
     for (const neighbor of neighbors) {
-      if (closedSet.has(neighbor.point)) {
+      const neighborKey = `${neighbor.point.x},${neighbor.point.y}`;
+      if (closedSet.has(neighborKey) || existingPath.has(neighborKey) && !neighbor.point.barelyEqual(end)) {
         continue;
       }
       const extraCost = isChangingDirection(current, neighbor, newStart, newEnd);
-      const tentativeCost = current.costSoFar + 1;
-      if (!openSet.some((node2) => node2.point.barelyEqual(neighbor.point) && node2.costSoFar <= tentativeCost)) {
-        neighbor.costSoFar = tentativeCost + extraCost;
-        neighbor.heuristic = heuristic(neighbor, endNode);
-        neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
-        openSet.push(neighbor);
+      const pathOverlapCost = existingPath.has(neighborKey) ? 1000 : 0;
+      const tentativeCost = current.costSoFar + 1 + pathOverlapCost;
+      let existingNodeInOpenSet = openSet.find((node2) => node2.point.barelyEqual(neighbor.point));
+      if (!existingNodeInOpenSet || tentativeCost < existingNodeInOpenSet.costSoFar) {
+        if (existingNodeInOpenSet) {
+          existingNodeInOpenSet.costSoFar = tentativeCost + extraCost;
+          existingNodeInOpenSet.heuristic = heuristic(neighbor, endNode);
+          existingNodeInOpenSet.toFinish = existingNodeInOpenSet.costSoFar + existingNodeInOpenSet.heuristic;
+          existingNodeInOpenSet.parent = current;
+        } else {
+          neighbor.costSoFar = tentativeCost + extraCost;
+          neighbor.heuristic = heuristic(neighbor, endNode);
+          neighbor.toFinish = neighbor.costSoFar + neighbor.heuristic;
+          openSet.push(neighbor);
+        }
       }
     }
   }
   return;
 }
 function findPathPoints(points, grid, obstacles, newStart, newEnd) {
-  const pathPoints = [];
+  const finalPath = [];
+  const existingPathSegments = new Set;
+  if (points.length > 0) {
+    finalPath.push(points[0]);
+    const startKey = `${points[0].x},${points[0].y}`;
+    existingPathSegments.add(startKey);
+  }
   for (let i = 0;i < points.length - 1; i += 1) {
-    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, newStart, newEnd);
-    if (segmentPath) {
-      pathPoints.push(...segmentPath.slice(0, -1));
+    const segmentPath = findPath(points[i], points[i + 1], grid, obstacles, existingPathSegments, newStart, newEnd);
+    if (segmentPath && segmentPath.length > 0) {
+      for (let j = 1;j < segmentPath.length; j++) {
+        const point5 = segmentPath[j];
+        const key = `${point5.x},${point5.y}`;
+        finalPath.push(point5);
+        existingPathSegments.add(key);
+      }
     } else {
       points.splice(i + 1, 1);
       i--;
     }
   }
-  if (pathPoints.length !== 0) {
-    pathPoints.push(points[points.length - 1]);
-  }
-  return pathPoints;
+  return finalPath;
 }
 function reducePoints(points) {
   const uniquePoints = new Map;
@@ -39187,6 +39219,12 @@ function reducePoints(points) {
     if (uniquePoints.has(key)) {
       const loopStartIndex = uniquePoints.get(key);
       result.splice(loopStartIndex + 1);
+      const removedPoints = points.slice(loopStartIndex + 1, i + 1);
+      removedPoints.forEach((p3) => {
+        uniquePoints.delete(`${p3.x},${p3.y}`);
+      });
+      uniquePoints.set(key, result.length);
+      result.push(point5);
     } else {
       uniquePoints.set(key, result.length);
       result.push(point5);
@@ -39196,19 +39234,32 @@ function reducePoints(points) {
 }
 function getLines(pathPoints) {
   const lines = [];
+  if (pathPoints.length < 2) {
+    return [];
+  }
   const reducedPoints = reducePoints(pathPoints);
+  if (reducedPoints.length < 2) {
+    return [];
+  }
   let startPoint = reducedPoints[0];
-  for (let i = 1;i < reducedPoints.length - 1; i += 1) {
+  for (let i = 1;i < reducedPoints.length; i += 1) {
     const prevPoint = reducedPoints[i - 1];
     const currPoint = reducedPoints[i];
-    const nextPoint = reducedPoints[i + 1];
-    if (prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
+    const nextPoint = i + 1 < reducedPoints.length ? reducedPoints[i + 1] : null;
+    if (!nextPoint || prevPoint.x !== nextPoint.x && prevPoint.y !== nextPoint.y) {
       lines.push(new Line(startPoint, currPoint));
       startPoint = currPoint;
     }
   }
-  if (lines.length > 0) {
-    lines.push(new Line(startPoint, pathPoints[pathPoints.length - 1]));
+  if (lines.length === 0 && reducedPoints.length > 1) {
+    lines.push(new Line(reducedPoints[0], reducedPoints[reducedPoints.length - 1]));
+  } else if (lines.length > 0) {
+    const lastLine = lines[lines.length - 1];
+    const lastPointInLines = lastLine.getEndPoint();
+    const lastPointInReduced = reducedPoints[reducedPoints.length - 1];
+    if (!lastPointInLines.barelyEqual(lastPointInReduced)) {
+      lines.push(new Line(lastPointInLines, lastPointInReduced));
+    }
   }
   return lines;
 }