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

package/node_modules/jsts/org/locationtech/jts/index/bintree/Root.js

@@ -1,33 +0,0 @@
-import NodeBase from './NodeBase'
-import Node from './Node'
-import IntervalSize from '../quadtree/IntervalSize'
-import Assert from '../../util/Assert'
-export default class Root extends NodeBase {
-  constructor() {
-    super()
-  }
-  insert(itemInterval, item) {
-    const index = NodeBase.getSubnodeIndex(itemInterval, Root.origin)
-    if (index === -1) {
-      this.add(item)
-      return null
-    }
-    const node = this._subnode[index]
-    if (node === null || !node.getInterval().contains(itemInterval)) {
-      const largerNode = Node.createExpanded(node, itemInterval)
-      this._subnode[index] = largerNode
-    }
-    this.insertContained(this._subnode[index], itemInterval, item)
-  }
-  isSearchMatch(interval) {
-    return true
-  }
-  insertContained(tree, itemInterval, item) {
-    Assert.isTrue(tree.getInterval().contains(itemInterval))
-    const isZeroArea = IntervalSize.isZeroWidth(itemInterval.getMin(), itemInterval.getMax())
-    let node = null
-    if (isZeroArea) node = tree.find(itemInterval); else node = tree.getNode(itemInterval)
-    node.add(item)
-  }
-}
-Root.origin = 0.0

package/node_modules/jsts/org/locationtech/jts/index/chain/MonotoneChain.js

@@ -1,99 +0,0 @@
-import Envelope from '../../geom/Envelope'
-export default class MonotoneChain {
-  constructor() {
-    MonotoneChain.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._pts = null
-    this._start = null
-    this._end = null
-    this._env = null
-    this._context = null
-    this._id = null
-    const pts = arguments[0], start = arguments[1], end = arguments[2], context = arguments[3]
-    this._pts = pts
-    this._start = start
-    this._end = end
-    this._context = context
-  }
-  getLineSegment(index, ls) {
-    ls.p0 = this._pts[index]
-    ls.p1 = this._pts[index + 1]
-  }
-  computeSelect(searchEnv, start0, end0, mcs) {
-    const p0 = this._pts[start0]
-    const p1 = this._pts[end0]
-    if (end0 - start0 === 1) {
-      mcs.select(this, start0)
-      return null
-    }
-    if (!searchEnv.intersects(p0, p1)) return null
-    const mid = Math.trunc((start0 + end0) / 2)
-    if (start0 < mid) 
-      this.computeSelect(searchEnv, start0, mid, mcs)
-    
-    if (mid < end0) 
-      this.computeSelect(searchEnv, mid, end0, mcs)
-    
-  }
-  getCoordinates() {
-    const coord = new Array(this._end - this._start + 1).fill(null)
-    let index = 0
-    for (let i = this._start; i <= this._end; i++) 
-      coord[index++] = this._pts[i]
-    
-    return coord
-  }
-  computeOverlaps() {
-    if (arguments.length === 2) {
-      const mc = arguments[0], mco = arguments[1]
-      this.computeOverlaps(this._start, this._end, mc, mc._start, mc._end, mco)
-    } else if (arguments.length === 6) {
-      const start0 = arguments[0], end0 = arguments[1], mc = arguments[2], start1 = arguments[3], end1 = arguments[4], mco = arguments[5]
-      if (end0 - start0 === 1 && end1 - start1 === 1) {
-        mco.overlap(this, start0, mc, start1)
-        return null
-      }
-      if (!this.overlaps(start0, end0, mc, start1, end1)) return null
-      const mid0 = Math.trunc((start0 + end0) / 2)
-      const mid1 = Math.trunc((start1 + end1) / 2)
-      if (start0 < mid0) {
-        if (start1 < mid1) this.computeOverlaps(start0, mid0, mc, start1, mid1, mco)
-        if (mid1 < end1) this.computeOverlaps(start0, mid0, mc, mid1, end1, mco)
-      }
-      if (mid0 < end0) {
-        if (start1 < mid1) this.computeOverlaps(mid0, end0, mc, start1, mid1, mco)
-        if (mid1 < end1) this.computeOverlaps(mid0, end0, mc, mid1, end1, mco)
-      }
-    }
-  }
-  setId(id) {
-    this._id = id
-  }
-  select(searchEnv, mcs) {
-    this.computeSelect(searchEnv, this._start, this._end, mcs)
-  }
-  getEnvelope() {
-    if (this._env === null) {
-      const p0 = this._pts[this._start]
-      const p1 = this._pts[this._end]
-      this._env = new Envelope(p0, p1)
-    }
-    return this._env
-  }
-  overlaps(start0, end0, mc, start1, end1) {
-    return Envelope.intersects(this._pts[start0], this._pts[end0], mc._pts[start1], mc._pts[end1])
-  }
-  getEndIndex() {
-    return this._end
-  }
-  getStartIndex() {
-    return this._start
-  }
-  getContext() {
-    return this._context
-  }
-  getId() {
-    return this._id
-  }
-}

package/node_modules/jsts/org/locationtech/jts/index/chain/MonotoneChainBuilder.js

@@ -1,41 +0,0 @@
-import MonotoneChain from './MonotoneChain'
-import ArrayList from '../../../../../java/util/ArrayList'
-import Quadrant from '../../geomgraph/Quadrant'
-export default class MonotoneChainBuilder {
-  static findChainEnd(pts, start) {
-    let safeStart = start
-    while (safeStart < pts.length - 1 && pts[safeStart].equals2D(pts[safeStart + 1])) 
-      safeStart++
-    
-    if (safeStart >= pts.length - 1) 
-      return pts.length - 1
-    
-    const chainQuad = Quadrant.quadrant(pts[safeStart], pts[safeStart + 1])
-    let last = start + 1
-    while (last < pts.length) {
-      if (!pts[last - 1].equals2D(pts[last])) {
-        const quad = Quadrant.quadrant(pts[last - 1], pts[last])
-        if (quad !== chainQuad) break
-      }
-      last++
-    }
-    return last - 1
-  }
-  static getChains() {
-    if (arguments.length === 1) {
-      const pts = arguments[0]
-      return MonotoneChainBuilder.getChains(pts, null)
-    } else if (arguments.length === 2) {
-      const pts = arguments[0], context = arguments[1]
-      const mcList = new ArrayList()
-      let chainStart = 0
-      do {
-        const chainEnd = MonotoneChainBuilder.findChainEnd(pts, chainStart)
-        const mc = new MonotoneChain(pts, chainStart, chainEnd, context)
-        mcList.add(mc)
-        chainStart = chainEnd
-      } while (chainStart < pts.length - 1)
-      return mcList
-    }
-  }
-}

package/node_modules/jsts/org/locationtech/jts/index/chain/MonotoneChainOverlapAction.js

@@ -1,20 +0,0 @@
-import LineSegment from '../../geom/LineSegment'
-export default class MonotoneChainOverlapAction {
-  constructor() {
-    MonotoneChainOverlapAction.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._overlapSeg1 = new LineSegment()
-    this._overlapSeg2 = new LineSegment()
-  }
-  overlap() {
-    if (arguments.length === 2) {
-      const seg1 = arguments[0], seg2 = arguments[1]
-    } else if (arguments.length === 4) {
-      const mc1 = arguments[0], start1 = arguments[1], mc2 = arguments[2], start2 = arguments[3]
-      mc1.getLineSegment(start1, this._overlapSeg1)
-      mc2.getLineSegment(start2, this._overlapSeg2)
-      this.overlap(this._overlapSeg1, this._overlapSeg2)
-    }
-  }
-}

package/node_modules/jsts/org/locationtech/jts/index/chain/MonotoneChainSelectAction.js

@@ -1,18 +0,0 @@
-import LineSegment from '../../geom/LineSegment'
-export default class MonotoneChainSelectAction {
-  constructor() {
-    MonotoneChainSelectAction.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this.selectedSegment = new LineSegment()
-  }
-  select() {
-    if (arguments.length === 1) {
-      const seg = arguments[0]
-    } else if (arguments.length === 2) {
-      const mc = arguments[0], startIndex = arguments[1]
-      mc.getLineSegment(startIndex, this.selectedSegment)
-      this.select(this.selectedSegment)
-    }
-  }
-}

package/node_modules/jsts/org/locationtech/jts/index/hprtree/HPRtree.js

@@ -1,245 +0,0 @@
-import GeometryFactory from '../../geom/GeometryFactory'
-import SpatialIndex from '../SpatialIndex'
-import Double from '../../../../../java/lang/Double'
-import Integer from '../../../../../java/lang/Integer'
-import HilbertEncoder from './HilbertEncoder'
-import Collections from '../../../../../java/util/Collections'
-import System from '../../../../../java/lang/System'
-import ArrayList from '../../../../../java/util/ArrayList'
-import Comparator from '../../../../../java/util/Comparator'
-import Item from './Item'
-import ArrayListVisitor from '../ArrayListVisitor'
-import Envelope from '../../geom/Envelope'
-export default class HPRtree {
-  constructor() {
-    HPRtree.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._items = new ArrayList()
-    this._nodeCapacity = HPRtree.DEFAULT_NODE_CAPACITY
-    this._totalExtent = new Envelope()
-    this._layerStartIndex = null
-    this._nodeBounds = null
-    this._isBuilt = false
-    if (arguments.length === 0) {
-      HPRtree.constructor_.call(this, HPRtree.DEFAULT_NODE_CAPACITY)
-    } else if (arguments.length === 1) {
-      const nodeCapacity = arguments[0]
-      this._nodeCapacity = nodeCapacity
-    }
-  }
-  static computeLayerIndices(itemSize, nodeCapacity) {
-    const layerIndexList = new ArrayList()
-    let layerSize = itemSize
-    let index = 0
-    do {
-      layerIndexList.add(index)
-      layerSize = HPRtree.numNodesToCover(layerSize, nodeCapacity)
-      index += HPRtree.ENV_SIZE * layerSize
-    } while (layerSize > 1)
-    return HPRtree.toIntArray(layerIndexList)
-  }
-  static createBoundsArray(size) {
-    const a = new Array(4 * size).fill(null)
-    for (let i = 0; i < size; i++) {
-      const index = 4 * i
-      a[index] = Double.MAX_VALUE
-      a[index + 1] = Double.MAX_VALUE
-      a[index + 2] = -Double.MAX_VALUE
-      a[index + 3] = -Double.MAX_VALUE
-    }
-    return a
-  }
-  static intersects(env1, env2) {
-    return !(env2.getMinX() > env1.getMaxX() || env2.getMaxX() < env1.getMinX() || env2.getMinY() > env1.getMaxY() || env2.getMaxY() < env1.getMinY())
-  }
-  static dumpItems(items) {
-    const fact = new GeometryFactory()
-    for (const item of items) {
-      const env = item.getEnvelope()
-      System.out.println(fact.toGeometry(env))
-    }
-  }
-  static numNodesToCover(nChild, nodeCapacity) {
-    const mult = Math.trunc(nChild / nodeCapacity)
-    const total = mult * nodeCapacity
-    if (total === nChild) return mult
-    return mult + 1
-  }
-  static toIntArray(list) {
-    const array = new Array(list.size()).fill(null)
-    for (let i = 0; i < array.length; i++) 
-      array[i] = list.get(i)
-    
-    return array
-  }
-  computeLeafNodes(layerSize) {
-    for (let i = 0; i < layerSize; i += HPRtree.ENV_SIZE) 
-      this.computeLeafNodeBounds(i, Math.trunc(this._nodeCapacity * i / 4))
-    
-  }
-  size() {
-    return this._items.size()
-  }
-  insert(itemEnv, item) {
-    if (this._isBuilt) 
-      throw new IllegalStateException('Cannot insert items after tree is built.')
-    
-    this._items.add(new Item(itemEnv, item))
-    this._totalExtent.expandToInclude(itemEnv)
-  }
-  intersects(nodeIndex, env) {
-    const isBeyond = env.getMaxX() < this._nodeBounds[nodeIndex] || env.getMaxY() < this._nodeBounds[nodeIndex + 1] || env.getMinX() > this._nodeBounds[nodeIndex + 2] || env.getMinY() > this._nodeBounds[nodeIndex + 3]
-    return !isBeyond
-  }
-  query() {
-    if (arguments.length === 1) {
-      const searchEnv = arguments[0]
-      this.build()
-      if (!this._totalExtent.intersects(searchEnv)) return new ArrayList()
-      const visitor = new ArrayListVisitor()
-      this.query(searchEnv, visitor)
-      return visitor.getItems()
-    } else if (arguments.length === 2) {
-      const searchEnv = arguments[0], visitor = arguments[1]
-      this.build()
-      if (!this._totalExtent.intersects(searchEnv)) return null
-      if (this._layerStartIndex === null) 
-        this.queryItems(0, searchEnv, visitor)
-      else 
-        this.queryTopLayer(searchEnv, visitor)
-      
-    }
-  }
-  build() {
-    if (this._isBuilt) return null
-    this._isBuilt = true
-    if (this._items.size() <= this._nodeCapacity) return null
-    this.sortItems()
-    this._layerStartIndex = HPRtree.computeLayerIndices(this._items.size(), this._nodeCapacity)
-    const nodeCount = Math.trunc(this._layerStartIndex[this._layerStartIndex.length - 1] / 4)
-    this._nodeBounds = HPRtree.createBoundsArray(nodeCount)
-    this.computeLeafNodes(this._layerStartIndex[1])
-    for (let i = 1; i < this._layerStartIndex.length - 1; i++) 
-      this.computeLayerNodes(i)
-    
-  }
-  getNodeEnvelope(i) {
-    return new Envelope(this._nodeBounds[i], this._nodeBounds[i + 1], this._nodeBounds[i + 2], this._nodeBounds[i + 3])
-  }
-  sortItems() {
-    const comp = new ItemComparator(new HilbertEncoder(HPRtree.HILBERT_LEVEL, this._totalExtent))
-    Collections.sort(this._items, comp)
-  }
-  queryNode(layerIndex, nodeOffset, searchEnv, visitor) {
-    const layerStart = this._layerStartIndex[layerIndex]
-    const nodeIndex = layerStart + nodeOffset
-    if (!this.intersects(nodeIndex, searchEnv)) return null
-    if (layerIndex === 0) {
-      const childNodesOffset = Math.trunc(nodeOffset / HPRtree.ENV_SIZE) * this._nodeCapacity
-      this.queryItems(childNodesOffset, searchEnv, visitor)
-    } else {
-      const childNodesOffset = nodeOffset * this._nodeCapacity
-      this.queryNodeChildren(layerIndex - 1, childNodesOffset, searchEnv, visitor)
-    }
-  }
-  updateNodeBounds(nodeIndex, minX, minY, maxX, maxY) {
-    if (minX < this._nodeBounds[nodeIndex]) this._nodeBounds[nodeIndex] = minX
-    if (minY < this._nodeBounds[nodeIndex + 1]) this._nodeBounds[nodeIndex + 1] = minY
-    if (maxX > this._nodeBounds[nodeIndex + 2]) this._nodeBounds[nodeIndex + 2] = maxX
-    if (maxY > this._nodeBounds[nodeIndex + 3]) this._nodeBounds[nodeIndex + 3] = maxY
-  }
-  remove(itemEnv, item) {
-    return false
-  }
-  computeNodeBounds(nodeIndex, blockStart, nodeMaxIndex) {
-    for (let i = 0; i <= this._nodeCapacity; i++) {
-      const index = blockStart + 4 * i
-      if (index >= nodeMaxIndex) break
-      this.updateNodeBounds(nodeIndex, this._nodeBounds[index], this._nodeBounds[index + 1], this._nodeBounds[index + 2], this._nodeBounds[index + 3])
-    }
-  }
-  queryTopLayer(searchEnv, visitor) {
-    const layerIndex = this._layerStartIndex.length - 2
-    const layerSize = this.layerSize(layerIndex)
-    for (let i = 0; i < layerSize; i += HPRtree.ENV_SIZE) 
-      this.queryNode(layerIndex, i, searchEnv, visitor)
-    
-  }
-  queryItems(blockStart, searchEnv, visitor) {
-    for (let i = 0; i < this._nodeCapacity; i++) {
-      const itemIndex = blockStart + i
-      if (itemIndex >= this._items.size()) break
-      const item = this._items.get(itemIndex)
-      if (HPRtree.intersects(item.getEnvelope(), searchEnv)) 
-        visitor.visitItem(item.getItem())
-      
-    }
-  }
-  queryNodeChildren(layerIndex, blockOffset, searchEnv, visitor) {
-    const layerStart = this._layerStartIndex[layerIndex]
-    const layerEnd = this._layerStartIndex[layerIndex + 1]
-    for (let i = 0; i < this._nodeCapacity; i++) {
-      const nodeOffset = blockOffset + HPRtree.ENV_SIZE * i
-      if (layerStart + nodeOffset >= layerEnd) break
-      this.queryNode(layerIndex, nodeOffset, searchEnv, visitor)
-    }
-  }
-  computeLayerNodes(layerIndex) {
-    const layerStart = this._layerStartIndex[layerIndex]
-    const childLayerStart = this._layerStartIndex[layerIndex - 1]
-    const layerSize = this.layerSize(layerIndex)
-    const childLayerEnd = layerStart
-    for (let i = 0; i < layerSize; i += HPRtree.ENV_SIZE) {
-      const childStart = childLayerStart + this._nodeCapacity * i
-      this.computeNodeBounds(layerStart + i, childStart, childLayerEnd)
-    }
-  }
-  layerSize(layerIndex) {
-    const layerStart = this._layerStartIndex[layerIndex]
-    const layerEnd = this._layerStartIndex[layerIndex + 1]
-    return layerEnd - layerStart
-  }
-  computeLeafNodeBounds(nodeIndex, blockStart) {
-    for (let i = 0; i <= this._nodeCapacity; i++) {
-      const itemIndex = blockStart + i
-      if (itemIndex >= this._items.size()) break
-      const env = this._items.get(itemIndex).getEnvelope()
-      this.updateNodeBounds(nodeIndex, env.getMinX(), env.getMinY(), env.getMaxX(), env.getMaxY())
-    }
-  }
-  getBounds() {
-    const numNodes = Math.trunc(this._nodeBounds.length / 4)
-    const bounds = new Array(numNodes).fill(null)
-    for (let i = numNodes - 1; i >= 0; i--) {
-      const boundIndex = 4 * i
-      bounds[i] = new Envelope(this._nodeBounds[boundIndex], this._nodeBounds[boundIndex + 2], this._nodeBounds[boundIndex + 1], this._nodeBounds[boundIndex + 3])
-    }
-    return bounds
-  }
-  get interfaces_() {
-    return [SpatialIndex]
-  }
-}
-class ItemComparator {
-  constructor() {
-    ItemComparator.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._encoder = null
-    const encoder = arguments[0]
-    this._encoder = encoder
-  }
-  compare(item1, item2) {
-    const hcode1 = this._encoder.encode(item1.getEnvelope())
-    const hcode2 = this._encoder.encode(item2.getEnvelope())
-    return Integer.compare(hcode1, hcode2)
-  }
-  get interfaces_() {
-    return [Comparator]
-  }
-}
-HPRtree.ItemComparator = ItemComparator
-HPRtree.ENV_SIZE = 4
-HPRtree.HILBERT_LEVEL = 12
-HPRtree.DEFAULT_NODE_CAPACITY = 16

package/node_modules/jsts/org/locationtech/jts/index/hprtree/HilbertEncoder.js

@@ -1,29 +0,0 @@
-import HilbertCode from '../../shape/fractal/HilbertCode'
-export default class HilbertEncoder {
-  constructor() {
-    HilbertEncoder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._level = null
-    this._minx = null
-    this._miny = null
-    this._strideX = null
-    this._strideY = null
-    const level = arguments[0], extent = arguments[1]
-    this._level = level
-    const hside = Math.trunc(Math.pow(2, level)) - 1
-    this._minx = extent.getMinX()
-    const extentX = extent.getWidth()
-    this._strideX = extentX / hside
-    this._miny = extent.getMinX()
-    const extentY = extent.getHeight()
-    this._strideY = extentY / hside
-  }
-  encode(env) {
-    const midx = env.getWidth() / 2 + env.getMinX()
-    const x = Math.trunc((midx - this._minx) / this._strideX)
-    const midy = env.getHeight() / 2 + env.getMinY()
-    const y = Math.trunc((midy - this._miny) / this._strideY)
-    return HilbertCode.encode(this._level, x, y)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/index/hprtree/Item.js

@@ -1,21 +0,0 @@
-export default class Item {
-  constructor() {
-    Item.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._env = null
-    this._item = null
-    const env = arguments[0], item = arguments[1]
-    this._env = env
-    this._item = item
-  }
-  getEnvelope() {
-    return this._env
-  }
-  getItem() {
-    return this._item
-  }
-  toString() {
-    return 'Item: ' + this._env.toString()
-  }
-}

package/node_modules/jsts/org/locationtech/jts/index/intervalrtree/IntervalRTreeBranchNode.js

@@ -1,26 +0,0 @@
-import IntervalRTreeNode from './IntervalRTreeNode'
-export default class IntervalRTreeBranchNode extends IntervalRTreeNode {
-  constructor() {
-    super()
-    IntervalRTreeBranchNode.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._node1 = null
-    this._node2 = null
-    const n1 = arguments[0], n2 = arguments[1]
-    this._node1 = n1
-    this._node2 = n2
-    this.buildExtent(this._node1, this._node2)
-  }
-  buildExtent(n1, n2) {
-    this._min = Math.min(n1._min, n2._min)
-    this._max = Math.max(n1._max, n2._max)
-  }
-  query(queryMin, queryMax, visitor) {
-    if (!this.intersects(queryMin, queryMax)) 
-      return null
-    
-    if (this._node1 !== null) this._node1.query(queryMin, queryMax, visitor)
-    if (this._node2 !== null) this._node2.query(queryMin, queryMax, visitor)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/index/intervalrtree/IntervalRTreeLeafNode.js

@@ -1,18 +0,0 @@
-import IntervalRTreeNode from './IntervalRTreeNode'
-export default class IntervalRTreeLeafNode extends IntervalRTreeNode {
-  constructor() {
-    super()
-    IntervalRTreeLeafNode.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._item = null
-    const min = arguments[0], max = arguments[1], item = arguments[2]
-    this._min = min
-    this._max = max
-    this._item = item
-  }
-  query(queryMin, queryMax, visitor) {
-    if (!this.intersects(queryMin, queryMax)) return null
-    visitor.visitItem(this._item)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/index/intervalrtree/IntervalRTreeNode.js

@@ -1,41 +0,0 @@
-import WKTWriter from '../../io/WKTWriter'
-import Coordinate from '../../geom/Coordinate'
-import Double from '../../../../../java/lang/Double'
-import Comparator from '../../../../../java/util/Comparator'
-export default class IntervalRTreeNode {
-  constructor() {
-    IntervalRTreeNode.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._min = Double.POSITIVE_INFINITY
-    this._max = Double.NEGATIVE_INFINITY
-  }
-  getMin() {
-    return this._min
-  }
-  intersects(queryMin, queryMax) {
-    if (this._min > queryMax || this._max < queryMin) return false
-    return true
-  }
-  getMax() {
-    return this._max
-  }
-  toString() {
-    return WKTWriter.toLineString(new Coordinate(this._min, 0), new Coordinate(this._max, 0))
-  }
-}
-class NodeComparator {
-  compare(o1, o2) {
-    const n1 = o1
-    const n2 = o2
-    const mid1 = (n1._min + n1._max) / 2
-    const mid2 = (n2._min + n2._max) / 2
-    if (mid1 < mid2) return -1
-    if (mid1 > mid2) return 1
-    return 0
-  }
-  get interfaces_() {
-    return [Comparator]
-  }
-}
-IntervalRTreeNode.NodeComparator = NodeComparator

package/node_modules/jsts/org/locationtech/jts/index/intervalrtree/SortedPackedIntervalRTree.js

@@ -1,66 +0,0 @@
-import WKTWriter from '../../io/WKTWriter'
-import Coordinate from '../../geom/Coordinate'
-import IntervalRTreeLeafNode from './IntervalRTreeLeafNode'
-import IntervalRTreeNode from './IntervalRTreeNode'
-import Collections from '../../../../../java/util/Collections'
-import System from '../../../../../java/lang/System'
-import ArrayList from '../../../../../java/util/ArrayList'
-import IntervalRTreeBranchNode from './IntervalRTreeBranchNode'
-export default class SortedPackedIntervalRTree {
-  constructor() {
-    SortedPackedIntervalRTree.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._leaves = new ArrayList()
-    this._root = null
-    this._level = 0
-  }
-  buildTree() {
-    Collections.sort(this._leaves, new IntervalRTreeNode.NodeComparator())
-    let src = this._leaves
-    let temp = null
-    let dest = new ArrayList()
-    while (true) {
-      this.buildLevel(src, dest)
-      if (dest.size() === 1) return dest.get(0)
-      temp = src
-      src = dest
-      dest = temp
-    }
-  }
-  insert(min, max, item) {
-    if (this._root !== null) throw new IllegalStateException('Index cannot be added to once it has been queried')
-    this._leaves.add(new IntervalRTreeLeafNode(min, max, item))
-  }
-  query(min, max, visitor) {
-    this.init()
-    if (this._root === null) return null
-    this._root.query(min, max, visitor)
-  }
-  buildRoot() {
-    if (this._root !== null) return null
-    this._root = this.buildTree()
-  }
-  printNode(node) {
-    System.out.println(WKTWriter.toLineString(new Coordinate(node._min, this._level), new Coordinate(node._max, this._level)))
-  }
-  init() {
-    if (this._root !== null) return null
-    if (this._leaves.size() === 0) return null
-    this.buildRoot()
-  }
-  buildLevel(src, dest) {
-    this._level++
-    dest.clear()
-    for (let i = 0; i < src.size(); i += 2) {
-      const n1 = src.get(i)
-      const n2 = i + 1 < src.size() ? src.get(i) : null
-      if (n2 === null) {
-        dest.add(n1)
-      } else {
-        const node = new IntervalRTreeBranchNode(src.get(i), src.get(i + 1))
-        dest.add(node)
-      }
-    }
-  }
-}