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

package/node_modules/jsts/org/locationtech/jts/operation/relate/EdgeEndBundle.js

@@ -1,93 +0,0 @@
-import Location from '../../geom/Location'
-import EdgeEnd from '../../geomgraph/EdgeEnd'
-import Position from '../../geomgraph/Position'
-import GeometryGraph from '../../geomgraph/GeometryGraph'
-import Label from '../../geomgraph/Label'
-import ArrayList from '../../../../../java/util/ArrayList'
-import Edge from '../../geomgraph/Edge'
-export default class EdgeEndBundle extends EdgeEnd {
-  constructor() {
-    super()
-    EdgeEndBundle.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._edgeEnds = new ArrayList()
-    if (arguments.length === 1) {
-      const e = arguments[0]
-      EdgeEndBundle.constructor_.call(this, null, e)
-    } else if (arguments.length === 2) {
-      const boundaryNodeRule = arguments[0], e = arguments[1]
-      EdgeEnd.constructor_.call(this, e.getEdge(), e.getCoordinate(), e.getDirectedCoordinate(), new Label(e.getLabel()))
-      this.insert(e)
-    }
-  }
-  insert(e) {
-    this._edgeEnds.add(e)
-  }
-  print(out) {
-    out.println('EdgeEndBundle--> Label: ' + this._label)
-    for (let it = this.iterator(); it.hasNext(); ) {
-      const ee = it.next()
-      ee.print(out)
-      out.println()
-    }
-  }
-  iterator() {
-    return this._edgeEnds.iterator()
-  }
-  getEdgeEnds() {
-    return this._edgeEnds
-  }
-  computeLabelOn(geomIndex, boundaryNodeRule) {
-    let boundaryCount = 0
-    let foundInterior = false
-    for (let it = this.iterator(); it.hasNext(); ) {
-      const e = it.next()
-      const loc = e.getLabel().getLocation(geomIndex)
-      if (loc === Location.BOUNDARY) boundaryCount++
-      if (loc === Location.INTERIOR) foundInterior = true
-    }
-    let loc = Location.NONE
-    if (foundInterior) loc = Location.INTERIOR
-    if (boundaryCount > 0) 
-      loc = GeometryGraph.determineBoundary(boundaryNodeRule, boundaryCount)
-    
-    this._label.setLocation(geomIndex, loc)
-  }
-  computeLabelSide(geomIndex, side) {
-    for (let it = this.iterator(); it.hasNext(); ) {
-      const e = it.next()
-      if (e.getLabel().isArea()) {
-        const loc = e.getLabel().getLocation(geomIndex, side)
-        if (loc === Location.INTERIOR) {
-          this._label.setLocation(geomIndex, side, Location.INTERIOR)
-          return null
-        } else if (loc === Location.EXTERIOR) {
-          this._label.setLocation(geomIndex, side, Location.EXTERIOR)
-        }
-      }
-    }
-  }
-  getLabel() {
-    return this._label
-  }
-  computeLabelSides(geomIndex) {
-    this.computeLabelSide(geomIndex, Position.LEFT)
-    this.computeLabelSide(geomIndex, Position.RIGHT)
-  }
-  updateIM(im) {
-    Edge.updateIM(this._label, im)
-  }
-  computeLabel(boundaryNodeRule) {
-    let isArea = false
-    for (let it = this.iterator(); it.hasNext(); ) {
-      const e = it.next()
-      if (e.getLabel().isArea()) isArea = true
-    }
-    if (isArea) this._label = new Label(Location.NONE, Location.NONE, Location.NONE); else this._label = new Label(Location.NONE)
-    for (let i = 0; i < 2; i++) {
-      this.computeLabelOn(i, boundaryNodeRule)
-      if (isArea) this.computeLabelSides(i)
-    }
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/relate/EdgeEndBundleStar.js

@@ -1,22 +0,0 @@
-import EdgeEndStar from '../../geomgraph/EdgeEndStar'
-import EdgeEndBundle from './EdgeEndBundle'
-export default class EdgeEndBundleStar extends EdgeEndStar {
-  constructor() {
-    super()
-  }
-  updateIM(im) {
-    for (let it = this.iterator(); it.hasNext(); ) {
-      const esb = it.next()
-      esb.updateIM(im)
-    }
-  }
-  insert(e) {
-    let eb = this._edgeMap.get(e)
-    if (eb === null) {
-      eb = new EdgeEndBundle(e)
-      this.insertEdgeEnd(e, eb)
-    } else {
-      eb.insert(e)
-    }
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/relate/RelateComputer.js

@@ -1,168 +0,0 @@
-import PointLocator from '../../algorithm/PointLocator'
-import Location from '../../geom/Location'
-import IntersectionMatrix from '../../geom/IntersectionMatrix'
-import EdgeEndBuilder from './EdgeEndBuilder'
-import NodeMap from '../../geomgraph/NodeMap'
-import RelateNodeFactory from './RelateNodeFactory'
-import ArrayList from '../../../../../java/util/ArrayList'
-import RobustLineIntersector from '../../algorithm/RobustLineIntersector'
-import Assert from '../../util/Assert'
-export default class RelateComputer {
-  constructor() {
-    RelateComputer.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._li = new RobustLineIntersector()
-    this._ptLocator = new PointLocator()
-    this._arg = null
-    this._nodes = new NodeMap(new RelateNodeFactory())
-    this._im = null
-    this._isolatedEdges = new ArrayList()
-    this._invalidPoint = null
-    const arg = arguments[0]
-    this._arg = arg
-  }
-  insertEdgeEnds(ee) {
-    for (let i = ee.iterator(); i.hasNext(); ) {
-      const e = i.next()
-      this._nodes.add(e)
-    }
-  }
-  computeProperIntersectionIM(intersector, im) {
-    const dimA = this._arg[0].getGeometry().getDimension()
-    const dimB = this._arg[1].getGeometry().getDimension()
-    const hasProper = intersector.hasProperIntersection()
-    const hasProperInterior = intersector.hasProperInteriorIntersection()
-    if (dimA === 2 && dimB === 2) {
-      if (hasProper) im.setAtLeast('212101212')
-    } else if (dimA === 2 && dimB === 1) {
-      if (hasProper) im.setAtLeast('FFF0FFFF2')
-      if (hasProperInterior) im.setAtLeast('1FFFFF1FF')
-    } else if (dimA === 1 && dimB === 2) {
-      if (hasProper) im.setAtLeast('F0FFFFFF2')
-      if (hasProperInterior) im.setAtLeast('1F1FFFFFF')
-    } else if (dimA === 1 && dimB === 1) {
-      if (hasProperInterior) im.setAtLeast('0FFFFFFFF')
-    }
-  }
-  labelIsolatedEdges(thisIndex, targetIndex) {
-    for (let ei = this._arg[thisIndex].getEdgeIterator(); ei.hasNext(); ) {
-      const e = ei.next()
-      if (e.isIsolated()) {
-        this.labelIsolatedEdge(e, targetIndex, this._arg[targetIndex].getGeometry())
-        this._isolatedEdges.add(e)
-      }
-    }
-  }
-  labelIsolatedEdge(e, targetIndex, target) {
-    if (target.getDimension() > 0) {
-      const loc = this._ptLocator.locate(e.getCoordinate(), target)
-      e.getLabel().setAllLocations(targetIndex, loc)
-    } else {
-      e.getLabel().setAllLocations(targetIndex, Location.EXTERIOR)
-    }
-  }
-  computeIM() {
-    const im = new IntersectionMatrix()
-    im.set(Location.EXTERIOR, Location.EXTERIOR, 2)
-    if (!this._arg[0].getGeometry().getEnvelopeInternal().intersects(this._arg[1].getGeometry().getEnvelopeInternal())) {
-      this.computeDisjointIM(im)
-      return im
-    }
-    this._arg[0].computeSelfNodes(this._li, false)
-    this._arg[1].computeSelfNodes(this._li, false)
-    const intersector = this._arg[0].computeEdgeIntersections(this._arg[1], this._li, false)
-    this.computeIntersectionNodes(0)
-    this.computeIntersectionNodes(1)
-    this.copyNodesAndLabels(0)
-    this.copyNodesAndLabels(1)
-    this.labelIsolatedNodes()
-    this.computeProperIntersectionIM(intersector, im)
-    const eeBuilder = new EdgeEndBuilder()
-    const ee0 = eeBuilder.computeEdgeEnds(this._arg[0].getEdgeIterator())
-    this.insertEdgeEnds(ee0)
-    const ee1 = eeBuilder.computeEdgeEnds(this._arg[1].getEdgeIterator())
-    this.insertEdgeEnds(ee1)
-    this.labelNodeEdges()
-    this.labelIsolatedEdges(0, 1)
-    this.labelIsolatedEdges(1, 0)
-    this.updateIM(im)
-    return im
-  }
-  labelNodeEdges() {
-    for (let ni = this._nodes.iterator(); ni.hasNext(); ) {
-      const node = ni.next()
-      node.getEdges().computeLabelling(this._arg)
-    }
-  }
-  copyNodesAndLabels(argIndex) {
-    for (let i = this._arg[argIndex].getNodeIterator(); i.hasNext(); ) {
-      const graphNode = i.next()
-      const newNode = this._nodes.addNode(graphNode.getCoordinate())
-      newNode.setLabel(argIndex, graphNode.getLabel().getLocation(argIndex))
-    }
-  }
-  labelIntersectionNodes(argIndex) {
-    for (let i = this._arg[argIndex].getEdgeIterator(); i.hasNext(); ) {
-      const e = i.next()
-      const eLoc = e.getLabel().getLocation(argIndex)
-      for (let eiIt = e.getEdgeIntersectionList().iterator(); eiIt.hasNext(); ) {
-        const ei = eiIt.next()
-        const n = this._nodes.find(ei.coord)
-        if (n.getLabel().isNull(argIndex)) 
-          if (eLoc === Location.BOUNDARY) n.setLabelBoundary(argIndex); else n.setLabel(argIndex, Location.INTERIOR)
-        
-      }
-    }
-  }
-  labelIsolatedNode(n, targetIndex) {
-    const loc = this._ptLocator.locate(n.getCoordinate(), this._arg[targetIndex].getGeometry())
-    n.getLabel().setAllLocations(targetIndex, loc)
-  }
-  computeIntersectionNodes(argIndex) {
-    for (let i = this._arg[argIndex].getEdgeIterator(); i.hasNext(); ) {
-      const e = i.next()
-      const eLoc = e.getLabel().getLocation(argIndex)
-      for (let eiIt = e.getEdgeIntersectionList().iterator(); eiIt.hasNext(); ) {
-        const ei = eiIt.next()
-        const n = this._nodes.addNode(ei.coord)
-        if (eLoc === Location.BOUNDARY) n.setLabelBoundary(argIndex); else 
-        if (n.getLabel().isNull(argIndex)) n.setLabel(argIndex, Location.INTERIOR)
-        
-      }
-    }
-  }
-  labelIsolatedNodes() {
-    for (let ni = this._nodes.iterator(); ni.hasNext(); ) {
-      const n = ni.next()
-      const label = n.getLabel()
-      Assert.isTrue(label.getGeometryCount() > 0, 'node with empty label found')
-      if (n.isIsolated()) 
-        if (label.isNull(0)) this.labelIsolatedNode(n, 0); else this.labelIsolatedNode(n, 1)
-      
-    }
-  }
-  updateIM(im) {
-    for (let ei = this._isolatedEdges.iterator(); ei.hasNext(); ) {
-      const e = ei.next()
-      e.updateIM(im)
-    }
-    for (let ni = this._nodes.iterator(); ni.hasNext(); ) {
-      const node = ni.next()
-      node.updateIM(im)
-      node.updateIMFromEdges(im)
-    }
-  }
-  computeDisjointIM(im) {
-    const ga = this._arg[0].getGeometry()
-    if (!ga.isEmpty()) {
-      im.set(Location.INTERIOR, Location.EXTERIOR, ga.getDimension())
-      im.set(Location.BOUNDARY, Location.EXTERIOR, ga.getBoundaryDimension())
-    }
-    const gb = this._arg[1].getGeometry()
-    if (!gb.isEmpty()) {
-      im.set(Location.EXTERIOR, Location.INTERIOR, gb.getDimension())
-      im.set(Location.EXTERIOR, Location.BOUNDARY, gb.getBoundaryDimension())
-    }
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/relate/RelateNode.js

@@ -1,17 +0,0 @@
-import Node from '../../geomgraph/Node'
-export default class RelateNode extends Node {
-  constructor() {
-    super()
-    RelateNode.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    const coord = arguments[0], edges = arguments[1]
-    Node.constructor_.call(this, coord, edges)
-  }
-  updateIMFromEdges(im) {
-    this._edges.updateIM(im)
-  }
-  computeIM(im) {
-    im.setAtLeastIfValid(this._label.getLocation(0), this._label.getLocation(1), 0)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/relate/RelateNodeFactory.js

@@ -1,11 +0,0 @@
-import EdgeEndBundleStar from './EdgeEndBundleStar'
-import RelateNode from './RelateNode'
-import NodeFactory from '../../geomgraph/NodeFactory'
-export default class RelateNodeFactory extends NodeFactory {
-  constructor() {
-    super()
-  }
-  createNode(coord) {
-    return new RelateNode(coord, new EdgeEndBundleStar())
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/relate/RelateNodeGraph.js

@@ -1,48 +0,0 @@
-import Location from '../../geom/Location'
-import EdgeEndBuilder from './EdgeEndBuilder'
-import NodeMap from '../../geomgraph/NodeMap'
-import RelateNodeFactory from './RelateNodeFactory'
-export default class RelateNodeGraph {
-  constructor() {
-    RelateNodeGraph.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._nodes = new NodeMap(new RelateNodeFactory())
-  }
-  insertEdgeEnds(ee) {
-    for (let i = ee.iterator(); i.hasNext(); ) {
-      const e = i.next()
-      this._nodes.add(e)
-    }
-  }
-  getNodeIterator() {
-    return this._nodes.iterator()
-  }
-  copyNodesAndLabels(geomGraph, argIndex) {
-    for (let nodeIt = geomGraph.getNodeIterator(); nodeIt.hasNext(); ) {
-      const graphNode = nodeIt.next()
-      const newNode = this._nodes.addNode(graphNode.getCoordinate())
-      newNode.setLabel(argIndex, graphNode.getLabel().getLocation(argIndex))
-    }
-  }
-  build(geomGraph) {
-    this.computeIntersectionNodes(geomGraph, 0)
-    this.copyNodesAndLabels(geomGraph, 0)
-    const eeBuilder = new EdgeEndBuilder()
-    const eeList = eeBuilder.computeEdgeEnds(geomGraph.getEdgeIterator())
-    this.insertEdgeEnds(eeList)
-  }
-  computeIntersectionNodes(geomGraph, argIndex) {
-    for (let edgeIt = geomGraph.getEdgeIterator(); edgeIt.hasNext(); ) {
-      const e = edgeIt.next()
-      const eLoc = e.getLabel().getLocation(argIndex)
-      for (let eiIt = e.getEdgeIntersectionList().iterator(); eiIt.hasNext(); ) {
-        const ei = eiIt.next()
-        const n = this._nodes.addNode(ei.coord)
-        if (eLoc === Location.BOUNDARY) n.setLabelBoundary(argIndex); else 
-        if (n.getLabel().isNull(argIndex)) n.setLabel(argIndex, Location.INTERIOR)
-        
-      }
-    }
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/relate/RelateOp.js

@@ -1,101 +0,0 @@
-import RelateComputer from './RelateComputer'
-import GeometryGraphOperation from '../GeometryGraphOperation'
-import RectangleContains from '../predicate/RectangleContains'
-import RectangleIntersects from '../predicate/RectangleIntersects'
-export default class RelateOp extends GeometryGraphOperation {
-  constructor() {
-    super()
-    RelateOp.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._relate = null
-    if (arguments.length === 2) {
-      const g0 = arguments[0], g1 = arguments[1]
-      GeometryGraphOperation.constructor_.call(this, g0, g1)
-      this._relate = new RelateComputer(this._arg)
-    } else if (arguments.length === 3) {
-      const g0 = arguments[0], g1 = arguments[1], boundaryNodeRule = arguments[2]
-      GeometryGraphOperation.constructor_.call(this, g0, g1, boundaryNodeRule)
-      this._relate = new RelateComputer(this._arg)
-    }
-  }
-  static covers(g1, g2) {
-    if (g2.getDimension() === 2 && g1.getDimension() < 2) 
-      return false
-    
-    if (g2.getDimension() === 1 && g1.getDimension() < 1 && g2.getLength() > 0.0) 
-      return false
-    
-    if (!g1.getEnvelopeInternal().covers(g2.getEnvelopeInternal())) return false
-    if (g1.isRectangle()) 
-      return true
-    
-    return new RelateOp(g1, g2).getIntersectionMatrix().isCovers()
-  }
-  static intersects(g1, g2) {
-    if (!g1.getEnvelopeInternal().intersects(g2.getEnvelopeInternal())) return false
-    if (g1.isRectangle()) 
-      return RectangleIntersects.intersects(g1, g2)
-    
-    if (g2.isRectangle()) 
-      return RectangleIntersects.intersects(g2, g1)
-    
-    if (g1.isGeometryCollection() || g2.isGeometryCollection()) {
-      const r = false
-      for (let i = 0; i < g1.getNumGeometries(); i++) 
-        for (let j = 0; j < g2.getNumGeometries(); j++) 
-          if (g1.getGeometryN(i).intersects(g2.getGeometryN(j))) 
-            return true
-          
-        
-      
-      return false
-    }
-    return new RelateOp(g1, g2).getIntersectionMatrix().isIntersects()
-  }
-  static touches(g1, g2) {
-    if (!g1.getEnvelopeInternal().intersects(g2.getEnvelopeInternal())) return false
-    return new RelateOp(g1, g2).getIntersectionMatrix().isTouches(g1.getDimension(), g2.getDimension())
-  }
-  static equalsTopo(g1, g2) {
-    if (!g1.getEnvelopeInternal().equals(g2.getEnvelopeInternal())) return false
-    return RelateOp.relate(g1, g2).isEquals(g1.getDimension(), g2.getDimension())
-  }
-  static relate() {
-    if (arguments.length === 2) {
-      const a = arguments[0], b = arguments[1]
-      const relOp = new RelateOp(a, b)
-      const im = relOp.getIntersectionMatrix()
-      return im
-    } else if (arguments.length === 3) {
-      const a = arguments[0], b = arguments[1], boundaryNodeRule = arguments[2]
-      const relOp = new RelateOp(a, b, boundaryNodeRule)
-      const im = relOp.getIntersectionMatrix()
-      return im
-    }
-  }
-  static overlaps(g1, g2) {
-    if (!g1.getEnvelopeInternal().intersects(g2.getEnvelopeInternal())) return false
-    return new RelateOp(g1, g2).getIntersectionMatrix().isOverlaps(g1.getDimension(), g2.getDimension())
-  }
-  static crosses(g1, g2) {
-    if (!g1.getEnvelopeInternal().intersects(g2.getEnvelopeInternal())) return false
-    return new RelateOp(g1, g2).getIntersectionMatrix().isCrosses(g1.getDimension(), g2.getDimension())
-  }
-  static contains(g1, g2) {
-    if (g2.getDimension() === 2 && g1.getDimension() < 2) 
-      return false
-    
-    if (g2.getDimension() === 1 && g1.getDimension() < 1 && g2.getLength() > 0.0) 
-      return false
-    
-    if (!g1.getEnvelopeInternal().contains(g2.getEnvelopeInternal())) return false
-    if (g1.isRectangle()) 
-      return RectangleContains.contains(g1, g2)
-    
-    return new RelateOp(g1, g2).getIntersectionMatrix().isContains()
-  }
-  getIntersectionMatrix() {
-    return this._relate.computeIM()
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/relate.js

@@ -1,5 +0,0 @@
-import RelateOp from './relate/RelateOp'
-
-export {
-  RelateOp
-}

package/node_modules/jsts/org/locationtech/jts/operation/union/CascadedPolygonUnion.js

@@ -1,124 +0,0 @@
-import PolygonExtracter from '../../geom/util/PolygonExtracter'
-import OverlapUnion from './OverlapUnion'
-import STRtree from '../../index/strtree/STRtree'
-import Geometry from '../../geom/Geometry'
-import hasInterface from '../../../../../hasInterface'
-import GeometryFactory from '../../geom/GeometryFactory'
-import Polygonal from '../../geom/Polygonal'
-import ArrayList from '../../../../../java/util/ArrayList'
-import List from '../../../../../java/util/List'
-export default class CascadedPolygonUnion {
-  constructor() {
-    CascadedPolygonUnion.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._inputPolys = null
-    this._geomFactory = null
-    const polys = arguments[0]
-    this._inputPolys = polys
-    if (this._inputPolys === null) this._inputPolys = new ArrayList()
-  }
-  static restrictToPolygons(g) {
-    if (hasInterface(g, Polygonal)) 
-      return g
-    
-    const polygons = PolygonExtracter.getPolygons(g)
-    if (polygons.size() === 1) return polygons.get(0)
-    return g.getFactory().createMultiPolygon(GeometryFactory.toPolygonArray(polygons))
-  }
-  static getGeometry(list, index) {
-    if (index >= list.size()) return null
-    return list.get(index)
-  }
-  static union(polys) {
-    const op = new CascadedPolygonUnion(polys)
-    return op.union()
-  }
-  reduceToGeometries(geomTree) {
-    const geoms = new ArrayList()
-    for (let i = geomTree.iterator(); i.hasNext(); ) {
-      const o = i.next()
-      let geom = null
-      if (hasInterface(o, List)) 
-        geom = this.unionTree(o)
-      else if (o instanceof Geometry) 
-        geom = o
-      
-      geoms.add(geom)
-    }
-    return geoms
-  }
-  union() {
-    if (this._inputPolys === null) throw new IllegalStateException('union() method cannot be called twice')
-    if (this._inputPolys.isEmpty()) return null
-    this._geomFactory = this._inputPolys.iterator().next().getFactory()
-    const index = new STRtree(CascadedPolygonUnion.STRTREE_NODE_CAPACITY)
-    for (let i = this._inputPolys.iterator(); i.hasNext(); ) {
-      const item = i.next()
-      index.insert(item.getEnvelopeInternal(), item)
-    }
-    this._inputPolys = null
-    const itemTree = index.itemsTree()
-    const unionAll = this.unionTree(itemTree)
-    return unionAll
-  }
-  binaryUnion() {
-    if (arguments.length === 1) {
-      const geoms = arguments[0]
-      return this.binaryUnion(geoms, 0, geoms.size())
-    } else if (arguments.length === 3) {
-      const geoms = arguments[0], start = arguments[1], end = arguments[2]
-      if (end - start <= 1) {
-        const g0 = CascadedPolygonUnion.getGeometry(geoms, start)
-        return this.unionSafe(g0, null)
-      } else if (end - start === 2) {
-        return this.unionSafe(CascadedPolygonUnion.getGeometry(geoms, start), CascadedPolygonUnion.getGeometry(geoms, start + 1))
-      } else {
-        const mid = Math.trunc((end + start) / 2)
-        const g0 = this.binaryUnion(geoms, start, mid)
-        const g1 = this.binaryUnion(geoms, mid, end)
-        return this.unionSafe(g0, g1)
-      }
-    }
-  }
-  repeatedUnion(geoms) {
-    let union = null
-    for (let i = geoms.iterator(); i.hasNext(); ) {
-      const g = i.next()
-      if (union === null) union = g.copy(); else union = union.union(g)
-    }
-    return union
-  }
-  unionSafe(g0, g1) {
-    if (g0 === null && g1 === null) return null
-    if (g0 === null) return g1.copy()
-    if (g1 === null) return g0.copy()
-    return this.unionActual(g0, g1)
-  }
-  unionActual(g0, g1) {
-    const union = OverlapUnion.union(g0, g1)
-    
-    return CascadedPolygonUnion.restrictToPolygons(union)
-  }
-  unionTree(geomTree) {
-    const geoms = this.reduceToGeometries(geomTree)
-    const union = this.binaryUnion(geoms)
-    return union
-  }
-  bufferUnion() {
-    if (arguments.length === 1) {
-      const geoms = arguments[0]
-      const factory = geoms.get(0).getFactory()
-      const gColl = factory.buildGeometry(geoms)
-      const unionAll = gColl.buffer(0.0)
-      return unionAll
-    } else if (arguments.length === 2) {
-      const g0 = arguments[0], g1 = arguments[1]
-      const factory = g0.getFactory()
-      const gColl = factory.createGeometryCollection([g0, g1])
-      const unionAll = gColl.buffer(0.0)
-      return unionAll
-    }
-  }
-}
-CascadedPolygonUnion.STRTREE_NODE_CAPACITY = 4

package/node_modules/jsts/org/locationtech/jts/operation/union/InputExtracter.js

@@ -1,93 +0,0 @@
-import LineString from '../../geom/LineString'
-import Geometry from '../../geom/Geometry'
-import hasInterface from '../../../../../hasInterface'
-import Collection from '../../../../../java/util/Collection'
-import Point from '../../geom/Point'
-import Polygon from '../../geom/Polygon'
-import GeometryCollection from '../../geom/GeometryCollection'
-import Dimension from '../../geom/Dimension'
-import ArrayList from '../../../../../java/util/ArrayList'
-import GeometryFilter from '../../geom/GeometryFilter'
-import Assert from '../../util/Assert'
-export default class InputExtracter {
-  constructor() {
-    InputExtracter.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._geomFactory = null
-    this._polygons = new ArrayList()
-    this._lines = new ArrayList()
-    this._points = new ArrayList()
-    this._dimension = Dimension.FALSE
-  }
-  static extract() {
-    if (hasInterface(arguments[0], Collection)) {
-      const geoms = arguments[0]
-      const extracter = new InputExtracter()
-      extracter.add(geoms)
-      return extracter
-    } else if (arguments[0] instanceof Geometry) {
-      const geom = arguments[0]
-      const extracter = new InputExtracter()
-      extracter.add(geom)
-      return extracter
-    }
-  }
-  getFactory() {
-    return this._geomFactory
-  }
-  recordDimension(dim) {
-    if (dim > this._dimension) this._dimension = dim
-  }
-  getDimension() {
-    return this._dimension
-  }
-  filter(geom) {
-    this.recordDimension(geom.getDimension())
-    if (geom instanceof GeometryCollection) 
-      return null
-    
-    if (geom.isEmpty()) return null
-    if (geom instanceof Polygon) {
-      this._polygons.add(geom)
-      return null
-    } else if (geom instanceof LineString) {
-      this._lines.add(geom)
-      return null
-    } else if (geom instanceof Point) {
-      this._points.add(geom)
-      return null
-    }
-    Assert.shouldNeverReachHere('Unhandled geometry type: ' + geom.getGeometryType())
-  }
-  getExtract(dim) {
-    switch (dim) {
-    case 0:
-      return this._points
-    case 1:
-      return this._lines
-    case 2:
-      return this._polygons
-    }
-    Assert.shouldNeverReachHere('Invalid dimension: ' + dim)
-    return null
-  }
-  isEmpty() {
-    return this._polygons.isEmpty() && this._lines.isEmpty() && this._points.isEmpty()
-  }
-  add() {
-    if (hasInterface(arguments[0], Collection)) {
-      const geoms = arguments[0]
-      for (const geom of geoms) 
-        this.add(geom)
-      
-    } else if (arguments[0] instanceof Geometry) {
-      const geom = arguments[0]
-      if (this._geomFactory === null) this._geomFactory = geom.getFactory()
-      geom.apply(this)
-    }
-  }
-  get interfaces_() {
-    return [GeometryFilter]
-  }
-}