{"version":3,"sources":["webpack:///./node_modules/ol/geom/LinearRing.js","webpack:///./node_modules/ol/geom/flat/interiorpoint.js","webpack:///./node_modules/ol/geom/flat/contains.js","webpack:///./node_modules/ol/geom/MultiLineString.js","webpack:///./node_modules/ol/geom/flat/reverse.js","webpack:///./node_modules/ol/geom/flat/orient.js","webpack:///./node_modules/ol/geom/Polygon.js","webpack:///./node_modules/ol/geom/LineString.js","webpack:///./node_modules/ol/geom/flat/center.js","webpack:///./node_modules/ol/geom/MultiPolygon.js","webpack:///./node_modules/ol/geom/flat/closest.js","webpack:///./node_modules/ol/geom/MultiPoint.js","webpack:///./node_modules/ol/geom/flat/interpolate.js","webpack:///./node_modules/ol/geom/flat/area.js","webpack:///./node_modules/ol/geom/flat/intersectsextent.js","webpack:///./node_modules/ol/easing.js","webpack:///./node_modules/ol/geom/flat/segments.js"],"names":["__extends","extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","hasOwnProperty","__","this","constructor","prototype","create","LinearRing","_super","coordinates","opt_layout","_this","call","maxDelta_","maxDeltaRevision_","undefined","isArray","setCoordinates","setFlatCoordinates","clone","flatCoordinates","slice","layout","closestPointXY","x","y","closestPoint","minSquaredDistance","getExtent","getRevision","Math","sqrt","length","stride","getArea","getCoordinates","getSimplifiedGeometryInternal","squaredTolerance","simplifiedFlatCoordinates","XY","getType","LINEAR_RING","intersectsExtent","extent","setLayout","changed","getInteriorPointOfArray","offset","ends","flatCenters","flatCentersOffset","opt_dest","i","ii","x1","x2","y1","y2","intersections","r","rr","end","push","pointX","NaN","maxSegmentLength","Infinity","sort","segmentLength","abs","isNaN","getInteriorPointsOfMultiArray","endss","interiorPoints","linearRingContainsExtent","outside","coordinate","linearRingContainsXY","wn","linearRingsContainsXY","linearRingssContainsXY","MultiLineString","opt_ends","ends_","getLayout","lineStrings","lineString","getFlatCoordinates","appendLineString","getCoordinateAtM","m","opt_extrapolate","opt_interpolate","XYM","XYZM","extrapolate","interpolate","getEnds","getLineString","index","getLineStrings","getFlatMidpoints","midpoints","midpoint","simplifiedEnds","MULTI_LINE_STRING","tmp","linearRingIsClockwise","edge","linearRingsAreOriented","opt_right","right","isClockwise","linearRingssAreOriented","orientLinearRings","reverse","orientLinearRingsArray","Polygon","flatInteriorPointRevision_","flatInteriorPoint_","orientedRevision_","orientedFlatCoordinates_","appendLinearRing","linearRing","containsXY","getOrientedFlatCoordinates","getFlatInteriorPoint","flatCenter","getInteriorPoint","getLinearRingCount","getLinearRing","getLinearRings","linearRings","POLYGON","fromExtent","minX","minY","maxX","maxY","fromCircle","circle","opt_sides","opt_angle","sides","getStride","center","getCenter","arrayLength","j","polygon","makeRegular","getRadius","radius","startAngle","angle","PI","cos","sin","LineString","flatMidpoint_","flatMidpointRevision_","appendCoordinate","forEachSegment","callback","getCoordinateAt","fraction","getLength","getFlatMidpoint","LINE_STRING","linearRingss","MultiPolygon","opt_endss","endss_","flatInteriorPointsRevision_","flatInteriorPoints_","polygons","jj","appendPolygon","len","newEndss","orient","inflate","getEndss","getFlatInteriorPoints","getInteriorPoints","MultiPoint","GeometryLayout","simplifiedEndss","getPolygon","prevEnds","getPolygons","GeometryType","MULTI_POLYGON","deflate","lastEnds","SimpleGeometry","assignClosest","offset1","offset2","dx","dy","t","maxSquaredDelta","max","squaredDelta","arrayMaxSquaredDelta","multiArrayMaxSquaredDelta","assignClosestPoint","maxDelta","isRing","opt_tmpPoint","squaredDistance","tmpPoint","assignClosestArrayPoint","assignClosestMultiArrayPoint","appendPoint","point","multiPoint","getPoint","n","getPoints","points","MULTI_POINT","interpolatePoint","pointY","length_1","cumulativeLengths","target","o","lineStringCoordinateAtM","lo","hi","mid","m0","m1","lineStringsCoordinateAtM","twiceArea","area","intersectsLineString","coordinatesExtent","point1","point2","intersectsLineStringArray","intersectsLinearRing","intersectsLinearRingArray","intersectsLinearRingMultiArray","easeIn","pow","easeOut","inAndOut","linear","forEach","ret"],"mappings":"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","file":"js/chunk-317c3930.d44b588b.js","sourcesContent":["var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n/**\n * @module ol/geom/LinearRing\n */\nimport { closestSquaredDistanceXY } from '../extent.js';\nimport GeometryLayout from './GeometryLayout.js';\nimport GeometryType from './GeometryType.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { linearRing as linearRingArea } from './flat/area.js';\nimport { assignClosestPoint, maxSquaredDelta } from './flat/closest.js';\nimport { deflateCoordinates } from './flat/deflate.js';\nimport { inflateCoordinates } from './flat/inflate.js';\nimport { douglasPeucker } from './flat/simplify.js';\n/**\n * @classdesc\n * Linear ring geometry. Only used as part of polygon; cannot be rendered\n * on its own.\n *\n * @api\n */\nvar LinearRing = /** @class */ (function (_super) {\n    __extends(LinearRing, _super);\n    /**\n     * @param {Array<import(\"../coordinate.js\").Coordinate>|Array<number>} coordinates Coordinates.\n     *     For internal use, flat coordinates in combination with `opt_layout` are also accepted.\n     * @param {GeometryLayout=} opt_layout Layout.\n     */\n    function LinearRing(coordinates, opt_layout) {\n        var _this = _super.call(this) || this;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.maxDelta_ = -1;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.maxDeltaRevision_ = -1;\n        if (opt_layout !== undefined && !Array.isArray(coordinates[0])) {\n            _this.setFlatCoordinates(opt_layout, /** @type {Array<number>} */ (coordinates));\n        }\n        else {\n            _this.setCoordinates(/** @type {Array<import(\"../coordinate.js\").Coordinate>} */ (coordinates), opt_layout);\n        }\n        return _this;\n    }\n    /**\n     * Make a complete copy of the geometry.\n     * @return {!LinearRing} Clone.\n     * @override\n     * @api\n     */\n    LinearRing.prototype.clone = function () {\n        return new LinearRing(this.flatCoordinates.slice(), this.layout);\n    };\n    /**\n     * @inheritDoc\n     */\n    LinearRing.prototype.closestPointXY = function (x, y, closestPoint, minSquaredDistance) {\n        if (minSquaredDistance < closestSquaredDistanceXY(this.getExtent(), x, y)) {\n            return minSquaredDistance;\n        }\n        if (this.maxDeltaRevision_ != this.getRevision()) {\n            this.maxDelta_ = Math.sqrt(maxSquaredDelta(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, 0));\n            this.maxDeltaRevision_ = this.getRevision();\n        }\n        return assignClosestPoint(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, this.maxDelta_, true, x, y, closestPoint, minSquaredDistance);\n    };\n    /**\n     * Return the area of the linear ring on projected plane.\n     * @return {number} Area (on projected plane).\n     * @api\n     */\n    LinearRing.prototype.getArea = function () {\n        return linearRingArea(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride);\n    };\n    /**\n     * Return the coordinates of the linear ring.\n     * @return {Array<import(\"../coordinate.js\").Coordinate>} Coordinates.\n     * @override\n     * @api\n     */\n    LinearRing.prototype.getCoordinates = function () {\n        return inflateCoordinates(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride);\n    };\n    /**\n     * @inheritDoc\n     */\n    LinearRing.prototype.getSimplifiedGeometryInternal = function (squaredTolerance) {\n        var simplifiedFlatCoordinates = [];\n        simplifiedFlatCoordinates.length = douglasPeucker(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, squaredTolerance, simplifiedFlatCoordinates, 0);\n        return new LinearRing(simplifiedFlatCoordinates, GeometryLayout.XY);\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    LinearRing.prototype.getType = function () {\n        return GeometryType.LINEAR_RING;\n    };\n    /**\n     * @inheritDoc\n     */\n    LinearRing.prototype.intersectsExtent = function (extent) {\n        return false;\n    };\n    /**\n     * Set the coordinates of the linear ring.\n     * @param {!Array<import(\"../coordinate.js\").Coordinate>} coordinates Coordinates.\n     * @param {GeometryLayout=} opt_layout Layout.\n     * @override\n     * @api\n     */\n    LinearRing.prototype.setCoordinates = function (coordinates, opt_layout) {\n        this.setLayout(opt_layout, coordinates, 1);\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = [];\n        }\n        this.flatCoordinates.length = deflateCoordinates(this.flatCoordinates, 0, coordinates, this.stride);\n        this.changed();\n    };\n    return LinearRing;\n}(SimpleGeometry));\nexport default LinearRing;\n//# sourceMappingURL=LinearRing.js.map","/**\n * @module ol/geom/flat/interiorpoint\n */\nimport { numberSafeCompareFunction } from '../../array.js';\nimport { linearRingsContainsXY } from './contains.js';\n/**\n * Calculates a point that is likely to lie in the interior of the linear rings.\n * Inspired by JTS's com.vividsolutions.jts.geom.Geometry#getInteriorPoint.\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<number>} ends Ends.\n * @param {number} stride Stride.\n * @param {Array<number>} flatCenters Flat centers.\n * @param {number} flatCentersOffset Flat center offset.\n * @param {Array<number>=} opt_dest Destination.\n * @return {Array<number>} Destination point as XYM coordinate, where M is the\n * length of the horizontal intersection that the point belongs to.\n */\nexport function getInteriorPointOfArray(flatCoordinates, offset, ends, stride, flatCenters, flatCentersOffset, opt_dest) {\n    var i, ii, x, x1, x2, y1, y2;\n    var y = flatCenters[flatCentersOffset + 1];\n    /** @type {Array<number>} */\n    var intersections = [];\n    // Calculate intersections with the horizontal line\n    for (var r = 0, rr = ends.length; r < rr; ++r) {\n        var end = ends[r];\n        x1 = flatCoordinates[end - stride];\n        y1 = flatCoordinates[end - stride + 1];\n        for (i = offset; i < end; i += stride) {\n            x2 = flatCoordinates[i];\n            y2 = flatCoordinates[i + 1];\n            if ((y <= y1 && y2 <= y) || (y1 <= y && y <= y2)) {\n                x = (y - y1) / (y2 - y1) * (x2 - x1) + x1;\n                intersections.push(x);\n            }\n            x1 = x2;\n            y1 = y2;\n        }\n    }\n    // Find the longest segment of the horizontal line that has its center point\n    // inside the linear ring.\n    var pointX = NaN;\n    var maxSegmentLength = -Infinity;\n    intersections.sort(numberSafeCompareFunction);\n    x1 = intersections[0];\n    for (i = 1, ii = intersections.length; i < ii; ++i) {\n        x2 = intersections[i];\n        var segmentLength = Math.abs(x2 - x1);\n        if (segmentLength > maxSegmentLength) {\n            x = (x1 + x2) / 2;\n            if (linearRingsContainsXY(flatCoordinates, offset, ends, stride, x, y)) {\n                pointX = x;\n                maxSegmentLength = segmentLength;\n            }\n        }\n        x1 = x2;\n    }\n    if (isNaN(pointX)) {\n        // There is no horizontal line that has its center point inside the linear\n        // ring.  Use the center of the the linear ring's extent.\n        pointX = flatCenters[flatCentersOffset];\n    }\n    if (opt_dest) {\n        opt_dest.push(pointX, y, maxSegmentLength);\n        return opt_dest;\n    }\n    else {\n        return [pointX, y, maxSegmentLength];\n    }\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<number>>} endss Endss.\n * @param {number} stride Stride.\n * @param {Array<number>} flatCenters Flat centers.\n * @return {Array<number>} Interior points as XYM coordinates, where M is the\n * length of the horizontal intersection that the point belongs to.\n */\nexport function getInteriorPointsOfMultiArray(flatCoordinates, offset, endss, stride, flatCenters) {\n    var interiorPoints = [];\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        var ends = endss[i];\n        interiorPoints = getInteriorPointOfArray(flatCoordinates, offset, ends, stride, flatCenters, 2 * i, interiorPoints);\n        offset = ends[ends.length - 1];\n    }\n    return interiorPoints;\n}\n//# sourceMappingURL=interiorpoint.js.map","/**\n * @module ol/geom/flat/contains\n */\nimport { forEachCorner } from '../../extent.js';\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {import(\"../../extent.js\").Extent} extent Extent.\n * @return {boolean} Contains extent.\n */\nexport function linearRingContainsExtent(flatCoordinates, offset, end, stride, extent) {\n    var outside = forEachCorner(extent, \n    /**\n     * @param {import(\"../../coordinate.js\").Coordinate} coordinate Coordinate.\n     * @return {boolean} Contains (x, y).\n     */\n    function (coordinate) {\n        return !linearRingContainsXY(flatCoordinates, offset, end, stride, coordinate[0], coordinate[1]);\n    });\n    return !outside;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {number} x X.\n * @param {number} y Y.\n * @return {boolean} Contains (x, y).\n */\nexport function linearRingContainsXY(flatCoordinates, offset, end, stride, x, y) {\n    // http://geomalgorithms.com/a03-_inclusion.html\n    // Copyright 2000 softSurfer, 2012 Dan Sunday\n    // This code may be freely used and modified for any purpose\n    // providing that this copyright notice is included with it.\n    // SoftSurfer makes no warranty for this code, and cannot be held\n    // liable for any real or imagined damage resulting from its use.\n    // Users of this code must verify correctness for their application.\n    var wn = 0;\n    var x1 = flatCoordinates[end - stride];\n    var y1 = flatCoordinates[end - stride + 1];\n    for (; offset < end; offset += stride) {\n        var x2 = flatCoordinates[offset];\n        var y2 = flatCoordinates[offset + 1];\n        if (y1 <= y) {\n            if (y2 > y && ((x2 - x1) * (y - y1)) - ((x - x1) * (y2 - y1)) > 0) {\n                wn++;\n            }\n        }\n        else if (y2 <= y && ((x2 - x1) * (y - y1)) - ((x - x1) * (y2 - y1)) < 0) {\n            wn--;\n        }\n        x1 = x2;\n        y1 = y2;\n    }\n    return wn !== 0;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<number>} ends Ends.\n * @param {number} stride Stride.\n * @param {number} x X.\n * @param {number} y Y.\n * @return {boolean} Contains (x, y).\n */\nexport function linearRingsContainsXY(flatCoordinates, offset, ends, stride, x, y) {\n    if (ends.length === 0) {\n        return false;\n    }\n    if (!linearRingContainsXY(flatCoordinates, offset, ends[0], stride, x, y)) {\n        return false;\n    }\n    for (var i = 1, ii = ends.length; i < ii; ++i) {\n        if (linearRingContainsXY(flatCoordinates, ends[i - 1], ends[i], stride, x, y)) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<number>>} endss Endss.\n * @param {number} stride Stride.\n * @param {number} x X.\n * @param {number} y Y.\n * @return {boolean} Contains (x, y).\n */\nexport function linearRingssContainsXY(flatCoordinates, offset, endss, stride, x, y) {\n    if (endss.length === 0) {\n        return false;\n    }\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        var ends = endss[i];\n        if (linearRingsContainsXY(flatCoordinates, offset, ends, stride, x, y)) {\n            return true;\n        }\n        offset = ends[ends.length - 1];\n    }\n    return false;\n}\n//# sourceMappingURL=contains.js.map","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n/**\n * @module ol/geom/MultiLineString\n */\nimport { extend } from '../array.js';\nimport { closestSquaredDistanceXY } from '../extent.js';\nimport GeometryLayout from './GeometryLayout.js';\nimport GeometryType from './GeometryType.js';\nimport LineString from './LineString.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { assignClosestArrayPoint, arrayMaxSquaredDelta } from './flat/closest.js';\nimport { deflateCoordinatesArray } from './flat/deflate.js';\nimport { inflateCoordinatesArray } from './flat/inflate.js';\nimport { interpolatePoint, lineStringsCoordinateAtM } from './flat/interpolate.js';\nimport { intersectsLineStringArray } from './flat/intersectsextent.js';\nimport { douglasPeuckerArray } from './flat/simplify.js';\n/**\n * @classdesc\n * Multi-linestring geometry.\n *\n * @api\n */\nvar MultiLineString = /** @class */ (function (_super) {\n    __extends(MultiLineString, _super);\n    /**\n     * @param {Array<Array<import(\"../coordinate.js\").Coordinate>|LineString>|Array<number>} coordinates\n     *     Coordinates or LineString geometries. (For internal use, flat coordinates in\n     *     combination with `opt_layout` and `opt_ends` are also accepted.)\n     * @param {GeometryLayout=} opt_layout Layout.\n     * @param {Array<number>=} opt_ends Flat coordinate ends for internal use.\n     */\n    function MultiLineString(coordinates, opt_layout, opt_ends) {\n        var _this = _super.call(this) || this;\n        /**\n         * @type {Array<number>}\n         * @private\n         */\n        _this.ends_ = [];\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.maxDelta_ = -1;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.maxDeltaRevision_ = -1;\n        if (Array.isArray(coordinates[0])) {\n            _this.setCoordinates(/** @type {Array<Array<import(\"../coordinate.js\").Coordinate>>} */ (coordinates), opt_layout);\n        }\n        else if (opt_layout !== undefined && opt_ends) {\n            _this.setFlatCoordinates(opt_layout, /** @type {Array<number>} */ (coordinates));\n            _this.ends_ = opt_ends;\n        }\n        else {\n            var layout = _this.getLayout();\n            var lineStrings = /** @type {Array<LineString>} */ (coordinates);\n            var flatCoordinates = [];\n            var ends = [];\n            for (var i = 0, ii = lineStrings.length; i < ii; ++i) {\n                var lineString = lineStrings[i];\n                if (i === 0) {\n                    layout = lineString.getLayout();\n                }\n                extend(flatCoordinates, lineString.getFlatCoordinates());\n                ends.push(flatCoordinates.length);\n            }\n            _this.setFlatCoordinates(layout, flatCoordinates);\n            _this.ends_ = ends;\n        }\n        return _this;\n    }\n    /**\n     * Append the passed linestring to the multilinestring.\n     * @param {LineString} lineString LineString.\n     * @api\n     */\n    MultiLineString.prototype.appendLineString = function (lineString) {\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = lineString.getFlatCoordinates().slice();\n        }\n        else {\n            extend(this.flatCoordinates, lineString.getFlatCoordinates().slice());\n        }\n        this.ends_.push(this.flatCoordinates.length);\n        this.changed();\n    };\n    /**\n     * Make a complete copy of the geometry.\n     * @return {!MultiLineString} Clone.\n     * @override\n     * @api\n     */\n    MultiLineString.prototype.clone = function () {\n        return new MultiLineString(this.flatCoordinates.slice(), this.layout, this.ends_.slice());\n    };\n    /**\n     * @inheritDoc\n     */\n    MultiLineString.prototype.closestPointXY = function (x, y, closestPoint, minSquaredDistance) {\n        if (minSquaredDistance < closestSquaredDistanceXY(this.getExtent(), x, y)) {\n            return minSquaredDistance;\n        }\n        if (this.maxDeltaRevision_ != this.getRevision()) {\n            this.maxDelta_ = Math.sqrt(arrayMaxSquaredDelta(this.flatCoordinates, 0, this.ends_, this.stride, 0));\n            this.maxDeltaRevision_ = this.getRevision();\n        }\n        return assignClosestArrayPoint(this.flatCoordinates, 0, this.ends_, this.stride, this.maxDelta_, false, x, y, closestPoint, minSquaredDistance);\n    };\n    /**\n     * Returns the coordinate at `m` using linear interpolation, or `null` if no\n     * such coordinate exists.\n     *\n     * `opt_extrapolate` controls extrapolation beyond the range of Ms in the\n     * MultiLineString. If `opt_extrapolate` is `true` then Ms less than the first\n     * M will return the first coordinate and Ms greater than the last M will\n     * return the last coordinate.\n     *\n     * `opt_interpolate` controls interpolation between consecutive LineStrings\n     * within the MultiLineString. If `opt_interpolate` is `true` the coordinates\n     * will be linearly interpolated between the last coordinate of one LineString\n     * and the first coordinate of the next LineString.  If `opt_interpolate` is\n     * `false` then the function will return `null` for Ms falling between\n     * LineStrings.\n     *\n     * @param {number} m M.\n     * @param {boolean=} opt_extrapolate Extrapolate. Default is `false`.\n     * @param {boolean=} opt_interpolate Interpolate. Default is `false`.\n     * @return {import(\"../coordinate.js\").Coordinate} Coordinate.\n     * @api\n     */\n    MultiLineString.prototype.getCoordinateAtM = function (m, opt_extrapolate, opt_interpolate) {\n        if ((this.layout != GeometryLayout.XYM &&\n            this.layout != GeometryLayout.XYZM) ||\n            this.flatCoordinates.length === 0) {\n            return null;\n        }\n        var extrapolate = opt_extrapolate !== undefined ? opt_extrapolate : false;\n        var interpolate = opt_interpolate !== undefined ? opt_interpolate : false;\n        return lineStringsCoordinateAtM(this.flatCoordinates, 0, this.ends_, this.stride, m, extrapolate, interpolate);\n    };\n    /**\n     * Return the coordinates of the multilinestring.\n     * @return {Array<Array<import(\"../coordinate.js\").Coordinate>>} Coordinates.\n     * @override\n     * @api\n     */\n    MultiLineString.prototype.getCoordinates = function () {\n        return inflateCoordinatesArray(this.flatCoordinates, 0, this.ends_, this.stride);\n    };\n    /**\n     * @return {Array<number>} Ends.\n     */\n    MultiLineString.prototype.getEnds = function () {\n        return this.ends_;\n    };\n    /**\n     * Return the linestring at the specified index.\n     * @param {number} index Index.\n     * @return {LineString} LineString.\n     * @api\n     */\n    MultiLineString.prototype.getLineString = function (index) {\n        if (index < 0 || this.ends_.length <= index) {\n            return null;\n        }\n        return new LineString(this.flatCoordinates.slice(index === 0 ? 0 : this.ends_[index - 1], this.ends_[index]), this.layout);\n    };\n    /**\n     * Return the linestrings of this multilinestring.\n     * @return {Array<LineString>} LineStrings.\n     * @api\n     */\n    MultiLineString.prototype.getLineStrings = function () {\n        var flatCoordinates = this.flatCoordinates;\n        var ends = this.ends_;\n        var layout = this.layout;\n        /** @type {Array<LineString>} */\n        var lineStrings = [];\n        var offset = 0;\n        for (var i = 0, ii = ends.length; i < ii; ++i) {\n            var end = ends[i];\n            var lineString = new LineString(flatCoordinates.slice(offset, end), layout);\n            lineStrings.push(lineString);\n            offset = end;\n        }\n        return lineStrings;\n    };\n    /**\n     * @return {Array<number>} Flat midpoints.\n     */\n    MultiLineString.prototype.getFlatMidpoints = function () {\n        var midpoints = [];\n        var flatCoordinates = this.flatCoordinates;\n        var offset = 0;\n        var ends = this.ends_;\n        var stride = this.stride;\n        for (var i = 0, ii = ends.length; i < ii; ++i) {\n            var end = ends[i];\n            var midpoint = interpolatePoint(flatCoordinates, offset, end, stride, 0.5);\n            extend(midpoints, midpoint);\n            offset = end;\n        }\n        return midpoints;\n    };\n    /**\n     * @inheritDoc\n     */\n    MultiLineString.prototype.getSimplifiedGeometryInternal = function (squaredTolerance) {\n        var simplifiedFlatCoordinates = [];\n        var simplifiedEnds = [];\n        simplifiedFlatCoordinates.length = douglasPeuckerArray(this.flatCoordinates, 0, this.ends_, this.stride, squaredTolerance, simplifiedFlatCoordinates, 0, simplifiedEnds);\n        return new MultiLineString(simplifiedFlatCoordinates, GeometryLayout.XY, simplifiedEnds);\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    MultiLineString.prototype.getType = function () {\n        return GeometryType.MULTI_LINE_STRING;\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    MultiLineString.prototype.intersectsExtent = function (extent) {\n        return intersectsLineStringArray(this.flatCoordinates, 0, this.ends_, this.stride, extent);\n    };\n    /**\n     * Set the coordinates of the multilinestring.\n     * @param {!Array<Array<import(\"../coordinate.js\").Coordinate>>} coordinates Coordinates.\n     * @param {GeometryLayout=} opt_layout Layout.\n     * @override\n     * @api\n     */\n    MultiLineString.prototype.setCoordinates = function (coordinates, opt_layout) {\n        this.setLayout(opt_layout, coordinates, 2);\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = [];\n        }\n        var ends = deflateCoordinatesArray(this.flatCoordinates, 0, coordinates, this.stride, this.ends_);\n        this.flatCoordinates.length = ends.length === 0 ? 0 : ends[ends.length - 1];\n        this.changed();\n    };\n    return MultiLineString;\n}(SimpleGeometry));\nexport default MultiLineString;\n//# sourceMappingURL=MultiLineString.js.map","/**\n * @module ol/geom/flat/reverse\n */\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n */\nexport function coordinates(flatCoordinates, offset, end, stride) {\n    while (offset < end - stride) {\n        for (var i = 0; i < stride; ++i) {\n            var tmp = flatCoordinates[offset + i];\n            flatCoordinates[offset + i] = flatCoordinates[end - stride + i];\n            flatCoordinates[end - stride + i] = tmp;\n        }\n        offset += stride;\n        end -= stride;\n    }\n}\n//# sourceMappingURL=reverse.js.map","/**\n * @module ol/geom/flat/orient\n */\nimport { coordinates as reverseCoordinates } from './reverse.js';\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @return {boolean} Is clockwise.\n */\nexport function linearRingIsClockwise(flatCoordinates, offset, end, stride) {\n    // http://tinyurl.com/clockwise-method\n    // https://github.com/OSGeo/gdal/blob/trunk/gdal/ogr/ogrlinearring.cpp\n    var edge = 0;\n    var x1 = flatCoordinates[end - stride];\n    var y1 = flatCoordinates[end - stride + 1];\n    for (; offset < end; offset += stride) {\n        var x2 = flatCoordinates[offset];\n        var y2 = flatCoordinates[offset + 1];\n        edge += (x2 - x1) * (y2 + y1);\n        x1 = x2;\n        y1 = y2;\n    }\n    return edge > 0;\n}\n/**\n * Determines if linear rings are oriented.  By default, left-hand orientation\n * is tested (first ring must be clockwise, remaining rings counter-clockwise).\n * To test for right-hand orientation, use the `opt_right` argument.\n *\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<number>} ends Array of end indexes.\n * @param {number} stride Stride.\n * @param {boolean=} opt_right Test for right-hand orientation\n *     (counter-clockwise exterior ring and clockwise interior rings).\n * @return {boolean} Rings are correctly oriented.\n */\nexport function linearRingsAreOriented(flatCoordinates, offset, ends, stride, opt_right) {\n    var right = opt_right !== undefined ? opt_right : false;\n    for (var i = 0, ii = ends.length; i < ii; ++i) {\n        var end = ends[i];\n        var isClockwise = linearRingIsClockwise(flatCoordinates, offset, end, stride);\n        if (i === 0) {\n            if ((right && isClockwise) || (!right && !isClockwise)) {\n                return false;\n            }\n        }\n        else {\n            if ((right && !isClockwise) || (!right && isClockwise)) {\n                return false;\n            }\n        }\n        offset = end;\n    }\n    return true;\n}\n/**\n * Determines if linear rings are oriented.  By default, left-hand orientation\n * is tested (first ring must be clockwise, remaining rings counter-clockwise).\n * To test for right-hand orientation, use the `opt_right` argument.\n *\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<number>>} endss Array of array of end indexes.\n * @param {number} stride Stride.\n * @param {boolean=} opt_right Test for right-hand orientation\n *     (counter-clockwise exterior ring and clockwise interior rings).\n * @return {boolean} Rings are correctly oriented.\n */\nexport function linearRingssAreOriented(flatCoordinates, offset, endss, stride, opt_right) {\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        var ends = endss[i];\n        if (!linearRingsAreOriented(flatCoordinates, offset, ends, stride, opt_right)) {\n            return false;\n        }\n        if (ends.length) {\n            offset = ends[ends.length - 1];\n        }\n    }\n    return true;\n}\n/**\n * Orient coordinates in a flat array of linear rings.  By default, rings\n * are oriented following the left-hand rule (clockwise for exterior and\n * counter-clockwise for interior rings).  To orient according to the\n * right-hand rule, use the `opt_right` argument.\n *\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<number>} ends Ends.\n * @param {number} stride Stride.\n * @param {boolean=} opt_right Follow the right-hand rule for orientation.\n * @return {number} End.\n */\nexport function orientLinearRings(flatCoordinates, offset, ends, stride, opt_right) {\n    var right = opt_right !== undefined ? opt_right : false;\n    for (var i = 0, ii = ends.length; i < ii; ++i) {\n        var end = ends[i];\n        var isClockwise = linearRingIsClockwise(flatCoordinates, offset, end, stride);\n        var reverse = i === 0 ?\n            (right && isClockwise) || (!right && !isClockwise) :\n            (right && !isClockwise) || (!right && isClockwise);\n        if (reverse) {\n            reverseCoordinates(flatCoordinates, offset, end, stride);\n        }\n        offset = end;\n    }\n    return offset;\n}\n/**\n * Orient coordinates in a flat array of linear rings.  By default, rings\n * are oriented following the left-hand rule (clockwise for exterior and\n * counter-clockwise for interior rings).  To orient according to the\n * right-hand rule, use the `opt_right` argument.\n *\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<number>>} endss Array of array of end indexes.\n * @param {number} stride Stride.\n * @param {boolean=} opt_right Follow the right-hand rule for orientation.\n * @return {number} End.\n */\nexport function orientLinearRingsArray(flatCoordinates, offset, endss, stride, opt_right) {\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        offset = orientLinearRings(flatCoordinates, offset, endss[i], stride, opt_right);\n    }\n    return offset;\n}\n//# sourceMappingURL=orient.js.map","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n/**\n * @module ol/geom/Polygon\n */\nimport { extend } from '../array.js';\nimport { closestSquaredDistanceXY, getCenter } from '../extent.js';\nimport GeometryLayout from './GeometryLayout.js';\nimport GeometryType from './GeometryType.js';\nimport LinearRing from './LinearRing.js';\nimport Point from './Point.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { offset as sphereOffset } from '../sphere.js';\nimport { linearRings as linearRingsArea } from './flat/area.js';\nimport { assignClosestArrayPoint, arrayMaxSquaredDelta } from './flat/closest.js';\nimport { linearRingsContainsXY } from './flat/contains.js';\nimport { deflateCoordinatesArray } from './flat/deflate.js';\nimport { inflateCoordinatesArray } from './flat/inflate.js';\nimport { getInteriorPointOfArray } from './flat/interiorpoint.js';\nimport { intersectsLinearRingArray } from './flat/intersectsextent.js';\nimport { linearRingsAreOriented, orientLinearRings } from './flat/orient.js';\nimport { quantizeArray } from './flat/simplify.js';\nimport { modulo } from '../math.js';\n/**\n * @classdesc\n * Polygon geometry.\n *\n * @api\n */\nvar Polygon = /** @class */ (function (_super) {\n    __extends(Polygon, _super);\n    /**\n     * @param {!Array<Array<import(\"../coordinate.js\").Coordinate>>|!Array<number>} coordinates\n     *     Array of linear rings that define the polygon. The first linear ring of the\n     *     array defines the outer-boundary or surface of the polygon. Each subsequent\n     *     linear ring defines a hole in the surface of the polygon. A linear ring is\n     *     an array of vertices' coordinates where the first coordinate and the last are\n     *     equivalent. (For internal use, flat coordinates in combination with\n     *     `opt_layout` and `opt_ends` are also accepted.)\n     * @param {GeometryLayout=} opt_layout Layout.\n     * @param {Array<number>=} opt_ends Ends (for internal use with flat coordinates).\n     */\n    function Polygon(coordinates, opt_layout, opt_ends) {\n        var _this = _super.call(this) || this;\n        /**\n         * @type {Array<number>}\n         * @private\n         */\n        _this.ends_ = [];\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.flatInteriorPointRevision_ = -1;\n        /**\n         * @private\n         * @type {import(\"../coordinate.js\").Coordinate}\n         */\n        _this.flatInteriorPoint_ = null;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.maxDelta_ = -1;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.maxDeltaRevision_ = -1;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.orientedRevision_ = -1;\n        /**\n         * @private\n         * @type {Array<number>}\n         */\n        _this.orientedFlatCoordinates_ = null;\n        if (opt_layout !== undefined && opt_ends) {\n            _this.setFlatCoordinates(opt_layout, /** @type {Array<number>} */ (coordinates));\n            _this.ends_ = opt_ends;\n        }\n        else {\n            _this.setCoordinates(/** @type {Array<Array<import(\"../coordinate.js\").Coordinate>>} */ (coordinates), opt_layout);\n        }\n        return _this;\n    }\n    /**\n     * Append the passed linear ring to this polygon.\n     * @param {LinearRing} linearRing Linear ring.\n     * @api\n     */\n    Polygon.prototype.appendLinearRing = function (linearRing) {\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = linearRing.getFlatCoordinates().slice();\n        }\n        else {\n            extend(this.flatCoordinates, linearRing.getFlatCoordinates());\n        }\n        this.ends_.push(this.flatCoordinates.length);\n        this.changed();\n    };\n    /**\n     * Make a complete copy of the geometry.\n     * @return {!Polygon} Clone.\n     * @override\n     * @api\n     */\n    Polygon.prototype.clone = function () {\n        return new Polygon(this.flatCoordinates.slice(), this.layout, this.ends_.slice());\n    };\n    /**\n     * @inheritDoc\n     */\n    Polygon.prototype.closestPointXY = function (x, y, closestPoint, minSquaredDistance) {\n        if (minSquaredDistance < closestSquaredDistanceXY(this.getExtent(), x, y)) {\n            return minSquaredDistance;\n        }\n        if (this.maxDeltaRevision_ != this.getRevision()) {\n            this.maxDelta_ = Math.sqrt(arrayMaxSquaredDelta(this.flatCoordinates, 0, this.ends_, this.stride, 0));\n            this.maxDeltaRevision_ = this.getRevision();\n        }\n        return assignClosestArrayPoint(this.flatCoordinates, 0, this.ends_, this.stride, this.maxDelta_, true, x, y, closestPoint, minSquaredDistance);\n    };\n    /**\n     * @inheritDoc\n     */\n    Polygon.prototype.containsXY = function (x, y) {\n        return linearRingsContainsXY(this.getOrientedFlatCoordinates(), 0, this.ends_, this.stride, x, y);\n    };\n    /**\n     * Return the area of the polygon on projected plane.\n     * @return {number} Area (on projected plane).\n     * @api\n     */\n    Polygon.prototype.getArea = function () {\n        return linearRingsArea(this.getOrientedFlatCoordinates(), 0, this.ends_, this.stride);\n    };\n    /**\n     * Get the coordinate array for this geometry.  This array has the structure\n     * of a GeoJSON coordinate array for polygons.\n     *\n     * @param {boolean=} opt_right Orient coordinates according to the right-hand\n     *     rule (counter-clockwise for exterior and clockwise for interior rings).\n     *     If `false`, coordinates will be oriented according to the left-hand rule\n     *     (clockwise for exterior and counter-clockwise for interior rings).\n     *     By default, coordinate orientation will depend on how the geometry was\n     *     constructed.\n     * @return {Array<Array<import(\"../coordinate.js\").Coordinate>>} Coordinates.\n     * @override\n     * @api\n     */\n    Polygon.prototype.getCoordinates = function (opt_right) {\n        var flatCoordinates;\n        if (opt_right !== undefined) {\n            flatCoordinates = this.getOrientedFlatCoordinates().slice();\n            orientLinearRings(flatCoordinates, 0, this.ends_, this.stride, opt_right);\n        }\n        else {\n            flatCoordinates = this.flatCoordinates;\n        }\n        return inflateCoordinatesArray(flatCoordinates, 0, this.ends_, this.stride);\n    };\n    /**\n     * @return {Array<number>} Ends.\n     */\n    Polygon.prototype.getEnds = function () {\n        return this.ends_;\n    };\n    /**\n     * @return {Array<number>} Interior point.\n     */\n    Polygon.prototype.getFlatInteriorPoint = function () {\n        if (this.flatInteriorPointRevision_ != this.getRevision()) {\n            var flatCenter = getCenter(this.getExtent());\n            this.flatInteriorPoint_ = getInteriorPointOfArray(this.getOrientedFlatCoordinates(), 0, this.ends_, this.stride, flatCenter, 0);\n            this.flatInteriorPointRevision_ = this.getRevision();\n        }\n        return this.flatInteriorPoint_;\n    };\n    /**\n     * Return an interior point of the polygon.\n     * @return {Point} Interior point as XYM coordinate, where M is the\n     * length of the horizontal intersection that the point belongs to.\n     * @api\n     */\n    Polygon.prototype.getInteriorPoint = function () {\n        return new Point(this.getFlatInteriorPoint(), GeometryLayout.XYM);\n    };\n    /**\n     * Return the number of rings of the polygon,  this includes the exterior\n     * ring and any interior rings.\n     *\n     * @return {number} Number of rings.\n     * @api\n     */\n    Polygon.prototype.getLinearRingCount = function () {\n        return this.ends_.length;\n    };\n    /**\n     * Return the Nth linear ring of the polygon geometry. Return `null` if the\n     * given index is out of range.\n     * The exterior linear ring is available at index `0` and the interior rings\n     * at index `1` and beyond.\n     *\n     * @param {number} index Index.\n     * @return {LinearRing} Linear ring.\n     * @api\n     */\n    Polygon.prototype.getLinearRing = function (index) {\n        if (index < 0 || this.ends_.length <= index) {\n            return null;\n        }\n        return new LinearRing(this.flatCoordinates.slice(index === 0 ? 0 : this.ends_[index - 1], this.ends_[index]), this.layout);\n    };\n    /**\n     * Return the linear rings of the polygon.\n     * @return {Array<LinearRing>} Linear rings.\n     * @api\n     */\n    Polygon.prototype.getLinearRings = function () {\n        var layout = this.layout;\n        var flatCoordinates = this.flatCoordinates;\n        var ends = this.ends_;\n        var linearRings = [];\n        var offset = 0;\n        for (var i = 0, ii = ends.length; i < ii; ++i) {\n            var end = ends[i];\n            var linearRing = new LinearRing(flatCoordinates.slice(offset, end), layout);\n            linearRings.push(linearRing);\n            offset = end;\n        }\n        return linearRings;\n    };\n    /**\n     * @return {Array<number>} Oriented flat coordinates.\n     */\n    Polygon.prototype.getOrientedFlatCoordinates = function () {\n        if (this.orientedRevision_ != this.getRevision()) {\n            var flatCoordinates = this.flatCoordinates;\n            if (linearRingsAreOriented(flatCoordinates, 0, this.ends_, this.stride)) {\n                this.orientedFlatCoordinates_ = flatCoordinates;\n            }\n            else {\n                this.orientedFlatCoordinates_ = flatCoordinates.slice();\n                this.orientedFlatCoordinates_.length =\n                    orientLinearRings(this.orientedFlatCoordinates_, 0, this.ends_, this.stride);\n            }\n            this.orientedRevision_ = this.getRevision();\n        }\n        return this.orientedFlatCoordinates_;\n    };\n    /**\n     * @inheritDoc\n     */\n    Polygon.prototype.getSimplifiedGeometryInternal = function (squaredTolerance) {\n        var simplifiedFlatCoordinates = [];\n        var simplifiedEnds = [];\n        simplifiedFlatCoordinates.length = quantizeArray(this.flatCoordinates, 0, this.ends_, this.stride, Math.sqrt(squaredTolerance), simplifiedFlatCoordinates, 0, simplifiedEnds);\n        return new Polygon(simplifiedFlatCoordinates, GeometryLayout.XY, simplifiedEnds);\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    Polygon.prototype.getType = function () {\n        return GeometryType.POLYGON;\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    Polygon.prototype.intersectsExtent = function (extent) {\n        return intersectsLinearRingArray(this.getOrientedFlatCoordinates(), 0, this.ends_, this.stride, extent);\n    };\n    /**\n     * Set the coordinates of the polygon.\n     * @param {!Array<Array<import(\"../coordinate.js\").Coordinate>>} coordinates Coordinates.\n     * @param {GeometryLayout=} opt_layout Layout.\n     * @override\n     * @api\n     */\n    Polygon.prototype.setCoordinates = function (coordinates, opt_layout) {\n        this.setLayout(opt_layout, coordinates, 2);\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = [];\n        }\n        var ends = deflateCoordinatesArray(this.flatCoordinates, 0, coordinates, this.stride, this.ends_);\n        this.flatCoordinates.length = ends.length === 0 ? 0 : ends[ends.length - 1];\n        this.changed();\n    };\n    return Polygon;\n}(SimpleGeometry));\nexport default Polygon;\n/**\n * Create an approximation of a circle on the surface of a sphere.\n * @param {import(\"../coordinate.js\").Coordinate} center Center (`[lon, lat]` in degrees).\n * @param {number} radius The great-circle distance from the center to\n *     the polygon vertices.\n * @param {number=} opt_n Optional number of vertices for the resulting\n *     polygon. Default is `32`.\n * @param {number=} opt_sphereRadius Optional radius for the sphere (defaults to\n *     the Earth's mean radius using the WGS84 ellipsoid).\n * @return {Polygon} The \"circular\" polygon.\n * @api\n */\nexport function circular(center, radius, opt_n, opt_sphereRadius) {\n    var n = opt_n ? opt_n : 32;\n    /** @type {Array<number>} */\n    var flatCoordinates = [];\n    for (var i = 0; i < n; ++i) {\n        extend(flatCoordinates, sphereOffset(center, radius, 2 * Math.PI * i / n, opt_sphereRadius));\n    }\n    flatCoordinates.push(flatCoordinates[0], flatCoordinates[1]);\n    return new Polygon(flatCoordinates, GeometryLayout.XY, [flatCoordinates.length]);\n}\n/**\n * Create a polygon from an extent. The layout used is `XY`.\n * @param {import(\"../extent.js\").Extent} extent The extent.\n * @return {Polygon} The polygon.\n * @api\n */\nexport function fromExtent(extent) {\n    var minX = extent[0];\n    var minY = extent[1];\n    var maxX = extent[2];\n    var maxY = extent[3];\n    var flatCoordinates = [minX, minY, minX, maxY, maxX, maxY, maxX, minY, minX, minY];\n    return new Polygon(flatCoordinates, GeometryLayout.XY, [flatCoordinates.length]);\n}\n/**\n * Create a regular polygon from a circle.\n * @param {import(\"./Circle.js\").default} circle Circle geometry.\n * @param {number=} opt_sides Number of sides of the polygon. Default is 32.\n * @param {number=} opt_angle Start angle for the first vertex of the polygon in\n *     radians. Default is 0.\n * @return {Polygon} Polygon geometry.\n * @api\n */\nexport function fromCircle(circle, opt_sides, opt_angle) {\n    var sides = opt_sides ? opt_sides : 32;\n    var stride = circle.getStride();\n    var layout = circle.getLayout();\n    var center = circle.getCenter();\n    var arrayLength = stride * (sides + 1);\n    var flatCoordinates = new Array(arrayLength);\n    for (var i = 0; i < arrayLength; i += stride) {\n        flatCoordinates[i] = 0;\n        flatCoordinates[i + 1] = 0;\n        for (var j = 2; j < stride; j++) {\n            flatCoordinates[i + j] = center[j];\n        }\n    }\n    var ends = [flatCoordinates.length];\n    var polygon = new Polygon(flatCoordinates, layout, ends);\n    makeRegular(polygon, center, circle.getRadius(), opt_angle);\n    return polygon;\n}\n/**\n * Modify the coordinates of a polygon to make it a regular polygon.\n * @param {Polygon} polygon Polygon geometry.\n * @param {import(\"../coordinate.js\").Coordinate} center Center of the regular polygon.\n * @param {number} radius Radius of the regular polygon.\n * @param {number=} opt_angle Start angle for the first vertex of the polygon in\n *     radians. Default is 0.\n */\nexport function makeRegular(polygon, center, radius, opt_angle) {\n    var flatCoordinates = polygon.getFlatCoordinates();\n    var stride = polygon.getStride();\n    var sides = flatCoordinates.length / stride - 1;\n    var startAngle = opt_angle ? opt_angle : 0;\n    for (var i = 0; i <= sides; ++i) {\n        var offset = i * stride;\n        var angle = startAngle + (modulo(i, sides) * 2 * Math.PI / sides);\n        flatCoordinates[offset] = center[0] + (radius * Math.cos(angle));\n        flatCoordinates[offset + 1] = center[1] + (radius * Math.sin(angle));\n    }\n    polygon.changed();\n}\n//# sourceMappingURL=Polygon.js.map","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n/**\n * @module ol/geom/LineString\n */\nimport { extend } from '../array.js';\nimport { closestSquaredDistanceXY } from '../extent.js';\nimport GeometryLayout from './GeometryLayout.js';\nimport GeometryType from './GeometryType.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { assignClosestPoint, maxSquaredDelta } from './flat/closest.js';\nimport { deflateCoordinates } from './flat/deflate.js';\nimport { inflateCoordinates } from './flat/inflate.js';\nimport { interpolatePoint, lineStringCoordinateAtM } from './flat/interpolate.js';\nimport { intersectsLineString } from './flat/intersectsextent.js';\nimport { lineStringLength } from './flat/length.js';\nimport { forEach as forEachSegment } from './flat/segments.js';\nimport { douglasPeucker } from './flat/simplify.js';\n/**\n * @classdesc\n * Linestring geometry.\n *\n * @api\n */\nvar LineString = /** @class */ (function (_super) {\n    __extends(LineString, _super);\n    /**\n     * @param {Array<import(\"../coordinate.js\").Coordinate>|Array<number>} coordinates Coordinates.\n     *     For internal use, flat coordinates in combination with `opt_layout` are also accepted.\n     * @param {GeometryLayout=} opt_layout Layout.\n     */\n    function LineString(coordinates, opt_layout) {\n        var _this = _super.call(this) || this;\n        /**\n         * @private\n         * @type {import(\"../coordinate.js\").Coordinate}\n         */\n        _this.flatMidpoint_ = null;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.flatMidpointRevision_ = -1;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.maxDelta_ = -1;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.maxDeltaRevision_ = -1;\n        if (opt_layout !== undefined && !Array.isArray(coordinates[0])) {\n            _this.setFlatCoordinates(opt_layout, /** @type {Array<number>} */ (coordinates));\n        }\n        else {\n            _this.setCoordinates(/** @type {Array<import(\"../coordinate.js\").Coordinate>} */ (coordinates), opt_layout);\n        }\n        return _this;\n    }\n    /**\n     * Append the passed coordinate to the coordinates of the linestring.\n     * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n     * @api\n     */\n    LineString.prototype.appendCoordinate = function (coordinate) {\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = coordinate.slice();\n        }\n        else {\n            extend(this.flatCoordinates, coordinate);\n        }\n        this.changed();\n    };\n    /**\n     * Make a complete copy of the geometry.\n     * @return {!LineString} Clone.\n     * @override\n     * @api\n     */\n    LineString.prototype.clone = function () {\n        return new LineString(this.flatCoordinates.slice(), this.layout);\n    };\n    /**\n     * @inheritDoc\n     */\n    LineString.prototype.closestPointXY = function (x, y, closestPoint, minSquaredDistance) {\n        if (minSquaredDistance < closestSquaredDistanceXY(this.getExtent(), x, y)) {\n            return minSquaredDistance;\n        }\n        if (this.maxDeltaRevision_ != this.getRevision()) {\n            this.maxDelta_ = Math.sqrt(maxSquaredDelta(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, 0));\n            this.maxDeltaRevision_ = this.getRevision();\n        }\n        return assignClosestPoint(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, this.maxDelta_, false, x, y, closestPoint, minSquaredDistance);\n    };\n    /**\n     * Iterate over each segment, calling the provided callback.\n     * If the callback returns a truthy value the function returns that\n     * value immediately. Otherwise the function returns `false`.\n     *\n     * @param {function(this: S, import(\"../coordinate.js\").Coordinate, import(\"../coordinate.js\").Coordinate): T} callback Function\n     *     called for each segment. The function will receive two arguments, the start and end coordinates of the segment.\n     * @return {T|boolean} Value.\n     * @template T,S\n     * @api\n     */\n    LineString.prototype.forEachSegment = function (callback) {\n        return forEachSegment(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, callback);\n    };\n    /**\n     * Returns the coordinate at `m` using linear interpolation, or `null` if no\n     * such coordinate exists.\n     *\n     * `opt_extrapolate` controls extrapolation beyond the range of Ms in the\n     * MultiLineString. If `opt_extrapolate` is `true` then Ms less than the first\n     * M will return the first coordinate and Ms greater than the last M will\n     * return the last coordinate.\n     *\n     * @param {number} m M.\n     * @param {boolean=} opt_extrapolate Extrapolate. Default is `false`.\n     * @return {import(\"../coordinate.js\").Coordinate} Coordinate.\n     * @api\n     */\n    LineString.prototype.getCoordinateAtM = function (m, opt_extrapolate) {\n        if (this.layout != GeometryLayout.XYM &&\n            this.layout != GeometryLayout.XYZM) {\n            return null;\n        }\n        var extrapolate = opt_extrapolate !== undefined ? opt_extrapolate : false;\n        return lineStringCoordinateAtM(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, m, extrapolate);\n    };\n    /**\n     * Return the coordinates of the linestring.\n     * @return {Array<import(\"../coordinate.js\").Coordinate>} Coordinates.\n     * @override\n     * @api\n     */\n    LineString.prototype.getCoordinates = function () {\n        return inflateCoordinates(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride);\n    };\n    /**\n     * Return the coordinate at the provided fraction along the linestring.\n     * The `fraction` is a number between 0 and 1, where 0 is the start of the\n     * linestring and 1 is the end.\n     * @param {number} fraction Fraction.\n     * @param {import(\"../coordinate.js\").Coordinate=} opt_dest Optional coordinate whose values will\n     *     be modified. If not provided, a new coordinate will be returned.\n     * @return {import(\"../coordinate.js\").Coordinate} Coordinate of the interpolated point.\n     * @api\n     */\n    LineString.prototype.getCoordinateAt = function (fraction, opt_dest) {\n        return interpolatePoint(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, fraction, opt_dest);\n    };\n    /**\n     * Return the length of the linestring on projected plane.\n     * @return {number} Length (on projected plane).\n     * @api\n     */\n    LineString.prototype.getLength = function () {\n        return lineStringLength(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride);\n    };\n    /**\n     * @return {Array<number>} Flat midpoint.\n     */\n    LineString.prototype.getFlatMidpoint = function () {\n        if (this.flatMidpointRevision_ != this.getRevision()) {\n            this.flatMidpoint_ = this.getCoordinateAt(0.5, this.flatMidpoint_);\n            this.flatMidpointRevision_ = this.getRevision();\n        }\n        return this.flatMidpoint_;\n    };\n    /**\n     * @inheritDoc\n     */\n    LineString.prototype.getSimplifiedGeometryInternal = function (squaredTolerance) {\n        var simplifiedFlatCoordinates = [];\n        simplifiedFlatCoordinates.length = douglasPeucker(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, squaredTolerance, simplifiedFlatCoordinates, 0);\n        return new LineString(simplifiedFlatCoordinates, GeometryLayout.XY);\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    LineString.prototype.getType = function () {\n        return GeometryType.LINE_STRING;\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    LineString.prototype.intersectsExtent = function (extent) {\n        return intersectsLineString(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, extent);\n    };\n    /**\n     * Set the coordinates of the linestring.\n     * @param {!Array<import(\"../coordinate.js\").Coordinate>} coordinates Coordinates.\n     * @param {GeometryLayout=} opt_layout Layout.\n     * @override\n     * @api\n     */\n    LineString.prototype.setCoordinates = function (coordinates, opt_layout) {\n        this.setLayout(opt_layout, coordinates, 1);\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = [];\n        }\n        this.flatCoordinates.length = deflateCoordinates(this.flatCoordinates, 0, coordinates, this.stride);\n        this.changed();\n    };\n    return LineString;\n}(SimpleGeometry));\nexport default LineString;\n//# sourceMappingURL=LineString.js.map","/**\n * @module ol/geom/flat/center\n */\nimport { createEmpty, createOrUpdateFromFlatCoordinates } from '../../extent.js';\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<number>>} endss Endss.\n * @param {number} stride Stride.\n * @return {Array<number>} Flat centers.\n */\nexport function linearRingss(flatCoordinates, offset, endss, stride) {\n    var flatCenters = [];\n    var extent = createEmpty();\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        var ends = endss[i];\n        extent = createOrUpdateFromFlatCoordinates(flatCoordinates, offset, ends[0], stride);\n        flatCenters.push((extent[0] + extent[2]) / 2, (extent[1] + extent[3]) / 2);\n        offset = ends[ends.length - 1];\n    }\n    return flatCenters;\n}\n//# sourceMappingURL=center.js.map","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n/**\n * @module ol/geom/MultiPolygon\n */\nimport { extend } from '../array.js';\nimport { closestSquaredDistanceXY } from '../extent.js';\nimport GeometryLayout from './GeometryLayout.js';\nimport GeometryType from './GeometryType.js';\nimport MultiPoint from './MultiPoint.js';\nimport Polygon from './Polygon.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { linearRingss as linearRingssArea } from './flat/area.js';\nimport { linearRingss as linearRingssCenter } from './flat/center.js';\nimport { assignClosestMultiArrayPoint, multiArrayMaxSquaredDelta } from './flat/closest.js';\nimport { linearRingssContainsXY } from './flat/contains.js';\nimport { deflateMultiCoordinatesArray } from './flat/deflate.js';\nimport { inflateMultiCoordinatesArray } from './flat/inflate.js';\nimport { getInteriorPointsOfMultiArray } from './flat/interiorpoint.js';\nimport { intersectsLinearRingMultiArray } from './flat/intersectsextent.js';\nimport { linearRingssAreOriented, orientLinearRingsArray } from './flat/orient.js';\nimport { quantizeMultiArray } from './flat/simplify.js';\n/**\n * @classdesc\n * Multi-polygon geometry.\n *\n * @api\n */\nvar MultiPolygon = /** @class */ (function (_super) {\n    __extends(MultiPolygon, _super);\n    /**\n     * @param {Array<Array<Array<import(\"../coordinate.js\").Coordinate>>|Polygon>|Array<number>} coordinates Coordinates.\n     *     For internal use, flat coordinates in combination with `opt_layout` and `opt_endss` are also accepted.\n     * @param {GeometryLayout=} opt_layout Layout.\n     * @param {Array<Array<number>>=} opt_endss Array of ends for internal use with flat coordinates.\n     */\n    function MultiPolygon(coordinates, opt_layout, opt_endss) {\n        var _this = _super.call(this) || this;\n        /**\n         * @type {Array<Array<number>>}\n         * @private\n         */\n        _this.endss_ = [];\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.flatInteriorPointsRevision_ = -1;\n        /**\n         * @private\n         * @type {Array<number>}\n         */\n        _this.flatInteriorPoints_ = null;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.maxDelta_ = -1;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.maxDeltaRevision_ = -1;\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.orientedRevision_ = -1;\n        /**\n         * @private\n         * @type {Array<number>}\n         */\n        _this.orientedFlatCoordinates_ = null;\n        if (!opt_endss && !Array.isArray(coordinates[0])) {\n            var layout = _this.getLayout();\n            var polygons = /** @type {Array<Polygon>} */ (coordinates);\n            var flatCoordinates = [];\n            var endss = [];\n            for (var i = 0, ii = polygons.length; i < ii; ++i) {\n                var polygon = polygons[i];\n                if (i === 0) {\n                    layout = polygon.getLayout();\n                }\n                var offset = flatCoordinates.length;\n                var ends = polygon.getEnds();\n                for (var j = 0, jj = ends.length; j < jj; ++j) {\n                    ends[j] += offset;\n                }\n                extend(flatCoordinates, polygon.getFlatCoordinates());\n                endss.push(ends);\n            }\n            opt_layout = layout;\n            coordinates = flatCoordinates;\n            opt_endss = endss;\n        }\n        if (opt_layout !== undefined && opt_endss) {\n            _this.setFlatCoordinates(opt_layout, /** @type {Array<number>} */ (coordinates));\n            _this.endss_ = opt_endss;\n        }\n        else {\n            _this.setCoordinates(/** @type {Array<Array<Array<import(\"../coordinate.js\").Coordinate>>>} */ (coordinates), opt_layout);\n        }\n        return _this;\n    }\n    /**\n     * Append the passed polygon to this multipolygon.\n     * @param {Polygon} polygon Polygon.\n     * @api\n     */\n    MultiPolygon.prototype.appendPolygon = function (polygon) {\n        /** @type {Array<number>} */\n        var ends;\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = polygon.getFlatCoordinates().slice();\n            ends = polygon.getEnds().slice();\n            this.endss_.push();\n        }\n        else {\n            var offset = this.flatCoordinates.length;\n            extend(this.flatCoordinates, polygon.getFlatCoordinates());\n            ends = polygon.getEnds().slice();\n            for (var i = 0, ii = ends.length; i < ii; ++i) {\n                ends[i] += offset;\n            }\n        }\n        this.endss_.push(ends);\n        this.changed();\n    };\n    /**\n     * Make a complete copy of the geometry.\n     * @return {!MultiPolygon} Clone.\n     * @override\n     * @api\n     */\n    MultiPolygon.prototype.clone = function () {\n        var len = this.endss_.length;\n        var newEndss = new Array(len);\n        for (var i = 0; i < len; ++i) {\n            newEndss[i] = this.endss_[i].slice();\n        }\n        return new MultiPolygon(this.flatCoordinates.slice(), this.layout, newEndss);\n    };\n    /**\n     * @inheritDoc\n     */\n    MultiPolygon.prototype.closestPointXY = function (x, y, closestPoint, minSquaredDistance) {\n        if (minSquaredDistance < closestSquaredDistanceXY(this.getExtent(), x, y)) {\n            return minSquaredDistance;\n        }\n        if (this.maxDeltaRevision_ != this.getRevision()) {\n            this.maxDelta_ = Math.sqrt(multiArrayMaxSquaredDelta(this.flatCoordinates, 0, this.endss_, this.stride, 0));\n            this.maxDeltaRevision_ = this.getRevision();\n        }\n        return assignClosestMultiArrayPoint(this.getOrientedFlatCoordinates(), 0, this.endss_, this.stride, this.maxDelta_, true, x, y, closestPoint, minSquaredDistance);\n    };\n    /**\n     * @inheritDoc\n     */\n    MultiPolygon.prototype.containsXY = function (x, y) {\n        return linearRingssContainsXY(this.getOrientedFlatCoordinates(), 0, this.endss_, this.stride, x, y);\n    };\n    /**\n     * Return the area of the multipolygon on projected plane.\n     * @return {number} Area (on projected plane).\n     * @api\n     */\n    MultiPolygon.prototype.getArea = function () {\n        return linearRingssArea(this.getOrientedFlatCoordinates(), 0, this.endss_, this.stride);\n    };\n    /**\n     * Get the coordinate array for this geometry.  This array has the structure\n     * of a GeoJSON coordinate array for multi-polygons.\n     *\n     * @param {boolean=} opt_right Orient coordinates according to the right-hand\n     *     rule (counter-clockwise for exterior and clockwise for interior rings).\n     *     If `false`, coordinates will be oriented according to the left-hand rule\n     *     (clockwise for exterior and counter-clockwise for interior rings).\n     *     By default, coordinate orientation will depend on how the geometry was\n     *     constructed.\n     * @return {Array<Array<Array<import(\"../coordinate.js\").Coordinate>>>} Coordinates.\n     * @override\n     * @api\n     */\n    MultiPolygon.prototype.getCoordinates = function (opt_right) {\n        var flatCoordinates;\n        if (opt_right !== undefined) {\n            flatCoordinates = this.getOrientedFlatCoordinates().slice();\n            orientLinearRingsArray(flatCoordinates, 0, this.endss_, this.stride, opt_right);\n        }\n        else {\n            flatCoordinates = this.flatCoordinates;\n        }\n        return inflateMultiCoordinatesArray(flatCoordinates, 0, this.endss_, this.stride);\n    };\n    /**\n     * @return {Array<Array<number>>} Endss.\n     */\n    MultiPolygon.prototype.getEndss = function () {\n        return this.endss_;\n    };\n    /**\n     * @return {Array<number>} Flat interior points.\n     */\n    MultiPolygon.prototype.getFlatInteriorPoints = function () {\n        if (this.flatInteriorPointsRevision_ != this.getRevision()) {\n            var flatCenters = linearRingssCenter(this.flatCoordinates, 0, this.endss_, this.stride);\n            this.flatInteriorPoints_ = getInteriorPointsOfMultiArray(this.getOrientedFlatCoordinates(), 0, this.endss_, this.stride, flatCenters);\n            this.flatInteriorPointsRevision_ = this.getRevision();\n        }\n        return this.flatInteriorPoints_;\n    };\n    /**\n     * Return the interior points as {@link module:ol/geom/MultiPoint multipoint}.\n     * @return {MultiPoint} Interior points as XYM coordinates, where M is\n     * the length of the horizontal intersection that the point belongs to.\n     * @api\n     */\n    MultiPolygon.prototype.getInteriorPoints = function () {\n        return new MultiPoint(this.getFlatInteriorPoints().slice(), GeometryLayout.XYM);\n    };\n    /**\n     * @return {Array<number>} Oriented flat coordinates.\n     */\n    MultiPolygon.prototype.getOrientedFlatCoordinates = function () {\n        if (this.orientedRevision_ != this.getRevision()) {\n            var flatCoordinates = this.flatCoordinates;\n            if (linearRingssAreOriented(flatCoordinates, 0, this.endss_, this.stride)) {\n                this.orientedFlatCoordinates_ = flatCoordinates;\n            }\n            else {\n                this.orientedFlatCoordinates_ = flatCoordinates.slice();\n                this.orientedFlatCoordinates_.length =\n                    orientLinearRingsArray(this.orientedFlatCoordinates_, 0, this.endss_, this.stride);\n            }\n            this.orientedRevision_ = this.getRevision();\n        }\n        return this.orientedFlatCoordinates_;\n    };\n    /**\n     * @inheritDoc\n     */\n    MultiPolygon.prototype.getSimplifiedGeometryInternal = function (squaredTolerance) {\n        var simplifiedFlatCoordinates = [];\n        var simplifiedEndss = [];\n        simplifiedFlatCoordinates.length = quantizeMultiArray(this.flatCoordinates, 0, this.endss_, this.stride, Math.sqrt(squaredTolerance), simplifiedFlatCoordinates, 0, simplifiedEndss);\n        return new MultiPolygon(simplifiedFlatCoordinates, GeometryLayout.XY, simplifiedEndss);\n    };\n    /**\n     * Return the polygon at the specified index.\n     * @param {number} index Index.\n     * @return {Polygon} Polygon.\n     * @api\n     */\n    MultiPolygon.prototype.getPolygon = function (index) {\n        if (index < 0 || this.endss_.length <= index) {\n            return null;\n        }\n        var offset;\n        if (index === 0) {\n            offset = 0;\n        }\n        else {\n            var prevEnds = this.endss_[index - 1];\n            offset = prevEnds[prevEnds.length - 1];\n        }\n        var ends = this.endss_[index].slice();\n        var end = ends[ends.length - 1];\n        if (offset !== 0) {\n            for (var i = 0, ii = ends.length; i < ii; ++i) {\n                ends[i] -= offset;\n            }\n        }\n        return new Polygon(this.flatCoordinates.slice(offset, end), this.layout, ends);\n    };\n    /**\n     * Return the polygons of this multipolygon.\n     * @return {Array<Polygon>} Polygons.\n     * @api\n     */\n    MultiPolygon.prototype.getPolygons = function () {\n        var layout = this.layout;\n        var flatCoordinates = this.flatCoordinates;\n        var endss = this.endss_;\n        var polygons = [];\n        var offset = 0;\n        for (var i = 0, ii = endss.length; i < ii; ++i) {\n            var ends = endss[i].slice();\n            var end = ends[ends.length - 1];\n            if (offset !== 0) {\n                for (var j = 0, jj = ends.length; j < jj; ++j) {\n                    ends[j] -= offset;\n                }\n            }\n            var polygon = new Polygon(flatCoordinates.slice(offset, end), layout, ends);\n            polygons.push(polygon);\n            offset = end;\n        }\n        return polygons;\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    MultiPolygon.prototype.getType = function () {\n        return GeometryType.MULTI_POLYGON;\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    MultiPolygon.prototype.intersectsExtent = function (extent) {\n        return intersectsLinearRingMultiArray(this.getOrientedFlatCoordinates(), 0, this.endss_, this.stride, extent);\n    };\n    /**\n     * Set the coordinates of the multipolygon.\n     * @param {!Array<Array<Array<import(\"../coordinate.js\").Coordinate>>>} coordinates Coordinates.\n     * @param {GeometryLayout=} opt_layout Layout.\n     * @override\n     * @api\n     */\n    MultiPolygon.prototype.setCoordinates = function (coordinates, opt_layout) {\n        this.setLayout(opt_layout, coordinates, 3);\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = [];\n        }\n        var endss = deflateMultiCoordinatesArray(this.flatCoordinates, 0, coordinates, this.stride, this.endss_);\n        if (endss.length === 0) {\n            this.flatCoordinates.length = 0;\n        }\n        else {\n            var lastEnds = endss[endss.length - 1];\n            this.flatCoordinates.length = lastEnds.length === 0 ?\n                0 : lastEnds[lastEnds.length - 1];\n        }\n        this.changed();\n    };\n    return MultiPolygon;\n}(SimpleGeometry));\nexport default MultiPolygon;\n//# sourceMappingURL=MultiPolygon.js.map","/**\n * @module ol/geom/flat/closest\n */\nimport { lerp, squaredDistance as squaredDx } from '../../math.js';\n/**\n * Returns the point on the 2D line segment flatCoordinates[offset1] to\n * flatCoordinates[offset2] that is closest to the point (x, y).  Extra\n * dimensions are linearly interpolated.\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset1 Offset 1.\n * @param {number} offset2 Offset 2.\n * @param {number} stride Stride.\n * @param {number} x X.\n * @param {number} y Y.\n * @param {Array<number>} closestPoint Closest point.\n */\nfunction assignClosest(flatCoordinates, offset1, offset2, stride, x, y, closestPoint) {\n    var x1 = flatCoordinates[offset1];\n    var y1 = flatCoordinates[offset1 + 1];\n    var dx = flatCoordinates[offset2] - x1;\n    var dy = flatCoordinates[offset2 + 1] - y1;\n    var offset;\n    if (dx === 0 && dy === 0) {\n        offset = offset1;\n    }\n    else {\n        var t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy);\n        if (t > 1) {\n            offset = offset2;\n        }\n        else if (t > 0) {\n            for (var i = 0; i < stride; ++i) {\n                closestPoint[i] = lerp(flatCoordinates[offset1 + i], flatCoordinates[offset2 + i], t);\n            }\n            closestPoint.length = stride;\n            return;\n        }\n        else {\n            offset = offset1;\n        }\n    }\n    for (var i = 0; i < stride; ++i) {\n        closestPoint[i] = flatCoordinates[offset + i];\n    }\n    closestPoint.length = stride;\n}\n/**\n * Return the squared of the largest distance between any pair of consecutive\n * coordinates.\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {number} max Max squared delta.\n * @return {number} Max squared delta.\n */\nexport function maxSquaredDelta(flatCoordinates, offset, end, stride, max) {\n    var x1 = flatCoordinates[offset];\n    var y1 = flatCoordinates[offset + 1];\n    for (offset += stride; offset < end; offset += stride) {\n        var x2 = flatCoordinates[offset];\n        var y2 = flatCoordinates[offset + 1];\n        var squaredDelta = squaredDx(x1, y1, x2, y2);\n        if (squaredDelta > max) {\n            max = squaredDelta;\n        }\n        x1 = x2;\n        y1 = y2;\n    }\n    return max;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<number>} ends Ends.\n * @param {number} stride Stride.\n * @param {number} max Max squared delta.\n * @return {number} Max squared delta.\n */\nexport function arrayMaxSquaredDelta(flatCoordinates, offset, ends, stride, max) {\n    for (var i = 0, ii = ends.length; i < ii; ++i) {\n        var end = ends[i];\n        max = maxSquaredDelta(flatCoordinates, offset, end, stride, max);\n        offset = end;\n    }\n    return max;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<number>>} endss Endss.\n * @param {number} stride Stride.\n * @param {number} max Max squared delta.\n * @return {number} Max squared delta.\n */\nexport function multiArrayMaxSquaredDelta(flatCoordinates, offset, endss, stride, max) {\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        var ends = endss[i];\n        max = arrayMaxSquaredDelta(flatCoordinates, offset, ends, stride, max);\n        offset = ends[ends.length - 1];\n    }\n    return max;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {number} maxDelta Max delta.\n * @param {boolean} isRing Is ring.\n * @param {number} x X.\n * @param {number} y Y.\n * @param {Array<number>} closestPoint Closest point.\n * @param {number} minSquaredDistance Minimum squared distance.\n * @param {Array<number>=} opt_tmpPoint Temporary point object.\n * @return {number} Minimum squared distance.\n */\nexport function assignClosestPoint(flatCoordinates, offset, end, stride, maxDelta, isRing, x, y, closestPoint, minSquaredDistance, opt_tmpPoint) {\n    if (offset == end) {\n        return minSquaredDistance;\n    }\n    var i, squaredDistance;\n    if (maxDelta === 0) {\n        // All points are identical, so just test the first point.\n        squaredDistance = squaredDx(x, y, flatCoordinates[offset], flatCoordinates[offset + 1]);\n        if (squaredDistance < minSquaredDistance) {\n            for (i = 0; i < stride; ++i) {\n                closestPoint[i] = flatCoordinates[offset + i];\n            }\n            closestPoint.length = stride;\n            return squaredDistance;\n        }\n        else {\n            return minSquaredDistance;\n        }\n    }\n    var tmpPoint = opt_tmpPoint ? opt_tmpPoint : [NaN, NaN];\n    var index = offset + stride;\n    while (index < end) {\n        assignClosest(flatCoordinates, index - stride, index, stride, x, y, tmpPoint);\n        squaredDistance = squaredDx(x, y, tmpPoint[0], tmpPoint[1]);\n        if (squaredDistance < minSquaredDistance) {\n            minSquaredDistance = squaredDistance;\n            for (i = 0; i < stride; ++i) {\n                closestPoint[i] = tmpPoint[i];\n            }\n            closestPoint.length = stride;\n            index += stride;\n        }\n        else {\n            // Skip ahead multiple points, because we know that all the skipped\n            // points cannot be any closer than the closest point we have found so\n            // far.  We know this because we know how close the current point is, how\n            // close the closest point we have found so far is, and the maximum\n            // distance between consecutive points.  For example, if we're currently\n            // at distance 10, the best we've found so far is 3, and that the maximum\n            // distance between consecutive points is 2, then we'll need to skip at\n            // least (10 - 3) / 2 == 3 (rounded down) points to have any chance of\n            // finding a closer point.  We use Math.max(..., 1) to ensure that we\n            // always advance at least one point, to avoid an infinite loop.\n            index += stride * Math.max(((Math.sqrt(squaredDistance) -\n                Math.sqrt(minSquaredDistance)) / maxDelta) | 0, 1);\n        }\n    }\n    if (isRing) {\n        // Check the closing segment.\n        assignClosest(flatCoordinates, end - stride, offset, stride, x, y, tmpPoint);\n        squaredDistance = squaredDx(x, y, tmpPoint[0], tmpPoint[1]);\n        if (squaredDistance < minSquaredDistance) {\n            minSquaredDistance = squaredDistance;\n            for (i = 0; i < stride; ++i) {\n                closestPoint[i] = tmpPoint[i];\n            }\n            closestPoint.length = stride;\n        }\n    }\n    return minSquaredDistance;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<number>} ends Ends.\n * @param {number} stride Stride.\n * @param {number} maxDelta Max delta.\n * @param {boolean} isRing Is ring.\n * @param {number} x X.\n * @param {number} y Y.\n * @param {Array<number>} closestPoint Closest point.\n * @param {number} minSquaredDistance Minimum squared distance.\n * @param {Array<number>=} opt_tmpPoint Temporary point object.\n * @return {number} Minimum squared distance.\n */\nexport function assignClosestArrayPoint(flatCoordinates, offset, ends, stride, maxDelta, isRing, x, y, closestPoint, minSquaredDistance, opt_tmpPoint) {\n    var tmpPoint = opt_tmpPoint ? opt_tmpPoint : [NaN, NaN];\n    for (var i = 0, ii = ends.length; i < ii; ++i) {\n        var end = ends[i];\n        minSquaredDistance = assignClosestPoint(flatCoordinates, offset, end, stride, maxDelta, isRing, x, y, closestPoint, minSquaredDistance, tmpPoint);\n        offset = end;\n    }\n    return minSquaredDistance;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<number>>} endss Endss.\n * @param {number} stride Stride.\n * @param {number} maxDelta Max delta.\n * @param {boolean} isRing Is ring.\n * @param {number} x X.\n * @param {number} y Y.\n * @param {Array<number>} closestPoint Closest point.\n * @param {number} minSquaredDistance Minimum squared distance.\n * @param {Array<number>=} opt_tmpPoint Temporary point object.\n * @return {number} Minimum squared distance.\n */\nexport function assignClosestMultiArrayPoint(flatCoordinates, offset, endss, stride, maxDelta, isRing, x, y, closestPoint, minSquaredDistance, opt_tmpPoint) {\n    var tmpPoint = opt_tmpPoint ? opt_tmpPoint : [NaN, NaN];\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        var ends = endss[i];\n        minSquaredDistance = assignClosestArrayPoint(flatCoordinates, offset, ends, stride, maxDelta, isRing, x, y, closestPoint, minSquaredDistance, tmpPoint);\n        offset = ends[ends.length - 1];\n    }\n    return minSquaredDistance;\n}\n//# sourceMappingURL=closest.js.map","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n/**\n * @module ol/geom/MultiPoint\n */\nimport { extend } from '../array.js';\nimport { closestSquaredDistanceXY, containsXY } from '../extent.js';\nimport GeometryType from './GeometryType.js';\nimport Point from './Point.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { deflateCoordinates } from './flat/deflate.js';\nimport { inflateCoordinates } from './flat/inflate.js';\nimport { squaredDistance as squaredDx } from '../math.js';\n/**\n * @classdesc\n * Multi-point geometry.\n *\n * @api\n */\nvar MultiPoint = /** @class */ (function (_super) {\n    __extends(MultiPoint, _super);\n    /**\n     * @param {Array<import(\"../coordinate.js\").Coordinate>|Array<number>} coordinates Coordinates.\n     *     For internal use, flat coordinates in combination with `opt_layout` are also accepted.\n     * @param {import(\"./GeometryLayout.js\").default=} opt_layout Layout.\n     */\n    function MultiPoint(coordinates, opt_layout) {\n        var _this = _super.call(this) || this;\n        if (opt_layout && !Array.isArray(coordinates[0])) {\n            _this.setFlatCoordinates(opt_layout, /** @type {Array<number>} */ (coordinates));\n        }\n        else {\n            _this.setCoordinates(/** @type {Array<import(\"../coordinate.js\").Coordinate>} */ (coordinates), opt_layout);\n        }\n        return _this;\n    }\n    /**\n     * Append the passed point to this multipoint.\n     * @param {Point} point Point.\n     * @api\n     */\n    MultiPoint.prototype.appendPoint = function (point) {\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = point.getFlatCoordinates().slice();\n        }\n        else {\n            extend(this.flatCoordinates, point.getFlatCoordinates());\n        }\n        this.changed();\n    };\n    /**\n     * Make a complete copy of the geometry.\n     * @return {!MultiPoint} Clone.\n     * @override\n     * @api\n     */\n    MultiPoint.prototype.clone = function () {\n        var multiPoint = new MultiPoint(this.flatCoordinates.slice(), this.layout);\n        return multiPoint;\n    };\n    /**\n     * @inheritDoc\n     */\n    MultiPoint.prototype.closestPointXY = function (x, y, closestPoint, minSquaredDistance) {\n        if (minSquaredDistance < closestSquaredDistanceXY(this.getExtent(), x, y)) {\n            return minSquaredDistance;\n        }\n        var flatCoordinates = this.flatCoordinates;\n        var stride = this.stride;\n        for (var i = 0, ii = flatCoordinates.length; i < ii; i += stride) {\n            var squaredDistance = squaredDx(x, y, flatCoordinates[i], flatCoordinates[i + 1]);\n            if (squaredDistance < minSquaredDistance) {\n                minSquaredDistance = squaredDistance;\n                for (var j = 0; j < stride; ++j) {\n                    closestPoint[j] = flatCoordinates[i + j];\n                }\n                closestPoint.length = stride;\n            }\n        }\n        return minSquaredDistance;\n    };\n    /**\n     * Return the coordinates of the multipoint.\n     * @return {Array<import(\"../coordinate.js\").Coordinate>} Coordinates.\n     * @override\n     * @api\n     */\n    MultiPoint.prototype.getCoordinates = function () {\n        return inflateCoordinates(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride);\n    };\n    /**\n     * Return the point at the specified index.\n     * @param {number} index Index.\n     * @return {Point} Point.\n     * @api\n     */\n    MultiPoint.prototype.getPoint = function (index) {\n        var n = !this.flatCoordinates ? 0 : this.flatCoordinates.length / this.stride;\n        if (index < 0 || n <= index) {\n            return null;\n        }\n        return new Point(this.flatCoordinates.slice(index * this.stride, (index + 1) * this.stride), this.layout);\n    };\n    /**\n     * Return the points of this multipoint.\n     * @return {Array<Point>} Points.\n     * @api\n     */\n    MultiPoint.prototype.getPoints = function () {\n        var flatCoordinates = this.flatCoordinates;\n        var layout = this.layout;\n        var stride = this.stride;\n        /** @type {Array<Point>} */\n        var points = [];\n        for (var i = 0, ii = flatCoordinates.length; i < ii; i += stride) {\n            var point = new Point(flatCoordinates.slice(i, i + stride), layout);\n            points.push(point);\n        }\n        return points;\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    MultiPoint.prototype.getType = function () {\n        return GeometryType.MULTI_POINT;\n    };\n    /**\n     * @inheritDoc\n     * @api\n     */\n    MultiPoint.prototype.intersectsExtent = function (extent) {\n        var flatCoordinates = this.flatCoordinates;\n        var stride = this.stride;\n        for (var i = 0, ii = flatCoordinates.length; i < ii; i += stride) {\n            var x = flatCoordinates[i];\n            var y = flatCoordinates[i + 1];\n            if (containsXY(extent, x, y)) {\n                return true;\n            }\n        }\n        return false;\n    };\n    /**\n     * Set the coordinates of the multipoint.\n     * @param {!Array<import(\"../coordinate.js\").Coordinate>} coordinates Coordinates.\n     * @param {import(\"./GeometryLayout.js\").default=} opt_layout Layout.\n     * @override\n     * @api\n     */\n    MultiPoint.prototype.setCoordinates = function (coordinates, opt_layout) {\n        this.setLayout(opt_layout, coordinates, 1);\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = [];\n        }\n        this.flatCoordinates.length = deflateCoordinates(this.flatCoordinates, 0, coordinates, this.stride);\n        this.changed();\n    };\n    return MultiPoint;\n}(SimpleGeometry));\nexport default MultiPoint;\n//# sourceMappingURL=MultiPoint.js.map","/**\n * @module ol/geom/flat/interpolate\n */\nimport { binarySearch } from '../../array.js';\nimport { lerp } from '../../math.js';\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {number} fraction Fraction.\n * @param {Array<number>=} opt_dest Destination.\n * @return {Array<number>} Destination.\n */\nexport function interpolatePoint(flatCoordinates, offset, end, stride, fraction, opt_dest) {\n    var pointX = NaN;\n    var pointY = NaN;\n    var n = (end - offset) / stride;\n    if (n === 1) {\n        pointX = flatCoordinates[offset];\n        pointY = flatCoordinates[offset + 1];\n    }\n    else if (n == 2) {\n        pointX = (1 - fraction) * flatCoordinates[offset] +\n            fraction * flatCoordinates[offset + stride];\n        pointY = (1 - fraction) * flatCoordinates[offset + 1] +\n            fraction * flatCoordinates[offset + stride + 1];\n    }\n    else if (n !== 0) {\n        var x1 = flatCoordinates[offset];\n        var y1 = flatCoordinates[offset + 1];\n        var length_1 = 0;\n        var cumulativeLengths = [0];\n        for (var i = offset + stride; i < end; i += stride) {\n            var x2 = flatCoordinates[i];\n            var y2 = flatCoordinates[i + 1];\n            length_1 += Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));\n            cumulativeLengths.push(length_1);\n            x1 = x2;\n            y1 = y2;\n        }\n        var target = fraction * length_1;\n        var index = binarySearch(cumulativeLengths, target);\n        if (index < 0) {\n            var t = (target - cumulativeLengths[-index - 2]) /\n                (cumulativeLengths[-index - 1] - cumulativeLengths[-index - 2]);\n            var o = offset + (-index - 2) * stride;\n            pointX = lerp(flatCoordinates[o], flatCoordinates[o + stride], t);\n            pointY = lerp(flatCoordinates[o + 1], flatCoordinates[o + stride + 1], t);\n        }\n        else {\n            pointX = flatCoordinates[offset + index * stride];\n            pointY = flatCoordinates[offset + index * stride + 1];\n        }\n    }\n    if (opt_dest) {\n        opt_dest[0] = pointX;\n        opt_dest[1] = pointY;\n        return opt_dest;\n    }\n    else {\n        return [pointX, pointY];\n    }\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {number} m M.\n * @param {boolean} extrapolate Extrapolate.\n * @return {import(\"../../coordinate.js\").Coordinate} Coordinate.\n */\nexport function lineStringCoordinateAtM(flatCoordinates, offset, end, stride, m, extrapolate) {\n    if (end == offset) {\n        return null;\n    }\n    var coordinate;\n    if (m < flatCoordinates[offset + stride - 1]) {\n        if (extrapolate) {\n            coordinate = flatCoordinates.slice(offset, offset + stride);\n            coordinate[stride - 1] = m;\n            return coordinate;\n        }\n        else {\n            return null;\n        }\n    }\n    else if (flatCoordinates[end - 1] < m) {\n        if (extrapolate) {\n            coordinate = flatCoordinates.slice(end - stride, end);\n            coordinate[stride - 1] = m;\n            return coordinate;\n        }\n        else {\n            return null;\n        }\n    }\n    // FIXME use O(1) search\n    if (m == flatCoordinates[offset + stride - 1]) {\n        return flatCoordinates.slice(offset, offset + stride);\n    }\n    var lo = offset / stride;\n    var hi = end / stride;\n    while (lo < hi) {\n        var mid = (lo + hi) >> 1;\n        if (m < flatCoordinates[(mid + 1) * stride - 1]) {\n            hi = mid;\n        }\n        else {\n            lo = mid + 1;\n        }\n    }\n    var m0 = flatCoordinates[lo * stride - 1];\n    if (m == m0) {\n        return flatCoordinates.slice((lo - 1) * stride, (lo - 1) * stride + stride);\n    }\n    var m1 = flatCoordinates[(lo + 1) * stride - 1];\n    var t = (m - m0) / (m1 - m0);\n    coordinate = [];\n    for (var i = 0; i < stride - 1; ++i) {\n        coordinate.push(lerp(flatCoordinates[(lo - 1) * stride + i], flatCoordinates[lo * stride + i], t));\n    }\n    coordinate.push(m);\n    return coordinate;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<number>} ends Ends.\n * @param {number} stride Stride.\n * @param {number} m M.\n * @param {boolean} extrapolate Extrapolate.\n * @param {boolean} interpolate Interpolate.\n * @return {import(\"../../coordinate.js\").Coordinate} Coordinate.\n */\nexport function lineStringsCoordinateAtM(flatCoordinates, offset, ends, stride, m, extrapolate, interpolate) {\n    if (interpolate) {\n        return lineStringCoordinateAtM(flatCoordinates, offset, ends[ends.length - 1], stride, m, extrapolate);\n    }\n    var coordinate;\n    if (m < flatCoordinates[stride - 1]) {\n        if (extrapolate) {\n            coordinate = flatCoordinates.slice(0, stride);\n            coordinate[stride - 1] = m;\n            return coordinate;\n        }\n        else {\n            return null;\n        }\n    }\n    if (flatCoordinates[flatCoordinates.length - 1] < m) {\n        if (extrapolate) {\n            coordinate = flatCoordinates.slice(flatCoordinates.length - stride);\n            coordinate[stride - 1] = m;\n            return coordinate;\n        }\n        else {\n            return null;\n        }\n    }\n    for (var i = 0, ii = ends.length; i < ii; ++i) {\n        var end = ends[i];\n        if (offset == end) {\n            continue;\n        }\n        if (m < flatCoordinates[offset + stride - 1]) {\n            return null;\n        }\n        else if (m <= flatCoordinates[end - 1]) {\n            return lineStringCoordinateAtM(flatCoordinates, offset, end, stride, m, false);\n        }\n        offset = end;\n    }\n    return null;\n}\n//# sourceMappingURL=interpolate.js.map","/**\n * @module ol/geom/flat/area\n */\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @return {number} Area.\n */\nexport function linearRing(flatCoordinates, offset, end, stride) {\n    var twiceArea = 0;\n    var x1 = flatCoordinates[end - stride];\n    var y1 = flatCoordinates[end - stride + 1];\n    for (; offset < end; offset += stride) {\n        var x2 = flatCoordinates[offset];\n        var y2 = flatCoordinates[offset + 1];\n        twiceArea += y1 * x2 - x1 * y2;\n        x1 = x2;\n        y1 = y2;\n    }\n    return twiceArea / 2;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<number>} ends Ends.\n * @param {number} stride Stride.\n * @return {number} Area.\n */\nexport function linearRings(flatCoordinates, offset, ends, stride) {\n    var area = 0;\n    for (var i = 0, ii = ends.length; i < ii; ++i) {\n        var end = ends[i];\n        area += linearRing(flatCoordinates, offset, end, stride);\n        offset = end;\n    }\n    return area;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<number>>} endss Endss.\n * @param {number} stride Stride.\n * @return {number} Area.\n */\nexport function linearRingss(flatCoordinates, offset, endss, stride) {\n    var area = 0;\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        var ends = endss[i];\n        area += linearRings(flatCoordinates, offset, ends, stride);\n        offset = ends[ends.length - 1];\n    }\n    return area;\n}\n//# sourceMappingURL=area.js.map","/**\n * @module ol/geom/flat/intersectsextent\n */\nimport { containsExtent, createEmpty, extendFlatCoordinates, intersects, intersectsSegment } from '../../extent.js';\nimport { linearRingContainsXY, linearRingContainsExtent } from './contains.js';\nimport { forEach as forEachSegment } from './segments.js';\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {import(\"../../extent.js\").Extent} extent Extent.\n * @return {boolean} True if the geometry and the extent intersect.\n */\nexport function intersectsLineString(flatCoordinates, offset, end, stride, extent) {\n    var coordinatesExtent = extendFlatCoordinates(createEmpty(), flatCoordinates, offset, end, stride);\n    if (!intersects(extent, coordinatesExtent)) {\n        return false;\n    }\n    if (containsExtent(extent, coordinatesExtent)) {\n        return true;\n    }\n    if (coordinatesExtent[0] >= extent[0] &&\n        coordinatesExtent[2] <= extent[2]) {\n        return true;\n    }\n    if (coordinatesExtent[1] >= extent[1] &&\n        coordinatesExtent[3] <= extent[3]) {\n        return true;\n    }\n    return forEachSegment(flatCoordinates, offset, end, stride, \n    /**\n     * @param {import(\"../../coordinate.js\").Coordinate} point1 Start point.\n     * @param {import(\"../../coordinate.js\").Coordinate} point2 End point.\n     * @return {boolean} `true` if the segment and the extent intersect,\n     *     `false` otherwise.\n     */\n    function (point1, point2) {\n        return intersectsSegment(extent, point1, point2);\n    });\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<number>} ends Ends.\n * @param {number} stride Stride.\n * @param {import(\"../../extent.js\").Extent} extent Extent.\n * @return {boolean} True if the geometry and the extent intersect.\n */\nexport function intersectsLineStringArray(flatCoordinates, offset, ends, stride, extent) {\n    for (var i = 0, ii = ends.length; i < ii; ++i) {\n        if (intersectsLineString(flatCoordinates, offset, ends[i], stride, extent)) {\n            return true;\n        }\n        offset = ends[i];\n    }\n    return false;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {import(\"../../extent.js\").Extent} extent Extent.\n * @return {boolean} True if the geometry and the extent intersect.\n */\nexport function intersectsLinearRing(flatCoordinates, offset, end, stride, extent) {\n    if (intersectsLineString(flatCoordinates, offset, end, stride, extent)) {\n        return true;\n    }\n    if (linearRingContainsXY(flatCoordinates, offset, end, stride, extent[0], extent[1])) {\n        return true;\n    }\n    if (linearRingContainsXY(flatCoordinates, offset, end, stride, extent[0], extent[3])) {\n        return true;\n    }\n    if (linearRingContainsXY(flatCoordinates, offset, end, stride, extent[2], extent[1])) {\n        return true;\n    }\n    if (linearRingContainsXY(flatCoordinates, offset, end, stride, extent[2], extent[3])) {\n        return true;\n    }\n    return false;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<number>} ends Ends.\n * @param {number} stride Stride.\n * @param {import(\"../../extent.js\").Extent} extent Extent.\n * @return {boolean} True if the geometry and the extent intersect.\n */\nexport function intersectsLinearRingArray(flatCoordinates, offset, ends, stride, extent) {\n    if (!intersectsLinearRing(flatCoordinates, offset, ends[0], stride, extent)) {\n        return false;\n    }\n    if (ends.length === 1) {\n        return true;\n    }\n    for (var i = 1, ii = ends.length; i < ii; ++i) {\n        if (linearRingContainsExtent(flatCoordinates, ends[i - 1], ends[i], stride, extent)) {\n            if (!intersectsLineString(flatCoordinates, ends[i - 1], ends[i], stride, extent)) {\n                return false;\n            }\n        }\n    }\n    return true;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<number>>} endss Endss.\n * @param {number} stride Stride.\n * @param {import(\"../../extent.js\").Extent} extent Extent.\n * @return {boolean} True if the geometry and the extent intersect.\n */\nexport function intersectsLinearRingMultiArray(flatCoordinates, offset, endss, stride, extent) {\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        var ends = endss[i];\n        if (intersectsLinearRingArray(flatCoordinates, offset, ends, stride, extent)) {\n            return true;\n        }\n        offset = ends[ends.length - 1];\n    }\n    return false;\n}\n//# sourceMappingURL=intersectsextent.js.map","/**\n * @module ol/easing\n */\n/**\n * Start slow and speed up.\n * @param {number} t Input between 0 and 1.\n * @return {number} Output between 0 and 1.\n * @api\n */\nexport function easeIn(t) {\n    return Math.pow(t, 3);\n}\n/**\n * Start fast and slow down.\n * @param {number} t Input between 0 and 1.\n * @return {number} Output between 0 and 1.\n * @api\n */\nexport function easeOut(t) {\n    return 1 - easeIn(1 - t);\n}\n/**\n * Start slow, speed up, and then slow down again.\n * @param {number} t Input between 0 and 1.\n * @return {number} Output between 0 and 1.\n * @api\n */\nexport function inAndOut(t) {\n    return 3 * t * t - 2 * t * t * t;\n}\n/**\n * Maintain a constant speed over time.\n * @param {number} t Input between 0 and 1.\n * @return {number} Output between 0 and 1.\n * @api\n */\nexport function linear(t) {\n    return t;\n}\n/**\n * Start slow, speed up, and at the very end slow down again.  This has the\n * same general behavior as {@link module:ol/easing~inAndOut}, but the final\n * slowdown is delayed.\n * @param {number} t Input between 0 and 1.\n * @return {number} Output between 0 and 1.\n * @api\n */\nexport function upAndDown(t) {\n    if (t < 0.5) {\n        return inAndOut(2 * t);\n    }\n    else {\n        return 1 - inAndOut(2 * (t - 0.5));\n    }\n}\n//# sourceMappingURL=easing.js.map","/**\n * @module ol/geom/flat/segments\n */\n/**\n * This function calls `callback` for each segment of the flat coordinates\n * array. If the callback returns a truthy value the function returns that\n * value immediately. Otherwise the function returns `false`.\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {function(import(\"../../coordinate.js\").Coordinate, import(\"../../coordinate.js\").Coordinate): T} callback Function\n *     called for each segment.\n * @return {T|boolean} Value.\n * @template T\n */\nexport function forEach(flatCoordinates, offset, end, stride, callback) {\n    var point1 = [flatCoordinates[offset], flatCoordinates[offset + 1]];\n    var point2 = [];\n    var ret;\n    for (; (offset + stride) < end; offset += stride) {\n        point2[0] = flatCoordinates[offset + stride];\n        point2[1] = flatCoordinates[offset + stride + 1];\n        ret = callback(point1, point2);\n        if (ret) {\n            return ret;\n        }\n        point1[0] = point2[0];\n        point1[1] = point2[1];\n    }\n    return false;\n}\n//# sourceMappingURL=segments.js.map"],"sourceRoot":""}