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

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/package.json

@@ -1,22 +1,34 @@
 {
   "name": "point-in-polygon-hao",
-  "version": "1.1.0",
+  "version": "1.2.4",
+  "type": "module",
   "description": "A point in polygon based on the paper Optimal Reliable Point-in-Polygon Test and Differential Coding Boolean Operations on Polygons",
-  "main": "dist/pointInPolygon.js",
-  "module": "dist/pointInPolygon.mjs",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "unpkg": "dist/pointInPolygon.min.js",
   "jsdelivr": "dist/pointInPolygon.min.js",
-  "types": "index.d.ts",
   "scripts": {
     "bench": "npm run build && node test/bench.js",
     "build": "rollup -c",
-    "test": "ava"
+    "test": "vitest"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "robust-predicates": "^3.0.2"
   },
-  "dependencies": {},
   "devDependencies": {
-    "@rollup/plugin-buble": "^0.21.3",
-    "@turf/boolean-point-in-polygon": "^6.0.1",
-    "ava": "^3.15.0",
+    "@rollup/plugin-buble": "^1.0.3",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-terser": "^0.4.4",
     "benchmark": "^2.1.4",
     "eslint": "^5.15.3",
     "eslint-config-mourner": "^3.0.0",
@@ -24,17 +36,9 @@
     "load-json-file": "^5.2.0",
     "point-in-polygon": "^1.0.1",
     "robust-point-in-polygon": "^1.0.3",
-    "rollup": "^1.7.0",
-    "rollup-plugin-terser": "^4.0.4"
-  },
-  "ava": {
-    "files": [
-      "test/*.spec.js"
-    ],
-    "require": [
-      "esm"
-    ],
-    "verbose": true
+    "rollup": "^4.28.0",
+    "rollup-plugin-copy": "^3.5.0",
+    "vitest": "^2.1.6"
   },
   "keywords": [
     "point-in-polygon",

package/node_modules/polyclip-ts/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Luiz Felipe Machado Barboza
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

package/node_modules/{polygon-clipping → polyclip-ts}/README.md

@@ -1,22 +1,41 @@
-# polygon-clipping
+# polyclip-ts
 
-Apply boolean Polygon clipping operations (`intersection`, `union`, `difference`, `xor`) to your Polygons & MultiPolygons.
+Apply boolean polygon clipping operations (`intersection`, `union`, `difference`, `xor`) to your Polygons & MultiPolygons.
 
-[![CI](https://github.com/mfogel/polygon-clipping/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/mfogel/polygon-clipping/actions) [![codecov](https://codecov.io/gh/mfogel/polygon-clipping/branch/main/graph/badge.svg?token=is93inDQiJ)](https://codecov.io/gh/mfogel/polygon-clipping) [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT) [![npm](https://img.shields.io/npm/v/polygon-clipping.svg)](https://www.npmjs.com/package/polygon-clipping)
+## Installing
+
+If you use npm, `npm install polyclip-ts`. You can also download the [latest release on GitHub](https://github.com/luizbarboza/polyclip-ts/tags). For vanilla HTML in modern browsers, import polyclip-ts from Skypack:
+
+```html
+<script type="module">
+import * as polyclip from "https://cdn.skypack.dev/polyclip-ts";
+
+polyclip.intersection(…)
+</script>
+```
+
+For legacy environments, you can load polyclip-ts’s UMD bundle from an npm-based CDN such as jsDelivr; a polyclip global is exported:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/polyclip-ts/dist/polyclip-ts.umd.min.js"></script>
+<script>
+polyclip.intersection(…)
+</script>
+```
 
 ## Quickstart
 
 <!-- prettier-ignore-start -->
 ```javascript
-const polygonClipping = require('polygon-clipping')
+import * as polyclip from "polyclip-ts"
 
 const poly1 = [[[0,0],[2,0],[0,2],[0,0]]]
 const poly2 = [[[-1,0],[1,0],[0,1],[-1,0]]]
 
-polygonClipping.union       (poly1, poly2 /* , poly3, ... */)
-polygonClipping.intersection(poly1, poly2 /* , poly3, ... */)
-polygonClipping.xor         (poly1, poly2 /* , poly3, ... */)
-polygonClipping.difference  (poly1, poly2 /* , poly3, ... */)
+polyclip.union       (poly1, poly2 /* , poly3, ... */)
+polyclip.intersection(poly1, poly2 /* , poly3, ... */)
+polyclip.xor         (poly1, poly2 /* , poly3, ... */)
+polyclip.difference  (poly1, poly2 /* , poly3, ... */)
 ```
 <!-- prettier-ignore-end -->
 
@@ -25,17 +44,17 @@ polygonClipping.difference  (poly1, poly2 /* , poly3, ... */)
 ```javascript
 /* All functions take one or more [multi]polygon(s) as input */
 
-polygonClipping.union       (<geom>, ...<geoms>)
-polygonClipping.intersection(<geom>, ...<geoms>)
-polygonClipping.xor         (<geom>, ...<geoms>)
+polyclip.union       (geom, ...moreGeoms)
+polyclip.intersection(geom, ...moreGeoms)
+polyclip.xor         (geom, ...moreGeoms)
 
-/* The clipGeoms will be subtracted from the subjectGeom */
-polygonClipping.difference(<subjectGeom>, ...<clipGeoms>)
+/* The moreGeoms will be subtracted from the geom */
+polyclip.difference  (geom, ...moreGeoms)
 ```
 
 ### Input
 
-Each positional argument (`<geom>`) may be either a Polygon or a MultiPolygon. The [GeoJSON spec](https://tools.ietf.org/html/rfc7946#section-3.1) is followed, with the following notes/modifications:
+Each positional argument (`geom`) may be either a Polygon or a MultiPolygon. The [GeoJSON spec](https://tools.ietf.org/html/rfc7946#section-3.1) is followed, with the following notes/modifications:
 
 - MultiPolygons may contain touching or overlapping Polygons.
 - rings are not required to be self-closing.
@@ -70,33 +89,13 @@ The tests are broken up into unit tests and end-to-end tests. The end-to-end tes
 
 The Martinez-Rueda-Feito polygon clipping algorithm is used to compute the result in `O((n+k)*log(n))` time, where `n` is the total number of edges in all polygons involved and `k` is the number of intersections between edges.
 
-## Settings
-
-Global settings are set via environment variables.
-
-- **POLYGON_CLIPPING_MAX_QUEUE_SIZE** and **POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS**: Aims to prevent infinite loops - usually caused by floating-point math round-off errors. Defaults are 1,000,000.
-
-## Changelog
-
-This project adheres to [Semantic Versioning](https://semver.org/).
-
-<!-- prettier-ignore-end -->
-
-The full changelog is available at [CHANGELOG.md](https://github.com/mfogel/polygon-clipping/blob/master/CHANGELOG.md).
-
 ## Authors
 
+- [Luiz F. M. Barboza](https://github.com/SBanksX)
 - [Mike Fogel](https://github.com/mfogel)
 - [Alexander Milevski](https://github.com/w8r)
 - [Vladimir Ovsyannikov](https://github.com/sh1ng)
 
-## Sponsors
-
-- [Alantgeo](https://www.alantgeo.com.au/)
-- [EasyTerritory](https://www.easyterritory.com/)
-
-Please contact [Mike Fogel](https://github.com/mfogel) if you or your company is interested in sponsoring work on specific bug fixes or feature requests.
-
 ## Based on
 
-- [A new algorithm for computing Boolean operations on polygons](paper.pdf) by Francisco Martinez, Antonio Jesus Rueda, Francisco Ramon Feito (2009)
+- [A simple algorithm for Boolean operations on polygons](https://www.sciencedirect.com/science/article/abs/pii/S0965997813000379) by Francisco Martinez, Antonio Jesus Rueda, Francisco Ramon Feito (2009)