node-red-contrib-tak-registration 0.13.0 → 0.13.1

package/node_modules/point-in-polygon-hao/dist/pointInPolygon.js

@@ -1,29 +1,295 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
     typeof define === 'function' && define.amd ? define(factory) :
-    (global = global || self, global.pointInPolygon = factory());
-}(this, (function () { 'use strict';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.pointInPolygon = factory());
+})(this, (function () { 'use strict';
+
+    var epsilon = 1.1102230246251565e-16;
+    var splitter = 134217729;
+    var resulterrbound = (3 + 8 * epsilon) * epsilon;
+
+    // fast_expansion_sum_zeroelim routine from oritinal code
+    function sum(elen, e, flen, f, h) {
+        var Q, Qnew, hh, bvirt;
+        var enow = e[0];
+        var fnow = f[0];
+        var eindex = 0;
+        var findex = 0;
+        if ((fnow > enow) === (fnow > -enow)) {
+            Q = enow;
+            enow = e[++eindex];
+        } else {
+            Q = fnow;
+            fnow = f[++findex];
+        }
+        var 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 estimate(elen, e) {
+        var Q = e[0];
+        for (var i = 1; i < elen; i++) { Q += e[i]; }
+        return Q;
+    }
+
+    function vec(n) {
+        return new Float64Array(n);
+    }
+
+    var ccwerrboundA = (3 + 16 * epsilon) * epsilon;
+    var ccwerrboundB = (2 + 12 * epsilon) * epsilon;
+    var ccwerrboundC = (9 + 64 * epsilon) * epsilon * epsilon;
+
+    var B = vec(4);
+    var C1 = vec(8);
+    var C2 = vec(12);
+    var D = vec(16);
+    var u = vec(4);
+
+    function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
+        var acxtail, acytail, bcxtail, bcytail;
+        var bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+        var acx = ax - cx;
+        var bcx = bx - cx;
+        var acy = ay - cy;
+        var 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;
+        B[0] = s0 - (_i + bvirt) + (bvirt - t0);
+        _j = s1 + _i;
+        bvirt = _j - s1;
+        _0 = s1 - (_j - bvirt) + (_i - bvirt);
+        _i = _0 - t1;
+        bvirt = _0 - _i;
+        B[1] = _0 - (_i + bvirt) + (bvirt - t1);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        B[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        B[3] = u3;
+
+        var det = estimate(4, B);
+        var 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;
+        u[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);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        u[3] = u3;
+        var C1len = sum(4, B, 4, u, C1);
+
+        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;
+        u[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);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        u[3] = u3;
+        var C2len = sum(C1len, C1, 4, u, C2);
+
+        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;
+        u[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);
+        u3 = _j + _i;
+        bvirt = u3 - _j;
+        u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+        u[3] = u3;
+        var Dlen = sum(C2len, C2, 4, u, D);
+
+        return D[Dlen - 1];
+    }
+
+    function orient2d(ax, ay, bx, by, cx, cy) {
+        var detleft = (ay - cy) * (bx - cx);
+        var detright = (ax - cx) * (by - cy);
+        var det = detleft - detright;
+
+        var detsum = Math.abs(detleft + detright);
+        if (Math.abs(det) >= ccwerrboundA * detsum) { return det; }
+
+        return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
+    }
 
     function pointInPolygon(p, polygon) {
-        var i = 0;
-        var ii = 0;
+        var i;
+        var ii;
         var k = 0;
-        var f = 0;
-        var u1 = 0;
-        var v1 = 0;
-        var u2 = 0;
-        var v2 = 0;
-        var currentP = null;
-        var nextP = null;
+        var f;
+        var u1;
+        var v1;
+        var u2;
+        var v2;
+        var currentP;
+        var nextP;
 
         var x = p[0];
         var y = p[1];
 
         var numContours = polygon.length;
-        for (i; i < numContours; i++) {
+        for (i = 0; i < numContours; i++) {
             ii = 0;
-            var contourLen = polygon[i].length - 1;
             var contour = polygon[i];
+            var contourLen = contour.length - 1;
 
             currentP = contour[0];
             if (currentP[0] !== contour[contourLen][0] &&
@@ -37,37 +303,15 @@
             for (ii; ii < contourLen; ii++) {
                 nextP = contour[ii + 1];
 
+                u2 = nextP[0] - x;
                 v2 = nextP[1] - y;
 
-                if ((v1 < 0 && v2 < 0) || (v1 > 0 && v2 > 0)) {
-                    currentP = nextP;
-                    v1 = v2;
-                    u1 = currentP[0] - x;
-                    continue
-                }
-
-                u2 = nextP[0] - p[0];
-
-                if (v2 > 0 && v1 <= 0) {
-                    f = (u1 * v2) - (u2 * v1);
-                    if (f > 0) { k = k + 1; }
-                    else if (f === 0) { return 0 }
-                } else if (v1 > 0 && v2 <= 0) {
-                    f = (u1 * v2) - (u2 * v1);
-                    if (f < 0) { k = k + 1; }
-                    else if (f === 0) { return 0 }
-                } else if (v2 === 0 && v1 < 0) {
-                    f = (u1 * v2) - (u2 * v1);
-                    if (f === 0) { return 0 }
-                } else if (v1 === 0 && v2 < 0) {
-                    f = u1 * v2 - u2 * v1;
+                if (v1 === 0 && v2 === 0) {
+                    if ((u2 <= 0 && u1 >= 0) || (u1 <= 0 && u2 >= 0)) { return 0 }
+                } else if ((v2 >= 0 && v1 <= 0) || (v2 <= 0 && v1 >= 0)) {
+                    f = orient2d(u1, u2, v1, v2, 0, 0);
                     if (f === 0) { return 0 }
-                } else if (v1 === 0 && v2 === 0) {
-                    if (u2 <= 0 && u1 >= 0) {
-                        return 0
-                    } else if (u1 <= 0 && u2 >= 0) {
-                        return 0
-                    }
+                    if ((f > 0 && v2 > 0 && v1 <= 0) || (f < 0 && v2 <= 0 && v1 > 0)) { k++; }
                 }
                 currentP = nextP;
                 v1 = v2;
@@ -81,4 +325,4 @@
 
     return pointInPolygon;
 
-})));
+}));

package/node_modules/point-in-polygon-hao/dist/pointInPolygon.min.js

@@ -1 +1 @@
-!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):(e=e||self).pointInPolygon=n()}(this,function(){"use strict";return function(e,n){for(var i=0,r=0,t=0,f=0,o=0,u=0,l=0,s=0,d=null,a=null,c=e[0],p=e[1],h=n.length;i<h;i++){r=0;var m=n[i].length-1,g=n[i];if((d=g[0])[0]!==g[m][0]&&d[1]!==g[m][1])throw new Error("First and last coordinates in a ring must be the same");for(o=d[0]-c,u=d[1]-p;r<m;r++)if(s=(a=g[r+1])[1]-p,u<0&&s<0||u>0&&s>0)u=s,o=(d=a)[0]-c;else{if(l=a[0]-e[0],s>0&&u<=0){if((f=o*s-l*u)>0)t+=1;else if(0===f)return 0}else if(u>0&&s<=0){if((f=o*s-l*u)<0)t+=1;else if(0===f)return 0}else if(0===s&&u<0){if(0==(f=o*s-l*u))return 0}else if(0===u&&s<0){if(0==(f=o*s-l*u))return 0}else if(0===u&&0===s){if(l<=0&&o>=0)return 0;if(o<=0&&l>=0)return 0}d=a,u=s,o=l}}return t%2!=0}});
+!function(r,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):(r="undefined"!=typeof globalThis?globalThis:r||self).pointInPolygon=n()}(this,(function(){"use strict";var r=11102230246251565e-32,n=134217729,e=(3+8*r)*r;function t(r,n,e,t,f){var o,i,a,u,s=n[0],l=t[0],v=0,c=0;l>s==l>-s?(o=s,s=n[++v]):(o=l,l=t[++c]);var d=0;if(v<r&&c<e)for(l>s==l>-s?(a=o-((i=s+o)-s),s=n[++v]):(a=o-((i=l+o)-l),l=t[++c]),o=i,0!==a&&(f[d++]=a);v<r&&c<e;)l>s==l>-s?(a=o-((i=o+s)-(u=i-o))+(s-u),s=n[++v]):(a=o-((i=o+l)-(u=i-o))+(l-u),l=t[++c]),o=i,0!==a&&(f[d++]=a);for(;v<r;)a=o-((i=o+s)-(u=i-o))+(s-u),s=n[++v],o=i,0!==a&&(f[d++]=a);for(;c<e;)a=o-((i=o+l)-(u=i-o))+(l-u),l=t[++c],o=i,0!==a&&(f[d++]=a);return 0===o&&0!==d||(f[d++]=o),d}function f(r){return new Float64Array(r)}var o=f(4),i=f(8),a=f(12),u=f(16),s=f(4);function l(r,f,l,v,c,d){var h=(f-d)*(l-c),b=(r-c)*(v-d),p=h-b,g=Math.abs(h+b);return Math.abs(p)>=33306690738754716e-32*g?p:-function(r,f,l,v,c,d,h){var b,p,g,y,m,w,M,x,F,T,j,A,E,I,P,k,q,z,B=r-c,C=l-c,D=f-d,G=v-d;m=(P=(x=B-(M=(w=n*B)-(w-B)))*(T=G-(F=(w=n*G)-(w-G)))-((I=B*G)-M*F-x*F-M*T))-(j=P-(q=(x=D-(M=(w=n*D)-(w-D)))*(T=C-(F=(w=n*C)-(w-C)))-((k=D*C)-M*F-x*F-M*T))),o[0]=P-(j+m)+(m-q),m=(E=I-((A=I+j)-(m=A-I))+(j-m))-(j=E-k),o[1]=E-(j+m)+(m-k),m=(z=A+j)-A,o[2]=A-(z-m)+(j-m),o[3]=z;var H=function(r,n){for(var e=n[0],t=1;t<r;t++)e+=n[t];return e}(4,o),J=22204460492503146e-32*h;if(H>=J||-H>=J)return H;if(b=r-(B+(m=r-B))+(m-c),g=l-(C+(m=l-C))+(m-c),p=f-(D+(m=f-D))+(m-d),y=v-(G+(m=v-G))+(m-d),0===b&&0===p&&0===g&&0===y)return H;if(J=11093356479670487e-47*h+e*Math.abs(H),(H+=B*y+G*b-(D*g+C*p))>=J||-H>=J)return H;m=(P=(x=b-(M=(w=n*b)-(w-b)))*(T=G-(F=(w=n*G)-(w-G)))-((I=b*G)-M*F-x*F-M*T))-(j=P-(q=(x=p-(M=(w=n*p)-(w-p)))*(T=C-(F=(w=n*C)-(w-C)))-((k=p*C)-M*F-x*F-M*T))),s[0]=P-(j+m)+(m-q),m=(E=I-((A=I+j)-(m=A-I))+(j-m))-(j=E-k),s[1]=E-(j+m)+(m-k),m=(z=A+j)-A,s[2]=A-(z-m)+(j-m),s[3]=z;var K=t(4,o,4,s,i);m=(P=(x=B-(M=(w=n*B)-(w-B)))*(T=y-(F=(w=n*y)-(w-y)))-((I=B*y)-M*F-x*F-M*T))-(j=P-(q=(x=D-(M=(w=n*D)-(w-D)))*(T=g-(F=(w=n*g)-(w-g)))-((k=D*g)-M*F-x*F-M*T))),s[0]=P-(j+m)+(m-q),m=(E=I-((A=I+j)-(m=A-I))+(j-m))-(j=E-k),s[1]=E-(j+m)+(m-k),m=(z=A+j)-A,s[2]=A-(z-m)+(j-m),s[3]=z;var L=t(K,i,4,s,a);m=(P=(x=b-(M=(w=n*b)-(w-b)))*(T=y-(F=(w=n*y)-(w-y)))-((I=b*y)-M*F-x*F-M*T))-(j=P-(q=(x=p-(M=(w=n*p)-(w-p)))*(T=g-(F=(w=n*g)-(w-g)))-((k=p*g)-M*F-x*F-M*T))),s[0]=P-(j+m)+(m-q),m=(E=I-((A=I+j)-(m=A-I))+(j-m))-(j=E-k),s[1]=E-(j+m)+(m-k),m=(z=A+j)-A,s[2]=A-(z-m)+(j-m),s[3]=z;var N=t(L,a,4,s,u);return u[N-1]}(r,f,l,v,c,d,g)}return function(r,n){var e,t,f,o,i,a,u,s,v,c=0,d=r[0],h=r[1],b=n.length;for(e=0;e<b;e++){t=0;var p=n[e],g=p.length-1;if((s=p[0])[0]!==p[g][0]&&s[1]!==p[g][1])throw new Error("First and last coordinates in a ring must be the same");for(o=s[0]-d,i=s[1]-h;t<g;t++){if(a=(v=p[t+1])[0]-d,u=v[1]-h,0===i&&0===u){if(a<=0&&o>=0||o<=0&&a>=0)return 0}else if(u>=0&&i<=0||u<=0&&i>=0){if(0===(f=l(o,a,i,u,0,0)))return 0;(f>0&&u>0&&i<=0||f<0&&u<=0&&i>0)&&c++}s=v,i=u,o=a}}return c%2!=0}}));

package/node_modules/point-in-polygon-hao/node_modules/robust-predicates/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>

package/node_modules/point-in-polygon-hao/node_modules/robust-predicates/README.md

@@ -0,0 +1,82 @@
+# robust-predicates
+
+Fast robust predicates for computational geometry in JavaScript. Provides reliable 2D and 3D point orientation tests (`orient2d`, `orient3d`, `incircle`, `insphere`) that are not susceptible to floating point errors (without sacrificing performance). A modern port of [Jonathan R Shewchuk's C code](https://www.cs.cmu.edu/~quake/robust.html), an industry standard since 1996.
+
+<a href="https://observablehq.com/@mourner/non-robust-arithmetic-as-art"><img width="600" height="200" src="predicates.png" /></a>
+
+_Figure: non-robust vs robust `orient2d` test for points within a tiny range (2<sup>-42</sup>)._
+
+[![Build Status](https://github.com/mourner/robust-predicates/workflows/Node/badge.svg?branch=master)](https://github.com/mourner/robust-predicates/actions)
+[![Simply Awesome](https://img.shields.io/badge/simply-awesome-brightgreen.svg)](https://github.com/mourner/projects)
+[![Browser Build](https://badgen.net/bundlephobia/minzip/robust-predicates)](https://unpkg.com/robust-predicates)
+
+## [Demo](https://observablehq.com/@mourner/non-robust-arithmetic-as-art)
+
+## API
+
+Note: unlike J. Shewchuk's original code, all the functions in this library assume `y` axis is oriented _downwards_ &darr;, so the semantics are different.
+
+### `orient2d(ax,ay, bx,by, cx,cy)`
+
+- Returns a *positive* value if the points `a`, `b`, and `c` occur in _counterclockwise_ order (`c` lies to the left of the directed line defined by points `a` and `b`).
+- Returns a *negative* value if they occur in _clockwise_ order (`c` lies to the right of the directed line `ab`).
+- Returns *zero* if they are _collinear_.
+
+The result is also an approximation of twice the signed area of the triangle defined by the three points.
+
+### `incircle(ax,ay, bx,by, cx,cy, dx,dy)`
+
+- Returns a _positive_ value if the point `d` lies _outside_ the circle passing through `a`, `b`, and `c`.
+- Returns a _negative_ value if it lies _inside_.
+- Returns _zero_ if the four points are _cocircular_.
+
+The points `a`, `b`, and `c` must be in _counterclockwise_ order, or the sign of the result will be reversed.
+
+### `orient3d(ax,ay,az, bx,by,bz, cx,cy,cz, dx,dy,dz)`
+
+- Returns a _positive_ value if the point `d` lies _above_ the plane passing through `a`, `b`, and `c`, meaning that `a`, `b`, and `c` appear in counterclockwise order when viewed from `d`.
+- Returns a _negative_ value if `d` lies _below_ the plane.
+- Returns _zero_ if the points are _coplanar_.
+
+The result is also an approximation of six times the signed volume of the tetrahedron defined by the four points.
+
+### `insphere(ax,ay,az, bx,by,bz, cx,cy,cz, dx,dy,dz, ex,ey,ez)`
+
+- Returns a _positive_ value if the point `e` lies _outside_ the sphere passing through `a`, `b`, `c`, and `d`.
+- Returns a _negative_ value if it lies _inside_.
+- Returns _zero_ if the five points are _cospherical_.
+
+The points `a`, `b`, `c`, and `d` must be ordered so that they have a _positive orientation_
+(as defined by `orient3d`), or the sign of the result will be reversed.
+
+### `orient2dfast`, `orient3dfast`, `incirclefast`, `inspherefast`
+
+Simple, approximate, non-robust versions of predicates above. Use when robustness isn't needed.
+
+## Example
+
+```js
+import {orient2d} from 'robust-predicates';
+
+const ccw = orient2d(ax, ay, bx, by, cx, cy) > 0;
+````
+
+## Install
+
+Install with `npm install robust-predicates` or `yarn add robust-predicates`, or use one of the browser builds:
+
+- [predicates.min.js](https://unpkg.com/robust-predicates/umd/predicates.min.js) (all predicates)
+- [orient2d.min.js](https://unpkg.com/robust-predicates/umd/orient2d.min.js) (`orient2d`, `orient2dfast`)
+- [orient3d.min.js](https://unpkg.com/robust-predicates/umd/orient3d.min.js) (`orient3d`, `orient3dfast`)
+- [incircle.min.js](https://unpkg.com/robust-predicates/umd/incircle.min.js) (`incircle`, `incirclefast`)
+- [insphere.min.js](https://unpkg.com/robust-predicates/umd/insphere.min.js) (`insphere`, `inspherefast`)
+
+## Thanks
+
+This project is just a port — all the brilliant, hard work was done by [Jonathan Richard Shewchuk](https://people.eecs.berkeley.edu/~jrs/).
+
+The port was also inspired by [Mikola Lysenko](https://twitter.com/MikolaLysenko)'s excellent [Robust Arithmetic Notes](https://github.com/mikolalysenko/robust-arithmetic-notes) and related projects like [robust-orientation](https://github.com/mikolalysenko/robust-orientation) and [robust-in-sphere](https://github.com/mikolalysenko/robust-in-sphere).
+
+## License
+
+Since the original code is in the public domain, this project follows the same choice. See [Unlicense](https://unlicense.org).