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

package/node_modules/jsts/org/locationtech/jts/noding/OrientedCoordinateArray.js

@@ -1,44 +0,0 @@
-import Comparable from '../../../../java/lang/Comparable'
-import CoordinateArrays from '../geom/CoordinateArrays'
-export default class OrientedCoordinateArray {
-  constructor() {
-    OrientedCoordinateArray.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._pts = null
-    this._orientation = null
-    const pts = arguments[0]
-    this._pts = pts
-    this._orientation = OrientedCoordinateArray.orientation(pts)
-  }
-  static orientation(pts) {
-    return CoordinateArrays.increasingDirection(pts) === 1
-  }
-  static compareOriented(pts1, orientation1, pts2, orientation2) {
-    const dir1 = orientation1 ? 1 : -1
-    const dir2 = orientation2 ? 1 : -1
-    const limit1 = orientation1 ? pts1.length : -1
-    const limit2 = orientation2 ? pts2.length : -1
-    let i1 = orientation1 ? 0 : pts1.length - 1
-    let i2 = orientation2 ? 0 : pts2.length - 1
-    while (true) {
-      const compPt = pts1[i1].compareTo(pts2[i2])
-      if (compPt !== 0) return compPt
-      i1 += dir1
-      i2 += dir2
-      const done1 = i1 === limit1
-      const done2 = i2 === limit2
-      if (done1 && !done2) return -1
-      if (!done1 && done2) return 1
-      if (done1 && done2) return 0
-    }
-  }
-  compareTo(o1) {
-    const oca = o1
-    const comp = OrientedCoordinateArray.compareOriented(this._pts, this._orientation, oca._pts, oca._orientation)
-    return comp
-  }
-  get interfaces_() {
-    return [Comparable]
-  }
-}

package/node_modules/jsts/org/locationtech/jts/noding/ScaledNoder.js

@@ -1,82 +0,0 @@
-import hasInterface from '../../../../hasInterface'
-import Collection from '../../../../java/util/Collection'
-import Noder from './Noder'
-import Coordinate from '../geom/Coordinate'
-import NodedSegmentString from './NodedSegmentString'
-import System from '../../../../java/lang/System'
-import CoordinateArrays from '../geom/CoordinateArrays'
-import ArrayList from '../../../../java/util/ArrayList'
-export default class ScaledNoder {
-  constructor() {
-    ScaledNoder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._noder = null
-    this._scaleFactor = null
-    this._offsetX = null
-    this._offsetY = null
-    this._isScaled = false
-    if (arguments.length === 2) {
-      const noder = arguments[0], scaleFactor = arguments[1]
-      ScaledNoder.constructor_.call(this, noder, scaleFactor, 0, 0)
-    } else if (arguments.length === 4) {
-      const noder = arguments[0], scaleFactor = arguments[1], offsetX = arguments[2], offsetY = arguments[3]
-      this._noder = noder
-      this._scaleFactor = scaleFactor
-      this._isScaled = !this.isIntegerPrecision()
-    }
-  }
-  rescale() {
-    if (hasInterface(arguments[0], Collection)) {
-      const segStrings = arguments[0]
-      for (let i = segStrings.iterator(); i.hasNext(); ) {
-        const ss = i.next()
-        this.rescale(ss.getCoordinates())
-      }
-    } else if (arguments[0] instanceof Array) {
-      const pts = arguments[0]
-      for (let i = 0; i < pts.length; i++) {
-        pts[i].x = pts[i].x / this._scaleFactor + this._offsetX
-        pts[i].y = pts[i].y / this._scaleFactor + this._offsetY
-      }
-      if (pts.length === 2 && pts[0].equals2D(pts[1])) 
-        System.out.println(pts)
-      
-    }
-  }
-  scale() {
-    if (hasInterface(arguments[0], Collection)) {
-      const segStrings = arguments[0]
-      const nodedSegmentStrings = new ArrayList(segStrings.size())
-      for (let i = segStrings.iterator(); i.hasNext(); ) {
-        const ss = i.next()
-        nodedSegmentStrings.add(new NodedSegmentString(this.scale(ss.getCoordinates()), ss.getData()))
-      }
-      return nodedSegmentStrings
-    } else if (arguments[0] instanceof Array) {
-      const pts = arguments[0]
-      const roundPts = new Array(pts.length).fill(null)
-      for (let i = 0; i < pts.length; i++) 
-        roundPts[i] = new Coordinate(Math.round((pts[i].x - this._offsetX) * this._scaleFactor), Math.round((pts[i].y - this._offsetY) * this._scaleFactor), pts[i].getZ())
-      
-      const roundPtsNoDup = CoordinateArrays.removeRepeatedPoints(roundPts)
-      return roundPtsNoDup
-    }
-  }
-  isIntegerPrecision() {
-    return this._scaleFactor === 1.0
-  }
-  getNodedSubstrings() {
-    const splitSS = this._noder.getNodedSubstrings()
-    if (this._isScaled) this.rescale(splitSS)
-    return splitSS
-  }
-  computeNodes(inputSegStrings) {
-    let intSegStrings = inputSegStrings
-    if (this._isScaled) intSegStrings = this.scale(inputSegStrings)
-    this._noder.computeNodes(intSegStrings)
-  }
-  get interfaces_() {
-    return [Noder]
-  }
-}

package/node_modules/jsts/org/locationtech/jts/noding/SegmentIntersectionDetector.js

@@ -1,80 +0,0 @@
-import SegmentIntersector from './SegmentIntersector'
-import RobustLineIntersector from '../algorithm/RobustLineIntersector'
-export default class SegmentIntersectionDetector {
-  constructor() {
-    SegmentIntersectionDetector.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._li = null
-    this._findProper = false
-    this._findAllTypes = false
-    this._hasIntersection = false
-    this._hasProperIntersection = false
-    this._hasNonProperIntersection = false
-    this._intPt = null
-    this._intSegments = null
-    if (arguments.length === 0) {
-      SegmentIntersectionDetector.constructor_.call(this, new RobustLineIntersector())
-    } else if (arguments.length === 1) {
-      const li = arguments[0]
-      this._li = li
-    }
-  }
-  getIntersectionSegments() {
-    return this._intSegments
-  }
-  setFindAllIntersectionTypes(findAllTypes) {
-    this._findAllTypes = findAllTypes
-  }
-  hasProperIntersection() {
-    return this._hasProperIntersection
-  }
-  getIntersection() {
-    return this._intPt
-  }
-  processIntersections(e0, segIndex0, e1, segIndex1) {
-    if (e0 === e1 && segIndex0 === segIndex1) return null
-    const p00 = e0.getCoordinates()[segIndex0]
-    const p01 = e0.getCoordinates()[segIndex0 + 1]
-    const p10 = e1.getCoordinates()[segIndex1]
-    const p11 = e1.getCoordinates()[segIndex1 + 1]
-    this._li.computeIntersection(p00, p01, p10, p11)
-    if (this._li.hasIntersection()) {
-      this._hasIntersection = true
-      const isProper = this._li.isProper()
-      if (isProper) this._hasProperIntersection = true
-      if (!isProper) this._hasNonProperIntersection = true
-      let saveLocation = true
-      if (this._findProper && !isProper) saveLocation = false
-      if (this._intPt === null || saveLocation) {
-        this._intPt = this._li.getIntersection(0)
-        this._intSegments = new Array(4).fill(null)
-        this._intSegments[0] = p00
-        this._intSegments[1] = p01
-        this._intSegments[2] = p10
-        this._intSegments[3] = p11
-      }
-    }
-  }
-  hasIntersection() {
-    return this._hasIntersection
-  }
-  isDone() {
-    if (this._findAllTypes) 
-      return this._hasProperIntersection && this._hasNonProperIntersection
-    
-    if (this._findProper) 
-      return this._hasProperIntersection
-    
-    return this._hasIntersection
-  }
-  hasNonProperIntersection() {
-    return this._hasNonProperIntersection
-  }
-  setFindProper(findProper) {
-    this._findProper = findProper
-  }
-  get interfaces_() {
-    return [SegmentIntersector]
-  }
-}

package/node_modules/jsts/org/locationtech/jts/noding/SegmentIntersector.js

@@ -1,4 +0,0 @@
-export default class SegmentIntersector {
-  processIntersections(e0, segIndex0, e1, segIndex1) {}
-  isDone() {}
-}

package/node_modules/jsts/org/locationtech/jts/noding/SegmentNode.js

@@ -1,51 +0,0 @@
-import Coordinate from '../geom/Coordinate'
-import SegmentPointComparator from './SegmentPointComparator'
-import Comparable from '../../../../java/lang/Comparable'
-export default class SegmentNode {
-  constructor() {
-    SegmentNode.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._segString = null
-    this.coord = null
-    this.segmentIndex = null
-    this._segmentOctant = null
-    this._isInterior = null
-    const segString = arguments[0], coord = arguments[1], segmentIndex = arguments[2], segmentOctant = arguments[3]
-    this._segString = segString
-    this.coord = new Coordinate(coord)
-    this.segmentIndex = segmentIndex
-    this._segmentOctant = segmentOctant
-    this._isInterior = !coord.equals2D(segString.getCoordinate(segmentIndex))
-  }
-  getCoordinate() {
-    return this.coord
-  }
-  print(out) {
-    out.print(this.coord)
-    out.print(' seg # = ' + this.segmentIndex)
-  }
-  compareTo(obj) {
-    const other = obj
-    if (this.segmentIndex < other.segmentIndex) return -1
-    if (this.segmentIndex > other.segmentIndex) return 1
-    if (this.coord.equals2D(other.coord)) return 0
-    if (!this._isInterior) return -1
-    if (!other._isInterior) return 1
-    return SegmentPointComparator.compare(this._segmentOctant, this.coord, other.coord)
-  }
-  isEndPoint(maxSegmentIndex) {
-    if (this.segmentIndex === 0 && !this._isInterior) return true
-    if (this.segmentIndex === maxSegmentIndex) return true
-    return false
-  }
-  toString() {
-    return this.segmentIndex + ':' + this.coord.toString()
-  }
-  isInterior() {
-    return this._isInterior
-  }
-  get interfaces_() {
-    return [Comparable]
-  }
-}

package/node_modules/jsts/org/locationtech/jts/noding/SegmentNodeList.js

@@ -1,199 +0,0 @@
-import CoordinateList from '../geom/CoordinateList'
-import SegmentNode from './SegmentNode'
-import Iterator from '../../../../java/util/Iterator'
-import Coordinate from '../geom/Coordinate'
-import NodedSegmentString from './NodedSegmentString'
-import Integer from '../../../../java/lang/Integer'
-import UnsupportedOperationException from '../../../../java/lang/UnsupportedOperationException'
-import ArrayList from '../../../../java/util/ArrayList'
-import RuntimeException from '../../../../java/lang/RuntimeException'
-import Assert from '../util/Assert'
-import TreeMap from '../../../../java/util/TreeMap'
-export default class SegmentNodeList {
-  constructor() {
-    SegmentNodeList.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._nodeMap = new TreeMap()
-    this._edge = null
-    const edge = arguments[0]
-    this._edge = edge
-  }
-  getSplitCoordinates() {
-    const coordList = new CoordinateList()
-    this.addEndpoints()
-    const it = this.iterator()
-    let eiPrev = it.next()
-    while (it.hasNext()) {
-      const ei = it.next()
-      this.addEdgeCoordinates(eiPrev, ei, coordList)
-      eiPrev = ei
-    }
-    return coordList.toCoordinateArray()
-  }
-  addCollapsedNodes() {
-    const collapsedVertexIndexes = new ArrayList()
-    this.findCollapsesFromInsertedNodes(collapsedVertexIndexes)
-    this.findCollapsesFromExistingVertices(collapsedVertexIndexes)
-    for (let it = collapsedVertexIndexes.iterator(); it.hasNext(); ) {
-      const vertexIndex = it.next().intValue()
-      this.add(this._edge.getCoordinate(vertexIndex), vertexIndex)
-    }
-  }
-  createSplitEdgePts(ei0, ei1) {
-    let npts = ei1.segmentIndex - ei0.segmentIndex + 2
-    if (npts === 2) return [new Coordinate(ei0.coord), new Coordinate(ei1.coord)]
-    const lastSegStartPt = this._edge.getCoordinate(ei1.segmentIndex)
-    const useIntPt1 = ei1.isInterior() || !ei1.coord.equals2D(lastSegStartPt)
-    if (!useIntPt1) 
-      npts--
-    
-    const pts = new Array(npts).fill(null)
-    let ipt = 0
-    pts[ipt++] = new Coordinate(ei0.coord)
-    for (let i = ei0.segmentIndex + 1; i <= ei1.segmentIndex; i++) 
-      pts[ipt++] = this._edge.getCoordinate(i)
-    
-    if (useIntPt1) pts[ipt] = new Coordinate(ei1.coord)
-    return pts
-  }
-  print(out) {
-    out.println('Intersections:')
-    for (let it = this.iterator(); it.hasNext(); ) {
-      const ei = it.next()
-      ei.print(out)
-    }
-  }
-  findCollapsesFromExistingVertices(collapsedVertexIndexes) {
-    for (let i = 0; i < this._edge.size() - 2; i++) {
-      const p0 = this._edge.getCoordinate(i)
-      const p1 = this._edge.getCoordinate(i + 1)
-      const p2 = this._edge.getCoordinate(i + 2)
-      if (p0.equals2D(p2)) 
-        collapsedVertexIndexes.add(Integer.valueOf(i + 1))
-      
-    }
-  }
-  addEdgeCoordinates(ei0, ei1, coordList) {
-    const pts = this.createSplitEdgePts(ei0, ei1)
-    coordList.add(pts, false)
-  }
-  iterator() {
-    return this._nodeMap.values().iterator()
-  }
-  addSplitEdges(edgeList) {
-    this.addEndpoints()
-    this.addCollapsedNodes()
-    const it = this.iterator()
-    let eiPrev = it.next()
-    while (it.hasNext()) {
-      const ei = it.next()
-      const newEdge = this.createSplitEdge(eiPrev, ei)
-      edgeList.add(newEdge)
-      eiPrev = ei
-    }
-  }
-  findCollapseIndex(ei0, ei1, collapsedVertexIndex) {
-    if (!ei0.coord.equals2D(ei1.coord)) return false
-    let numVerticesBetween = ei1.segmentIndex - ei0.segmentIndex
-    if (!ei1.isInterior()) 
-      numVerticesBetween--
-    
-    if (numVerticesBetween === 1) {
-      collapsedVertexIndex[0] = ei0.segmentIndex + 1
-      return true
-    }
-    return false
-  }
-  findCollapsesFromInsertedNodes(collapsedVertexIndexes) {
-    const collapsedVertexIndex = new Array(1).fill(null)
-    const it = this.iterator()
-    let eiPrev = it.next()
-    while (it.hasNext()) {
-      const ei = it.next()
-      const isCollapsed = this.findCollapseIndex(eiPrev, ei, collapsedVertexIndex)
-      if (isCollapsed) collapsedVertexIndexes.add(Integer.valueOf(collapsedVertexIndex[0]))
-      eiPrev = ei
-    }
-  }
-  getEdge() {
-    return this._edge
-  }
-  addEndpoints() {
-    const maxSegIndex = this._edge.size() - 1
-    this.add(this._edge.getCoordinate(0), 0)
-    this.add(this._edge.getCoordinate(maxSegIndex), maxSegIndex)
-  }
-  createSplitEdge(ei0, ei1) {
-    const pts = this.createSplitEdgePts(ei0, ei1)
-    return new NodedSegmentString(pts, this._edge.getData())
-  }
-  add(intPt, segmentIndex) {
-    const eiNew = new SegmentNode(this._edge, intPt, segmentIndex, this._edge.getSegmentOctant(segmentIndex))
-    const ei = this._nodeMap.get(eiNew)
-    if (ei !== null) {
-      Assert.isTrue(ei.coord.equals2D(intPt), 'Found equal nodes with different coordinates')
-      return ei
-    }
-    this._nodeMap.put(eiNew, eiNew)
-    return eiNew
-  }
-  checkSplitEdgesCorrectness(splitEdges) {
-    const edgePts = this._edge.getCoordinates()
-    const split0 = splitEdges.get(0)
-    const pt0 = split0.getCoordinate(0)
-    if (!pt0.equals2D(edgePts[0])) throw new RuntimeException('bad split edge start point at ' + pt0)
-    const splitn = splitEdges.get(splitEdges.size() - 1)
-    const splitnPts = splitn.getCoordinates()
-    const ptn = splitnPts[splitnPts.length - 1]
-    if (!ptn.equals2D(edgePts[edgePts.length - 1])) throw new RuntimeException('bad split edge end point at ' + ptn)
-  }
-}
-class NodeVertexIterator {
-  constructor() {
-    NodeVertexIterator.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._nodeList = null
-    this._edge = null
-    this._nodeIt = null
-    this._currNode = null
-    this._nextNode = null
-    this._currSegIndex = 0
-    const nodeList = arguments[0]
-    this._nodeList = nodeList
-    this._edge = nodeList.getEdge()
-    this._nodeIt = nodeList.iterator()
-    this.readNextNode()
-  }
-  next() {
-    if (this._currNode === null) {
-      this._currNode = this._nextNode
-      this._currSegIndex = this._currNode.segmentIndex
-      this.readNextNode()
-      return this._currNode
-    }
-    if (this._nextNode === null) return null
-    if (this._nextNode.segmentIndex === this._currNode.segmentIndex) {
-      this._currNode = this._nextNode
-      this._currSegIndex = this._currNode.segmentIndex
-      this.readNextNode()
-      return this._currNode
-    }
-    if (this._nextNode.segmentIndex > this._currNode.segmentIndex) {}
-    return null
-  }
-  remove() {
-    throw new UnsupportedOperationException(this.getClass().getName())
-  }
-  hasNext() {
-    if (this._nextNode === null) return false
-    return true
-  }
-  readNextNode() {
-    if (this._nodeIt.hasNext()) this._nextNode = this._nodeIt.next(); else this._nextNode = null
-  }
-  get interfaces_() {
-    return [Iterator]
-  }
-}

package/node_modules/jsts/org/locationtech/jts/noding/SegmentPointComparator.js

@@ -1,40 +0,0 @@
-import Assert from '../util/Assert'
-export default class SegmentPointComparator {
-  static relativeSign(x0, x1) {
-    if (x0 < x1) return -1
-    if (x0 > x1) return 1
-    return 0
-  }
-  static compare(octant, p0, p1) {
-    if (p0.equals2D(p1)) return 0
-    const xSign = SegmentPointComparator.relativeSign(p0.x, p1.x)
-    const ySign = SegmentPointComparator.relativeSign(p0.y, p1.y)
-    switch (octant) {
-    case 0:
-      return SegmentPointComparator.compareValue(xSign, ySign)
-    case 1:
-      return SegmentPointComparator.compareValue(ySign, xSign)
-    case 2:
-      return SegmentPointComparator.compareValue(ySign, -xSign)
-    case 3:
-      return SegmentPointComparator.compareValue(-xSign, ySign)
-    case 4:
-      return SegmentPointComparator.compareValue(-xSign, -ySign)
-    case 5:
-      return SegmentPointComparator.compareValue(-ySign, -xSign)
-    case 6:
-      return SegmentPointComparator.compareValue(-ySign, xSign)
-    case 7:
-      return SegmentPointComparator.compareValue(xSign, -ySign)
-    }
-    Assert.shouldNeverReachHere('invalid octant value')
-    return 0
-  }
-  static compareValue(compareSign0, compareSign1) {
-    if (compareSign0 < 0) return -1
-    if (compareSign0 > 0) return 1
-    if (compareSign1 < 0) return -1
-    if (compareSign1 > 0) return 1
-    return 0
-  }
-}

package/node_modules/jsts/org/locationtech/jts/noding/SegmentSetMutualIntersector.js

@@ -1,3 +0,0 @@
-export default class SegmentSetMutualIntersector {
-  process(segStrings, segInt) {}
-}

package/node_modules/jsts/org/locationtech/jts/noding/SegmentString.js

@@ -1,8 +0,0 @@
-export default class SegmentString {
-  getCoordinates() {}
-  size() {}
-  getCoordinate(i) {}
-  isClosed() {}
-  setData(data) {}
-  getData() {}
-}

package/node_modules/jsts/org/locationtech/jts/noding/SegmentStringDissolver.js

@@ -1,53 +0,0 @@
-import hasInterface from '../../../../hasInterface'
-import Collection from '../../../../java/util/Collection'
-import OrientedCoordinateArray from './OrientedCoordinateArray'
-import SegmentString from './SegmentString'
-import CoordinateArrays from '../geom/CoordinateArrays'
-import TreeMap from '../../../../java/util/TreeMap'
-export default class SegmentStringDissolver {
-  constructor() {
-    SegmentStringDissolver.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._merger = null
-    this._ocaMap = new TreeMap()
-    if (arguments.length === 0) {
-      SegmentStringDissolver.constructor_.call(this, null)
-    } else if (arguments.length === 1) {
-      const merger = arguments[0]
-      this._merger = merger
-    }
-  }
-  findMatching(oca, segString) {
-    const matchSS = this._ocaMap.get(oca)
-    return matchSS
-  }
-  getDissolved() {
-    return this._ocaMap.values()
-  }
-  dissolve() {
-    if (hasInterface(arguments[0], Collection)) {
-      const segStrings = arguments[0]
-      for (let i = segStrings.iterator(); i.hasNext(); ) 
-        this.dissolve(i.next())
-      
-    } else if (hasInterface(arguments[0], SegmentString)) {
-      const segString = arguments[0]
-      const oca = new OrientedCoordinateArray(segString.getCoordinates())
-      const existing = this.findMatching(oca, segString)
-      if (existing === null) {
-        this.add(oca, segString)
-      } else 
-      if (this._merger !== null) {
-        const isSameOrientation = CoordinateArrays.equals(existing.getCoordinates(), segString.getCoordinates())
-        this._merger.merge(existing, segString, isSameOrientation)
-      }
-      
-    }
-  }
-  add(oca, segString) {
-    this._ocaMap.put(oca, segString)
-  }
-}
-function SegmentStringMerger() {}
-SegmentStringDissolver.SegmentStringMerger = SegmentStringMerger

package/node_modules/jsts/org/locationtech/jts/noding/SegmentStringUtil.js

@@ -1,44 +0,0 @@
-import StringBuffer from '../../../../java/lang/StringBuffer'
-import hasInterface from '../../../../hasInterface'
-import NodedSegmentString from './NodedSegmentString'
-import ArrayList from '../../../../java/util/ArrayList'
-import LinearComponentExtracter from '../geom/util/LinearComponentExtracter'
-import List from '../../../../java/util/List'
-export default class SegmentStringUtil {
-  static toGeometry(segStrings, geomFact) {
-    const lines = new Array(segStrings.size()).fill(null)
-    let index = 0
-    for (let i = segStrings.iterator(); i.hasNext(); ) {
-      const ss = i.next()
-      const line = geomFact.createLineString(ss.getCoordinates())
-      lines[index++] = line
-    }
-    if (lines.length === 1) return lines[0]
-    return geomFact.createMultiLineString(lines)
-  }
-  static extractNodedSegmentStrings(geom) {
-    const segStr = new ArrayList()
-    const lines = LinearComponentExtracter.getLines(geom)
-    for (let i = lines.iterator(); i.hasNext(); ) {
-      const line = i.next()
-      const pts = line.getCoordinates()
-      segStr.add(new NodedSegmentString(pts, geom))
-    }
-    return segStr
-  }
-  static extractSegmentStrings(geom) {
-    return SegmentStringUtil.extractNodedSegmentStrings(geom)
-  }
-  static toString() {
-    if (arguments.length === 1 && hasInterface(arguments[0], List)) {
-      const segStrings = arguments[0]
-      const buf = new StringBuffer()
-      for (let i = segStrings.iterator(); i.hasNext(); ) {
-        const segStr = i.next()
-        buf.append(segStr.toString())
-        buf.append('\n')
-      }
-      return buf.toString()
-    }
-  }
-}

package/node_modules/jsts/org/locationtech/jts/noding/SimpleNoder.js

@@ -1,33 +0,0 @@
-import NodedSegmentString from './NodedSegmentString'
-import SinglePassNoder from './SinglePassNoder'
-export default class SimpleNoder extends SinglePassNoder {
-  constructor() {
-    super()
-    SimpleNoder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._nodedSegStrings = null
-  }
-  computeNodes(inputSegStrings) {
-    this._nodedSegStrings = inputSegStrings
-    for (let i0 = inputSegStrings.iterator(); i0.hasNext(); ) {
-      const edge0 = i0.next()
-      for (let i1 = inputSegStrings.iterator(); i1.hasNext(); ) {
-        const edge1 = i1.next()
-        this.computeIntersects(edge0, edge1)
-      }
-    }
-  }
-  computeIntersects(e0, e1) {
-    const pts0 = e0.getCoordinates()
-    const pts1 = e1.getCoordinates()
-    for (let i0 = 0; i0 < pts0.length - 1; i0++) 
-      for (let i1 = 0; i1 < pts1.length - 1; i1++) 
-        this._segInt.processIntersections(e0, i0, e1, i1)
-      
-    
-  }
-  getNodedSubstrings() {
-    return NodedSegmentString.getNodedSubstrings(this._nodedSegStrings)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/noding/SimpleSegmentSetMutualIntersector.js

@@ -1,34 +0,0 @@
-import SegmentSetMutualIntersector from './SegmentSetMutualIntersector'
-export default class SimpleSegmentSetMutualIntersector {
-  constructor() {
-    SimpleSegmentSetMutualIntersector.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._baseSegStrings = null
-    const segStrings = arguments[0]
-    this._baseSegStrings = segStrings
-  }
-  intersect(ss0, ss1, segInt) {
-    const pts0 = ss0.getCoordinates()
-    const pts1 = ss1.getCoordinates()
-    for (let i0 = 0; i0 < pts0.length - 1; i0++) 
-      for (let i1 = 0; i1 < pts1.length - 1; i1++) {
-        segInt.processIntersections(ss0, i0, ss1, i1)
-        if (segInt.isDone()) return null
-      }
-    
-  }
-  process(segStrings, segInt) {
-    for (let i = this._baseSegStrings.iterator(); i.hasNext(); ) {
-      const baseSS = i.next()
-      for (let j = segStrings.iterator(); j.hasNext(); ) {
-        const ss = j.next()
-        this.intersect(baseSS, ss, segInt)
-        if (segInt.isDone()) return null
-      }
-    }
-  }
-  get interfaces_() {
-    return [SegmentSetMutualIntersector]
-  }
-}