Index: node_modules/robust-predicates/umd/incircle.js
===================================================================
--- node_modules/robust-predicates/umd/incircle.js	(revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a)
+++ node_modules/robust-predicates/umd/incircle.js	(revision e4c61dd6cd86e06265bc2bd91adba84a0f04044a)
@@ -0,0 +1,908 @@
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.predicates = {}));
+})(this, (function (exports) { 'use strict';
+
+const epsilon = 1.1102230246251565e-16;
+const splitter = 134217729;
+const resulterrbound = (3 + 8 * epsilon) * epsilon;
+
+// fast_expansion_sum_zeroelim routine from oritinal code
+function sum(elen, e, flen, f, h) {
+    let Q, Qnew, hh, bvirt;
+    let enow = e[0];
+    let fnow = f[0];
+    let eindex = 0;
+    let findex = 0;
+    if ((fnow > enow) === (fnow > -enow)) {
+        Q = enow;
+        enow = e[++eindex];
+    } else {
+        Q = fnow;
+        fnow = f[++findex];
+    }
+    let hindex = 0;
+    if (eindex < elen && findex < flen) {
+        if ((fnow > enow) === (fnow > -enow)) {
+            Qnew = enow + Q;
+            hh = Q - (Qnew - enow);
+            enow = e[++eindex];
+        } else {
+            Qnew = fnow + Q;
+            hh = Q - (Qnew - fnow);
+            fnow = f[++findex];
+        }
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        while (eindex < elen && findex < flen) {
+            if ((fnow > enow) === (fnow > -enow)) {
+                Qnew = Q + enow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (enow - bvirt);
+                enow = e[++eindex];
+            } else {
+                Qnew = Q + fnow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+                fnow = f[++findex];
+            }
+            Q = Qnew;
+            if (hh !== 0) {
+                h[hindex++] = hh;
+            }
+        }
+    }
+    while (eindex < elen) {
+        Qnew = Q + enow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (enow - bvirt);
+        enow = e[++eindex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    while (findex < flen) {
+        Qnew = Q + fnow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+        fnow = f[++findex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function sum_three(alen, a, blen, b, clen, c, tmp, out) {
+    return sum(sum(alen, a, blen, b, tmp), tmp, clen, c, out);
+}
+
+// scale_expansion_zeroelim routine from oritinal code
+function scale(elen, e, b, h) {
+    let Q, sum, hh, product1, product0;
+    let bvirt, c, ahi, alo, bhi, blo;
+
+    c = splitter * b;
+    bhi = c - (c - b);
+    blo = b - bhi;
+    let enow = e[0];
+    Q = enow * b;
+    c = splitter * enow;
+    ahi = c - (c - enow);
+    alo = enow - ahi;
+    hh = alo * blo - (Q - ahi * bhi - alo * bhi - ahi * blo);
+    let hindex = 0;
+    if (hh !== 0) {
+        h[hindex++] = hh;
+    }
+    for (let i = 1; i < elen; i++) {
+        enow = e[i];
+        product1 = enow * b;
+        c = splitter * enow;
+        ahi = c - (c - enow);
+        alo = enow - ahi;
+        product0 = alo * blo - (product1 - ahi * bhi - alo * bhi - ahi * blo);
+        sum = Q + product0;
+        bvirt = sum - Q;
+        hh = Q - (sum - bvirt) + (product0 - bvirt);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        Q = product1 + sum;
+        hh = sum - (Q - product1);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+function estimate(elen, e) {
+    let Q = e[0];
+    for (let i = 1; i < elen; i++) Q += e[i];
+    return Q;
+}
+
+function vec(n) {
+    return new Float64Array(n);
+}
+
+const iccerrboundA = (10 + 96 * epsilon) * epsilon;
+const iccerrboundB = (4 + 48 * epsilon) * epsilon;
+const iccerrboundC = (44 + 576 * epsilon) * epsilon * epsilon;
+
+const bc = vec(4);
+const ca = vec(4);
+const ab = vec(4);
+const aa = vec(4);
+const bb = vec(4);
+const cc = vec(4);
+const u = vec(4);
+const v = vec(4);
+const axtbc = vec(8);
+const aytbc = vec(8);
+const bxtca = vec(8);
+const bytca = vec(8);
+const cxtab = vec(8);
+const cytab = vec(8);
+const abt = vec(8);
+const bct = vec(8);
+const cat = vec(8);
+const abtt = vec(4);
+const bctt = vec(4);
+const catt = vec(4);
+
+const _8 = vec(8);
+const _16 = vec(16);
+const _16b = vec(16);
+const _16c = vec(16);
+const _32 = vec(32);
+const _32b = vec(32);
+const _48 = vec(48);
+const _64 = vec(64);
+
+let fin = vec(1152);
+let fin2 = vec(1152);
+
+function finadd(finlen, a, alen) {
+    finlen = sum(finlen, fin, a, alen, fin2);
+    const tmp = fin; fin = fin2; fin2 = tmp;
+    return finlen;
+}
+
+function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
+    let finlen;
+    let adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail;
+    let axtbclen, aytbclen, bxtcalen, bytcalen, cxtablen, cytablen;
+    let abtlen, bctlen, catlen;
+    let abttlen, bcttlen, cattlen;
+    let n1, n0;
+
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+
+    s1 = bdx * cdy;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = cdx * bdy;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc[3] = u3;
+    s1 = cdx * ady;
+    c = splitter * cdx;
+    ahi = c - (c - cdx);
+    alo = cdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = adx * cdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * cdy;
+    bhi = c - (c - cdy);
+    blo = cdy - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ca[3] = u3;
+    s1 = adx * bdy;
+    c = splitter * adx;
+    ahi = c - (c - adx);
+    alo = adx - ahi;
+    c = splitter * bdy;
+    bhi = c - (c - bdy);
+    blo = bdy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = bdx * ady;
+    c = splitter * bdx;
+    ahi = c - (c - bdx);
+    alo = bdx - ahi;
+    c = splitter * ady;
+    bhi = c - (c - ady);
+    blo = ady - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab[3] = u3;
+
+    finlen = sum(
+        sum(
+            sum(
+                scale(scale(4, bc, adx, _8), _8, adx, _16), _16,
+                scale(scale(4, bc, ady, _8), _8, ady, _16b), _16b, _32), _32,
+            sum(
+                scale(scale(4, ca, bdx, _8), _8, bdx, _16), _16,
+                scale(scale(4, ca, bdy, _8), _8, bdy, _16b), _16b, _32b), _32b, _64), _64,
+        sum(
+            scale(scale(4, ab, cdx, _8), _8, cdx, _16), _16,
+            scale(scale(4, ab, cdy, _8), _8, cdy, _16b), _16b, _32), _32, fin);
+
+    let det = estimate(finlen, fin);
+    let errbound = iccerrboundB * permanent;
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    bvirt = ax - adx;
+    adxtail = ax - (adx + bvirt) + (bvirt - dx);
+    bvirt = ay - ady;
+    adytail = ay - (ady + bvirt) + (bvirt - dy);
+    bvirt = bx - bdx;
+    bdxtail = bx - (bdx + bvirt) + (bvirt - dx);
+    bvirt = by - bdy;
+    bdytail = by - (bdy + bvirt) + (bvirt - dy);
+    bvirt = cx - cdx;
+    cdxtail = cx - (cdx + bvirt) + (bvirt - dx);
+    bvirt = cy - cdy;
+    cdytail = cy - (cdy + bvirt) + (bvirt - dy);
+    if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 && adytail === 0 && bdytail === 0 && cdytail === 0) {
+        return det;
+    }
+
+    errbound = iccerrboundC * permanent + resulterrbound * Math.abs(det);
+    det += ((adx * adx + ady * ady) * ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail)) +
+        2 * (adx * adxtail + ady * adytail) * (bdx * cdy - bdy * cdx)) +
+        ((bdx * bdx + bdy * bdy) * ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail)) +
+        2 * (bdx * bdxtail + bdy * bdytail) * (cdx * ady - cdy * adx)) +
+        ((cdx * cdx + cdy * cdy) * ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail)) +
+        2 * (cdx * cdxtail + cdy * cdytail) * (adx * bdy - ady * bdx));
+
+    if (det >= errbound || -det >= errbound) {
+        return det;
+    }
+
+    if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {
+        s1 = adx * adx;
+        c = splitter * adx;
+        ahi = c - (c - adx);
+        alo = adx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = ady * ady;
+        c = splitter * ady;
+        ahi = c - (c - ady);
+        alo = ady - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        aa[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        aa[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        aa[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        aa[3] = u3;
+    }
+    if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {
+        s1 = bdx * bdx;
+        c = splitter * bdx;
+        ahi = c - (c - bdx);
+        alo = bdx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = bdy * bdy;
+        c = splitter * bdy;
+        ahi = c - (c - bdy);
+        alo = bdy - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        bb[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        bb[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        bb[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        bb[3] = u3;
+    }
+    if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {
+        s1 = cdx * cdx;
+        c = splitter * cdx;
+        ahi = c - (c - cdx);
+        alo = cdx - ahi;
+        s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
+        t1 = cdy * cdy;
+        c = splitter * cdy;
+        ahi = c - (c - cdy);
+        alo = cdy - ahi;
+        t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
+        _i = s0 + t0;
+        bvirt = _i - s0;
+        cc[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        cc[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        cc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        cc[3] = u3;
+    }
+
+    if (adxtail !== 0) {
+        axtbclen = scale(4, bc, adxtail, axtbc);
+        finlen = finadd(finlen, sum_three(
+            scale(axtbclen, axtbc, 2 * adx, _16), _16,
+            scale(scale(4, cc, adxtail, _8), _8, bdy, _16b), _16b,
+            scale(scale(4, bb, adxtail, _8), _8, -cdy, _16c), _16c, _32, _48), _48);
+    }
+    if (adytail !== 0) {
+        aytbclen = scale(4, bc, adytail, aytbc);
+        finlen = finadd(finlen, sum_three(
+            scale(aytbclen, aytbc, 2 * ady, _16), _16,
+            scale(scale(4, bb, adytail, _8), _8, cdx, _16b), _16b,
+            scale(scale(4, cc, adytail, _8), _8, -bdx, _16c), _16c, _32, _48), _48);
+    }
+    if (bdxtail !== 0) {
+        bxtcalen = scale(4, ca, bdxtail, bxtca);
+        finlen = finadd(finlen, sum_three(
+            scale(bxtcalen, bxtca, 2 * bdx, _16), _16,
+            scale(scale(4, aa, bdxtail, _8), _8, cdy, _16b), _16b,
+            scale(scale(4, cc, bdxtail, _8), _8, -ady, _16c), _16c, _32, _48), _48);
+    }
+    if (bdytail !== 0) {
+        bytcalen = scale(4, ca, bdytail, bytca);
+        finlen = finadd(finlen, sum_three(
+            scale(bytcalen, bytca, 2 * bdy, _16), _16,
+            scale(scale(4, cc, bdytail, _8), _8, adx, _16b), _16b,
+            scale(scale(4, aa, bdytail, _8), _8, -cdx, _16c), _16c, _32, _48), _48);
+    }
+    if (cdxtail !== 0) {
+        cxtablen = scale(4, ab, cdxtail, cxtab);
+        finlen = finadd(finlen, sum_three(
+            scale(cxtablen, cxtab, 2 * cdx, _16), _16,
+            scale(scale(4, bb, cdxtail, _8), _8, ady, _16b), _16b,
+            scale(scale(4, aa, cdxtail, _8), _8, -bdy, _16c), _16c, _32, _48), _48);
+    }
+    if (cdytail !== 0) {
+        cytablen = scale(4, ab, cdytail, cytab);
+        finlen = finadd(finlen, sum_three(
+            scale(cytablen, cytab, 2 * cdy, _16), _16,
+            scale(scale(4, aa, cdytail, _8), _8, bdx, _16b), _16b,
+            scale(scale(4, bb, cdytail, _8), _8, -adx, _16c), _16c, _32, _48), _48);
+    }
+
+    if (adxtail !== 0 || adytail !== 0) {
+        if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {
+            s1 = bdxtail * cdy;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * cdy;
+            bhi = c - (c - cdy);
+            blo = cdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdx * cdytail;
+            c = splitter * bdx;
+            ahi = c - (c - bdx);
+            alo = bdx - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            s1 = cdxtail * -bdy;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * -bdy;
+            bhi = c - (c - -bdy);
+            blo = -bdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdx * -bdytail;
+            c = splitter * cdx;
+            ahi = c - (c - cdx);
+            alo = cdx - ahi;
+            c = splitter * -bdytail;
+            bhi = c - (c - -bdytail);
+            blo = -bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            bctlen = sum(4, u, 4, v, bct);
+            s1 = bdxtail * cdytail;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdxtail * bdytail;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            bctt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            bctt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            bctt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            bctt[3] = u3;
+            bcttlen = 4;
+        } else {
+            bct[0] = 0;
+            bctlen = 1;
+            bctt[0] = 0;
+            bcttlen = 1;
+        }
+        if (adxtail !== 0) {
+            const len = scale(bctlen, bct, adxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(axtbclen, axtbc, adxtail, _16), _16,
+                scale(len, _16c, 2 * adx, _32), _32, _48), _48);
+
+            const len2 = scale(bcttlen, bctt, adxtail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * adx, _16), _16,
+                scale(len2, _8, adxtail, _16b), _16b,
+                scale(len, _16c, adxtail, _32), _32, _32b, _64), _64);
+
+            if (bdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, cc, adxtail, _8), _8, bdytail, _16), _16);
+            }
+            if (cdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, bb, -adxtail, _8), _8, cdytail, _16), _16);
+            }
+        }
+        if (adytail !== 0) {
+            const len = scale(bctlen, bct, adytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(aytbclen, aytbc, adytail, _16), _16,
+                scale(len, _16c, 2 * ady, _32), _32, _48), _48);
+
+            const len2 = scale(bcttlen, bctt, adytail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * ady, _16), _16,
+                scale(len2, _8, adytail, _16b), _16b,
+                scale(len, _16c, adytail, _32), _32, _32b, _64), _64);
+        }
+    }
+    if (bdxtail !== 0 || bdytail !== 0) {
+        if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {
+            s1 = cdxtail * ady;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * ady;
+            bhi = c - (c - ady);
+            blo = ady - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdx * adytail;
+            c = splitter * cdx;
+            ahi = c - (c - cdx);
+            alo = cdx - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            n1 = -cdy;
+            n0 = -cdytail;
+            s1 = adxtail * n1;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * n1;
+            bhi = c - (c - n1);
+            blo = n1 - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adx * n0;
+            c = splitter * adx;
+            ahi = c - (c - adx);
+            alo = adx - ahi;
+            c = splitter * n0;
+            bhi = c - (c - n0);
+            blo = n0 - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            catlen = sum(4, u, 4, v, cat);
+            s1 = cdxtail * adytail;
+            c = splitter * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adxtail * cdytail;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * cdytail;
+            bhi = c - (c - cdytail);
+            blo = cdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            catt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            catt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            catt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            catt[3] = u3;
+            cattlen = 4;
+        } else {
+            cat[0] = 0;
+            catlen = 1;
+            catt[0] = 0;
+            cattlen = 1;
+        }
+        if (bdxtail !== 0) {
+            const len = scale(catlen, cat, bdxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(bxtcalen, bxtca, bdxtail, _16), _16,
+                scale(len, _16c, 2 * bdx, _32), _32, _48), _48);
+
+            const len2 = scale(cattlen, catt, bdxtail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * bdx, _16), _16,
+                scale(len2, _8, bdxtail, _16b), _16b,
+                scale(len, _16c, bdxtail, _32), _32, _32b, _64), _64);
+
+            if (cdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, aa, bdxtail, _8), _8, cdytail, _16), _16);
+            }
+            if (adytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, cc, -bdxtail, _8), _8, adytail, _16), _16);
+            }
+        }
+        if (bdytail !== 0) {
+            const len = scale(catlen, cat, bdytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(bytcalen, bytca, bdytail, _16), _16,
+                scale(len, _16c, 2 * bdy, _32), _32, _48), _48);
+
+            const len2 = scale(cattlen, catt, bdytail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * bdy, _16), _16,
+                scale(len2, _8, bdytail, _16b), _16b,
+                scale(len, _16c, bdytail, _32), _32,  _32b, _64), _64);
+        }
+    }
+    if (cdxtail !== 0 || cdytail !== 0) {
+        if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {
+            s1 = adxtail * bdy;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * bdy;
+            bhi = c - (c - bdy);
+            blo = bdy - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = adx * bdytail;
+            c = splitter * adx;
+            ahi = c - (c - adx);
+            alo = adx - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
+            n1 = -ady;
+            n0 = -adytail;
+            s1 = bdxtail * n1;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * n1;
+            bhi = c - (c - n1);
+            blo = n1 - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdx * n0;
+            c = splitter * bdx;
+            ahi = c - (c - bdx);
+            alo = bdx - ahi;
+            c = splitter * n0;
+            bhi = c - (c - n0);
+            blo = n0 - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 + t0;
+            bvirt = _i - s0;
+            v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            v[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            v[3] = u3;
+            abtlen = sum(4, u, 4, v, abt);
+            s1 = adxtail * bdytail;
+            c = splitter * adxtail;
+            ahi = c - (c - adxtail);
+            alo = adxtail - ahi;
+            c = splitter * bdytail;
+            bhi = c - (c - bdytail);
+            blo = bdytail - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = bdxtail * adytail;
+            c = splitter * bdxtail;
+            ahi = c - (c - bdxtail);
+            alo = bdxtail - ahi;
+            c = splitter * adytail;
+            bhi = c - (c - adytail);
+            blo = adytail - bhi;
+            t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+            _i = s0 - t0;
+            bvirt = s0 - _i;
+            abtt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            abtt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            abtt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            abtt[3] = u3;
+            abttlen = 4;
+        } else {
+            abt[0] = 0;
+            abtlen = 1;
+            abtt[0] = 0;
+            abttlen = 1;
+        }
+        if (cdxtail !== 0) {
+            const len = scale(abtlen, abt, cdxtail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(cxtablen, cxtab, cdxtail, _16), _16,
+                scale(len, _16c, 2 * cdx, _32), _32, _48), _48);
+
+            const len2 = scale(abttlen, abtt, cdxtail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * cdx, _16), _16,
+                scale(len2, _8, cdxtail, _16b), _16b,
+                scale(len, _16c, cdxtail, _32), _32, _32b, _64), _64);
+
+            if (adytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, bb, cdxtail, _8), _8, adytail, _16), _16);
+            }
+            if (bdytail !== 0) {
+                finlen = finadd(finlen, scale(scale(4, aa, -cdxtail, _8), _8, bdytail, _16), _16);
+            }
+        }
+        if (cdytail !== 0) {
+            const len = scale(abtlen, abt, cdytail, _16c);
+            finlen = finadd(finlen, sum(
+                scale(cytablen, cytab, cdytail, _16), _16,
+                scale(len, _16c, 2 * cdy, _32), _32, _48), _48);
+
+            const len2 = scale(abttlen, abtt, cdytail, _8);
+            finlen = finadd(finlen, sum_three(
+                scale(len2, _8, 2 * cdy, _16), _16,
+                scale(len2, _8, cdytail, _16b), _16b,
+                scale(len, _16c, cdytail, _32), _32, _32b, _64), _64);
+        }
+    }
+
+    return fin[finlen - 1];
+}
+
+function incircle(ax, ay, bx, by, cx, cy, dx, dy) {
+    const adx = ax - dx;
+    const bdx = bx - dx;
+    const cdx = cx - dx;
+    const ady = ay - dy;
+    const bdy = by - dy;
+    const cdy = cy - dy;
+
+    const bdxcdy = bdx * cdy;
+    const cdxbdy = cdx * bdy;
+    const alift = adx * adx + ady * ady;
+
+    const cdxady = cdx * ady;
+    const adxcdy = adx * cdy;
+    const blift = bdx * bdx + bdy * bdy;
+
+    const adxbdy = adx * bdy;
+    const bdxady = bdx * ady;
+    const clift = cdx * cdx + cdy * cdy;
+
+    const det =
+        alift * (bdxcdy - cdxbdy) +
+        blift * (cdxady - adxcdy) +
+        clift * (adxbdy - bdxady);
+
+    const permanent =
+        (Math.abs(bdxcdy) + Math.abs(cdxbdy)) * alift +
+        (Math.abs(cdxady) + Math.abs(adxcdy)) * blift +
+        (Math.abs(adxbdy) + Math.abs(bdxady)) * clift;
+
+    const errbound = iccerrboundA * permanent;
+
+    if (det > errbound || -det > errbound) {
+        return det;
+    }
+    return incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent);
+}
+
+function incirclefast(ax, ay, bx, by, cx, cy, dx, dy) {
+    const adx = ax - dx;
+    const ady = ay - dy;
+    const bdx = bx - dx;
+    const bdy = by - dy;
+    const cdx = cx - dx;
+    const cdy = cy - dy;
+
+    const abdet = adx * bdy - bdx * ady;
+    const bcdet = bdx * cdy - cdx * bdy;
+    const cadet = cdx * ady - adx * cdy;
+    const alift = adx * adx + ady * ady;
+    const blift = bdx * bdx + bdy * bdy;
+    const clift = cdx * cdx + cdy * cdy;
+
+    return alift * bcdet + blift * cadet + clift * abdet;
+}
+
+exports.incircle = incircle;
+exports.incirclefast = incirclefast;
+
+}));