node-red-contrib-tak-registration 0.16.1 → 0.16.5

package/node_modules/jsts/org/locationtech/jts/geom/LinearRing.js

@@ -1,48 +0,0 @@
-import LineString from './LineString'
-import Geometry from './Geometry'
-import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
-import CoordinateSequences from './CoordinateSequences'
-import Dimension from './Dimension'
-export default class LinearRing extends LineString {
-  constructor() {
-    super()
-    LinearRing.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    const points = arguments[0], factory = arguments[1]
-    LineString.constructor_.call(this, points, factory)
-    this.validateConstruction()
-  }
-  copyInternal() {
-    return new LinearRing(this._points.copy(), this._factory)
-  }
-  getBoundaryDimension() {
-    return Dimension.FALSE
-  }
-  isClosed() {
-    if (this.isEmpty()) 
-      return true
-    
-    return super.isClosed.call(this)
-  }
-  reverseInternal() {
-    const seq = this._points.copy()
-    CoordinateSequences.reverse(seq)
-    return this.getFactory().createLinearRing(seq)
-  }
-  getTypeCode() {
-    return Geometry.TYPECODE_LINEARRING
-  }
-  validateConstruction() {
-    if (!this.isEmpty() && !super.isClosed.call(this)) 
-      throw new IllegalArgumentException('Points of LinearRing do not form a closed linestring')
-    
-    if (this.getCoordinateSequence().size() >= 1 && this.getCoordinateSequence().size() < LinearRing.MINIMUM_VALID_SIZE) 
-      throw new IllegalArgumentException('Invalid number of points in LinearRing (found ' + this.getCoordinateSequence().size() + ' - must be 0 or >= 4)')
-    
-  }
-  getGeometryType() {
-    return Geometry.TYPENAME_LINEARRING
-  }
-}
-LinearRing.MINIMUM_VALID_SIZE = 4

package/node_modules/jsts/org/locationtech/jts/geom/Location.js

@@ -1,20 +0,0 @@
-import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
-export default class Location {
-  static toLocationSymbol(locationValue) {
-    switch (locationValue) {
-    case Location.EXTERIOR:
-      return 'e'
-    case Location.BOUNDARY:
-      return 'b'
-    case Location.INTERIOR:
-      return 'i'
-    case Location.NONE:
-      return '-'
-    }
-    throw new IllegalArgumentException('Unknown location value: ' + locationValue)
-  }
-}
-Location.INTERIOR = 0
-Location.BOUNDARY = 1
-Location.EXTERIOR = 2
-Location.NONE = -1

package/node_modules/jsts/org/locationtech/jts/geom/MultiLineString.js

@@ -1,65 +0,0 @@
-import Geometry from './Geometry'
-import Lineal from './Lineal'
-import GeometryCollection from './GeometryCollection'
-import UnsupportedOperationException from '../../../../java/lang/UnsupportedOperationException'
-import Dimension from './Dimension'
-export default class MultiLineString extends GeometryCollection {
-  constructor() {
-    super()
-    MultiLineString.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    const lineStrings = arguments[0], factory = arguments[1]
-    GeometryCollection.constructor_.call(this, lineStrings, factory)
-  }
-  copyInternal() {
-    const lineStrings = new Array(this._geometries.length).fill(null)
-    for (let i = 0; i < lineStrings.length; i++) 
-      lineStrings[i] = this._geometries[i].copy()
-    
-    return new MultiLineString(lineStrings, this._factory)
-  }
-  equalsExact() {
-    if (arguments.length === 2 && (typeof arguments[1] === 'number' && arguments[0] instanceof Geometry)) {
-      const other = arguments[0], tolerance = arguments[1]
-      if (!this.isEquivalentClass(other)) 
-        return false
-      
-      return super.equalsExact.call(this, other, tolerance)
-    } else {
-      return super.equalsExact.apply(this, arguments)
-    }
-  }
-  getBoundaryDimension() {
-    if (this.isClosed()) 
-      return Dimension.FALSE
-    
-    return 0
-  }
-  isClosed() {
-    if (this.isEmpty()) 
-      return false
-    
-    for (let i = 0; i < this._geometries.length; i++) 
-      if (!this._geometries[i].isClosed()) 
-        return false
-      
-    
-    return true
-  }
-  getTypeCode() {
-    return Geometry.TYPECODE_MULTILINESTRING
-  }
-  getDimension() {
-    return 1
-  }
-  getBoundary() {
-    throw new UnsupportedOperationException()
-  }
-  getGeometryType() {
-    return Geometry.TYPENAME_MULTILINESTRING
-  }
-  get interfaces_() {
-    return [Lineal]
-  }
-}

package/node_modules/jsts/org/locationtech/jts/geom/MultiPoint.js

@@ -1,61 +0,0 @@
-import Geometry from './Geometry'
-import GeometryCollection from './GeometryCollection'
-import Dimension from './Dimension'
-import Puntal from './Puntal'
-export default class MultiPoint extends GeometryCollection {
-  constructor() {
-    super()
-    MultiPoint.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    const points = arguments[0], factory = arguments[1]
-    GeometryCollection.constructor_.call(this, points, factory)
-  }
-  copyInternal() {
-    const points = new Array(this._geometries.length).fill(null)
-    for (let i = 0; i < points.length; i++) 
-      points[i] = this._geometries[i].copy()
-    
-    return new MultiPoint(points, this._factory)
-  }
-  isValid() {
-    return true
-  }
-  equalsExact() {
-    if (arguments.length === 2 && (typeof arguments[1] === 'number' && arguments[0] instanceof Geometry)) {
-      const other = arguments[0], tolerance = arguments[1]
-      if (!this.isEquivalentClass(other)) 
-        return false
-      
-      return super.equalsExact.call(this, other, tolerance)
-    } else {
-      return super.equalsExact.apply(this, arguments)
-    }
-  }
-  getCoordinate() {
-    if (arguments.length === 1 && Number.isInteger(arguments[0])) {
-      const n = arguments[0]
-      return this._geometries[n].getCoordinate()
-    } else {
-      return super.getCoordinate.apply(this, arguments)
-    }
-  }
-  getBoundaryDimension() {
-    return Dimension.FALSE
-  }
-  getTypeCode() {
-    return Geometry.TYPECODE_MULTIPOINT
-  }
-  getDimension() {
-    return 0
-  }
-  getBoundary() {
-    return this.getFactory().createGeometryCollection()
-  }
-  getGeometryType() {
-    return Geometry.TYPENAME_MULTIPOINT
-  }
-  get interfaces_() {
-    return [Puntal]
-  }
-}

package/node_modules/jsts/org/locationtech/jts/geom/MultiPolygon.js

@@ -1,62 +0,0 @@
-import Geometry from './Geometry'
-import GeometryCollection from './GeometryCollection'
-import Polygonal from './Polygonal'
-import ArrayList from '../../../../java/util/ArrayList'
-export default class MultiPolygon extends GeometryCollection {
-  constructor() {
-    super()
-    MultiPolygon.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    const polygons = arguments[0], factory = arguments[1]
-    GeometryCollection.constructor_.call(this, polygons, factory)
-  }
-  copyInternal() {
-    const polygons = new Array(this._geometries.length).fill(null)
-    for (let i = 0; i < polygons.length; i++) 
-      polygons[i] = this._geometries[i].copy()
-    
-    return new MultiPolygon(polygons, this._factory)
-  }
-  equalsExact() {
-    if (arguments.length === 2 && (typeof arguments[1] === 'number' && arguments[0] instanceof Geometry)) {
-      const other = arguments[0], tolerance = arguments[1]
-      if (!this.isEquivalentClass(other)) 
-        return false
-      
-      return super.equalsExact.call(this, other, tolerance)
-    } else {
-      return super.equalsExact.apply(this, arguments)
-    }
-  }
-  getBoundaryDimension() {
-    return 1
-  }
-  getTypeCode() {
-    return Geometry.TYPECODE_MULTIPOLYGON
-  }
-  getDimension() {
-    return 2
-  }
-  getBoundary() {
-    if (this.isEmpty()) 
-      return this.getFactory().createMultiLineString()
-    
-    const allRings = new ArrayList()
-    for (let i = 0; i < this._geometries.length; i++) {
-      const polygon = this._geometries[i]
-      const rings = polygon.getBoundary()
-      for (let j = 0; j < rings.getNumGeometries(); j++) 
-        allRings.add(rings.getGeometryN(j))
-      
-    }
-    const allRingsArray = new Array(allRings.size()).fill(null)
-    return this.getFactory().createMultiLineString(allRings.toArray(allRingsArray))
-  }
-  getGeometryType() {
-    return Geometry.TYPENAME_MULTIPOLYGON
-  }
-  get interfaces_() {
-    return [Polygonal]
-  }
-}

package/node_modules/jsts/org/locationtech/jts/geom/OctagonalEnvelope.js

@@ -1,273 +0,0 @@
-import LineString from './LineString'
-import CoordinateList from './CoordinateList'
-import Geometry from './Geometry'
-import hasInterface from '../../../../hasInterface'
-import Coordinate from './Coordinate'
-import Point from './Point'
-import Double from '../../../../java/lang/Double'
-import GeometryComponentFilter from './GeometryComponentFilter'
-import CoordinateSequence from './CoordinateSequence'
-import Envelope from './Envelope'
-export default class OctagonalEnvelope {
-  constructor() {
-    OctagonalEnvelope.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._minX = Double.NaN
-    this._maxX = null
-    this._minY = null
-    this._maxY = null
-    this._minA = null
-    this._maxA = null
-    this._minB = null
-    this._maxB = null
-    if (arguments.length === 0) {} else if (arguments.length === 1) {
-      if (arguments[0] instanceof Coordinate) {
-        const p = arguments[0]
-        this.expandToInclude(p)
-      } else if (arguments[0] instanceof Envelope) {
-        const env = arguments[0]
-        this.expandToInclude(env)
-      } else if (arguments[0] instanceof OctagonalEnvelope) {
-        const oct = arguments[0]
-        this.expandToInclude(oct)
-      } else if (arguments[0] instanceof Geometry) {
-        const geom = arguments[0]
-        this.expandToInclude(geom)
-      }
-    } else if (arguments.length === 2) {
-      const p0 = arguments[0], p1 = arguments[1]
-      this.expandToInclude(p0)
-      this.expandToInclude(p1)
-    }
-  }
-  static octagonalEnvelope(geom) {
-    return new OctagonalEnvelope(geom).toGeometry(geom.getFactory())
-  }
-  static computeB(x, y) {
-    return x - y
-  }
-  static computeA(x, y) {
-    return x + y
-  }
-  toGeometry(geomFactory) {
-    if (this.isNull()) 
-      return geomFactory.createPoint()
-    
-    const px00 = new Coordinate(this._minX, this._minA - this._minX)
-    const px01 = new Coordinate(this._minX, this._minX - this._minB)
-    const px10 = new Coordinate(this._maxX, this._maxX - this._maxB)
-    const px11 = new Coordinate(this._maxX, this._maxA - this._maxX)
-    const py00 = new Coordinate(this._minA - this._minY, this._minY)
-    const py01 = new Coordinate(this._minY + this._maxB, this._minY)
-    const py10 = new Coordinate(this._maxY + this._minB, this._maxY)
-    const py11 = new Coordinate(this._maxA - this._maxY, this._maxY)
-    const pm = geomFactory.getPrecisionModel()
-    pm.makePrecise(px00)
-    pm.makePrecise(px01)
-    pm.makePrecise(px10)
-    pm.makePrecise(px11)
-    pm.makePrecise(py00)
-    pm.makePrecise(py01)
-    pm.makePrecise(py10)
-    pm.makePrecise(py11)
-    const coordList = new CoordinateList()
-    coordList.add(px00, false)
-    coordList.add(px01, false)
-    coordList.add(py10, false)
-    coordList.add(py11, false)
-    coordList.add(px11, false)
-    coordList.add(px10, false)
-    coordList.add(py01, false)
-    coordList.add(py00, false)
-    if (coordList.size() === 1) 
-      return geomFactory.createPoint(px00)
-    
-    if (coordList.size() === 2) {
-      const pts = coordList.toCoordinateArray()
-      return geomFactory.createLineString(pts)
-    }
-    coordList.add(px00, false)
-    const pts = coordList.toCoordinateArray()
-    return geomFactory.createPolygon(geomFactory.createLinearRing(pts))
-  }
-  getMinA() {
-    return this._minA
-  }
-  getMaxB() {
-    return this._maxB
-  }
-  isValid() {
-    if (this.isNull()) return true
-    return this._minX <= this._maxX && this._minY <= this._maxY && this._minA <= this._maxA && this._minB <= this._maxB
-  }
-  isNull() {
-    return Double.isNaN(this._minX)
-  }
-  getMaxX() {
-    return this._maxX
-  }
-  intersects() {
-    if (arguments[0] instanceof OctagonalEnvelope) {
-      const other = arguments[0]
-      if (this.isNull() || other.isNull()) 
-        return false
-      
-      if (this._minX > other._maxX) return false
-      if (this._maxX < other._minX) return false
-      if (this._minY > other._maxY) return false
-      if (this._maxY < other._minY) return false
-      if (this._minA > other._maxA) return false
-      if (this._maxA < other._minA) return false
-      if (this._minB > other._maxB) return false
-      if (this._maxB < other._minB) return false
-      return true
-    } else if (arguments[0] instanceof Coordinate) {
-      const p = arguments[0]
-      if (this._minX > p.x) return false
-      if (this._maxX < p.x) return false
-      if (this._minY > p.y) return false
-      if (this._maxY < p.y) return false
-      const A = OctagonalEnvelope.computeA(p.x, p.y)
-      const B = OctagonalEnvelope.computeB(p.x, p.y)
-      if (this._minA > A) return false
-      if (this._maxA < A) return false
-      if (this._minB > B) return false
-      if (this._maxB < B) return false
-      return true
-    }
-  }
-  getMinY() {
-    return this._minY
-  }
-  getMinX() {
-    return this._minX
-  }
-  expandToInclude() {
-    if (arguments.length === 1) {
-      if (arguments[0] instanceof Geometry) {
-        const g = arguments[0]
-        g.apply(new BoundingOctagonComponentFilter(this))
-      } else if (hasInterface(arguments[0], CoordinateSequence)) {
-        const seq = arguments[0]
-        for (let i = 0; i < seq.size(); i++) {
-          const x = seq.getX(i)
-          const y = seq.getY(i)
-          this.expandToInclude(x, y)
-        }
-        return this
-      } else if (arguments[0] instanceof OctagonalEnvelope) {
-        const oct = arguments[0]
-        if (oct.isNull()) return this
-        if (this.isNull()) {
-          this._minX = oct._minX
-          this._maxX = oct._maxX
-          this._minY = oct._minY
-          this._maxY = oct._maxY
-          this._minA = oct._minA
-          this._maxA = oct._maxA
-          this._minB = oct._minB
-          this._maxB = oct._maxB
-          return this
-        }
-        if (oct._minX < this._minX) this._minX = oct._minX
-        if (oct._maxX > this._maxX) this._maxX = oct._maxX
-        if (oct._minY < this._minY) this._minY = oct._minY
-        if (oct._maxY > this._maxY) this._maxY = oct._maxY
-        if (oct._minA < this._minA) this._minA = oct._minA
-        if (oct._maxA > this._maxA) this._maxA = oct._maxA
-        if (oct._minB < this._minB) this._minB = oct._minB
-        if (oct._maxB > this._maxB) this._maxB = oct._maxB
-        return this
-      } else if (arguments[0] instanceof Coordinate) {
-        const p = arguments[0]
-        this.expandToInclude(p.x, p.y)
-        return this
-      } else if (arguments[0] instanceof Envelope) {
-        const env = arguments[0]
-        this.expandToInclude(env.getMinX(), env.getMinY())
-        this.expandToInclude(env.getMinX(), env.getMaxY())
-        this.expandToInclude(env.getMaxX(), env.getMinY())
-        this.expandToInclude(env.getMaxX(), env.getMaxY())
-        return this
-      }
-    } else if (arguments.length === 2) {
-      const x = arguments[0], y = arguments[1]
-      const A = OctagonalEnvelope.computeA(x, y)
-      const B = OctagonalEnvelope.computeB(x, y)
-      if (this.isNull()) {
-        this._minX = x
-        this._maxX = x
-        this._minY = y
-        this._maxY = y
-        this._minA = A
-        this._maxA = A
-        this._minB = B
-        this._maxB = B
-      } else {
-        if (x < this._minX) this._minX = x
-        if (x > this._maxX) this._maxX = x
-        if (y < this._minY) this._minY = y
-        if (y > this._maxY) this._maxY = y
-        if (A < this._minA) this._minA = A
-        if (A > this._maxA) this._maxA = A
-        if (B < this._minB) this._minB = B
-        if (B > this._maxB) this._maxB = B
-      }
-      return this
-    }
-  }
-  getMinB() {
-    return this._minB
-  }
-  setToNull() {
-    this._minX = Double.NaN
-  }
-  expandBy(distance) {
-    if (this.isNull()) return null
-    const diagonalDistance = OctagonalEnvelope.SQRT2 * distance
-    this._minX -= distance
-    this._maxX += distance
-    this._minY -= distance
-    this._maxY += distance
-    this._minA -= diagonalDistance
-    this._maxA += diagonalDistance
-    this._minB -= diagonalDistance
-    this._maxB += diagonalDistance
-    if (!this.isValid()) this.setToNull()
-  }
-  getMaxA() {
-    return this._maxA
-  }
-  contains(other) {
-    if (this.isNull() || other.isNull()) 
-      return false
-    
-    return other._minX >= this._minX && other._maxX <= this._maxX && other._minY >= this._minY && other._maxY <= this._maxY && other._minA >= this._minA && other._maxA <= this._maxA && other._minB >= this._minB && other._maxB <= this._maxB
-  }
-  getMaxY() {
-    return this._maxY
-  }
-}
-class BoundingOctagonComponentFilter {
-  constructor() {
-    BoundingOctagonComponentFilter.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this.oe = null
-    const oe = arguments[0]
-    this.oe = oe
-  }
-  filter(geom) {
-    if (geom instanceof LineString) 
-      this.oe.expandToInclude(geom.getCoordinateSequence())
-    else if (geom instanceof Point) 
-      this.oe.expandToInclude(geom.getCoordinateSequence())
-    
-  }
-  get interfaces_() {
-    return [GeometryComponentFilter]
-  }
-}
-OctagonalEnvelope.BoundingOctagonComponentFilter = BoundingOctagonComponentFilter
-OctagonalEnvelope.SQRT2 = Math.sqrt(2.0)

package/node_modules/jsts/org/locationtech/jts/geom/Point.js

@@ -1,140 +0,0 @@
-import Geometry from './Geometry'
-import CoordinateFilter from './CoordinateFilter'
-import hasInterface from '../../../../hasInterface'
-import GeometryComponentFilter from './GeometryComponentFilter'
-import Dimension from './Dimension'
-import GeometryFilter from './GeometryFilter'
-import CoordinateSequenceFilter from './CoordinateSequenceFilter'
-import Puntal from './Puntal'
-import Envelope from './Envelope'
-import Assert from '../util/Assert'
-export default class Point extends Geometry {
-  constructor() {
-    super()
-    Point.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._coordinates = null
-    const coordinates = arguments[0], factory = arguments[1]
-    Geometry.constructor_.call(this, factory)
-    this.init(coordinates)
-  }
-  computeEnvelopeInternal() {
-    if (this.isEmpty()) 
-      return new Envelope()
-    
-    const env = new Envelope()
-    env.expandToInclude(this._coordinates.getX(0), this._coordinates.getY(0))
-    return env
-  }
-  getCoordinates() {
-    return this.isEmpty() ? [] : [this.getCoordinate()]
-  }
-  copyInternal() {
-    return new Point(this._coordinates.copy(), this._factory)
-  }
-  equalsExact() {
-    if (arguments.length === 2 && (typeof arguments[1] === 'number' && arguments[0] instanceof Geometry)) {
-      const other = arguments[0], tolerance = arguments[1]
-      if (!this.isEquivalentClass(other)) 
-        return false
-      
-      if (this.isEmpty() && other.isEmpty()) 
-        return true
-      
-      if (this.isEmpty() !== other.isEmpty()) 
-        return false
-      
-      return this.equal(other.getCoordinate(), this.getCoordinate(), tolerance)
-    } else {
-      return super.equalsExact.apply(this, arguments)
-    }
-  }
-  normalize() {}
-  getCoordinate() {
-    return this._coordinates.size() !== 0 ? this._coordinates.getCoordinate(0) : null
-  }
-  getBoundaryDimension() {
-    return Dimension.FALSE
-  }
-  reverseInternal() {
-    return this.getFactory().createPoint(this._coordinates.copy())
-  }
-  getTypeCode() {
-    return Geometry.TYPECODE_POINT
-  }
-  getDimension() {
-    return 0
-  }
-  getNumPoints() {
-    return this.isEmpty() ? 0 : 1
-  }
-  getX() {
-    if (this.getCoordinate() === null) 
-      throw new IllegalStateException('getX called on empty Point')
-    
-    return this.getCoordinate().x
-  }
-  compareToSameClass() {
-    if (arguments.length === 1) {
-      const other = arguments[0]
-      const point = other
-      return this.getCoordinate().compareTo(point.getCoordinate())
-    } else if (arguments.length === 2) {
-      const other = arguments[0], comp = arguments[1]
-      const point = other
-      return comp.compare(this._coordinates, point._coordinates)
-    }
-  }
-  apply() {
-    if (hasInterface(arguments[0], CoordinateFilter)) {
-      const filter = arguments[0]
-      if (this.isEmpty()) 
-        return null
-      
-      filter.filter(this.getCoordinate())
-    } else if (hasInterface(arguments[0], CoordinateSequenceFilter)) {
-      const filter = arguments[0]
-      if (this.isEmpty()) return null
-      filter.filter(this._coordinates, 0)
-      if (filter.isGeometryChanged()) this.geometryChanged()
-    } else if (hasInterface(arguments[0], GeometryFilter)) {
-      const filter = arguments[0]
-      filter.filter(this)
-    } else if (hasInterface(arguments[0], GeometryComponentFilter)) {
-      const filter = arguments[0]
-      filter.filter(this)
-    }
-  }
-  getBoundary() {
-    return this.getFactory().createGeometryCollection()
-  }
-  getGeometryType() {
-    return Geometry.TYPENAME_POINT
-  }
-  getCoordinateSequence() {
-    return this._coordinates
-  }
-  getY() {
-    if (this.getCoordinate() === null) 
-      throw new IllegalStateException('getY called on empty Point')
-    
-    return this.getCoordinate().y
-  }
-  isEmpty() {
-    return this._coordinates.size() === 0
-  }
-  init(coordinates) {
-    if (coordinates === null) 
-      coordinates = this.getFactory().getCoordinateSequenceFactory().create([])
-    
-    Assert.isTrue(coordinates.size() <= 1)
-    this._coordinates = coordinates
-  }
-  isSimple() {
-    return true
-  }
-  get interfaces_() {
-    return [Puntal]
-  }
-}