clipper2-ts 2.0.1-13 → 2.0.1-15

package/dist/Shewchuk.js

@@ -0,0 +1,953 @@
+// Adaptive precision geometric predicates ported from
+// Jonathan Richard Shewchuk's predicates.c (public domain).
+// https://www.cs.cmu.edu/~quake/robust.html
+const EPSILON = 1.1102230246251565e-16; // 2^-53
+const SPLITTER = 134217729; // 2^27 + 1
+const resulterrbound = (3 + 8 * EPSILON) * EPSILON;
+const ccwerrboundA = (3 + 16 * EPSILON) * EPSILON;
+const ccwerrboundB = (2 + 12 * EPSILON) * EPSILON;
+const ccwerrboundC = (9 + 64 * EPSILON) * EPSILON * EPSILON;
+const iccerrboundA = (10 + 96 * EPSILON) * EPSILON;
+const iccerrboundB = (4 + 48 * EPSILON) * EPSILON;
+const iccerrboundC = (44 + 576 * EPSILON) * EPSILON * EPSILON;
+// Pre-allocated working arrays
+const o2dB = new Float64Array(4);
+const o2dC1 = new Float64Array(8);
+const o2dC2 = new Float64Array(12);
+const o2dD = new Float64Array(16);
+const o2du = new Float64Array(4);
+const icbc = new Float64Array(4);
+const icca = new Float64Array(4);
+const icab = new Float64Array(4);
+const icaa = new Float64Array(4);
+const icbb = new Float64Array(4);
+const iccc = new Float64Array(4);
+const icu = new Float64Array(4);
+const icaxtbc = new Float64Array(8);
+const icaytbc = new Float64Array(8);
+const icbxtca = new Float64Array(8);
+const icbytca = new Float64Array(8);
+const iccxtab = new Float64Array(8);
+const iccytab = new Float64Array(8);
+const icabt = new Float64Array(8);
+const icbct = new Float64Array(8);
+const iccat = new Float64Array(8);
+const icabtt = new Float64Array(4);
+const icbctt = new Float64Array(4);
+const iccatt = new Float64Array(4);
+const ic8 = new Float64Array(8);
+const ic16 = new Float64Array(16);
+const ic16b = new Float64Array(16);
+const ic16c = new Float64Array(16);
+const ic32 = new Float64Array(32);
+const ic32b = new Float64Array(32);
+const ic48 = new Float64Array(48);
+const ic64 = new Float64Array(64);
+const icv = new Float64Array(4);
+let icfin = new Float64Array(1152);
+let icfin2 = new Float64Array(1152);
+// fast_expansion_sum_zeroelim from predicates.c
+function expansionSum(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;
+}
+// scale_expansion_zeroelim from predicates.c
+function scaleExpansion(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;
+}
+// orient2d
+function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
+    let bvirt, c, ahi, alo, bhi, blo;
+    let _i, _j, _0, s1, s0, t1, t0, u3;
+    let acxtail, acytail, bcxtail, bcytail;
+    const acx = ax - cx, bcx = bx - cx, acy = ay - cy, bcy = by - cy;
+    s1 = acx * bcy;
+    c = SPLITTER * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = SPLITTER * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcx;
+    c = SPLITTER * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = SPLITTER * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    o2dB[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    o2dB[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    o2dB[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    o2dB[3] = u3;
+    let det = estimate(4, o2dB);
+    let errbound = ccwerrboundB * detsum;
+    if (det >= errbound || -det >= errbound)
+        return det;
+    bvirt = ax - acx;
+    acxtail = ax - (acx + bvirt) + (bvirt - cx);
+    bvirt = bx - bcx;
+    bcxtail = bx - (bcx + bvirt) + (bvirt - cx);
+    bvirt = ay - acy;
+    acytail = ay - (acy + bvirt) + (bvirt - cy);
+    bvirt = by - bcy;
+    bcytail = by - (bcy + bvirt) + (bvirt - cy);
+    if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0)
+        return det;
+    errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
+    det += (acx * bcytail + bcy * acxtail) - (acy * bcxtail + bcx * acytail);
+    if (det >= errbound || -det >= errbound)
+        return det;
+    s1 = acxtail * bcy;
+    c = SPLITTER * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = SPLITTER * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcx;
+    c = SPLITTER * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = SPLITTER * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    o2du[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    o2du[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    o2du[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    o2du[3] = u3;
+    const C1len = expansionSum(4, o2dB, 4, o2du, o2dC1);
+    s1 = acx * bcytail;
+    c = SPLITTER * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = SPLITTER * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcxtail;
+    c = SPLITTER * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = SPLITTER * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    o2du[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    o2du[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    o2du[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    o2du[3] = u3;
+    const C2len = expansionSum(C1len, o2dC1, 4, o2du, o2dC2);
+    s1 = acxtail * bcytail;
+    c = SPLITTER * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = SPLITTER * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcxtail;
+    c = SPLITTER * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = SPLITTER * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    o2du[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    o2du[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    o2du[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    o2du[3] = u3;
+    const Dlen = expansionSum(C2len, o2dC2, 4, o2du, o2dD);
+    return o2dD[Dlen - 1];
+}
+// orient2d sign, with adaptive exact fallback
+export function adaptiveOrient2dSign(ax, ay, bx, by, cx, cy) {
+    const detleft = (ay - cy) * (bx - cx);
+    const detright = (ax - cx) * (by - cy);
+    const det = detleft - detright;
+    if (detleft > 0) {
+        if (detright <= 0)
+            return det > 0 ? 1 : det < 0 ? -1 : 0;
+    }
+    else if (detleft < 0) {
+        if (detright >= 0)
+            return det > 0 ? 1 : det < 0 ? -1 : 0;
+    }
+    else {
+        return det > 0 ? 1 : det < 0 ? -1 : 0;
+    }
+    const detsum = detleft > 0 ? detleft + detright : -detleft - detright;
+    const errbound = ccwerrboundA * detsum;
+    if (det >= errbound || -det >= errbound)
+        return det > 0 ? 1 : -1;
+    const result = orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
+    return result > 0 ? 1 : result < 0 ? -1 : 0;
+}
+// incircle
+function icFinadd(finlen, alen, a) {
+    finlen = expansionSum(finlen, icfin, alen, a, icfin2);
+    const tmp = icfin;
+    icfin = icfin2;
+    icfin2 = tmp;
+    return finlen;
+}
+function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
+    let bvirt, c, ahi, alo, bhi, blo;
+    let _i, _j, _0, s1, s0, t1, t0, u3;
+    let finlen;
+    let adxtail, bdxtail, cdxtail;
+    let adytail, bdytail, cdytail;
+    let axtbclen = 0, aytbclen = 0, bxtcalen = 0, bytcalen = 0, cxtablen = 0, cytablen = 0;
+    let n1, n0;
+    const adx = ax - dx, bdx = bx - dx, cdx = cx - dx;
+    const ady = ay - dy, bdy = by - dy, cdy = cy - dy;
+    // bc = bdx*cdy - cdx*bdy as exact expansion
+    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;
+    icbc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    icbc[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    icbc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    icbc[3] = u3;
+    // ca = cdx*ady - adx*cdy
+    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;
+    icca[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    icca[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    icca[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    icca[3] = u3;
+    // ab = adx*bdy - bdx*ady
+    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;
+    icab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    icab[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    icab[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    icab[3] = u3;
+    finlen = expansionSum(expansionSum(expansionSum(scaleExpansion(scaleExpansion(4, icbc, adx, ic8), ic8, adx, ic16), ic16, scaleExpansion(scaleExpansion(4, icbc, ady, ic8), ic8, ady, ic16b), ic16b, ic32), ic32, expansionSum(scaleExpansion(scaleExpansion(4, icca, bdx, ic8), ic8, bdx, ic16), ic16, scaleExpansion(scaleExpansion(4, icca, bdy, ic8), ic8, bdy, ic16b), ic16b, ic32b), ic32b, ic64), ic64, expansionSum(scaleExpansion(scaleExpansion(4, icab, cdx, ic8), ic8, cdx, ic16), ic16, scaleExpansion(scaleExpansion(4, icab, cdy, ic8), ic8, cdy, ic16b), ic16b, ic32), ic32, icfin);
+    let det = estimate(finlen, icfin);
+    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;
+    // Stage C: full exact arithmetic with tail terms
+    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;
+        icaa[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        icaa[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        icaa[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        icaa[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;
+        icbb[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        icbb[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        icbb[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        icbb[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;
+        iccc[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 + t1;
+        bvirt = _i - _0;
+        iccc[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        iccc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        iccc[3] = u3;
+    }
+    const sum3 = (al, a, bl, b, cl, cv) => {
+        const tl = expansionSum(al, a, bl, b, ic32);
+        return expansionSum(tl, ic32, cl, cv, ic48);
+    };
+    if (adxtail !== 0) {
+        axtbclen = scaleExpansion(4, icbc, adxtail, icaxtbc);
+        finlen = icFinadd(finlen, sum3(scaleExpansion(axtbclen, icaxtbc, 2 * adx, ic16), ic16, scaleExpansion(scaleExpansion(4, iccc, adxtail, ic8), ic8, bdy, ic16b), ic16b, scaleExpansion(scaleExpansion(4, icbb, adxtail, ic8), ic8, -cdy, ic16c), ic16c), ic48);
+    }
+    if (adytail !== 0) {
+        aytbclen = scaleExpansion(4, icbc, adytail, icaytbc);
+        finlen = icFinadd(finlen, sum3(scaleExpansion(aytbclen, icaytbc, 2 * ady, ic16), ic16, scaleExpansion(scaleExpansion(4, icbb, adytail, ic8), ic8, cdx, ic16b), ic16b, scaleExpansion(scaleExpansion(4, iccc, adytail, ic8), ic8, -bdx, ic16c), ic16c), ic48);
+    }
+    if (bdxtail !== 0) {
+        bxtcalen = scaleExpansion(4, icca, bdxtail, icbxtca);
+        finlen = icFinadd(finlen, sum3(scaleExpansion(bxtcalen, icbxtca, 2 * bdx, ic16), ic16, scaleExpansion(scaleExpansion(4, icaa, bdxtail, ic8), ic8, cdy, ic16b), ic16b, scaleExpansion(scaleExpansion(4, iccc, bdxtail, ic8), ic8, -ady, ic16c), ic16c), ic48);
+    }
+    if (bdytail !== 0) {
+        bytcalen = scaleExpansion(4, icca, bdytail, icbytca);
+        finlen = icFinadd(finlen, sum3(scaleExpansion(bytcalen, icbytca, 2 * bdy, ic16), ic16, scaleExpansion(scaleExpansion(4, iccc, bdytail, ic8), ic8, adx, ic16b), ic16b, scaleExpansion(scaleExpansion(4, icaa, bdytail, ic8), ic8, -cdx, ic16c), ic16c), ic48);
+    }
+    if (cdxtail !== 0) {
+        cxtablen = scaleExpansion(4, icab, cdxtail, iccxtab);
+        finlen = icFinadd(finlen, sum3(scaleExpansion(cxtablen, iccxtab, 2 * cdx, ic16), ic16, scaleExpansion(scaleExpansion(4, icbb, cdxtail, ic8), ic8, ady, ic16b), ic16b, scaleExpansion(scaleExpansion(4, icaa, cdxtail, ic8), ic8, -bdy, ic16c), ic16c), ic48);
+    }
+    if (cdytail !== 0) {
+        cytablen = scaleExpansion(4, icab, cdytail, iccytab);
+        finlen = icFinadd(finlen, sum3(scaleExpansion(cytablen, iccytab, 2 * cdy, ic16), ic16, scaleExpansion(scaleExpansion(4, icaa, cdytail, ic8), ic8, bdx, ic16b), ic16b, scaleExpansion(scaleExpansion(4, icbb, cdytail, ic8), ic8, -adx, ic16c), ic16c), ic48);
+    }
+    // Cross-tail terms
+    let bctlen, catlen, abtlen;
+    let bcttlen, cattlen, abttlen;
+    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;
+            icu[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            icu[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            icu[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            icu[3] = u3;
+            n1 = -bdy;
+            n0 = -bdytail;
+            s1 = cdxtail * n1;
+            c = SPLITTER * cdxtail;
+            ahi = c - (c - cdxtail);
+            alo = cdxtail - ahi;
+            c = SPLITTER * n1;
+            bhi = c - (c - n1);
+            blo = n1 - bhi;
+            s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+            t1 = cdx * n0;
+            c = SPLITTER * cdx;
+            ahi = c - (c - cdx);
+            alo = cdx - 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;
+            icv[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            icv[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            icv[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            icv[3] = u3;
+            bctlen = expansionSum(4, icu, 4, icv, icbct);
+            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;
+            icbctt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            icbctt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            icbctt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            icbctt[3] = u3;
+            bcttlen = 4;
+        }
+        else {
+            icbct[0] = 0;
+            bctlen = 1;
+            icbctt[0] = 0;
+            bcttlen = 1;
+        }
+        if (adxtail !== 0) {
+            const len = scaleExpansion(bctlen, icbct, adxtail, ic16c);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(axtbclen, icaxtbc, adxtail, ic16), ic16, scaleExpansion(len, ic16c, 2 * adx, ic32), ic32, ic48), ic48);
+            const len2 = scaleExpansion(bcttlen, icbctt, adxtail, ic8);
+            const t32bl = expansionSum(scaleExpansion(len2, ic8, 2 * adx, ic16), ic16, scaleExpansion(len2, ic8, adxtail, ic16b), ic16b, ic32b);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(len, ic16c, adxtail, ic32), ic32, t32bl, ic32b, ic64), ic64);
+            if (bdytail !== 0)
+                finlen = icFinadd(finlen, scaleExpansion(scaleExpansion(4, iccc, adxtail, ic8), ic8, bdytail, ic16), ic16);
+            if (cdytail !== 0)
+                finlen = icFinadd(finlen, scaleExpansion(scaleExpansion(4, icbb, -adxtail, ic8), ic8, cdytail, ic16), ic16);
+        }
+        if (adytail !== 0) {
+            const len = scaleExpansion(bctlen, icbct, adytail, ic16c);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(aytbclen, icaytbc, adytail, ic16), ic16, scaleExpansion(len, ic16c, 2 * ady, ic32), ic32, ic48), ic48);
+            const len2 = scaleExpansion(bcttlen, icbctt, adytail, ic8);
+            const t32bl = expansionSum(scaleExpansion(len2, ic8, 2 * ady, ic16), ic16, scaleExpansion(len2, ic8, adytail, ic16b), ic16b, ic32b);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(len, ic16c, adytail, ic32), ic32, t32bl, ic32b, ic64), ic64);
+        }
+    }
+    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;
+            icu[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            icu[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            icu[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            icu[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;
+            icv[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            icv[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            icv[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            icv[3] = u3;
+            catlen = expansionSum(4, icu, 4, icv, iccat);
+            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;
+            iccatt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            iccatt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            iccatt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            iccatt[3] = u3;
+            cattlen = 4;
+        }
+        else {
+            iccat[0] = 0;
+            catlen = 1;
+            iccatt[0] = 0;
+            cattlen = 1;
+        }
+        if (bdxtail !== 0) {
+            const len = scaleExpansion(catlen, iccat, bdxtail, ic16c);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(bxtcalen, icbxtca, bdxtail, ic16), ic16, scaleExpansion(len, ic16c, 2 * bdx, ic32), ic32, ic48), ic48);
+            const len2 = scaleExpansion(cattlen, iccatt, bdxtail, ic8);
+            const t32bl = expansionSum(scaleExpansion(len2, ic8, 2 * bdx, ic16), ic16, scaleExpansion(len2, ic8, bdxtail, ic16b), ic16b, ic32b);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(len, ic16c, bdxtail, ic32), ic32, t32bl, ic32b, ic64), ic64);
+            if (cdytail !== 0)
+                finlen = icFinadd(finlen, scaleExpansion(scaleExpansion(4, icaa, bdxtail, ic8), ic8, cdytail, ic16), ic16);
+            if (adytail !== 0)
+                finlen = icFinadd(finlen, scaleExpansion(scaleExpansion(4, iccc, -bdxtail, ic8), ic8, adytail, ic16), ic16);
+        }
+        if (bdytail !== 0) {
+            const len = scaleExpansion(catlen, iccat, bdytail, ic16c);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(bytcalen, icbytca, bdytail, ic16), ic16, scaleExpansion(len, ic16c, 2 * bdy, ic32), ic32, ic48), ic48);
+            const len2 = scaleExpansion(cattlen, iccatt, bdytail, ic8);
+            const t32bl = expansionSum(scaleExpansion(len2, ic8, 2 * bdy, ic16), ic16, scaleExpansion(len2, ic8, bdytail, ic16b), ic16b, ic32b);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(len, ic16c, bdytail, ic32), ic32, t32bl, ic32b, ic64), ic64);
+        }
+    }
+    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;
+            icu[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            icu[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            icu[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            icu[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;
+            icv[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 + t1;
+            bvirt = _i - _0;
+            icv[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            icv[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            icv[3] = u3;
+            abtlen = expansionSum(4, icu, 4, icv, icabt);
+            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;
+            icabtt[0] = s0 - (_i + bvirt) + (bvirt - t0);
+            _j = s1 + _i;
+            bvirt = _j - s1;
+            _0 = s1 - (_j - bvirt) + (_i - bvirt);
+            _i = _0 - t1;
+            bvirt = _0 - _i;
+            icabtt[1] = _0 - (_i + bvirt) + (bvirt - t1);
+            u3 = _j + _i;
+            bvirt = u3 - _j;
+            icabtt[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            icabtt[3] = u3;
+            abttlen = 4;
+        }
+        else {
+            icabt[0] = 0;
+            abtlen = 1;
+            icabtt[0] = 0;
+            abttlen = 1;
+        }
+        if (cdxtail !== 0) {
+            const len = scaleExpansion(abtlen, icabt, cdxtail, ic16c);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(cxtablen, iccxtab, cdxtail, ic16), ic16, scaleExpansion(len, ic16c, 2 * cdx, ic32), ic32, ic48), ic48);
+            const len2 = scaleExpansion(abttlen, icabtt, cdxtail, ic8);
+            const t32bl = expansionSum(scaleExpansion(len2, ic8, 2 * cdx, ic16), ic16, scaleExpansion(len2, ic8, cdxtail, ic16b), ic16b, ic32b);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(len, ic16c, cdxtail, ic32), ic32, t32bl, ic32b, ic64), ic64);
+            if (adytail !== 0)
+                finlen = icFinadd(finlen, scaleExpansion(scaleExpansion(4, icbb, cdxtail, ic8), ic8, adytail, ic16), ic16);
+            if (bdytail !== 0)
+                finlen = icFinadd(finlen, scaleExpansion(scaleExpansion(4, icaa, -cdxtail, ic8), ic8, bdytail, ic16), ic16);
+        }
+        if (cdytail !== 0) {
+            const len = scaleExpansion(abtlen, icabt, cdytail, ic16c);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(cytablen, iccytab, cdytail, ic16), ic16, scaleExpansion(len, ic16c, 2 * cdy, ic32), ic32, ic48), ic48);
+            const len2 = scaleExpansion(abttlen, icabtt, cdytail, ic8);
+            const t32bl = expansionSum(scaleExpansion(len2, ic8, 2 * cdy, ic16), ic16, scaleExpansion(len2, ic8, cdytail, ic16b), ic16b, ic32b);
+            finlen = icFinadd(finlen, expansionSum(scaleExpansion(len, ic16c, cdytail, ic32), ic32, t32bl, ic32b, ic64), ic64);
+        }
+    }
+    return icfin[finlen - 1];
+}
+// incircle sign, with adaptive exact fallback
+export function adaptiveIncircleSign(ax, ay, bx, by, cx, cy, dx, dy) {
+    const adx = ax - dx, bdx = bx - dx, cdx = cx - dx;
+    const ady = ay - dy, bdy = by - dy, cdy = cy - dy;
+    const bdxcdy = bdx * cdy, cdxbdy = cdx * bdy;
+    const alift = adx * adx + ady * ady;
+    const cdxady = cdx * ady, adxcdy = adx * cdy;
+    const blift = bdx * bdx + bdy * bdy;
+    const adxbdy = adx * bdy, 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 > 0 ? 1 : -1;
+    const result = incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent);
+    return result > 0 ? 1 : result < 0 ? -1 : 0;
+}
+//# sourceMappingURL=Shewchuk.js.map