nodes2ts 2.0.0 → 3.0.0

package/dist/S2LatLngRect.js

@@ -1,46 +1,49 @@
 "use strict";
-var S1Interval_1 = require("./S1Interval");
-var R1Interval_1 = require("./R1Interval");
-var S2LatLng_1 = require("./S2LatLng");
-var S2_1 = require("./S2");
-var S2Point_1 = require("./S2Point");
-var S1Angle_1 = require("./S1Angle");
-var S2EdgeUtil_1 = require("./S2EdgeUtil");
-var S2Cap_1 = require("./S2Cap");
-var S2LatLngRect = (function () {
-    function S2LatLngRect(lat, lng) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S2LatLngRect = void 0;
+const S1Interval_1 = require("./S1Interval");
+const R1Interval_1 = require("./R1Interval");
+const S2LatLng_1 = require("./S2LatLng");
+const S2_1 = require("./S2");
+const S2Point_1 = require("./S2Point");
+const S1Angle_1 = require("./S1Angle");
+const S2EdgeUtil_1 = require("./S2EdgeUtil");
+const S2Cap_1 = require("./S2Cap");
+const Platform_1 = require("./Platform");
+class S2LatLngRect {
+    constructor(lat, lng) {
         this.lat = lat;
         this.lng = lng;
     }
-    S2LatLngRect.fromLatLng = function (lo, hi) {
+    static fromLatLng(lo, hi) {
         return new S2LatLngRect(new R1Interval_1.R1Interval(lo.latRadians, hi.latRadians), new S1Interval_1.S1Interval(lo.lngRadians, hi.lngRadians));
-    };
+    }
     /** The canonical empty rectangle */
-    S2LatLngRect.empty = function () {
+    static empty() {
         return new S2LatLngRect(R1Interval_1.R1Interval.empty(), S1Interval_1.S1Interval.empty());
-    };
+    }
     /** The canonical full rectangle. */
-    S2LatLngRect.full = function () {
+    static full() {
         return new S2LatLngRect(S2LatLngRect.fullLat(), S1Interval_1.S1Interval.full());
-    };
+    }
     /** The full allowable range of latitudes. */
-    S2LatLngRect.fullLat = function () {
+    static fullLat() {
         return new R1Interval_1.R1Interval(-S2_1.S2.M_PI_2, S2_1.S2.M_PI_2);
-    };
+    }
     /**
      * Construct a rectangle from a center point (in lat-lng space) and size in
      * each dimension. If size.lng is greater than 360 degrees it is clamped,
      * and latitudes greater than +/- 90 degrees are also clamped. So for example,
      * FromCenterSize((80,170),(20,20)) -> (lo=(60,150),hi=(90,-170)).
      */
-    S2LatLngRect.fromCenterSize = function (center, size) {
+    static fromCenterSize(center, size) {
         return S2LatLngRect.fromPoint(center).expanded(size.mul(0.5));
-    };
+    }
     /** Convenience method to construct a rectangle containing a single point. */
-    S2LatLngRect.fromPoint = function (p) {
+    static fromPoint(p) {
         // assert (p.isValid());
         return S2LatLngRect.fromLatLng(p, p);
-    };
+    }
     /**
      * Convenience method to construct the minimal bounding rectangle containing
      * the two given points. This is equivalent to starting with an empty
@@ -48,80 +51,92 @@ var S2LatLngRect = (function () {
      * S2LatLngRect(lo, hi) constructor, where the first point is always used as
      * the lower-left corner of the resulting rectangle.
      */
-    S2LatLngRect.fromPointPair = function (p1, p2) {
+    static fromPointPair(p1, p2) {
         // assert (p1.isValid() && p2.isValid());
         return new S2LatLngRect(R1Interval_1.R1Interval.fromPointPair(p1.latRadians, p2
             .latRadians), S1Interval_1.S1Interval.fromPointPair(p1.lngRadians, p2.lngRadians));
-    };
+    }
     /**
      * Return a latitude-longitude rectangle that contains the edge from "a" to
      * "b". Both points must be unit-length. Note that the bounding rectangle of
      * an edge can be larger than the bounding rectangle of its endpoints.
      */
-    S2LatLngRect.fromEdge = function (a, b) {
+    static fromEdge(a, b) {
         // assert (S2.isUnitLength(a) && S2.isUnitLength(b));
-        var r = S2LatLngRect.fromPointPair(S2LatLng_1.S2LatLng.fromPoint(a), S2LatLng_1.S2LatLng.fromPoint(b));
+        const r = S2LatLngRect.fromPointPair(S2LatLng_1.S2LatLng.fromPoint(a), S2LatLng_1.S2LatLng.fromPoint(b));
         // Check whether the min/max latitude occurs in the edge interior.
         // We find the normal to the plane containing AB, and then a vector "dir" in
         // this plane that also passes through the equator. We use RobustCrossProd
         // to ensure that the edge normal is accurate even when the two points are
         // very close together.
-        var ab = S2_1.S2.robustCrossProd(a, b);
-        var dir = S2Point_1.S2Point.crossProd(ab, new S2Point_1.S2Point(0, 0, 1));
-        var da = dir.dotProd(a);
-        var db = dir.dotProd(b);
+        const ab = S2_1.S2.robustCrossProd(a, b);
+        const dir = S2Point_1.S2Point.crossProd(ab, new S2Point_1.S2Point(0, 0, 1));
+        const da = dir.dotProd(a);
+        const db = dir.dotProd(b);
         if (da * db >= 0) {
             // Minimum and maximum latitude are attained at the vertices.
             return r;
         }
         // Minimum/maximum latitude occurs in the edge interior. This affects the
         // latitude bounds but not the longitude bounds.
-        var absLat = Math.acos(ab.z / Math.abs(ab.norm()));
+        const absLat = Math.acos(ab.z / Math.abs(ab.norm()));
         if (da < 0) {
             return new S2LatLngRect(new R1Interval_1.R1Interval(r.lat.lo, absLat), r.lng);
         }
         else {
             return new S2LatLngRect(new R1Interval_1.R1Interval(-absLat, r.lat.hi), r.lng);
         }
-    };
+    }
     /**
      * Return true if the rectangle is valid, which essentially just means that
      * the latitude bounds do not exceed Pi/2 in absolute value and the longitude
      * bounds do not exceed Pi in absolute value.
      *
      */
-    S2LatLngRect.prototype.isValid = function () {
+    isValid() {
         // The lat/lng ranges must either be both empty or both non-empty.
         return (Math.abs(this.lat.lo) <= S2_1.S2.M_PI_2 && Math.abs(this.lat.hi) <= (S2_1.S2.M_PI_2)
             && this.lng.isValid() && this.lat.isEmpty() == this.lng.isEmpty());
-    };
-    S2LatLngRect.prototype.lo = function () {
+    }
+    lo() {
         return new S2LatLng_1.S2LatLng(this.lat.lo, this.lng.lo);
-    };
-    S2LatLngRect.prototype.hi = function () {
+    }
+    hi() {
         return new S2LatLng_1.S2LatLng(this.lat.hi, this.lng.hi);
-    };
+    }
+    latLo() {
+        return S1Angle_1.S1Angle.radians(this.lat.lo);
+    }
+    latHi() {
+        return S1Angle_1.S1Angle.radians(this.lat.hi);
+    }
+    lngLo() {
+        return S1Angle_1.S1Angle.radians(this.lng.lo);
+    }
+    lngHi() {
+        return S1Angle_1.S1Angle.radians(this.lng.hi);
+    }
     /**
      * Return true if the rectangle is empty, i.e. it contains no points at all.
      */
-    S2LatLngRect.prototype.isEmpty = function () {
+    isEmpty() {
         return this.lat.isEmpty();
-    };
+    }
     // Return true if the rectangle is full, i.e. it contains all points.
-    S2LatLngRect.prototype.isFull = function () {
+    isFull() {
         // console.log(this.lat.toString());
         // console.log(S2LatLngRect.fullLat().toString());
         return this.lat.equals(S2LatLngRect.fullLat()) && this.lng.isFull();
-    };
+    }
     /**
      * Return true if lng_.lo() > lng_.hi(), i.e. the rectangle crosses the 180
      * degree latitude line.
      */
-    S2LatLngRect.prototype.isInverted = function () {
+    isInverted() {
         return this.lng.isInverted();
-    };
+    }
     /** Return the k-th vertex of the rectangle (k = 0,1,2,3) in CCW order. */
-    S2LatLngRect.prototype.getVertex = function (k) {
+    getVertex(k) {
         // Return the points in CCW order (SW, SE, NE, NW).
         switch (k) {
             case 0:
@@ -135,87 +150,85 @@ var S2LatLngRect = (function () {
             default:
                 throw new Error("Invalid vertex index.");
         }
-    };
+    }
     /**
      * Return the center of the rectangle in latitude-longitude space (in general
      * this is not the center of the region on the sphere).
      */
-    S2LatLngRect.prototype.getCenter = function () {
+    getCenter() {
         return new S2LatLng_1.S2LatLng(this.lat.getCenter(), this.lng.getCenter());
-    };
+    }
     /**
      * Return the minimum distance (measured along the surface of the sphere)
      * from a given point to the rectangle (both its boundary and its interior).
      * The latLng must be valid.
      */
-    S2LatLngRect.prototype.getDistanceLL = function (p) {
+    getDistanceLL(p) {
         // The algorithm here is the same as in getDistance(S2LagLngRect), only
         // with simplified calculations.
-        var a = this;
-        if (a.isEmpty()) {
+        if (this.isEmpty()) {
             throw new Error();
         }
         if (!p.isValid()) {
             throw new Error('point is not valid');
         }
-        if (a.lng.contains(p.lngRadians)) {
-            return new S1Angle_1.S1Angle(Math.max(0.0, Math.max(p.latRadians - a.lat.hi, a.lat.lo - p.latRadians)));
+        if (this.lng.contains(p.lngRadians)) {
+            return new S1Angle_1.S1Angle(Math.max(0.0, Math.max(p.latRadians - this.lat.hi, this.lat.lo - p.latRadians)));
         }
-        var interval = new S1Interval_1.S1Interval(a.lng.hi, a.lng.complement().getCenter());
-        var aLng = a.lng.lo;
+        const interval = new S1Interval_1.S1Interval(this.lng.hi, this.lng.complement().getCenter());
+        let aLng = this.lng.lo;
         if (interval.contains(p.lngRadians)) {
-            aLng = a.lng.hi;
+            aLng = this.lng.hi;
         }
-        var lo = new S2LatLng_1.S2LatLng(a.lat.lo, aLng).toPoint();
-        var hi = new S2LatLng_1.S2LatLng(a.lat.hi, aLng).toPoint();
-        var loCrossHi = new S2LatLng_1.S2LatLng(0, aLng - S2_1.S2.M_PI_2).normalized().toPoint();
+        const lo = new S2LatLng_1.S2LatLng(this.lat.lo, aLng).toPoint();
+        const hi = new S2LatLng_1.S2LatLng(this.lat.hi, aLng).toPoint();
+        const loCrossHi = new S2LatLng_1.S2LatLng(0, aLng - S2_1.S2.M_PI_2).normalized().toPoint();
         return S2EdgeUtil_1.S2EdgeUtil.getDistance(p.toPoint(), lo, hi, loCrossHi);
-    };
+    }
     /**
      * Return the minimum distance (measured along the surface of the sphere) to
      * the given S2LatLngRect. Both S2LatLngRects must be non-empty.
      */
-    S2LatLngRect.prototype.getDistanceLLR = function (other) {
-        var a = this;
-        var b = other;
-        if (a.isEmpty()) {
+    getDistanceLLR(other) {
+        const b = other;
+        if (this.isEmpty()) {
             throw new Error();
         }
         if (b.isEmpty()) {
             throw new Error();
         }
         // First, handle the trivial cases where the longitude intervals overlap.
-        if (a.lng.intersects(b.lng)) {
-            if (a.lat.intersects(b.lat)) {
+        if (this.lng.intersects(b.lng)) {
+            if (this.lat.intersects(b.lat)) {
                 return new S1Angle_1.S1Angle(0); // Intersection between a and b.
             }
             // We found an overlap in the longitude interval, but not in the latitude
             // interval. This means the shortest path travels along some line of
             // longitude connecting the high-latitude of the lower rect with the
             // low-latitude of the higher rect.
-            var lo = void 0, hi = void 0;
-            if (a.lat.lo > b.lat.hi) {
+            let lo, hi;
+            if (this.lat.lo > b.lat.hi) {
                 lo = b.lat.hi;
-                hi = a.lat.lo;
+                hi = this.lat.lo;
             }
             else {
-                lo = a.lat.hi;
+                lo = this.lat.hi;
                 hi = b.lat.lo;
             }
-            return new S1Angle_1.S1Angle(hi.radians().minus(lo.radians()));
+            return S1Angle_1.S1Angle.radians(hi.radians() - lo.radians());
         }
         // The longitude intervals don't overlap. In this case, the closest points
         // occur somewhere on the pair of longitudinal edges which are nearest in
         // longitude-space.
-        var aLng, bLng;
-        var loHi = S1Interval_1.S1Interval.fromPointPair(a.lng.lo, b.lng.hi);
-        var hiLo = S1Interval_1.S1Interval.fromPointPair(a.lng.hi, b.lng.lo);
+        let aLng, bLng;
+        const loHi = S1Interval_1.S1Interval.fromPointPair(this.lng.lo, b.lng.hi);
+        const hiLo = S1Interval_1.S1Interval.fromPointPair(this.lng.hi, b.lng.lo);
         if (loHi.getLength() < (hiLo.getLength())) {
-            aLng = a.lng.lo;
+            aLng = this.lng.lo;
             bLng = b.lng.hi;
         }
         else {
-            aLng = a.lng.hi;
+            aLng = this.lng.hi;
             bLng = b.lng.lo;
         }
         // The shortest distance between the two longitudinal segments will include
@@ -223,78 +236,78 @@ var S2LatLngRect = (function () {
         // to a single point-edge distance by comparing the relative latitudes of the
         // endpoints, but for the sake of clarity, we'll do all four point-edge
         // distance tests.
-        var aLo = new S2LatLng_1.S2LatLng(a.lat.lo, aLng).toPoint();
-        var aHi = new S2LatLng_1.S2LatLng(a.lat.hi, aLng).toPoint();
-        var aLoCrossHi = new S2LatLng_1.S2LatLng(0, aLng.radians().minus(S2_1.S2.M_PI_2)).normalized().toPoint();
-        var bLo = new S2LatLng_1.S2LatLng(b.lat.lo, bLng).toPoint();
-        var bHi = new S2LatLng_1.S2LatLng(b.lat.hi, bLng).toPoint();
-        var bLoCrossHi = new S2LatLng_1.S2LatLng(0, bLng.radians().minus(S2_1.S2.M_PI_2)).normalized().toPoint();
+        const aLo = new S2LatLng_1.S2LatLng(this.lat.lo, aLng).toPoint();
+        const aHi = new S2LatLng_1.S2LatLng(this.lat.hi, aLng).toPoint();
+        const aLoCrossHi = new S2LatLng_1.S2LatLng(0, aLng.radians().minus(S2_1.S2.M_PI_2)).normalized().toPoint();
+        const bLo = new S2LatLng_1.S2LatLng(b.lat.lo, bLng).toPoint();
+        const bHi = new S2LatLng_1.S2LatLng(b.lat.hi, bLng).toPoint();
+        const bLoCrossHi = new S2LatLng_1.S2LatLng(0, bLng.radians().minus(S2_1.S2.M_PI_2)).normalized().toPoint();
         return S1Angle_1.S1Angle.min(S2EdgeUtil_1.S2EdgeUtil.getDistance(aLo, bLo, bHi, bLoCrossHi), S1Angle_1.S1Angle.min(S2EdgeUtil_1.S2EdgeUtil.getDistance(aHi, bLo, bHi, bLoCrossHi), S1Angle_1.S1Angle.min(S2EdgeUtil_1.S2EdgeUtil.getDistance(bLo, aLo, aHi, aLoCrossHi), S2EdgeUtil_1.S2EdgeUtil.getDistance(bHi, aLo, aHi, aLoCrossHi))));
-    };
+    }
     /**
      * Return the width and height of this rectangle in latitude-longitude space.
      * Empty rectangles have a negative width and height.
      */
-    S2LatLngRect.prototype.getSize = function () {
+    getSize() {
         return new S2LatLng_1.S2LatLng(this.lat.getLength(), this.lng.getLength());
-    };
+    }
     /**
      * More efficient version of Contains() that accepts a S2LatLng rather than an
      * S2Point.
      */
-    S2LatLngRect.prototype.containsLL = function (ll) {
+    containsLL(ll) {
         // assert (ll.isValid());
         return (this.lat.contains(ll.latRadians) && this.lng.contains(ll.lngRadians));
-    };
+    }
     /**
      * Return true if and only if the given point is contained in the interior of
      * the region (i.e. the region excluding its boundary). The point 'p' does not
      * need to be normalized.
      */
-    S2LatLngRect.prototype.interiorContainsP = function (p) {
+    interiorContainsP(p) {
         return this.interiorContainsLL(S2LatLng_1.S2LatLng.fromPoint(p));
-    };
+    }
     /**
      * More efficient version of InteriorContains() that accepts a S2LatLng rather
      * than an S2Point.
      */
-    S2LatLngRect.prototype.interiorContainsLL = function (ll) {
+    interiorContainsLL(ll) {
         // assert (ll.isValid());
         return (this.lat.interiorContains(ll.latRadians) && this.lng
             .interiorContains(ll.lngRadians));
-    };
+    }
     /**
      * Return true if and only if the rectangle contains the given other
      * rectangle.
      */
-    S2LatLngRect.prototype.containsLLR = function (other) {
+    containsLLR(other) {
         return this.lat.containsI(other.lat) && this.lng.containsI(other.lng);
-    };
+    }
     /**
      * Return true if and only if the interior of this rectangle contains all
      * points of the given other rectangle (including its boundary).
      */
-    S2LatLngRect.prototype.interiorContainsLLR = function (other) {
+    interiorContainsLLR(other) {
         return (this.lat.interiorContainsI(other.lat) && this.lng
             .interiorContainsI(other.lng));
-    };
+    }
     /** Return true if this rectangle and the given other rectangle have any
      points in common. */
-    S2LatLngRect.prototype.intersectsLLR = function (other) {
+    intersectsLLR(other) {
         return this.lat.intersects(other.lat) && this.lng.intersects(other.lng);
-    };
+    }
     /**
      * Returns true if this rectangle intersects the given cell. (This is an exact
      * test and may be fairly expensive, see also MayIntersect below.)
      */
-    S2LatLngRect.prototype.intersects = function (cell) {
+    intersects(cell) {
         // First we eliminate the cases where one region completely contains the
         // other. Once these are disposed of, then the regions will intersect
         // if and only if their boundaries intersect.
         if (this.isEmpty()) {
             return false;
         }
-        if (this.containsP(cell.getCenter())) {
+        if (this.containsP(cell.getCenterRaw())) {
             return true;
         }
         if (cell.contains(this.getCenter().toPoint())) {
@@ -308,22 +321,22 @@ var S2LatLngRect = (function () {
         // latitude-longitude rectangle does not have straight edges -- two edges
         // are curved, and at least one of them is concave.
         // Precompute the cell vertices as points and latitude-longitudes.
-        var cellV = new Array(4);
-        var cellLl = new Array(4);
-        for (var i = 0; i < 4; ++i) {
+        const cellV = new Array(4);
+        const cellLl = new Array(4);
+        for (let i = 0; i < 4; ++i) {
             cellV[i] = cell.getVertex(i); // Must be normalized.
             cellLl[i] = S2LatLng_1.S2LatLng.fromPoint(cellV[i]);
             if (this.containsLL(cellLl[i])) {
                 return true; // Quick acceptance test.
             }
         }
-        for (var i = 0; i < 4; ++i) {
-            var edgeLng = S1Interval_1.S1Interval.fromPointPair(cellLl[i].lngRadians, cellLl[(i + 1) & 3].lngRadians);
+        for (let i = 0; i < 4; ++i) {
+            const edgeLng = S1Interval_1.S1Interval.fromPointPair(cellLl[i].lngRadians, cellLl[(i + 1) & 3].lngRadians);
             if (!this.lng.intersects(edgeLng)) {
                 continue;
             }
-            var a = cellV[i];
-            var b = cellV[(i + 1) & 3];
+            const a = cellV[i];
+            const b = cellV[(i + 1) & 3];
             if (edgeLng.contains(this.lng.lo)) {
                 if (S2LatLngRect.intersectsLngEdge(a, b, this.lat, this.lng.lo)) {
                     return true;
@@ -342,25 +355,25 @@ var S2LatLngRect = (function () {
             }
         }
         return false;
-    };
+    }
     /**
      * Return true if and only if the interior of this rectangle intersects any
      * point (including the boundary) of the given other rectangle.
      */
-    S2LatLngRect.prototype.interiorIntersects = function (other) {
+    interiorIntersects(other) {
         return (this.lat.interiorIntersects(other.lat) && this.lng
             .interiorIntersects(other.lng));
-    };
-    S2LatLngRect.prototype.addPoint = function (p) {
+    }
+    addPoint(p) {
         return this.addPointLL(S2LatLng_1.S2LatLng.fromPoint(p));
-    };
+    }
     // Increase the size of the bounding rectangle to include the given point.
     // The rectangle is expanded by the minimum amount possible.
-    S2LatLngRect.prototype.addPointLL = function (ll) {
-        var newLat = this.lat.addPoint(ll.latRadians);
-        var newLng = this.lng.addPoint(ll.lngRadians);
+    addPointLL(ll) {
+        const newLat = this.lat.addPoint(ll.latRadians);
+        const newLng = this.lng.addPoint(ll.lngRadians);
         return new S2LatLngRect(newLat, newLng);
-    };
+    }
     /**
      * Return a rectangle that contains all points whose latitude distance from
      * this rectangle is at most margin.lat, and whose longitude distance from
@@ -372,7 +385,7 @@ var S2LatLngRect = (function () {
      * NOTE: If you are trying to grow a rectangle by a certain *distance* on the
      * sphere (e.g. 5km), use the ConvolveWithCap() method instead.
      */
-    S2LatLngRect.prototype.expanded = function (margin) {
+    expanded(margin) {
         // assert (margin.latRadians >= 0 && margin.lngRadians >= 0);
         if (this.isEmpty()) {
             return this;
@@ -380,29 +393,37 @@ var S2LatLngRect = (function () {
         return new S2LatLngRect(this.lat
             .expanded(margin.latRadians)
             .intersection(S2LatLngRect.fullLat()), this.lng.expanded(margin.lngRadians));
-    };
+    }
+    polarClosure() {
+        if (this.lat.lo == -S2_1.S2.M_PI_2 || this.lat.hi == S2_1.S2.M_PI_2) {
+            return new S2LatLngRect(this.lat, S1Interval_1.S1Interval.full());
+        }
+        else {
+            return this;
+        }
+    }
     /**
      * Return the smallest rectangle containing the union of this rectangle and
      * the given rectangle.
      */
-    S2LatLngRect.prototype.union = function (other) {
+    union(other) {
         return new S2LatLngRect(this.lat.union(other.lat), this.lng.union(other.lng));
-    };
+    }
     /**
      * Return the smallest rectangle containing the intersection of this rectangle
      * and the given rectangle. Note that the region of intersection may consist
      * of two disjoint rectangles, in which case a single rectangle spanning both
      * of them is returned.
      */
-    S2LatLngRect.prototype.intersection = function (other) {
-        var intersectLat = this.lat.intersection(other.lat);
-        var intersectLng = this.lng.intersection(other.lng);
+    intersection(other) {
+        const intersectLat = this.lat.intersection(other.lat);
+        const intersectLng = this.lng.intersection(other.lng);
         if (intersectLat.isEmpty() || intersectLng.isEmpty()) {
             // The lat/lng ranges must either be both empty or both non-empty.
             return S2LatLngRect.empty();
         }
         return new S2LatLngRect(intersectLat, intersectLng);
-    };
+    }
     //
     // /**
     //  * Return a rectangle that contains the convolution of this rectangle with a
@@ -428,7 +449,7 @@ var S2LatLngRect = (function () {
     //   return r;
     // }
     /** Return the surface area of this rectangle on the unit sphere. */
-    S2LatLngRect.prototype.area = function () {
+    area() {
         if (this.isEmpty()) {
             return 0;
         }
@@ -436,72 +457,71 @@ var S2LatLngRect = (function () {
         // the longitude ratio.
         //TODO: check if this.lat.hi & this.lat.lo is radians.
         return this.lng.getLength() * (Math.sin(this.lat.hi) - Math.abs(Math.sin(this.lat.lo)));
-    };
+    }
     /** Return true if two rectangles contains the same set of points. */
-    S2LatLngRect.prototype.equals = function (that) {
+    equals(that) {
         if (!(that instanceof S2LatLngRect)) {
             return false;
         }
         return this.lat.equals(that.lat) && this.lng.equals(that.lng);
-    };
+    }
     /**
      * Return true if the latitude and longitude intervals of the two rectangles
      * are the same up to the given tolerance (see r1interval.h and s1interval.h
      * for details).
      */
-    S2LatLngRect.prototype.approxEquals = function (other, maxError) {
-        if (maxError === void 0) { maxError = 1e-15; }
+    approxEquals(other, maxError = 1e-15) {
         return (this.lat.approxEquals(other.lat, maxError) && this.lng.approxEquals(other.lng, maxError));
-    };
+    }
     // //////////////////////////////////////////////////////////////////////
     // S2Region interface (see {@code S2Region} for details):
-    S2LatLngRect.prototype.clone = function () {
+    clone() {
         return new S2LatLngRect(this.lat, this.lng);
-    };
-    S2LatLngRect.prototype.getCapBound = function () {
-        // We consider two possible bounding caps, one whose axis passes
-        // through the center of the lat-long rectangle and one whose axis
-        // is the north or south pole. We return the smaller of the two caps.
+    }
+    getCapBound() {
+        // We consider two possible bounding caps, one whose axis passes through the center of the
+        // lat-lng rectangle and one whose axis is the north or south pole. We return the smaller of the
+        // two caps.
         if (this.isEmpty()) {
             return S2Cap_1.S2Cap.empty();
         }
-        var poleZ, poleAngle;
-        if (this.lat.lo + (this.lat.hi) < (0)) {
+        let poleZ = 0;
+        let poleAngle = 0;
+        if (this.lat.lo + this.lat.hi < 0) {
             // South pole axis yields smaller cap.
             poleZ = -1;
-            poleAngle = this.lat.hi + (S2_1.S2.M_PI_2);
+            poleAngle = S2_1.S2.M_PI_2 + this.lat.hi;
         }
         else {
             poleZ = 1;
-            poleAngle = this.lat.lo * -1 + (S2_1.S2.M_PI_2);
-        }
-        var poleCap = S2Cap_1.S2Cap.fromAxisAngle(new S2Point_1.S2Point(0, 0, poleZ), new S1Angle_1.S1Angle(poleAngle));
-        // For bounding rectangles that span 180 degrees or less in longitude, the
-        // maximum cap size is achieved at one of the rectangle vertices. For
-        // rectangles that are larger than 180 degrees, we punt and always return a
-        // bounding cap centered at one of the two poles.
-        var lngSpan = this.lng.hi - (this.lng.lo);
-        if (S2_1.S2.IEEEremainder(lngSpan, 2 * S2_1.S2.M_PI) >= (0)) {
-            if (lngSpan < (2 * S2_1.S2.M_PI)) {
-                var midCap = S2Cap_1.S2Cap.fromAxisAngle(this.getCenter().toPoint(), new S1Angle_1.S1Angle(0));
-                for (var k = 0; k < 4; ++k) {
+            poleAngle = S2_1.S2.M_PI_2 - this.lat.lo;
+        }
+        const poleCap = S2Cap_1.S2Cap.fromAxisAngle(new S2Point_1.S2Point(0, 0, poleZ), S1Angle_1.S1Angle.radians(poleAngle));
+        // For bounding rectangles that span 180 degrees or less in longitude, the maximum cap size is
+        // achieved at one of the rectangle vertices. For rectangles that are larger than 180 degrees,
+        // we punt and always return a bounding cap centered at one of the two poles.
+        const lngSpan = this.lng.hi - this.lng.lo;
+        if (Platform_1.Platform.IEEEremainder(lngSpan, 2 * S2_1.S2.M_PI) >= 0) {
+            if (lngSpan < 2 * S2_1.S2.M_PI) {
+                let midCap = S2Cap_1.S2Cap.fromAxisAngle(this.getCenter().toPoint(), S1Angle_1.S1Angle.radians(0));
+                for (let k = 0; k < 4; ++k) {
                     midCap = midCap.addPoint(this.getVertex(k).toPoint());
                 }
-                if (midCap.height < (poleCap.height)) {
+                if (midCap.height() < poleCap.height()) {
                     return midCap;
                 }
             }
         }
         return poleCap;
-    };
-    S2LatLngRect.prototype.getRectBound = function () {
+    }
+    getRectBound() {
         return this;
-    };
-    S2LatLngRect.prototype.containsC = function (cell) {
+    }
+    containsC(cell) {
         // A latitude-longitude rectangle contains a cell if and only if it contains
         // the cell's bounding rectangle. (This is an exact test.)
         return this.containsLLR(cell.getRectBound());
-    };
+    }
     /**
      * This test is cheap but is NOT exact. Use Intersects() if you want a more
      * accurate and more expensive test. Note that when this method is used by an
@@ -509,97 +529,96 @@ var S2LatLngRect = (function () {
      * intersect the region then it is subdivided, and the accuracy of this method
      * goes up as the cells get smaller.
      */
-    S2LatLngRect.prototype.mayIntersectC = function (cell) {
+    mayIntersectC(cell) {
         // This test is cheap but is NOT exact (see s2latlngrect.h).
         return this.intersectsLLR(cell.getRectBound());
-    };
+    }
     /** The point 'p' does not need to be normalized. */
-    S2LatLngRect.prototype.containsP = function (p) {
+    containsP(p) {
         return this.containsLL(S2LatLng_1.S2LatLng.fromPoint(p));
-    };
+    }
     /**
      * Return true if the edge AB intersects the given edge of constant longitude.
      */
-    S2LatLngRect.intersectsLngEdge = function (a, b, lat, lng) {
+    static /*boolean*/ intersectsLngEdge(a, b, lat, lng) {
         // Return true if the segment AB intersects the given edge of constant
         // longitude. The nice thing about edges of constant longitude is that
         // they are straight lines on the sphere (geodesics).
         return S2_1.S2.simpleCrossing(a, b, new S2LatLng_1.S2LatLng(lat.lo, lng)
             .toPoint(), new S2LatLng_1.S2LatLng(lat.hi, lng).toPoint());
-    };
+    }
     /**
      * Return true if the edge AB intersects the given edge of constant latitude.
      */
-    S2LatLngRect.intersectsLatEdge = function (a, b, lat, lng) {
+    static /*boolean*/ intersectsLatEdge(a, b, lat, lng) {
         // Return true if the segment AB intersects the given edge of constant
         // latitude. Unfortunately, lines of constant latitude are curves on
         // the sphere. They can intersect a straight edge in 0, 1, or 2 points.
         // assert (S2.isUnitLength(a) && S2.isUnitLength(b));
         // First, compute the normal to the plane AB that points vaguely north.
-        var z = S2Point_1.S2Point.normalize(S2_1.S2.robustCrossProd(a, b));
+        let z = S2Point_1.S2Point.normalize(S2_1.S2.robustCrossProd(a, b));
         if (z.z < (0)) {
             z = S2Point_1.S2Point.neg(z);
         }
         // Extend this to an orthonormal frame (x,y,z) where x is the direction
         // where the great circle through AB achieves its maximium latitude.
-        var y = S2Point_1.S2Point.normalize(S2_1.S2.robustCrossProd(z, new S2Point_1.S2Point(0, 0, 1)));
-        var x = S2Point_1.S2Point.crossProd(y, z);
+        const y = S2Point_1.S2Point.normalize(S2_1.S2.robustCrossProd(z, new S2Point_1.S2Point(0, 0, 1)));
+        const x = S2Point_1.S2Point.crossProd(y, z);
         // assert (S2.isUnitLength(x) && x.z >= 0);
         // Compute the angle "theta" from the x-axis (in the x-y plane defined
         // above) where the great circle intersects the given line of latitude.
-        var sinLat = Math.sin(lat);
+        const sinLat = Math.sin(lat);
         if (Math.abs(sinLat) >= (x.z)) {
             return false; // The great circle does not reach the given latitude.
         }
         // assert (x.z > 0);
-        var cosTheta = sinLat / x.z;
-        var sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
-        var theta = Math.atan2(sinTheta, cosTheta);
+        const cosTheta = sinLat / x.z;
+        const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
+        const theta = Math.atan2(sinTheta, cosTheta);
         // Math.atan2(sinTheta, cosTheta);
         // The candidate intersection points are located +/- theta in the x-y
         // plane. For an intersection to be valid, we need to check that the
         // intersection point is contained in the interior of the edge AB and
         // also that it is contained within the given longitude interval "lng".
         // Compute the range of theta values spanned by the edge AB.
-        var abTheta = S1Interval_1.S1Interval.fromPointPair(Math.atan2(a.dotProd(y), a.dotProd(x)), Math.atan2(b.dotProd(y), b.dotProd(x)));
+        const abTheta = S1Interval_1.S1Interval.fromPointPair(Math.atan2(a.dotProd(y), a.dotProd(x)), Math.atan2(b.dotProd(y), b.dotProd(x)));
         if (abTheta.contains(theta)) {
             // Check if the intersection point is also in the given "lng" interval.
-            var isect = S2Point_1.S2Point.add(S2Point_1.S2Point.mul(x, cosTheta), S2Point_1.S2Point.mul(y, sinTheta));
+            const isect = S2Point_1.S2Point.add(S2Point_1.S2Point.mul(x, cosTheta), S2Point_1.S2Point.mul(y, sinTheta));
             if (lng.contains(Math.atan2(isect.y, isect.x))) {
                 return true;
             }
         }
         if (abTheta.contains(theta * -1)) {
             // Check if the intersection point is also in the given "lng" interval.
-            var intersection = S2Point_1.S2Point.sub(S2Point_1.S2Point.mul(x, cosTheta), S2Point_1.S2Point.mul(y, sinTheta));
+            const intersection = S2Point_1.S2Point.sub(S2Point_1.S2Point.mul(x, cosTheta), S2Point_1.S2Point.mul(y, sinTheta));
             if (lng.contains(Math.atan2(intersection.y, intersection.x))) {
                 return true;
             }
         }
         return false;
-    };
-    S2LatLngRect.prototype.allVertex = function () {
+    }
+    allVertex() {
         return [
             this.getVertex(0),
             this.getVertex(1),
             this.getVertex(2),
             this.getVertex(3)
         ];
-    };
-    S2LatLngRect.prototype.toGEOJSON = function () {
+    }
+    toGEOJSON() {
         return {
             type: 'Feature',
             geometry: {
                 type: 'Polygon',
-                coordinates: [this.allVertex().concat(this.getVertex(0)).map(function (v) { return [parseFloat(v.lngDegrees.toFixed(5)), parseFloat(v.latDegrees.toFixed(5))]; })],
+                coordinates: [this.allVertex().concat(this.getVertex(0)).map(v => [parseFloat(v.lngDegrees.toFixed(5)), parseFloat(v.latDegrees.toFixed(5))])],
             },
             properties: {}
         };
-    };
-    S2LatLngRect.prototype.toString = function () {
+    }
+    toString() {
         return "[Lo=" + this.lo().toString() + ", Hi=" + this.hi().toString() + "]";
-    };
-    return S2LatLngRect;
-}());
+    }
+}
 exports.S2LatLngRect = S2LatLngRect;
 //# sourceMappingURL=S2LatLngRect.js.map