@loaders.gl/terrain 3.1.0-alpha.4 → 3.1.0-alpha.5

package/dist/es5/lib/delatin/index.js

@@ -1,20 +1,12 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var Delatin = function () {
-  function Delatin(data, width) {
-    var height = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : width;
-    (0, _classCallCheck2.default)(this, Delatin);
+class Delatin {
+  constructor(data, width, height = width) {
     this.data = data;
     this.width = width;
     this.height = height;
@@ -29,461 +21,436 @@ var Delatin = function () {
     this._pending = [];
     this._pendingLen = 0;
     this._rmsSum = 0;
-    var x1 = width - 1;
-    var y1 = height - 1;
+    const x1 = width - 1;
+    const y1 = height - 1;
 
-    var p0 = this._addPoint(0, 0);
+    const p0 = this._addPoint(0, 0);
 
-    var p1 = this._addPoint(x1, 0);
+    const p1 = this._addPoint(x1, 0);
 
-    var p2 = this._addPoint(0, y1);
+    const p2 = this._addPoint(0, y1);
 
-    var p3 = this._addPoint(x1, y1);
+    const p3 = this._addPoint(x1, y1);
 
-    var t0 = this._addTriangle(p3, p0, p2, -1, -1, -1);
+    const t0 = this._addTriangle(p3, p0, p2, -1, -1, -1);
 
     this._addTriangle(p0, p3, p1, t0, -1, -1);
 
     this._flush();
   }
 
-  (0, _createClass2.default)(Delatin, [{
-    key: "run",
-    value: function run() {
-      var maxError = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
-
-      while (this.getMaxError() > maxError) {
-        this.refine();
-      }
+  run(maxError = 1) {
+    while (this.getMaxError() > maxError) {
+      this.refine();
     }
-  }, {
-    key: "refine",
-    value: function refine() {
-      this._step();
+  }
 
-      this._flush();
-    }
-  }, {
-    key: "getMaxError",
-    value: function getMaxError() {
-      return this._errors[0];
-    }
-  }, {
-    key: "getRMSD",
-    value: function getRMSD() {
-      return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;
-    }
-  }, {
-    key: "heightAt",
-    value: function heightAt(x, y) {
-      return this.data[this.width * y + x];
-    }
-  }, {
-    key: "_flush",
-    value: function _flush() {
-      var coords = this.coords;
-
-      for (var i = 0; i < this._pendingLen; i++) {
-        var t = this._pending[i];
-        var a = 2 * this.triangles[t * 3 + 0];
-        var b = 2 * this.triangles[t * 3 + 1];
-        var c = 2 * this.triangles[t * 3 + 2];
-
-        this._findCandidate(coords[a], coords[a + 1], coords[b], coords[b + 1], coords[c], coords[c + 1], t);
-      }
+  refine() {
+    this._step();
 
-      this._pendingLen = 0;
-    }
-  }, {
-    key: "_findCandidate",
-    value: function _findCandidate(p0x, p0y, p1x, p1y, p2x, p2y, t) {
-      var minX = Math.min(p0x, p1x, p2x);
-      var minY = Math.min(p0y, p1y, p2y);
-      var maxX = Math.max(p0x, p1x, p2x);
-      var maxY = Math.max(p0y, p1y, p2y);
-      var w00 = orient(p1x, p1y, p2x, p2y, minX, minY);
-      var w01 = orient(p2x, p2y, p0x, p0y, minX, minY);
-      var w02 = orient(p0x, p0y, p1x, p1y, minX, minY);
-      var a01 = p1y - p0y;
-      var b01 = p0x - p1x;
-      var a12 = p2y - p1y;
-      var b12 = p1x - p2x;
-      var a20 = p0y - p2y;
-      var b20 = p2x - p0x;
-      var a = orient(p0x, p0y, p1x, p1y, p2x, p2y);
-      var z0 = this.heightAt(p0x, p0y) / a;
-      var z1 = this.heightAt(p1x, p1y) / a;
-      var z2 = this.heightAt(p2x, p2y) / a;
-      var maxError = 0;
-      var mx = 0;
-      var my = 0;
-      var rms = 0;
-
-      for (var y = minY; y <= maxY; y++) {
-        var dx = 0;
-
-        if (w00 < 0 && a12 !== 0) {
-          dx = Math.max(dx, Math.floor(-w00 / a12));
-        }
+    this._flush();
+  }
 
-        if (w01 < 0 && a20 !== 0) {
-          dx = Math.max(dx, Math.floor(-w01 / a20));
-        }
+  getMaxError() {
+    return this._errors[0];
+  }
 
-        if (w02 < 0 && a01 !== 0) {
-          dx = Math.max(dx, Math.floor(-w02 / a01));
-        }
+  getRMSD() {
+    return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;
+  }
 
-        var w0 = w00 + a12 * dx;
-        var w1 = w01 + a20 * dx;
-        var w2 = w02 + a01 * dx;
-        var wasInside = false;
-
-        for (var x = minX + dx; x <= maxX; x++) {
-          if (w0 >= 0 && w1 >= 0 && w2 >= 0) {
-            wasInside = true;
-            var z = z0 * w0 + z1 * w1 + z2 * w2;
-            var dz = Math.abs(z - this.heightAt(x, y));
-            rms += dz * dz;
-
-            if (dz > maxError) {
-              maxError = dz;
-              mx = x;
-              my = y;
-            }
-          } else if (wasInside) {
-            break;
-          }
+  heightAt(x, y) {
+    return this.data[this.width * y + x];
+  }
 
-          w0 += a12;
-          w1 += a20;
-          w2 += a01;
-        }
+  _flush() {
+    const coords = this.coords;
+
+    for (let i = 0; i < this._pendingLen; i++) {
+      const t = this._pending[i];
+      const a = 2 * this.triangles[t * 3 + 0];
+      const b = 2 * this.triangles[t * 3 + 1];
+      const c = 2 * this.triangles[t * 3 + 2];
+
+      this._findCandidate(coords[a], coords[a + 1], coords[b], coords[b + 1], coords[c], coords[c + 1], t);
+    }
+
+    this._pendingLen = 0;
+  }
+
+  _findCandidate(p0x, p0y, p1x, p1y, p2x, p2y, t) {
+    const minX = Math.min(p0x, p1x, p2x);
+    const minY = Math.min(p0y, p1y, p2y);
+    const maxX = Math.max(p0x, p1x, p2x);
+    const maxY = Math.max(p0y, p1y, p2y);
+    let w00 = orient(p1x, p1y, p2x, p2y, minX, minY);
+    let w01 = orient(p2x, p2y, p0x, p0y, minX, minY);
+    let w02 = orient(p0x, p0y, p1x, p1y, minX, minY);
+    const a01 = p1y - p0y;
+    const b01 = p0x - p1x;
+    const a12 = p2y - p1y;
+    const b12 = p1x - p2x;
+    const a20 = p0y - p2y;
+    const b20 = p2x - p0x;
+    const a = orient(p0x, p0y, p1x, p1y, p2x, p2y);
+    const z0 = this.heightAt(p0x, p0y) / a;
+    const z1 = this.heightAt(p1x, p1y) / a;
+    const z2 = this.heightAt(p2x, p2y) / a;
+    let maxError = 0;
+    let mx = 0;
+    let my = 0;
+    let rms = 0;
+
+    for (let y = minY; y <= maxY; y++) {
+      let dx = 0;
+
+      if (w00 < 0 && a12 !== 0) {
+        dx = Math.max(dx, Math.floor(-w00 / a12));
+      }
 
-        w00 += b12;
-        w01 += b20;
-        w02 += b01;
+      if (w01 < 0 && a20 !== 0) {
+        dx = Math.max(dx, Math.floor(-w01 / a20));
       }
 
-      if (mx === p0x && my === p0y || mx === p1x && my === p1y || mx === p2x && my === p2y) {
-        maxError = 0;
+      if (w02 < 0 && a01 !== 0) {
+        dx = Math.max(dx, Math.floor(-w02 / a01));
       }
 
-      this._candidates[2 * t] = mx;
-      this._candidates[2 * t + 1] = my;
-      this._rms[t] = rms;
+      let w0 = w00 + a12 * dx;
+      let w1 = w01 + a20 * dx;
+      let w2 = w02 + a01 * dx;
+      let wasInside = false;
+
+      for (let x = minX + dx; x <= maxX; x++) {
+        if (w0 >= 0 && w1 >= 0 && w2 >= 0) {
+          wasInside = true;
+          const z = z0 * w0 + z1 * w1 + z2 * w2;
+          const dz = Math.abs(z - this.heightAt(x, y));
+          rms += dz * dz;
+
+          if (dz > maxError) {
+            maxError = dz;
+            mx = x;
+            my = y;
+          }
+        } else if (wasInside) {
+          break;
+        }
+
+        w0 += a12;
+        w1 += a20;
+        w2 += a01;
+      }
 
-      this._queuePush(t, maxError, rms);
+      w00 += b12;
+      w01 += b20;
+      w02 += b01;
     }
-  }, {
-    key: "_step",
-    value: function _step() {
-      var t = this._queuePop();
-
-      var e0 = t * 3 + 0;
-      var e1 = t * 3 + 1;
-      var e2 = t * 3 + 2;
-      var p0 = this.triangles[e0];
-      var p1 = this.triangles[e1];
-      var p2 = this.triangles[e2];
-      var ax = this.coords[2 * p0];
-      var ay = this.coords[2 * p0 + 1];
-      var bx = this.coords[2 * p1];
-      var by = this.coords[2 * p1 + 1];
-      var cx = this.coords[2 * p2];
-      var cy = this.coords[2 * p2 + 1];
-      var px = this._candidates[2 * t];
-      var py = this._candidates[2 * t + 1];
-
-      var pn = this._addPoint(px, py);
-
-      if (orient(ax, ay, bx, by, px, py) === 0) {
-        this._handleCollinear(pn, e0);
-      } else if (orient(bx, by, cx, cy, px, py) === 0) {
-        this._handleCollinear(pn, e1);
-      } else if (orient(cx, cy, ax, ay, px, py) === 0) {
-        this._handleCollinear(pn, e2);
-      } else {
-        var h0 = this._halfedges[e0];
-        var h1 = this._halfedges[e1];
-        var h2 = this._halfedges[e2];
 
-        var t0 = this._addTriangle(p0, p1, pn, h0, -1, -1, e0);
+    if (mx === p0x && my === p0y || mx === p1x && my === p1y || mx === p2x && my === p2y) {
+      maxError = 0;
+    }
 
-        var t1 = this._addTriangle(p1, p2, pn, h1, -1, t0 + 1);
+    this._candidates[2 * t] = mx;
+    this._candidates[2 * t + 1] = my;
+    this._rms[t] = rms;
 
-        var t2 = this._addTriangle(p2, p0, pn, h2, t0 + 2, t1 + 1);
+    this._queuePush(t, maxError, rms);
+  }
 
-        this._legalize(t0);
+  _step() {
+    const t = this._queuePop();
+
+    const e0 = t * 3 + 0;
+    const e1 = t * 3 + 1;
+    const e2 = t * 3 + 2;
+    const p0 = this.triangles[e0];
+    const p1 = this.triangles[e1];
+    const p2 = this.triangles[e2];
+    const ax = this.coords[2 * p0];
+    const ay = this.coords[2 * p0 + 1];
+    const bx = this.coords[2 * p1];
+    const by = this.coords[2 * p1 + 1];
+    const cx = this.coords[2 * p2];
+    const cy = this.coords[2 * p2 + 1];
+    const px = this._candidates[2 * t];
+    const py = this._candidates[2 * t + 1];
+
+    const pn = this._addPoint(px, py);
+
+    if (orient(ax, ay, bx, by, px, py) === 0) {
+      this._handleCollinear(pn, e0);
+    } else if (orient(bx, by, cx, cy, px, py) === 0) {
+      this._handleCollinear(pn, e1);
+    } else if (orient(cx, cy, ax, ay, px, py) === 0) {
+      this._handleCollinear(pn, e2);
+    } else {
+      const h0 = this._halfedges[e0];
+      const h1 = this._halfedges[e1];
+      const h2 = this._halfedges[e2];
+
+      const t0 = this._addTriangle(p0, p1, pn, h0, -1, -1, e0);
+
+      const t1 = this._addTriangle(p1, p2, pn, h1, -1, t0 + 1);
+
+      const t2 = this._addTriangle(p2, p0, pn, h2, t0 + 2, t1 + 1);
 
-        this._legalize(t1);
+      this._legalize(t0);
 
-        this._legalize(t2);
-      }
+      this._legalize(t1);
+
+      this._legalize(t2);
     }
-  }, {
-    key: "_addPoint",
-    value: function _addPoint(x, y) {
-      var i = this.coords.length >> 1;
-      this.coords.push(x, y);
-      return i;
+  }
+
+  _addPoint(x, y) {
+    const i = this.coords.length >> 1;
+    this.coords.push(x, y);
+    return i;
+  }
+
+  _addTriangle(a, b, c, ab, bc, ca, e = this.triangles.length) {
+    const t = e / 3;
+    this.triangles[e + 0] = a;
+    this.triangles[e + 1] = b;
+    this.triangles[e + 2] = c;
+    this._halfedges[e + 0] = ab;
+    this._halfedges[e + 1] = bc;
+    this._halfedges[e + 2] = ca;
+
+    if (ab >= 0) {
+      this._halfedges[ab] = e + 0;
     }
-  }, {
-    key: "_addTriangle",
-    value: function _addTriangle(a, b, c, ab, bc, ca) {
-      var e = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : this.triangles.length;
-      var t = e / 3;
-      this.triangles[e + 0] = a;
-      this.triangles[e + 1] = b;
-      this.triangles[e + 2] = c;
-      this._halfedges[e + 0] = ab;
-      this._halfedges[e + 1] = bc;
-      this._halfedges[e + 2] = ca;
-
-      if (ab >= 0) {
-        this._halfedges[ab] = e + 0;
-      }
 
-      if (bc >= 0) {
-        this._halfedges[bc] = e + 1;
-      }
+    if (bc >= 0) {
+      this._halfedges[bc] = e + 1;
+    }
 
-      if (ca >= 0) {
-        this._halfedges[ca] = e + 2;
-      }
+    if (ca >= 0) {
+      this._halfedges[ca] = e + 2;
+    }
+
+    this._candidates[2 * t + 0] = 0;
+    this._candidates[2 * t + 1] = 0;
+    this._queueIndices[t] = -1;
+    this._rms[t] = 0;
+    this._pending[this._pendingLen++] = t;
+    return e;
+  }
 
-      this._candidates[2 * t + 0] = 0;
-      this._candidates[2 * t + 1] = 0;
-      this._queueIndices[t] = -1;
-      this._rms[t] = 0;
-      this._pending[this._pendingLen++] = t;
-      return e;
+  _legalize(a) {
+    const b = this._halfedges[a];
+
+    if (b < 0) {
+      return;
     }
-  }, {
-    key: "_legalize",
-    value: function _legalize(a) {
-      var b = this._halfedges[a];
 
-      if (b < 0) {
-        return;
-      }
+    const a0 = a - a % 3;
+    const b0 = b - b % 3;
+    const al = a0 + (a + 1) % 3;
+    const ar = a0 + (a + 2) % 3;
+    const bl = b0 + (b + 2) % 3;
+    const br = b0 + (b + 1) % 3;
+    const p0 = this.triangles[ar];
+    const pr = this.triangles[a];
+    const pl = this.triangles[al];
+    const p1 = this.triangles[bl];
+    const coords = this.coords;
+
+    if (!inCircle(coords[2 * p0], coords[2 * p0 + 1], coords[2 * pr], coords[2 * pr + 1], coords[2 * pl], coords[2 * pl + 1], coords[2 * p1], coords[2 * p1 + 1])) {
+      return;
+    }
 
-      var a0 = a - a % 3;
-      var b0 = b - b % 3;
-      var al = a0 + (a + 1) % 3;
-      var ar = a0 + (a + 2) % 3;
-      var bl = b0 + (b + 2) % 3;
-      var br = b0 + (b + 1) % 3;
-      var p0 = this.triangles[ar];
-      var pr = this.triangles[a];
-      var pl = this.triangles[al];
-      var p1 = this.triangles[bl];
-      var coords = this.coords;
-
-      if (!inCircle(coords[2 * p0], coords[2 * p0 + 1], coords[2 * pr], coords[2 * pr + 1], coords[2 * pl], coords[2 * pl + 1], coords[2 * p1], coords[2 * p1 + 1])) {
-        return;
-      }
+    const hal = this._halfedges[al];
+    const har = this._halfedges[ar];
+    const hbl = this._halfedges[bl];
+    const hbr = this._halfedges[br];
+
+    this._queueRemove(a0 / 3);
+
+    this._queueRemove(b0 / 3);
+
+    const t0 = this._addTriangle(p0, p1, pl, -1, hbl, hal, a0);
 
-      var hal = this._halfedges[al];
-      var har = this._halfedges[ar];
-      var hbl = this._halfedges[bl];
-      var hbr = this._halfedges[br];
+    const t1 = this._addTriangle(p1, p0, pr, t0, har, hbr, b0);
 
-      this._queueRemove(a0 / 3);
+    this._legalize(t0 + 1);
 
-      this._queueRemove(b0 / 3);
+    this._legalize(t1 + 2);
+  }
+
+  _handleCollinear(pn, a) {
+    const a0 = a - a % 3;
+    const al = a0 + (a + 1) % 3;
+    const ar = a0 + (a + 2) % 3;
+    const p0 = this.triangles[ar];
+    const pr = this.triangles[a];
+    const pl = this.triangles[al];
+    const hal = this._halfedges[al];
+    const har = this._halfedges[ar];
+    const b = this._halfedges[a];
 
-      var t0 = this._addTriangle(p0, p1, pl, -1, hbl, hal, a0);
+    if (b < 0) {
+      const t0 = this._addTriangle(pn, p0, pr, -1, har, -1, a0);
 
-      var t1 = this._addTriangle(p1, p0, pr, t0, har, hbr, b0);
+      const t1 = this._addTriangle(p0, pn, pl, t0, -1, hal);
 
       this._legalize(t0 + 1);
 
       this._legalize(t1 + 2);
+
+      return;
     }
-  }, {
-    key: "_handleCollinear",
-    value: function _handleCollinear(pn, a) {
-      var a0 = a - a % 3;
-      var al = a0 + (a + 1) % 3;
-      var ar = a0 + (a + 2) % 3;
-      var p0 = this.triangles[ar];
-      var pr = this.triangles[a];
-      var pl = this.triangles[al];
-      var hal = this._halfedges[al];
-      var har = this._halfedges[ar];
-      var b = this._halfedges[a];
 
-      if (b < 0) {
-        var _t = this._addTriangle(pn, p0, pr, -1, har, -1, a0);
+    const b0 = b - b % 3;
+    const bl = b0 + (b + 2) % 3;
+    const br = b0 + (b + 1) % 3;
+    const p1 = this.triangles[bl];
+    const hbl = this._halfedges[bl];
+    const hbr = this._halfedges[br];
 
-        var _t2 = this._addTriangle(p0, pn, pl, _t, -1, hal);
+    this._queueRemove(b0 / 3);
 
-        this._legalize(_t + 1);
+    const t0 = this._addTriangle(p0, pr, pn, har, -1, -1, a0);
 
-        this._legalize(_t2 + 2);
+    const t1 = this._addTriangle(pr, p1, pn, hbr, -1, t0 + 1, b0);
 
-        return;
-      }
+    const t2 = this._addTriangle(p1, pl, pn, hbl, -1, t1 + 1);
 
-      var b0 = b - b % 3;
-      var bl = b0 + (b + 2) % 3;
-      var br = b0 + (b + 1) % 3;
-      var p1 = this.triangles[bl];
-      var hbl = this._halfedges[bl];
-      var hbr = this._halfedges[br];
+    const t3 = this._addTriangle(pl, p0, pn, hal, t0 + 2, t2 + 1);
 
-      this._queueRemove(b0 / 3);
+    this._legalize(t0);
 
-      var t0 = this._addTriangle(p0, pr, pn, har, -1, -1, a0);
+    this._legalize(t1);
 
-      var t1 = this._addTriangle(pr, p1, pn, hbr, -1, t0 + 1, b0);
+    this._legalize(t2);
 
-      var t2 = this._addTriangle(p1, pl, pn, hbl, -1, t1 + 1);
+    this._legalize(t3);
+  }
 
-      var t3 = this._addTriangle(pl, p0, pn, hal, t0 + 2, t2 + 1);
+  _queuePush(t, error, rms) {
+    const i = this._queue.length;
+    this._queueIndices[t] = i;
 
-      this._legalize(t0);
+    this._queue.push(t);
 
-      this._legalize(t1);
+    this._errors.push(error);
 
-      this._legalize(t2);
+    this._rmsSum += rms;
 
-      this._legalize(t3);
-    }
-  }, {
-    key: "_queuePush",
-    value: function _queuePush(t, error, rms) {
-      var i = this._queue.length;
-      this._queueIndices[t] = i;
+    this._queueUp(i);
+  }
 
-      this._queue.push(t);
+  _queuePop() {
+    const n = this._queue.length - 1;
 
-      this._errors.push(error);
+    this._queueSwap(0, n);
 
-      this._rmsSum += rms;
+    this._queueDown(0, n);
 
-      this._queueUp(i);
-    }
-  }, {
-    key: "_queuePop",
-    value: function _queuePop() {
-      var n = this._queue.length - 1;
+    return this._queuePopBack();
+  }
 
-      this._queueSwap(0, n);
+  _queuePopBack() {
+    const t = this._queue.pop();
 
-      this._queueDown(0, n);
+    this._errors.pop();
 
-      return this._queuePopBack();
-    }
-  }, {
-    key: "_queuePopBack",
-    value: function _queuePopBack() {
-      var t = this._queue.pop();
+    this._rmsSum -= this._rms[t];
+    this._queueIndices[t] = -1;
+    return t;
+  }
 
-      this._errors.pop();
+  _queueRemove(t) {
+    const i = this._queueIndices[t];
 
-      this._rmsSum -= this._rms[t];
-      this._queueIndices[t] = -1;
-      return t;
-    }
-  }, {
-    key: "_queueRemove",
-    value: function _queueRemove(t) {
-      var i = this._queueIndices[t];
-
-      if (i < 0) {
-        var it = this._pending.indexOf(t);
-
-        if (it !== -1) {
-          this._pending[it] = this._pending[--this._pendingLen];
-        } else {
-          throw new Error('Broken triangulation (something went wrong).');
-        }
+    if (i < 0) {
+      const it = this._pending.indexOf(t);
 
-        return;
+      if (it !== -1) {
+        this._pending[it] = this._pending[--this._pendingLen];
+      } else {
+        throw new Error('Broken triangulation (something went wrong).');
       }
 
-      var n = this._queue.length - 1;
+      return;
+    }
 
-      if (n !== i) {
-        this._queueSwap(i, n);
+    const n = this._queue.length - 1;
 
-        if (!this._queueDown(i, n)) {
-          this._queueUp(i);
-        }
-      }
+    if (n !== i) {
+      this._queueSwap(i, n);
 
-      this._queuePopBack();
-    }
-  }, {
-    key: "_queueLess",
-    value: function _queueLess(i, j) {
-      return this._errors[i] > this._errors[j];
-    }
-  }, {
-    key: "_queueSwap",
-    value: function _queueSwap(i, j) {
-      var pi = this._queue[i];
-      var pj = this._queue[j];
-      this._queue[i] = pj;
-      this._queue[j] = pi;
-      this._queueIndices[pi] = j;
-      this._queueIndices[pj] = i;
-      var e = this._errors[i];
-      this._errors[i] = this._errors[j];
-      this._errors[j] = e;
+      if (!this._queueDown(i, n)) {
+        this._queueUp(i);
+      }
     }
-  }, {
-    key: "_queueUp",
-    value: function _queueUp(j0) {
-      var j = j0;
 
-      while (true) {
-        var i = j - 1 >> 1;
+    this._queuePopBack();
+  }
 
-        if (i === j || !this._queueLess(j, i)) {
-          break;
-        }
+  _queueLess(i, j) {
+    return this._errors[i] > this._errors[j];
+  }
 
-        this._queueSwap(i, j);
+  _queueSwap(i, j) {
+    const pi = this._queue[i];
+    const pj = this._queue[j];
+    this._queue[i] = pj;
+    this._queue[j] = pi;
+    this._queueIndices[pi] = j;
+    this._queueIndices[pj] = i;
+    const e = this._errors[i];
+    this._errors[i] = this._errors[j];
+    this._errors[j] = e;
+  }
+
+  _queueUp(j0) {
+    let j = j0;
+
+    while (true) {
+      const i = j - 1 >> 1;
 
-        j = i;
+      if (i === j || !this._queueLess(j, i)) {
+        break;
       }
-    }
-  }, {
-    key: "_queueDown",
-    value: function _queueDown(i0, n) {
-      var i = i0;
 
-      while (true) {
-        var j1 = 2 * i + 1;
+      this._queueSwap(i, j);
 
-        if (j1 >= n || j1 < 0) {
-          break;
-        }
+      j = i;
+    }
+  }
 
-        var j2 = j1 + 1;
-        var j = j1;
+  _queueDown(i0, n) {
+    let i = i0;
 
-        if (j2 < n && this._queueLess(j2, j1)) {
-          j = j2;
-        }
+    while (true) {
+      const j1 = 2 * i + 1;
 
-        if (!this._queueLess(j, i)) {
-          break;
-        }
+      if (j1 >= n || j1 < 0) {
+        break;
+      }
 
-        this._queueSwap(i, j);
+      const j2 = j1 + 1;
+      let j = j1;
 
-        i = j;
+      if (j2 < n && this._queueLess(j2, j1)) {
+        j = j2;
       }
 
-      return i > i0;
+      if (!this._queueLess(j, i)) {
+        break;
+      }
+
+      this._queueSwap(i, j);
+
+      i = j;
     }
-  }]);
-  return Delatin;
-}();
+
+    return i > i0;
+  }
+
+}
 
 exports.default = Delatin;
 
@@ -492,15 +459,15 @@ function orient(ax, ay, bx, by, cx, cy) {
 }
 
 function inCircle(ax, ay, bx, by, cx, cy, px, py) {
-  var dx = ax - px;
-  var dy = ay - py;
-  var ex = bx - px;
-  var ey = by - py;
-  var fx = cx - px;
-  var fy = cy - py;
-  var ap = dx * dx + dy * dy;
-  var bp = ex * ex + ey * ey;
-  var cp = fx * fx + fy * fy;
+  const dx = ax - px;
+  const dy = ay - py;
+  const ex = bx - px;
+  const ey = by - py;
+  const fx = cx - px;
+  const fy = cy - py;
+  const ap = dx * dx + dy * dy;
+  const bp = ex * ex + ey * ey;
+  const cp = fx * fx + fy * fy;
   return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + ap * (ex * fy - ey * fx) < 0;
 }
 //# sourceMappingURL=index.js.map