robust-predicates 3.0.0 → 3.0.1

package/index.d.ts

@@ -0,0 +1,49 @@
+export as namespace predicates;
+
+export function orient2d(
+    ax: number, ay: number,
+    bx: number, by: number,
+    cx: number, cy: number): number;
+
+export function orient2dfast(
+    ax: number, ay: number,
+    bx: number, by: number,
+    cx: number, cy: number): number;
+
+export function incircle(
+    ax: number, ay: number,
+    bx: number, by: number,
+    cx: number, cy: number,
+    dx: number, dy: number): number;
+
+export function incirclefast(
+    ax: number, ay: number,
+    bx: number, by: number,
+    cx: number, cy: number,
+    dx: number, dy: number): number;
+
+export function orient3d(
+    ax: number, ay: number, az: number,
+    bx: number, by: number, bz: number,
+    cx: number, cy: number, cz: number,
+    dx: number, dy: number, dz: number): number;
+
+export function orient3dfast(
+    ax: number, ay: number, az: number,
+    bx: number, by: number, bz: number,
+    cx: number, cy: number, cz: number,
+    dx: number, dy: number, dz: number): number;
+
+export function insphere(
+    ax: number, ay: number, az: number,
+    bx: number, by: number, bz: number,
+    cx: number, cy: number, cz: number,
+    dx: number, dy: number, dz: number,
+    ex: number, ey: number, ez: number): number;
+
+export function inspherefast(
+    ax: number, ay: number, az: number,
+    bx: number, by: number, bz: number,
+    cx: number, cy: number, cz: number,
+    dx: number, dy: number, dz: number,
+    ex: number, ey: number, ez: number): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robust-predicates",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Fast robust predicates for computational geometry",
   "keywords": [
     "computational geometry",
@@ -23,20 +23,21 @@
     "prepublishOnly": "npm run test && rollup -c"
   },
   "devDependencies": {
-    "c8": "^7.5.0",
-    "eslint": "^7.19.0",
+    "c8": "^7.7.0",
+    "eslint": "^7.23.0",
     "eslint-config-mourner": "^3.0.0",
     "mkdirp": "^1.0.4",
     "nextafter": "^1.0.0",
     "robust-in-sphere": "^1.1.3",
     "robust-orientation": "^1.1.3",
-    "rollup": "^2.38.5",
+    "rollup": "^2.44.0",
     "rollup-plugin-terser": "^7.0.2",
-    "tape": "^5.1.1",
-    "terser": "^5.5.1"
+    "tape": "^5.2.2",
+    "terser": "^5.6.1"
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "esm",
     "umd"
   ],

package/umd/predicates.js

@@ -151,7 +151,7 @@ const B = vec(4);
 const C1 = vec(8);
 const C2 = vec(12);
 const D = vec(16);
-const u = vec(4);
+const u$2 = vec(4);
 
 function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
     let acxtail, acytail, bcxtail, bcytail;
@@ -233,18 +233,18 @@ function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    u$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
     _j = s1 + _i;
     bvirt = _j - s1;
     _0 = s1 - (_j - bvirt) + (_i - bvirt);
     _i = _0 - t1;
     bvirt = _0 - _i;
-    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
     u3 = _j + _i;
     bvirt = u3 - _j;
-    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
-    u[3] = u3;
-    const C1len = sum(4, B, 4, u, C1);
+    u$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u$2[3] = u3;
+    const C1len = sum(4, B, 4, u$2, C1);
 
     s1 = acx * bcytail;
     c = splitter * acx;
@@ -264,18 +264,18 @@ function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    u$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
     _j = s1 + _i;
     bvirt = _j - s1;
     _0 = s1 - (_j - bvirt) + (_i - bvirt);
     _i = _0 - t1;
     bvirt = _0 - _i;
-    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
     u3 = _j + _i;
     bvirt = u3 - _j;
-    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
-    u[3] = u3;
-    const C2len = sum(C1len, C1, 4, u, C2);
+    u$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u$2[3] = u3;
+    const C2len = sum(C1len, C1, 4, u$2, C2);
 
     s1 = acxtail * bcytail;
     c = splitter * acxtail;
@@ -295,18 +295,18 @@ function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    u$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
     _j = s1 + _i;
     bvirt = _j - s1;
     _0 = s1 - (_j - bvirt) + (_i - bvirt);
     _i = _0 - t1;
     bvirt = _0 - _i;
-    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
     u3 = _j + _i;
     bvirt = u3 - _j;
-    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
-    u[3] = u3;
-    const Dlen = sum(C2len, C2, 4, u, D);
+    u$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u$2[3] = u3;
+    const Dlen = sum(C2len, C2, 4, u$2, D);
 
     return D[Dlen - 1];
 }
@@ -332,31 +332,31 @@ const o3derrboundA = (7 + 56 * epsilon) * epsilon;
 const o3derrboundB = (3 + 28 * epsilon) * epsilon;
 const o3derrboundC = (26 + 288 * epsilon) * epsilon * epsilon;
 
-const bc = vec(4);
-const ca = vec(4);
-const ab = vec(4);
+const bc$2 = vec(4);
+const ca$1 = vec(4);
+const ab$2 = vec(4);
 const at_b = vec(4);
 const at_c = vec(4);
 const bt_c = vec(4);
 const bt_a = vec(4);
 const ct_a = vec(4);
 const ct_b = vec(4);
-const bct = vec(8);
-const cat = vec(8);
-const abt = vec(8);
+const bct$1 = vec(8);
+const cat$1 = vec(8);
+const abt$1 = vec(8);
 const u$1 = vec(4);
 
-const _8 = vec(8);
-const _8b = vec(8);
-const _16 = vec(8);
+const _8$2 = vec(8);
+const _8b$1 = vec(8);
+const _16$2 = vec(8);
 const _12 = vec(12);
 
-let fin = vec(192);
-let fin2 = vec(192);
+let fin$2 = vec(192);
+let fin2$1 = vec(192);
 
-function finadd(finlen, alen, a) {
-    finlen = sum(finlen, fin, alen, a, fin2);
-    const tmp = fin; fin = fin2; fin2 = tmp;
+function finadd$1(finlen, alen, a) {
+    finlen = sum(finlen, fin$2, alen, a, fin2$1);
+    const tmp = fin$2; fin$2 = fin2$1; fin2$1 = tmp;
     return finlen;
 }
 
@@ -504,7 +504,7 @@ function tailadd(finlen, a, b, k, z) {
     u3 = _j + _k;
     u$1[2] = _k - (u3 - _j);
     u$1[3] = u3;
-    finlen = finadd(finlen, 4, u$1);
+    finlen = finadd$1(finlen, 4, u$1);
     if (z !== 0) {
         c = splitter * z;
         bhi = c - (c - z);
@@ -525,7 +525,7 @@ function tailadd(finlen, a, b, k, z) {
         u3 = _j + _k;
         u$1[2] = _k - (u3 - _j);
         u$1[3] = u3;
-        finlen = finadd(finlen, 4, u$1);
+        finlen = finadd$1(finlen, 4, u$1);
     }
     return finlen;
 }
@@ -565,17 +565,17 @@ function orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    bc$2[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);
+    bc$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
     u3 = _j + _i;
     bvirt = u3 - _j;
-    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
-    bc[3] = u3;
+    bc$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc$2[3] = u3;
     s1 = cdx * ady;
     c = splitter * cdx;
     ahi = c - (c - cdx);
@@ -594,17 +594,17 @@ function orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    ca[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    ca$1[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);
+    ca$1[1] = _0 - (_i + bvirt) + (bvirt - t1);
     u3 = _j + _i;
     bvirt = u3 - _j;
-    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);
-    ca[3] = u3;
+    ca$1[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ca$1[3] = u3;
     s1 = adx * bdy;
     c = splitter * adx;
     ahi = c - (c - adx);
@@ -623,25 +623,25 @@ function orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    ab$2[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);
+    ab$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
     u3 = _j + _i;
     bvirt = u3 - _j;
-    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
-    ab[3] = u3;
+    ab$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab$2[3] = u3;
 
     finlen = sum(
         sum(
-            scale(4, bc, adz, _8), _8,
-            scale(4, ca, bdz, _8b), _8b, _16), _16,
-        scale(4, ab, cdz, _8), _8, fin);
+            scale(4, bc$2, adz, _8$2), _8$2,
+            scale(4, ca$1, bdz, _8b$1), _8b$1, _16$2), _16$2,
+        scale(4, ab$2, cdz, _8$2), _8$2, fin$2);
 
-    let det = estimate(finlen, fin);
+    let det = estimate(finlen, fin$2);
     let errbound = o3derrboundB * permanent;
     if (det >= errbound || -det >= errbound) {
         return det;
@@ -685,26 +685,26 @@ function orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent
     const bt_len = tailinit(bdxtail, bdytail, cdx, cdy, adx, ady, bt_c, bt_a);
     const ct_len = tailinit(cdxtail, cdytail, adx, ady, bdx, bdy, ct_a, ct_b);
 
-    const bctlen = sum(bt_len, bt_c, ct_len, ct_b, bct);
-    finlen = finadd(finlen, scale(bctlen, bct, adz, _16), _16);
+    const bctlen = sum(bt_len, bt_c, ct_len, ct_b, bct$1);
+    finlen = finadd$1(finlen, scale(bctlen, bct$1, adz, _16$2), _16$2);
 
-    const catlen = sum(ct_len, ct_a, at_len, at_c, cat);
-    finlen = finadd(finlen, scale(catlen, cat, bdz, _16), _16);
+    const catlen = sum(ct_len, ct_a, at_len, at_c, cat$1);
+    finlen = finadd$1(finlen, scale(catlen, cat$1, bdz, _16$2), _16$2);
 
-    const abtlen = sum(at_len, at_b, bt_len, bt_a, abt);
-    finlen = finadd(finlen, scale(abtlen, abt, cdz, _16), _16);
+    const abtlen = sum(at_len, at_b, bt_len, bt_a, abt$1);
+    finlen = finadd$1(finlen, scale(abtlen, abt$1, cdz, _16$2), _16$2);
 
     if (adztail !== 0) {
-        finlen = finadd(finlen, scale(4, bc, adztail, _12), _12);
-        finlen = finadd(finlen, scale(bctlen, bct, adztail, _16), _16);
+        finlen = finadd$1(finlen, scale(4, bc$2, adztail, _12), _12);
+        finlen = finadd$1(finlen, scale(bctlen, bct$1, adztail, _16$2), _16$2);
     }
     if (bdztail !== 0) {
-        finlen = finadd(finlen, scale(4, ca, bdztail, _12), _12);
-        finlen = finadd(finlen, scale(catlen, cat, bdztail, _16), _16);
+        finlen = finadd$1(finlen, scale(4, ca$1, bdztail, _12), _12);
+        finlen = finadd$1(finlen, scale(catlen, cat$1, bdztail, _16$2), _16$2);
     }
     if (cdztail !== 0) {
-        finlen = finadd(finlen, scale(4, ab, cdztail, _12), _12);
-        finlen = finadd(finlen, scale(abtlen, abt, cdztail, _16), _16);
+        finlen = finadd$1(finlen, scale(4, ab$2, cdztail, _12), _12);
+        finlen = finadd$1(finlen, scale(abtlen, abt$1, cdztail, _16$2), _16$2);
     }
 
     if (adxtail !== 0) {
@@ -732,7 +732,7 @@ function orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent
         }
     }
 
-    return fin[finlen - 1];
+    return fin$2[finlen - 1];
 }
 
 function orient3d(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {
@@ -794,12 +794,12 @@ const iccerrboundB = (4 + 48 * epsilon) * epsilon;
 const iccerrboundC = (44 + 576 * epsilon) * epsilon * epsilon;
 
 const bc$1 = vec(4);
-const ca$1 = vec(4);
+const ca = vec(4);
 const ab$1 = vec(4);
 const aa = vec(4);
 const bb = vec(4);
 const cc = vec(4);
-const u$2 = vec(4);
+const u = vec(4);
 const v = vec(4);
 const axtbc = vec(8);
 const aytbc = vec(8);
@@ -807,9 +807,9 @@ const bxtca = vec(8);
 const bytca = vec(8);
 const cxtab = vec(8);
 const cytab = vec(8);
-const abt$1 = vec(8);
-const bct$1 = vec(8);
-const cat$1 = 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);
@@ -820,15 +820,15 @@ const _16b = vec(16);
 const _16c = vec(16);
 const _32 = vec(32);
 const _32b = vec(32);
-const _48 = vec(48);
+const _48$1 = vec(48);
 const _64 = vec(64);
 
 let fin$1 = vec(1152);
-let fin2$1 = vec(1152);
+let fin2 = vec(1152);
 
-function finadd$1(finlen, a, alen) {
-    finlen = sum(finlen, fin$1, a, alen, fin2$1);
-    const tmp = fin$1; fin$1 = fin2$1; fin2$1 = tmp;
+function finadd(finlen, a, alen) {
+    finlen = sum(finlen, fin$1, a, alen, fin2);
+    const tmp = fin$1; fin$1 = fin2; fin2 = tmp;
     return finlen;
 }
 
@@ -896,17 +896,17 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    ca$1[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    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[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    ca[1] = _0 - (_i + bvirt) + (bvirt - t1);
     u3 = _j + _i;
     bvirt = u3 - _j;
-    ca$1[2] = _j - (u3 - bvirt) + (_i - bvirt);
-    ca$1[3] = u3;
+    ca[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ca[3] = u3;
     s1 = adx * bdy;
     c = splitter * adx;
     ahi = c - (c - adx);
@@ -943,8 +943,8 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
                 scale(scale(4, bc$1, adx, _8$1), _8$1, adx, _16$1), _16$1,
                 scale(scale(4, bc$1, ady, _8$1), _8$1, ady, _16b), _16b, _32), _32,
             sum(
-                scale(scale(4, ca$1, bdx, _8$1), _8$1, bdx, _16$1), _16$1,
-                scale(scale(4, ca$1, bdy, _8$1), _8$1, bdy, _16b), _16b, _32b), _32b, _64), _64,
+                scale(scale(4, ca, bdx, _8$1), _8$1, bdx, _16$1), _16$1,
+                scale(scale(4, ca, bdy, _8$1), _8$1, bdy, _16b), _16b, _32b), _32b, _64), _64,
         sum(
             scale(scale(4, ab$1, cdx, _8$1), _8$1, cdx, _16$1), _16$1,
             scale(scale(4, ab$1, cdy, _8$1), _8$1, cdy, _16b), _16b, _32), _32, fin$1);
@@ -1061,45 +1061,45 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
 
     if (adxtail !== 0) {
         axtbclen = scale(4, bc$1, adxtail, axtbc);
-        finlen = finadd$1(finlen, sum_three(
+        finlen = finadd(finlen, sum_three(
             scale(axtbclen, axtbc, 2 * adx, _16$1), _16$1,
             scale(scale(4, cc, adxtail, _8$1), _8$1, bdy, _16b), _16b,
-            scale(scale(4, bb, adxtail, _8$1), _8$1, -cdy, _16c), _16c, _32, _48), _48);
+            scale(scale(4, bb, adxtail, _8$1), _8$1, -cdy, _16c), _16c, _32, _48$1), _48$1);
     }
     if (adytail !== 0) {
         aytbclen = scale(4, bc$1, adytail, aytbc);
-        finlen = finadd$1(finlen, sum_three(
+        finlen = finadd(finlen, sum_three(
             scale(aytbclen, aytbc, 2 * ady, _16$1), _16$1,
             scale(scale(4, bb, adytail, _8$1), _8$1, cdx, _16b), _16b,
-            scale(scale(4, cc, adytail, _8$1), _8$1, -bdx, _16c), _16c, _32, _48), _48);
+            scale(scale(4, cc, adytail, _8$1), _8$1, -bdx, _16c), _16c, _32, _48$1), _48$1);
     }
     if (bdxtail !== 0) {
-        bxtcalen = scale(4, ca$1, bdxtail, bxtca);
-        finlen = finadd$1(finlen, sum_three(
+        bxtcalen = scale(4, ca, bdxtail, bxtca);
+        finlen = finadd(finlen, sum_three(
             scale(bxtcalen, bxtca, 2 * bdx, _16$1), _16$1,
             scale(scale(4, aa, bdxtail, _8$1), _8$1, cdy, _16b), _16b,
-            scale(scale(4, cc, bdxtail, _8$1), _8$1, -ady, _16c), _16c, _32, _48), _48);
+            scale(scale(4, cc, bdxtail, _8$1), _8$1, -ady, _16c), _16c, _32, _48$1), _48$1);
     }
     if (bdytail !== 0) {
-        bytcalen = scale(4, ca$1, bdytail, bytca);
-        finlen = finadd$1(finlen, sum_three(
+        bytcalen = scale(4, ca, bdytail, bytca);
+        finlen = finadd(finlen, sum_three(
             scale(bytcalen, bytca, 2 * bdy, _16$1), _16$1,
             scale(scale(4, cc, bdytail, _8$1), _8$1, adx, _16b), _16b,
-            scale(scale(4, aa, bdytail, _8$1), _8$1, -cdx, _16c), _16c, _32, _48), _48);
+            scale(scale(4, aa, bdytail, _8$1), _8$1, -cdx, _16c), _16c, _32, _48$1), _48$1);
     }
     if (cdxtail !== 0) {
         cxtablen = scale(4, ab$1, cdxtail, cxtab);
-        finlen = finadd$1(finlen, sum_three(
+        finlen = finadd(finlen, sum_three(
             scale(cxtablen, cxtab, 2 * cdx, _16$1), _16$1,
             scale(scale(4, bb, cdxtail, _8$1), _8$1, ady, _16b), _16b,
-            scale(scale(4, aa, cdxtail, _8$1), _8$1, -bdy, _16c), _16c, _32, _48), _48);
+            scale(scale(4, aa, cdxtail, _8$1), _8$1, -bdy, _16c), _16c, _32, _48$1), _48$1);
     }
     if (cdytail !== 0) {
         cytablen = scale(4, ab$1, cdytail, cytab);
-        finlen = finadd$1(finlen, sum_three(
+        finlen = finadd(finlen, sum_three(
             scale(cytablen, cytab, 2 * cdy, _16$1), _16$1,
             scale(scale(4, aa, cdytail, _8$1), _8$1, bdx, _16b), _16b,
-            scale(scale(4, bb, cdytail, _8$1), _8$1, -adx, _16c), _16c, _32, _48), _48);
+            scale(scale(4, bb, cdytail, _8$1), _8$1, -adx, _16c), _16c, _32, _48$1), _48$1);
     }
 
     if (adxtail !== 0 || adytail !== 0) {
@@ -1122,17 +1122,17 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
             t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
             _i = s0 + t0;
             bvirt = _i - s0;
-            u$2[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            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$2[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
             u3 = _j + _i;
             bvirt = u3 - _j;
-            u$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
-            u$2[3] = u3;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
             s1 = cdxtail * -bdy;
             c = splitter * cdxtail;
             ahi = c - (c - cdxtail);
@@ -1162,7 +1162,7 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
             bvirt = u3 - _j;
             v[2] = _j - (u3 - bvirt) + (_i - bvirt);
             v[3] = u3;
-            bctlen = sum(4, u$2, 4, v, bct$1);
+            bctlen = sum(4, u, 4, v, bct);
             s1 = bdxtail * cdytail;
             c = splitter * bdxtail;
             ahi = c - (c - bdxtail);
@@ -1194,38 +1194,38 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
             bctt[3] = u3;
             bcttlen = 4;
         } else {
-            bct$1[0] = 0;
+            bct[0] = 0;
             bctlen = 1;
             bctt[0] = 0;
             bcttlen = 1;
         }
         if (adxtail !== 0) {
-            const len = scale(bctlen, bct$1, adxtail, _16c);
-            finlen = finadd$1(finlen, sum(
+            const len = scale(bctlen, bct, adxtail, _16c);
+            finlen = finadd(finlen, sum(
                 scale(axtbclen, axtbc, adxtail, _16$1), _16$1,
-                scale(len, _16c, 2 * adx, _32), _32, _48), _48);
+                scale(len, _16c, 2 * adx, _32), _32, _48$1), _48$1);
 
             const len2 = scale(bcttlen, bctt, adxtail, _8$1);
-            finlen = finadd$1(finlen, sum_three(
+            finlen = finadd(finlen, sum_three(
                 scale(len2, _8$1, 2 * adx, _16$1), _16$1,
                 scale(len2, _8$1, adxtail, _16b), _16b,
                 scale(len, _16c, adxtail, _32), _32, _32b, _64), _64);
 
             if (bdytail !== 0) {
-                finlen = finadd$1(finlen, scale(scale(4, cc, adxtail, _8$1), _8$1, bdytail, _16$1), _16$1);
+                finlen = finadd(finlen, scale(scale(4, cc, adxtail, _8$1), _8$1, bdytail, _16$1), _16$1);
             }
             if (cdytail !== 0) {
-                finlen = finadd$1(finlen, scale(scale(4, bb, -adxtail, _8$1), _8$1, cdytail, _16$1), _16$1);
+                finlen = finadd(finlen, scale(scale(4, bb, -adxtail, _8$1), _8$1, cdytail, _16$1), _16$1);
             }
         }
         if (adytail !== 0) {
-            const len = scale(bctlen, bct$1, adytail, _16c);
-            finlen = finadd$1(finlen, sum(
+            const len = scale(bctlen, bct, adytail, _16c);
+            finlen = finadd(finlen, sum(
                 scale(aytbclen, aytbc, adytail, _16$1), _16$1,
-                scale(len, _16c, 2 * ady, _32), _32, _48), _48);
+                scale(len, _16c, 2 * ady, _32), _32, _48$1), _48$1);
 
             const len2 = scale(bcttlen, bctt, adytail, _8$1);
-            finlen = finadd$1(finlen, sum_three(
+            finlen = finadd(finlen, sum_three(
                 scale(len2, _8$1, 2 * ady, _16$1), _16$1,
                 scale(len2, _8$1, adytail, _16b), _16b,
                 scale(len, _16c, adytail, _32), _32, _32b, _64), _64);
@@ -1251,17 +1251,17 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
             t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
             _i = s0 + t0;
             bvirt = _i - s0;
-            u$2[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            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$2[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
             u3 = _j + _i;
             bvirt = u3 - _j;
-            u$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
-            u$2[3] = u3;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
             n1 = -cdy;
             n0 = -cdytail;
             s1 = adxtail * n1;
@@ -1293,7 +1293,7 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
             bvirt = u3 - _j;
             v[2] = _j - (u3 - bvirt) + (_i - bvirt);
             v[3] = u3;
-            catlen = sum(4, u$2, 4, v, cat$1);
+            catlen = sum(4, u, 4, v, cat);
             s1 = cdxtail * adytail;
             c = splitter * cdxtail;
             ahi = c - (c - cdxtail);
@@ -1325,38 +1325,38 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
             catt[3] = u3;
             cattlen = 4;
         } else {
-            cat$1[0] = 0;
+            cat[0] = 0;
             catlen = 1;
             catt[0] = 0;
             cattlen = 1;
         }
         if (bdxtail !== 0) {
-            const len = scale(catlen, cat$1, bdxtail, _16c);
-            finlen = finadd$1(finlen, sum(
+            const len = scale(catlen, cat, bdxtail, _16c);
+            finlen = finadd(finlen, sum(
                 scale(bxtcalen, bxtca, bdxtail, _16$1), _16$1,
-                scale(len, _16c, 2 * bdx, _32), _32, _48), _48);
+                scale(len, _16c, 2 * bdx, _32), _32, _48$1), _48$1);
 
             const len2 = scale(cattlen, catt, bdxtail, _8$1);
-            finlen = finadd$1(finlen, sum_three(
+            finlen = finadd(finlen, sum_three(
                 scale(len2, _8$1, 2 * bdx, _16$1), _16$1,
                 scale(len2, _8$1, bdxtail, _16b), _16b,
                 scale(len, _16c, bdxtail, _32), _32, _32b, _64), _64);
 
             if (cdytail !== 0) {
-                finlen = finadd$1(finlen, scale(scale(4, aa, bdxtail, _8$1), _8$1, cdytail, _16$1), _16$1);
+                finlen = finadd(finlen, scale(scale(4, aa, bdxtail, _8$1), _8$1, cdytail, _16$1), _16$1);
             }
             if (adytail !== 0) {
-                finlen = finadd$1(finlen, scale(scale(4, cc, -bdxtail, _8$1), _8$1, adytail, _16$1), _16$1);
+                finlen = finadd(finlen, scale(scale(4, cc, -bdxtail, _8$1), _8$1, adytail, _16$1), _16$1);
             }
         }
         if (bdytail !== 0) {
-            const len = scale(catlen, cat$1, bdytail, _16c);
-            finlen = finadd$1(finlen, sum(
+            const len = scale(catlen, cat, bdytail, _16c);
+            finlen = finadd(finlen, sum(
                 scale(bytcalen, bytca, bdytail, _16$1), _16$1,
-                scale(len, _16c, 2 * bdy, _32), _32, _48), _48);
+                scale(len, _16c, 2 * bdy, _32), _32, _48$1), _48$1);
 
             const len2 = scale(cattlen, catt, bdytail, _8$1);
-            finlen = finadd$1(finlen, sum_three(
+            finlen = finadd(finlen, sum_three(
                 scale(len2, _8$1, 2 * bdy, _16$1), _16$1,
                 scale(len2, _8$1, bdytail, _16b), _16b,
                 scale(len, _16c, bdytail, _32), _32,  _32b, _64), _64);
@@ -1382,17 +1382,17 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
             t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
             _i = s0 + t0;
             bvirt = _i - s0;
-            u$2[0] = s0 - (_i - bvirt) + (t0 - bvirt);
+            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$2[1] = _0 - (_i - bvirt) + (t1 - bvirt);
+            u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
             u3 = _j + _i;
             bvirt = u3 - _j;
-            u$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
-            u$2[3] = u3;
+            u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+            u[3] = u3;
             n1 = -ady;
             n0 = -adytail;
             s1 = bdxtail * n1;
@@ -1424,7 +1424,7 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
             bvirt = u3 - _j;
             v[2] = _j - (u3 - bvirt) + (_i - bvirt);
             v[3] = u3;
-            abtlen = sum(4, u$2, 4, v, abt$1);
+            abtlen = sum(4, u, 4, v, abt);
             s1 = adxtail * bdytail;
             c = splitter * adxtail;
             ahi = c - (c - adxtail);
@@ -1456,38 +1456,38 @@ function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
             abtt[3] = u3;
             abttlen = 4;
         } else {
-            abt$1[0] = 0;
+            abt[0] = 0;
             abtlen = 1;
             abtt[0] = 0;
             abttlen = 1;
         }
         if (cdxtail !== 0) {
-            const len = scale(abtlen, abt$1, cdxtail, _16c);
-            finlen = finadd$1(finlen, sum(
+            const len = scale(abtlen, abt, cdxtail, _16c);
+            finlen = finadd(finlen, sum(
                 scale(cxtablen, cxtab, cdxtail, _16$1), _16$1,
-                scale(len, _16c, 2 * cdx, _32), _32, _48), _48);
+                scale(len, _16c, 2 * cdx, _32), _32, _48$1), _48$1);
 
             const len2 = scale(abttlen, abtt, cdxtail, _8$1);
-            finlen = finadd$1(finlen, sum_three(
+            finlen = finadd(finlen, sum_three(
                 scale(len2, _8$1, 2 * cdx, _16$1), _16$1,
                 scale(len2, _8$1, cdxtail, _16b), _16b,
                 scale(len, _16c, cdxtail, _32), _32, _32b, _64), _64);
 
             if (adytail !== 0) {
-                finlen = finadd$1(finlen, scale(scale(4, bb, cdxtail, _8$1), _8$1, adytail, _16$1), _16$1);
+                finlen = finadd(finlen, scale(scale(4, bb, cdxtail, _8$1), _8$1, adytail, _16$1), _16$1);
             }
             if (bdytail !== 0) {
-                finlen = finadd$1(finlen, scale(scale(4, aa, -cdxtail, _8$1), _8$1, bdytail, _16$1), _16$1);
+                finlen = finadd(finlen, scale(scale(4, aa, -cdxtail, _8$1), _8$1, bdytail, _16$1), _16$1);
             }
         }
         if (cdytail !== 0) {
-            const len = scale(abtlen, abt$1, cdytail, _16c);
-            finlen = finadd$1(finlen, sum(
+            const len = scale(abtlen, abt, cdytail, _16c);
+            finlen = finadd(finlen, sum(
                 scale(cytablen, cytab, cdytail, _16$1), _16$1,
-                scale(len, _16c, 2 * cdy, _32), _32, _48), _48);
+                scale(len, _16c, 2 * cdy, _32), _32, _48$1), _48$1);
 
             const len2 = scale(abttlen, abtt, cdytail, _8$1);
-            finlen = finadd$1(finlen, sum_three(
+            finlen = finadd(finlen, sum_three(
                 scale(len2, _8$1, 2 * cdy, _16$1), _16$1,
                 scale(len2, _8$1, cdytail, _16b), _16b,
                 scale(len, _16c, cdytail, _32), _32, _32b, _64), _64);
@@ -1557,8 +1557,8 @@ const isperrboundA = (16 + 224 * epsilon) * epsilon;
 const isperrboundB = (5 + 72 * epsilon) * epsilon;
 const isperrboundC = (71 + 1408 * epsilon) * epsilon * epsilon;
 
-const ab$2 = vec(4);
-const bc$2 = vec(4);
+const ab = vec(4);
+const bc = vec(4);
 const cd = vec(4);
 const de = vec(4);
 const ea = vec(4);
@@ -1589,12 +1589,12 @@ const cddet = vec(2304);
 const cdedet = vec(3456);
 const deter = vec(5760);
 
-const _8$2 = vec(8);
-const _8b$1 = vec(8);
+const _8 = vec(8);
+const _8b = vec(8);
 const _8c = vec(8);
-const _16$2 = vec(16);
+const _16 = vec(16);
 const _24 = vec(24);
-const _48$1 = vec(48);
+const _48 = vec(48);
 const _48b = vec(48);
 const _96 = vec(96);
 const _192 = vec(192);
@@ -1605,14 +1605,14 @@ const _768 = vec(768);
 
 function sum_three_scale(a, b, c, az, bz, cz, out) {
     return sum_three(
-        scale(4, a, az, _8$2), _8$2,
-        scale(4, b, bz, _8b$1), _8b$1,
-        scale(4, c, cz, _8c), _8c, _16$2, out);
+        scale(4, a, az, _8), _8,
+        scale(4, b, bz, _8b), _8b,
+        scale(4, c, cz, _8c), _8c, _16, out);
 }
 
 function liftexact(alen, a, blen, b, clen, c, dlen, d, x, y, z, out) {
     const len = sum(
-        sum(alen, a, blen, b, _48$1), _48$1,
+        sum(alen, a, blen, b, _48), _48,
         negate(sum(clen, c, dlen, d, _48b), _48b), _48b, _96);
 
     return sum_three(
@@ -1642,17 +1642,17 @@ function insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, e
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    ab$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    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$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
     u3 = _j + _i;
     bvirt = u3 - _j;
-    ab$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
-    ab$2[3] = u3;
+    ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    ab[3] = u3;
     s1 = bx * cy;
     c = splitter * bx;
     ahi = c - (c - bx);
@@ -1671,17 +1671,17 @@ function insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, e
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    bc$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    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$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
     u3 = _j + _i;
     bvirt = u3 - _j;
-    bc$2[2] = _j - (u3 - bvirt) + (_i - bvirt);
-    bc$2[3] = u3;
+    bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    bc[3] = u3;
     s1 = cx * dy;
     c = splitter * cx;
     ahi = c - (c - cx);
@@ -1915,13 +1915,13 @@ function insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, e
     eb[2] = _j - (u3 - bvirt) + (_i - bvirt);
     eb[3] = u3;
 
-    const abclen = sum_three_scale(ab$2, bc$2, ac, cz, az, -bz, abc);
-    const bcdlen = sum_three_scale(bc$2, cd, bd, dz, bz, -cz, bcd);
+    const abclen = sum_three_scale(ab, bc, ac, cz, az, -bz, abc);
+    const bcdlen = sum_three_scale(bc, cd, bd, dz, bz, -cz, bcd);
     const cdelen = sum_three_scale(cd, de, ce, ez, cz, -dz, cde);
     const dealen = sum_three_scale(de, ea, da, az, dz, -ez, dea);
-    const eablen = sum_three_scale(ea, ab$2, eb, bz, ez, -az, eab);
-    const abdlen = sum_three_scale(ab$2, bd, da, dz, az, bz, abd);
-    const bcelen = sum_three_scale(bc$2, ce, eb, ez, bz, cz, bce);
+    const eablen = sum_three_scale(ea, ab, eb, bz, ez, -az, eab);
+    const abdlen = sum_three_scale(ab, bd, da, dz, az, bz, abd);
+    const bcelen = sum_three_scale(bc, ce, eb, ez, bz, cz, bce);
     const cdalen = sum_three_scale(cd, da, ac, az, cz, dz, cda);
     const deblen = sum_three_scale(de, eb, bd, bz, dz, ez, deb);
     const eaclen = sum_three_scale(ea, ac, ce, cz, ez, az, eac);
@@ -1940,14 +1940,14 @@ function insphereexact(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, e
 const xdet = vec(96);
 const ydet = vec(96);
 const zdet = vec(96);
-const fin$2 = vec(1152);
+const fin = vec(1152);
 
 function liftadapt(a, b, c, az, bz, cz, x, y, z, out) {
     const len = sum_three_scale(a, b, c, az, bz, cz, _24);
     return sum_three(
-        scale(scale(len, _24, x, _48$1), _48$1, x, xdet), xdet,
-        scale(scale(len, _24, y, _48$1), _48$1, y, ydet), ydet,
-        scale(scale(len, _24, z, _48$1), _48$1, z, zdet), zdet, _192, out);
+        scale(scale(len, _24, x, _48), _48, x, xdet), xdet,
+        scale(scale(len, _24, y, _48), _48, y, ydet), ydet,
+        scale(scale(len, _24, z, _48), _48, z, zdet), zdet, _192, out);
 }
 
 function insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, ez, permanent) {
@@ -1990,17 +1990,17 @@ function insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, e
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    ab$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    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$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
     ab3 = _j + _i;
     bvirt = ab3 - _j;
-    ab$2[2] = _j - (ab3 - bvirt) + (_i - bvirt);
-    ab$2[3] = ab3;
+    ab[2] = _j - (ab3 - bvirt) + (_i - bvirt);
+    ab[3] = ab3;
     s1 = bex * cey;
     c = splitter * bex;
     ahi = c - (c - bex);
@@ -2019,17 +2019,17 @@ function insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, e
     t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
     _i = s0 - t0;
     bvirt = s0 - _i;
-    bc$2[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    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$2[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
     bc3 = _j + _i;
     bvirt = bc3 - _j;
-    bc$2[2] = _j - (bc3 - bvirt) + (_i - bvirt);
-    bc$2[3] = bc3;
+    bc[2] = _j - (bc3 - bvirt) + (_i - bvirt);
+    bc[3] = bc3;
     s1 = cex * dey;
     c = splitter * cex;
     ahi = c - (c - cex);
@@ -2149,13 +2149,13 @@ function insphereadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, ex, ey, e
 
     const finlen = sum(
         sum(
-            negate(liftadapt(bc$2, cd, bd, dez, bez, -cez, aex, aey, aez, adet), adet), adet,
+            negate(liftadapt(bc, cd, bd, dez, bez, -cez, aex, aey, aez, adet), adet), adet,
             liftadapt(cd, da, ac, aez, cez, dez, bex, bey, bez, bdet), bdet, abdet), abdet,
         sum(
-            negate(liftadapt(da, ab$2, bd, bez, dez, aez, cex, cey, cez, cdet), cdet), cdet,
-            liftadapt(ab$2, bc$2, ac, cez, aez, -bez, dex, dey, dez, ddet), ddet, cddet), cddet, fin$2);
+            negate(liftadapt(da, ab, bd, bez, dez, aez, cex, cey, cez, cdet), cdet), cdet,
+            liftadapt(ab, bc, ac, cez, aez, -bez, dex, dey, dez, ddet), ddet, cddet), cddet, fin);
 
-    let det = estimate(finlen, fin$2);
+    let det = estimate(finlen, fin);
     let errbound = isperrboundB * permanent;
     if (det >= errbound || -det >= errbound) {
         return det;