vehicle-path2 4.0.1 → 4.0.3

package/README.md

@@ -68,39 +68,37 @@ Curve menghubungkan **ujung satu line** ke **awal line lain**. Tidak bisa berdir
 ```typescript
 import type { Curve } from 'vehicle-path2/core'
 
-// Tambah curve
-engine.addCurve({
+// Tambah curve (returns curve id — auto-generated if not provided)
+const curveId = engine.addCurve({
+  id: 'c1',              // optional — auto-generated if omitted
   fromLineId: 'L1',
   toLineId: 'L2',
   fromOffset: 380,        // posisi di L1 (px dari start)
   fromIsPercentage: false,
   toOffset: 20,           // posisi di L2 (px dari start)
   toIsPercentage: false,
-} as Curve)
-
-// Atau dengan offset persentase (0–1)
-engine.addCurve({
-  fromLineId: 'L1',
-  toLineId: 'L2',
-  fromOffset: 0.95,
-  fromIsPercentage: true,
-  toOffset: 0.05,
-  toIsPercentage: true,
-} as Curve)
+})
 
-// Update curve berdasarkan index
-engine.updateCurve(0, { fromOffset: 0.9 })
+// Update curve berdasarkan id
+engine.updateCurve('c1', { fromOffset: 100 })
 
-// Hapus curve berdasarkan index
-engine.removeCurve(0)
+// Hapus curve berdasarkan id
+engine.removeCurve('c1')
 
 // Baca semua curves
 engine.getCurves() // → Curve[]
+
+// Dapatkan computed bezier untuk rendering
+engine.getCurveBeziers() // → Map<string, BezierCurve>
 ```
 
-> **Catatan:** Curve diidentifikasi via **array index** (bukan named ID). Gunakan `getCurves()` lalu cari index yang sesuai sebelum update/delete.
+> **Catatan:** Curve diidentifikasi via `id` (string). Jika tidak diberikan saat `addCurve`, id otomatis di-generate.
+
+> **Konsekuensi `removeLine`:** Curve yang terhubung ke line yang dihapus otomatis ikut terhapus. `removeLine` mengembalikan `{ success, removedCurveIds }`.
+
+> **Path validation:** Gunakan `engine.canReach(fromLineId, fromOffset, toLineId, toOffset)` untuk mengecek apakah path ada tanpa membuat execution plan.
 
-> **Konsekuensi `removeLine`:** Curve yang terhubung ke line yang dihapus otomatis ikut terhapus, sehingga index curve-curve lainnya bisa bergeser.
+> **Acceleration:** Gunakan `engine.moveVehicleWithAcceleration(state, exec, accelState, config, deltaTime)` untuk movement dengan physics-based acceleration/deceleration.
 
 ---
 

package/dist/core/algorithms/pathFinding.d.ts

@@ -2,11 +2,13 @@ import type { Line, Curve, BezierCurve } from '../types/geometry';
 import type { MovementConfig } from '../types/movement';
 export interface GraphEdge {
     curveIndex: number;
+    curveId?: string;
     fromLineId: string;
     toLineId: string;
     fromOffset: number;
     toOffset: number;
     curveLength: number;
+    bezier: BezierCurve;
 }
 export interface Graph {
     adjacency: Map<string, GraphEdge[]>;

package/dist/core/engine.d.ts

@@ -25,11 +25,12 @@
  * }
  * ```
  */
-import type { Line, Curve, Point } from './types/geometry';
+import type { Line, Curve, BezierCurve, Point } from './types/geometry';
 import type { VehicleDefinition } from './types/vehicle';
 import type { MovementConfig, CurveData } from './types/movement';
-import type { PathResult } from './algorithms/pathFinding';
+import type { PathResult, Graph } from './algorithms/pathFinding';
 import type { TangentMode } from './types/config';
+import { type AccelerationConfig, type AccelerationState } from './algorithms/acceleration';
 export interface PathEngineConfig {
     tangentMode: TangentMode;
 }
@@ -71,15 +72,29 @@ export { moveVehicle } from './algorithms/vehicleMovement';
  */
 export declare class PathEngine {
     private graph;
+    private graphDirty;
     private linesMap;
-    private curves;
+    private curvesMap;
+    private curveSeq;
     private config;
     constructor(engineConfig: PathEngineConfig);
+    private ensureGraph;
     get movementConfig(): MovementConfig;
     get lines(): Line[];
     getCurves(): Curve[];
     /**
-     * Replace the entire scene and rebuild the graph.
+     * Expose the graph (lazily built) for consumers that need it
+     * (e.g., scene stats, custom pathfinding).
+     */
+    getGraph(): Graph;
+    /**
+     * Returns computed bezier for each curve by id.
+     * Internally calls ensureGraph() to guarantee beziers are computed,
+     * then iterates graph edges to build the return map.
+     */
+    getCurveBeziers(): Map<string, BezierCurve>;
+    /**
+     * Replace the entire scene. Graph is rebuilt lazily on first access.
      */
     setScene(lines: Line[], curves: Curve[]): void;
     /**
@@ -88,6 +103,7 @@ export declare class PathEngine {
     addLine(line: Line): boolean;
     /**
      * Update start and/or end coordinates of an existing line.
+     * Immutable — does not mutate the original line object.
      */
     updateLine(lineId: string, updates: {
         start?: Point;
@@ -99,27 +115,39 @@ export declare class PathEngine {
     updateLineEndpoint(lineId: string, endpoint: 'start' | 'end', point: Point): boolean;
     /**
      * Rename a line ID and cascade the change to all connected curves.
+     * Immutable — does not mutate original objects.
      */
     renameLine(oldId: string, newId: string): {
         success: boolean;
         error?: string;
+        renamedCurveIds?: string[];
     };
     /**
      * Remove a line and all curves connected to it.
+     * Returns which curves were also removed.
      */
-    removeLine(lineId: string): boolean;
+    removeLine(lineId: string): {
+        success: boolean;
+        removedCurveIds: string[];
+    };
     /**
      * Add a directional curve (connection) from one line to another.
+     * Returns the curve id (auto-generated if not provided).
+     */
+    addCurve(curve: Curve): string;
+    /**
+     * Update a curve by id. Returns false if curve not found.
      */
-    addCurve(curve: Curve): void;
+    updateCurve(curveId: string, updates: Partial<Curve>): boolean;
     /**
-     * Update a curve by index. Returns false if index is out of bounds.
+     * Remove a curve by id. Returns false if curve not found.
      */
-    updateCurve(index: number, updates: Partial<Curve>): boolean;
+    removeCurve(curveId: string): boolean;
     /**
-     * Remove a curve by index. Returns false if index is out of bounds.
+     * Check if a path exists from one position to another.
+     * Both offsets are absolute pixel values.
      */
-    removeCurve(index: number): boolean;
+    canReach(fromLineId: string, fromOffset: number, toLineId: string, toOffset: number): boolean;
     /**
      * Initialize a vehicle's N-axle position on a line.
      *
@@ -156,4 +184,16 @@ export declare class PathEngine {
         execution: PathExecution;
         arrived: boolean;
     };
+    /**
+     * Advance a vehicle with physics-based acceleration/deceleration.
+     *
+     * Thin wrapper — internally calls the standalone moveVehicleWithAcceleration()
+     * function from acceleration.ts, injecting this.linesMap as the 6th argument.
+     */
+    moveVehicleWithAcceleration(state: VehiclePathState, execution: PathExecution, accelState: AccelerationState, config: AccelerationConfig, deltaTime: number): {
+        state: VehiclePathState;
+        execution: PathExecution;
+        accelState: AccelerationState;
+        arrived: boolean;
+    };
 }

package/dist/core/types/geometry.d.ts

@@ -17,6 +17,7 @@ export interface BezierCurve {
     p3: Point;
 }
 export interface Curve {
+    id?: string;
     fromLineId: string;
     toLineId: string;
     fromOffset?: number;

package/dist/core.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./index-BQoeJKCj.cjs");function P(n,e){const a={lines:n,curves:e.map(t=>({id:t.id,fromLineId:t.fromLineId,toLineId:t.toLineId,fromOffset:t.fromOffset,fromIsPercentage:t.fromIsPercentage??!1,toOffset:t.toOffset,toIsPercentage:t.toIsPercentage??!1}))};return JSON.stringify(a,null,2)}function O(n){let e;try{e=JSON.parse(n)}catch{throw new Error("deserializeScene: invalid JSON")}if(!e||typeof e!="object"||Array.isArray(e))throw new Error("deserializeScene: expected a JSON object");const a=e;if(!Array.isArray(a.lines))throw new Error('deserializeScene: missing "lines"');if(!Array.isArray(a.curves))throw new Error('deserializeScene: missing "curves"');return{lines:a.lines,curves:a.curves}}function h(n){const e=n.axleExecutions[n.axleExecutions.length-1],a=i.getCumulativeArcLength(n.path,e.segmentIndex,e.segmentDistance);return Math.max(0,n.path.totalDistance-a)}function d(n){const e=n.axleExecutions[0],a=i.getCumulativeArcLength(n.path,e.segmentIndex,e.segmentDistance);let t=0;for(let r=0;r<n.path.segments.length;r++){const o=n.path.segments[r];if(r>=e.segmentIndex&&o.type==="curve")return Math.max(0,t-a);t+=o.length}return null}function p(n,e,a){let t=a.maxSpeed;const r=Math.sqrt(2*a.deceleration*Math.max(0,n));if(t=Math.min(t,r),e!==null){const o=Math.sqrt(a.minCurveSpeed**2+2*a.deceleration*e);t=Math.min(t,o)}return Math.max(0,t)}function x(n,e,a,t,r){return n<e?Math.min(e,n+a*r):n>e?Math.max(e,n-t*r):n}function S(n,e,a,t,r,o){const c=h(e),l=d(e),f=p(c,l,t),g=x(a.currentSpeed,f,t.acceleration,t.deceleration,r),u=g*r,v=n.axles.map(s=>({lineId:s.lineId,position:s.position,absoluteOffset:s.offset})),L=e.axleExecutions.map(s=>({currentSegmentIndex:s.segmentIndex,segmentDistance:s.segmentDistance})),m=i.moveVehicle(v,L,e.path,u,o,e.curveDataMap);return{state:{axles:m.axles.map(s=>({lineId:s.lineId,offset:s.absoluteOffset,position:s.position})),axleSpacings:n.axleSpacings},execution:{...e,axleExecutions:m.axleExecutions.map(s=>({segmentIndex:s.currentSegmentIndex,segmentDistance:s.segmentDistance}))},accelState:{currentSpeed:g},arrived:m.arrived}}function A(n,e){const a=e.end.x-e.start.x,t=e.end.y-e.start.y,r=a*a+t*t;if(r===0)return{offset:0,distance:Math.sqrt((n.x-e.start.x)**2+(n.y-e.start.y)**2)};const o=Math.max(0,Math.min(1,((n.x-e.start.x)*a+(n.y-e.start.y)*t)/r)),c=e.start.x+o*a,l=e.start.y+o*t,f=Math.sqrt((n.x-c)**2+(n.y-l)**2);return{offset:o*Math.sqrt(r),distance:f}}function I(n,e){const a=i.getLineLength(n),t=e.reduce((o,c)=>o+c,0);return[0,Math.max(0,a-t)]}function M(n,e){let a=0;for(const t of e)t.fromLineId===n&&!t.fromIsPercentage&&t.fromOffset!==void 0&&(a=Math.max(a,t.fromOffset)),t.toLineId===n&&!t.toIsPercentage&&t.toOffset!==void 0&&(a=Math.max(a,t.toOffset));return a}exports.PathEngine=i.PathEngine;exports.arcLengthToSegmentPosition=i.arcLengthToSegmentPosition;exports.buildArcLengthTable=i.buildArcLengthTable;exports.buildGraph=i.buildGraph;exports.calculateBezierArcLength=i.calculateBezierArcLength;exports.calculateFrontAxlePosition=i.calculateFrontAxlePosition;exports.calculateInitialAxlePositions=i.calculateInitialAxlePositions;exports.calculatePositionOnCurve=i.calculatePositionOnCurve;exports.calculatePositionOnLine=i.calculatePositionOnLine;exports.calculateTangentLength=i.calculateTangentLength;exports.createBezierCurve=i.createBezierCurve;exports.createInitialMovementState=i.createInitialMovementState;exports.distance=i.distance;exports.distanceToT=i.distanceToT;exports.findPath=i.findPath;exports.getArcLength=i.getArcLength;exports.getCumulativeArcLength=i.getCumulativeArcLength;exports.getLineLength=i.getLineLength;exports.getPointOnBezier=i.getPointOnBezier;exports.getPointOnLine=i.getPointOnLine;exports.getPointOnLineByOffset=i.getPointOnLineByOffset;exports.getPositionFromOffset=i.getPositionFromOffset;exports.handleArrival=i.handleArrival;exports.initializeAllVehicles=i.initializeAllVehicles;exports.initializeMovingVehicle=i.initializeMovingVehicle;exports.isPointNearPoint=i.isPointNearPoint;exports.moveVehicle=i.moveVehicle;exports.normalize=i.normalize;exports.prepareCommandPath=i.prepareCommandPath;exports.resolveFromLineOffset=i.resolveFromLineOffset;exports.resolveToLineOffset=i.resolveToLineOffset;exports.updateAxlePosition=i.updateAxlePosition;exports.approachSpeed=x;exports.computeDistToNextCurve=d;exports.computeMinLineLength=M;exports.computeRemainingToArrival=h;exports.computeTargetSpeed=p;exports.deserializeScene=O;exports.getValidRearOffsetRange=I;exports.moveVehicleWithAcceleration=S;exports.projectPointOnLine=A;exports.serializeScene=P;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index-BpTZXV22.cjs");function f(r,i){const n={lines:r,curves:i.map(t=>({id:t.id,fromLineId:t.fromLineId,toLineId:t.toLineId,fromOffset:t.fromOffset,fromIsPercentage:t.fromIsPercentage??!1,toOffset:t.toOffset,toIsPercentage:t.toIsPercentage??!1}))};return JSON.stringify(n,null,2)}function g(r){let i;try{i=JSON.parse(r)}catch{throw new Error("deserializeScene: invalid JSON")}if(!i||typeof i!="object"||Array.isArray(i))throw new Error("deserializeScene: expected a JSON object");const n=i;if(!Array.isArray(n.lines))throw new Error('deserializeScene: missing "lines"');if(!Array.isArray(n.curves))throw new Error('deserializeScene: missing "curves"');return{lines:n.lines,curves:n.curves}}function u(r,i){const n=i.end.x-i.start.x,t=i.end.y-i.start.y,a=n*n+t*t;if(a===0)return{offset:0,distance:Math.sqrt((r.x-i.start.x)**2+(r.y-i.start.y)**2)};const o=Math.max(0,Math.min(1,((r.x-i.start.x)*n+(r.y-i.start.y)*t)/a)),s=i.start.x+o*n,c=i.start.y+o*t,l=Math.sqrt((r.x-s)**2+(r.y-c)**2);return{offset:o*Math.sqrt(a),distance:l}}function h(r,i){const n=e.getLineLength(r),t=i.reduce((o,s)=>o+s,0);return[0,Math.max(0,n-t)]}function m(r,i){let n=0;for(const t of i)t.fromLineId===r&&!t.fromIsPercentage&&t.fromOffset!==void 0&&(n=Math.max(n,t.fromOffset)),t.toLineId===r&&!t.toIsPercentage&&t.toOffset!==void 0&&(n=Math.max(n,t.toOffset));return n}exports.PathEngine=e.PathEngine;exports.approachSpeed=e.approachSpeed;exports.arcLengthToSegmentPosition=e.arcLengthToSegmentPosition;exports.buildArcLengthTable=e.buildArcLengthTable;exports.buildGraph=e.buildGraph;exports.calculateBezierArcLength=e.calculateBezierArcLength;exports.calculateFrontAxlePosition=e.calculateFrontAxlePosition;exports.calculateInitialAxlePositions=e.calculateInitialAxlePositions;exports.calculatePositionOnCurve=e.calculatePositionOnCurve;exports.calculatePositionOnLine=e.calculatePositionOnLine;exports.calculateTangentLength=e.calculateTangentLength;exports.computeDistToNextCurve=e.computeDistToNextCurve;exports.computeRemainingToArrival=e.computeRemainingToArrival;exports.computeTargetSpeed=e.computeTargetSpeed;exports.createBezierCurve=e.createBezierCurve;exports.createInitialMovementState=e.createInitialMovementState;exports.distance=e.distance;exports.distanceToT=e.distanceToT;exports.findPath=e.findPath;exports.getArcLength=e.getArcLength;exports.getCumulativeArcLength=e.getCumulativeArcLength;exports.getLineLength=e.getLineLength;exports.getPointOnBezier=e.getPointOnBezier;exports.getPointOnLine=e.getPointOnLine;exports.getPointOnLineByOffset=e.getPointOnLineByOffset;exports.getPositionFromOffset=e.getPositionFromOffset;exports.handleArrival=e.handleArrival;exports.initializeAllVehicles=e.initializeAllVehicles;exports.initializeMovingVehicle=e.initializeMovingVehicle;exports.isPointNearPoint=e.isPointNearPoint;exports.moveVehicle=e.moveVehicle;exports.moveVehicleWithAcceleration=e.moveVehicleWithAcceleration;exports.normalize=e.normalize;exports.prepareCommandPath=e.prepareCommandPath;exports.resolveFromLineOffset=e.resolveFromLineOffset;exports.resolveToLineOffset=e.resolveToLineOffset;exports.updateAxlePosition=e.updateAxlePosition;exports.computeMinLineLength=m;exports.deserializeScene=g;exports.getValidRearOffsetRange=h;exports.projectPointOnLine=u;exports.serializeScene=f;

package/dist/core.js

@@ -1,30 +1,30 @@
-import { g as u, m as x, a as p } from "./index-DUYG8fxI.js";
-import { P as T, b, c as j, d as q, e as C, f as N, h as B, i as V, j as J, k as F, l as R, n as k, o as G, p as W, q as X, r as Y, s as H, t as K, u as Q, v as U, w as Z, x as _, y as $, z as ee, A as te, B as ne, C as ae, D as se, E as re } from "./index-DUYG8fxI.js";
-function P(n, e) {
+import { g as f } from "./index-BObuJxsC.js";
+import { P as v, a as p, b as y, c as A, d as S, e as I, f as z, h as M, i as w, j as T, k as b, l as j, m as C, n as E, o as N, p as q, q as B, r as J, s as V, t as F, u as R, v as D, w as G, x as k, y as H, z as W, A as X, B as Y, C as K, D as Q, E as U, F as Z, G as _, H as $, I as ee, J as te } from "./index-BObuJxsC.js";
+function d(s, t) {
   const a = {
-    lines: n,
-    curves: e.map((t) => ({
-      id: t.id,
-      fromLineId: t.fromLineId,
-      toLineId: t.toLineId,
-      fromOffset: t.fromOffset,
-      fromIsPercentage: t.fromIsPercentage ?? !1,
-      toOffset: t.toOffset,
-      toIsPercentage: t.toIsPercentage ?? !1
+    lines: s,
+    curves: t.map((e) => ({
+      id: e.id,
+      fromLineId: e.fromLineId,
+      toLineId: e.toLineId,
+      fromOffset: e.fromOffset,
+      fromIsPercentage: e.fromIsPercentage ?? !1,
+      toOffset: e.toOffset,
+      toIsPercentage: e.toIsPercentage ?? !1
     }))
   };
   return JSON.stringify(a, null, 2);
 }
-function M(n) {
-  let e;
+function g(s) {
+  let t;
   try {
-    e = JSON.parse(n);
+    t = JSON.parse(s);
   } catch {
     throw new Error("deserializeScene: invalid JSON");
   }
-  if (!e || typeof e != "object" || Array.isArray(e))
+  if (!t || typeof t != "object" || Array.isArray(t))
     throw new Error("deserializeScene: expected a JSON object");
-  const a = e;
+  const a = t;
   if (!Array.isArray(a.lines)) throw new Error('deserializeScene: missing "lines"');
   if (!Array.isArray(a.curves)) throw new Error('deserializeScene: missing "curves"');
   return {
@@ -32,140 +32,72 @@ function M(n) {
     curves: a.curves
   };
 }
-function v(n) {
-  const e = n.axleExecutions[n.axleExecutions.length - 1], a = u(
-    n.path,
-    e.segmentIndex,
-    e.segmentDistance
-  );
-  return Math.max(0, n.path.totalDistance - a);
-}
-function S(n) {
-  const e = n.axleExecutions[0], a = u(
-    n.path,
-    e.segmentIndex,
-    e.segmentDistance
-  );
-  let t = 0;
-  for (let s = 0; s < n.path.segments.length; s++) {
-    const i = n.path.segments[s];
-    if (s >= e.segmentIndex && i.type === "curve")
-      return Math.max(0, t - a);
-    t += i.length;
-  }
-  return null;
-}
-function L(n, e, a) {
-  let t = a.maxSpeed;
-  const s = Math.sqrt(2 * a.deceleration * Math.max(0, n));
-  if (t = Math.min(t, s), e !== null) {
-    const i = Math.sqrt(
-      a.minCurveSpeed ** 2 + 2 * a.deceleration * e
-    );
-    t = Math.min(t, i);
-  }
-  return Math.max(0, t);
-}
-function O(n, e, a, t, s) {
-  return n < e ? Math.min(e, n + a * s) : n > e ? Math.max(e, n - t * s) : n;
-}
-function y(n, e, a, t, s, i) {
-  const o = v(e), c = S(e), l = L(o, c, t), f = O(
-    a.currentSpeed,
-    l,
-    t.acceleration,
-    t.deceleration,
-    s
-  ), d = f * s, h = n.axles.map((r) => ({
-    lineId: r.lineId,
-    position: r.position,
-    absoluteOffset: r.offset
-  })), g = e.axleExecutions.map((r) => ({
-    currentSegmentIndex: r.segmentIndex,
-    segmentDistance: r.segmentDistance
-  })), m = x(h, g, e.path, d, i, e.curveDataMap);
-  return {
-    state: {
-      axles: m.axles.map((r) => ({ lineId: r.lineId, offset: r.absoluteOffset, position: r.position })),
-      axleSpacings: n.axleSpacings
-    },
-    execution: {
-      ...e,
-      axleExecutions: m.axleExecutions.map((r) => ({
-        segmentIndex: r.currentSegmentIndex,
-        segmentDistance: r.segmentDistance
-      }))
-    },
-    accelState: { currentSpeed: f },
-    arrived: m.arrived
-  };
-}
-function A(n, e) {
-  const a = e.end.x - e.start.x, t = e.end.y - e.start.y, s = a * a + t * t;
-  if (s === 0)
+function h(s, t) {
+  const a = t.end.x - t.start.x, e = t.end.y - t.start.y, n = a * a + e * e;
+  if (n === 0)
     return { offset: 0, distance: Math.sqrt(
-      (n.x - e.start.x) ** 2 + (n.y - e.start.y) ** 2
+      (s.x - t.start.x) ** 2 + (s.y - t.start.y) ** 2
     ) };
-  const i = Math.max(
+  const r = Math.max(
     0,
     Math.min(
       1,
-      ((n.x - e.start.x) * a + (n.y - e.start.y) * t) / s
+      ((s.x - t.start.x) * a + (s.y - t.start.y) * e) / n
     )
-  ), o = e.start.x + i * a, c = e.start.y + i * t, l = Math.sqrt((n.x - o) ** 2 + (n.y - c) ** 2);
-  return { offset: i * Math.sqrt(s), distance: l };
+  ), i = t.start.x + r * a, o = t.start.y + r * e, c = Math.sqrt((s.x - i) ** 2 + (s.y - o) ** 2);
+  return { offset: r * Math.sqrt(n), distance: c };
 }
-function E(n, e) {
-  const a = p(n), t = e.reduce((i, o) => i + o, 0);
-  return [0, Math.max(0, a - t)];
+function x(s, t) {
+  const a = f(s), e = t.reduce((r, i) => r + i, 0);
+  return [0, Math.max(0, a - e)];
 }
-function z(n, e) {
+function L(s, t) {
   let a = 0;
-  for (const t of e)
-    t.fromLineId === n && !t.fromIsPercentage && t.fromOffset !== void 0 && (a = Math.max(a, t.fromOffset)), t.toLineId === n && !t.toIsPercentage && t.toOffset !== void 0 && (a = Math.max(a, t.toOffset));
+  for (const e of t)
+    e.fromLineId === s && !e.fromIsPercentage && e.fromOffset !== void 0 && (a = Math.max(a, e.fromOffset)), e.toLineId === s && !e.toIsPercentage && e.toOffset !== void 0 && (a = Math.max(a, e.toOffset));
   return a;
 }
 export {
-  T as PathEngine,
-  O as approachSpeed,
-  b as arcLengthToSegmentPosition,
-  j as buildArcLengthTable,
-  q as buildGraph,
-  C as calculateBezierArcLength,
-  N as calculateFrontAxlePosition,
-  B as calculateInitialAxlePositions,
-  V as calculatePositionOnCurve,
-  J as calculatePositionOnLine,
-  F as calculateTangentLength,
-  S as computeDistToNextCurve,
-  z as computeMinLineLength,
-  v as computeRemainingToArrival,
-  L as computeTargetSpeed,
-  R as createBezierCurve,
-  k as createInitialMovementState,
-  M as deserializeScene,
-  G as distance,
-  W as distanceToT,
-  X as findPath,
-  Y as getArcLength,
-  u as getCumulativeArcLength,
-  p as getLineLength,
-  H as getPointOnBezier,
-  K as getPointOnLine,
-  Q as getPointOnLineByOffset,
-  U as getPositionFromOffset,
-  E as getValidRearOffsetRange,
-  Z as handleArrival,
-  _ as initializeAllVehicles,
-  $ as initializeMovingVehicle,
-  ee as isPointNearPoint,
-  x as moveVehicle,
-  y as moveVehicleWithAcceleration,
-  te as normalize,
-  ne as prepareCommandPath,
-  A as projectPointOnLine,
-  ae as resolveFromLineOffset,
-  se as resolveToLineOffset,
-  P as serializeScene,
-  re as updateAxlePosition
+  v as PathEngine,
+  p as approachSpeed,
+  y as arcLengthToSegmentPosition,
+  A as buildArcLengthTable,
+  S as buildGraph,
+  I as calculateBezierArcLength,
+  z as calculateFrontAxlePosition,
+  M as calculateInitialAxlePositions,
+  w as calculatePositionOnCurve,
+  T as calculatePositionOnLine,
+  b as calculateTangentLength,
+  j as computeDistToNextCurve,
+  L as computeMinLineLength,
+  C as computeRemainingToArrival,
+  E as computeTargetSpeed,
+  N as createBezierCurve,
+  q as createInitialMovementState,
+  g as deserializeScene,
+  B as distance,
+  J as distanceToT,
+  V as findPath,
+  F as getArcLength,
+  R as getCumulativeArcLength,
+  f as getLineLength,
+  D as getPointOnBezier,
+  G as getPointOnLine,
+  k as getPointOnLineByOffset,
+  H as getPositionFromOffset,
+  x as getValidRearOffsetRange,
+  W as handleArrival,
+  X as initializeAllVehicles,
+  Y as initializeMovingVehicle,
+  K as isPointNearPoint,
+  Q as moveVehicle,
+  U as moveVehicleWithAcceleration,
+  Z as normalize,
+  _ as prepareCommandPath,
+  h as projectPointOnLine,
+  $ as resolveFromLineOffset,
+  ee as resolveToLineOffset,
+  d as serializeScene,
+  te as updateAxlePosition
 };