@rxflow/manhattan 0.0.1-alpha.11 → 0.0.1-alpha.13

package/cjs/pathfinder/findRoute.js

@@ -4,8 +4,162 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.findRoute = findRoute;
+var _geometry = require("../geometry");
 var _SortedSet = require("./SortedSet");
 var _utils = require("../utils");
+/**
+ * Find the closest accessible point in a given direction using step-based search with linear refinement
+ *
+ * Algorithm:
+ * 1. Try moving by step increments (step, 2*step, 3*step...) until finding an accessible point
+ * 2. Once found, linearly search backward from (n-1)*step+1 to n*step to find the closest accessible point
+ * 3. Returns null if no accessible point found within maxSteps
+ */
+function findAccessibleNeighbor(from, directionX, directionY, step, map, precision, maxSteps = 20) {
+  // Normalize direction
+  const length = Math.sqrt(directionX * directionX + directionY * directionY);
+  const ndx = directionX / length;
+  const ndy = directionY / length;
+
+  // 1. Try the first step directly (most common case)
+  const firstStepPoint = new _geometry.Point(from.x + ndx * step, from.y + ndy * step).round(precision);
+  if (map.isAccessible(firstStepPoint)) {
+    // First step is accessible, no need for refinement
+    return firstStepPoint;
+  }
+
+  // 2. First step blocked, search outward by step increments
+  let stepMultiplier = 2;
+  let foundAccessibleDistance = -1;
+  while (stepMultiplier <= maxSteps) {
+    const distance = stepMultiplier * step;
+    const testPoint = new _geometry.Point(from.x + ndx * distance, from.y + ndy * distance).round(precision);
+    if (map.isAccessible(testPoint)) {
+      foundAccessibleDistance = distance;
+      break;
+    }
+    stepMultiplier++;
+  }
+  if (foundAccessibleDistance < 0) {
+    return null; // No accessible point found
+  }
+
+  // 3. Linear search within the last step interval to find closest accessible point
+  // Search from (n-1)*step+1 to n*step
+  const outerDistance = foundAccessibleDistance;
+  const innerDistance = foundAccessibleDistance - step;
+
+  // Search backward from outer to inner to find the closest accessible point
+  for (let dist = innerDistance + 1; dist < outerDistance; dist++) {
+    const testPoint = new _geometry.Point(from.x + ndx * dist, from.y + ndy * dist).round(precision);
+    if (map.isAccessible(testPoint)) {
+      return testPoint;
+    }
+  }
+
+  // If no closer point found, return the outer distance point
+  return new _geometry.Point(from.x + ndx * outerDistance, from.y + ndy * outerDistance).round(precision);
+}
+
+/**
+ * Generate smart points based on position using extensionDistance and binary search
+ *
+ * Algorithm:
+ * 1. First try extensionDistance in the specified direction
+ * 2. If blocked, use binary search starting from step, halving until finding accessible point
+ * 3. For target points, approach from opposite direction
+ */
+function generateSmartPoints(anchor, bbox, position, grid, map, options, isTarget = false) {
+  const directionMap = {
+    'right': {
+      x: 1,
+      y: 0
+    },
+    'left': {
+      x: -1,
+      y: 0
+    },
+    'top': {
+      x: 0,
+      y: -1
+    },
+    'bottom': {
+      x: 0,
+      y: 1
+    }
+  };
+  const direction = directionMap[position];
+  if (!direction) {
+    console.warn(`[generateSmartPoints] Unknown position: ${position}, falling back to anchor`);
+    return [anchor];
+  }
+
+  // Both source and target extend in the specified direction
+  // - Source: extends away from node in sourcePosition direction
+  // - Target: extends away from node in targetPosition direction (path approaches from this direction)
+  const actualDirection = direction;
+  const points = [];
+
+  // 1. First try extensionDistance
+  const extensionPoint = new _geometry.Point(anchor.x + actualDirection.x * options.extensionDistance, anchor.y + actualDirection.y * options.extensionDistance).round(options.precision);
+  console.log(`[generateSmartPoints] ${isTarget ? 'Target' : 'Source'} position=${position}, trying extension point: (${extensionPoint.x}, ${extensionPoint.y})`);
+  if (map.isAccessible(extensionPoint)) {
+    points.push(extensionPoint);
+    console.log(`[generateSmartPoints] Extension point is accessible`);
+    return points;
+  }
+  console.log(`[generateSmartPoints] Extension point blocked, using step-based search`);
+
+  // 2. Step-based search with binary refinement
+  // First, extend outward by step increments until we find an accessible point
+  let stepMultiplier = 1;
+  let maxSteps = 20; // Prevent infinite loop
+  let foundAccessibleDistance = -1;
+  console.log(`[generateSmartPoints] Starting outward search with step=${options.step}`);
+  while (stepMultiplier <= maxSteps) {
+    const distance = stepMultiplier * options.step;
+    const testPoint = new _geometry.Point(anchor.x + actualDirection.x * distance, anchor.y + actualDirection.y * distance).round(options.precision);
+    console.log(`[generateSmartPoints] Testing ${stepMultiplier}*step (distance=${distance}): (${testPoint.x}, ${testPoint.y})`);
+    if (map.isAccessible(testPoint)) {
+      foundAccessibleDistance = distance;
+      console.log(`[generateSmartPoints] Found accessible point at ${stepMultiplier}*step (distance=${distance})`);
+      break;
+    }
+    stepMultiplier++;
+  }
+
+  // 3. If we found an accessible point, refine by linear search within the last step interval
+  if (foundAccessibleDistance > 0) {
+    const outerDistance = foundAccessibleDistance;
+    const innerDistance = foundAccessibleDistance - options.step;
+    console.log(`[generateSmartPoints] Refining between ${innerDistance} and ${outerDistance}`);
+
+    // Linear search from innerDistance+1 to outerDistance to find the closest accessible point
+    let bestDistance = outerDistance;
+
+    // Search forward from inner to outer to find the first accessible point
+    for (let dist = innerDistance + 1; dist < outerDistance; dist++) {
+      const testPoint = new _geometry.Point(anchor.x + actualDirection.x * dist, anchor.y + actualDirection.y * dist).round(options.precision);
+      console.log(`[generateSmartPoints] Linear search testing distance ${dist}: (${testPoint.x}, ${testPoint.y})`);
+      if (map.isAccessible(testPoint)) {
+        bestDistance = dist;
+        console.log(`[generateSmartPoints] Found closest accessible point at distance ${dist}`);
+        break;
+      }
+    }
+
+    // Use the best distance found
+    const finalPoint = new _geometry.Point(anchor.x + actualDirection.x * bestDistance, anchor.y + actualDirection.y * bestDistance).round(options.precision);
+    points.push(finalPoint);
+    console.log(`[generateSmartPoints] Final point at distance ${bestDistance}: (${finalPoint.x}, ${finalPoint.y})`);
+  } else {
+    // 4. If no accessible point found after maxSteps, use anchor as fallback
+    console.log(`[generateSmartPoints] No accessible point found after ${maxSteps} steps, using anchor: (${anchor.x}, ${anchor.y})`);
+    points.push(anchor);
+  }
+  return points;
+}
+
 /**
  * Find route between two points using A* algorithm
  */
@@ -24,24 +178,41 @@ function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, map, opti
   const endPoint = targetEndpoint;
 
   // Get start and end points around rectangles
-  let startPoints = (0, _utils.getRectPoints)(startPoint, sourceBBox, options.startDirections, grid, options);
-  let endPoints = (0, _utils.getRectPoints)(targetEndpoint, targetBBox, options.endDirections, grid, options);
-  console.log('[findRoute] Start points from getRectPoints:', startPoints.map(p => `(${p.x}, ${p.y})`));
-  console.log('[findRoute] End points from getRectPoints:', endPoints.map(p => `(${p.x}, ${p.y})`));
-
-  // Take into account only accessible rect points
-  startPoints = startPoints.filter(p => map.isAccessible(p));
-  endPoints = endPoints.filter(p => map.isAccessible(p));
+  // Use smart point generation based on position if available
+  let startPoints;
+  let endPoints;
+
+  // Generate smart start points based on sourcePosition
+  if (options.sourcePosition) {
+    startPoints = generateSmartPoints(startPoint, sourceBBox, options.sourcePosition, grid, map, options, false);
+    console.log('[findRoute] Start points from smart generation:', startPoints.map(p => `(${p.x}, ${p.y})`));
+  } else {
+    startPoints = (0, _utils.getRectPoints)(startPoint, sourceBBox, options.startDirections, grid, options);
+    console.log('[findRoute] Start points from getRectPoints:', startPoints.map(p => `(${p.x}, ${p.y})`));
+    // Take into account only accessible rect points
+    startPoints = startPoints.filter(p => map.isAccessible(p));
+  }
+
+  // Generate smart end points based on targetPosition
+  if (options.targetPosition) {
+    endPoints = generateSmartPoints(targetEndpoint, targetBBox, options.targetPosition, grid, map, options, true);
+    console.log('[findRoute] End points from smart generation:', endPoints.map(p => `(${p.x}, ${p.y})`));
+  } else {
+    endPoints = (0, _utils.getRectPoints)(targetEndpoint, targetBBox, options.endDirections, grid, options);
+    console.log('[findRoute] End points from getRectPoints:', endPoints.map(p => `(${p.x}, ${p.y})`));
+    // Take into account only accessible rect points
+    endPoints = endPoints.filter(p => map.isAccessible(p));
+  }
   console.log('[findRoute] Start points after filter:', startPoints.map(p => `(${p.x}, ${p.y})`));
   console.log('[findRoute] End points after filter:', endPoints.map(p => `(${p.x}, ${p.y})`));
 
   // Ensure we always have at least the anchor points
   // This handles edge cases where anchor is on the node boundary
   if (startPoints.length === 0) {
-    startPoints = [(0, _utils.align)(startPoint, grid, precision)];
+    startPoints = [(0, _utils.round)(startPoint, precision)];
   }
   if (endPoints.length === 0) {
-    endPoints = [(0, _utils.align)(endPoint, grid, precision)];
+    endPoints = [(0, _utils.round)(endPoint, precision)];
   }
 
   // Initialize A* data structures
@@ -111,16 +282,69 @@ function findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, map, opti
         continue;
       }
 
-      // Calculate neighbor point
-      const neighborPoint = (0, _utils.align)(currentPoint.clone().translate(direction.gridOffsetX || 0, direction.gridOffsetY || 0), grid, precision);
+      // Find the closest accessible neighbor in this direction using binary search
+      const neighborPoint = findAccessibleNeighbor(currentPoint, direction.offsetX, direction.offsetY, options.step, map, precision);
+
+      // Skip if no accessible neighbor found in this direction
+      if (!neighborPoint) {
+        continue;
+      }
       const neighborKey = (0, _utils.getKey)(neighborPoint);
 
-      // Skip if closed or not accessible
-      if (openSet.isClose(neighborKey) || !map.isAccessible(neighborPoint)) {
+      // Skip if already closed
+      if (openSet.isClose(neighborKey)) {
         continue;
       }
 
-      // Check if neighbor is an end point
+      // Check if we can reach any end point directly from this neighbor
+      // This allows connecting to end points that are not on the grid
+      let canReachEndPoint = false;
+      let reachableEndPoint = null;
+      for (const endPt of endPoints) {
+        const distanceToEnd = neighborPoint.manhattanDistance(endPt);
+
+        // If close enough to end point (within step distance), try direct connection
+        if (distanceToEnd < options.step * 1.5) {
+          // Check if we can move directly to the end point
+          const dx = endPt.x - neighborPoint.x;
+          const dy = endPt.y - neighborPoint.y;
+
+          // Allow direct connection if it's orthogonal or close to orthogonal
+          const isOrthogonal = Math.abs(dx) < 0.1 || Math.abs(dy) < 0.1;
+          if (isOrthogonal && map.isAccessible(endPt)) {
+            canReachEndPoint = true;
+            reachableEndPoint = endPt;
+            break;
+          }
+        }
+      }
+
+      // If we can reach an end point directly, add it as the final step
+      if (canReachEndPoint && reachableEndPoint) {
+        const endKey = (0, _utils.getKey)(reachableEndPoint);
+        const endCost = neighborPoint.manhattanDistance(reachableEndPoint);
+        const totalCost = currentCost + direction.cost + endCost;
+        if (!openSet.isOpen(endKey) || totalCost < (costs.get(endKey) || Infinity)) {
+          points.set(endKey, reachableEndPoint);
+          parents.set(endKey, neighborPoint);
+          costs.set(endKey, totalCost);
+
+          // Also add the neighbor point if not already added
+          if (!points.has(neighborKey)) {
+            points.set(neighborKey, neighborPoint);
+            parents.set(neighborKey, currentPoint);
+            costs.set(neighborKey, currentCost + direction.cost);
+          }
+
+          // Check if this is our target end point
+          if (endPointsKeys.has(endKey)) {
+            options.previousDirectionAngle = directionAngle;
+            return (0, _utils.reconstructRoute)(parents, points, reachableEndPoint, startPoint, endPoint);
+          }
+        }
+      }
+
+      // Check if neighbor is an end point (exact match)
       if (endPointsKeys.has(neighborKey)) {
         const isEndPoint = neighborPoint.equals(endPoint);
         if (!isEndPoint) {

package/cjs/svg/pathConverter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pathConverter.d.ts","sourceRoot":"","sources":["../../src/svg/pathConverter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM,CAgEjG;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,EAAE,CAgCzE"}
+{"version":3,"file":"pathConverter.d.ts","sourceRoot":"","sources":["../../src/svg/pathConverter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAEnC;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM,CA2EjG;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,KAAK,EAAE,CAgCzE"}

package/cjs/svg/pathConverter.js

@@ -36,31 +36,42 @@ function pointsToPath(points, precision, borderRadius = 0) {
     const current = points[i];
     const next = points[i + 1];
 
-    // Calculate the distance from prev to current and current to next
-    const distToPrev = Math.sqrt(Math.pow(current.x - prev.x, 2) + Math.pow(current.y - prev.y, 2));
-    const distToNext = Math.sqrt(Math.pow(next.x - current.x, 2) + Math.pow(next.y - current.y, 2));
+    // Calculate direction vectors
+    const dx1 = current.x - prev.x;
+    const dy1 = current.y - prev.y;
+    const dx2 = next.x - current.x;
+    const dy2 = next.y - current.y;
+
+    // Calculate distances
+    const dist1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+    const dist2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);
 
     // Use the smaller of borderRadius or half the segment length
-    const radius = Math.min(borderRadius, distToPrev / 2, distToNext / 2);
+    const radius = Math.min(borderRadius, dist1 / 2, dist2 / 2);
+
+    // Normalize direction vectors
+    const ndx1 = dx1 / dist1;
+    const ndy1 = dy1 / dist1;
+    const ndx2 = dx2 / dist2;
+    const ndy2 = dy2 / dist2;
 
-    // Calculate the point before the corner (on the line from prev to current)
-    const beforeCornerRatio = (distToPrev - radius) / distToPrev;
+    // Calculate the point before the corner
     const beforeCorner = {
-      x: prev.x + (current.x - prev.x) * beforeCornerRatio,
-      y: prev.y + (current.y - prev.y) * beforeCornerRatio
+      x: current.x - ndx1 * radius,
+      y: current.y - ndy1 * radius
     };
 
-    // Calculate the point after the corner (on the line from current to next)
-    const afterCornerRatio = radius / distToNext;
+    // Calculate the point after the corner
     const afterCorner = {
-      x: current.x + (next.x - current.x) * afterCornerRatio,
-      y: current.y + (next.y - current.y) * afterCornerRatio
+      x: current.x + ndx2 * radius,
+      y: current.y + ndy2 * radius
     };
 
     // Draw line to the point before corner
     path += ` L ${roundCoord(beforeCorner.x)} ${roundCoord(beforeCorner.y)}`;
 
     // Draw quadratic bezier curve for the rounded corner
+    // The control point is the actual corner point
     path += ` Q ${roundCoord(current.x)} ${roundCoord(current.y)} ${roundCoord(afterCorner.x)} ${roundCoord(afterCorner.y)}`;
   }
 

package/cjs/utils/getAnchorPoints.d.ts

@@ -0,0 +1,15 @@
+import { Point } from '../geometry';
+import type { ObstacleMap } from '../obstacle';
+import type { Direction } from '../options';
+/**
+ * Get accessible anchor points using binary search optimization
+ *
+ * @param anchor - The anchor point (on node edge)
+ * @param position - The position/direction (right, left, top, bottom)
+ * @param extensionDistance - The preferred extension distance
+ * @param step - The step size for binary search
+ * @param obstacleMap - The obstacle map for accessibility checking
+ * @returns Array of accessible points, prioritized by distance
+ */
+export declare function getAnchorPoints(anchor: Point, position: Direction, extensionDistance: number, step: number, obstacleMap: ObstacleMap): Point[];
+//# sourceMappingURL=getAnchorPoints.d.ts.map

package/cjs/utils/getAnchorPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAnchorPoints.d.ts","sourceRoot":"","sources":["../../src/utils/getAnchorPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3C;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,KAAK,EACb,QAAQ,EAAE,SAAS,EACnB,iBAAiB,EAAE,MAAM,EACzB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,WAAW,GACvB,KAAK,EAAE,CA0DT"}

package/cjs/utils/getAnchorPoints.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAnchorPoints = getAnchorPoints;
+var _geometry = require("../geometry");
+/**
+ * Get accessible anchor points using binary search optimization
+ *
+ * @param anchor - The anchor point (on node edge)
+ * @param position - The position/direction (right, left, top, bottom)
+ * @param extensionDistance - The preferred extension distance
+ * @param step - The step size for binary search
+ * @param obstacleMap - The obstacle map for accessibility checking
+ * @returns Array of accessible points, prioritized by distance
+ */
+function getAnchorPoints(anchor, position, extensionDistance, step, obstacleMap) {
+  const points = [];
+
+  // Determine direction vector based on position
+  const directionMap = {
+    'right': {
+      dx: 1,
+      dy: 0
+    },
+    'left': {
+      dx: -1,
+      dy: 0
+    },
+    'top': {
+      dx: 0,
+      dy: -1
+    },
+    'bottom': {
+      dx: 0,
+      dy: 1
+    }
+  };
+  const dir = directionMap[position];
+  if (!dir) {
+    console.warn(`[getAnchorPoints] Invalid position: ${position}`);
+    return [anchor];
+  }
+  console.log(`[getAnchorPoints] Finding points for position '${position}' from (${anchor.x}, ${anchor.y})`);
+
+  // 1. First try extensionDistance
+  const extensionPoint = new _geometry.Point(anchor.x + dir.dx * extensionDistance, anchor.y + dir.dy * extensionDistance);
+  if (obstacleMap.isAccessible(extensionPoint)) {
+    console.log(`[getAnchorPoints] Extension point (${extensionPoint.x}, ${extensionPoint.y}) is accessible`);
+    points.push(extensionPoint);
+    return points;
+  }
+  console.log(`[getAnchorPoints] Extension point (${extensionPoint.x}, ${extensionPoint.y}) is blocked, trying binary search`);
+
+  // 2. If extensionDistance point is blocked, use binary search with step
+  // Try: step -> step/2 -> step/4 -> ... -> 1px
+  let distance = step;
+  while (distance >= 1) {
+    const testPoint = new _geometry.Point(anchor.x + dir.dx * distance, anchor.y + dir.dy * distance);
+    if (obstacleMap.isAccessible(testPoint)) {
+      console.log(`[getAnchorPoints] Found accessible point at distance ${distance}px: (${testPoint.x}, ${testPoint.y})`);
+      points.push(testPoint);
+      return points;
+    }
+
+    // Halve the distance for next iteration
+    distance = Math.floor(distance / 2);
+  }
+
+  // 3. If still no accessible point found, return the anchor itself
+  console.warn(`[getAnchorPoints] No accessible point found, using anchor itself: (${anchor.x}, ${anchor.y})`);
+  points.push(anchor);
+  return points;
+}

package/cjs/utils/index.d.ts

@@ -4,4 +4,5 @@ export * from './rect';
 export * from './route';
 export * from './node';
 export * from './pathValidation';
+export * from './getAnchorPoints';
 //# sourceMappingURL=index.d.ts.map

package/cjs/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,QAAQ,CAAA;AACtB,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA"}

package/cjs/utils/index.js

@@ -68,4 +68,15 @@ Object.keys(_pathValidation).forEach(function (key) {
       return _pathValidation[key];
     }
   });
+});
+var _getAnchorPoints = require("./getAnchorPoints");
+Object.keys(_getAnchorPoints).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getAnchorPoints[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _getAnchorPoints[key];
+    }
+  });
 });

package/esm/geometry/Rectangle.d.ts

@@ -25,7 +25,7 @@ export declare class Rectangle {
      */
     getCorner(): Point;
     /**
-     * Check if a point is contained within this rectangle
+     * Check if a point is contained within this rectangle (interior only, excluding edges)
      */
     containsPoint(point: Point): boolean;
     /**

package/esm/geometry/Rectangle.js

@@ -60,12 +60,12 @@ export var Rectangle = /*#__PURE__*/function () {
     }
 
     /**
-     * Check if a point is contained within this rectangle
+     * Check if a point is contained within this rectangle (interior only, excluding edges)
      */
   }, {
     key: "containsPoint",
     value: function containsPoint(point) {
-      return point.x >= this.x && point.x <= this.x + this.width && point.y >= this.y && point.y <= this.y + this.height;
+      return point.x > this.x && point.x < this.x + this.width && point.y > this.y && point.y < this.y + this.height;
     }
 
     /**

package/esm/getManHattanPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,QAAQ,EAAE,MAAM,eAAe,CAAA;AAG3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAMnE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAA;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAwRvE"}
+{"version":3,"file":"getManHattanPath.d.ts","sourceRoot":"","sources":["../src/getManHattanPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,QAAQ,EAAE,MAAM,eAAe,CAAA;AAG3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAa,MAAM,WAAW,CAAA;AAM9E;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAEhB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAA;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAgbvE"}