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

package/node_modules/jsts/org/locationtech/jts/operation/overlay/OverlayOp.js

@@ -1,312 +0,0 @@
-import PointLocator from '../../algorithm/PointLocator'
-import Location from '../../geom/Location'
-import EdgeNodingValidator from '../../geomgraph/EdgeNodingValidator'
-import GeometryCollectionMapper from '../../geom/util/GeometryCollectionMapper'
-import PolygonBuilder from './PolygonBuilder'
-import Position from '../../geomgraph/Position'
-import IllegalArgumentException from '../../../../../java/lang/IllegalArgumentException'
-import LineBuilder from './LineBuilder'
-import PointBuilder from './PointBuilder'
-import SnapIfNeededOverlayOp from './snap/SnapIfNeededOverlayOp'
-import Label from '../../geomgraph/Label'
-import OverlayNodeFactory from './OverlayNodeFactory'
-import GeometryGraphOperation from '../GeometryGraphOperation'
-import EdgeList from '../../geomgraph/EdgeList'
-import ArrayList from '../../../../../java/util/ArrayList'
-import Assert from '../../util/Assert'
-import PlanarGraph from '../../geomgraph/PlanarGraph'
-export default class OverlayOp extends GeometryGraphOperation {
-  constructor() {
-    super()
-    OverlayOp.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._ptLocator = new PointLocator()
-    this._geomFact = null
-    this._resultGeom = null
-    this._graph = null
-    this._edgeList = new EdgeList()
-    this._resultPolyList = new ArrayList()
-    this._resultLineList = new ArrayList()
-    this._resultPointList = new ArrayList()
-    const g0 = arguments[0], g1 = arguments[1]
-    GeometryGraphOperation.constructor_.call(this, g0, g1)
-    this._graph = new PlanarGraph(new OverlayNodeFactory())
-    this._geomFact = g0.getFactory()
-  }
-  static overlayOp(geom0, geom1, opCode) {
-    const gov = new OverlayOp(geom0, geom1)
-    const geomOv = gov.getResultGeometry(opCode)
-    return geomOv
-  }
-  static union(geom, other) {
-    if (geom.isEmpty() || other.isEmpty()) {
-      if (geom.isEmpty() && other.isEmpty()) return OverlayOp.createEmptyResult(OverlayOp.UNION, geom, other, geom.getFactory())
-      if (geom.isEmpty()) return other.copy()
-      if (other.isEmpty()) return geom.copy()
-    }
-    if (geom.isGeometryCollection() || other.isGeometryCollection()) throw new IllegalArgumentException('This method does not support GeometryCollection arguments')
-    return SnapIfNeededOverlayOp.overlayOp(geom, other, OverlayOp.UNION)
-  }
-  static intersection(geom, other) {
-    if (geom.isEmpty() || other.isEmpty()) return OverlayOp.createEmptyResult(OverlayOp.INTERSECTION, geom, other, geom.getFactory())
-    if (geom.isGeometryCollection()) {
-      const g2 = other
-      return GeometryCollectionMapper.map(geom, new (class {
-        get interfaces_() {
-          return [MapOp]
-        }
-        map(g) {
-          return OverlayOp.intersection(g, g2)
-        }
-      })())
-    }
-    return SnapIfNeededOverlayOp.overlayOp(geom, other, OverlayOp.INTERSECTION)
-  }
-  static symDifference(geom, other) {
-    if (geom.isEmpty() || other.isEmpty()) {
-      if (geom.isEmpty() && other.isEmpty()) return OverlayOp.createEmptyResult(OverlayOp.SYMDIFFERENCE, geom, other, geom.getFactory())
-      if (geom.isEmpty()) return other.copy()
-      if (other.isEmpty()) return geom.copy()
-    }
-    if (geom.isGeometryCollection() || other.isGeometryCollection()) throw new IllegalArgumentException('This method does not support GeometryCollection arguments')
-    return SnapIfNeededOverlayOp.overlayOp(geom, other, OverlayOp.SYMDIFFERENCE)
-  }
-  static resultDimension(opCode, g0, g1) {
-    const dim0 = g0.getDimension()
-    const dim1 = g1.getDimension()
-    let resultDimension = -1
-    switch (opCode) {
-    case OverlayOp.INTERSECTION:
-      resultDimension = Math.min(dim0, dim1)
-      break
-    case OverlayOp.UNION:
-      resultDimension = Math.max(dim0, dim1)
-      break
-    case OverlayOp.DIFFERENCE:
-      resultDimension = dim0
-      break
-    case OverlayOp.SYMDIFFERENCE:
-      resultDimension = Math.max(dim0, dim1)
-      break
-    }
-    return resultDimension
-  }
-  static createEmptyResult(overlayOpCode, a, b, geomFact) {
-    let result = null
-    const resultDim = OverlayOp.resultDimension(overlayOpCode, a, b)
-    return result = geomFact.createEmpty(resultDim)
-  }
-  static difference(geom, other) {
-    if (geom.isEmpty()) return OverlayOp.createEmptyResult(OverlayOp.DIFFERENCE, geom, other, geom.getFactory())
-    if (other.isEmpty()) return geom.copy()
-    if (geom.isGeometryCollection() || other.isGeometryCollection()) throw new IllegalArgumentException('This method does not support GeometryCollection arguments')
-    return SnapIfNeededOverlayOp.overlayOp(geom, other, OverlayOp.DIFFERENCE)
-  }
-  static isResultOfOp() {
-    if (arguments.length === 2) {
-      const label = arguments[0], opCode = arguments[1]
-      const loc0 = label.getLocation(0)
-      const loc1 = label.getLocation(1)
-      return OverlayOp.isResultOfOp(loc0, loc1, opCode)
-    } else if (arguments.length === 3) {
-      let loc0 = arguments[0], loc1 = arguments[1], overlayOpCode = arguments[2]
-      if (loc0 === Location.BOUNDARY) loc0 = Location.INTERIOR
-      if (loc1 === Location.BOUNDARY) loc1 = Location.INTERIOR
-      switch (overlayOpCode) {
-      case OverlayOp.INTERSECTION:
-        return loc0 === Location.INTERIOR && loc1 === Location.INTERIOR
-      case OverlayOp.UNION:
-        return loc0 === Location.INTERIOR || loc1 === Location.INTERIOR
-      case OverlayOp.DIFFERENCE:
-        return loc0 === Location.INTERIOR && loc1 !== Location.INTERIOR
-      case OverlayOp.SYMDIFFERENCE:
-        return loc0 === Location.INTERIOR && loc1 !== Location.INTERIOR || loc0 !== Location.INTERIOR && loc1 === Location.INTERIOR
-      }
-      return false
-    }
-  }
-  insertUniqueEdge(e) {
-    const existingEdge = this._edgeList.findEqualEdge(e)
-    if (existingEdge !== null) {
-      const existingLabel = existingEdge.getLabel()
-      let labelToMerge = e.getLabel()
-      if (!existingEdge.isPointwiseEqual(e)) {
-        labelToMerge = new Label(e.getLabel())
-        labelToMerge.flip()
-      }
-      const depth = existingEdge.getDepth()
-      if (depth.isNull()) 
-        depth.add(existingLabel)
-      
-      depth.add(labelToMerge)
-      existingLabel.merge(labelToMerge)
-    } else {
-      this._edgeList.add(e)
-    }
-  }
-  getGraph() {
-    return this._graph
-  }
-  cancelDuplicateResultEdges() {
-    for (let it = this._graph.getEdgeEnds().iterator(); it.hasNext(); ) {
-      const de = it.next()
-      const sym = de.getSym()
-      if (de.isInResult() && sym.isInResult()) {
-        de.setInResult(false)
-        sym.setInResult(false)
-      }
-    }
-  }
-  isCoveredByLA(coord) {
-    if (this.isCovered(coord, this._resultLineList)) return true
-    if (this.isCovered(coord, this._resultPolyList)) return true
-    return false
-  }
-  computeGeometry(resultPointList, resultLineList, resultPolyList, opcode) {
-    const geomList = new ArrayList()
-    geomList.addAll(resultPointList)
-    geomList.addAll(resultLineList)
-    geomList.addAll(resultPolyList)
-    if (geomList.isEmpty()) return OverlayOp.createEmptyResult(opcode, this._arg[0].getGeometry(), this._arg[1].getGeometry(), this._geomFact)
-    return this._geomFact.buildGeometry(geomList)
-  }
-  mergeSymLabels() {
-    for (let nodeit = this._graph.getNodes().iterator(); nodeit.hasNext(); ) {
-      const node = nodeit.next()
-      node.getEdges().mergeSymLabels()
-    }
-  }
-  isCovered(coord, geomList) {
-    for (let it = geomList.iterator(); it.hasNext(); ) {
-      const geom = it.next()
-      const loc = this._ptLocator.locate(coord, geom)
-      if (loc !== Location.EXTERIOR) return true
-    }
-    return false
-  }
-  replaceCollapsedEdges() {
-    const newEdges = new ArrayList()
-    for (let it = this._edgeList.iterator(); it.hasNext(); ) {
-      const e = it.next()
-      if (e.isCollapsed()) {
-        it.remove()
-        newEdges.add(e.getCollapsedEdge())
-      }
-    }
-    this._edgeList.addAll(newEdges)
-  }
-  updateNodeLabelling() {
-    for (let nodeit = this._graph.getNodes().iterator(); nodeit.hasNext(); ) {
-      const node = nodeit.next()
-      const lbl = node.getEdges().getLabel()
-      node.getLabel().merge(lbl)
-    }
-  }
-  getResultGeometry(overlayOpCode) {
-    this.computeOverlay(overlayOpCode)
-    return this._resultGeom
-  }
-  insertUniqueEdges(edges) {
-    for (let i = edges.iterator(); i.hasNext(); ) {
-      const e = i.next()
-      this.insertUniqueEdge(e)
-    }
-  }
-  computeOverlay(opCode) {
-    this.copyPoints(0)
-    this.copyPoints(1)
-    this._arg[0].computeSelfNodes(this._li, false)
-    this._arg[1].computeSelfNodes(this._li, false)
-    this._arg[0].computeEdgeIntersections(this._arg[1], this._li, true)
-    const baseSplitEdges = new ArrayList()
-    this._arg[0].computeSplitEdges(baseSplitEdges)
-    this._arg[1].computeSplitEdges(baseSplitEdges)
-    const splitEdges = baseSplitEdges
-    this.insertUniqueEdges(baseSplitEdges)
-    this.computeLabelsFromDepths()
-    this.replaceCollapsedEdges()
-    EdgeNodingValidator.checkValid(this._edgeList.getEdges())
-    this._graph.addEdges(this._edgeList.getEdges())
-    this.computeLabelling()
-    this.labelIncompleteNodes()
-    this.findResultAreaEdges(opCode)
-    this.cancelDuplicateResultEdges()
-    const polyBuilder = new PolygonBuilder(this._geomFact)
-    polyBuilder.add(this._graph)
-    this._resultPolyList = polyBuilder.getPolygons()
-    const lineBuilder = new LineBuilder(this, this._geomFact, this._ptLocator)
-    this._resultLineList = lineBuilder.build(opCode)
-    const pointBuilder = new PointBuilder(this, this._geomFact, this._ptLocator)
-    this._resultPointList = pointBuilder.build(opCode)
-    this._resultGeom = this.computeGeometry(this._resultPointList, this._resultLineList, this._resultPolyList, opCode)
-  }
-  labelIncompleteNode(n, targetIndex) {
-    const loc = this._ptLocator.locate(n.getCoordinate(), this._arg[targetIndex].getGeometry())
-    n.getLabel().setLocation(targetIndex, loc)
-  }
-  copyPoints(argIndex) {
-    for (let i = this._arg[argIndex].getNodeIterator(); i.hasNext(); ) {
-      const graphNode = i.next()
-      const newNode = this._graph.addNode(graphNode.getCoordinate())
-      newNode.setLabel(argIndex, graphNode.getLabel().getLocation(argIndex))
-    }
-  }
-  findResultAreaEdges(opCode) {
-    for (let it = this._graph.getEdgeEnds().iterator(); it.hasNext(); ) {
-      const de = it.next()
-      const label = de.getLabel()
-      if (label.isArea() && !de.isInteriorAreaEdge() && OverlayOp.isResultOfOp(label.getLocation(0, Position.RIGHT), label.getLocation(1, Position.RIGHT), opCode)) 
-        de.setInResult(true)
-      
-    }
-  }
-  computeLabelsFromDepths() {
-    for (let it = this._edgeList.iterator(); it.hasNext(); ) {
-      const e = it.next()
-      const lbl = e.getLabel()
-      const depth = e.getDepth()
-      if (!depth.isNull()) {
-        depth.normalize()
-        for (let i = 0; i < 2; i++) 
-          if (!lbl.isNull(i) && lbl.isArea() && !depth.isNull(i)) 
-            if (depth.getDelta(i) === 0) {
-              lbl.toLine(i)
-            } else {
-              Assert.isTrue(!depth.isNull(i, Position.LEFT), 'depth of LEFT side has not been initialized')
-              lbl.setLocation(i, Position.LEFT, depth.getLocation(i, Position.LEFT))
-              Assert.isTrue(!depth.isNull(i, Position.RIGHT), 'depth of RIGHT side has not been initialized')
-              lbl.setLocation(i, Position.RIGHT, depth.getLocation(i, Position.RIGHT))
-            }
-          
-        
-      }
-    }
-  }
-  computeLabelling() {
-    for (let nodeit = this._graph.getNodes().iterator(); nodeit.hasNext(); ) {
-      const node = nodeit.next()
-      node.getEdges().computeLabelling(this._arg)
-    }
-    this.mergeSymLabels()
-    this.updateNodeLabelling()
-  }
-  labelIncompleteNodes() {
-    for (let ni = this._graph.getNodes().iterator(); ni.hasNext(); ) {
-      const n = ni.next()
-      const label = n.getLabel()
-      if (n.isIsolated()) 
-        if (label.isNull(0)) this.labelIncompleteNode(n, 0); else this.labelIncompleteNode(n, 1)
-      
-      n.getEdges().updateLabelling(label)
-    }
-  }
-  isCoveredByA(coord) {
-    if (this.isCovered(coord, this._resultPolyList)) return true
-    return false
-  }
-}
-OverlayOp.INTERSECTION = 1
-OverlayOp.UNION = 2
-OverlayOp.DIFFERENCE = 3
-OverlayOp.SYMDIFFERENCE = 4

package/node_modules/jsts/org/locationtech/jts/operation/overlay/PointBuilder.js

@@ -1,39 +0,0 @@
-import ArrayList from '../../../../../java/util/ArrayList'
-import OverlayOp from './OverlayOp'
-export default class PointBuilder {
-  constructor() {
-    PointBuilder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._op = null
-    this._geometryFactory = null
-    this._resultPointList = new ArrayList()
-    const op = arguments[0], geometryFactory = arguments[1], ptLocator = arguments[2]
-    this._op = op
-    this._geometryFactory = geometryFactory
-  }
-  filterCoveredNodeToPoint(n) {
-    const coord = n.getCoordinate()
-    if (!this._op.isCoveredByLA(coord)) {
-      const pt = this._geometryFactory.createPoint(coord)
-      this._resultPointList.add(pt)
-    }
-  }
-  extractNonCoveredResultNodes(opCode) {
-    for (let nodeit = this._op.getGraph().getNodes().iterator(); nodeit.hasNext(); ) {
-      const n = nodeit.next()
-      if (n.isInResult()) continue
-      if (n.isIncidentEdgeInResult()) continue
-      if (n.getEdges().getDegree() === 0 || opCode === OverlayOp.INTERSECTION) {
-        const label = n.getLabel()
-        if (OverlayOp.isResultOfOp(label, opCode)) 
-          this.filterCoveredNodeToPoint(n)
-        
-      }
-    }
-  }
-  build(opCode) {
-    this.extractNonCoveredResultNodes(opCode)
-    return this._resultPointList
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/overlay/PolygonBuilder.js

@@ -1,144 +0,0 @@
-import PointLocation from '../../algorithm/PointLocation'
-import TopologyException from '../../geom/TopologyException'
-import MaximalEdgeRing from './MaximalEdgeRing'
-import CoordinateArrays from '../../geom/CoordinateArrays'
-import ArrayList from '../../../../../java/util/ArrayList'
-import Assert from '../../util/Assert'
-import PlanarGraph from '../../geomgraph/PlanarGraph'
-export default class PolygonBuilder {
-  constructor() {
-    PolygonBuilder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._geometryFactory = null
-    this._shellList = new ArrayList()
-    const geometryFactory = arguments[0]
-    this._geometryFactory = geometryFactory
-  }
-  static findEdgeRingContaining(testEr, shellList) {
-    const testRing = testEr.getLinearRing()
-    const testEnv = testRing.getEnvelopeInternal()
-    let testPt = testRing.getCoordinateN(0)
-    let minShell = null
-    let minShellEnv = null
-    for (let it = shellList.iterator(); it.hasNext(); ) {
-      const tryShell = it.next()
-      const tryShellRing = tryShell.getLinearRing()
-      const tryShellEnv = tryShellRing.getEnvelopeInternal()
-      if (tryShellEnv.equals(testEnv)) continue
-      if (!tryShellEnv.contains(testEnv)) continue
-      testPt = CoordinateArrays.ptNotInList(testRing.getCoordinates(), tryShellRing.getCoordinates())
-      let isContained = false
-      if (PointLocation.isInRing(testPt, tryShellRing.getCoordinates())) isContained = true
-      if (isContained) 
-        if (minShell === null || minShellEnv.contains(tryShellEnv)) {
-          minShell = tryShell
-          minShellEnv = minShell.getLinearRing().getEnvelopeInternal()
-        }
-      
-    }
-    return minShell
-  }
-  sortShellsAndHoles(edgeRings, shellList, freeHoleList) {
-    for (let it = edgeRings.iterator(); it.hasNext(); ) {
-      const er = it.next()
-      if (er.isHole()) 
-        freeHoleList.add(er)
-      else 
-        shellList.add(er)
-      
-    }
-  }
-  computePolygons(shellList) {
-    const resultPolyList = new ArrayList()
-    for (let it = shellList.iterator(); it.hasNext(); ) {
-      const er = it.next()
-      const poly = er.toPolygon(this._geometryFactory)
-      resultPolyList.add(poly)
-    }
-    return resultPolyList
-  }
-  placeFreeHoles(shellList, freeHoleList) {
-    for (let it = freeHoleList.iterator(); it.hasNext(); ) {
-      const hole = it.next()
-      if (hole.getShell() === null) {
-        const shell = PolygonBuilder.findEdgeRingContaining(hole, shellList)
-        if (shell === null) throw new TopologyException('unable to assign hole to a shell', hole.getCoordinate(0))
-        hole.setShell(shell)
-      }
-    }
-  }
-  buildMinimalEdgeRings(maxEdgeRings, shellList, freeHoleList) {
-    const edgeRings = new ArrayList()
-    for (let it = maxEdgeRings.iterator(); it.hasNext(); ) {
-      const er = it.next()
-      if (er.getMaxNodeDegree() > 2) {
-        er.linkDirectedEdgesForMinimalEdgeRings()
-        const minEdgeRings = er.buildMinimalRings()
-        const shell = this.findShell(minEdgeRings)
-        if (shell !== null) {
-          this.placePolygonHoles(shell, minEdgeRings)
-          shellList.add(shell)
-        } else {
-          freeHoleList.addAll(minEdgeRings)
-        }
-      } else {
-        edgeRings.add(er)
-      }
-    }
-    return edgeRings
-  }
-  buildMaximalEdgeRings(dirEdges) {
-    const maxEdgeRings = new ArrayList()
-    for (let it = dirEdges.iterator(); it.hasNext(); ) {
-      const de = it.next()
-      if (de.isInResult() && de.getLabel().isArea()) 
-        if (de.getEdgeRing() === null) {
-          const er = new MaximalEdgeRing(de, this._geometryFactory)
-          maxEdgeRings.add(er)
-          er.setInResult()
-        }
-      
-    }
-    return maxEdgeRings
-  }
-  placePolygonHoles(shell, minEdgeRings) {
-    for (let it = minEdgeRings.iterator(); it.hasNext(); ) {
-      const er = it.next()
-      if (er.isHole()) 
-        er.setShell(shell)
-      
-    }
-  }
-  getPolygons() {
-    const resultPolyList = this.computePolygons(this._shellList)
-    return resultPolyList
-  }
-  findShell(minEdgeRings) {
-    let shellCount = 0
-    let shell = null
-    for (let it = minEdgeRings.iterator(); it.hasNext(); ) {
-      const er = it.next()
-      if (!er.isHole()) {
-        shell = er
-        shellCount++
-      }
-    }
-    Assert.isTrue(shellCount <= 1, 'found two shells in MinimalEdgeRing list')
-    return shell
-  }
-  add() {
-    if (arguments.length === 1) {
-      const graph = arguments[0]
-      this.add(graph.getEdgeEnds(), graph.getNodes())
-    } else if (arguments.length === 2) {
-      const dirEdges = arguments[0], nodes = arguments[1]
-      PlanarGraph.linkResultDirectedEdges(nodes)
-      const maxEdgeRings = this.buildMaximalEdgeRings(dirEdges)
-      const freeHoleList = new ArrayList()
-      const edgeRings = this.buildMinimalEdgeRings(maxEdgeRings, this._shellList, freeHoleList)
-      this.sortShellsAndHoles(edgeRings, this._shellList, freeHoleList)
-      this.placeFreeHoles(this._shellList, freeHoleList)
-    }
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/overlay/snap/GeometrySnapper.js

@@ -1,118 +0,0 @@
-import TreeSet from '../../../../../../java/util/TreeSet'
-import GeometryTransformer from '../../../geom/util/GeometryTransformer'
-import hasInterface from '../../../../../../hasInterface'
-import Double from '../../../../../../java/lang/Double'
-import LineStringSnapper from './LineStringSnapper'
-import PrecisionModel from '../../../geom/PrecisionModel'
-import Polygonal from '../../../geom/Polygonal'
-export default class GeometrySnapper {
-  constructor() {
-    GeometrySnapper.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._srcGeom = null
-    const srcGeom = arguments[0]
-    this._srcGeom = srcGeom
-  }
-  static snap(g0, g1, snapTolerance) {
-    const snapGeom = new Array(2).fill(null)
-    const snapper0 = new GeometrySnapper(g0)
-    snapGeom[0] = snapper0.snapTo(g1, snapTolerance)
-    const snapper1 = new GeometrySnapper(g1)
-    snapGeom[1] = snapper1.snapTo(snapGeom[0], snapTolerance)
-    return snapGeom
-  }
-  static computeOverlaySnapTolerance() {
-    if (arguments.length === 1) {
-      const g = arguments[0]
-      let snapTolerance = GeometrySnapper.computeSizeBasedSnapTolerance(g)
-      const pm = g.getPrecisionModel()
-      if (pm.getType() === PrecisionModel.FIXED) {
-        const fixedSnapTol = 1 / pm.getScale() * 2 / 1.415
-        if (fixedSnapTol > snapTolerance) snapTolerance = fixedSnapTol
-      }
-      return snapTolerance
-    } else if (arguments.length === 2) {
-      const g0 = arguments[0], g1 = arguments[1]
-      return Math.min(GeometrySnapper.computeOverlaySnapTolerance(g0), GeometrySnapper.computeOverlaySnapTolerance(g1))
-    }
-  }
-  static computeSizeBasedSnapTolerance(g) {
-    const env = g.getEnvelopeInternal()
-    const minDimension = Math.min(env.getHeight(), env.getWidth())
-    const snapTol = minDimension * GeometrySnapper.SNAP_PRECISION_FACTOR
-    return snapTol
-  }
-  static snapToSelf(geom, snapTolerance, cleanResult) {
-    const snapper0 = new GeometrySnapper(geom)
-    return snapper0.snapToSelf(snapTolerance, cleanResult)
-  }
-  snapTo(snapGeom, snapTolerance) {
-    const snapPts = this.extractTargetCoordinates(snapGeom)
-    const snapTrans = new SnapTransformer(snapTolerance, snapPts)
-    return snapTrans.transform(this._srcGeom)
-  }
-  snapToSelf(snapTolerance, cleanResult) {
-    const snapPts = this.extractTargetCoordinates(this._srcGeom)
-    const snapTrans = new SnapTransformer(snapTolerance, snapPts, true)
-    const snappedGeom = snapTrans.transform(this._srcGeom)
-    let result = snappedGeom
-    if (cleanResult && hasInterface(result, Polygonal)) 
-      result = snappedGeom.buffer(0)
-    
-    return result
-  }
-  computeSnapTolerance(ringPts) {
-    const minSegLen = this.computeMinimumSegmentLength(ringPts)
-    const snapTol = minSegLen / 10
-    return snapTol
-  }
-  extractTargetCoordinates(g) {
-    const ptSet = new TreeSet()
-    const pts = g.getCoordinates()
-    for (let i = 0; i < pts.length; i++) 
-      ptSet.add(pts[i])
-    
-    return ptSet.toArray(new Array(0).fill(null))
-  }
-  computeMinimumSegmentLength(pts) {
-    let minSegLen = Double.MAX_VALUE
-    for (let i = 0; i < pts.length - 1; i++) {
-      const segLen = pts[i].distance(pts[i + 1])
-      if (segLen < minSegLen) minSegLen = segLen
-    }
-    return minSegLen
-  }
-}
-GeometrySnapper.SNAP_PRECISION_FACTOR = 1e-9
-class SnapTransformer extends GeometryTransformer {
-  constructor() {
-    super()
-    SnapTransformer.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._snapTolerance = null
-    this._snapPts = null
-    this._isSelfSnap = false
-    if (arguments.length === 2) {
-      const snapTolerance = arguments[0], snapPts = arguments[1]
-      this._snapTolerance = snapTolerance
-      this._snapPts = snapPts
-    } else if (arguments.length === 3) {
-      const snapTolerance = arguments[0], snapPts = arguments[1], isSelfSnap = arguments[2]
-      this._snapTolerance = snapTolerance
-      this._snapPts = snapPts
-      this._isSelfSnap = isSelfSnap
-    }
-  }
-  snapLine(srcPts, snapPts) {
-    const snapper = new LineStringSnapper(srcPts, this._snapTolerance)
-    snapper.setAllowSnappingToSourceVertices(this._isSelfSnap)
-    return snapper.snapTo(snapPts)
-  }
-  transformCoordinates(coords, parent) {
-    const srcPts = coords.toCoordinateArray()
-    const newPts = this.snapLine(srcPts, this._snapPts)
-    return this._factory.getCoordinateSequenceFactory().create(newPts)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/overlay/snap/LineStringSnapper.js

@@ -1,87 +0,0 @@
-import LineString from '../../../geom/LineString'
-import CoordinateList from '../../../geom/CoordinateList'
-import Coordinate from '../../../geom/Coordinate'
-import Double from '../../../../../../java/lang/Double'
-import LineSegment from '../../../geom/LineSegment'
-export default class LineStringSnapper {
-  constructor() {
-    LineStringSnapper.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._snapTolerance = 0.0
-    this._srcPts = null
-    this._seg = new LineSegment()
-    this._allowSnappingToSourceVertices = false
-    this._isClosed = false
-    if (arguments[0] instanceof LineString && typeof arguments[1] === 'number') {
-      const srcLine = arguments[0], snapTolerance = arguments[1]
-      LineStringSnapper.constructor_.call(this, srcLine.getCoordinates(), snapTolerance)
-    } else if (arguments[0] instanceof Array && typeof arguments[1] === 'number') {
-      const srcPts = arguments[0], snapTolerance = arguments[1]
-      this._srcPts = srcPts
-      this._isClosed = LineStringSnapper.isClosed(srcPts)
-      this._snapTolerance = snapTolerance
-    }
-  }
-  static isClosed(pts) {
-    if (pts.length <= 1) return false
-    return pts[0].equals2D(pts[pts.length - 1])
-  }
-  snapVertices(srcCoords, snapPts) {
-    const end = this._isClosed ? srcCoords.size() - 1 : srcCoords.size()
-    for (let i = 0; i < end; i++) {
-      const srcPt = srcCoords.get(i)
-      const snapVert = this.findSnapForVertex(srcPt, snapPts)
-      if (snapVert !== null) {
-        srcCoords.set(i, new Coordinate(snapVert))
-        if (i === 0 && this._isClosed) srcCoords.set(srcCoords.size() - 1, new Coordinate(snapVert))
-      }
-    }
-  }
-  findSnapForVertex(pt, snapPts) {
-    for (let i = 0; i < snapPts.length; i++) {
-      if (pt.equals2D(snapPts[i])) return null
-      if (pt.distance(snapPts[i]) < this._snapTolerance) return snapPts[i]
-    }
-    return null
-  }
-  snapTo(snapPts) {
-    const coordList = new CoordinateList(this._srcPts)
-    this.snapVertices(coordList, snapPts)
-    this.snapSegments(coordList, snapPts)
-    const newPts = coordList.toCoordinateArray()
-    return newPts
-  }
-  snapSegments(srcCoords, snapPts) {
-    if (snapPts.length === 0) return null
-    let distinctPtCount = snapPts.length
-    if (snapPts[0].equals2D(snapPts[snapPts.length - 1])) distinctPtCount = snapPts.length - 1
-    for (let i = 0; i < distinctPtCount; i++) {
-      const snapPt = snapPts[i]
-      const index = this.findSegmentIndexToSnap(snapPt, srcCoords)
-      if (index >= 0) 
-        srcCoords.add(index + 1, new Coordinate(snapPt), false)
-      
-    }
-  }
-  findSegmentIndexToSnap(snapPt, srcCoords) {
-    let minDist = Double.MAX_VALUE
-    let snapIndex = -1
-    for (let i = 0; i < srcCoords.size() - 1; i++) {
-      this._seg.p0 = srcCoords.get(i)
-      this._seg.p1 = srcCoords.get(i + 1)
-      if (this._seg.p0.equals2D(snapPt) || this._seg.p1.equals2D(snapPt)) 
-        if (this._allowSnappingToSourceVertices) continue; else return -1
-      
-      const dist = this._seg.distance(snapPt)
-      if (dist < this._snapTolerance && dist < minDist) {
-        minDist = dist
-        snapIndex = i
-      }
-    }
-    return snapIndex
-  }
-  setAllowSnappingToSourceVertices(allowSnappingToSourceVertices) {
-    this._allowSnappingToSourceVertices = allowSnappingToSourceVertices
-  }
-}