@maptalks/traffic 0.97.4 → 0.98.0

package/dist/maptalks.traffic.es.js

@@ -1,142 +1,32 @@
 /*!
- * @maptalks/traffic v0.97.4
+ * @maptalks/traffic v0.98.0
  * LICENSE : UNLICENSED
  * (c) 2016-2024 maptalks.org
  */
 import * as t from "maptalks";
 
-import { GLTFLayer as i, MultiGLTFMarker as s } from "@maptalks/gltf-layer";
+import * as s from "@turf/turf";
 
-import * as n from "turf";
+import { GLTFLayer as i, MultiGLTFMarker as h } from "@maptalks/gltf-layer";
 
-let e = 0;
+let n = 0;
 
-function r(t, i, s) {
-    return null == i || s ? (t.length !== +t.length && (t = function(t) {
-        const i = function(t) {
-            if (!function(t) {
-                return t === Object(t);
-            }(t)) return [];
-            const i = [];
-            for (const s in t) a(t, s) && i.push(s);
-            return i;
-        }(t), s = i.length, n = new Array(s);
-        for (let e = 0; e < s; e++) n[e] = t[i[e]];
-        return n;
-    }(t)), t[u(t.length - 1)]) : function(t) {
-        let i, s = 0;
-        const n = [];
-        return c(t, t => {
-            i = i(s++), n[s - 1] = n[i], n[i] = t;
-        }), n;
-    }(t).slice(0, Math.max(0, i));
+function e(t, s, i) {
+    return t.length !== +t.length && (t = Object.values(t)), t[o(t.length - 1)];
 }
 
-function h(t) {
-    const i = ++e + "";
-    return t ? t + i : i;
+function r(t) {
+    const s = ++n + "";
+    return t ? t + s : s;
 }
 
-function o(t, i) {
-    let s;
-    if (nativeBind && t.bind === nativeBind) return nativeBind.apply(t, slice.call(arguments, 1));
-    const n = slice.call(arguments, 2);
-    return s = function() {
-        if (!(this instanceof s)) return t.apply(i, n.concat(slice.call(arguments)));
-        ctor.prototype = t.prototype;
-        const e = new ctor;
-        ctor.prototype = null;
-        const r = t.apply(e, n.concat(slice.call(arguments)));
-        return Object(r) === r ? r : e;
-    };
+function o(t, s) {
+    return s || (s = t, t = 0), t + Math.floor(Math.random() * (s - t + 1));
 }
 
-function u(t, i) {
-    return i || (i = t, t = 0), t + Math.floor(Math.random() * (i - t + 1));
-}
-
-function l(t) {
-    return c(slice.call(arguments, 1), (function(i) {
-        if (i) for (const s in i) t[s] = i[s];
-    })), t;
-}
-
-function c(t, i, s) {
-    if (null == t) return t;
-    if (nativeForEach && t.forEach === nativeForEach) t.forEach(i, s); else if (t.length === +t.length) {
-        for (let n = 0, e = t.length; n < e; n++) if (i.call(s, t[n], n, t) === breaker) return null;
-    } else {
-        const n = n(t);
-        for (let e = 0, r = n.length; e < r; e++) if (i.call(s, t[n[e]], n[e], t) === breaker) return null;
-    }
-    return t;
-}
-
-function a(t, i) {
-    return hasOwnProperty.call(t, i);
-}
-
-class f {
-    constructor(t, i) {
-        let s, n, e;
-        if (this.factory = t, this.objects = {}, null != i && null != i.objects) for (s in e = i.objects, 
-        e) n = e[s], this.objects[s] = this.factory.copy(n);
-    }
-    get length() {
-        return Object.keys(this.objects).length;
-    }
-    toJSON() {
-        return this.objects;
-    }
-    get(t) {
-        return this.objects[t];
-    }
-    put(t) {
-        return this.objects[t.id] = t;
-    }
-    pop(t) {
-        let i;
-        const s = null != (i = t.id) ? i : t, n = this.objects[s];
-        return "function" == typeof n.release && n.release(), delete this.objects[s], n;
-    }
-    all() {
-        return this.objects;
-    }
-    clear() {
-        return this.objects = {};
-    }
-}
-
-class d {
-    constructor(t, i) {
-        this.x = t || 0, this.y = i || 0;
-    }
-    get length() {
-        return Math.sqrt(this.x * this.x + this.y * this.y);
-    }
-    get direction() {
-        return Math.atan2(this.y, this.x);
-    }
-    get normalized() {
-        return new d(this.x / this.length, this.y / this.length);
-    }
-    add(t) {
-        return new d(this.x + t.x, this.y + t.y);
-    }
-    subtract(t) {
-        return new d(this.x - t.x, this.y - t.y);
-    }
-    mult(t) {
-        return new d(this.x * t, this.y * t);
-    }
-    divide(t) {
-        return new d(this.x / t, this.y / t);
-    }
-}
-
-class g {
-    constructor(t, i) {
-        this.source = t, this.target = i;
+class u {
+    constructor(t, s) {
+        this.source = t, this.target = s;
     }
     get vector() {
         return this.target.subtract(this.source);
@@ -150,148 +40,53 @@ class g {
     get center() {
         return this.getPoint(.5);
     }
-    split(t, i) {
-        let s, n, e, r, h, o;
-        const u = i ? function() {
-            h = [];
-            for (let i = r = t - 1; r <= 0 ? i <= 0 : i >= 0; r <= 0 ? i++ : i--) h.push(i);
-            return h;
+    split(t, s) {
+        let i, h, n, e, r, o;
+        const u = s ? function() {
+            r = [];
+            for (let s = e = t - 1; e <= 0 ? s <= 0 : s >= 0; e <= 0 ? s++ : s--) r.push(s);
+            return r;
         }.apply(this) : function() {
             o = [];
-            for (let i = 0, s = t - 1; 0 <= s ? i <= s : i >= s; 0 <= s ? i++ : i--) o.push(i);
+            for (let s = 0, i = t - 1; 0 <= i ? s <= i : s >= i; 0 <= i ? s++ : s--) o.push(s);
             return o;
         }.apply(this), l = [];
-        for (n = 0, e = u.length; n < e; n++) s = u[n], l.push(this.subsegment(s / t, (s + 1) / t));
+        for (h = 0, n = u.length; h < n; h++) i = u[h], l.push(this.subsegment(i / t, (i + 1) / t));
         return l;
     }
     getPoint(t) {
         return this.source.add(this.vector.mult(t));
     }
-    subsegment(t, i) {
-        const s = this.vector, n = this.source.add(s.mult(t)), e = this.source.add(s.mult(i));
-        return new g(n, e);
+    subsegment(t, s) {
+        const i = this.vector, h = this.source.add(i.mult(t)), n = this.source.add(i.mult(s));
+        return new u(h, n);
     }
 }
 
-class w {
-    constructor(t, i, s, n) {
-        this.x = t || 0, this.y = i || 0, this.width = s || 0, this.height = n || 0;
-    }
-    copy(t) {
-        return new w(t.x, t.y, t.width, t.height);
-    }
-    toJSON() {
-        return l({}, this);
-    }
-    area() {
-        return this.width * this.height;
-    }
-    left(t) {
-        return null != t && (this.x = t), this.x;
-    }
-    right(t) {
-        return null != t && (this.x = t - this.width), this.x + this.width;
-    }
-    top(t) {
-        return null != t && (this.y = t), this.y;
+class l {
+    constructor(t, s, i, h) {
+        this.A = t, this.B = s, this.O = i, this.Q = h, this.AO = new u(this.A, this.O), 
+        this.OQ = new u(this.O, this.Q), this.QB = new u(this.Q, this.B), this.len = null;
     }
-    bottom(t) {
-        return null != t && (this.y = t - this.height), this.y + this.height;
-    }
-    center(t) {
-        return null != t && (this.x = t.x - this.width / 2, this.y = t.y - this.height / 2), 
-        new d(this.x + this.width / 2, this.y + this.heigh / 2);
-    }
-    containsPoint(t) {
-        let i, s;
-        return this.left() <= (i = t.x) && i <= this.right() && this.top() <= (s = t.y) && s <= this.bottom();
-    }
-    containsRect(t) {
-        return this.left() <= t.left() && t.right() <= this.right() && this.top() <= t.top() && t.bottom() <= this.bottom();
-    }
-    getVertices() {
-        return [ new d(this.left(), this.top()), new d(this.right(), this.top()), new d(this.right(), this.bottom()), new d(this.left(), this.bottom()) ];
-    }
-    getSide(t) {
-        const i = this.getVertices();
-        return new g(i[t], i[(t + 1) % 4]);
-    }
-    getSectorId(t) {
-        const i = t.subtract(this.center());
-        if (i.y <= 0 && Math.abs(i.x) <= Math.abs(i.y)) return 0;
-        if (i.x >= 0 && Math.abs(i.x) >= Math.abs(i.y)) return 1;
-        if (i.y >= 0 && Math.abs(i.x) <= Math.abs(i.y)) return 2;
-        if (i.x <= 0 && Math.abs(i.x) >= Math.abs(i.y)) return 3;
-        throw new Error("algorithm error");
-    }
-    getSector(t) {
-        return this.getSide(this.getSectorId(t));
-    }
-}
-
-class p {
-    constructor(t) {
-        this.intersection = t, this.time = 0, this.flipMultiplier = .4 * Math.random() - .2 + 1, 
-        this.stateNum = 0, this.lightsFlipInterval = 20, this.states = [ [ "L", "", "L", "" ], [ "FR", "", "FR", "" ], [ "", "L", "", "L" ], [ "", "FR", "", "FR" ] ];
-    }
-    get flipInterval() {
-        return this.flipMultiplier * this.lightsFlipInterval;
-    }
-    get state() {
-        let t = this.states[this.stateNum % this.states.length];
-        this.intersection.roads.length <= 2 && (t = [ "LFR", "LFR", "LFR", "LFR" ]);
-        const i = [];
-        for (let s = 0, n = t.length; s < n; s++) {
-            const n = t[s];
-            i.push(this.decode(n));
-        }
-        return i;
-    }
-    decode(t) {
-        const i = [ 0, 0, 0 ], s = [].indexOf || function(t) {
-            for (let i = 0, s = this.length; i < s; i++) if (i in this && this[i] === t) return i;
-            return -1;
-        };
-        return s.call(t, "L") >= 0 && (i[0] = 1), s.call(t, "F") >= 0 && (i[1] = 1), s.call(t, "R") >= 0 && (i[2] = 1), 
-        i;
-    }
-    flip() {
-        return this.stateNum += 1;
-    }
-    onTick(t) {
-        return this.time += t, this.time > this.flipInterval ? (this.flip(), this.time -= this.flipInterval) : null;
-    }
-}
-
-class m {
-    constructor(t) {
-        this.rect = t, this.id = h("intersection"), this.roads = [], this.inRoads = [], 
-        this.controlSignals = new p(this);
-    }
-    copy(t) {
-        t.rect = w.copy(t.rect);
-        const i = Object.create(m.prototype);
-        return l(i, t), i.roads = [], i.inRoads = [], i.controlSignals = new p(i), i;
+    get length() {
+        let t, s, i, h, n;
+        if (null == this.len) for (i = 10, h = null, this.len = 0, t = n = 0; n <= 10; t = ++n) s = this.getPoint(t / 10), 
+        h && (this.len += s.subtract(h).length), h = s;
+        return this.len;
     }
-    toJSON() {
-        return {
-            id: this.id,
-            rect: this.rect
-        };
+    getPoint(t) {
+        const s = this.AO.getPoint(t), i = this.OQ.getPoint(t), h = this.QB.getPoint(t), n = new u(s, i).getPoint(t), e = new u(i, h).getPoint(t);
+        return new u(n, e).getPoint(t);
     }
-    update() {
-        let t, i, s, n, e;
-        const r = this.roads;
-        for (i = 0, n = r.length; i < n; i++) t = r[i], t.update();
-        const h = this.inRoads, o = [];
-        for (s = 0, e = h.length; s < e; s++) t = h[s], o.push(t.update());
-        return o;
+    getDirection(t) {
+        const s = this.AO.getPoint(t), i = this.OQ.getPoint(t), h = this.QB.getPoint(t), n = new u(s, i).getPoint(t), e = new u(i, h).getPoint(t);
+        return new u(n, e).direction;
     }
 }
 
-class v {
-    constructor(t, i, s) {
-        this.car = t, this.position = s, this.id = h("laneposition"), this.free = !0, this.tmpLane = i;
+class c {
+    constructor(t, s, i) {
+        this.id = r("laneposition"), this.free = !0, this.car = t, this.position = i, this.tmpLane = s;
     }
     get lane() {
         return this.tmpLane;
@@ -303,12 +98,12 @@ class v {
         return this.position / this.lane.length;
     }
     get nextCarDistance() {
-        let t, i;
-        const s = this.getNext();
-        return s ? (i = s.position - s.car.length / 2, t = this.position + this.car.length / 2, 
+        let t, s;
+        const i = this.getNext();
+        return i ? (s = i.position - i.car.length / 2, t = this.position + this.car.length / 2, 
         {
-            car: s.car,
-            distance: i - t
+            car: i.car,
+            distance: s - t
         }) : {
             car: null,
             distance: 1 / 0
@@ -329,51 +124,29 @@ class v {
     }
 }
 
-class M {
-    constructor(t, i, s, n) {
-        this.A = t, this.B = i, this.O = s, this.Q = n, this.AB = new g(this.A, this.B), 
-        this.AO = new g(this.A, this.O), this.OQ = new g(this.O, this.Q), this.QB = new g(this.Q, this.B), 
-        this.len = null;
-    }
-    get length() {
-        let t, i, s, n, e;
-        if (null == this.len) for (s = 10, n = null, this.len = 0, t = e = 0; e <= 10; t = ++e) i = this.getPoint(t / 10), 
-        n && (this.len += i.subtract(n).length), n = i;
-        return this.len;
-    }
-    getPoint(t) {
-        const i = this.AO.getPoint(t), s = this.OQ.getPoint(t), n = this.QB.getPoint(t), e = new g(i, s).getPoint(t), r = new g(s, n).getPoint(t);
-        return new g(e, r).getPoint(t);
-    }
-    getDirection(t) {
-        const i = this.AO.getPoint(t), s = this.OQ.getPoint(t), n = this.QB.getPoint(t), e = new g(i, s).getPoint(t), r = new g(s, n).getPoint(t);
-        return new g(e, r).direction;
-    }
-}
-
-class y {
-    constructor(t, i, s) {
-        this.car = t, this.current = new v(this.car, i, s || 0), this.current.acquire(), 
-        this.next = new v(this.car), this.temp = new v(this.car), this.isChangingLanes = !1;
+class a {
+    constructor(t, s, i) {
+        this.isChangingLanes = !1, this.car = t, this.current = new c(t, s, i || 0), this.current.acquire(), 
+        this.next = new c(t), this.temp = new c(t);
     }
     get lane() {
         return this.temp.lane || this.current.lane;
     }
     get absolutePosition() {
-        return null != this.temp.lane ? this.temp.position : this.current.position;
+        return null !== this.temp.lane && void 0 !== this.temp.lane ? this.temp.position : this.current.position;
     }
     get relativePosition() {
         return this.absolutePosition / this.lane.length;
     }
     get direction() {
-        return this.lane.getDirection(this.relativePosition);
+        return this.lane.getDirection();
     }
     get coords() {
         return this.lane.getPoint(this.relativePosition);
     }
     get nextCarDistance() {
-        const t = this.current.nextCarDistance, i = this.next.nextCarDistance;
-        return t.distance < i.distance ? t : i;
+        const t = this.current.nextCarDistance, s = this.next.nextCarDistance;
+        return t.distance < s.distance ? t : s;
     }
     get distanceToStopLine() {
         return this.canEnterIntersection() ? 1 / 0 : this.getDistanceToIntersection();
@@ -385,55 +158,55 @@ class y {
         return this.current.lane.road.source;
     }
     isValidTurn() {
-        const t = this.car.nextLane, i = this.current.lane, s = i.getTurnDirection(t);
-        if (3 === s) throw Error("no U-turns are allowed");
-        if (0 === s && !i.isLeftmost) throw Error("no left turns from this lane");
-        if (2 === s && !i.isRightmost) throw Error("no right turns from this lane");
+        const t = this.car.nextLane, s = this.current.lane, i = s.getTurnDirection(t);
+        if (3 === i) throw Error("no U-turns are allowed");
+        if (0 === i && !s.isLeftmost) throw Error("no left turns from this lane");
+        if (2 === i && !s.isRightmost) throw Error("no right turns from this lane");
         return !0;
     }
     canEnterIntersection() {
-        const t = this.car.nextLane, i = this.current.lane;
+        const t = this.car.nextLane, s = this.current.lane;
         if (!t) return !0;
-        const s = this.nextIntersection, n = i.getTurnDirection(t), e = i.road.targetSideId;
-        return s.controlSignals.state[e][n];
+        const i = this.nextIntersection, h = s.getTurnDirection(t), n = s.road.targetSideId;
+        return i.controlSignals.state[n][h];
     }
     getDistanceToIntersection() {
         const t = this.current.lane.length - this.car.length / 2 - this.current.position;
         return this.isChangingLanes ? 1 / 0 : Math.max(t, 0);
     }
     timeToMakeTurn(t) {
-        return null == t && (t = 0), this.getDistanceToIntersection() <= t;
+        return void 0 === t && (t = 0), this.getDistanceToIntersection() <= t;
     }
     moveForward(t) {
-        let i, s;
+        let s, i;
         t = Math.max(t, 0), this.current.position += t, this.next.position += t, this.temp.position += t, 
         this.timeToMakeTurn() && this.canEnterIntersection() && this.isValidTurn() && this.t(this.car.popNextLane(), 0);
-        const n = this.temp.position / (null != (i = this.temp.lane) ? i.length : void 0), e = 2 * this.car.length;
-        return this.isChangingLanes && this.temp.position > e && !this.current.free && this.current.release(), 
-        this.isChangingLanes && this.next.free && this.temp.position + e > (null != (s = this.temp.lane) ? s.length : void 0) && this.next.acquire(), 
-        this.isChangingLanes && n >= 1 && this.i(), !this.current.lane || this.isChangingLanes || this.car.nextLane ? null : this.car.pickNextLane();
+        const h = this.temp.position / (null != (s = this.temp.lane) ? s.length : void 0), n = 2 * this.car.length;
+        return this.isChangingLanes && this.temp.position > n && !this.current.free && this.current.release(), 
+        this.isChangingLanes && this.next.free && this.temp.position + n > (null != (i = this.temp.lane) ? i.length : void 0) && this.next.acquire(), 
+        this.isChangingLanes && h >= 1 && this.i(), !this.current.lane || this.isChangingLanes || this.car.nextLane ? null : this.car.pickNextLane();
     }
     changeLane(t) {
         if (this.isChangingLanes) throw Error("already changing lane");
         if (null == t) throw Error("no next lane");
         if (t === this.lane) throw Error("next lane == current lane");
         if (this.lane.road !== t.road) throw Error("not neighbouring lanes");
-        const i = this.current.position + 3 * this.car.length;
-        return this.t(t, i);
-    }
-    s() {
-        const t = this.current.lane.getPoint(this.current.relativePosition), i = this.next.lane.getPoint(this.next.relativePosition), s = i.subtract(t).length, n = this.current.lane.middleLine.vector.normalized.mult(.3 * s), e = t.add(n), r = this.next.lane.middleLine.vector.normalized.mult(.3 * s), h = i.subtract(r);
-        return new M(t, i, e, h);
+        const s = this.current.position + 3 * this.car.length;
+        return this.t(t, s);
     }
     h() {
-        return this.s();
+        const t = this.current.lane.getPoint(this.current.relativePosition), s = this.next.lane.getPoint(this.next.relativePosition), i = s.subtract(t).length, h = this.current.lane.middleLine.vector.normalized.mult(.3 * i), n = t.add(h), e = this.next.lane.middleLine.vector.normalized.mult(.3 * i), r = s.subtract(e);
+        return new l(t, s, n, r);
     }
-    t(t, i) {
+    o() {
+        return this.h();
+    }
+    t(t, s) {
         if (this.isChangingLanes) throw Error("already changing lane");
         if (null == t) return 0;
-        this.isChangingLanes = !0, this.next.lane = t, this.next.position = i;
-        const s = this.h();
-        return this.temp.lane = s, this.temp.position = 0, this.next.position -= this.temp.lane.length;
+        this.isChangingLanes = !0, this.next.lane = t, this.next.position = s;
+        const i = this.o();
+        return this.temp.lane = i, this.temp.position = 0, this.next.position -= this.temp.lane.length;
     }
     i() {
         if (!this.isChangingLanes) throw Error("no lane changing is going on");
@@ -442,20 +215,20 @@ class y {
         this.temp.position = NaN, this.current.lane;
     }
     release() {
-        let t, i, s;
-        return null != (t = this.current) && t.release(), null != (i = this.next) && i.release(), 
-        null != (s = this.temp) ? s.release() : void 0;
+        let t, s, i;
+        return null != (t = this.current) && t.release(), null != (s = this.next) && s.release(), 
+        null != (i = this.temp) ? i.release() : void 0;
     }
 }
 
-const L = [];
+const f = [];
 
-class C {
-    constructor(t, i) {
-        this.type = u(L.length - 1), this.id = h("car"), this.color = (300 + 240 * Math.random() | 0) % 360, 
-        this.tmpSpeed = 0, this.width = 2, this.length = 2, this.maxSpeed = 30, this.s0 = 2, 
-        this.timeHeadway = 1.5, this.maxAcceleration = 1, this.maxDeceleration = 3, this.trajectory = new y(this, t, i), 
-        this.alive = !0, this.preferedLane = null;
+class d {
+    constructor(t, s) {
+        this.type = o(f.length - 1), this.id = r("car"), this.color = (300 + 240 * Math.random() | 0) % 360, 
+        this.preferedLane = null, this.width = 2, this.length = 2, this.tmpSpeed = 0, this.maxSpeed = 30, 
+        this.s0 = 2, this.timeHeadway = 1.5, this.maxAcceleration = 1, this.maxDeceleration = 3, 
+        this.alive = !0, this.trajectory = new a(this, t, s);
     }
     get coords() {
         return this.trajectory.coords;
@@ -474,14 +247,14 @@ class C {
     }
     getAcceleration() {
         let t;
-        const i = this.trajectory.nextCarDistance, s = Math.max(i.distance, 0), n = this.maxAcceleration, e = this.maxDeceleration, r = this.speed - (null != (t = i.car) ? t.speed : void 0) || 0, h = Math.pow(this.speed / this.maxSpeed, 4), o = this.s0, u = this.speed * this.timeHeadway, l = o + u + this.speed * r / (2 * Math.sqrt(n * e)), c = Math.pow(l / s, 2), a = 1 + u + Math.pow(this.speed, 2) / (2 * e), f = 1 - h - c - Math.pow(a / this.trajectory.distanceToStopLine, 2);
+        const s = this.trajectory.nextCarDistance, i = Math.max(s.distance, 0), h = this.maxAcceleration, n = this.maxDeceleration, e = this.speed - (null != (t = s.car) ? t.speed : void 0) || 0, r = Math.pow(this.speed / this.maxSpeed, 4), o = this.s0, u = this.speed * this.timeHeadway, l = o + u + this.speed * e / (2 * Math.sqrt(h * n)), c = Math.pow(l / i, 2), a = 1 + u + Math.pow(this.speed, 2) / (2 * n), f = 1 - r - c - Math.pow(a / this.trajectory.distanceToStopLine, 2);
         return this.maxAcceleration * f;
     }
     move(t) {
-        const i = this.getAcceleration();
-        if (this.speed += i * t, !this.trajectory.isChangingLanes && this.nextLane) {
-            const t = this.trajectory.current.lane, i = t.getTurnDirection(this.nextLane), s = function() {
-                switch (i) {
+        const s = this.getAcceleration();
+        if (this.speed += s * t, !this.trajectory.isChangingLanes && this.nextLane) {
+            const t = this.trajectory.current.lane, s = t.getTurnDirection(this.nextLane), i = function() {
+                switch (s) {
                   case 0:
                     return t.leftmostAdjacent;
 
@@ -492,38 +265,38 @@ class C {
                     return t;
                 }
             }();
-            s !== t && this.trajectory.changeLane(s);
+            i !== t && this.trajectory.changeLane(i);
         }
-        const s = this.speed * t + .5 * i * Math.pow(t, 2);
-        return this.trajectory.nextCarDistance.distance < s && console.log("bad IDM"), this.trajectory.timeToMakeTurn(s) && null == this.nextLane ? (this.alive = !1, 
-        this.alive) : this.trajectory.moveForward(s);
+        const i = this.speed * t + .5 * s * Math.pow(t, 2);
+        return this.trajectory.nextCarDistance.distance < i && console.log("bad IDM"), this.trajectory.timeToMakeTurn(i) && null == this.nextLane ? (this.alive = !1, 
+        this.alive) : this.trajectory.moveForward(i);
     }
     pickNextRoad() {
-        const t = this.trajectory.nextIntersection, i = this.trajectory.current.lane, s = t.roads.filter((function(t) {
-            return t.target !== i.road.source;
+        const t = this.trajectory.nextIntersection, s = this.trajectory.current.lane, i = t.roads.filter((function(t) {
+            return t.target !== s.road.source;
         }));
-        if (0 === s.length) return null;
-        return r(s);
+        if (0 === i.length) return null;
+        return e(i);
     }
     pickNextLane() {
         if (this.nextLane) throw Error("next lane is already chosen");
         this.nextLane = null;
         const t = this.pickNextRoad();
         if (!t) return null;
-        const i = this.trajectory.current.lane.road.getTurnDirection(t), s = function() {
-            switch (i) {
+        const s = this.trajectory.current.lane.road.getTurnDirection(t), i = function() {
+            switch (s) {
               case 0:
                 return t.lanesNumber - 1;
 
               case 1:
-                return u(0, t.lanesNumber - 1);
+                return o(0, t.lanesNumber - 1);
 
               case 2:
                 return 0;
             }
             return null;
         }();
-        return this.nextLane = t.lanes[s], this.nextLane;
+        return this.nextLane = t.lanes[i], this.nextLane;
     }
     popNextLane() {
         const t = this.nextLane;
@@ -531,11 +304,187 @@ class C {
     }
 }
 
-class E {
-    constructor(t, i, s) {
-        this.sourceSegment = t, this.targetSegment = i, this.road = s, this.leftAdjacent = null, 
-        this.rightAdjacent = null, this.leftmostAdjacent = null, this.rightmostAdjacent = null, 
-        this.carsPositions = {}, this.update();
+class g {
+    constructor(t) {
+        this.flipMultiplier = .4 * Math.random() - .2 + 1, this.time = 0, this.stateNum = 0, 
+        this.lightsFlipInterval = 20, this.states = [ [ "L", "", "L", "" ], [ "FR", "", "FR", "" ], [ "", "L", "", "L" ], [ "", "FR", "", "FR" ] ], 
+        this.intersection = t;
+    }
+    get flipInterval() {
+        return this.flipMultiplier * this.lightsFlipInterval;
+    }
+    get state() {
+        let t = this.states[this.stateNum % this.states.length];
+        this.intersection.roads.length <= 2 && (t = [ "LFR", "LFR", "LFR", "LFR" ]);
+        const s = [];
+        for (let i = 0, h = t.length; i < h; i++) {
+            const h = t[i];
+            s.push(this.decode(h));
+        }
+        return s;
+    }
+    decode(t) {
+        const s = [ 0, 0, 0 ], i = [].indexOf || function(t) {
+            for (let s = 0, i = this.length; s < i; s++) if (s in this && this[s] === t) return s;
+            return -1;
+        };
+        return i.call(t, "L") >= 0 && (s[0] = 1), i.call(t, "F") >= 0 && (s[1] = 1), i.call(t, "R") >= 0 && (s[2] = 1), 
+        s;
+    }
+    flip() {
+        return this.stateNum += 1;
+    }
+    onTick(t) {
+        return this.time += t, this.time > this.flipInterval ? (this.flip(), this.time -= this.flipInterval) : null;
+    }
+}
+
+class w {
+    constructor(t, s) {
+        this.x = 0, this.y = 0, t && (this.x = t), s && (this.y = s);
+    }
+    get length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+    get direction() {
+        return Math.atan2(this.y, this.x);
+    }
+    get normalized() {
+        return new w(this.x / this.length, this.y / this.length);
+    }
+    add(t) {
+        return new w(this.x + t.x, this.y + t.y);
+    }
+    subtract(t) {
+        return new w(this.x - t.x, this.y - t.y);
+    }
+    mult(t) {
+        return new w(this.x * t, this.y * t);
+    }
+    divide(t) {
+        return new w(this.x / t, this.y / t);
+    }
+}
+
+class p {
+    constructor(t, s, i, h) {
+        this.x = 0, this.y = 0, this.width = 0, this.height = 0, this.x = t || 0, this.y = s || 0, 
+        this.width = i || 0, this.height = h || 0;
+    }
+    static copy(t) {
+        return new p(t.x, t.y, t.width, t.height);
+    }
+    toJSON() {
+        return Object.assign({}, this);
+    }
+    area() {
+        return this.width * this.height;
+    }
+    left(t) {
+        return void 0 !== t && (this.x = t), this.x;
+    }
+    right(t) {
+        return void 0 !== t && (this.x = t - this.width), this.x + this.width;
+    }
+    top(t) {
+        return void 0 !== t && (this.y = t), this.y;
+    }
+    bottom(t) {
+        return void 0 !== t && (this.y = t - this.height), this.y + this.height;
+    }
+    center(t) {
+        return void 0 !== t && (this.x = t.x - this.width / 2, this.y = t.y - this.height / 2), 
+        new w(this.x + this.width / 2, this.y + this.height / 2);
+    }
+    containsPoint(t) {
+        let s, i;
+        return this.left() <= (s = t.x) && s <= this.right() && this.top() <= (i = t.y) && i <= this.bottom();
+    }
+    containsRect(t) {
+        return this.left() <= t.left() && t.right() <= this.right() && this.top() <= t.top() && t.bottom() <= this.bottom();
+    }
+    getVertices() {
+        return [ new w(this.left(), this.top()), new w(this.right(), this.top()), new w(this.right(), this.bottom()), new w(this.left(), this.bottom()) ];
+    }
+    getSide(t) {
+        const s = this.getVertices();
+        return new u(s[t], s[(t + 1) % 4]);
+    }
+    getSectorId(t) {
+        const s = t.subtract(this.center());
+        if (s.y <= 0 && Math.abs(s.x) <= Math.abs(s.y)) return 0;
+        if (s.x >= 0 && Math.abs(s.x) >= Math.abs(s.y)) return 1;
+        if (s.y >= 0 && Math.abs(s.x) <= Math.abs(s.y)) return 2;
+        if (s.x <= 0 && Math.abs(s.x) >= Math.abs(s.y)) return 3;
+        throw new Error("algorithm error");
+    }
+    getSector(t) {
+        return this.getSide(this.getSectorId(t));
+    }
+}
+
+class m {
+    constructor(t) {
+        this.id = r("intersection"), this.rect = t, this.roads = [], this.inRoads = [], 
+        this.controlSignals = new g(this);
+    }
+    static copy(t) {
+        t.rect = p.copy(t.rect);
+        const s = Object.create(m.prototype);
+        return Object.assign(s, t), s.roads = [], s.inRoads = [], s.controlSignals = new g(s), 
+        s;
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            rect: this.rect
+        };
+    }
+    update() {
+        let t, s, i, h, n;
+        const e = this.roads;
+        for (s = 0, h = e.length; s < h; s++) t = e[s], t.update();
+        const r = this.inRoads, o = [];
+        for (i = 0, n = r.length; i < n; i++) t = r[i], o.push(t.update());
+        return o;
+    }
+}
+
+class v {
+    constructor(t, s) {
+        let i, h, n;
+        if (this.objects = {}, this.factory = t, s && s.objects) for (i in n = s.objects, 
+        n) h = n[i], this.factory instanceof d || (this.objects[i] = this.factory.copy(h));
+    }
+    get length() {
+        return Object.keys(this.objects).length;
+    }
+    toJSON() {
+        return this.objects;
+    }
+    get(t) {
+        return this.objects[t];
+    }
+    put(t) {
+        return this.objects[t.id] = t;
+    }
+    pop(t) {
+        let s;
+        const i = null !== (s = t.id) ? s : t, h = this.objects[i];
+        return h instanceof d && h.release(), delete this.objects[i], h;
+    }
+    all() {
+        return this.objects;
+    }
+    clear() {
+        return this.objects = {};
+    }
+}
+
+class M {
+    constructor(t, s, i) {
+        this.leftmostAdjacent = null, this.rightmostAdjacent = null, this.carsPositions = {}, 
+        this.sourceSegment = t, this.targetSegment = s, this.road = i, this.update();
     }
     get sourceSideId() {
         return this.road.sourceSideId;
@@ -550,17 +499,17 @@ class E {
         return this === this.leftmostAdjacent;
     }
     get leftBorder() {
-        return new g(this.sourceSegment.source, this.targetSegment.target);
+        return new u(this.sourceSegment.source, this.targetSegment.target);
     }
     get rightBorder() {
-        return new g(this.sourceSegment.target, this.targetSegment.source);
+        return new u(this.sourceSegment.target, this.targetSegment.source);
     }
     toJSON() {
-        const t = l({}, this);
+        const t = Object.assign({}, this);
         return delete t.carsPositions, t;
     }
     update() {
-        return this.middleLine = new g(this.sourceSegment.center, this.targetSegment.center), 
+        return this.middleLine = new u(this.sourceSegment.center, this.targetSegment.center), 
         this.length = this.middleLine.length, this.direction = this.middleLine.direction;
     }
     getTurnDirection(t) {
@@ -582,20 +531,20 @@ class E {
     }
     getNext(t) {
         if (t.lane !== this) throw Error("car is on other lane");
-        let i = null, s = 1 / 0;
-        const n = this.carsPositions;
-        for (const e in n) {
-            const r = n[e], h = r.position - t.position;
-            !r.free && 0 < h && h < s && (s = h, i = r);
+        let s = null, i = 1 / 0;
+        const h = this.carsPositions;
+        for (const n in h) {
+            const e = h[n], r = e.position - t.position;
+            !e.free && 0 < r && r < i && (i = r, s = e);
         }
-        return i;
+        return s;
     }
 }
 
-class R {
-    constructor(t, i, s) {
-        this.source = t, this.target = i, this.id = h("road"), this.lanes = [], this.gridSize = s || 32, 
-        this.lanesNumber = null, this.update();
+class b {
+    constructor(t, s, i) {
+        this.id = r("road"), this.lanes = [], this.lanesNumber = null, this.source = t, 
+        this.target = s, this.gridSize = i || 32, this.update();
     }
     get length() {
         return this.targetSide.target.subtract(this.sourceSide.source).length;
@@ -607,8 +556,8 @@ class R {
         return this.lanes[0];
     }
     copy(t) {
-        const i = Object.create(R.prototype);
-        return l.extend(i, t), null == i.lanes && (i.lanes = []), i;
+        const s = Object.create(b.prototype);
+        return Object.assign(s, t), null == s.lanes && (s.lanes = []), s;
     }
     toJSON() {
         return {
@@ -619,21 +568,21 @@ class R {
     }
     getTurnDirection(t) {
         if (this.target !== t.source) throw Error("invalid roads");
-        const i = this.targetSideId;
-        return (t.sourceSideId - i - 1 + 8) % 4;
+        const s = this.targetSideId;
+        return (t.sourceSideId - s - 1 + 8) % 4;
     }
     update() {
-        let t, i, s, n, e, r;
+        let t, s, i, h, n, e;
         if (!this.source || !this.target) throw Error("incomplete road");
         this.sourceSideId = this.source.rect.getSectorId(this.target.rect.center()), this.sourceSide = this.source.rect.getSide(this.sourceSideId).subsegment(.5, 1), 
         this.targetSideId = this.target.rect.getSectorId(this.source.rect.center()), this.targetSide = this.target.rect.getSide(this.targetSideId).subsegment(0, .5), 
         this.lanesNumber = 0 | Math.min(this.sourceSide.length, this.targetSide.length), 
         this.lanesNumber = Math.max(2, this.lanesNumber / this.gridSize | 0);
-        const h = this.sourceSide.split(this.lanesNumber, !0), o = this.targetSide.split(this.lanesNumber);
+        const r = this.sourceSide.split(this.lanesNumber, !0), o = this.targetSide.split(this.lanesNumber);
         if (null == this.lanes || this.lanes.length < this.lanesNumber) for (null == this.lanes && (this.lanes = []), 
-        t = s = 0, e = this.lanesNumber - 1; 0 <= e ? s <= e : s >= e; t = 0 <= e ? ++s : --s) null == (i = this.lanes)[t] && (i[t] = new E(h[t], o[t], this));
+        t = i = 0, n = this.lanesNumber - 1; 0 <= n ? i <= n : i >= n; t = 0 <= n ? ++i : --i) null == (s = this.lanes)[t] && (s[t] = new M(r[t], o[t], this));
         const u = [];
-        for (t = n = 0, r = this.lanesNumber - 1; 0 <= r ? n <= r : n >= r; t = 0 <= r ? ++n : --n) this.lanes[t].sourceSegment = h[t], 
+        for (t = h = 0, e = this.lanesNumber - 1; 0 <= e ? h <= e : h >= e; t = 0 <= e ? ++h : --h) this.lanes[t].sourceSegment = r[t], 
         this.lanes[t].targetSegment = o[t], this.lanes[t].leftAdjacent = this.lanes[t + 1], 
         this.lanes[t].rightAdjacent = this.lanes[t - 1], this.lanes[t].leftmostAdjacent = this.lanes[this.lanesNumber - 1], 
         this.lanes[t].rightmostAdjacent = this.lanes[0], u.push(this.lanes[t].update());
@@ -641,71 +590,70 @@ class R {
     }
 }
 
-class b {
+class L {
     constructor(t) {
-        this.toRemove = [], this.options = t || {}, this.carsNumber = this.options.carsNumber || 10, 
-        this.gridSize = this.options.gridSize || 32, this.o = 0, this.u = 0, this.l = 5, 
-        this.carsList = {}, this.g = new i("traffic"), this.p = "stop", this.m = [], this.v = {}, 
-        this.set();
+        this.toRemove = [], this.carsList = {}, this.u = 0, this.l = 0, this.p = new i("traffic"), 
+        this.m = 5, this.v = "stop", this.M = [], this.L = {}, this.options = t || {}, this.carsNumber = this.options.carsNumber || 10, 
+        this.gridSize = this.options.gridSize || 32, this.set();
     }
     run() {
-        this.p = "running", this.M();
+        this.v = "running", this.C();
     }
     stop() {
-        this.p = "stop";
+        this.v = "stop";
     }
     remove() {
-        this.L && cancelAnimationFrame(this.L), this.g.remove(), delete this.map;
+        this.N && cancelAnimationFrame(this.N), this.p.remove(), delete this.map;
     }
     setSymbols(t) {
-        this.m = t;
-        for (let t = 0; t < this.m.length; t++) {
-            const i = this.m[t];
-            this.v[i.url] = new s([], {
-                symbol: i
-            }).addTo(this.g);
+        this.M = t;
+        for (let t = 0; t < this.M.length; t++) {
+            const s = this.M[t];
+            this.L[s.url] = new h([], {
+                symbol: s
+            }).addTo(this.p);
         }
     }
-    M() {
-        if ("running" !== this.p) return;
+    C() {
+        if ("running" !== this.v) return;
         const t = Date.now();
         this.u = t;
-        const i = Date.now();
-        let s, n = i - this.o || 0;
-        n > 100 && (n = 100), this.o = i, this.onTick(this.l * n / 1e3);
-        let e = this.toRemove.length;
-        for (;e--; ) this.C(this.toRemove[e]);
+        const s = Date.now();
+        let i, h = s - this.l || 0;
+        h > 100 && (h = 100), this.l = s, this.onTick(this.m * h / 1e3);
+        let n = this.toRemove.length;
+        for (;n--; ) this.I(this.toRemove[n]);
         this.clearTmpRemove();
-        const r = this.cars.all();
-        for (s in r) this.R(r[s], s);
-        this.L = window.requestAnimationFrame(this.M.bind(this));
+        const e = this.cars.all();
+        for (i in e) this.R(e[i]);
+        this.N = window.requestAnimationFrame(this.C.bind(this));
     }
-    N() {
-        for (const t in this.v) this.v[t].removeData();
+    S() {
+        for (const t in this.L) this.L[t].removeData();
         for (const t in this.carsList) {
-            const i = this.carsList[t], s = i.url;
-            this.v[s].addData(i);
+            const s = this.carsList[t], i = s.url;
+            this.L[i].addData(s);
         }
     }
-    R(i) {
-        const s = i.id.substring(3);
-        if (this.carsList[s]) {
-            if (!i) return;
-            const n = i.coords, e = i.direction, r = this.map, h = r.pointAtResToCoordinate(new t.Point(n.x / this.gridSize, n.y / this.gridSize), r.getGLRes()), o = e / Math.PI * 180 + 90;
-            this.carsList[s].coordinates = h, this.carsList[s].rotation = [ 0, 0, o ];
-            const u = this.I(s), l = this.carsList[s].url;
-            u > -1 ? this.v[l].updateData(u, this.carsList[s]) : this.v[l].addData(this.carsList[s]);
+    R(s) {
+        const i = s.id.substring(3);
+        if (this.carsList[i]) {
+            if (!s) return;
+            const h = s.coords, n = s.direction, e = this.map, r = e.pointAtResToCoordinate(new t.Point(h.x / this.gridSize, h.y / this.gridSize), e.getGLRes()), o = n / Math.PI * 180 + 90;
+            this.carsList[i].coordinates = r, this.carsList[i].rotation = [ 0, 0, o ];
+            const u = this.T(i), l = this.carsList[i].url;
+            u > -1 ? this.L[l].updateData(u, this.carsList[i]) : this.L[l].addData(this.carsList[i]);
         } else {
-            const t = this.m[Math.floor(Math.random() * this.m.length)];
-            this.carsList[s] = {
+            const t = this.M[Math.floor(Math.random() * this.M.length)];
+            this.carsList[i] = {
                 coordinates: null,
                 direction: null,
                 url: t.url
-            }, this.showHideCar(this.carsList[s], "show");
+            }, this.showHideCar(this.carsList[i], "show");
         }
     }
-    showHideCar(i, s, n) {
-        const e = this;
+    showHideCar(s, i, h) {
+        const n = this;
         t.animation.Animation.animate({
             symbol: {
                 transparent: 1
@@ -715,57 +663,46 @@ class b {
             easing: "out"
         }, (function(t) {
             if ("running" === t.state.playState) {
-                let r = 0;
-                "show" === s ? (r = t.styles.symbol.transparent, i.color = [ 1, 1, 1, r ]) : "hide" === s && (r = 1 - t.styles.symbol.transparent, 
-                i.color = [ 1, 1, 1, r ], r < .01 && setTimeout((function() {
-                    const t = e.I(n);
-                    if (!e.carsList[n]) return;
-                    const i = e.carsList[n].url;
-                    t > -1 && e.v[i].removeData(t), delete e.carsList[n];
+                let e = 0;
+                "show" === i ? (e = t.styles.symbol.transparent, s.color = [ 1, 1, 1, e ]) : "hide" === i && (e = 1 - t.styles.symbol.transparent, 
+                s.color = [ 1, 1, 1, e ], e < .01 && setTimeout((function() {
+                    const t = n.T(h);
+                    if (!n.carsList[h]) return;
+                    const s = n.carsList[h].url;
+                    t > -1 && n.L[s].removeData(t), delete n.carsList[h];
                 }), 100));
             }
         })).play();
     }
-    I(t) {
-        const i = this.carsList[t];
-        if (!i) return -1;
-        const s = i.url;
-        return this.v[s].getAllData().indexOf(this.carsList[t]);
+    T(t) {
+        const s = this.carsList[t];
+        if (!s) return -1;
+        const i = s.url;
+        return this.L[i].getAllData().indexOf(this.carsList[t]);
     }
-    C(t) {
-        const i = t.substring(3);
-        null != this.carsList[i] && this.showHideCar(this.carsList[i], "hide", i);
+    I(t) {
+        const s = t.substring(3);
+        null != this.carsList[s] && this.showHideCar(this.carsList[s], "hide", s);
     }
     get instantSpeed() {
-        const t = function(t, i, s) {
-            const n = [];
-            return null == t ? n : nativeMap && t.map === nativeMap ? t.map(i, s) : (c(t, (t, e, r) => {
-                n.push(i.call(s, t, e, r));
-            }), n);
-        }(this.cars.all(), t => t.speed);
-        return 0 === t.length ? 0 : function(t, i, s, n) {
-            let e = arguments.length > 2;
-            return null == t && (t = []), nativeReduce && t.reduce === nativeReduce ? (n && (i = o(i, n)), 
-            e ? t.reduce(i, s) : t.reduce(i)) : (c(t, (t, r, h) => {
-                e ? s = i.call(n, s, t, r, h) : (s = t, e = !0);
-            }), s);
-        }(t, (function(t, i) {
-            return t + i;
+        const t = Object.values(this.cars.all()).map((t => t.speed));
+        return 0 === t.length ? 0 : t.reduce((function(t, s) {
+            return t + s;
         })) / t.length;
     }
     get map() {
-        const t = this.S;
+        const t = this.j;
         return t ? t.getMap() : null;
     }
     addTo(t) {
-        this.S = t, this.g.addTo(t);
+        this.j = t, this.p.addTo(t);
     }
     set(t) {
-        return null == t && (t = {}), this.intersections = new f(m, t.intersections), this.roads = new f(R, t.roads), 
-        this.cars = new f(C, t.cars), this.carsNumber = 0;
+        return null == t && (t = {}), this.intersections = new v(m, t.intersections), this.roads = new v(b, t.roads), 
+        this.cars = new v(d, t.cars), this.carsNumber = 0;
     }
     save() {
-        const t = l({}, this);
+        const t = Object.assign({}, this);
         return delete t.cars, window.localStorage.world = JSON.stringify(t);
     }
     setCarNumber(t) {
@@ -775,36 +712,36 @@ class b {
         return this.carsNumber;
     }
     load() {
-        let t, i, s, n;
+        let t, s, i, h;
         if (t = window.localStorage.world, t = t && JSON.parse(t), null == t) return null;
         this.clear(), this.carsNumber = t.carsNumber || 0;
-        const e = t.intersections;
-        for (i in e) s = e[i], this.addIntersection(m.copy(s));
-        const r = t.roads, h = [];
-        for (i in r) n = r[i], n = (new R).copy(n), n.source = this.getIntersection(n.source), 
-        n.target = this.getIntersection(n.target), h.push(this.addRoad(n));
-        return h;
+        const n = t.intersections;
+        for (s in n) i = n[s], this.addIntersection(m.copy(i));
+        const e = t.roads, r = [];
+        for (s in e) h = e[s], h = (new b).copy(h), h.source = this.getIntersection(h.source), 
+        h.target = this.getIntersection(h.target), r.push(this.addRoad(h));
+        return r;
     }
     intersectSegment(t, i) {
-        for (let s = 0; s < i.length - 1; s++) {
-            const e = [ i[s], i[s + 1] ], r = n.lineString(e), h = n.lineIntersect(t, r);
-            if (h.features.length) return {
-                intersectIndex: s,
-                coord: h.features[0].geometry.coordinates
+        for (let h = 0; h < i.length - 1; h++) {
+            const n = [ i[h], i[h + 1] ], e = s.lineString(n), r = s.lineIntersect(t, e);
+            if (r.features.length) return {
+                intersectIndex: h,
+                coord: r.features[0].geometry.coordinates
             };
         }
         return null;
     }
-    intersection(t, i, s, e, r, h) {
-        const o = n.lineString(t);
-        for (let t = i + 1; t < e.length; t++) {
-            const n = e[t], u = this.intersectSegment(o, n);
+    intersection(t, i, h, n, e, r) {
+        const o = s.lineString(t);
+        for (let t = i + 1; t < n.length; t++) {
+            const s = n[t], u = this.intersectSegment(o, s);
             if (!u) continue;
             const l = {};
             l[i] = {
-                pre: s
+                pre: h
             }, l[t] = {
-                pre: u.intersectIndex + h[t]
+                pre: u.intersectIndex + r[t]
             };
             const c = {
                 inLines: l,
@@ -813,113 +750,113 @@ class b {
                     y: u.coord[1]
                 }, this.map.getGLRes())
             };
-            r.push(c);
+            e.push(c);
         }
     }
     generateTraffic(t) {
         if (!this.map) return;
-        const i = {};
-        let s = 0;
-        for (let n = 0; n < t.length; n++) i[n] = s, s += t[n].length;
-        const n = [];
-        let e = 0;
-        for (let s = 0; s < t.length; s++) {
-            const r = t[s];
-            for (let h = 0; h < r.length - 1; h++) {
-                const o = [ r[h], r[h + 1] ];
-                this.intersection(o, s, e + h, t, n, i);
+        const s = {};
+        let i = 0;
+        for (let h = 0; h < t.length; h++) s[h] = i, i += t[h].length;
+        const h = [];
+        let n = 0;
+        for (let i = 0; i < t.length; i++) {
+            const e = t[i];
+            for (let r = 0; r < e.length - 1; r++) {
+                const o = [ e[r], e[r + 1] ];
+                this.intersection(o, i, n + r, t, h, s);
             }
-            e += r.length;
+            n += e.length;
         }
-        const r = [];
-        let h = 0;
+        const e = [];
+        let r = 0;
         const o = this.map;
-        for (let i = 0; i < t.length; i++) {
-            const s = t[i];
-            for (let t = 0; t < s.length; t++) {
-                const n = o.coordinateToPointAtRes({
-                    x: s[t][0],
-                    y: s[t][1]
-                }, o.getGLRes()), e = {};
-                0 === t ? e[i] = {
+        for (let s = 0; s < t.length; s++) {
+            const i = t[s];
+            for (let t = 0; t < i.length; t++) {
+                const h = o.coordinateToPointAtRes({
+                    x: i[t][0],
+                    y: i[t][1]
+                }, o.getGLRes()), n = {};
+                0 === t ? n[s] = {
                     pre: null
-                } : (s.length, e[i] = {
-                    pre: t - 1 + h
+                } : (i.length, n[s] = {
+                    pre: t - 1 + r
                 });
                 const u = {
-                    inLines: e,
-                    coordinate: n
+                    inLines: n,
+                    coordinate: h
                 };
-                r.push(u);
+                e.push(u);
             }
-            h += s.length;
+            r += i.length;
         }
-        for (let t = 0; t < r.length; t++) {
-            const i = r[t];
-            this.comparePrePoint(i, t, n);
+        for (let t = 0; t < e.length; t++) {
+            const s = e[t];
+            this.comparePrePoint(s, t, h);
         }
         const u = this.gridSize, l = [];
-        for (let t = 0; t < r.length; t++) {
-            const i = r[t], s = i.coordinate.x, n = i.coordinate.y, e = new w(s * u - .5, n * u - .5, 1, 1), h = new m(e);
-            h.connectRoads = i.roads, l.push(h), this.addIntersection(h);
+        for (let t = 0; t < e.length; t++) {
+            const s = e[t], i = s.coordinate.x, h = s.coordinate.y, n = new p(i * u - .5, h * u - .5, 1, 1), r = new m(n);
+            r.connectRoads = s.roads, l.push(r), this.addIntersection(r);
         }
         const c = [];
-        for (let t = 0; t < n.length; t++) {
-            const i = n[t], s = i.coordinate.x, e = i.coordinate.y, r = new w(s * u - .5, e * u - .5, 1, 1), h = new m(r);
-            h.connectRoads = i.roads, c.push(h), this.addIntersection(h);
+        for (let t = 0; t < h.length; t++) {
+            const s = h[t], i = s.coordinate.x, n = s.coordinate.y, e = new p(i * u - .5, n * u - .5, 1, 1), r = new m(e);
+            r.connectRoads = s.roads, c.push(r), this.addIntersection(r);
         }
         for (let t = 0; t < l.length; t++) {
-            const i = l[t], s = i.connectRoads;
-            if (s) for (let t = 0; t < s.length; t++) {
-                const n = s[t];
-                if (null != n.pre) {
+            const s = l[t], i = s.connectRoads;
+            if (i) for (let t = 0; t < i.length; t++) {
+                const h = i[t];
+                if (null != h.pre) {
                     let t = null;
-                    const s = n.type;
-                    "line" === s ? t = l[n.pre] : "line-interact" === s && (t = c[n.pre]), this.addRoad(new R(i, t)), 
-                    this.addRoad(new R(t, i));
+                    const i = h.type;
+                    "line" === i ? t = l[h.pre] : "line-interact" === i && (t = c[h.pre]), this.addRoad(new b(s, t)), 
+                    this.addRoad(new b(t, s));
                 }
             }
         }
         for (let t = 0; t < c.length; t++) {
-            const i = c[t], s = i.connectRoads;
-            if (s) for (let t = 0; t < s.length; t++) {
-                const n = s[t];
-                if (null != n.pre) {
+            const s = c[t], i = s.connectRoads;
+            if (i) for (let t = 0; t < i.length; t++) {
+                const h = i[t];
+                if (null != h.pre) {
                     let t = null;
-                    const s = n.type;
-                    "line" === s ? t = l[n.pre] : "line-interact" === s && (t = c[n.pre]), this.addRoad(new R(i, t)), 
-                    this.addRoad(new R(t, i));
+                    const i = h.type;
+                    "line" === i ? t = l[h.pre] : "line-interact" === i && (t = c[h.pre]), this.addRoad(new b(s, t)), 
+                    this.addRoad(new b(t, s));
                 }
             }
         }
     }
-    comparePrePoint(t, i, s) {
-        const n = this.getPre(t);
-        if (n) {
-            const {pre: e, lineIndex: r} = n;
-            for (let n = 0; n < s.length; n++) {
-                const h = s[n];
-                h.inLines[r] && h.inLines[r].pre === e && (t.roads = [ {
-                    pre: n,
+    comparePrePoint(t, s, i) {
+        const h = this.getPre(t);
+        if (h) {
+            const {pre: n, lineIndex: e} = h;
+            for (let h = 0; h < i.length; h++) {
+                const r = i[h];
+                r.inLines[e] && r.inLines[e].pre === n && (t.roads = [ {
+                    pre: h,
                     type: "line-interact"
-                } ], h.roads ? h.roads.push({
-                    pre: i - 1,
+                } ], r.roads ? r.roads.push({
+                    pre: s - 1,
                     type: "line"
-                }) : h.roads = [ {
-                    pre: i - 1,
+                }) : r.roads = [ {
+                    pre: s - 1,
                     type: "line"
                 } ]);
             }
             t.roads || (t.roads = [ {
-                pre: i - 1,
+                pre: s - 1,
                 type: "line"
             } ]);
         }
     }
     getPre(t) {
-        for (const i in t.inLines) if (null !== t.inLines[i].pre) return {
-            pre: t.inLines[i].pre,
-            lineIndex: i
+        for (const s in t.inLines) if (null !== t.inLines[s].pre) return {
+            pre: t.inLines[s].pre,
+            lineIndex: s
         };
         return null;
     }
@@ -927,14 +864,14 @@ class b {
         return this.set({});
     }
     onTick(t) {
-        let i, s, n;
+        let s, i, h;
         if (t > 1) throw Error("delta > 1");
         this.refreshCars();
-        const e = this.intersections.all();
-        for (s in e) n = e[s], n.controlSignals.onTick(t);
-        const r = this.cars.all(), h = [];
-        for (s in r) i = r[s], i.move(t), i.alive ? h.push(void 0) : h.push(this.removeCar(i));
-        return h;
+        const n = this.intersections.all();
+        for (i in n) h = n[i], h.controlSignals.onTick(t);
+        const e = this.cars.all(), r = [];
+        for (i in e) s = e[i], s.move(t), s.alive ? r.push(void 0) : r.push(this.removeCar(s));
+        return r;
     }
     refreshCars() {
         return this.cars.length < this.carsNumber && this.addRandomCar(), this.cars.length > this.carsNumber ? this.removeRandomCar() : null;
@@ -965,17 +902,18 @@ class b {
     }
     addRandomCar() {
         let t;
-        const i = r(this.roads.all());
-        return null != i && (t = r(i.lanes), null != t) ? this.addCar(new C(t)) : null;
+        const s = e(this.roads.all());
+        return null != s && (t = e(s.lanes), null != t) ? this.addCar(new d(t)) : null;
     }
     removeRandomCar() {
-        const t = r(this.cars.all());
+        const t = e(this.cars.all());
         return null != t ? this.removeCar(t) : null;
     }
 }
 
-"undefined" != typeof window && window.maptalks && (window.maptalks.TrafficScene = b);
+"undefined" != typeof window && window.maptalks && (window.maptalks.TrafficScene = L);
 
-export { b as TrafficScene };
+export { L as TrafficScene };
 
-"undefined" != typeof console && console.log("@maptalks/traffic v0.97.4");
+"undefined" != typeof console && console.log("@maptalks/traffic v0.98.0");
+//# sourceMappingURL=maptalks.traffic.es.js.map