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

package/node_modules/point-in-polygon-hao/node_modules/robust-predicates/esm/util.js

@@ -0,0 +1,138 @@
+export const epsilon = 1.1102230246251565e-16;
+export const splitter = 134217729;
+export const resulterrbound = (3 + 8 * epsilon) * epsilon;
+
+// fast_expansion_sum_zeroelim routine from oritinal code
+export function sum(elen, e, flen, f, h) {
+    let Q, Qnew, hh, bvirt;
+    let enow = e[0];
+    let fnow = f[0];
+    let eindex = 0;
+    let findex = 0;
+    if ((fnow > enow) === (fnow > -enow)) {
+        Q = enow;
+        enow = e[++eindex];
+    } else {
+        Q = fnow;
+        fnow = f[++findex];
+    }
+    let hindex = 0;
+    if (eindex < elen && findex < flen) {
+        if ((fnow > enow) === (fnow > -enow)) {
+            Qnew = enow + Q;
+            hh = Q - (Qnew - enow);
+            enow = e[++eindex];
+        } else {
+            Qnew = fnow + Q;
+            hh = Q - (Qnew - fnow);
+            fnow = f[++findex];
+        }
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        while (eindex < elen && findex < flen) {
+            if ((fnow > enow) === (fnow > -enow)) {
+                Qnew = Q + enow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (enow - bvirt);
+                enow = e[++eindex];
+            } else {
+                Qnew = Q + fnow;
+                bvirt = Qnew - Q;
+                hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+                fnow = f[++findex];
+            }
+            Q = Qnew;
+            if (hh !== 0) {
+                h[hindex++] = hh;
+            }
+        }
+    }
+    while (eindex < elen) {
+        Qnew = Q + enow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (enow - bvirt);
+        enow = e[++eindex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    while (findex < flen) {
+        Qnew = Q + fnow;
+        bvirt = Qnew - Q;
+        hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+        fnow = f[++findex];
+        Q = Qnew;
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+export function sum_three(alen, a, blen, b, clen, c, tmp, out) {
+    return sum(sum(alen, a, blen, b, tmp), tmp, clen, c, out);
+}
+
+// scale_expansion_zeroelim routine from oritinal code
+export function scale(elen, e, b, h) {
+    let Q, sum, hh, product1, product0;
+    let bvirt, c, ahi, alo, bhi, blo;
+
+    c = splitter * b;
+    bhi = c - (c - b);
+    blo = b - bhi;
+    let enow = e[0];
+    Q = enow * b;
+    c = splitter * enow;
+    ahi = c - (c - enow);
+    alo = enow - ahi;
+    hh = alo * blo - (Q - ahi * bhi - alo * bhi - ahi * blo);
+    let hindex = 0;
+    if (hh !== 0) {
+        h[hindex++] = hh;
+    }
+    for (let i = 1; i < elen; i++) {
+        enow = e[i];
+        product1 = enow * b;
+        c = splitter * enow;
+        ahi = c - (c - enow);
+        alo = enow - ahi;
+        product0 = alo * blo - (product1 - ahi * bhi - alo * bhi - ahi * blo);
+        sum = Q + product0;
+        bvirt = sum - Q;
+        hh = Q - (sum - bvirt) + (product0 - bvirt);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+        Q = product1 + sum;
+        hh = sum - (Q - product1);
+        if (hh !== 0) {
+            h[hindex++] = hh;
+        }
+    }
+    if (Q !== 0 || hindex === 0) {
+        h[hindex++] = Q;
+    }
+    return hindex;
+}
+
+export function negate(elen, e) {
+    for (let i = 0; i < elen; i++) e[i] = -e[i];
+    return elen;
+}
+
+export function estimate(elen, e) {
+    let Q = e[0];
+    for (let i = 1; i < elen; i++) Q += e[i];
+    return Q;
+}
+
+export function vec(n) {
+    return new Float64Array(n);
+}

package/node_modules/point-in-polygon-hao/node_modules/robust-predicates/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/node_modules/point-in-polygon-hao/node_modules/robust-predicates/index.js

@@ -0,0 +1,5 @@
+
+export {orient2d, orient2dfast} from './esm/orient2d.js';
+export {orient3d, orient3dfast} from './esm/orient3d.js';
+export {incircle, incirclefast} from './esm/incircle.js';
+export {insphere, inspherefast} from './esm/insphere.js';

package/node_modules/point-in-polygon-hao/node_modules/robust-predicates/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "robust-predicates",
+  "version": "3.0.2",
+  "description": "Fast robust predicates for computational geometry",
+  "keywords": [
+    "computational geometry",
+    "robust arithmetic"
+  ],
+  "author": "Vladimir Agafonkin",
+  "license": "Unlicense",
+  "type": "module",
+  "main": "index.js",
+  "unpkg": "umd/predicates.min.js",
+  "module": "index.js",
+  "exports": "./index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "mkdirp esm && node compile.js",
+    "lint": "eslint *.js src test/test.js",
+    "test": "npm run lint && npm run build && node test/test.js",
+    "cov": "c8 node test/test.js",
+    "bench": "node bench.js",
+    "prepublishOnly": "npm run test && rollup -c"
+  },
+  "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.3",
+    "c8": "^7.13.0",
+    "eslint": "^8.41.0",
+    "eslint-config-mourner": "^3.0.0",
+    "mkdirp": "^3.0.1",
+    "nextafter": "^1.0.0",
+    "robust-in-sphere": "^1.2.1",
+    "robust-orientation": "^1.2.1",
+    "rollup": "^3.23.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "esm",
+    "umd"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mourner/robust-predicates.git"
+  },
+  "eslintConfig": {
+    "extends": "mourner",
+    "parserOptions": {
+      "ecmaVersion": 2020
+    },
+    "rules": {
+      "camelcase": 0,
+      "new-cap": 0,
+      "no-unused-vars": [
+        2,
+        {
+          "varsIgnorePattern": "splitter|bvirt|c|[ab]hi|[ab]lo|_[ijk0]|u3|[st][01]"
+        }
+      ],
+      "no-lonely-if": 0
+    },
+    "globals": {
+      "$Fast_Two_Sum": false,
+      "$Two_Sum": false,
+      "$Two_Diff_Tail": false,
+      "$Split": false,
+      "$Two_Product": false,
+      "$Two_Product_Presplit": false,
+      "$Two_One_Product": false,
+      "$Cross_Product": false,
+      "$Square_Sum": false,
+      "$Two_Product_Sum": false
+    }
+  }
+}