highcharts 9.3.2 → 10.1.0

package/es-modules/Maps/MapViewInsetsOptionsDefault.js

@@ -0,0 +1,148 @@
+/* *
+ *
+ *  (c) 2010-2021 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+/**
+ * Generic options for the placement and appearance of map insets like
+ * non-contiguous territories.
+ *
+ * @since 10.0.0
+ * @product      highmaps
+ * @optionparent mapView.insetOptions
+ */
+var defaultOptions = {
+    /**
+     * The border color of the insets.
+     *
+     * @sample maps/mapview/insetoptions-border
+     *         Inset border options
+     * @type {Highcharts.ColorType}
+     */
+    borderColor: "#cccccc" /* neutralColor20 */,
+    /**
+     * The pixel border width of the insets.
+     *
+     * @sample maps/mapview/insetoptions-border
+     *         Inset border options
+     */
+    borderWidth: 1,
+    /**
+     * @ignore-option
+     */
+    center: [0, 0],
+    /**
+     * The padding of the insets. Can be either a number of pixels, a percentage
+     * string, or an array of either. If an array is given, it sets the top,
+     * right, bottom, left paddings respectively.
+     *
+     * @type {number|string|Array<number|string>}
+     */
+    padding: '10%',
+    /**
+     * What coordinate system the `field` and `borderPath` should relate to. If
+     * `plotBox`, they will be fixed to the plot box and responsively move in
+     * relation to the main map. If `mapBoundingBox`, they will be fixed to the
+     * map bounding box, which is constant and centered in different chart sizes
+     * and ratios.
+     *
+     * @validvalue ["plotBox", "mapBoundingBox"]
+     */
+    relativeTo: 'mapBoundingBox',
+    /**
+     * What units to use for the `field` and `borderPath` geometries. If
+     * `percent` (default), they relate to the box given in `relativeTo`. If
+     * `pixels`, they are absolute values.
+     *
+     * @validvalue ["percent", "pixels"]
+     */
+    units: 'percent'
+};
+/**
+ * The individual MapView insets, typically used for non-contiguous areas of a
+ * country. Each item inherits from the generic `insetOptions`.
+ *
+ * Some of the TopoJSON files of the [Highcharts Map
+ * Collection](https://code.highcharts.com/mapdata/) include a property called
+ * `hc-recommended-mapview`, and some of these include insets. In order to
+ * override the recommended inset options, an inset option with a matching id
+ * can be applied, and it will be merged into the embedded settings.
+ *
+ * @sample      maps/mapview/insets-extended
+ *              Extending the embedded insets
+ * @sample      maps/mapview/insets-complete
+ *              Complete inset config from scratch
+ *
+ * @extends     mapView.insetOptions
+ * @type        Array<Object>
+ * @product     highmaps
+ * @apioption   mapView.insets
+ */
+/**
+ * A geometry object of type `MultiLineString` defining the border path of the
+ * inset in terms of `units`. If undefined, a border is rendered around the
+ * `field` geometry. It is recommended that the `borderPath` partly follows the
+ * outline of the `field` in order to make pointer positioning consistent.
+ *
+ * @sample    maps/mapview/insets-complete
+ *            Complete inset config with `borderPath`
+ *
+ * @product   highmaps
+ * @type      {Object|undefined}
+ * @apioption mapView.insets.borderPath
+ */
+/**
+ * A geometry object of type `Polygon` defining where in the chart the inset
+ * should be rendered, in terms of `units` and relative to the `relativeTo`
+ * setting. If a `borderPath` is omitted, a border is rendered around the field.
+ * If undefined, the inset is rendered in the full plot area.
+ *
+ * @sample    maps/mapview/insets-extended
+ *            Border path emitted, field is rendered
+ *
+ * @product   highmaps
+ * @type      {Object|undefined}
+ * @apioption mapView.insets.field
+ */
+/**
+ * A geometry object of type `Polygon` encircling the shapes that should be
+ * rendered in the inset, in terms of geographic coordinates. Geometries within
+ * this geometry are removed from the default map view and rendered in the
+ * inset.
+ *
+ * @sample    maps/mapview/insets-complete
+ *            Complete inset config with `geoBounds`
+ *
+ * @product   highmaps
+ * @type      {Object}
+ * @apioption mapView.insets.geoBounds
+ */
+/**
+ * The id of the inset, used for internal reference.
+ *
+ * @sample    maps/mapview/insets-extended
+ *            Extending recommended insets by id
+ *
+ * @product   highmaps
+ * @type      {string}
+ * @apioption mapView.insets.id
+ */
+/**
+ * The projection options for the inset.
+ *
+ * @product   highmaps
+ * @type      {Object}
+ * @extends   mapView.projection
+ * @apioption mapView.insets.projection
+ */
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default defaultOptions;

package/es-modules/Maps/MapViewOptionsDefault.js

@@ -22,16 +22,15 @@
 var defaultOptions = {
     /**
      * The center of the map in terms of longitude and latitude. For
-     * preprojected maps (like in Map Collection v1.x), the units are projected
-     * x and y units.
+     * preprojected maps (like the GeoJSON files in Map Collection v1.x), the
+     * units are projected x and y units.
      *
      * @default [0, 0]
      * @type   {Highcharts.LonLatArray}
      *
-     * @sample {highmaps} maps/mapview/center-zoom
-     *         Custom view of a world map
-     * @sample {highmaps} maps/mapview/get-view
-     *         Report the current view of a preprojected map
+     * @sample {highmaps} maps/mapview/center-zoom Custom view of a world map
+     * @sample {highmaps} maps/mapview/get-view Report the current view of a
+     *         preprojected map
      */
     center: [0, 0],
     /**
@@ -51,27 +50,68 @@ var defaultOptions = {
      *
      * @sample {highmaps} maps/chart/plotbackgroundcolor-color
      *         Visible plot area and percentage padding
+     * @type  {number|string|Array<number|string>}
      */
     padding: 0,
     /**
-     * Beta feature in v9.3. The projection options allow applying client side
-     * projection to a map given in coordinates, typically from TopoJSON or
-     * GeoJSON.
-     *
-     * Sub-options are:
-     * * `name`, which as of v9.3 can be `EqualEarth`,
-     * `LambertConformalConic`, `Miller`, `Orthographic` or `WebMercator`.
-     * * `parallels`, the standard parallels for the LambertConformalConic
-     * projection.
-     * * `rotation`, a three-axis rotation of the globe prior to projection,
-     * which in practice can be used for example to render a world map with the
-     * Americas centered (`[90, 0]`), or to rotate an orthographic projection.
+     * The projection options allow applying client side projection to a map
+     * given in geographic coordinates, typically from TopoJSON or GeoJSON.
      *
      * @type   {Object}
-     * @sample {highmaps} maps/demo/topojson-projection
+     *
+     * @sample maps/mapview/projection-explorer
+     *         Projection explorer
+     * @sample maps/demo/topojson-projection
      *         Orthographic projection
+     * @sample maps/mapview/projection-custom-proj4js
+     *         Custom UTM projection definition
+     * @sample maps/mapview/projection-custom-d3geo
+     *         Custom Robinson projection definition
      */
-    projection: void 0,
+    projection: {
+        /**
+         * Projection name. Built-in projections are `EqualEarth`,
+         * `LambertConformalConic`, `Miller`, `Orthographic` and `WebMercator`.
+         *
+         * @type   {string}
+         * @sample maps/mapview/projection-explorer
+         *         Projection explorer
+         * @sample maps/mapview/projection-custom-proj4js
+         *         Custom UTM projection definition
+         * @sample maps/mapview/projection-custom-d3geo
+         *         Custom Robinson projection definition
+         * @sample maps/demo/topojson-projection
+         *         Orthographic projection
+         */
+        name: void 0,
+        /**
+         * The two standard parallels that define the map layout in conic
+         * projections, like the LambertConformalConic projection. If only one
+         * number is given, the second parallel will be the same as the first.
+         *
+         * @sample maps/mapview/projection-parallels
+         *         LCC projection with parallels
+         * @sample maps/mapview/projection-explorer
+         *         Projection explorer
+         * @type {Array<number>}
+         */
+        parallels: void 0,
+        /**
+         * Rotation of the projection in terms of degrees `[lambda, phi,
+         * gamma]`. When given, a three-axis spherical rotation is be applied
+         * to the globe prior to the projection.
+         *
+         * * `lambda` shifts the longitudes by the given value.
+         * * `phi` shifts the latitudes by the given value. Can be omitted.
+         * * `gamma` applies a _roll_. Can be omitted.
+         *
+         * @sample maps/mapview/projection-explorer
+         *         Projection explorer
+         * @sample maps/mapview/projection-america-centric
+         *         America-centric world map
+         */
+        rotation: void 0
+    },
     /**
      * The zoom level of a map. Higher zoom levels means more zoomed in. An
      * increase of 1 zooms in to a quarter of the viewed area (half the width

package/es-modules/Maps/Projection.js

@@ -15,9 +15,11 @@ var __spreadArrays = (this && this.__spreadArrays) || function () {
             r[k] = a[j];
     return r;
 };
+import PC from '../Core/Geometry/PolygonClip.js';
+var clipLineString = PC.clipLineString, clipPolygon = PC.clipPolygon;
 import registry from './Projections/ProjectionRegistry.js';
 import U from '../Core/Utilities.js';
-var erase = U.erase;
+var clamp = U.clamp, erase = U.erase;
 var deg2rad = Math.PI * 2 / 360;
 // Safe padding on either side of the antimeridian to avoid points being
 // projected to the wrong side of the plane
@@ -47,35 +49,37 @@ var Projection = /** @class */ (function () {
         this.hasGeoProjection = false;
         this.maxLatitude = 90;
         this.options = options;
-        var name = options.name, rotation = options.rotation;
+        var name = options.name, projectedBounds = options.projectedBounds, rotation = options.rotation;
         this.rotator = rotation ? this.getRotator(rotation) : void 0;
-        this.def = name ? Projection.registry[name] : void 0;
+        var ProjectionDefinition = name ? Projection.registry[name] : void 0;
+        if (ProjectionDefinition) {
+            this.def = new ProjectionDefinition(options);
+        }
         var _a = this, def = _a.def, rotator = _a.rotator;
         if (def) {
-            if (def.init) {
-                def.init(options);
-            }
             this.maxLatitude = def.maxLatitude || 90;
             this.hasGeoProjection = true;
         }
         if (rotator && def) {
             this.forward = function (lonLat) {
-                lonLat = rotator.forward(lonLat);
-                return def.forward(lonLat);
+                return def.forward(rotator.forward(lonLat));
             };
             this.inverse = function (xy) {
-                var lonLat = def.inverse(xy);
-                return rotator.inverse(lonLat);
+                return rotator.inverse(def.inverse(xy));
             };
         }
         else if (def) {
-            this.forward = def.forward;
-            this.inverse = def.inverse;
+            this.forward = function (lonLat) { return def.forward(lonLat); };
+            this.inverse = function (xy) { return def.inverse(xy); };
         }
         else if (rotator) {
             this.forward = rotator.forward;
             this.inverse = rotator.inverse;
         }
+        // Projected bounds/clipping
+        this.bounds = projectedBounds === 'world' ?
+            def && def.bounds :
+            projectedBounds;
     }
     // Add a projection definition to the registry, accessible by its `name`.
     Projection.add = function (name, definition) {
@@ -136,6 +140,37 @@ var Projection = /** @class */ (function () {
         var _a = options || {}, name = _a.name, rotation = _a.rotation;
         return [name, rotation && rotation.join(',')].join(';');
     };
+    Projection.prototype.lineIntersectsBounds = function (line) {
+        var _a = this.bounds || {}, x1 = _a.x1, x2 = _a.x2, y1 = _a.y1, y2 = _a.y2;
+        var getIntersect = function (line, dim, val) {
+            var p1 = line[0], p2 = line[1], otherDim = dim ? 0 : 1;
+            // Check if points are on either side of the line
+            if (typeof val === 'number' && p1[dim] >= val !== p2[dim] >= val) {
+                var fraction = ((val - p1[dim]) / (p2[dim] - p1[dim])), crossingVal = p1[otherDim] +
+                    fraction * (p2[otherDim] - p1[otherDim]);
+                return dim ? [crossingVal, val] : [val, crossingVal];
+            }
+        };
+        var intersection, ret = line[0];
+        if ((intersection = getIntersect(line, 0, x1))) {
+            ret = intersection;
+            // Assuming line[1] was originally outside, replace it with the
+            // intersection point so that the horizontal intersection will
+            // be correct.
+            line[1] = intersection;
+        }
+        else if ((intersection = getIntersect(line, 0, x2))) {
+            ret = intersection;
+            line[1] = intersection;
+        }
+        if ((intersection = getIntersect(line, 1, y1))) {
+            ret = intersection;
+        }
+        else if ((intersection = getIntersect(line, 1, y2))) {
+            ret = intersection;
+        }
+        return ret;
+    };
     /*
      * Take the rotation options and return the appropriate projection functions
      */
@@ -174,12 +209,12 @@ var Projection = /** @class */ (function () {
     Projection.prototype.forward = function (lonLat) {
         return lonLat;
     };
-    // Project an xy chart coordinate position to lonlat. Dynamically overridden
-    // when projection is set.
+    // Unproject an xy chart coordinate position to lonlat. Dynamically
+    // overridden when projection is set.
     Projection.prototype.inverse = function (xy) {
         return xy;
     };
-    Projection.prototype.clipOnAntimeridian = function (poly, isPolygon) {
+    Projection.prototype.cutOnAntimeridian = function (poly, isPolygon) {
         var antimeridian = 180;
         var intersections = [];
         var polygons = [poly];
@@ -201,10 +236,9 @@ var Projection = /** @class */ (function () {
                 // ... and on either side of the plane
                 (lon1 > 0) !== (lon2 > 0)) {
                 // Interpolate to the intersection latitude
-                var fraction = (antimeridian - previousLonLat[0]) /
-                    (lonLat[0] - previousLonLat[0]);
-                var lat = previousLonLat[1] +
-                    fraction * (lonLat[1] - previousLonLat[1]);
+                var fraction = clamp((antimeridian - (lon1 + 360) % 360) /
+                    ((lon2 + 360) % 360 - (lon1 + 360) % 360), 0, 1), lat = (previousLonLat[1] +
+                    fraction * (lonLat[1] - previousLonLat[1]));
                 intersections.push({
                     i: i,
                     lat: lat,
@@ -244,16 +278,23 @@ var Projection = /** @class */ (function () {
                 // Insert dummy points close to the pole
                 if (polarIntersection) {
                     for (var i_1 = 0; i_1 < polygons.length; i_1++) {
-                        var poly_1 = polygons[i_1];
-                        var indexOf = poly_1.indexOf(polarIntersection.lonLat);
+                        var direction = polarIntersection.direction, lat = polarIntersection.lat, poly_1 = polygons[i_1], indexOf = poly_1.indexOf(polarIntersection.lonLat);
                         if (indexOf > -1) {
-                            var polarLatitude = (polarIntersection.lat < 0 ? -1 : 1) *
+                            var polarLatitude = (lat < 0 ? -1 : 1) *
                                 this.maxLatitude;
                             var lon1 = wrapLon(antimeridian +
-                                polarIntersection.direction * floatCorrection);
+                                direction * floatCorrection);
                             var lon2 = wrapLon(antimeridian -
-                                polarIntersection.direction * floatCorrection);
-                            var polarSegment = Projection.greatCircle([lon1, polarIntersection.lat], [lon1, polarLatitude], true).concat(Projection.greatCircle([lon2, polarLatitude], [lon2, polarIntersection.lat], true));
+                                direction * floatCorrection);
+                            var polarSegment = Projection.greatCircle([lon1, lat], [lon1, polarLatitude], true);
+                            // Circle around the pole point in order to make
+                            // polygon clipping right. Without this, Antarctica
+                            // would wrap the wrong way in an LLC projection
+                            // with parallels [30, 40].
+                            for (var lon = lon1 + 120 * direction; lon > -180 && lon < 180; lon += 120 * direction) {
+                                polarSegment.push([lon, polarLatitude]);
+                            }
+                            polarSegment.push.apply(polarSegment, Projection.greatCircle([lon2, polarLatitude], [lon2, polarIntersection.lat], true));
                             poly_1.splice.apply(poly_1, __spreadArrays([indexOf,
                                 0], polarSegment));
                             break;
@@ -283,18 +324,12 @@ var Projection = /** @class */ (function () {
                 }
             }
         }
-        // Insert great circles along the cuts
-        /*
-        if (isPolygon && polygons.length > 1 || polarIntersection) {
-            polygons.forEach(Projection.insertGreatCircles);
-        }
-        */
         return polygons;
     };
     // Take a GeoJSON geometry and return a translated SVGPath
     Projection.prototype.path = function (geometry) {
         var _this = this;
-        var _a = this, def = _a.def, rotator = _a.rotator;
+        var _a = this, bounds = _a.bounds, def = _a.def, rotator = _a.rotator;
         var antimeridian = 180;
         var path = [];
         var isPolygon = geometry.type === 'Polygon' ||
@@ -303,12 +338,23 @@ var Projection = /** @class */ (function () {
         // positive. It depends on whether the coordinates are
         // pre-projected.
         var hasGeoProjection = this.hasGeoProjection;
-        // @todo better test for when to do this
-        var projectingToPlane = this.options.name !== 'Orthographic';
+        // Detect whether we need to do antimeridian cutting and clipping to
+        // bounds. The alternative (currently for Orthographic) is to apply a
+        // clip angle.
+        var projectingToPlane = !def || def.antimeridianCutting !== false;
         // We need to rotate in a separate step before applying antimeridian
-        // clipping
+        // cutting
         var preclip = projectingToPlane ? rotator : void 0;
         var postclip = projectingToPlane ? (def || this) : this;
+        var boundsPolygon;
+        if (bounds) {
+            boundsPolygon = [
+                [bounds.x1, bounds.y1],
+                [bounds.x2, bounds.y1],
+                [bounds.x2, bounds.y2],
+                [bounds.x1, bounds.y2]
+            ];
+        }
         var addToPath = function (polygon) {
             // Create a copy of the original coordinates. The copy applies a
             // correction of points close to the antimeridian in order to
@@ -338,7 +384,7 @@ var Projection = /** @class */ (function () {
                 // Insert great circles into long straight lines
                 Projection.insertGreatCircles(poly);
                 if (projectingToPlane) {
-                    polygons = _this.clipOnAntimeridian(poly, isPolygon);
+                    polygons = _this.cutOnAntimeridian(poly, isPolygon);
                 }
             }
             polygons.forEach(function (poly) {
@@ -358,52 +404,98 @@ var Projection = /** @class */ (function () {
                         path.push(['L', point[0], point[1]]);
                     }
                 };
-                for (var i = 0; i < poly.length; i++) {
-                    var lonLat = poly[i];
-                    var point = postclip.forward(lonLat);
-                    var valid = (!isNaN(point[0]) &&
-                        !isNaN(point[1]) &&
-                        (!hasGeoProjection ||
-                            // Limited projections like Web Mercator
-                            (lonLat[1] <= _this.maxLatitude &&
-                                lonLat[1] >= -_this.maxLatitude)));
-                    if (valid) {
-                        // In order to be able to interpolate if the first or
-                        // last point is invalid (on the far side of the globe
-                        // in an orthographic projection), we need to push the
-                        // first valid point to the end of the polygon.
-                        if (isPolygon && !firstValidLonLat) {
-                            firstValidLonLat = lonLat;
-                            poly.push(lonLat);
+                var someOutside = false, someInside = false;
+                var points = poly.map(function (lonLat) {
+                    var xy = postclip.forward(lonLat);
+                    if (xy.outside) {
+                        someOutside = true;
+                    }
+                    else {
+                        someInside = true;
+                    }
+                    // Mercator projects pole points to Infinity, and
+                    // clipPolygon is not able to handle it.
+                    if (xy[1] === Infinity) {
+                        xy[1] = 10e9;
+                    }
+                    else if (xy[1] === -Infinity) {
+                        xy[1] = -10e9;
+                    }
+                    return xy;
+                });
+                if (projectingToPlane) {
+                    // Wrap around in order for pointInPolygon to work
+                    if (isPolygon) {
+                        points.push(points[0]);
+                    }
+                    if (someOutside) {
+                        // All points are outside
+                        if (!someInside) {
+                            return;
                         }
-                        // When entering the first valid point after a gap of
-                        // invalid points, typically on the far side of the
-                        // globe in an orthographic projection.
-                        if (gap && lastValidLonLat) {
-                            // For areas, in an orthographic projection, the
-                            // great circle between two visible points will be
-                            // close to the horizon. A possible exception may be
-                            // when the two points are on opposite sides of the
-                            // globe. It that poses a problem, we may have to
-                            // rewrite this to use the small circle related to
-                            // the current lon0 and lat0.
-                            if (isPolygon && hasGeoProjection) {
-                                var greatCircle = Projection.greatCircle(lastValidLonLat, lonLat);
-                                greatCircle.forEach(function (lonLat) {
-                                    return pushToPath(postclip.forward(lonLat));
-                                });
-                                // For lines, just jump over the gap
+                        // Some inside, some outside. Clip to the bounds.
+                        if (boundsPolygon) {
+                            // Polygons
+                            if (isPolygon) {
+                                points = clipPolygon(points, boundsPolygon);
+                                // Linestrings
                             }
-                            else {
-                                movedTo = false;
+                            else if (bounds) {
+                                clipLineString(points, boundsPolygon)
+                                    .forEach(function (points) {
+                                    movedTo = false;
+                                    points.forEach(pushToPath);
+                                });
+                                return;
                             }
                         }
-                        pushToPath(point);
-                        lastValidLonLat = lonLat;
-                        gap = false;
                     }
-                    else {
-                        gap = true;
+                    points.forEach(pushToPath);
+                    // For orthographic projection, or when a clipAngle applies
+                }
+                else {
+                    for (var i = 0; i < points.length; i++) {
+                        var lonLat = poly[i], point = points[i];
+                        if (!point.outside) {
+                            // In order to be able to interpolate if the first
+                            // or last point is invalid (on the far side of the
+                            // globe in an orthographic projection), we need to
+                            // push the first valid point to the end of the
+                            // polygon.
+                            if (isPolygon && !firstValidLonLat) {
+                                firstValidLonLat = lonLat;
+                                poly.push(lonLat);
+                                points.push(point);
+                            }
+                            // When entering the first valid point after a gap
+                            // of invalid points, typically on the far side of
+                            // the globe in an orthographic projection.
+                            if (gap && lastValidLonLat) {
+                                // For areas, in an orthographic projection, the
+                                // great circle between two visible points will
+                                // be close to the horizon. A possible exception
+                                // may be when the two points are on opposite
+                                // sides of the globe. It that poses a problem,
+                                // we may have to rewrite this to use the small
+                                // circle related to the current lon0 and lat0.
+                                if (isPolygon && hasGeoProjection) {
+                                    var greatCircle = Projection.greatCircle(lastValidLonLat, lonLat);
+                                    greatCircle.forEach(function (lonLat) {
+                                        return pushToPath(postclip.forward(lonLat));
+                                    });
+                                    // For lines, just jump over the gap
+                                }
+                                else {
+                                    movedTo = false;
+                                }
+                            }
+                            pushToPath(point);
+                            lastValidLonLat = lonLat;
+                            gap = false;
+                        }
+                        else {
+                            gap = true;
+                        }
                     }
                 }
             });

package/es-modules/Maps/Projections/EqualEarth.js

@@ -9,8 +9,16 @@
  * */
 'use strict';
 var A1 = 1.340264, A2 = -0.081106, A3 = 0.000893, A4 = 0.003796, M = Math.sqrt(3) / 2.0, scale = 74.03120656864502;
-var EqualEarth = {
-    forward: function (lonLat) {
+var EqualEarth = /** @class */ (function () {
+    function EqualEarth() {
+        this.bounds = {
+            x1: -200.37508342789243,
+            x2: 200.37508342789243,
+            y1: -97.52595454902263,
+            y2: 97.52595454902263
+        };
+    }
+    EqualEarth.prototype.forward = function (lonLat) {
         var d = Math.PI / 180, paramLat = Math.asin(M * Math.sin(lonLat[1] * d)), paramLatSq = paramLat * paramLat, paramLatPow6 = paramLatSq * paramLatSq * paramLatSq;
         var x = lonLat[0] * d * Math.cos(paramLat) * scale / (M *
             (A1 +
@@ -18,8 +26,8 @@ var EqualEarth = {
                 paramLatPow6 * (7 * A3 + 9 * A4 * paramLatSq)));
         var y = paramLat * scale * (A1 + A2 * paramLatSq + paramLatPow6 * (A3 + A4 * paramLatSq));
         return [x, y];
-    },
-    inverse: function (xy) {
+    };
+    EqualEarth.prototype.inverse = function (xy) {
         var x = xy[0] / scale, y = xy[1] / scale, d = 180 / Math.PI, epsilon = 1e-9, iterations = 12;
         var paramLat = y, paramLatSq, paramLatPow6, fy, fpy, dlat, i;
         for (i = 0; i < iterations; ++i) {
@@ -37,6 +45,7 @@ var EqualEarth = {
         var lon = d * M * x * (A1 + 3 * A2 * paramLatSq + paramLatPow6 * (7 * A3 + 9 * A4 * paramLatSq)) / Math.cos(paramLat);
         var lat = d * Math.asin(Math.sin(paramLat) / M);
         return [lon, lat];
-    }
-};
+    };
+    return EqualEarth;
+}());
 export default EqualEarth;