vehicle-path2 1.0.11 → 1.0.13

package/dist/core.js

@@ -1,274 +1,274 @@
-function y(e, t) {
-  const s = t.x - e.x, n = t.y - e.y;
+function y(t, e) {
+  const s = e.x - t.x, n = e.y - t.y;
   return Math.sqrt(s * s + n * n);
 }
-function w(e, t) {
-  const s = t.x - e.x, n = t.y - e.y, o = Math.sqrt(s * s + n * n);
+function P(t, e) {
+  const s = e.x - t.x, n = e.y - t.y, o = Math.sqrt(s * s + n * n);
   return o === 0 ? { x: 0, y: 0 } : { x: s / o, y: n / o };
 }
-function K(e, t) {
-  return t * (e === "proportional-40" ? 0.4 : 0.5522);
+function K(t, e) {
+  return e * (t === "proportional-40" ? 0.4 : 0.5522);
 }
-function A(e, t, s, n = !1, o) {
-  const { wheelbase: c, tangentMode: i } = s;
-  let r;
-  o?.fromOffset !== void 0 ? r = T(e, o.fromOffset, o.fromIsPercentage ?? !1) : r = e.end;
-  let u;
-  o?.toOffset !== void 0 ? u = T(t, o.toOffset, o.toIsPercentage ?? !1) : u = t.start;
-  const l = w(e.start, e.end), a = n ? {
+function A(t, e, s, n = !1, o) {
+  const { wheelbase: i, tangentMode: r } = s;
+  let c;
+  o?.fromOffset !== void 0 ? c = D(t, o.fromOffset, o.fromIsPercentage ?? !1) : c = t.end;
+  let a;
+  o?.toOffset !== void 0 ? a = D(e, o.toOffset, o.toIsPercentage ?? !1) : a = e.start;
+  const l = P(t.start, t.end), u = n ? {
     // Transition with flip: kurva dimulai dari P (baseP0 - wheelbase in line direction)
-    x: r.x - l.x * c,
-    y: r.y - l.y * c
-  } : r, d = w(e.start, e.end), g = w(t.start, t.end), I = y(a, u), m = K(i, I), f = n ? { x: a.x - d.x * m, y: a.y - d.y * m } : { x: a.x + d.x * m, y: a.y + d.y * m }, v = {
-    x: u.x - g.x * m,
-    y: u.y - g.y * m
+    x: c.x - l.x * i,
+    y: c.y - l.y * i
+  } : c, g = P(t.start, t.end), d = P(e.start, e.end), v = y(u, a), h = K(r, v), f = n ? { x: u.x - g.x * h, y: u.y - g.y * h } : { x: u.x + g.x * h, y: u.y + g.y * h }, x = {
+    x: a.x - d.x * h,
+    y: a.y - d.y * h
   };
-  return { p0: a, p1: f, p2: v, p3: u };
+  return { p0: u, p1: f, p2: x, p3: a };
 }
-function k(e, t) {
+function R(t, e) {
   return {
-    x: e.start.x + (e.end.x - e.start.x) * t,
-    y: e.start.y + (e.end.y - e.start.y) * t
+    x: t.start.x + (t.end.x - t.start.x) * e,
+    y: t.start.y + (t.end.y - t.start.y) * e
   };
 }
-function T(e, t, s) {
-  const n = y(e.start, e.end);
+function D(t, e, s) {
+  const n = y(t.start, t.end);
   let o;
-  return s ? o = t : o = n > 0 ? t / n : 0, o = Math.max(0, Math.min(1, o)), k(e, o);
+  return s ? o = e : o = n > 0 ? e / n : 0, o = Math.max(0, Math.min(1, o)), R(t, o);
 }
-function D(e, t) {
-  const { p0: s, p1: n, p2: o, p3: c } = e, i = 1 - t, r = i * i, u = r * i, l = t * t, a = l * t;
+function w(t, e) {
+  const { p0: s, p1: n, p2: o, p3: i } = t, r = 1 - e, c = r * r, a = c * r, l = e * e, u = l * e;
   return {
-    x: u * s.x + 3 * r * t * n.x + 3 * i * l * o.x + a * c.x,
-    y: u * s.y + 3 * r * t * n.y + 3 * i * l * o.y + a * c.y
+    x: a * s.x + 3 * c * e * n.x + 3 * r * l * o.x + u * i.x,
+    y: a * s.y + 3 * c * e * n.y + 3 * r * l * o.y + u * i.y
   };
 }
-function Y(e, t, s = 10) {
-  return y(e, t) <= s;
+function Y(t, e, s = 10) {
+  return y(t, e) <= s;
 }
-function N(e, t = 100) {
+function N(t, e = 100) {
   const s = [{ t: 0, distance: 0 }];
-  let n = e.p0, o = 0;
-  for (let c = 1; c <= t; c++) {
-    const i = c / t, r = D(e, i);
-    o += y(n, r), s.push({ t: i, distance: o }), n = r;
+  let n = t.p0, o = 0;
+  for (let i = 1; i <= e; i++) {
+    const r = i / e, c = w(t, r);
+    o += y(n, c), s.push({ t: r, distance: o }), n = c;
   }
   return s;
 }
-function $(e, t) {
-  if (t <= 0) return 0;
-  const s = e[e.length - 1].distance;
-  if (t >= s) return 1;
-  let n = 0, o = e.length - 1;
+function $(t, e) {
+  if (e <= 0) return 0;
+  const s = t[t.length - 1].distance;
+  if (e >= s) return 1;
+  let n = 0, o = t.length - 1;
   for (; n < o - 1; ) {
-    const a = Math.floor((n + o) / 2);
-    e[a].distance < t ? n = a : o = a;
+    const u = Math.floor((n + o) / 2);
+    t[u].distance < e ? n = u : o = u;
   }
-  const c = e[n].distance, i = e[o].distance, r = e[n].t, u = e[o].t;
-  if (i === c) return r;
-  const l = (t - c) / (i - c);
-  return r + l * (u - r);
-}
-function Z(e) {
-  return e[e.length - 1].distance;
-}
-function G(e, t = 100) {
-  let s = 0, n = e.p0;
-  for (let o = 1; o <= t; o++) {
-    const c = o / t, i = D(e, c);
-    s += y(n, i), n = i;
+  const i = t[n].distance, r = t[o].distance, c = t[n].t, a = t[o].t;
+  if (r === i) return c;
+  const l = (e - i) / (r - i);
+  return c + l * (a - c);
+}
+function Z(t) {
+  return t[t.length - 1].distance;
+}
+function G(t, e = 100) {
+  let s = 0, n = t.p0;
+  for (let o = 1; o <= e; o++) {
+    const i = o / e, r = w(t, i);
+    s += y(n, r), n = r;
   }
   return s;
 }
-function V(e, t, s, n, o) {
-  const c = y(e.start, e.end), i = c - o;
-  if (i <= 0)
-    return c;
-  let r;
-  if (t === void 0)
-    r = n;
+function q(t, e, s, n, o) {
+  const i = y(t.start, t.end), r = i - o;
+  if (r <= 0)
+    return i;
+  let c;
+  if (e === void 0)
+    c = n;
   else if (s)
-    r = t;
+    c = e;
   else {
-    const u = Math.max(0, Math.min(t, i));
-    return o + u;
+    const a = Math.max(0, Math.min(e, r));
+    return o + a;
   }
-  return o + r * i;
+  return o + c * r;
 }
-function q(e, t, s, n, o) {
-  const i = y(e.start, e.end) - o;
-  if (i <= 0)
+function z(t, e, s, n, o) {
+  const r = y(t.start, t.end) - o;
+  if (r <= 0)
     return 0;
-  let r;
-  if (t === void 0)
-    r = n;
+  let c;
+  if (e === void 0)
+    c = n;
   else if (s)
-    r = t;
+    c = e;
   else
-    return Math.max(0, Math.min(t, i));
-  return r * i;
-}
-function ee(e, t, s) {
-  const n = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
-  for (const i of e)
-    o.set(i.id, i), c.set(i.id, y(i.start, i.end)), n.set(i.id, []);
-  for (let i = 0; i < t.length; i++) {
-    const r = t[i], u = o.get(r.fromLineId), l = o.get(r.toLineId);
-    if (!u || !l) continue;
-    const a = V(u, r.fromOffset, r.fromIsPercentage, 1, s.wheelbase), d = q(l, r.toOffset, r.toIsPercentage, 0, s.wheelbase), g = A(
-      u,
+    return Math.max(0, Math.min(e, r));
+  return c * r;
+}
+function tt(t, e, s) {
+  const n = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+  for (const r of t)
+    o.set(r.id, r), i.set(r.id, y(r.start, r.end)), n.set(r.id, []);
+  for (let r = 0; r < e.length; r++) {
+    const c = e[r], a = o.get(c.fromLineId), l = o.get(c.toLineId);
+    if (!a || !l) continue;
+    const u = q(a, c.fromOffset, c.fromIsPercentage, 1, s.wheelbase), g = z(l, c.toOffset, c.toIsPercentage, 0, s.wheelbase), d = A(
+      a,
       l,
       s,
       !1,
       // willFlip is always false now
       {
-        fromOffset: a,
+        fromOffset: u,
         fromIsPercentage: !1,
         // Already resolved to absolute
-        toOffset: d,
+        toOffset: g,
         toIsPercentage: !1
         // Already resolved to absolute
       }
-    ), I = G(g), m = {
-      curveIndex: i,
-      fromLineId: r.fromLineId,
-      toLineId: r.toLineId,
-      fromOffset: a,
-      toOffset: d,
-      curveLength: I
+    ), v = G(d), h = {
+      curveIndex: r,
+      fromLineId: c.fromLineId,
+      toLineId: c.toLineId,
+      fromOffset: u,
+      toOffset: g,
+      curveLength: v
     };
-    n.get(r.fromLineId).push(m);
+    n.get(c.fromLineId).push(h);
   }
-  return { adjacency: n, lines: o, lineLengths: c };
+  return { adjacency: n, lines: o, lineLengths: i };
 }
-function b(e, t) {
-  return e.curveCount !== t.curveCount ? e.curveCount - t.curveCount : e.totalDistance - t.totalDistance;
+function T(t, e) {
+  return t.curveCount !== e.curveCount ? t.curveCount - e.curveCount : t.totalDistance - e.totalDistance;
 }
-function Q(e, t, s, n, o = !1) {
-  const { adjacency: c, lines: i, lineLengths: r } = e;
-  if (!i.get(s)) return null;
-  const l = r.get(s), a = o ? n / 100 * l : n, d = [], g = /* @__PURE__ */ new Map(), I = (f, v) => `${f}:${Math.round(v)}`;
-  if (t.lineId === s && a >= t.offset) {
-    const f = a - t.offset;
+function Q(t, e, s, n, o = !1) {
+  const { adjacency: i, lines: r, lineLengths: c } = t;
+  if (!r.get(s)) return null;
+  const l = c.get(s), u = o ? n / 100 * l : n, g = [], d = /* @__PURE__ */ new Map(), v = (f, x) => `${f}:${Math.round(x)}`;
+  if (e.lineId === s && u >= e.offset) {
+    const f = u - e.offset;
     return {
       segments: [{
         type: "line",
-        lineId: t.lineId,
-        startOffset: t.offset,
-        endOffset: a,
+        lineId: e.lineId,
+        startOffset: e.offset,
+        endOffset: u,
         length: f
       }],
       totalDistance: f,
       curveCount: 0
     };
   }
-  const m = c.get(t.lineId) || [];
-  for (const f of m) {
-    if (f.fromOffset < t.offset) continue;
-    const v = f.fromOffset - t.offset, p = v + f.curveLength, x = {
+  const h = i.get(e.lineId) || [];
+  for (const f of h) {
+    if (f.fromOffset < e.offset) continue;
+    const x = f.fromOffset - e.offset, I = x + f.curveLength, p = {
       type: "line",
-      lineId: t.lineId,
-      startOffset: t.offset,
+      lineId: e.lineId,
+      startOffset: e.offset,
       endOffset: f.fromOffset,
-      length: v
-    }, h = {
+      length: x
+    }, m = {
       type: "curve",
       curveIndex: f.curveIndex,
       startOffset: 0,
       endOffset: f.curveLength,
       length: f.curveLength
     };
-    d.push({
+    g.push({
       lineId: f.toLineId,
       entryOffset: f.toOffset,
-      totalDistance: p,
+      totalDistance: I,
       curveCount: 1,
-      path: [x, h]
+      path: [p, m]
     });
   }
-  for (d.sort(b); d.length > 0; ) {
-    const f = d.shift(), v = I(f.lineId, f.entryOffset), p = g.get(v);
-    if (p !== void 0 && (p.curveCount < f.curveCount || p.curveCount === f.curveCount && p.distance <= f.totalDistance))
+  for (g.sort(T); g.length > 0; ) {
+    const f = g.shift(), x = v(f.lineId, f.entryOffset), I = d.get(x);
+    if (I !== void 0 && (I.curveCount < f.curveCount || I.curveCount === f.curveCount && I.distance <= f.totalDistance))
       continue;
-    if (g.set(v, { curveCount: f.curveCount, distance: f.totalDistance }), f.lineId === s) {
-      const h = Math.abs(a - f.entryOffset);
-      if (a >= f.entryOffset) {
-        const O = {
+    if (d.set(x, { curveCount: f.curveCount, distance: f.totalDistance }), f.lineId === s) {
+      const m = Math.abs(u - f.entryOffset);
+      if (u >= f.entryOffset) {
+        const L = {
           type: "line",
           lineId: s,
           startOffset: f.entryOffset,
-          endOffset: a,
-          length: h
+          endOffset: u,
+          length: m
         };
         return {
-          segments: [...f.path, O],
-          totalDistance: f.totalDistance + h,
+          segments: [...f.path, L],
+          totalDistance: f.totalDistance + m,
           curveCount: f.curveCount
         };
       }
     }
-    const x = c.get(f.lineId) || [];
-    for (const h of x) {
-      if (h.fromOffset < f.entryOffset) continue;
-      const O = h.fromOffset - f.entryOffset, S = f.totalDistance + O + h.curveLength, M = f.curveCount + 1, B = I(h.toLineId, h.toOffset), C = g.get(B);
-      if (C !== void 0 && (C.curveCount < M || C.curveCount === M && C.distance <= S))
+    const p = i.get(f.lineId) || [];
+    for (const m of p) {
+      if (m.fromOffset < f.entryOffset) continue;
+      const L = m.fromOffset - f.entryOffset, S = f.totalDistance + L + m.curveLength, C = f.curveCount + 1, B = v(m.toLineId, m.toOffset), M = d.get(B);
+      if (M !== void 0 && (M.curveCount < C || M.curveCount === C && M.distance <= S))
         continue;
       const j = {
         type: "line",
         lineId: f.lineId,
         startOffset: f.entryOffset,
-        endOffset: h.fromOffset,
-        length: O
-      }, F = {
+        endOffset: m.fromOffset,
+        length: L
+      }, k = {
         type: "curve",
-        curveIndex: h.curveIndex,
+        curveIndex: m.curveIndex,
         startOffset: 0,
-        endOffset: h.curveLength,
-        length: h.curveLength
+        endOffset: m.curveLength,
+        length: m.curveLength
       };
-      d.push({
-        lineId: h.toLineId,
-        entryOffset: h.toOffset,
+      g.push({
+        lineId: m.toLineId,
+        entryOffset: m.toOffset,
         totalDistance: S,
-        curveCount: M,
-        path: [...f.path, j, F]
+        curveCount: C,
+        path: [...f.path, j, k]
       });
     }
-    d.sort(b);
+    g.sort(T);
   }
   return null;
 }
-function z(e, t) {
+function V(t, e) {
   const s = Math.sqrt(
-    Math.pow(e.end.x - e.start.x, 2) + Math.pow(e.end.y - e.start.y, 2)
-  ), n = s > 0 ? t / s : 0;
+    Math.pow(t.end.x - t.start.x, 2) + Math.pow(t.end.y - t.start.y, 2)
+  ), n = s > 0 ? e / s : 0;
   return {
-    x: e.start.x + (e.end.x - e.start.x) * Math.min(1, Math.max(0, n)),
-    y: e.start.y + (e.end.y - e.start.y) * Math.min(1, Math.max(0, n))
+    x: t.start.x + (t.end.x - t.start.x) * Math.min(1, Math.max(0, n)),
+    y: t.start.y + (t.end.y - t.start.y) * Math.min(1, Math.max(0, n))
   };
 }
-function R(e) {
+function F(t) {
   return Math.sqrt(
-    Math.pow(e.end.x - e.start.x, 2) + Math.pow(e.end.y - e.start.y, 2)
+    Math.pow(t.end.x - t.start.x, 2) + Math.pow(t.end.y - t.start.y, 2)
   );
 }
-function W(e, t, s) {
+function W(t, e, s) {
   let n = 0;
-  for (let o = 0; o < t; o++)
-    n += e.segments[o].length;
+  for (let o = 0; o < e; o++)
+    n += t.segments[o].length;
   return n += s, n;
 }
-function _(e, t) {
+function _(t, e) {
   let s = 0;
-  for (let n = 0; n < e.segments.length; n++) {
-    const o = e.segments[n], c = s + o.length;
-    if (t < c)
+  for (let n = 0; n < t.segments.length; n++) {
+    const o = t.segments[n], i = s + o.length;
+    if (e < i)
       return {
         segmentIndex: n,
-        segmentDistance: t - s
+        segmentDistance: e - s
       };
-    if (t === c)
-      return n + 1 < e.segments.length ? {
+    if (e === i)
+      return n + 1 < t.segments.length ? {
         segmentIndex: n + 1,
         segmentDistance: 0
       } : {
@@ -279,145 +279,182 @@ function _(e, t) {
   }
   return null;
 }
-function E(e, t, s, n) {
-  const c = W(
-    e,
+function et(t, e, s, n) {
+  const i = W(
     t,
+    e,
     s
   ) + n;
-  return _(e, c);
+  return _(t, i);
 }
-function te(e, t, s, n) {
+function nt(t, e, s, n) {
   const o = Math.sqrt(
     Math.pow(n.end.x - n.start.x, 2) + Math.pow(n.end.y - n.start.y, 2)
   );
-  let c = t + s;
-  c = Math.min(c, o);
-  const i = z(n, c);
+  let i = e + s;
+  i = Math.min(i, o);
+  const r = V(n, i);
   return {
-    lineId: e,
-    position: i,
-    absoluteOffset: c
+    lineId: t,
+    position: r,
+    absoluteOffset: i
   };
 }
-function H(e, t) {
+function H(t, e) {
   return {
-    ...e,
+    ...t,
     state: "idle"
   };
 }
-function J(e) {
+function J(t) {
   return {
-    vehicle: e,
+    vehicle: t,
     execution: null
   };
 }
-function ne(e, t) {
+function ot(t, e) {
   const s = [], n = /* @__PURE__ */ new Map();
-  for (const o of e) {
-    if (!t.get(o.lineId)) continue;
-    const i = H(o);
-    s.push(i);
-    const r = J(i);
-    n.set(o.id, r);
+  for (const o of t) {
+    if (!e.get(o.lineId)) continue;
+    const r = H(o);
+    s.push(r);
+    const c = J(r);
+    n.set(o.id, c);
   }
   return { movingVehicles: s, stateMap: n };
 }
-function L(e, t) {
-  return { position: z(e, t), lineId: e.id, absoluteOffset: t };
-}
-function P(e, t) {
-  const s = $(e.arcLengthTable, t);
-  return { position: D(e.bezier, s) };
-}
-function oe(e, t, s, n, o, c, i) {
-  const r = s.segments[t.currentSegmentIndex], u = t.segmentDistance + n;
-  if (u >= r.length) {
-    const a = u - r.length, d = t.currentSegmentIndex + 1;
-    if (d >= s.segments.length) {
-      if (i !== void 0 && r.type === "line") {
-        const f = o.get(r.lineId), v = r.startOffset + u;
-        if (v <= i) {
-          const x = L(f, v);
+function O(t, e) {
+  return { position: V(t, e), lineId: t.id, absoluteOffset: e };
+}
+function E(t, e) {
+  const s = $(t.arcLengthTable, e);
+  return { position: w(t.bezier, s) };
+}
+function b(t, e, s, n, o, i, r) {
+  let c = e.currentSegmentIndex, a = e.segmentDistance, l = n;
+  for (; l > 0; ) {
+    const d = s.segments[c], v = d.length - a;
+    if (l < v) {
+      a += l, l = 0;
+      break;
+    }
+    l -= v;
+    const h = c + 1;
+    if (h >= s.segments.length) {
+      if (r !== void 0 && d.type === "line") {
+        const x = d.startOffset + d.length + l;
+        if (x <= r) {
+          const m = o.get(d.lineId), L = O(m, x);
           return {
-            axleState: { ...e, ...x },
-            execution: { ...t, segmentDistance: u },
+            axleState: { ...t, ...L },
+            execution: { currentSegmentIndex: c, segmentDistance: d.length + l },
             completed: !1
           };
         }
-        const p = L(f, i);
+        const I = o.get(d.lineId), p = O(I, r);
         return {
-          axleState: { ...e, ...p },
-          execution: { ...t, segmentDistance: i - r.startOffset },
+          axleState: { ...t, ...p },
+          execution: { currentSegmentIndex: c, segmentDistance: r - d.startOffset },
           completed: !0
         };
       }
-      const m = r.type === "line" ? L(
-        o.get(r.lineId),
-        r.endOffset
-      ) : P(
-        c.get(r.curveIndex),
-        r.length
+      const f = d.type === "line" ? O(
+        o.get(d.lineId),
+        d.endOffset
+      ) : E(
+        i.get(d.curveIndex),
+        d.length
       );
       return {
-        axleState: { ...e, ...m },
-        execution: { ...t, segmentDistance: r.length },
+        axleState: { ...t, ...f },
+        execution: { currentSegmentIndex: c, segmentDistance: d.length },
         completed: !0
       };
     }
-    const g = s.segments[d], I = g.type === "line" ? L(
-      o.get(g.lineId),
-      g.startOffset + a
-    ) : P(
-      c.get(g.curveIndex),
-      a
-    );
-    return {
-      axleState: { ...e, ...I },
-      execution: {
-        currentSegmentIndex: d,
-        segmentDistance: a
-      },
-      completed: !1
-    };
+    c = h, a = 0;
   }
-  const l = r.type === "line" ? L(
-    o.get(r.lineId),
-    r.startOffset + u
-  ) : P(
-    c.get(r.curveIndex),
-    u
+  const u = s.segments[c], g = u.type === "line" ? O(
+    o.get(u.lineId),
+    u.startOffset + a
+  ) : E(
+    i.get(u.curveIndex),
+    a
   );
   return {
-    axleState: { ...e, ...l },
-    execution: { ...t, segmentDistance: u },
+    axleState: { ...t, ...g },
+    execution: { currentSegmentIndex: c, segmentDistance: a },
     completed: !1
   };
 }
-function U(e, t, s, n) {
+function st(t, e, s, n, o, i, r, c) {
+  const a = b(
+    t.rear,
+    t.rearExecution,
+    e,
+    s,
+    n,
+    o
+  );
+  let l;
+  const u = t.frontExecution.currentSegmentIndex;
+  if (u < e.segments.length) {
+    const h = e.segments[u];
+    if (h.type === "line") {
+      const f = n.get(h.lineId);
+      f && (l = F(f));
+    }
+  }
+  const g = b(
+    t.front,
+    t.frontExecution,
+    e,
+    s,
+    n,
+    o,
+    l
+  ), d = r - c;
+  if (a.axleState.lineId === i && a.axleState.absoluteOffset >= d - 1e-3) {
+    const h = n.get(i), f = O(h, d), x = O(h, r);
+    return {
+      rear: { ...a.axleState, ...f },
+      front: { ...g.axleState, ...x },
+      rearExecution: a.execution,
+      frontExecution: g.execution,
+      arrived: !0
+    };
+  }
+  return {
+    rear: a.axleState,
+    front: g.axleState,
+    rearExecution: a.execution,
+    frontExecution: g.execution,
+    arrived: !1
+  };
+}
+function U(t, e, s, n) {
   const o = /* @__PURE__ */ new Map();
-  for (const c of e.segments)
-    if (c.type === "curve" && c.curveIndex !== void 0) {
-      const i = t[c.curveIndex];
-      if (i) {
-        const r = s.get(i.fromLineId), u = s.get(i.toLineId);
-        if (r && u) {
-          const l = V(
-            r,
-            i.fromOffset,
-            i.fromIsPercentage,
+  for (const i of t.segments)
+    if (i.type === "curve" && i.curveIndex !== void 0) {
+      const r = e[i.curveIndex];
+      if (r) {
+        const c = s.get(r.fromLineId), a = s.get(r.toLineId);
+        if (c && a) {
+          const l = q(
+            c,
+            r.fromOffset,
+            r.fromIsPercentage,
             1,
             // Default: 100% = 1.0
             n.wheelbase
-          ), a = q(
-            u,
-            i.toOffset,
-            i.toIsPercentage,
+          ), u = z(
+            a,
+            r.toOffset,
+            r.toIsPercentage,
             0,
             n.wheelbase
-          ), d = A(
-            r,
-            u,
+          ), g = A(
+            c,
+            a,
             n,
             !1,
             // willFlip is always false now
@@ -425,117 +462,61 @@ function U(e, t, s, n) {
               fromOffset: l,
               fromIsPercentage: !1,
               // Already resolved to absolute
-              toOffset: a,
+              toOffset: u,
               toIsPercentage: !1
               // Already resolved to absolute
             }
-          ), g = N(d);
-          o.set(c.curveIndex, { bezier: d, arcLengthTable: g });
+          ), d = N(g);
+          o.set(i.curveIndex, { bezier: g, arcLengthTable: d });
         }
       }
     }
   return o;
 }
-function se(e, t, s) {
-  const { graph: n, linesMap: o, curves: c, config: i } = s, r = o.get(t.targetLineId);
-  if (!r) return null;
-  const l = R(r) - i.wheelbase;
+function rt(t, e, s) {
+  const { graph: n, linesMap: o, curves: i, config: r } = s, c = o.get(e.targetLineId);
+  if (!c) return null;
+  const l = F(c) - r.wheelbase;
   if (l <= 0) return null;
-  const a = t.isPercentage ? t.targetOffset * l : Math.min(t.targetOffset, l), d = Q(
+  const u = e.isPercentage ? e.targetOffset * l : Math.min(e.targetOffset, l), g = Q(
     n,
-    { lineId: e.rear.lineId, offset: e.rear.absoluteOffset },
-    t.targetLineId,
-    a,
+    { lineId: t.rear.lineId, offset: t.rear.absoluteOffset },
+    e.targetLineId,
+    u,
     !1
   );
-  if (!d) return null;
-  const g = U(d, c, o, i);
-  return { path: d, curveDataMap: g };
-}
-function re(e, t) {
-  const s = e.execution, n = t.vehicleQueues.get(e.vehicle.id), o = n?.[s.currentCommandIndex];
-  if (o && t.onCommandComplete && t.onCommandComplete({
-    vehicleId: e.vehicle.id,
+  if (!g) return null;
+  const d = U(g, i, o, r);
+  return { path: g, curveDataMap: d };
+}
+function ct(t, e) {
+  const s = t.execution, o = e.vehicleQueues.get(t.vehicle.id)?.[s.currentCommandIndex];
+  return o && e.onCommandComplete && e.onCommandComplete({
+    vehicleId: t.vehicle.id,
     command: o,
     finalPosition: {
-      lineId: e.vehicle.rear.lineId,
-      absoluteOffset: e.vehicle.rear.absoluteOffset,
-      position: e.vehicle.rear.position
+      lineId: t.vehicle.rear.lineId,
+      absoluteOffset: t.vehicle.rear.absoluteOffset,
+      position: t.vehicle.rear.position
     },
     payload: o.payload
-  }), o?.awaitConfirmation)
-    return {
-      handled: !0,
-      vehicle: { ...e.vehicle, state: "waiting" },
-      newExecution: s,
-      // Keep execution state for resume
-      isWaiting: !0
-    };
-  const c = s.currentCommandIndex + 1;
-  if (n && c < n.length) {
-    const r = n[c], u = t.graphRef.current;
-    if (u) {
-      const l = {
-        graph: u,
-        linesMap: t.linesMap,
-        curves: t.curves,
-        config: t.config
-      }, a = t.prepareCommandPath(
-        e.vehicle,
-        r,
-        l
-      );
-      if (a) {
-        const d = E(
-          a.path,
-          0,
-          0,
-          t.config.wheelbase
-        );
-        t.onCommandStart && t.onCommandStart({
-          vehicleId: e.vehicle.id,
-          command: r,
-          commandIndex: c,
-          startPosition: {
-            lineId: e.vehicle.rear.lineId,
-            absoluteOffset: e.vehicle.rear.absoluteOffset,
-            position: e.vehicle.rear.position
-          }
-        });
-        const g = {
-          path: a.path,
-          curveDataMap: a.curveDataMap,
-          currentCommandIndex: c,
-          rear: {
-            currentSegmentIndex: 0,
-            segmentDistance: 0
-          },
-          front: d ? {
-            currentSegmentIndex: d.segmentIndex,
-            segmentDistance: d.segmentDistance
-          } : {
-            currentSegmentIndex: 0,
-            segmentDistance: 0
-          }
-        };
-        return { handled: !0, vehicle: { ...e.vehicle, state: "moving" }, newExecution: g };
-      }
-    }
-  }
-  return { handled: !0, vehicle: {
-    ...e.vehicle,
-    state: "idle"
-  }, newExecution: null };
+  }), {
+    handled: !0,
+    vehicle: { ...t.vehicle, state: "waiting" },
+    newExecution: s,
+    // Keep execution state for resume
+    isWaiting: !0
+  };
 }
 export {
   _ as arcLengthToSegmentPosition,
   N as buildArcLengthTable,
-  ee as buildGraph,
+  tt as buildGraph,
   G as calculateBezierArcLength,
-  E as calculateFrontAxlePosition,
-  te as calculateInitialFrontPosition,
-  P as calculatePositionOnCurve,
-  L as calculatePositionOnLine,
+  et as calculateFrontAxlePosition,
+  nt as calculateInitialFrontPosition,
+  E as calculatePositionOnCurve,
+  O as calculatePositionOnLine,
   K as calculateTangentLength,
   A as createBezierCurve,
   J as createInitialMovementState,
@@ -544,18 +525,19 @@ export {
   Q as findPath,
   Z as getArcLength,
   W as getCumulativeArcLength,
-  R as getLineLength,
-  D as getPointOnBezier,
-  k as getPointOnLine,
-  T as getPointOnLineByOffset,
-  z as getPositionFromOffset,
-  re as handleArrival,
-  ne as initializeAllVehicles,
+  F as getLineLength,
+  w as getPointOnBezier,
+  R as getPointOnLine,
+  D as getPointOnLineByOffset,
+  V as getPositionFromOffset,
+  ct as handleArrival,
+  ot as initializeAllVehicles,
   H as initializeMovingVehicle,
   Y as isPointNearPoint,
-  w as normalize,
-  se as prepareCommandPath,
-  V as resolveFromLineOffset,
-  q as resolveToLineOffset,
-  oe as updateAxlePosition
+  st as moveVehicle,
+  P as normalize,
+  rt as prepareCommandPath,
+  q as resolveFromLineOffset,
+  z as resolveToLineOffset,
+  b as updateAxlePosition
 };