@rxflow/manhattan 0.0.2-alpha.8 → 0.0.3

package/esm/getManHattanPath.js

@@ -14,13 +14,13 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-import { getSmoothStepPath } from '@xyflow/react';
+import { getSmoothStepPath, Position } from '@xyflow/react';
 import { Point, Rectangle } from "./geometry";
 import { ObstacleMap } from "./obstacle";
 import { resolveOptions } from "./options";
 import { findRoute } from "./pathfinder";
 import { pointsToPath, parseSVGPath } from "./svg";
-import { getNodeDimensions, getNodePosition, pathIntersectsObstacles } from "./utils";
+import { getNodeDimensions, getNodePosition, pathIntersectsObstacles, ErrorRecovery } from "./utils";
 
 /**
  * Parameters for getManHattanPath function
@@ -78,10 +78,12 @@ export function getManHattanPath(params) {
   var targetNode = nodeLookup.get(targetNodeId);
   if (!sourceNode || !targetNode) {
     // Fallback to simple straight line if nodes not found
-    console.warn('Source or target node not found in nodeLookup');
+    console.warn('[getManHattanPath] Source or target node not found in nodeLookup');
     var start = new Point(sourceX, sourceY);
     var end = new Point(targetX, targetY);
-    return pointsToPath([start, end], options.precision);
+    // Use ErrorRecovery to generate a proper fallback path
+    var fallbackPath = ErrorRecovery.generateFallbackPath(start, end);
+    return pointsToPath(fallbackPath, options.precision, options.borderRadius);
   }
 
   // Get node dimensions using ReactFlow's priority logic
@@ -118,10 +120,8 @@ export function getManHattanPath(params) {
 
   // Check if smooth step path intersects with any obstacles
   if (smoothStepPoints.length > 0 && !pathIntersectsObstacles(smoothStepPoints, nodeLookup)) {
-    console.log('[getManHattanPath] Using ReactFlow getSmoothStepPath (no obstacles)');
     return smoothStepPath;
   }
-  console.log('[getManHattanPath] SmoothStepPath intersects obstacles, using Manhattan routing');
 
   // Build obstacle map with anchor information
   var obstacleMap = new ObstacleMap(options).build(nodeLookup, sourceNodeId, targetNodeId, sourceAnchor, targetAnchor);
@@ -129,27 +129,80 @@ export function getManHattanPath(params) {
   // Find route
   var route = findRoute(sourceBBox, targetBBox, sourceAnchor, targetAnchor, obstacleMap, options);
 
-  // Fallback to straight line if no route found
+  // Fallback to Z-shaped path if no route found
   if (!route) {
-    console.warn('Unable to find Manhattan route, using straight line fallback');
-    route = [sourceAnchor, targetAnchor];
+    console.warn('[getManHattanPath] Unable to find Manhattan route, using fallback path');
+    route = ErrorRecovery.generateFallbackPath(sourceAnchor, targetAnchor);
   }
-  console.log('[getManHattanPath] Route from findRoute:', route.map(function (p) {
-    return "(".concat(p.x, ", ").concat(p.y, ")");
-  }));
-  console.log('[getManHattanPath] Source anchor:', "(".concat(sourceAnchor.x, ", ").concat(sourceAnchor.y, ")"));
-  console.log('[getManHattanPath] Target anchor:', "(".concat(targetAnchor.x, ", ").concat(targetAnchor.y, ")"));
 
   // If using smart point generation (sourcePosition/targetPosition specified),
   // the route already contains the correct extension points, so skip manual processing
   var useSmartPoints = sourcePosition || targetPosition;
   if (useSmartPoints) {
-    console.log('[getManHattanPath] Using smart points, skipping manual extension point processing');
+    // Post-process route to fix X coordinates for horizontal anchors
+    // This ensures the extension distance is fixed and not affected by grid alignment
+    var isSourceHorizontal = sourcePosition === Position.Left || sourcePosition === Position.Right;
+    var isTargetHorizontal = targetPosition === Position.Left || targetPosition === Position.Right;
+    if (isSourceHorizontal && isTargetHorizontal && route.length > 0) {
+      // Calculate expected extension X coordinates
+      var sourceExtensionX = sourcePosition === Position.Right ? sourceAnchor.x + options.extensionDistance : sourceAnchor.x - options.extensionDistance;
+      var targetExtensionX = targetPosition === Position.Left ? targetAnchor.x - options.extensionDistance : targetAnchor.x + options.extensionDistance;
+
+      // Find the horizontal segment (where Y stays constant but X changes significantly)
+      // This divides the path into source-side and target-side
+      var horizontalSegmentStart = -1;
+      var horizontalSegmentEnd = -1;
+      for (var _i = 0; _i < route.length - 1; _i++) {
+        var curr = route[_i];
+        var next = route[_i + 1];
+        var isHorizontalMove = Math.abs(curr.y - next.y) < 1 && Math.abs(curr.x - next.x) > options.step;
+        if (isHorizontalMove) {
+          horizontalSegmentStart = _i;
+          horizontalSegmentEnd = _i + 1;
+          break;
+        }
+      }
+
+      // Fix route points
+      for (var _i2 = 0; _i2 < route.length; _i2++) {
+        var point = route[_i2];
+        if (horizontalSegmentStart >= 0) {
+          if (_i2 <= horizontalSegmentStart) {
+            // Source side - all vertical segment points should use sourceExtensionX
+            route[_i2] = new Point(sourceExtensionX, point.y);
+          } else if (_i2 >= horizontalSegmentEnd) {
+            // Target side - all vertical segment points should use targetExtensionX
+            route[_i2] = new Point(targetExtensionX, point.y);
+          }
+        }
+      }
+
+      // Remove redundant points (consecutive points on same line)
+      var optimized = [];
+      for (var _i3 = 0; _i3 < route.length; _i3++) {
+        var _point = route[_i3];
+        if (optimized.length < 2) {
+          optimized.push(_point);
+        } else {
+          var prev = optimized[optimized.length - 1];
+          var prevPrev = optimized[optimized.length - 2];
+
+          // Check if prev is on the same line as prevPrev and point
+          var sameX = Math.abs(prevPrev.x - prev.x) < 1 && Math.abs(prev.x - _point.x) < 1;
+          var sameY = Math.abs(prevPrev.y - prev.y) < 1 && Math.abs(prev.y - _point.y) < 1;
+          if (sameX || sameY) {
+            // prev is redundant, replace it with current point
+            optimized[optimized.length - 1] = _point;
+          } else {
+            optimized.push(_point);
+          }
+        }
+      }
+      route = optimized;
+    }
+
     // Add source and target anchors to route
     var _finalRoute = [sourceAnchor].concat(_toConsumableArray(route), [targetAnchor]);
-    console.log('[getManHattanPath] Final route:', _finalRoute.map(function (p) {
-      return "(".concat(p.x, ", ").concat(p.y, ")");
-    }));
     return pointsToPath(_finalRoute, options.precision, options.borderRadius);
   }
 
@@ -172,7 +225,6 @@ export function getManHattanPath(params) {
       // This is likely an extension point, remove it
       if (onRight && firstPoint.x > sourceAnchor.x || onLeft && firstPoint.x < sourceAnchor.x || onBottom && firstPoint.y > sourceAnchor.y || onTop && firstPoint.y < sourceAnchor.y) {
         route.shift();
-        console.log('[getManHattanPath] Removed extension point from route start');
       }
     }
   }
@@ -191,7 +243,6 @@ export function getManHattanPath(params) {
       // This is likely an extension point, remove it
       if (_onLeft && lastPoint.x < targetAnchor.x || _onRight && lastPoint.x > targetAnchor.x || _onTop && lastPoint.y < targetAnchor.y || _onBottom && lastPoint.y > targetAnchor.y) {
         route.pop();
-        console.log('[getManHattanPath] Removed extension point from route end');
       }
     }
   }
@@ -217,7 +268,6 @@ export function getManHattanPath(params) {
         route.unshift(new Point(extendX, _firstPoint.y)); // Corner point
       }
       route.unshift(extensionPoint); // Extension point (fixed distance)
-      console.log('[getManHattanPath] Inserted source extension (right):', "(".concat(extendX, ", ").concat(sourceAnchor.y, ")"));
     } else if (_onLeft2) {
       // Anchor on left edge - extend left by step + borderRadius
       var _extendX = sourceAnchor.x - extensionDistance;
@@ -226,7 +276,6 @@ export function getManHattanPath(params) {
         route.unshift(new Point(_extendX, _firstPoint.y));
       }
       route.unshift(_extensionPoint);
-      console.log('[getManHattanPath] Inserted source extension (left):', "(".concat(_extendX, ", ").concat(sourceAnchor.y, ")"));
     } else if (_onBottom2) {
       // Anchor on bottom edge - extend down by step + borderRadius
       var extendY = sourceAnchor.y + extensionDistance;
@@ -235,7 +284,6 @@ export function getManHattanPath(params) {
         route.unshift(new Point(_firstPoint.x, extendY));
       }
       route.unshift(_extensionPoint2);
-      console.log('[getManHattanPath] Inserted source extension (down):', "(".concat(sourceAnchor.x, ", ").concat(extendY, ")"));
     } else if (_onTop2) {
       // Anchor on top edge - extend up by step + borderRadius
       var _extendY = sourceAnchor.y - extensionDistance;
@@ -244,33 +292,25 @@ export function getManHattanPath(params) {
         route.unshift(new Point(_firstPoint.x, _extendY));
       }
       route.unshift(_extensionPoint3);
-      console.log('[getManHattanPath] Inserted source extension (up):', "(".concat(sourceAnchor.x, ", ").concat(_extendY, ")"));
     }
   }
 
   // Remove redundant points after source extension
   // If the first route point has the same x or y coordinate as the source anchor, it's redundant
-  if (route.length > 2) {
-    var firstRoutePoint = route[0]; // Extension point
-    var secondRoutePoint = route[1]; // Corner point (if exists)
+  if (route.length > 3) {
     var thirdRoutePoint = route[2]; // Original A* point
-
     // Check if the third point (original A* point) is redundant
     // It's redundant if it's on the same line as the corner point and can be skipped
-    var sameX = Math.abs(thirdRoutePoint.x - sourceAnchor.x) < tolerance;
-    var sameY = Math.abs(thirdRoutePoint.y - sourceAnchor.y) < tolerance;
-    if (sameX || sameY) {
-      // The third point is aligned with the source anchor, likely redundant
-      // Check if we can skip it by connecting corner point directly to the next point
-      if (route.length > 3) {
-        var fourthPoint = route[3];
-        // If corner point and fourth point form a straight line, remove the third point
-        var cornerToThird = Math.abs(secondRoutePoint.x - thirdRoutePoint.x) < tolerance || Math.abs(secondRoutePoint.y - thirdRoutePoint.y) < tolerance;
-        var thirdToFourth = Math.abs(thirdRoutePoint.x - fourthPoint.x) < tolerance || Math.abs(thirdRoutePoint.y - fourthPoint.y) < tolerance;
-        if (cornerToThird && thirdToFourth) {
-          console.log('[getManHattanPath] Removing redundant point:', "(".concat(thirdRoutePoint.x, ", ").concat(thirdRoutePoint.y, ")"));
-          route.splice(2, 1); // Remove the third point
-        }
+    var _sameX = Math.abs(thirdRoutePoint.x - sourceAnchor.x) < tolerance;
+    var _sameY = Math.abs(thirdRoutePoint.y - sourceAnchor.y) < tolerance;
+    if (_sameX || _sameY) {
+      var secondRoutePoint = route[1]; // Corner point (if exists)
+      var fourthPoint = route[3];
+      // If corner point and fourth point form a straight line, remove the third point
+      var cornerToThird = Math.abs(secondRoutePoint.x - thirdRoutePoint.x) < tolerance || Math.abs(secondRoutePoint.y - thirdRoutePoint.y) < tolerance;
+      var thirdToFourth = Math.abs(thirdRoutePoint.x - fourthPoint.x) < tolerance || Math.abs(thirdRoutePoint.y - fourthPoint.y) < tolerance;
+      if (cornerToThird && thirdToFourth) {
+        route.splice(2, 1); // Remove the third point
       }
     }
   }
@@ -280,16 +320,12 @@ export function getManHattanPath(params) {
   // where the middle segment goes to target edge and then moves along it
   // Use target bbox with padding (same as ObstacleMap)
   var targetBBoxWithPadding = targetBBox.moveAndExpand(options.paddingBox);
-  console.log('[getManHattanPath] Route before zigzag check:', route.map(function (p) {
-    return "(".concat(p.x, ", ").concat(p.y, ")");
-  }));
-  console.log('[getManHattanPath] Target BBox with padding:', "x=".concat(targetBBoxWithPadding.x, ", y=").concat(targetBBoxWithPadding.y));
   if (route.length >= 3) {
-    var _i = 0;
-    while (_i < route.length - 2) {
-      var p1 = route[_i];
-      var p2 = route[_i + 1];
-      var p3 = route[_i + 2];
+    var _i4 = 0;
+    while (_i4 < route.length - 2) {
+      var p1 = route[_i4];
+      var p2 = route[_i4 + 1];
+      var p3 = route[_i4 + 2];
 
       // Check if p2 is on the target bbox edge (with padding)
       var p2OnTargetLeftEdge = Math.abs(p2.x - targetBBoxWithPadding.x) < tolerance;
@@ -297,22 +333,19 @@ export function getManHattanPath(params) {
       var p2OnTargetTopEdge = Math.abs(p2.y - targetBBoxWithPadding.y) < tolerance;
       var p2OnTargetBottomEdge = Math.abs(p2.y - (targetBBoxWithPadding.y + targetBBoxWithPadding.height)) < tolerance;
       var p2OnTargetEdge = p2OnTargetLeftEdge || p2OnTargetRightEdge || p2OnTargetTopEdge || p2OnTargetBottomEdge;
-      console.log("[getManHattanPath] Checking i=".concat(_i, ": p2=(").concat(p2.x, ", ").concat(p2.y, "), onEdge=").concat(p2OnTargetEdge));
       if (p2OnTargetEdge) {
         // Check if p1 -> p2 -> p3 forms a zigzag
         var p1ToP2Horizontal = Math.abs(p1.y - p2.y) < tolerance;
         var p2ToP3Vertical = Math.abs(p2.x - p3.x) < tolerance;
         var p1ToP2Vertical = Math.abs(p1.x - p2.x) < tolerance;
         var p2ToP3Horizontal = Math.abs(p2.y - p3.y) < tolerance;
-        console.log("[getManHattanPath] Zigzag pattern: H->V=".concat(p1ToP2Horizontal && p2ToP3Vertical, ", V->H=").concat(p1ToP2Vertical && p2ToP3Horizontal));
         if (p1ToP2Horizontal && p2ToP3Vertical || p1ToP2Vertical && p2ToP3Horizontal) {
           // We have a zigzag at target edge, remove p2 and p3
-          console.log('[getManHattanPath] Removing zigzag at target edge:', "(".concat(p2.x, ", ").concat(p2.y, ")"), "and (".concat(p3.x, ", ").concat(p3.y, ")"));
-          route.splice(_i + 1, 2); // Remove p2 and p3
+          route.splice(_i4 + 1, 2); // Remove p2 and p3
           continue;
         }
       }
-      _i++;
+      _i4++;
     }
   }
 
@@ -336,7 +369,6 @@ export function getManHattanPath(params) {
         route.push(new Point(_extendX2, _lastPoint.y)); // Corner point
       }
       route.push(_extensionPoint4); // Extension point (fixed distance)
-      console.log('[getManHattanPath] Inserted target extension (left):', "(".concat(_extendX2, ", ").concat(targetAnchor.y, ")"));
     } else if (_onRight3) {
       // Anchor on right edge - extend right by step + borderRadius
       var _extendX3 = targetAnchor.x + _extensionDistance;
@@ -345,7 +377,6 @@ export function getManHattanPath(params) {
         route.push(new Point(_extendX3, _lastPoint.y));
       }
       route.push(_extensionPoint5);
-      console.log('[getManHattanPath] Inserted target extension (right):', "(".concat(_extendX3, ", ").concat(targetAnchor.y, ")"));
     } else if (_onTop3) {
       // Anchor on top edge - extend up by step + borderRadius
       var _extendY2 = targetAnchor.y - _extensionDistance;
@@ -354,7 +385,6 @@ export function getManHattanPath(params) {
         route.push(new Point(_lastPoint.x, _extendY2));
       }
       route.push(_extensionPoint6);
-      console.log('[getManHattanPath] Inserted target extension (up):', "(".concat(targetAnchor.x, ", ").concat(_extendY2, ")"));
     } else if (_onBottom3) {
       // Anchor on bottom edge - extend down by step + borderRadius
       var _extendY3 = targetAnchor.y + _extensionDistance;
@@ -363,7 +393,6 @@ export function getManHattanPath(params) {
         route.push(new Point(_lastPoint.x, _extendY3));
       }
       route.push(_extensionPoint7);
-      console.log('[getManHattanPath] Inserted target extension (down):', "(".concat(targetAnchor.x, ", ").concat(_extendY3, ")"));
     }
   }
 
@@ -371,20 +400,18 @@ export function getManHattanPath(params) {
   // Similar logic for target side
   if (route.length > 2) {
     var lastIdx = route.length - 1;
-    var lastRoutePoint = route[lastIdx]; // Extension point
     var secondLastPoint = route[lastIdx - 1]; // Corner point (if exists)
     var thirdLastPoint = route[lastIdx - 2]; // Original A* point
 
     // Check if the third-to-last point is redundant
-    var _sameX = Math.abs(thirdLastPoint.x - targetAnchor.x) < tolerance;
-    var _sameY = Math.abs(thirdLastPoint.y - targetAnchor.y) < tolerance;
-    if (_sameX || _sameY) {
+    var _sameX2 = Math.abs(thirdLastPoint.x - targetAnchor.x) < tolerance;
+    var _sameY2 = Math.abs(thirdLastPoint.y - targetAnchor.y) < tolerance;
+    if (_sameX2 || _sameY2) {
       if (route.length > 3) {
         var fourthLastPoint = route[lastIdx - 3];
         var fourthToThird = Math.abs(fourthLastPoint.x - thirdLastPoint.x) < tolerance || Math.abs(fourthLastPoint.y - thirdLastPoint.y) < tolerance;
         var thirdToSecond = Math.abs(thirdLastPoint.x - secondLastPoint.x) < tolerance || Math.abs(thirdLastPoint.y - secondLastPoint.y) < tolerance;
         if (fourthToThird && thirdToSecond) {
-          console.log('[getManHattanPath] Removing redundant point:', "(".concat(thirdLastPoint.x, ", ").concat(thirdLastPoint.y, ")"));
           route.splice(lastIdx - 2, 1); // Remove the third-to-last point
         }
       }
@@ -417,7 +444,6 @@ export function getManHattanPath(params) {
         var p3ToP4Horizontal = Math.abs(_p3.y - p4.y) < tolerance;
         if (p3ToP4Horizontal) {
           // Pattern: horizontal -> vertical -> horizontal (zigzag)
-          console.log('[getManHattanPath] Removing zigzag at target edge:', "(".concat(_p2.x, ", ").concat(_p2.y, ")"), "and (".concat(_p3.x, ", ").concat(_p3.y, ")"));
           route.splice(i + 1, 2); // Remove p2 and p3
           continue;
         }
@@ -428,9 +454,6 @@ export function getManHattanPath(params) {
 
   // Add source and target anchors to route
   var finalRoute = [sourceAnchor].concat(_toConsumableArray(route), [targetAnchor]);
-  console.log('[getManHattanPath] Final route:', finalRoute.map(function (p) {
-    return "(".concat(p.x, ", ").concat(p.y, ")");
-  }));
 
   // Convert to SVG path string
   return pointsToPath(finalRoute, options.precision, options.borderRadius);

package/esm/obstacle/ObstacleMap.d.ts

@@ -2,29 +2,61 @@ import { Point } from '../geometry';
 import type { ResolvedOptions, NodeLookup } from '../options';
 /**
  * ObstacleMap class for managing obstacles in pathfinding
- * Uses a grid-based spatial partitioning for efficient queries
+ * Feature: manhattan-optimization
+ *
+ * Uses QuadTree for efficient spatial queries (O(log n) instead of O(n))
+ * Includes query caching for repeated accessibility checks
  */
 export declare class ObstacleMap {
     private options;
-    private mapGridSize;
-    private map;
+    private quadTree;
+    private obstacles;
     private sourceAnchor?;
     private targetAnchor?;
+    private accessibilityCache;
+    private cacheHits;
+    private cacheMisses;
     constructor(options: ResolvedOptions);
     /**
-     * Build obstacle map from node lookup
+     * Get cache statistics for performance monitoring
      */
-    build(nodeLookup: NodeLookup, sourceNodeId: string, targetNodeId: string, sourceAnchor?: Point, targetAnchor?: Point): ObstacleMap;
+    getCacheStats(): {
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+    /**
+     * Clear the accessibility cache
+     */
+    clearCache(): void;
     /**
-     * Shrink bbox to exclude the area around the anchor point
-     * This allows paths to start/end at the anchor but prevents crossing the node
+     * Build obstacle map from node lookup using QuadTree
      */
-    private shrinkBBoxAroundAnchor;
+    build(nodeLookup: NodeLookup, sourceNodeId: string, targetNodeId: string, sourceAnchor?: Point, targetAnchor?: Point): ObstacleMap;
     /**
      * Check if a point is accessible (not inside any obstacle)
-     * Uses binary search optimization: step -> step/2 -> step/4 -> ... -> 1px
+     * Uses QuadTree for efficient spatial queries with caching
      */
     isAccessible(point: Point, checkRadius?: number): boolean;
+    /**
+     * Check if an anchor point has sufficient clearance around it
+     * This ensures the path can start/end at the anchor without being blocked
+     */
+    hasAnchorClearance(anchor: Point, direction: 'top' | 'right' | 'bottom' | 'left'): boolean;
+    /**
+     * Check accessibility without using cache (for internal use)
+     */
+    private isAccessibleWithoutCache;
+    /**
+     * Find the nearest accessible point from an anchor in a given direction
+     * Uses binary search for efficiency
+     */
+    findNearestAccessiblePoint(anchor: Point, direction: 'top' | 'right' | 'bottom' | 'left', maxDistance: number): Point | null;
+    /**
+     * Batch check accessibility for multiple points (optimized)
+     * Returns array of booleans in same order as input points
+     */
+    areAccessible(points: Point[]): boolean[];
     /**
      * Check accessibility using binary search optimization
      * Tries step -> step/2 -> step/4 -> ... -> 1px

package/esm/obstacle/ObstacleMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ObstacleMap.d.ts","sourceRoot":"","sources":["../../src/obstacle/ObstacleMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAG7D;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,GAAG,CAA0B;IACrC,OAAO,CAAC,YAAY,CAAC,CAAO;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAO;gBAEhB,OAAO,EAAE,eAAe;IAMpC;;OAEG;IACH,KAAK,CACH,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,YAAY,CAAC,EAAE,KAAK,EACpB,YAAY,CAAC,EAAE,KAAK,GACnB,WAAW;IAiEd;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA6D9B;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,MAAU,GAAG,OAAO;IAiD5D;;;OAGG;IACH,OAAO,CAAC,4BAA4B;CAqCrC"}
+{"version":3,"file":"ObstacleMap.d.ts","sourceRoot":"","sources":["../../src/obstacle/ObstacleMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAa,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAI7D;;;;;;GAMG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,SAAS,CAAmD;IACpE,OAAO,CAAC,YAAY,CAAC,CAAO;IAC5B,OAAO,CAAC,YAAY,CAAC,CAAO;IAG5B,OAAO,CAAC,kBAAkB,CAAkC;IAC5D,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,WAAW,CAAY;gBAEnB,OAAO,EAAE,eAAe;IAIpC;;OAEG;IACH,aAAa,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IASlE;;OAEG;IACH,UAAU,IAAI,IAAI;IAMlB;;OAEG;IACH,KAAK,CACH,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,YAAY,CAAC,EAAE,KAAK,EACpB,YAAY,CAAC,EAAE,KAAK,GACnB,WAAW;IA8Cd;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,MAAU,GAAG,OAAO;IAoD5D;;;OAGG;IACH,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO;IA0C1F;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAShC;;;OAGG;IACH,0BAA0B,CACxB,MAAM,EAAE,KAAK,EACb,SAAS,EAAE,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,EAC9C,WAAW,EAAE,MAAM,GAClB,KAAK,GAAG,IAAI;IAyDf;;;OAGG;IACH,aAAa,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE;IAIzC;;;OAGG;IACH,OAAO,CAAC,4BAA4B;CAqCrC"}