@flare-engine/pathfinding 0.2.1 → 0.3.1

package/dist/index.js

@@ -1,696 +1,711 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  chebyshevDistance: () => chebyshevDistance,
-  createGrid: () => createGrid,
-  createNavMesh: () => createNavMesh,
-  euclideanDistance: () => euclideanDistance,
-  findNavMeshPath: () => findNavMeshPath,
-  findPath: () => findPath,
-  findPathJPS: () => findPathJPS,
-  findPolygonAt: () => findPolygonAt,
-  getCost: () => getCost,
-  inBounds: () => inBounds,
-  isWalkable: () => isWalkable,
-  manhattanDistance: () => manhattanDistance,
-  octileDistance: () => octileDistance,
-  setCost: () => setCost,
-  setWalkable: () => setWalkable
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/grid.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/grid.ts
 function createGrid(config) {
-  const { width, height, defaultCost = 1 } = config;
-  if (width <= 0 || height <= 0) {
-    throw new RangeError("Grid dimensions must be positive");
-  }
-  const w = width | 0;
-  const h = height | 0;
-  let data;
-  if (config.data) {
-    if (config.data.length !== w * h) {
-      throw new RangeError(`Grid data length ${config.data.length} does not match ${w}x${h}`);
-    }
-    data = config.data;
-  } else {
-    data = new Uint8Array(w * h);
-    if (defaultCost > 0) {
-      data.fill(defaultCost);
-    }
-  }
-  return { width: w, height: h, data };
+	const { width, height, defaultCost = 1 } = config;
+	if (width <= 0 || height <= 0) throw new RangeError("Grid dimensions must be positive");
+	const w = width | 0;
+	const h = height | 0;
+	let data;
+	if (config.data) {
+		if (config.data.length !== w * h) throw new RangeError(`Grid data length ${config.data.length} does not match ${w}x${h}`);
+		data = config.data;
+	} else {
+		data = new Uint8Array(w * h);
+		if (defaultCost > 0) data.fill(defaultCost);
+	}
+	return {
+		width: w,
+		height: h,
+		data
+	};
 }
 function inBounds(grid, x, y) {
-  return x >= 0 && y >= 0 && x < grid.width && y < grid.height;
+	return x >= 0 && y >= 0 && x < grid.width && y < grid.height;
 }
 function isWalkable(grid, x, y) {
-  if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return false;
-  return grid.data[(y | 0) * grid.width + (x | 0)] > 0;
+	if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return false;
+	return grid.data[(y | 0) * grid.width + (x | 0)] > 0;
 }
 function getCost(grid, x, y) {
-  if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return 0;
-  return grid.data[(y | 0) * grid.width + (x | 0)];
+	if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return 0;
+	return grid.data[(y | 0) * grid.width + (x | 0)];
 }
 function setWalkable(grid, x, y, walkable) {
-  if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return;
-  grid.data[(y | 0) * grid.width + (x | 0)] = walkable ? 1 : 0;
+	if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return;
+	grid.data[(y | 0) * grid.width + (x | 0)] = walkable ? 1 : 0;
 }
 function setCost(grid, x, y, cost) {
-  if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return;
-  grid.data[(y | 0) * grid.width + (x | 0)] = cost > 255 ? 255 : cost < 0 ? 0 : cost | 0;
+	if (x < 0 || y < 0 || x >= grid.width || y >= grid.height) return;
+	grid.data[(y | 0) * grid.width + (x | 0)] = cost > 255 ? 255 : cost < 0 ? 0 : cost | 0;
 }
-
-// src/astar.ts
-var SQRT2 = Math.SQRT2;
+//#endregion
+//#region src/astar.ts
+const SQRT2$1 = Math.SQRT2;
 function manhattanDistance(ax, ay, bx, by) {
-  return Math.abs(ax - bx) + Math.abs(ay - by);
+	return Math.abs(ax - bx) + Math.abs(ay - by);
 }
 function octileDistance(ax, ay, bx, by) {
-  const dx = Math.abs(ax - bx);
-  const dy = Math.abs(ay - by);
-  return dx > dy ? dx + (SQRT2 - 1) * dy : dy + (SQRT2 - 1) * dx;
+	const dx = Math.abs(ax - bx);
+	const dy = Math.abs(ay - by);
+	return dx > dy ? dx + (SQRT2$1 - 1) * dy : dy + (SQRT2$1 - 1) * dx;
 }
 function chebyshevDistance(ax, ay, bx, by) {
-  return Math.max(Math.abs(ax - bx), Math.abs(ay - by));
+	return Math.max(Math.abs(ax - bx), Math.abs(ay - by));
 }
 function euclideanDistance(ax, ay, bx, by) {
-  const dx = ax - bx;
-  const dy = ay - by;
-  return Math.sqrt(dx * dx + dy * dy);
+	const dx = ax - bx;
+	const dy = ay - by;
+	return Math.sqrt(dx * dx + dy * dy);
+}
+function heapCreate$1(capacity) {
+	return {
+		f: new Float64Array(capacity),
+		idx: new Int32Array(capacity),
+		size: 0
+	};
+}
+function heapPush$1(h, f, nodeIdx) {
+	let i = h.size++;
+	h.f[i] = f;
+	h.idx[i] = nodeIdx;
+	while (i > 0) {
+		const parent = i - 1 >> 1;
+		if (h.f[parent] <= h.f[i]) break;
+		const tf = h.f[parent];
+		const ti = h.idx[parent];
+		h.f[parent] = h.f[i];
+		h.idx[parent] = h.idx[i];
+		h.f[i] = tf;
+		h.idx[i] = ti;
+		i = parent;
+	}
+}
+function heapPop$1(h) {
+	const result = h.idx[0];
+	h.size--;
+	if (h.size > 0) {
+		h.f[0] = h.f[h.size];
+		h.idx[0] = h.idx[h.size];
+		let i = 0;
+		for (;;) {
+			let smallest = i;
+			const left = 2 * i + 1;
+			const right = 2 * i + 2;
+			if (left < h.size && h.f[left] < h.f[smallest]) smallest = left;
+			if (right < h.size && h.f[right] < h.f[smallest]) smallest = right;
+			if (smallest === i) break;
+			const tf = h.f[i];
+			const ti = h.idx[i];
+			h.f[i] = h.f[smallest];
+			h.idx[i] = h.idx[smallest];
+			h.f[smallest] = tf;
+			h.idx[smallest] = ti;
+			i = smallest;
+		}
+	}
+	return result;
+}
+const DIR4_X = [
+	0,
+	1,
+	0,
+	-1
+];
+const DIR4_Y = [
+	-1,
+	0,
+	1,
+	0
+];
+const DIR8_X = [
+	0,
+	1,
+	1,
+	1,
+	0,
+	-1,
+	-1,
+	-1
+];
+const DIR8_Y = [
+	-1,
+	-1,
+	0,
+	1,
+	1,
+	1,
+	0,
+	-1
+];
+const DIR8_COST = [
+	1,
+	SQRT2$1,
+	1,
+	SQRT2$1,
+	1,
+	SQRT2$1,
+	1,
+	SQRT2$1
+];
+function findPath(grid, startX, startY, endX, endY, options) {
+	const sx = startX | 0;
+	const sy = startY | 0;
+	const ex = endX | 0;
+	const ey = endY | 0;
+	if (!isWalkable(grid, sx, sy) || !isWalkable(grid, ex, ey)) return null;
+	if (sx === ex && sy === ey) return {
+		path: [{
+			x: sx,
+			y: sy
+		}],
+		cost: 0,
+		explored: 0
+	};
+	const diagonal = options?.diagonal !== false;
+	const maxIter = options?.maxIterations ?? grid.width * grid.height;
+	const heuristic = options?.heuristic ?? (diagonal ? octileDistance : manhattanDistance);
+	const w = grid.width;
+	const total = w * grid.height;
+	const g = new Float64Array(total);
+	g.fill(Number.POSITIVE_INFINITY);
+	const closed = new Uint8Array(total);
+	const cameFrom = new Int32Array(total);
+	cameFrom.fill(-1);
+	const startIdx = sy * w + sx;
+	const endIdx = ey * w + ex;
+	g[startIdx] = 0;
+	const heap = heapCreate$1(Math.min(total, 4096));
+	heapPush$1(heap, heuristic(sx, sy, ex, ey), startIdx);
+	const dirX = diagonal ? DIR8_X : DIR4_X;
+	const dirY = diagonal ? DIR8_Y : DIR4_Y;
+	const dirCost = diagonal ? DIR8_COST : null;
+	const dirCount = dirX.length;
+	let explored = 0;
+	while (heap.size > 0 && explored < maxIter) {
+		const currentIdx = heapPop$1(heap);
+		if (currentIdx === endIdx) return reconstructPath(cameFrom, w, currentIdx, g[currentIdx], explored);
+		if (closed[currentIdx]) continue;
+		closed[currentIdx] = 1;
+		explored++;
+		const cx = currentIdx % w;
+		const cy = currentIdx / w | 0;
+		const currentG = g[currentIdx];
+		for (let d = 0; d < dirCount; d++) {
+			const nx = cx + dirX[d];
+			const ny = cy + dirY[d];
+			if (nx < 0 || ny < 0 || nx >= w || ny >= grid.height) continue;
+			const nIdx = ny * w + nx;
+			if (closed[nIdx]) continue;
+			const tileCost = grid.data[nIdx];
+			if (tileCost === 0) continue;
+			if (diagonal && d & 1) {
+				const dx = dirX[d];
+				const dy = dirY[d];
+				if (!isWalkable(grid, cx + dx, cy) || !isWalkable(grid, cx, cy + dy)) continue;
+			}
+			const tentativeG = currentG + (dirCost ? dirCost[d] * tileCost : tileCost);
+			if (tentativeG < g[nIdx]) {
+				g[nIdx] = tentativeG;
+				cameFrom[nIdx] = currentIdx;
+				heapPush$1(heap, tentativeG + heuristic(nx, ny, ex, ey), nIdx);
+			}
+		}
+	}
+	return null;
 }
+function reconstructPath(cameFrom, w, endIdx, cost, explored) {
+	const path = [];
+	let idx = endIdx;
+	while (idx !== -1) {
+		path.push({
+			x: idx % w,
+			y: idx / w | 0
+		});
+		idx = cameFrom[idx];
+	}
+	path.reverse();
+	return {
+		path,
+		cost,
+		explored
+	};
+}
+//#endregion
+//#region src/jps.ts
 function heapCreate(capacity) {
-  return {
-    f: new Float64Array(capacity),
-    idx: new Int32Array(capacity),
-    size: 0
-  };
+	return {
+		f: new Float64Array(capacity),
+		idx: new Int32Array(capacity),
+		size: 0
+	};
 }
 function heapPush(h, f, nodeIdx) {
-  let i = h.size++;
-  h.f[i] = f;
-  h.idx[i] = nodeIdx;
-  while (i > 0) {
-    const parent = i - 1 >> 1;
-    if (h.f[parent] <= h.f[i]) break;
-    const tf = h.f[parent];
-    const ti = h.idx[parent];
-    h.f[parent] = h.f[i];
-    h.idx[parent] = h.idx[i];
-    h.f[i] = tf;
-    h.idx[i] = ti;
-    i = parent;
-  }
+	let i = h.size++;
+	h.f[i] = f;
+	h.idx[i] = nodeIdx;
+	while (i > 0) {
+		const parent = i - 1 >> 1;
+		if (h.f[parent] <= h.f[i]) break;
+		const tf = h.f[parent];
+		const ti = h.idx[parent];
+		h.f[parent] = h.f[i];
+		h.idx[parent] = h.idx[i];
+		h.f[i] = tf;
+		h.idx[i] = ti;
+		i = parent;
+	}
 }
 function heapPop(h) {
-  const result = h.idx[0];
-  h.size--;
-  if (h.size > 0) {
-    h.f[0] = h.f[h.size];
-    h.idx[0] = h.idx[h.size];
-    let i = 0;
-    for (; ; ) {
-      let smallest = i;
-      const left = 2 * i + 1;
-      const right = 2 * i + 2;
-      if (left < h.size && h.f[left] < h.f[smallest]) smallest = left;
-      if (right < h.size && h.f[right] < h.f[smallest]) smallest = right;
-      if (smallest === i) break;
-      const tf = h.f[i];
-      const ti = h.idx[i];
-      h.f[i] = h.f[smallest];
-      h.idx[i] = h.idx[smallest];
-      h.f[smallest] = tf;
-      h.idx[smallest] = ti;
-      i = smallest;
-    }
-  }
-  return result;
-}
-var DIR4_X = [0, 1, 0, -1];
-var DIR4_Y = [-1, 0, 1, 0];
-var DIR8_X = [0, 1, 1, 1, 0, -1, -1, -1];
-var DIR8_Y = [-1, -1, 0, 1, 1, 1, 0, -1];
-var DIR8_COST = [1, SQRT2, 1, SQRT2, 1, SQRT2, 1, SQRT2];
-function findPath(grid, startX, startY, endX, endY, options) {
-  const sx = startX | 0;
-  const sy = startY | 0;
-  const ex = endX | 0;
-  const ey = endY | 0;
-  if (!isWalkable(grid, sx, sy) || !isWalkable(grid, ex, ey)) return null;
-  if (sx === ex && sy === ey) return { path: [{ x: sx, y: sy }], cost: 0, explored: 0 };
-  const diagonal = options?.diagonal !== false;
-  const maxIter = options?.maxIterations ?? grid.width * grid.height;
-  const heuristic = options?.heuristic ?? (diagonal ? octileDistance : manhattanDistance);
-  const w = grid.width;
-  const total = w * grid.height;
-  const g = new Float64Array(total);
-  g.fill(Number.POSITIVE_INFINITY);
-  const closed = new Uint8Array(total);
-  const cameFrom = new Int32Array(total);
-  cameFrom.fill(-1);
-  const startIdx = sy * w + sx;
-  const endIdx = ey * w + ex;
-  g[startIdx] = 0;
-  const heap = heapCreate(Math.min(total, 4096));
-  heapPush(heap, heuristic(sx, sy, ex, ey), startIdx);
-  const dirX = diagonal ? DIR8_X : DIR4_X;
-  const dirY = diagonal ? DIR8_Y : DIR4_Y;
-  const dirCost = diagonal ? DIR8_COST : null;
-  const dirCount = dirX.length;
-  let explored = 0;
-  while (heap.size > 0 && explored < maxIter) {
-    const currentIdx = heapPop(heap);
-    if (currentIdx === endIdx) {
-      return reconstructPath(cameFrom, w, currentIdx, g[currentIdx], explored);
-    }
-    if (closed[currentIdx]) continue;
-    closed[currentIdx] = 1;
-    explored++;
-    const cx = currentIdx % w;
-    const cy = currentIdx / w | 0;
-    const currentG = g[currentIdx];
-    for (let d = 0; d < dirCount; d++) {
-      const nx = cx + dirX[d];
-      const ny = cy + dirY[d];
-      if (nx < 0 || ny < 0 || nx >= w || ny >= grid.height) continue;
-      const nIdx = ny * w + nx;
-      if (closed[nIdx]) continue;
-      const tileCost = grid.data[nIdx];
-      if (tileCost === 0) continue;
-      if (diagonal && d & 1) {
-        const dx = dirX[d];
-        const dy = dirY[d];
-        if (!isWalkable(grid, cx + dx, cy) || !isWalkable(grid, cx, cy + dy)) continue;
-      }
-      const moveCost = dirCost ? dirCost[d] * tileCost : tileCost;
-      const tentativeG = currentG + moveCost;
-      if (tentativeG < g[nIdx]) {
-        g[nIdx] = tentativeG;
-        cameFrom[nIdx] = currentIdx;
-        const f = tentativeG + heuristic(nx, ny, ex, ey);
-        heapPush(heap, f, nIdx);
-      }
-    }
-  }
-  return null;
-}
-function reconstructPath(cameFrom, w, endIdx, cost, explored) {
-  const path = [];
-  let idx = endIdx;
-  while (idx !== -1) {
-    path.push({ x: idx % w, y: idx / w | 0 });
-    idx = cameFrom[idx];
-  }
-  path.reverse();
-  return { path, cost, explored };
-}
-
-// src/jps.ts
-function heapCreate2(capacity) {
-  return {
-    f: new Float64Array(capacity),
-    idx: new Int32Array(capacity),
-    size: 0
-  };
-}
-function heapPush2(h, f, nodeIdx) {
-  let i = h.size++;
-  h.f[i] = f;
-  h.idx[i] = nodeIdx;
-  while (i > 0) {
-    const parent = i - 1 >> 1;
-    if (h.f[parent] <= h.f[i]) break;
-    const tf = h.f[parent];
-    const ti = h.idx[parent];
-    h.f[parent] = h.f[i];
-    h.idx[parent] = h.idx[i];
-    h.f[i] = tf;
-    h.idx[i] = ti;
-    i = parent;
-  }
-}
-function heapPop2(h) {
-  const result = h.idx[0];
-  h.size--;
-  if (h.size > 0) {
-    h.f[0] = h.f[h.size];
-    h.idx[0] = h.idx[h.size];
-    let i = 0;
-    for (; ; ) {
-      let smallest = i;
-      const left = 2 * i + 1;
-      const right = 2 * i + 2;
-      if (left < h.size && h.f[left] < h.f[smallest]) smallest = left;
-      if (right < h.size && h.f[right] < h.f[smallest]) smallest = right;
-      if (smallest === i) break;
-      const tf = h.f[i];
-      const ti = h.idx[i];
-      h.f[i] = h.f[smallest];
-      h.idx[i] = h.idx[smallest];
-      h.f[smallest] = tf;
-      h.idx[smallest] = ti;
-      i = smallest;
-    }
-  }
-  return result;
-}
-var SQRT22 = Math.SQRT2;
+	const result = h.idx[0];
+	h.size--;
+	if (h.size > 0) {
+		h.f[0] = h.f[h.size];
+		h.idx[0] = h.idx[h.size];
+		let i = 0;
+		for (;;) {
+			let smallest = i;
+			const left = 2 * i + 1;
+			const right = 2 * i + 2;
+			if (left < h.size && h.f[left] < h.f[smallest]) smallest = left;
+			if (right < h.size && h.f[right] < h.f[smallest]) smallest = right;
+			if (smallest === i) break;
+			const tf = h.f[i];
+			const ti = h.idx[i];
+			h.f[i] = h.f[smallest];
+			h.idx[i] = h.idx[smallest];
+			h.f[smallest] = tf;
+			h.idx[smallest] = ti;
+			i = smallest;
+		}
+	}
+	return result;
+}
+const SQRT2 = Math.SQRT2;
 function findPathJPS(grid, startX, startY, endX, endY, options) {
-  const sx = startX | 0;
-  const sy = startY | 0;
-  const ex = endX | 0;
-  const ey = endY | 0;
-  if (!isWalkable(grid, sx, sy) || !isWalkable(grid, ex, ey)) return null;
-  if (sx === ex && sy === ey) return { path: [{ x: sx, y: sy }], cost: 0, explored: 0 };
-  const w = grid.width;
-  const h = grid.height;
-  const total = w * h;
-  const maxIter = options?.maxIterations ?? total;
-  const heuristic = options?.heuristic ?? octileDistance;
-  const g = new Float64Array(total);
-  g.fill(Number.POSITIVE_INFINITY);
-  const closed = new Uint8Array(total);
-  const cameFrom = new Int32Array(total);
-  cameFrom.fill(-1);
-  const startIdx = sy * w + sx;
-  const endIdx = ey * w + ex;
-  g[startIdx] = 0;
-  const heap = heapCreate2(Math.min(total, 4096));
-  heapPush2(heap, heuristic(sx, sy, ex, ey), startIdx);
-  let explored = 0;
-  while (heap.size > 0 && explored < maxIter) {
-    const currentIdx = heapPop2(heap);
-    if (currentIdx === endIdx) {
-      return buildPath(cameFrom, w, currentIdx, g[currentIdx], explored);
-    }
-    if (closed[currentIdx]) continue;
-    closed[currentIdx] = 1;
-    explored++;
-    const cx = currentIdx % w;
-    const cy = currentIdx / w | 0;
-    const neighbors = identifySuccessors(grid, cx, cy, cameFrom, w, h, ex, ey);
-    for (let i = 0; i < neighbors.length; i += 2) {
-      const nx = neighbors[i];
-      const ny = neighbors[i + 1];
-      const nIdx = ny * w + nx;
-      if (closed[nIdx]) continue;
-      const dx = Math.abs(nx - cx);
-      const dy = Math.abs(ny - cy);
-      const diag = Math.min(dx, dy);
-      const straight = Math.abs(dx - dy);
-      const dist2 = diag * SQRT22 + straight;
-      const tentativeG = g[currentIdx] + dist2;
-      if (tentativeG < g[nIdx]) {
-        g[nIdx] = tentativeG;
-        cameFrom[nIdx] = currentIdx;
-        heapPush2(heap, tentativeG + heuristic(nx, ny, ex, ey), nIdx);
-      }
-    }
-  }
-  return null;
+	const sx = startX | 0;
+	const sy = startY | 0;
+	const ex = endX | 0;
+	const ey = endY | 0;
+	if (!isWalkable(grid, sx, sy) || !isWalkable(grid, ex, ey)) return null;
+	if (sx === ex && sy === ey) return {
+		path: [{
+			x: sx,
+			y: sy
+		}],
+		cost: 0,
+		explored: 0
+	};
+	const w = grid.width;
+	const h = grid.height;
+	const total = w * h;
+	const maxIter = options?.maxIterations ?? total;
+	const heuristic = options?.heuristic ?? octileDistance;
+	const g = new Float64Array(total);
+	g.fill(Number.POSITIVE_INFINITY);
+	const closed = new Uint8Array(total);
+	const cameFrom = new Int32Array(total);
+	cameFrom.fill(-1);
+	const startIdx = sy * w + sx;
+	const endIdx = ey * w + ex;
+	g[startIdx] = 0;
+	const heap = heapCreate(Math.min(total, 4096));
+	heapPush(heap, heuristic(sx, sy, ex, ey), startIdx);
+	let explored = 0;
+	while (heap.size > 0 && explored < maxIter) {
+		const currentIdx = heapPop(heap);
+		if (currentIdx === endIdx) return buildPath(cameFrom, w, currentIdx, g[currentIdx], explored);
+		if (closed[currentIdx]) continue;
+		closed[currentIdx] = 1;
+		explored++;
+		const cx = currentIdx % w;
+		const cy = currentIdx / w | 0;
+		const neighbors = identifySuccessors(grid, cx, cy, cameFrom, w, h, ex, ey);
+		for (let i = 0; i < neighbors.length; i += 2) {
+			const nx = neighbors[i];
+			const ny = neighbors[i + 1];
+			const nIdx = ny * w + nx;
+			if (closed[nIdx]) continue;
+			const dx = Math.abs(nx - cx);
+			const dy = Math.abs(ny - cy);
+			const diag = Math.min(dx, dy);
+			const straight = Math.abs(dx - dy);
+			const dist = diag * SQRT2 + straight;
+			const tentativeG = g[currentIdx] + dist;
+			if (tentativeG < g[nIdx]) {
+				g[nIdx] = tentativeG;
+				cameFrom[nIdx] = currentIdx;
+				heapPush(heap, tentativeG + heuristic(nx, ny, ex, ey), nIdx);
+			}
+		}
+	}
+	return null;
 }
 function identifySuccessors(grid, cx, cy, cameFrom, w, h, ex, ey) {
-  const results = [];
-  const parentIdx = cameFrom[cy * w + cx];
-  if (parentIdx === -1) {
-    for (let dx = -1; dx <= 1; dx++) {
-      for (let dy = -1; dy <= 1; dy++) {
-        if (dx === 0 && dy === 0) continue;
-        const jp = jump(grid, cx, cy, dx, dy, w, h, ex, ey);
-        if (jp !== -1) {
-          results.push(jp % w, jp / w | 0);
-        }
-      }
-    }
-  } else {
-    const px = parentIdx % w;
-    const py = parentIdx / w | 0;
-    const dx = clampDir(cx - px);
-    const dy = clampDir(cy - py);
-    if (dx !== 0 && dy !== 0) {
-      if (isWalkable(grid, cx, cy + dy)) {
-        const jp = jump(grid, cx, cy, 0, dy, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-      if (isWalkable(grid, cx + dx, cy)) {
-        const jp = jump(grid, cx, cy, dx, 0, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-      if (isWalkable(grid, cx + dx, cy + dy)) {
-        const jp = jump(grid, cx, cy, dx, dy, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-      if (!isWalkable(grid, cx - dx, cy) && isWalkable(grid, cx - dx, cy + dy)) {
-        const jp = jump(grid, cx, cy, -dx, dy, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-      if (!isWalkable(grid, cx, cy - dy) && isWalkable(grid, cx + dx, cy - dy)) {
-        const jp = jump(grid, cx, cy, dx, -dy, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-    } else if (dx !== 0) {
-      if (isWalkable(grid, cx + dx, cy)) {
-        const jp = jump(grid, cx, cy, dx, 0, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-      if (!isWalkable(grid, cx, cy + 1) && isWalkable(grid, cx + dx, cy + 1)) {
-        const jp = jump(grid, cx, cy, dx, 1, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-      if (!isWalkable(grid, cx, cy - 1) && isWalkable(grid, cx + dx, cy - 1)) {
-        const jp = jump(grid, cx, cy, dx, -1, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-    } else {
-      if (isWalkable(grid, cx, cy + dy)) {
-        const jp = jump(grid, cx, cy, 0, dy, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-      if (!isWalkable(grid, cx + 1, cy) && isWalkable(grid, cx + 1, cy + dy)) {
-        const jp = jump(grid, cx, cy, 1, dy, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-      if (!isWalkable(grid, cx - 1, cy) && isWalkable(grid, cx - 1, cy + dy)) {
-        const jp = jump(grid, cx, cy, -1, dy, w, h, ex, ey);
-        if (jp !== -1) results.push(jp % w, jp / w | 0);
-      }
-    }
-  }
-  return results;
+	const results = [];
+	const parentIdx = cameFrom[cy * w + cx];
+	if (parentIdx === -1) for (let dx = -1; dx <= 1; dx++) for (let dy = -1; dy <= 1; dy++) {
+		if (dx === 0 && dy === 0) continue;
+		const jp = jump(grid, cx, cy, dx, dy, w, h, ex, ey);
+		if (jp !== -1) results.push(jp % w, jp / w | 0);
+	}
+	else {
+		const px = parentIdx % w;
+		const py = parentIdx / w | 0;
+		const dx = clampDir(cx - px);
+		const dy = clampDir(cy - py);
+		if (dx !== 0 && dy !== 0) {
+			if (isWalkable(grid, cx, cy + dy)) {
+				const jp = jump(grid, cx, cy, 0, dy, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+			if (isWalkable(grid, cx + dx, cy)) {
+				const jp = jump(grid, cx, cy, dx, 0, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+			if (isWalkable(grid, cx + dx, cy + dy)) {
+				const jp = jump(grid, cx, cy, dx, dy, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+			if (!isWalkable(grid, cx - dx, cy) && isWalkable(grid, cx - dx, cy + dy)) {
+				const jp = jump(grid, cx, cy, -dx, dy, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+			if (!isWalkable(grid, cx, cy - dy) && isWalkable(grid, cx + dx, cy - dy)) {
+				const jp = jump(grid, cx, cy, dx, -dy, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+		} else if (dx !== 0) {
+			if (isWalkable(grid, cx + dx, cy)) {
+				const jp = jump(grid, cx, cy, dx, 0, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+			if (!isWalkable(grid, cx, cy + 1) && isWalkable(grid, cx + dx, cy + 1)) {
+				const jp = jump(grid, cx, cy, dx, 1, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+			if (!isWalkable(grid, cx, cy - 1) && isWalkable(grid, cx + dx, cy - 1)) {
+				const jp = jump(grid, cx, cy, dx, -1, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+		} else {
+			if (isWalkable(grid, cx, cy + dy)) {
+				const jp = jump(grid, cx, cy, 0, dy, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+			if (!isWalkable(grid, cx + 1, cy) && isWalkable(grid, cx + 1, cy + dy)) {
+				const jp = jump(grid, cx, cy, 1, dy, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+			if (!isWalkable(grid, cx - 1, cy) && isWalkable(grid, cx - 1, cy + dy)) {
+				const jp = jump(grid, cx, cy, -1, dy, w, h, ex, ey);
+				if (jp !== -1) results.push(jp % w, jp / w | 0);
+			}
+		}
+	}
+	return results;
 }
 function jump(grid, cx, cy, dx, dy, w, h, ex, ey) {
-  const nx = cx + dx;
-  const ny = cy + dy;
-  if (!isWalkable(grid, nx, ny)) return -1;
-  if (nx === ex && ny === ey) return ny * w + nx;
-  if (dx !== 0 && dy !== 0) {
-    if (!isWalkable(grid, nx - dx, ny) && isWalkable(grid, nx - dx, ny + dy) || !isWalkable(grid, nx, ny - dy) && isWalkable(grid, nx + dx, ny - dy)) {
-      return ny * w + nx;
-    }
-    if (jump(grid, nx, ny, dx, 0, w, h, ex, ey) !== -1) return ny * w + nx;
-    if (jump(grid, nx, ny, 0, dy, w, h, ex, ey) !== -1) return ny * w + nx;
-  } else if (dx !== 0) {
-    if (!isWalkable(grid, nx, ny + 1) && isWalkable(grid, nx + dx, ny + 1) || !isWalkable(grid, nx, ny - 1) && isWalkable(grid, nx + dx, ny - 1)) {
-      return ny * w + nx;
-    }
-  } else {
-    if (!isWalkable(grid, nx + 1, ny) && isWalkable(grid, nx + 1, ny + dy) || !isWalkable(grid, nx - 1, ny) && isWalkable(grid, nx - 1, ny + dy)) {
-      return ny * w + nx;
-    }
-  }
-  return jump(grid, nx, ny, dx, dy, w, h, ex, ey);
+	const nx = cx + dx;
+	const ny = cy + dy;
+	if (!isWalkable(grid, nx, ny)) return -1;
+	if (nx === ex && ny === ey) return ny * w + nx;
+	if (dx !== 0 && dy !== 0) {
+		if (!isWalkable(grid, nx - dx, ny) && isWalkable(grid, nx - dx, ny + dy) || !isWalkable(grid, nx, ny - dy) && isWalkable(grid, nx + dx, ny - dy)) return ny * w + nx;
+		if (jump(grid, nx, ny, dx, 0, w, h, ex, ey) !== -1) return ny * w + nx;
+		if (jump(grid, nx, ny, 0, dy, w, h, ex, ey) !== -1) return ny * w + nx;
+	} else if (dx !== 0) {
+		if (!isWalkable(grid, nx, ny + 1) && isWalkable(grid, nx + dx, ny + 1) || !isWalkable(grid, nx, ny - 1) && isWalkable(grid, nx + dx, ny - 1)) return ny * w + nx;
+	} else if (!isWalkable(grid, nx + 1, ny) && isWalkable(grid, nx + 1, ny + dy) || !isWalkable(grid, nx - 1, ny) && isWalkable(grid, nx - 1, ny + dy)) return ny * w + nx;
+	return jump(grid, nx, ny, dx, dy, w, h, ex, ey);
 }
 function clampDir(v) {
-  return v > 0 ? 1 : v < 0 ? -1 : 0;
+	return v > 0 ? 1 : v < 0 ? -1 : 0;
 }
 function buildPath(cameFrom, w, endIdx, cost, explored) {
-  const jumpPoints = [];
-  let idx = endIdx;
-  while (idx !== -1) {
-    jumpPoints.push(idx);
-    idx = cameFrom[idx];
-  }
-  jumpPoints.reverse();
-  const path = [];
-  for (let i = 0; i < jumpPoints.length; i++) {
-    const jpIdx = jumpPoints[i];
-    const jx = jpIdx % w;
-    const jy = jpIdx / w | 0;
-    if (i === 0) {
-      path.push({ x: jx, y: jy });
-    } else {
-      const prev = path[path.length - 1];
-      let cx = prev.x;
-      let cy = prev.y;
-      while (cx !== jx || cy !== jy) {
-        if (cx < jx) cx++;
-        else if (cx > jx) cx--;
-        if (cy < jy) cy++;
-        else if (cy > jy) cy--;
-        path.push({ x: cx, y: cy });
-      }
-    }
-  }
-  return { path, cost, explored };
-}
-
-// src/navmesh.ts
+	const jumpPoints = [];
+	let idx = endIdx;
+	while (idx !== -1) {
+		jumpPoints.push(idx);
+		idx = cameFrom[idx];
+	}
+	jumpPoints.reverse();
+	const path = [];
+	for (let i = 0; i < jumpPoints.length; i++) {
+		const jpIdx = jumpPoints[i];
+		const jx = jpIdx % w;
+		const jy = jpIdx / w | 0;
+		if (i === 0) path.push({
+			x: jx,
+			y: jy
+		});
+		else {
+			const prev = path[path.length - 1];
+			let cx = prev.x;
+			let cy = prev.y;
+			while (cx !== jx || cy !== jy) {
+				if (cx < jx) cx++;
+				else if (cx > jx) cx--;
+				if (cy < jy) cy++;
+				else if (cy > jy) cy--;
+				path.push({
+					x: cx,
+					y: cy
+				});
+			}
+		}
+	}
+	return {
+		path,
+		cost,
+		explored
+	};
+}
+//#endregion
+//#region src/navmesh.ts
 function createNavMesh(polygons) {
-  return { polygons };
+	return { polygons };
 }
 function pointInConvexPolygon(verts, px, py) {
-  const n = verts.length;
-  if (n < 3) return false;
-  let sign = 0;
-  for (let i = 0; i < n; i++) {
-    const a = verts[i];
-    const b = verts[(i + 1) % n];
-    const cross = (b.x - a.x) * (py - a.y) - (b.y - a.y) * (px - a.x);
-    if (cross !== 0) {
-      const s = cross > 0 ? 1 : -1;
-      if (sign === 0) sign = s;
-      else if (sign !== s) return false;
-    }
-  }
-  return true;
+	const n = verts.length;
+	if (n < 3) return false;
+	let sign = 0;
+	for (let i = 0; i < n; i++) {
+		const a = verts[i];
+		const b = verts[(i + 1) % n];
+		const cross = (b.x - a.x) * (py - a.y) - (b.y - a.y) * (px - a.x);
+		if (cross !== 0) {
+			const s = cross > 0 ? 1 : -1;
+			if (sign === 0) sign = s;
+			else if (sign !== s) return false;
+		}
+	}
+	return true;
 }
 function findPolygonAt(mesh, x, y) {
-  for (let i = 0; i < mesh.polygons.length; i++) {
-    if (pointInConvexPolygon(mesh.polygons[i].vertices, x, y)) {
-      return mesh.polygons[i].id;
-    }
-  }
-  return -1;
+	for (let i = 0; i < mesh.polygons.length; i++) if (pointInConvexPolygon(mesh.polygons[i].vertices, x, y)) return mesh.polygons[i].id;
+	return -1;
 }
 function centroid(verts) {
-  let cx = 0;
-  let cy = 0;
-  for (let i = 0; i < verts.length; i++) {
-    cx += verts[i].x;
-    cy += verts[i].y;
-  }
-  const n = verts.length;
-  return { x: cx / n, y: cy / n };
+	let cx = 0;
+	let cy = 0;
+	for (let i = 0; i < verts.length; i++) {
+		cx += verts[i].x;
+		cy += verts[i].y;
+	}
+	const n = verts.length;
+	return {
+		x: cx / n,
+		y: cy / n
+	};
 }
 function distSq(ax, ay, bx, by) {
-  const dx = ax - bx;
-  const dy = ay - by;
-  return dx * dx + dy * dy;
+	const dx = ax - bx;
+	const dy = ay - by;
+	return dx * dx + dy * dy;
 }
 function dist(ax, ay, bx, by) {
-  return Math.sqrt(distSq(ax, ay, bx, by));
+	return Math.sqrt(distSq(ax, ay, bx, by));
 }
 function findNavMeshPath(mesh, start, end) {
-  const startPolyId = findPolygonAt(mesh, start.x, start.y);
-  const endPolyId = findPolygonAt(mesh, end.x, end.y);
-  if (startPolyId === -1 || endPolyId === -1) return null;
-  if (startPolyId === endPolyId) {
-    return {
-      path: [
-        { x: start.x, y: start.y },
-        { x: end.x, y: end.y }
-      ],
-      corridor: [startPolyId]
-    };
-  }
-  const byId = /* @__PURE__ */ new Map();
-  for (let i = 0; i < mesh.polygons.length; i++) {
-    const p = mesh.polygons[i];
-    byId.set(p.id, p);
-  }
-  const gScore = /* @__PURE__ */ new Map();
-  const fScore = /* @__PURE__ */ new Map();
-  const cameFrom = /* @__PURE__ */ new Map();
-  gScore.set(startPolyId, 0);
-  const endPoly = byId.get(endPolyId);
-  const endCenter = centroid(endPoly.vertices);
-  const startPoly = byId.get(startPolyId);
-  const startCenter = centroid(startPoly.vertices);
-  fScore.set(startPolyId, dist(startCenter.x, startCenter.y, endCenter.x, endCenter.y));
-  const open = [startPolyId];
-  const inOpen = /* @__PURE__ */ new Set([startPolyId]);
-  const closed = /* @__PURE__ */ new Set();
-  while (open.length > 0) {
-    let bestI = 0;
-    let bestF = fScore.get(open[0]) ?? Number.POSITIVE_INFINITY;
-    for (let i = 1; i < open.length; i++) {
-      const f = fScore.get(open[i]) ?? Number.POSITIVE_INFINITY;
-      if (f < bestF) {
-        bestF = f;
-        bestI = i;
-      }
-    }
-    const currentId = open[bestI];
-    if (currentId === endPolyId) {
-      const corridor = [];
-      let id = endPolyId;
-      while (id !== void 0) {
-        corridor.push(id);
-        id = cameFrom.get(id);
-      }
-      corridor.reverse();
-      const path = funnelSmooth(mesh, byId, corridor, start, end);
-      return { path, corridor };
-    }
-    open[bestI] = open[open.length - 1];
-    open.length--;
-    inOpen.delete(currentId);
-    closed.add(currentId);
-    const current = byId.get(currentId);
-    const currentCenter = centroid(current.vertices);
-    const currentG = gScore.get(currentId);
-    for (let i = 0; i < current.portals.length; i++) {
-      const portal = current.portals[i];
-      const neighborId = portal.neighborId;
-      if (closed.has(neighborId)) continue;
-      const neighbor = byId.get(neighborId);
-      if (!neighbor) continue;
-      const portalMidX = (portal.a.x + portal.b.x) * 0.5;
-      const portalMidY = (portal.a.y + portal.b.y) * 0.5;
-      const tentativeG = currentG + dist(currentCenter.x, currentCenter.y, portalMidX, portalMidY);
-      const prevG = gScore.get(neighborId);
-      if (prevG !== void 0 && tentativeG >= prevG) continue;
-      gScore.set(neighborId, tentativeG);
-      cameFrom.set(neighborId, currentId);
-      const neighborCenter = centroid(neighbor.vertices);
-      fScore.set(
-        neighborId,
-        tentativeG + dist(neighborCenter.x, neighborCenter.y, endCenter.x, endCenter.y)
-      );
-      if (!inOpen.has(neighborId)) {
-        open.push(neighborId);
-        inOpen.add(neighborId);
-      }
-    }
-  }
-  return null;
+	const startPolyId = findPolygonAt(mesh, start.x, start.y);
+	const endPolyId = findPolygonAt(mesh, end.x, end.y);
+	if (startPolyId === -1 || endPolyId === -1) return null;
+	if (startPolyId === endPolyId) return {
+		path: [{
+			x: start.x,
+			y: start.y
+		}, {
+			x: end.x,
+			y: end.y
+		}],
+		corridor: [startPolyId]
+	};
+	const byId = /* @__PURE__ */ new Map();
+	for (let i = 0; i < mesh.polygons.length; i++) {
+		const p = mesh.polygons[i];
+		byId.set(p.id, p);
+	}
+	const gScore = /* @__PURE__ */ new Map();
+	const fScore = /* @__PURE__ */ new Map();
+	const cameFrom = /* @__PURE__ */ new Map();
+	gScore.set(startPolyId, 0);
+	const endCenter = centroid(byId.get(endPolyId).vertices);
+	const startCenter = centroid(byId.get(startPolyId).vertices);
+	fScore.set(startPolyId, dist(startCenter.x, startCenter.y, endCenter.x, endCenter.y));
+	const open = [startPolyId];
+	const inOpen = /* @__PURE__ */ new Set([startPolyId]);
+	const closed = /* @__PURE__ */ new Set();
+	while (open.length > 0) {
+		let bestI = 0;
+		let bestF = fScore.get(open[0]) ?? Number.POSITIVE_INFINITY;
+		for (let i = 1; i < open.length; i++) {
+			const f = fScore.get(open[i]) ?? Number.POSITIVE_INFINITY;
+			if (f < bestF) {
+				bestF = f;
+				bestI = i;
+			}
+		}
+		const currentId = open[bestI];
+		if (currentId === endPolyId) {
+			const corridor = [];
+			let id = endPolyId;
+			while (id !== void 0) {
+				corridor.push(id);
+				id = cameFrom.get(id);
+			}
+			corridor.reverse();
+			return {
+				path: funnelSmooth(mesh, byId, corridor, start, end),
+				corridor
+			};
+		}
+		open[bestI] = open[open.length - 1];
+		open.length--;
+		inOpen.delete(currentId);
+		closed.add(currentId);
+		const current = byId.get(currentId);
+		const currentCenter = centroid(current.vertices);
+		const currentG = gScore.get(currentId);
+		for (let i = 0; i < current.portals.length; i++) {
+			const portal = current.portals[i];
+			const neighborId = portal.neighborId;
+			if (closed.has(neighborId)) continue;
+			const neighbor = byId.get(neighborId);
+			if (!neighbor) continue;
+			const portalMidX = (portal.a.x + portal.b.x) * .5;
+			const portalMidY = (portal.a.y + portal.b.y) * .5;
+			const tentativeG = currentG + dist(currentCenter.x, currentCenter.y, portalMidX, portalMidY);
+			const prevG = gScore.get(neighborId);
+			if (prevG !== void 0 && tentativeG >= prevG) continue;
+			gScore.set(neighborId, tentativeG);
+			cameFrom.set(neighborId, currentId);
+			const neighborCenter = centroid(neighbor.vertices);
+			fScore.set(neighborId, tentativeG + dist(neighborCenter.x, neighborCenter.y, endCenter.x, endCenter.y));
+			if (!inOpen.has(neighborId)) {
+				open.push(neighborId);
+				inOpen.add(neighborId);
+			}
+		}
+	}
+	return null;
 }
 function funnelSmooth(_mesh, byId, corridor, start, end) {
-  if (corridor.length <= 1) {
-    return [
-      { x: start.x, y: start.y },
-      { x: end.x, y: end.y }
-    ];
-  }
-  const portalsLeft = [];
-  const portalsRight = [];
-  portalsLeft.push({ x: start.x, y: start.y });
-  portalsRight.push({ x: start.x, y: start.y });
-  for (let i = 0; i < corridor.length - 1; i++) {
-    const poly = byId.get(corridor[i]);
-    const nextId = corridor[i + 1];
-    let found = false;
-    for (let j = 0; j < poly.portals.length; j++) {
-      if (poly.portals[j].neighborId === nextId) {
-        portalsLeft.push(poly.portals[j].a);
-        portalsRight.push(poly.portals[j].b);
-        found = true;
-        break;
-      }
-    }
-    if (!found) {
-      const c = centroid(poly.vertices);
-      portalsLeft.push(c);
-      portalsRight.push(c);
-    }
-  }
-  portalsLeft.push({ x: end.x, y: end.y });
-  portalsRight.push({ x: end.x, y: end.y });
-  const path = [];
-  let apexPt = portalsLeft[0];
-  let leftPt = portalsLeft[0];
-  let rightPt = portalsRight[0];
-  let apexIdx = 0;
-  let leftIdx = 0;
-  let rightIdx = 0;
-  path.push({ x: apexPt.x, y: apexPt.y });
-  const n = portalsLeft.length;
-  for (let i = 1; i < n; i++) {
-    const pL = portalsLeft[i];
-    const pR = portalsRight[i];
-    if (triArea2(apexPt, rightPt, pR) <= 0) {
-      if (vEqual(apexPt, rightPt) || triArea2(apexPt, leftPt, pR) > 0) {
-        rightPt = pR;
-        rightIdx = i;
-      } else {
-        addUnique(path, leftPt);
-        apexPt = leftPt;
-        apexIdx = leftIdx;
-        leftPt = apexPt;
-        rightPt = apexPt;
-        leftIdx = apexIdx;
-        rightIdx = apexIdx;
-        i = apexIdx;
-        continue;
-      }
-    }
-    if (triArea2(apexPt, leftPt, pL) >= 0) {
-      if (vEqual(apexPt, leftPt) || triArea2(apexPt, rightPt, pL) < 0) {
-        leftPt = pL;
-        leftIdx = i;
-      } else {
-        addUnique(path, rightPt);
-        apexPt = rightPt;
-        apexIdx = rightIdx;
-        leftPt = apexPt;
-        rightPt = apexPt;
-        leftIdx = apexIdx;
-        rightIdx = apexIdx;
-        i = apexIdx;
-      }
-    }
-  }
-  addUnique(path, end);
-  return path;
+	if (corridor.length <= 1) return [{
+		x: start.x,
+		y: start.y
+	}, {
+		x: end.x,
+		y: end.y
+	}];
+	const portalsLeft = [];
+	const portalsRight = [];
+	portalsLeft.push({
+		x: start.x,
+		y: start.y
+	});
+	portalsRight.push({
+		x: start.x,
+		y: start.y
+	});
+	for (let i = 0; i < corridor.length - 1; i++) {
+		const poly = byId.get(corridor[i]);
+		const nextId = corridor[i + 1];
+		let found = false;
+		for (let j = 0; j < poly.portals.length; j++) if (poly.portals[j].neighborId === nextId) {
+			portalsLeft.push(poly.portals[j].a);
+			portalsRight.push(poly.portals[j].b);
+			found = true;
+			break;
+		}
+		if (!found) {
+			const c = centroid(poly.vertices);
+			portalsLeft.push(c);
+			portalsRight.push(c);
+		}
+	}
+	portalsLeft.push({
+		x: end.x,
+		y: end.y
+	});
+	portalsRight.push({
+		x: end.x,
+		y: end.y
+	});
+	const path = [];
+	let apexPt = portalsLeft[0];
+	let leftPt = portalsLeft[0];
+	let rightPt = portalsRight[0];
+	let apexIdx = 0;
+	let leftIdx = 0;
+	let rightIdx = 0;
+	path.push({
+		x: apexPt.x,
+		y: apexPt.y
+	});
+	const n = portalsLeft.length;
+	for (let i = 1; i < n; i++) {
+		const pL = portalsLeft[i];
+		const pR = portalsRight[i];
+		if (triArea2(apexPt, rightPt, pR) <= 0) if (vEqual(apexPt, rightPt) || triArea2(apexPt, leftPt, pR) > 0) {
+			rightPt = pR;
+			rightIdx = i;
+		} else {
+			addUnique(path, leftPt);
+			apexPt = leftPt;
+			apexIdx = leftIdx;
+			leftPt = apexPt;
+			rightPt = apexPt;
+			leftIdx = apexIdx;
+			rightIdx = apexIdx;
+			i = apexIdx;
+			continue;
+		}
+		if (triArea2(apexPt, leftPt, pL) >= 0) if (vEqual(apexPt, leftPt) || triArea2(apexPt, rightPt, pL) < 0) {
+			leftPt = pL;
+			leftIdx = i;
+		} else {
+			addUnique(path, rightPt);
+			apexPt = rightPt;
+			apexIdx = rightIdx;
+			leftPt = apexPt;
+			rightPt = apexPt;
+			leftIdx = apexIdx;
+			rightIdx = apexIdx;
+			i = apexIdx;
+		}
+	}
+	addUnique(path, end);
+	return path;
 }
 function addUnique(path, p) {
-  const last = path[path.length - 1];
-  if (!last || last.x !== p.x || last.y !== p.y) {
-    path.push({ x: p.x, y: p.y });
-  }
+	const last = path[path.length - 1];
+	if (!last || last.x !== p.x || last.y !== p.y) path.push({
+		x: p.x,
+		y: p.y
+	});
 }
+/** Twice the signed area of the triangle (a, b, c). Positive = CCW. */
 function triArea2(a, b, c) {
-  return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
+	return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
 }
 function vEqual(a, b) {
-  return a.x === b.x && a.y === b.y;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  chebyshevDistance,
-  createGrid,
-  createNavMesh,
-  euclideanDistance,
-  findNavMeshPath,
-  findPath,
-  findPathJPS,
-  findPolygonAt,
-  getCost,
-  inBounds,
-  isWalkable,
-  manhattanDistance,
-  octileDistance,
-  setCost,
-  setWalkable
-});
+	return a.x === b.x && a.y === b.y;
+}
+//#endregion
+exports.chebyshevDistance = chebyshevDistance;
+exports.createGrid = createGrid;
+exports.createNavMesh = createNavMesh;
+exports.euclideanDistance = euclideanDistance;
+exports.findNavMeshPath = findNavMeshPath;
+exports.findPath = findPath;
+exports.findPathJPS = findPathJPS;
+exports.findPolygonAt = findPolygonAt;
+exports.getCost = getCost;
+exports.inBounds = inBounds;
+exports.isWalkable = isWalkable;
+exports.manhattanDistance = manhattanDistance;
+exports.octileDistance = octileDistance;
+exports.setCost = setCost;
+exports.setWalkable = setWalkable;
+
 //# sourceMappingURL=index.js.map