@esengine/pathfinding 13.2.0 → 13.3.1

package/dist/chunk-VNC2YAAL.js

@@ -1,1650 +0,0 @@
-import {
-  EMPTY_PROGRESS,
-  PathfindingState
-} from "./chunk-YKA3PWU3.js";
-import {
-  __name,
-  __publicField
-} from "./chunk-T626JPC7.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-VNC2YAAL.js.map