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

package/node_modules/long/umd/index.d.ts

@@ -1,2 +1,457 @@
-import Long from "../index.js";
+declare class Long {
+  /**
+   * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as signed integers. See the from* functions below for more convenient ways of constructing Longs.
+   */
+  constructor(low: number, high?: number, unsigned?: boolean);
+  
+  /**
+   * Maximum unsigned value.
+   */
+  static MAX_UNSIGNED_VALUE: Long;
+
+  /**
+   * Maximum signed value.
+   */
+  static MAX_VALUE: Long;
+
+  /**
+   * Minimum signed value.
+   */
+  static MIN_VALUE: Long;
+
+  /**
+   * Signed negative one.
+   */
+  static NEG_ONE: Long;
+
+  /**
+   * Signed one.
+   */
+  static ONE: Long;
+
+  /**
+   * Unsigned one.
+   */
+  static UONE: Long;
+
+  /**
+   * Unsigned zero.
+   */
+  static UZERO: Long;
+
+  /**
+   * Signed zero
+   */
+  static ZERO: Long;
+
+  /**
+   * The high 32 bits as a signed value.
+   */
+  high: number;
+
+  /**
+   * The low 32 bits as a signed value.
+   */
+  low: number;
+
+  /**
+   * Whether unsigned or not.
+   */
+  unsigned: boolean;
+
+  /**
+   * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is assumed to use 32 bits.
+   */
+  static fromBits(lowBits: number, highBits: number, unsigned?: boolean): Long;
+
+  /**
+   * Returns a Long representing the given 32 bit integer value.
+   */
+  static fromInt(value: number, unsigned?: boolean): Long;
+
+  /**
+   * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
+   */
+  static fromNumber(value: number, unsigned?: boolean): Long;
+
+  /**
+   * Returns a Long representation of the given string, written using the specified radix.
+   */
+  static fromString(
+    str: string,
+    unsigned?: boolean | number,
+    radix?: number
+  ): Long;
+
+  /**
+   * Creates a Long from its byte representation.
+   */
+  static fromBytes(bytes: number[], unsigned?: boolean, le?: boolean): Long;
+
+  /**
+   * Creates a Long from its little endian byte representation.
+   */
+  static fromBytesLE(bytes: number[], unsigned?: boolean): Long;
+
+  /**
+   * Creates a Long from its big endian byte representation.
+   */
+  static fromBytesBE(bytes: number[], unsigned?: boolean): Long;
+
+  /**
+   * Tests if the specified object is a Long.
+   */
+  static isLong(obj: any): obj is Long;
+
+  /**
+   * Converts the specified value to a Long.
+   */
+  static fromValue(
+    val:
+      | Long
+      | number
+      | string
+      | { low: number; high: number; unsigned: boolean },
+    unsigned?: boolean
+  ): Long;
+
+  /**
+   * Returns the sum of this and the specified Long.
+   */
+  add(addend: number | Long | string): Long;
+
+  /**
+   * Returns the bitwise AND of this Long and the specified.
+   */
+  and(other: Long | number | string): Long;
+
+  /**
+   * Compares this Long's value with the specified's.
+   */
+  compare(other: Long | number | string): number;
+
+  /**
+   * Compares this Long's value with the specified's.
+   */
+  comp(other: Long | number | string): number;
+
+  /**
+   * Returns this Long divided by the specified.
+   */
+  divide(divisor: Long | number | string): Long;
+
+  /**
+   * Returns this Long divided by the specified.
+   */
+  div(divisor: Long | number | string): Long;
+
+  /**
+   * Tests if this Long's value equals the specified's.
+   */
+  equals(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value equals the specified's.
+   */
+  eq(other: Long | number | string): boolean;
+
+  /**
+   * Gets the high 32 bits as a signed integer.
+   */
+  getHighBits(): number;
+
+  /**
+   * Gets the high 32 bits as an unsigned integer.
+   */
+  getHighBitsUnsigned(): number;
+
+  /**
+   * Gets the low 32 bits as a signed integer.
+   */
+  getLowBits(): number;
+
+  /**
+   * Gets the low 32 bits as an unsigned integer.
+   */
+  getLowBitsUnsigned(): number;
+
+  /**
+   * Gets the number of bits needed to represent the absolute value of this Long.
+   */
+  getNumBitsAbs(): number;
+
+  /**
+   * Tests if this Long's value is greater than the specified's.
+   */
+  greaterThan(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value is greater than the specified's.
+   */
+  gt(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value is greater than or equal the specified's.
+   */
+  greaterThanOrEqual(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value is greater than or equal the specified's.
+   */
+  gte(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value is greater than or equal the specified's.
+   */
+  ge(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value is even.
+   */
+  isEven(): boolean;
+
+  /**
+   * Tests if this Long's value is negative.
+   */
+  isNegative(): boolean;
+
+  /**
+   * Tests if this Long's value is odd.
+   */
+  isOdd(): boolean;
+
+  /**
+   * Tests if this Long's value is positive or zero.
+   */
+  isPositive(): boolean;
+
+  /**
+   * Tests if this Long's value equals zero.
+   */
+  isZero(): boolean;
+
+  /**
+   * Tests if this Long's value equals zero.
+   */
+  eqz(): boolean;
+
+  /**
+   * Tests if this Long's value is less than the specified's.
+   */
+  lessThan(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value is less than the specified's.
+   */
+  lt(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value is less than or equal the specified's.
+   */
+  lessThanOrEqual(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value is less than or equal the specified's.
+   */
+  lte(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value is less than or equal the specified's.
+   */
+  le(other: Long | number | string): boolean;
+
+  /**
+   * Returns this Long modulo the specified.
+   */
+  modulo(other: Long | number | string): Long;
+
+  /**
+   * Returns this Long modulo the specified.
+   */
+  mod(other: Long | number | string): Long;
+
+  /**
+   * Returns this Long modulo the specified.
+   */
+  rem(other: Long | number | string): Long;
+
+  /**
+   * Returns the product of this and the specified Long.
+   */
+  multiply(multiplier: Long | number | string): Long;
+
+  /**
+   * Returns the product of this and the specified Long.
+   */
+  mul(multiplier: Long | number | string): Long;
+
+  /**
+   * Negates this Long's value.
+   */
+  negate(): Long;
+
+  /**
+   * Negates this Long's value.
+   */
+  neg(): Long;
+
+  /**
+   * Returns the bitwise NOT of this Long.
+   */
+  not(): Long;
+
+  /**
+   * Returns count leading zeros of this Long.
+   */
+  countLeadingZeros(): number;
+
+  /**
+   * Returns count leading zeros of this Long.
+   */
+  clz(): number;
+
+  /**
+   * Returns count trailing zeros of this Long.
+   */
+  countTrailingZeros(): number;
+
+  /**
+   * Returns count trailing zeros of this Long.
+   */
+  ctz(): number;
+
+  /**
+   * Tests if this Long's value differs from the specified's.
+   */
+  notEquals(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value differs from the specified's.
+   */
+  neq(other: Long | number | string): boolean;
+
+  /**
+   * Tests if this Long's value differs from the specified's.
+   */
+  ne(other: Long | number | string): boolean;
+
+  /**
+   * Returns the bitwise OR of this Long and the specified.
+   */
+  or(other: Long | number | string): Long;
+
+  /**
+   * Returns this Long with bits shifted to the left by the given amount.
+   */
+  shiftLeft(numBits: number | Long): Long;
+
+  /**
+   * Returns this Long with bits shifted to the left by the given amount.
+   */
+  shl(numBits: number | Long): Long;
+
+  /**
+   * Returns this Long with bits arithmetically shifted to the right by the given amount.
+   */
+  shiftRight(numBits: number | Long): Long;
+
+  /**
+   * Returns this Long with bits arithmetically shifted to the right by the given amount.
+   */
+  shr(numBits: number | Long): Long;
+
+  /**
+   * Returns this Long with bits logically shifted to the right by the given amount.
+   */
+  shiftRightUnsigned(numBits: number | Long): Long;
+
+  /**
+   * Returns this Long with bits logically shifted to the right by the given amount.
+   */
+  shru(numBits: number | Long): Long;
+
+  /**
+   * Returns this Long with bits logically shifted to the right by the given amount.
+   */
+  shr_u(numBits: number | Long): Long;
+
+  /**
+   * Returns this Long with bits rotated to the left by the given amount.
+   */
+  rotateLeft(numBits: number | Long): Long;
+
+  /**
+   * Returns this Long with bits rotated to the left by the given amount.
+   */
+  rotl(numBits: number | Long): Long;
+
+  /**
+   * Returns this Long with bits rotated to the right by the given amount.
+   */
+  rotateRight(numBits: number | Long): Long;
+
+  /**
+   * Returns this Long with bits rotated to the right by the given amount.
+   */
+  rotr(numBits: number | Long): Long;
+
+  /**
+   * Returns the difference of this and the specified Long.
+   */
+  subtract(subtrahend: number | Long | string): Long;
+
+  /**
+   * Returns the difference of this and the specified Long.
+   */
+  sub(subtrahend: number | Long | string): Long;
+
+  /**
+   * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.
+   */
+  toInt(): number;
+
+  /**
+   * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).
+   */
+  toNumber(): number;
+
+  /**
+   * Converts this Long to its byte representation.
+   */
+
+  toBytes(le?: boolean): number[];
+
+  /**
+   * Converts this Long to its little endian byte representation.
+   */
+
+  toBytesLE(): number[];
+
+  /**
+   * Converts this Long to its big endian byte representation.
+   */
+
+  toBytesBE(): number[];
+
+  /**
+   * Converts this Long to signed.
+   */
+  toSigned(): Long;
+
+  /**
+   * Converts the Long to a string written in the specified radix.
+   */
+  toString(radix?: number): string;
+
+  /**
+   * Converts this Long to unsigned.
+   */
+  toUnsigned(): Long;
+
+  /**
+   * Returns the bitwise XOR of this Long and the given one.
+   */
+  xor(other: Long | number | string): Long;
+}
+  
 export = Long;

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)