@esengine/pathfinding 12.0.0 → 12.1.2

package/dist/chunk-TPT7Q3E3.js

@@ -0,0 +1,1648 @@
+import {
+  EMPTY_PROGRESS,
+  PathfindingState,
+  __name,
+  __publicField
+} from "./chunk-GTFFYRZM.js";
+
+// src/core/IPathfinding.ts
+function createPoint(x, y) {
+  return {
+    x,
+    y
+  };
+}
+__name(createPoint, "createPoint");
+var EMPTY_PATH_RESULT = {
+  found: false,
+  path: [],
+  cost: 0,
+  nodesSearched: 0
+};
+function manhattanDistance(a, b) {
+  return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+}
+__name(manhattanDistance, "manhattanDistance");
+function euclideanDistance(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+__name(euclideanDistance, "euclideanDistance");
+function chebyshevDistance(a, b) {
+  return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y));
+}
+__name(chebyshevDistance, "chebyshevDistance");
+function octileDistance(a, b) {
+  const dx = Math.abs(a.x - b.x);
+  const dy = Math.abs(a.y - b.y);
+  const D = 1;
+  const D2 = Math.SQRT2;
+  return D * (dx + dy) + (D2 - 2 * D) * Math.min(dx, dy);
+}
+__name(octileDistance, "octileDistance");
+var DEFAULT_PATHFINDING_OPTIONS = {
+  maxNodes: 1e4,
+  heuristicWeight: 1,
+  allowDiagonal: true,
+  avoidCorners: true
+};
+
+// src/core/IndexedBinaryHeap.ts
+var _IndexedBinaryHeap = class _IndexedBinaryHeap {
+  /**
+   * @zh 创建带索引追踪的二叉堆
+   * @en Create indexed binary heap
+   *
+   * @param compare - @zh 比较函数，返回负数表示 a < b @en Compare function, returns negative if a < b
+   */
+  constructor(compare) {
+    __publicField(this, "heap", []);
+    __publicField(this, "compare");
+    this.compare = compare;
+  }
+  /**
+   * @zh 堆大小
+   * @en Heap size
+   */
+  get size() {
+    return this.heap.length;
+  }
+  /**
+   * @zh 是否为空
+   * @en Is empty
+   */
+  get isEmpty() {
+    return this.heap.length === 0;
+  }
+  /**
+   * @zh 插入元素
+   * @en Push element
+   */
+  push(item) {
+    item.heapIndex = this.heap.length;
+    this.heap.push(item);
+    this.bubbleUp(this.heap.length - 1);
+  }
+  /**
+   * @zh 弹出最小元素
+   * @en Pop minimum element
+   */
+  pop() {
+    if (this.heap.length === 0) {
+      return void 0;
+    }
+    const result = this.heap[0];
+    result.heapIndex = -1;
+    const last = this.heap.pop();
+    if (this.heap.length > 0) {
+      last.heapIndex = 0;
+      this.heap[0] = last;
+      this.sinkDown(0);
+    }
+    return result;
+  }
+  /**
+   * @zh 查看最小元素（不移除）
+   * @en Peek minimum element (without removing)
+   */
+  peek() {
+    return this.heap[0];
+  }
+  /**
+   * @zh 更新元素
+   * @en Update element
+   */
+  update(item) {
+    const index = item.heapIndex;
+    if (index >= 0 && index < this.heap.length && this.heap[index] === item) {
+      this.bubbleUp(index);
+      this.sinkDown(item.heapIndex);
+    }
+  }
+  /**
+   * @zh 检查是否包含元素
+   * @en Check if contains element
+   */
+  contains(item) {
+    const index = item.heapIndex;
+    return index >= 0 && index < this.heap.length && this.heap[index] === item;
+  }
+  /**
+   * @zh 从堆中移除指定元素
+   * @en Remove specific element from heap
+   */
+  remove(item) {
+    const index = item.heapIndex;
+    if (index < 0 || index >= this.heap.length || this.heap[index] !== item) {
+      return false;
+    }
+    item.heapIndex = -1;
+    if (index === this.heap.length - 1) {
+      this.heap.pop();
+      return true;
+    }
+    const last = this.heap.pop();
+    last.heapIndex = index;
+    this.heap[index] = last;
+    this.bubbleUp(index);
+    this.sinkDown(last.heapIndex);
+    return true;
+  }
+  /**
+   * @zh 清空堆
+   * @en Clear heap
+   */
+  clear() {
+    for (const item of this.heap) {
+      item.heapIndex = -1;
+    }
+    this.heap.length = 0;
+  }
+  /**
+   * @zh 上浮操作
+   * @en Bubble up operation
+   */
+  bubbleUp(index) {
+    const item = this.heap[index];
+    while (index > 0) {
+      const parentIndex = index - 1 >> 1;
+      const parent = this.heap[parentIndex];
+      if (this.compare(item, parent) >= 0) {
+        break;
+      }
+      parent.heapIndex = index;
+      this.heap[index] = parent;
+      index = parentIndex;
+    }
+    item.heapIndex = index;
+    this.heap[index] = item;
+  }
+  /**
+   * @zh 下沉操作
+   * @en Sink down operation
+   */
+  sinkDown(index) {
+    const length = this.heap.length;
+    const item = this.heap[index];
+    const halfLength = length >> 1;
+    while (index < halfLength) {
+      const leftIndex = (index << 1) + 1;
+      const rightIndex = leftIndex + 1;
+      let smallest = index;
+      let smallestItem = item;
+      const left = this.heap[leftIndex];
+      if (this.compare(left, smallestItem) < 0) {
+        smallest = leftIndex;
+        smallestItem = left;
+      }
+      if (rightIndex < length) {
+        const right = this.heap[rightIndex];
+        if (this.compare(right, smallestItem) < 0) {
+          smallest = rightIndex;
+          smallestItem = right;
+        }
+      }
+      if (smallest === index) {
+        break;
+      }
+      smallestItem.heapIndex = index;
+      this.heap[index] = smallestItem;
+      index = smallest;
+    }
+    item.heapIndex = index;
+    this.heap[index] = item;
+  }
+};
+__name(_IndexedBinaryHeap, "IndexedBinaryHeap");
+var IndexedBinaryHeap = _IndexedBinaryHeap;
+
+// src/core/PathCache.ts
+var DEFAULT_PATH_CACHE_CONFIG = {
+  maxEntries: 1e3,
+  ttlMs: 5e3,
+  enableApproximateMatch: false,
+  approximateRange: 2
+};
+var _PathCache = class _PathCache {
+  constructor(config = {}) {
+    __publicField(this, "config");
+    __publicField(this, "cache");
+    __publicField(this, "accessOrder");
+    this.config = {
+      ...DEFAULT_PATH_CACHE_CONFIG,
+      ...config
+    };
+    this.cache = /* @__PURE__ */ new Map();
+    this.accessOrder = [];
+  }
+  /**
+   * @zh 获取缓存的路径
+   * @en Get cached path
+   *
+   * @param startX - @zh 起点 X 坐标 @en Start X coordinate
+   * @param startY - @zh 起点 Y 坐标 @en Start Y coordinate
+   * @param endX - @zh 终点 X 坐标 @en End X coordinate
+   * @param endY - @zh 终点 Y 坐标 @en End Y coordinate
+   * @param mapVersion - @zh 地图版本号 @en Map version number
+   * @returns @zh 缓存的路径结果或 null @en Cached path result or null
+   */
+  get(startX, startY, endX, endY, mapVersion) {
+    const key = this.generateKey(startX, startY, endX, endY);
+    const entry = this.cache.get(key);
+    if (!entry) {
+      if (this.config.enableApproximateMatch) {
+        return this.getApproximate(startX, startY, endX, endY, mapVersion);
+      }
+      return null;
+    }
+    if (!this.isValid(entry, mapVersion)) {
+      this.cache.delete(key);
+      this.removeFromAccessOrder(key);
+      return null;
+    }
+    this.updateAccessOrder(key);
+    return entry.result;
+  }
+  /**
+   * @zh 设置缓存路径
+   * @en Set cached path
+   *
+   * @param startX - @zh 起点 X 坐标 @en Start X coordinate
+   * @param startY - @zh 起点 Y 坐标 @en Start Y coordinate
+   * @param endX - @zh 终点 X 坐标 @en End X coordinate
+   * @param endY - @zh 终点 Y 坐标 @en End Y coordinate
+   * @param result - @zh 路径结果 @en Path result
+   * @param mapVersion - @zh 地图版本号 @en Map version number
+   */
+  set(startX, startY, endX, endY, result, mapVersion) {
+    if (this.cache.size >= this.config.maxEntries) {
+      this.evictLRU();
+    }
+    const key = this.generateKey(startX, startY, endX, endY);
+    const entry = {
+      result,
+      timestamp: Date.now(),
+      mapVersion
+    };
+    this.cache.set(key, entry);
+    this.updateAccessOrder(key);
+  }
+  /**
+   * @zh 使所有缓存失效
+   * @en Invalidate all cache
+   */
+  invalidateAll() {
+    this.cache.clear();
+    this.accessOrder.length = 0;
+  }
+  /**
+   * @zh 使指定区域的缓存失效
+   * @en Invalidate cache for specified region
+   *
+   * @param minX - @zh 最小 X 坐标 @en Minimum X coordinate
+   * @param minY - @zh 最小 Y 坐标 @en Minimum Y coordinate
+   * @param maxX - @zh 最大 X 坐标 @en Maximum X coordinate
+   * @param maxY - @zh 最大 Y 坐标 @en Maximum Y coordinate
+   */
+  invalidateRegion(minX, minY, maxX, maxY) {
+    const keysToDelete = [];
+    for (const [key, entry] of this.cache) {
+      const path = entry.result.path;
+      if (path.length === 0) continue;
+      for (const point of path) {
+        if (point.x >= minX && point.x <= maxX && point.y >= minY && point.y <= maxY) {
+          keysToDelete.push(key);
+          break;
+        }
+      }
+    }
+    for (const key of keysToDelete) {
+      this.cache.delete(key);
+      this.removeFromAccessOrder(key);
+    }
+  }
+  /**
+   * @zh 获取缓存统计信息
+   * @en Get cache statistics
+   */
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.config.maxEntries
+    };
+  }
+  /**
+   * @zh 清理过期条目
+   * @en Clean up expired entries
+   */
+  cleanup() {
+    if (this.config.ttlMs === 0) return;
+    const now = Date.now();
+    const keysToDelete = [];
+    for (const [key, entry] of this.cache) {
+      if (now - entry.timestamp > this.config.ttlMs) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      this.cache.delete(key);
+      this.removeFromAccessOrder(key);
+    }
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  generateKey(startX, startY, endX, endY) {
+    return `${startX},${startY}->${endX},${endY}`;
+  }
+  isValid(entry, mapVersion) {
+    if (entry.mapVersion !== mapVersion) {
+      return false;
+    }
+    if (this.config.ttlMs > 0) {
+      const age = Date.now() - entry.timestamp;
+      if (age > this.config.ttlMs) {
+        return false;
+      }
+    }
+    return true;
+  }
+  getApproximate(startX, startY, endX, endY, mapVersion) {
+    const range = this.config.approximateRange;
+    for (let sx = startX - range; sx <= startX + range; sx++) {
+      for (let sy = startY - range; sy <= startY + range; sy++) {
+        for (let ex = endX - range; ex <= endX + range; ex++) {
+          for (let ey = endY - range; ey <= endY + range; ey++) {
+            const key = this.generateKey(sx, sy, ex, ey);
+            const entry = this.cache.get(key);
+            if (entry && this.isValid(entry, mapVersion)) {
+              this.updateAccessOrder(key);
+              return this.adjustPathForApproximate(entry.result, startX, startY, endX, endY);
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  adjustPathForApproximate(result, newStartX, newStartY, newEndX, newEndY) {
+    if (result.path.length === 0) {
+      return result;
+    }
+    const newPath = [];
+    const oldStart = result.path[0];
+    const oldEnd = result.path[result.path.length - 1];
+    if (newStartX !== oldStart.x || newStartY !== oldStart.y) {
+      newPath.push({
+        x: newStartX,
+        y: newStartY
+      });
+    }
+    newPath.push(...result.path);
+    if (newEndX !== oldEnd.x || newEndY !== oldEnd.y) {
+      newPath.push({
+        x: newEndX,
+        y: newEndY
+      });
+    }
+    return {
+      ...result,
+      path: newPath
+    };
+  }
+  updateAccessOrder(key) {
+    this.removeFromAccessOrder(key);
+    this.accessOrder.push(key);
+  }
+  removeFromAccessOrder(key) {
+    const index = this.accessOrder.indexOf(key);
+    if (index !== -1) {
+      this.accessOrder.splice(index, 1);
+    }
+  }
+  evictLRU() {
+    const lruKey = this.accessOrder.shift();
+    if (lruKey) {
+      this.cache.delete(lruKey);
+    }
+  }
+};
+__name(_PathCache, "PathCache");
+var PathCache = _PathCache;
+function createPathCache(config) {
+  return new PathCache(config);
+}
+__name(createPathCache, "createPathCache");
+
+// src/core/IncrementalAStarPathfinder.ts
+var _IncrementalAStarPathfinder = class _IncrementalAStarPathfinder {
+  /**
+   * @zh 创建增量 A* 寻路器
+   * @en Create incremental A* pathfinder
+   *
+   * @param map - @zh 寻路地图实例 @en Pathfinding map instance
+   * @param config - @zh 配置选项 @en Configuration options
+   */
+  constructor(map, config) {
+    __publicField(this, "map");
+    __publicField(this, "sessions", /* @__PURE__ */ new Map());
+    __publicField(this, "nextRequestId", 0);
+    __publicField(this, "affectedRegions", []);
+    __publicField(this, "maxRegionAge", 5e3);
+    __publicField(this, "cache");
+    __publicField(this, "enableCache");
+    __publicField(this, "mapVersion", 0);
+    __publicField(this, "cacheHits", 0);
+    __publicField(this, "cacheMisses", 0);
+    this.map = map;
+    this.enableCache = config?.enableCache ?? false;
+    this.cache = this.enableCache ? new PathCache(config?.cacheConfig) : null;
+  }
+  /**
+   * @zh 请求寻路（非阻塞）
+   * @en Request pathfinding (non-blocking)
+   */
+  requestPath(startX, startY, endX, endY, options) {
+    const id = this.nextRequestId++;
+    const priority = options?.priority ?? 50;
+    const opts = {
+      ...DEFAULT_PATHFINDING_OPTIONS,
+      ...options
+    };
+    const request = {
+      id,
+      startX,
+      startY,
+      endX,
+      endY,
+      options: opts,
+      priority,
+      createdAt: Date.now()
+    };
+    if (this.cache) {
+      const cached = this.cache.get(startX, startY, endX, endY, this.mapVersion);
+      if (cached) {
+        this.cacheHits++;
+        const session2 = {
+          request,
+          state: cached.found ? PathfindingState.Completed : PathfindingState.Failed,
+          options: opts,
+          openList: new IndexedBinaryHeap((a, b) => a.f - b.f),
+          nodeCache: /* @__PURE__ */ new Map(),
+          startNode: this.map.getNodeAt(startX, startY),
+          endNode: this.map.getNodeAt(endX, endY),
+          endPosition: {
+            x: endX,
+            y: endY
+          },
+          nodesSearched: cached.nodesSearched,
+          framesUsed: 0,
+          initialDistance: 0,
+          result: {
+            requestId: id,
+            found: cached.found,
+            path: [
+              ...cached.path
+            ],
+            cost: cached.cost,
+            nodesSearched: cached.nodesSearched,
+            framesUsed: 0,
+            isPartial: false
+          },
+          affectedByChange: false
+        };
+        this.sessions.set(id, session2);
+        return request;
+      }
+      this.cacheMisses++;
+    }
+    const startNode = this.map.getNodeAt(startX, startY);
+    const endNode = this.map.getNodeAt(endX, endY);
+    if (!startNode || !endNode || !startNode.walkable || !endNode.walkable) {
+      const session2 = {
+        request,
+        state: PathfindingState.Failed,
+        options: opts,
+        openList: new IndexedBinaryHeap((a, b) => a.f - b.f),
+        nodeCache: /* @__PURE__ */ new Map(),
+        startNode,
+        endNode,
+        endPosition: endNode?.position ?? {
+          x: endX,
+          y: endY
+        },
+        nodesSearched: 0,
+        framesUsed: 0,
+        initialDistance: 0,
+        result: this.createEmptyResult(id),
+        affectedByChange: false
+      };
+      this.sessions.set(id, session2);
+      return request;
+    }
+    if (startNode.id === endNode.id) {
+      const session2 = {
+        request,
+        state: PathfindingState.Completed,
+        options: opts,
+        openList: new IndexedBinaryHeap((a, b) => a.f - b.f),
+        nodeCache: /* @__PURE__ */ new Map(),
+        startNode,
+        endNode,
+        endPosition: endNode.position,
+        nodesSearched: 1,
+        framesUsed: 0,
+        initialDistance: 0,
+        result: {
+          requestId: id,
+          found: true,
+          path: [
+            startNode.position
+          ],
+          cost: 0,
+          nodesSearched: 1,
+          framesUsed: 0,
+          isPartial: false
+        },
+        affectedByChange: false
+      };
+      this.sessions.set(id, session2);
+      return request;
+    }
+    const initialDistance = this.map.heuristic(startNode.position, endNode.position);
+    const openList = new IndexedBinaryHeap((a, b) => a.f - b.f);
+    const nodeCache = /* @__PURE__ */ new Map();
+    const startAStarNode = {
+      node: startNode,
+      g: 0,
+      h: initialDistance * opts.heuristicWeight,
+      f: initialDistance * opts.heuristicWeight,
+      parent: null,
+      closed: false,
+      opened: true,
+      heapIndex: -1
+    };
+    nodeCache.set(startNode.id, startAStarNode);
+    openList.push(startAStarNode);
+    const session = {
+      request,
+      state: PathfindingState.InProgress,
+      options: opts,
+      openList,
+      nodeCache,
+      startNode,
+      endNode,
+      endPosition: endNode.position,
+      nodesSearched: 0,
+      framesUsed: 0,
+      initialDistance,
+      result: null,
+      affectedByChange: false
+    };
+    this.sessions.set(id, session);
+    return request;
+  }
+  /**
+   * @zh 执行一步搜索
+   * @en Execute one step of search
+   */
+  step(requestId, maxIterations) {
+    const session = this.sessions.get(requestId);
+    if (!session) {
+      return EMPTY_PROGRESS;
+    }
+    if (session.state !== PathfindingState.InProgress) {
+      return this.createProgress(session);
+    }
+    session.framesUsed++;
+    let iterations = 0;
+    while (!session.openList.isEmpty && iterations < maxIterations) {
+      const current = session.openList.pop();
+      current.closed = true;
+      session.nodesSearched++;
+      iterations++;
+      if (current.node.id === session.endNode.id) {
+        session.state = PathfindingState.Completed;
+        session.result = this.buildResult(session, current);
+        if (this.cache && session.result.found) {
+          const req = session.request;
+          this.cache.set(req.startX, req.startY, req.endX, req.endY, {
+            found: true,
+            path: session.result.path,
+            cost: session.result.cost,
+            nodesSearched: session.result.nodesSearched
+          }, this.mapVersion);
+        }
+        return this.createProgress(session);
+      }
+      this.expandNeighbors(session, current);
+      if (session.nodesSearched >= session.options.maxNodes) {
+        session.state = PathfindingState.Failed;
+        session.result = this.createEmptyResult(requestId);
+        return this.createProgress(session);
+      }
+    }
+    if (session.openList.isEmpty && session.state === PathfindingState.InProgress) {
+      session.state = PathfindingState.Failed;
+      session.result = this.createEmptyResult(requestId);
+    }
+    return this.createProgress(session);
+  }
+  /**
+   * @zh 暂停寻路
+   * @en Pause pathfinding
+   */
+  pause(requestId) {
+    const session = this.sessions.get(requestId);
+    if (session && session.state === PathfindingState.InProgress) {
+      session.state = PathfindingState.Paused;
+    }
+  }
+  /**
+   * @zh 恢复寻路
+   * @en Resume pathfinding
+   */
+  resume(requestId) {
+    const session = this.sessions.get(requestId);
+    if (session && session.state === PathfindingState.Paused) {
+      session.state = PathfindingState.InProgress;
+    }
+  }
+  /**
+   * @zh 取消寻路
+   * @en Cancel pathfinding
+   */
+  cancel(requestId) {
+    const session = this.sessions.get(requestId);
+    if (session && (session.state === PathfindingState.InProgress || session.state === PathfindingState.Paused)) {
+      session.state = PathfindingState.Cancelled;
+      session.result = this.createEmptyResult(requestId);
+    }
+  }
+  /**
+   * @zh 获取寻路结果
+   * @en Get pathfinding result
+   */
+  getResult(requestId) {
+    const session = this.sessions.get(requestId);
+    return session?.result ?? null;
+  }
+  /**
+   * @zh 获取当前进度
+   * @en Get current progress
+   */
+  getProgress(requestId) {
+    const session = this.sessions.get(requestId);
+    return session ? this.createProgress(session) : null;
+  }
+  /**
+   * @zh 清理已完成的请求
+   * @en Clean up completed request
+   */
+  cleanup(requestId) {
+    const session = this.sessions.get(requestId);
+    if (session) {
+      session.openList.clear();
+      session.nodeCache.clear();
+      this.sessions.delete(requestId);
+    }
+  }
+  /**
+   * @zh 通知障碍物变化
+   * @en Notify obstacle change
+   */
+  notifyObstacleChange(minX, minY, maxX, maxY) {
+    this.mapVersion++;
+    if (this.cache) {
+      this.cache.invalidateRegion(minX, minY, maxX, maxY);
+    }
+    const region = {
+      minX,
+      minY,
+      maxX,
+      maxY,
+      timestamp: Date.now()
+    };
+    this.affectedRegions.push(region);
+    for (const session of this.sessions.values()) {
+      if (session.state === PathfindingState.InProgress || session.state === PathfindingState.Paused) {
+        if (this.sessionAffectedByRegion(session, region)) {
+          session.affectedByChange = true;
+        }
+      }
+    }
+    this.cleanupOldRegions();
+  }
+  /**
+   * @zh 清理所有请求
+   * @en Clear all requests
+   */
+  clear() {
+    for (const session of this.sessions.values()) {
+      session.openList.clear();
+      session.nodeCache.clear();
+    }
+    this.sessions.clear();
+    this.affectedRegions.length = 0;
+  }
+  /**
+   * @zh 清空路径缓存
+   * @en Clear path cache
+   */
+  clearCache() {
+    if (this.cache) {
+      this.cache.invalidateAll();
+      this.cacheHits = 0;
+      this.cacheMisses = 0;
+    }
+  }
+  /**
+   * @zh 获取缓存统计信息
+   * @en Get cache statistics
+   */
+  getCacheStats() {
+    if (!this.cache) {
+      return {
+        enabled: false,
+        hits: 0,
+        misses: 0,
+        hitRate: 0,
+        size: 0
+      };
+    }
+    const total = this.cacheHits + this.cacheMisses;
+    const hitRate = total > 0 ? this.cacheHits / total : 0;
+    return {
+      enabled: true,
+      hits: this.cacheHits,
+      misses: this.cacheMisses,
+      hitRate,
+      size: this.cache.getStats().size
+    };
+  }
+  /**
+   * @zh 检查会话是否被障碍物变化影响
+   * @en Check if session is affected by obstacle change
+   */
+  isAffectedByChange(requestId) {
+    const session = this.sessions.get(requestId);
+    return session?.affectedByChange ?? false;
+  }
+  /**
+   * @zh 清除会话的变化标记
+   * @en Clear session's change flag
+   */
+  clearChangeFlag(requestId) {
+    const session = this.sessions.get(requestId);
+    if (session) {
+      session.affectedByChange = false;
+    }
+  }
+  // =========================================================================
+  // 私有方法 | Private Methods
+  // =========================================================================
+  /**
+   * @zh 展开邻居节点
+   * @en Expand neighbor nodes
+   */
+  expandNeighbors(session, current) {
+    const neighbors = this.map.getNeighbors(current.node);
+    for (const neighborNode of neighbors) {
+      if (!neighborNode.walkable) {
+        continue;
+      }
+      let neighbor = session.nodeCache.get(neighborNode.id);
+      if (!neighbor) {
+        neighbor = {
+          node: neighborNode,
+          g: Infinity,
+          h: 0,
+          f: Infinity,
+          parent: null,
+          closed: false,
+          opened: false,
+          heapIndex: -1
+        };
+        session.nodeCache.set(neighborNode.id, neighbor);
+      }
+      if (neighbor.closed) {
+        continue;
+      }
+      const movementCost = this.map.getMovementCost(current.node, neighborNode);
+      const tentativeG = current.g + movementCost;
+      if (!neighbor.opened) {
+        neighbor.g = tentativeG;
+        neighbor.h = this.map.heuristic(neighborNode.position, session.endPosition) * session.options.heuristicWeight;
+        neighbor.f = neighbor.g + neighbor.h;
+        neighbor.parent = current;
+        neighbor.opened = true;
+        session.openList.push(neighbor);
+      } else if (tentativeG < neighbor.g) {
+        neighbor.g = tentativeG;
+        neighbor.f = neighbor.g + neighbor.h;
+        neighbor.parent = current;
+        session.openList.update(neighbor);
+      }
+    }
+  }
+  /**
+   * @zh 创建进度对象
+   * @en Create progress object
+   */
+  createProgress(session) {
+    let estimatedProgress = 0;
+    if (session.state === PathfindingState.Completed) {
+      estimatedProgress = 1;
+    } else if (session.state === PathfindingState.InProgress && session.initialDistance > 0) {
+      const bestNode = session.openList.peek();
+      if (bestNode) {
+        const currentDistance = bestNode.h / session.options.heuristicWeight;
+        estimatedProgress = Math.max(0, Math.min(1, 1 - currentDistance / session.initialDistance));
+      }
+    }
+    return {
+      state: session.state,
+      nodesSearched: session.nodesSearched,
+      openListSize: session.openList.size,
+      estimatedProgress
+    };
+  }
+  /**
+   * @zh 构建路径结果
+   * @en Build path result
+   */
+  buildResult(session, endNode) {
+    const path = [];
+    let current = endNode;
+    while (current) {
+      path.push(current.node.position);
+      current = current.parent;
+    }
+    path.reverse();
+    return {
+      requestId: session.request.id,
+      found: true,
+      path,
+      cost: endNode.g,
+      nodesSearched: session.nodesSearched,
+      framesUsed: session.framesUsed,
+      isPartial: false
+    };
+  }
+  /**
+   * @zh 创建空结果
+   * @en Create empty result
+   */
+  createEmptyResult(requestId) {
+    return {
+      requestId,
+      found: false,
+      path: [],
+      cost: 0,
+      nodesSearched: 0,
+      framesUsed: 0,
+      isPartial: false
+    };
+  }
+  /**
+   * @zh 检查会话是否被区域影响
+   * @en Check if session is affected by region
+   */
+  sessionAffectedByRegion(session, region) {
+    for (const astarNode of session.nodeCache.values()) {
+      if (astarNode.opened || astarNode.closed) {
+        const pos = astarNode.node.position;
+        if (pos.x >= region.minX && pos.x <= region.maxX && pos.y >= region.minY && pos.y <= region.maxY) {
+          return true;
+        }
+      }
+    }
+    const start = session.request;
+    const end = session.endPosition;
+    if (start.startX >= region.minX && start.startX <= region.maxX && start.startY >= region.minY && start.startY <= region.maxY || end.x >= region.minX && end.x <= region.maxX && end.y >= region.minY && end.y <= region.maxY) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * @zh 清理过期的变化区域
+   * @en Clean up expired change regions
+   */
+  cleanupOldRegions() {
+    const now = Date.now();
+    let i = 0;
+    while (i < this.affectedRegions.length) {
+      if (now - this.affectedRegions[i].timestamp > this.maxRegionAge) {
+        this.affectedRegions.splice(i, 1);
+      } else {
+        i++;
+      }
+    }
+  }
+};
+__name(_IncrementalAStarPathfinder, "IncrementalAStarPathfinder");
+var IncrementalAStarPathfinder = _IncrementalAStarPathfinder;
+function createIncrementalAStarPathfinder(map) {
+  return new IncrementalAStarPathfinder(map);
+}
+__name(createIncrementalAStarPathfinder, "createIncrementalAStarPathfinder");
+
+// src/core/PathValidator.ts
+var _PathValidator = class _PathValidator {
+  /**
+   * @zh 验证路径段的有效性
+   * @en Validate path segment validity
+   *
+   * @param path - @zh 要验证的路径 @en Path to validate
+   * @param fromIndex - @zh 起始索引 @en Start index
+   * @param toIndex - @zh 结束索引 @en End index
+   * @param map - @zh 地图实例 @en Map instance
+   * @returns @zh 验证结果 @en Validation result
+   */
+  validatePath(path, fromIndex, toIndex, map) {
+    const end = Math.min(toIndex, path.length);
+    for (let i = fromIndex; i < end; i++) {
+      const point = path[i];
+      const x = Math.floor(point.x);
+      const y = Math.floor(point.y);
+      if (!map.isWalkable(x, y)) {
+        return {
+          valid: false,
+          invalidIndex: i
+        };
+      }
+      if (i > fromIndex) {
+        const prev = path[i - 1];
+        if (!this.checkLineOfSight(prev.x, prev.y, point.x, point.y, map)) {
+          return {
+            valid: false,
+            invalidIndex: i
+          };
+        }
+      }
+    }
+    return {
+      valid: true,
+      invalidIndex: -1
+    };
+  }
+  /**
+   * @zh 检查两点之间的视线（使用 Bresenham 算法）
+   * @en Check line of sight between two points (using Bresenham algorithm)
+   *
+   * @param x1 - @zh 起点 X @en Start X
+   * @param y1 - @zh 起点 Y @en Start Y
+   * @param x2 - @zh 终点 X @en End X
+   * @param y2 - @zh 终点 Y @en End Y
+   * @param map - @zh 地图实例 @en Map instance
+   * @returns @zh 是否有视线 @en Whether there is line of sight
+   */
+  checkLineOfSight(x1, y1, x2, y2, map) {
+    const ix1 = Math.floor(x1);
+    const iy1 = Math.floor(y1);
+    const ix2 = Math.floor(x2);
+    const iy2 = Math.floor(y2);
+    let dx = Math.abs(ix2 - ix1);
+    let dy = Math.abs(iy2 - iy1);
+    let x = ix1;
+    let y = iy1;
+    const sx = ix1 < ix2 ? 1 : -1;
+    const sy = iy1 < iy2 ? 1 : -1;
+    if (dx > dy) {
+      let err = dx / 2;
+      while (x !== ix2) {
+        if (!map.isWalkable(x, y)) {
+          return false;
+        }
+        err -= dy;
+        if (err < 0) {
+          y += sy;
+          err += dx;
+        }
+        x += sx;
+      }
+    } else {
+      let err = dy / 2;
+      while (y !== iy2) {
+        if (!map.isWalkable(x, y)) {
+          return false;
+        }
+        err -= dx;
+        if (err < 0) {
+          x += sx;
+          err += dy;
+        }
+        y += sy;
+      }
+    }
+    return map.isWalkable(ix2, iy2);
+  }
+};
+__name(_PathValidator, "PathValidator");
+var PathValidator = _PathValidator;
+var _ObstacleChangeManager = class _ObstacleChangeManager {
+  constructor() {
+    __publicField(this, "changes", /* @__PURE__ */ new Map());
+    __publicField(this, "epoch", 0);
+  }
+  /**
+   * @zh 记录障碍物变化
+   * @en Record obstacle change
+   *
+   * @param x - @zh X 坐标 @en X coordinate
+   * @param y - @zh Y 坐标 @en Y coordinate
+   * @param wasWalkable - @zh 变化前是否可通行 @en Was walkable before change
+   */
+  recordChange(x, y, wasWalkable) {
+    const key = `${x},${y}`;
+    this.changes.set(key, {
+      x,
+      y,
+      wasWalkable,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * @zh 获取影响区域
+   * @en Get affected region
+   *
+   * @returns @zh 影响区域或 null（如果没有变化）@en Affected region or null if no changes
+   */
+  getAffectedRegion() {
+    if (this.changes.size === 0) {
+      return null;
+    }
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const change of this.changes.values()) {
+      minX = Math.min(minX, change.x);
+      minY = Math.min(minY, change.y);
+      maxX = Math.max(maxX, change.x);
+      maxY = Math.max(maxY, change.y);
+    }
+    return {
+      minX,
+      minY,
+      maxX,
+      maxY
+    };
+  }
+  /**
+   * @zh 获取所有变化
+   * @en Get all changes
+   *
+   * @returns @zh 变化列表 @en List of changes
+   */
+  getChanges() {
+    return Array.from(this.changes.values());
+  }
+  /**
+   * @zh 检查是否有变化
+   * @en Check if there are changes
+   *
+   * @returns @zh 是否有变化 @en Whether there are changes
+   */
+  hasChanges() {
+    return this.changes.size > 0;
+  }
+  /**
+   * @zh 获取当前 epoch
+   * @en Get current epoch
+   *
+   * @returns @zh 当前 epoch @en Current epoch
+   */
+  getEpoch() {
+    return this.epoch;
+  }
+  /**
+   * @zh 清空变化记录并推进 epoch
+   * @en Clear changes and advance epoch
+   */
+  flush() {
+    this.changes.clear();
+    this.epoch++;
+  }
+  /**
+   * @zh 清空所有状态
+   * @en Clear all state
+   */
+  clear() {
+    this.changes.clear();
+    this.epoch = 0;
+  }
+};
+__name(_ObstacleChangeManager, "ObstacleChangeManager");
+var ObstacleChangeManager = _ObstacleChangeManager;
+function createPathValidator() {
+  return new PathValidator();
+}
+__name(createPathValidator, "createPathValidator");
+function createObstacleChangeManager() {
+  return new ObstacleChangeManager();
+}
+__name(createObstacleChangeManager, "createObstacleChangeManager");
+
+// src/grid/GridMap.ts
+var _GridNode = class _GridNode {
+  constructor(x, y, width, walkable = true, cost = 1) {
+    __publicField(this, "id");
+    __publicField(this, "position");
+    __publicField(this, "x");
+    __publicField(this, "y");
+    __publicField(this, "cost");
+    __publicField(this, "walkable");
+    this.x = x;
+    this.y = y;
+    this.id = y * width + x;
+    this.position = createPoint(x, y);
+    this.walkable = walkable;
+    this.cost = cost;
+  }
+};
+__name(_GridNode, "GridNode");
+var GridNode = _GridNode;
+var DIRECTIONS_4 = [
+  {
+    dx: 0,
+    dy: -1
+  },
+  {
+    dx: 1,
+    dy: 0
+  },
+  {
+    dx: 0,
+    dy: 1
+  },
+  {
+    dx: -1,
+    dy: 0
+  }
+  // Left
+];
+var DIRECTIONS_8 = [
+  {
+    dx: 0,
+    dy: -1
+  },
+  {
+    dx: 1,
+    dy: -1
+  },
+  {
+    dx: 1,
+    dy: 0
+  },
+  {
+    dx: 1,
+    dy: 1
+  },
+  {
+    dx: 0,
+    dy: 1
+  },
+  {
+    dx: -1,
+    dy: 1
+  },
+  {
+    dx: -1,
+    dy: 0
+  },
+  {
+    dx: -1,
+    dy: -1
+  }
+  // Up-Left
+];
+var DEFAULT_GRID_OPTIONS = {
+  allowDiagonal: true,
+  diagonalCost: Math.SQRT2,
+  avoidCorners: true,
+  heuristic: octileDistance
+};
+var _GridMap = class _GridMap {
+  constructor(width, height, options) {
+    __publicField(this, "width");
+    __publicField(this, "height");
+    __publicField(this, "nodes");
+    __publicField(this, "options");
+    this.width = width;
+    this.height = height;
+    this.options = {
+      ...DEFAULT_GRID_OPTIONS,
+      ...options
+    };
+    this.nodes = this.createNodes();
+  }
+  /**
+   * @zh 创建网格节点
+   * @en Create grid nodes
+   */
+  createNodes() {
+    const nodes = [];
+    for (let y = 0; y < this.height; y++) {
+      nodes[y] = [];
+      for (let x = 0; x < this.width; x++) {
+        nodes[y][x] = new GridNode(x, y, this.width, true, 1);
+      }
+    }
+    return nodes;
+  }
+  /**
+   * @zh 获取指定位置的节点
+   * @en Get node at position
+   */
+  getNodeAt(x, y) {
+    if (!this.isInBounds(x, y)) {
+      return null;
+    }
+    return this.nodes[y][x];
+  }
+  /**
+   * @zh 检查坐标是否在边界内
+   * @en Check if coordinates are within bounds
+   */
+  isInBounds(x, y) {
+    return x >= 0 && x < this.width && y >= 0 && y < this.height;
+  }
+  /**
+   * @zh 检查位置是否可通行
+   * @en Check if position is walkable
+   */
+  isWalkable(x, y) {
+    const node = this.getNodeAt(x, y);
+    return node !== null && node.walkable;
+  }
+  /**
+   * @zh 设置位置是否可通行
+   * @en Set position walkability
+   */
+  setWalkable(x, y, walkable) {
+    const node = this.getNodeAt(x, y);
+    if (node) {
+      node.walkable = walkable;
+    }
+  }
+  /**
+   * @zh 设置位置的移动代价
+   * @en Set movement cost at position
+   */
+  setCost(x, y, cost) {
+    const node = this.getNodeAt(x, y);
+    if (node) {
+      node.cost = cost;
+    }
+  }
+  /**
+   * @zh 获取节点的邻居
+   * @en Get neighbors of a node
+   */
+  getNeighbors(node) {
+    const neighbors = [];
+    const { x, y } = node.position;
+    const directions = this.options.allowDiagonal ? DIRECTIONS_8 : DIRECTIONS_4;
+    for (let i = 0; i < directions.length; i++) {
+      const dir = directions[i];
+      const nx = x + dir.dx;
+      const ny = y + dir.dy;
+      if (nx < 0 || nx >= this.width || ny < 0 || ny >= this.height) {
+        continue;
+      }
+      const neighbor = this.nodes[ny][nx];
+      if (!neighbor.walkable) {
+        continue;
+      }
+      if (this.options.avoidCorners && dir.dx !== 0 && dir.dy !== 0) {
+        const hNode = this.nodes[y][x + dir.dx];
+        const vNode = this.nodes[y + dir.dy][x];
+        if (!hNode.walkable || !vNode.walkable) {
+          continue;
+        }
+      }
+      neighbors.push(neighbor);
+    }
+    return neighbors;
+  }
+  /**
+   * @zh 遍历节点的邻居（零分配）
+   * @en Iterate over neighbors (zero allocation)
+   */
+  forEachNeighbor(node, callback) {
+    const { x, y } = node.position;
+    const directions = this.options.allowDiagonal ? DIRECTIONS_8 : DIRECTIONS_4;
+    for (let i = 0; i < directions.length; i++) {
+      const dir = directions[i];
+      const nx = x + dir.dx;
+      const ny = y + dir.dy;
+      if (nx < 0 || nx >= this.width || ny < 0 || ny >= this.height) {
+        continue;
+      }
+      const neighbor = this.nodes[ny][nx];
+      if (!neighbor.walkable) {
+        continue;
+      }
+      if (this.options.avoidCorners && dir.dx !== 0 && dir.dy !== 0) {
+        const hNode = this.nodes[y][x + dir.dx];
+        const vNode = this.nodes[y + dir.dy][x];
+        if (!hNode.walkable || !vNode.walkable) {
+          continue;
+        }
+      }
+      if (callback(neighbor) === false) {
+        return;
+      }
+    }
+  }
+  /**
+   * @zh 计算启发式距离
+   * @en Calculate heuristic distance
+   */
+  heuristic(a, b) {
+    return this.options.heuristic(a, b);
+  }
+  /**
+   * @zh 计算移动代价
+   * @en Calculate movement cost
+   */
+  getMovementCost(from, to) {
+    const dx = Math.abs(from.position.x - to.position.x);
+    const dy = Math.abs(from.position.y - to.position.y);
+    if (dx !== 0 && dy !== 0) {
+      return to.cost * this.options.diagonalCost;
+    }
+    return to.cost;
+  }
+  /**
+   * @zh 从二维数组加载地图
+   * @en Load map from 2D array
+   *
+   * @param data - @zh 0=可通行，非0=不可通行 @en 0=walkable, non-0=blocked
+   */
+  loadFromArray(data) {
+    for (let y = 0; y < Math.min(data.length, this.height); y++) {
+      for (let x = 0; x < Math.min(data[y].length, this.width); x++) {
+        this.nodes[y][x].walkable = data[y][x] === 0;
+      }
+    }
+  }
+  /**
+   * @zh 从字符串加载地图
+   * @en Load map from string
+   *
+   * @param str - @zh 地图字符串，'.'=可通行，'#'=障碍 @en Map string, '.'=walkable, '#'=blocked
+   */
+  loadFromString(str) {
+    const lines = str.trim().split("\n");
+    for (let y = 0; y < Math.min(lines.length, this.height); y++) {
+      const line = lines[y];
+      for (let x = 0; x < Math.min(line.length, this.width); x++) {
+        this.nodes[y][x].walkable = line[x] !== "#";
+      }
+    }
+  }
+  /**
+   * @zh 导出为字符串
+   * @en Export to string
+   */
+  toString() {
+    let result = "";
+    for (let y = 0; y < this.height; y++) {
+      for (let x = 0; x < this.width; x++) {
+        result += this.nodes[y][x].walkable ? "." : "#";
+      }
+      result += "\n";
+    }
+    return result;
+  }
+  /**
+   * @zh 重置所有节点为可通行
+   * @en Reset all nodes to walkable
+   */
+  reset() {
+    for (let y = 0; y < this.height; y++) {
+      for (let x = 0; x < this.width; x++) {
+        this.nodes[y][x].walkable = true;
+        this.nodes[y][x].cost = 1;
+      }
+    }
+  }
+  /**
+   * @zh 设置矩形区域的通行性
+   * @en Set walkability for a rectangle region
+   */
+  setRectWalkable(x, y, width, height, walkable) {
+    for (let dy = 0; dy < height; dy++) {
+      for (let dx = 0; dx < width; dx++) {
+        this.setWalkable(x + dx, y + dy, walkable);
+      }
+    }
+  }
+};
+__name(_GridMap, "GridMap");
+var GridMap = _GridMap;
+function createGridMap(width, height, options) {
+  return new GridMap(width, height, options);
+}
+__name(createGridMap, "createGridMap");
+
+// src/smoothing/PathSmoother.ts
+function bresenhamLineOfSight(x1, y1, x2, y2, map) {
+  let ix1 = Math.floor(x1);
+  let iy1 = Math.floor(y1);
+  const ix2 = Math.floor(x2);
+  const iy2 = Math.floor(y2);
+  const dx = Math.abs(ix2 - ix1);
+  const dy = Math.abs(iy2 - iy1);
+  const sx = ix1 < ix2 ? 1 : -1;
+  const sy = iy1 < iy2 ? 1 : -1;
+  let err = dx - dy;
+  while (true) {
+    if (!map.isWalkable(ix1, iy1)) {
+      return false;
+    }
+    if (ix1 === ix2 && iy1 === iy2) {
+      break;
+    }
+    const e2 = 2 * err;
+    if (e2 > -dy) {
+      err -= dy;
+      ix1 += sx;
+    }
+    if (e2 < dx) {
+      err += dx;
+      iy1 += sy;
+    }
+  }
+  return true;
+}
+__name(bresenhamLineOfSight, "bresenhamLineOfSight");
+function raycastLineOfSight(x1, y1, x2, y2, map, stepSize = 0.5) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const distance = Math.sqrt(dx * dx + dy * dy);
+  if (distance === 0) {
+    return map.isWalkable(Math.floor(x1), Math.floor(y1));
+  }
+  const steps = Math.ceil(distance / stepSize);
+  const stepX = dx / steps;
+  const stepY = dy / steps;
+  let x = x1;
+  let y = y1;
+  for (let i = 0; i <= steps; i++) {
+    if (!map.isWalkable(Math.floor(x), Math.floor(y))) {
+      return false;
+    }
+    x += stepX;
+    y += stepY;
+  }
+  return true;
+}
+__name(raycastLineOfSight, "raycastLineOfSight");
+var _LineOfSightSmoother = class _LineOfSightSmoother {
+  constructor(lineOfSight = bresenhamLineOfSight) {
+    __publicField(this, "lineOfSight");
+    this.lineOfSight = lineOfSight;
+  }
+  smooth(path, map) {
+    if (path.length <= 2) {
+      return [
+        ...path
+      ];
+    }
+    const result = [
+      path[0]
+    ];
+    let current = 0;
+    while (current < path.length - 1) {
+      let furthest = current + 1;
+      for (let i = path.length - 1; i > current + 1; i--) {
+        if (this.lineOfSight(path[current].x, path[current].y, path[i].x, path[i].y, map)) {
+          furthest = i;
+          break;
+        }
+      }
+      result.push(path[furthest]);
+      current = furthest;
+    }
+    return result;
+  }
+};
+__name(_LineOfSightSmoother, "LineOfSightSmoother");
+var LineOfSightSmoother = _LineOfSightSmoother;
+var _CatmullRomSmoother = class _CatmullRomSmoother {
+  /**
+   * @param segments - @zh 每段之间的插值点数 @en Number of interpolation points per segment
+   * @param tension - @zh 张力 (0-1) @en Tension (0-1)
+   */
+  constructor(segments = 5, tension = 0.5) {
+    __publicField(this, "segments");
+    __publicField(this, "tension");
+    this.segments = segments;
+    this.tension = tension;
+  }
+  smooth(path, _map) {
+    if (path.length <= 2) {
+      return [
+        ...path
+      ];
+    }
+    const result = [];
+    const points = [
+      path[0],
+      ...path,
+      path[path.length - 1]
+    ];
+    for (let i = 1; i < points.length - 2; i++) {
+      const p0 = points[i - 1];
+      const p1 = points[i];
+      const p2 = points[i + 1];
+      const p3 = points[i + 2];
+      for (let j = 0; j < this.segments; j++) {
+        const t = j / this.segments;
+        const point = this.interpolate(p0, p1, p2, p3, t);
+        result.push(point);
+      }
+    }
+    result.push(path[path.length - 1]);
+    return result;
+  }
+  /**
+   * @zh Catmull-Rom 插值
+   * @en Catmull-Rom interpolation
+   */
+  interpolate(p0, p1, p2, p3, t) {
+    const t2 = t * t;
+    const t3 = t2 * t;
+    const tension = this.tension;
+    const x = 0.5 * (2 * p1.x + (-p0.x + p2.x) * t * tension + (2 * p0.x - 5 * p1.x + 4 * p2.x - p3.x) * t2 * tension + (-p0.x + 3 * p1.x - 3 * p2.x + p3.x) * t3 * tension);
+    const y = 0.5 * (2 * p1.y + (-p0.y + p2.y) * t * tension + (2 * p0.y - 5 * p1.y + 4 * p2.y - p3.y) * t2 * tension + (-p0.y + 3 * p1.y - 3 * p2.y + p3.y) * t3 * tension);
+    return createPoint(x, y);
+  }
+};
+__name(_CatmullRomSmoother, "CatmullRomSmoother");
+var CatmullRomSmoother = _CatmullRomSmoother;
+var _CombinedSmoother = class _CombinedSmoother {
+  constructor(curveSegments = 5, tension = 0.5) {
+    __publicField(this, "simplifier");
+    __publicField(this, "curveSmoother");
+    this.simplifier = new LineOfSightSmoother();
+    this.curveSmoother = new CatmullRomSmoother(curveSegments, tension);
+  }
+  smooth(path, map) {
+    const simplified = this.simplifier.smooth(path, map);
+    return this.curveSmoother.smooth(simplified, map);
+  }
+};
+__name(_CombinedSmoother, "CombinedSmoother");
+var CombinedSmoother = _CombinedSmoother;
+function createLineOfSightSmoother(lineOfSight) {
+  return new LineOfSightSmoother(lineOfSight);
+}
+__name(createLineOfSightSmoother, "createLineOfSightSmoother");
+function createCatmullRomSmoother(segments, tension) {
+  return new CatmullRomSmoother(segments, tension);
+}
+__name(createCatmullRomSmoother, "createCatmullRomSmoother");
+function createCombinedSmoother(curveSegments, tension) {
+  return new CombinedSmoother(curveSegments, tension);
+}
+__name(createCombinedSmoother, "createCombinedSmoother");
+
+export {
+  createPoint,
+  EMPTY_PATH_RESULT,
+  manhattanDistance,
+  euclideanDistance,
+  chebyshevDistance,
+  octileDistance,
+  DEFAULT_PATHFINDING_OPTIONS,
+  IndexedBinaryHeap,
+  DEFAULT_PATH_CACHE_CONFIG,
+  PathCache,
+  createPathCache,
+  IncrementalAStarPathfinder,
+  createIncrementalAStarPathfinder,
+  PathValidator,
+  ObstacleChangeManager,
+  createPathValidator,
+  createObstacleChangeManager,
+  GridNode,
+  DIRECTIONS_4,
+  DIRECTIONS_8,
+  DEFAULT_GRID_OPTIONS,
+  GridMap,
+  createGridMap,
+  bresenhamLineOfSight,
+  raycastLineOfSight,
+  LineOfSightSmoother,
+  CatmullRomSmoother,
+  CombinedSmoother,
+  createLineOfSightSmoother,
+  createCatmullRomSmoother,
+  createCombinedSmoother
+};
+//# sourceMappingURL=chunk-TPT7Q3E3.js.map