{"version":3,"file":"js/7426-73e2cfb7595919cb321f.js","mappings":"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","sources":["webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/NotificationFactories.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/Subscriber.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/Subscription.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/config.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/operators/filter.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/operators/map.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/util/arrRemove.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/util/errorContext.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/util/isFunction.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/util/lift.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/util/noop.js","webpack://Chouette/./node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js","webpack://Chouette/./node_modules/rxjs/node_modules/tslib/tslib.es6.js","webpack://Chouette/./node_modules/dequal/lite/index.mjs","webpack://Chouette/./node_modules/swr/esm/libs/hash.js","webpack://Chouette/./node_modules/swr/esm/cache.js","webpack://Chouette/./node_modules/swr/esm/libs/web-preset.js","webpack://Chouette/./node_modules/swr/esm/config.js","webpack://Chouette/./node_modules/swr/esm/env.js","webpack://Chouette/./node_modules/swr/esm/swr-config-context.js","webpack://Chouette/./node_modules/swr/esm/use-swr.js","webpack://Chouette/./node_modules/swr/esm/index.js","webpack://Chouette/./node_modules/ol/AssertionError.js","webpack://Chouette/./node_modules/ol/Disposable.js","webpack://Chouette/./node_modules/ol/Feature.js","webpack://Chouette/./node_modules/ol/Object.js","webpack://Chouette/./node_modules/ol/ObjectEventType.js","webpack://Chouette/./node_modules/ol/Observable.js","webpack://Chouette/./node_modules/ol/array.js","webpack://Chouette/./node_modules/ol/asserts.js","webpack://Chouette/./node_modules/ol/events.js","webpack://Chouette/./node_modules/ol/events/Event.js","webpack://Chouette/./node_modules/ol/events/EventType.js","webpack://Chouette/./node_modules/ol/events/Target.js","webpack://Chouette/./node_modules/ol/extent.js","webpack://Chouette/./node_modules/ol/extent/Corner.js","webpack://Chouette/./node_modules/ol/extent/Relationship.js","webpack://Chouette/./node_modules/ol/format/FormatType.js","webpack://Chouette/./node_modules/ol/geom/GeometryCollection.js","webpack://Chouette/./node_modules/ol/format/Feature.js","webpack://Chouette/./node_modules/ol/format/JSONFeature.js","webpack://Chouette/./node_modules/ol/geom/flat/interpolate.js","webpack://Chouette/./node_modules/ol/geom/LineString.js","webpack://Chouette/./node_modules/ol/geom/MultiLineString.js","webpack://Chouette/./node_modules/ol/geom/MultiPoint.js","webpack://Chouette/./node_modules/ol/geom/MultiPolygon.js","webpack://Chouette/./node_modules/ol/geom/flat/center.js","webpack://Chouette/./node_modules/ol/format/GeoJSON.js","webpack://Chouette/./node_modules/ol/functions.js","webpack://Chouette/./node_modules/ol/geom/Geometry.js","webpack://Chouette/./node_modules/ol/geom/GeometryLayout.js","webpack://Chouette/./node_modules/ol/geom/GeometryType.js","webpack://Chouette/./node_modules/ol/geom/Point.js","webpack://Chouette/./node_modules/ol/geom/LinearRing.js","webpack://Chouette/./node_modules/ol/geom/Polygon.js","webpack://Chouette/./node_modules/ol/geom/SimpleGeometry.js","webpack://Chouette/./node_modules/ol/geom/flat/area.js","webpack://Chouette/./node_modules/ol/geom/flat/closest.js","webpack://Chouette/./node_modules/ol/geom/flat/contains.js","webpack://Chouette/./node_modules/ol/geom/flat/deflate.js","webpack://Chouette/./node_modules/ol/geom/flat/inflate.js","webpack://Chouette/./node_modules/ol/geom/flat/interiorpoint.js","webpack://Chouette/./node_modules/ol/geom/flat/intersectsextent.js","webpack://Chouette/./node_modules/ol/geom/flat/length.js","webpack://Chouette/./node_modules/ol/geom/flat/reverse.js","webpack://Chouette/./node_modules/ol/geom/flat/orient.js","webpack://Chouette/./node_modules/ol/geom/flat/segments.js","webpack://Chouette/./node_modules/ol/geom/flat/simplify.js","webpack://Chouette/./node_modules/ol/geom/flat/transform.js","webpack://Chouette/./node_modules/ol/has.js","webpack://Chouette/./node_modules/ol/math.js","webpack://Chouette/./node_modules/ol/obj.js","webpack://Chouette/./node_modules/ol/proj/epsg3857.js","webpack://Chouette/./node_modules/ol/proj/Projection.js","webpack://Chouette/./node_modules/ol/proj/epsg4326.js","webpack://Chouette/./node_modules/ol/proj/projections.js","webpack://Chouette/./node_modules/ol/proj/transforms.js","webpack://Chouette/./node_modules/ol/sphere.js","webpack://Chouette/./node_modules/ol/proj.js","webpack://Chouette/./node_modules/ol/proj/Units.js","webpack://Chouette/./node_modules/ol/transform.js","webpack://Chouette/./node_modules/ol/util.js"],"sourcesContent":["export var COMPLETE_NOTIFICATION = (function () { return createNotification('C', undefined, undefined); })();\nexport function errorNotification(error) {\n    return createNotification('E', undefined, error);\n}\nexport function nextNotification(value) {\n    return createNotification('N', value, undefined);\n}\nexport function createNotification(kind, value, error) {\n    return {\n        kind: kind,\n        value: value,\n        error: error,\n    };\n}\n//# sourceMappingURL=NotificationFactories.js.map","import { __extends, __read, __spreadArray } from \"tslib\";\nimport { isFunction } from './util/isFunction';\nimport { isSubscription, Subscription } from './Subscription';\nimport { config } from './config';\nimport { reportUnhandledError } from './util/reportUnhandledError';\nimport { noop } from './util/noop';\nimport { nextNotification, errorNotification, COMPLETE_NOTIFICATION } from './NotificationFactories';\nimport { timeoutProvider } from './scheduler/timeoutProvider';\nimport { captureError } from './util/errorContext';\nvar Subscriber = (function (_super) {\n    __extends(Subscriber, _super);\n    function Subscriber(destination) {\n        var _this = _super.call(this) || this;\n        _this.isStopped = false;\n        if (destination) {\n            _this.destination = destination;\n            if (isSubscription(destination)) {\n                destination.add(_this);\n            }\n        }\n        else {\n            _this.destination = EMPTY_OBSERVER;\n        }\n        return _this;\n    }\n    Subscriber.create = function (next, error, complete) {\n        return new SafeSubscriber(next, error, complete);\n    };\n    Subscriber.prototype.next = function (value) {\n        if (this.isStopped) {\n            handleStoppedNotification(nextNotification(value), this);\n        }\n        else {\n            this._next(value);\n        }\n    };\n    Subscriber.prototype.error = function (err) {\n        if (this.isStopped) {\n            handleStoppedNotification(errorNotification(err), this);\n        }\n        else {\n            this.isStopped = true;\n            this._error(err);\n        }\n    };\n    Subscriber.prototype.complete = function () {\n        if (this.isStopped) {\n            handleStoppedNotification(COMPLETE_NOTIFICATION, this);\n        }\n        else {\n            this.isStopped = true;\n            this._complete();\n        }\n    };\n    Subscriber.prototype.unsubscribe = function () {\n        if (!this.closed) {\n            this.isStopped = true;\n            _super.prototype.unsubscribe.call(this);\n            this.destination = null;\n        }\n    };\n    Subscriber.prototype._next = function (value) {\n        this.destination.next(value);\n    };\n    Subscriber.prototype._error = function (err) {\n        try {\n            this.destination.error(err);\n        }\n        finally {\n            this.unsubscribe();\n        }\n    };\n    Subscriber.prototype._complete = function () {\n        try {\n            this.destination.complete();\n        }\n        finally {\n            this.unsubscribe();\n        }\n    };\n    return Subscriber;\n}(Subscription));\nexport { Subscriber };\nvar SafeSubscriber = (function (_super) {\n    __extends(SafeSubscriber, _super);\n    function SafeSubscriber(observerOrNext, error, complete) {\n        var _this = _super.call(this) || this;\n        var next;\n        if (isFunction(observerOrNext)) {\n            next = observerOrNext;\n        }\n        else if (observerOrNext) {\n            (next = observerOrNext.next, error = observerOrNext.error, complete = observerOrNext.complete);\n            var context_1;\n            if (_this && config.useDeprecatedNextContext) {\n                context_1 = Object.create(observerOrNext);\n                context_1.unsubscribe = function () { return _this.unsubscribe(); };\n            }\n            else {\n                context_1 = observerOrNext;\n            }\n            next = next === null || next === void 0 ? void 0 : next.bind(context_1);\n            error = error === null || error === void 0 ? void 0 : error.bind(context_1);\n            complete = complete === null || complete === void 0 ? void 0 : complete.bind(context_1);\n        }\n        _this.destination = {\n            next: next ? wrapForErrorHandling(next, _this) : noop,\n            error: wrapForErrorHandling(error !== null && error !== void 0 ? error : defaultErrorHandler, _this),\n            complete: complete ? wrapForErrorHandling(complete, _this) : noop,\n        };\n        return _this;\n    }\n    return SafeSubscriber;\n}(Subscriber));\nexport { SafeSubscriber };\nfunction wrapForErrorHandling(handler, instance) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        try {\n            handler.apply(void 0, __spreadArray([], __read(args)));\n        }\n        catch (err) {\n            if (config.useDeprecatedSynchronousErrorHandling) {\n                captureError(err);\n            }\n            else {\n                reportUnhandledError(err);\n            }\n        }\n    };\n}\nfunction defaultErrorHandler(err) {\n    throw err;\n}\nfunction handleStoppedNotification(notification, subscriber) {\n    var onStoppedNotification = config.onStoppedNotification;\n    onStoppedNotification && timeoutProvider.setTimeout(function () { return onStoppedNotification(notification, subscriber); });\n}\nexport var EMPTY_OBSERVER = {\n    closed: true,\n    next: noop,\n    error: defaultErrorHandler,\n    complete: noop,\n};\n//# sourceMappingURL=Subscriber.js.map","import { createErrorClass } from './createErrorClass';\nexport var UnsubscriptionError = createErrorClass(function (_super) {\n    return function UnsubscriptionErrorImpl(errors) {\n        _super(this);\n        this.message = errors\n            ? errors.length + \" errors occurred during unsubscription:\\n\" + errors.map(function (err, i) { return i + 1 + \") \" + err.toString(); }).join('\\n  ')\n            : '';\n        this.name = 'UnsubscriptionError';\n        this.errors = errors;\n    };\n});\n//# sourceMappingURL=UnsubscriptionError.js.map","import { __read, __spreadArray, __values } from \"tslib\";\nimport { isFunction } from './util/isFunction';\nimport { UnsubscriptionError } from './util/UnsubscriptionError';\nimport { arrRemove } from './util/arrRemove';\nvar Subscription = (function () {\n    function Subscription(initialTeardown) {\n        this.initialTeardown = initialTeardown;\n        this.closed = false;\n        this._parentage = null;\n        this._teardowns = null;\n    }\n    Subscription.prototype.unsubscribe = function () {\n        var e_1, _a, e_2, _b;\n        var errors;\n        if (!this.closed) {\n            this.closed = true;\n            var _parentage = this._parentage;\n            if (_parentage) {\n                this._parentage = null;\n                if (Array.isArray(_parentage)) {\n                    try {\n                        for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {\n                            var parent_1 = _parentage_1_1.value;\n                            parent_1.remove(this);\n                        }\n                    }\n                    catch (e_1_1) { e_1 = { error: e_1_1 }; }\n                    finally {\n                        try {\n                            if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);\n                        }\n                        finally { if (e_1) throw e_1.error; }\n                    }\n                }\n                else {\n                    _parentage.remove(this);\n                }\n            }\n            var initialTeardown = this.initialTeardown;\n            if (isFunction(initialTeardown)) {\n                try {\n                    initialTeardown();\n                }\n                catch (e) {\n                    errors = e instanceof UnsubscriptionError ? e.errors : [e];\n                }\n            }\n            var _teardowns = this._teardowns;\n            if (_teardowns) {\n                this._teardowns = null;\n                try {\n                    for (var _teardowns_1 = __values(_teardowns), _teardowns_1_1 = _teardowns_1.next(); !_teardowns_1_1.done; _teardowns_1_1 = _teardowns_1.next()) {\n                        var teardown_1 = _teardowns_1_1.value;\n                        try {\n                            execTeardown(teardown_1);\n                        }\n                        catch (err) {\n                            errors = errors !== null && errors !== void 0 ? errors : [];\n                            if (err instanceof UnsubscriptionError) {\n                                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));\n                            }\n                            else {\n                                errors.push(err);\n                            }\n                        }\n                    }\n                }\n                catch (e_2_1) { e_2 = { error: e_2_1 }; }\n                finally {\n                    try {\n                        if (_teardowns_1_1 && !_teardowns_1_1.done && (_b = _teardowns_1.return)) _b.call(_teardowns_1);\n                    }\n                    finally { if (e_2) throw e_2.error; }\n                }\n            }\n            if (errors) {\n                throw new UnsubscriptionError(errors);\n            }\n        }\n    };\n    Subscription.prototype.add = function (teardown) {\n        var _a;\n        if (teardown && teardown !== this) {\n            if (this.closed) {\n                execTeardown(teardown);\n            }\n            else {\n                if (teardown instanceof Subscription) {\n                    if (teardown.closed || teardown._hasParent(this)) {\n                        return;\n                    }\n                    teardown._addParent(this);\n                }\n                (this._teardowns = (_a = this._teardowns) !== null && _a !== void 0 ? _a : []).push(teardown);\n            }\n        }\n    };\n    Subscription.prototype._hasParent = function (parent) {\n        var _parentage = this._parentage;\n        return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));\n    };\n    Subscription.prototype._addParent = function (parent) {\n        var _parentage = this._parentage;\n        this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;\n    };\n    Subscription.prototype._removeParent = function (parent) {\n        var _parentage = this._parentage;\n        if (_parentage === parent) {\n            this._parentage = null;\n        }\n        else if (Array.isArray(_parentage)) {\n            arrRemove(_parentage, parent);\n        }\n    };\n    Subscription.prototype.remove = function (teardown) {\n        var _teardowns = this._teardowns;\n        _teardowns && arrRemove(_teardowns, teardown);\n        if (teardown instanceof Subscription) {\n            teardown._removeParent(this);\n        }\n    };\n    Subscription.EMPTY = (function () {\n        var empty = new Subscription();\n        empty.closed = true;\n        return empty;\n    })();\n    return Subscription;\n}());\nexport { Subscription };\nexport var EMPTY_SUBSCRIPTION = Subscription.EMPTY;\nexport function isSubscription(value) {\n    return (value instanceof Subscription ||\n        (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));\n}\nfunction execTeardown(teardown) {\n    if (isFunction(teardown)) {\n        teardown();\n    }\n    else {\n        teardown.unsubscribe();\n    }\n}\n//# sourceMappingURL=Subscription.js.map","export var config = {\n    onUnhandledError: null,\n    onStoppedNotification: null,\n    Promise: undefined,\n    useDeprecatedSynchronousErrorHandling: false,\n    useDeprecatedNextContext: false,\n};\n//# sourceMappingURL=config.js.map","import { __extends } from \"tslib\";\nimport { Subscriber } from '../Subscriber';\nvar OperatorSubscriber = (function (_super) {\n    __extends(OperatorSubscriber, _super);\n    function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {\n        var _this = _super.call(this, destination) || this;\n        _this.onFinalize = onFinalize;\n        _this._next = onNext\n            ? function (value) {\n                try {\n                    onNext(value);\n                }\n                catch (err) {\n                    destination.error(err);\n                }\n            }\n            : _super.prototype._next;\n        _this._error = onError\n            ? function (err) {\n                try {\n                    onError(err);\n                }\n                catch (err) {\n                    destination.error(err);\n                }\n                finally {\n                    this.unsubscribe();\n                }\n            }\n            : _super.prototype._error;\n        _this._complete = onComplete\n            ? function () {\n                try {\n                    onComplete();\n                }\n                catch (err) {\n                    destination.error(err);\n                }\n                finally {\n                    this.unsubscribe();\n                }\n            }\n            : _super.prototype._complete;\n        return _this;\n    }\n    OperatorSubscriber.prototype.unsubscribe = function () {\n        var _a;\n        var closed = this.closed;\n        _super.prototype.unsubscribe.call(this);\n        !closed && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));\n    };\n    return OperatorSubscriber;\n}(Subscriber));\nexport { OperatorSubscriber };\n//# sourceMappingURL=OperatorSubscriber.js.map","import { operate } from '../util/lift';\nimport { OperatorSubscriber } from './OperatorSubscriber';\nexport function filter(predicate, thisArg) {\n    return operate(function (source, subscriber) {\n        var index = 0;\n        source.subscribe(new OperatorSubscriber(subscriber, function (value) { return predicate.call(thisArg, value, index++) && subscriber.next(value); }));\n    });\n}\n//# sourceMappingURL=filter.js.map","import { operate } from '../util/lift';\nimport { OperatorSubscriber } from './OperatorSubscriber';\nexport function map(project, thisArg) {\n    return operate(function (source, subscriber) {\n        var index = 0;\n        source.subscribe(new OperatorSubscriber(subscriber, function (value) {\n            subscriber.next(project.call(thisArg, value, index++));\n        }));\n    });\n}\n//# sourceMappingURL=map.js.map","import { __read, __spreadArray } from \"tslib\";\nexport var timeoutProvider = {\n    setTimeout: function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var delegate = timeoutProvider.delegate;\n        return ((delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) || setTimeout).apply(void 0, __spreadArray([], __read(args)));\n    },\n    clearTimeout: function (handle) {\n        var delegate = timeoutProvider.delegate;\n        return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);\n    },\n    delegate: undefined,\n};\n//# sourceMappingURL=timeoutProvider.js.map","export function arrRemove(arr, item) {\n    if (arr) {\n        var index = arr.indexOf(item);\n        0 <= index && arr.splice(index, 1);\n    }\n}\n//# sourceMappingURL=arrRemove.js.map","export function createErrorClass(createImpl) {\n    var _super = function (instance) {\n        Error.call(instance);\n        instance.stack = new Error().stack;\n    };\n    var ctorFunc = createImpl(_super);\n    ctorFunc.prototype = Object.create(Error.prototype);\n    ctorFunc.prototype.constructor = ctorFunc;\n    return ctorFunc;\n}\n//# sourceMappingURL=createErrorClass.js.map","import { config } from '../config';\nvar context = null;\nexport function errorContext(cb) {\n    if (config.useDeprecatedSynchronousErrorHandling) {\n        var isRoot = !context;\n        if (isRoot) {\n            context = { errorThrown: false, error: null };\n        }\n        cb();\n        if (isRoot) {\n            var _a = context, errorThrown = _a.errorThrown, error = _a.error;\n            context = null;\n            if (errorThrown) {\n                throw error;\n            }\n        }\n    }\n    else {\n        cb();\n    }\n}\nexport function captureError(err) {\n    if (config.useDeprecatedSynchronousErrorHandling && context) {\n        context.errorThrown = true;\n        context.error = err;\n    }\n}\n//# sourceMappingURL=errorContext.js.map","export function isFunction(value) {\n    return typeof value === 'function';\n}\n//# sourceMappingURL=isFunction.js.map","import { isFunction } from './isFunction';\nexport function hasLift(source) {\n    return isFunction(source === null || source === void 0 ? void 0 : source.lift);\n}\nexport function operate(init) {\n    return function (source) {\n        if (hasLift(source)) {\n            return source.lift(function (liftedSource) {\n                try {\n                    return init(liftedSource, this);\n                }\n                catch (err) {\n                    this.error(err);\n                }\n            });\n        }\n        throw new TypeError('Unable to lift unknown Observable type');\n    };\n}\n//# sourceMappingURL=lift.js.map","export function noop() { }\n//# sourceMappingURL=noop.js.map","import { config } from '../config';\nimport { timeoutProvider } from '../scheduler/timeoutProvider';\nexport function reportUnhandledError(err) {\n    timeoutProvider.setTimeout(function () {\n        var onUnhandledError = config.onUnhandledError;\n        if (onUnhandledError) {\n            onUnhandledError(err);\n        }\n        else {\n            throw err;\n        }\n    });\n}\n//# sourceMappingURL=reportUnhandledError.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","var has = Object.prototype.hasOwnProperty;\n\nexport function dequal(foo, bar) {\n\tvar ctor, len;\n\tif (foo === bar) return true;\n\n\tif (foo && bar && (ctor=foo.constructor) === bar.constructor) {\n\t\tif (ctor === Date) return foo.getTime() === bar.getTime();\n\t\tif (ctor === RegExp) return foo.toString() === bar.toString();\n\n\t\tif (ctor === Array) {\n\t\t\tif ((len=foo.length) === bar.length) {\n\t\t\t\twhile (len-- && dequal(foo[len], bar[len]));\n\t\t\t}\n\t\t\treturn len === -1;\n\t\t}\n\n\t\tif (!ctor || typeof foo === 'object') {\n\t\t\tlen = 0;\n\t\t\tfor (ctor in foo) {\n\t\t\t\tif (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;\n\t\t\t\tif (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;\n\t\t\t}\n\t\t\treturn Object.keys(bar).length === len;\n\t\t}\n\t}\n\n\treturn foo !== foo && bar !== bar;\n}\n","// use WeakMap to store the object->key mapping\n// so the objects can be garbage collected.\n// WeakMap uses a hashtable under the hood, so the lookup\n// complexity is almost O(1).\nvar table = new WeakMap();\n// counter of the key\nvar counter = 0;\n// hashes an array of objects and returns a string\nexport default function hash(args) {\n    if (!args.length)\n        return '';\n    var key = 'arg';\n    for (var i = 0; i < args.length; ++i) {\n        if (args[i] === null) {\n            key += '@null';\n            continue;\n        }\n        var _hash = void 0;\n        if (typeof args[i] !== 'object' && typeof args[i] !== 'function') {\n            // need to consider the case that args[i] is a string:\n            // args[i]        _hash\n            // \"undefined\" -> '\"undefined\"'\n            // undefined   -> 'undefined'\n            // 123         -> '123'\n            // \"null\"      -> '\"null\"'\n            if (typeof args[i] === 'string') {\n                _hash = '\"' + args[i] + '\"';\n            }\n            else {\n                _hash = String(args[i]);\n            }\n        }\n        else {\n            if (!table.has(args[i])) {\n                _hash = counter;\n                table.set(args[i], counter++);\n            }\n            else {\n                _hash = table.get(args[i]);\n            }\n        }\n        key += '@' + _hash;\n    }\n    return key;\n}\n","import hash from './libs/hash';\nvar Cache = /** @class */ (function () {\n    function Cache(initialData) {\n        if (initialData === void 0) { initialData = {}; }\n        this.cache = new Map(Object.entries(initialData));\n        this.subs = [];\n    }\n    Cache.prototype.get = function (key) {\n        var _key = this.serializeKey(key)[0];\n        return this.cache.get(_key);\n    };\n    Cache.prototype.set = function (key, value) {\n        var _key = this.serializeKey(key)[0];\n        this.cache.set(_key, value);\n        this.notify();\n    };\n    Cache.prototype.keys = function () {\n        return Array.from(this.cache.keys());\n    };\n    Cache.prototype.has = function (key) {\n        var _key = this.serializeKey(key)[0];\n        return this.cache.has(_key);\n    };\n    Cache.prototype.clear = function () {\n        this.cache.clear();\n        this.notify();\n    };\n    Cache.prototype.delete = function (key) {\n        var _key = this.serializeKey(key)[0];\n        this.cache.delete(_key);\n        this.notify();\n    };\n    // TODO: introduce namespace for the cache\n    Cache.prototype.serializeKey = function (key) {\n        var args = null;\n        if (typeof key === 'function') {\n            try {\n                key = key();\n            }\n            catch (err) {\n                // dependencies not ready\n                key = '';\n            }\n        }\n        if (Array.isArray(key)) {\n            // args array\n            args = key;\n            key = hash(key);\n        }\n        else {\n            // convert null to ''\n            key = String(key || '');\n        }\n        var errorKey = key ? 'err@' + key : '';\n        var isValidatingKey = key ? 'validating@' + key : '';\n        return [key, args, errorKey, isValidatingKey];\n    };\n    Cache.prototype.subscribe = function (listener) {\n        var _this = this;\n        if (typeof listener !== 'function') {\n            throw new Error('Expected the listener to be a function.');\n        }\n        var isSubscribed = true;\n        this.subs.push(listener);\n        return function () {\n            if (!isSubscribed)\n                return;\n            isSubscribed = false;\n            var index = _this.subs.indexOf(listener);\n            if (index > -1) {\n                _this.subs[index] = _this.subs[_this.subs.length - 1];\n                _this.subs.length--;\n            }\n        };\n    };\n    // Notify Cache subscribers about a change in the cache\n    Cache.prototype.notify = function () {\n        for (var _i = 0, _a = this.subs; _i < _a.length; _i++) {\n            var listener = _a[_i];\n            listener();\n        }\n    };\n    return Cache;\n}());\nexport default Cache;\n","/**\n * Due to bug https://bugs.chromium.org/p/chromium/issues/detail?id=678075,\n * it's not reliable to detect if the browser is currently online or offline\n * based on `navigator.onLine`.\n * As a work around, we always assume it's online on first load, and change\n * the status upon `online` or `offline` events.\n */\nvar online = true;\nvar isOnline = function () { return online; };\nvar isDocumentVisible = function () {\n    if (typeof document !== 'undefined' &&\n        document.visibilityState !== undefined) {\n        return document.visibilityState !== 'hidden';\n    }\n    // always assume it's visible\n    return true;\n};\nvar fetcher = function (url) { return fetch(url).then(function (res) { return res.json(); }); };\nvar registerOnFocus = function (cb) {\n    if (typeof window !== 'undefined' &&\n        window.addEventListener !== undefined &&\n        typeof document !== 'undefined' &&\n        document.addEventListener !== undefined) {\n        // focus revalidate\n        document.addEventListener('visibilitychange', function () { return cb(); }, false);\n        window.addEventListener('focus', function () { return cb(); }, false);\n    }\n};\nvar registerOnReconnect = function (cb) {\n    if (typeof window !== 'undefined' && window.addEventListener !== undefined) {\n        // reconnect revalidate\n        window.addEventListener('online', function () {\n            online = true;\n            cb();\n        }, false);\n        // nothing to revalidate, just update the status\n        window.addEventListener('offline', function () { return (online = false); }, false);\n    }\n};\nexport default {\n    isOnline: isOnline,\n    isDocumentVisible: isDocumentVisible,\n    fetcher: fetcher,\n    registerOnFocus: registerOnFocus,\n    registerOnReconnect: registerOnReconnect\n};\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport { dequal } from 'dequal/lite';\nimport Cache from './cache';\nimport webPreset from './libs/web-preset';\n// cache\nvar cache = new Cache();\n// error retry\nfunction onErrorRetry(_, __, config, revalidate, opts) {\n    if (!config.isDocumentVisible()) {\n        // if it's hidden, stop\n        // it will auto revalidate when focus\n        return;\n    }\n    if (typeof config.errorRetryCount === 'number' &&\n        opts.retryCount > config.errorRetryCount) {\n        return;\n    }\n    // exponential backoff\n    var count = Math.min(opts.retryCount, 8);\n    var timeout = ~~((Math.random() + 0.5) * (1 << count)) * config.errorRetryInterval;\n    setTimeout(revalidate, timeout, opts);\n}\n// client side: need to adjust the config\n// based on the browser status\n// slow connection (<= 70Kbps)\nvar slowConnection = typeof window !== 'undefined' &&\n    // @ts-ignore\n    navigator['connection'] &&\n    // @ts-ignore\n    ['slow-2g', '2g'].indexOf(navigator['connection'].effectiveType) !== -1;\n// config\nvar defaultConfig = __assign({ \n    // events\n    onLoadingSlow: function () { }, onSuccess: function () { }, onError: function () { }, onErrorRetry: onErrorRetry, errorRetryInterval: (slowConnection ? 10 : 5) * 1000, focusThrottleInterval: 5 * 1000, dedupingInterval: 2 * 1000, loadingTimeout: (slowConnection ? 5 : 3) * 1000, refreshInterval: 0, revalidateOnFocus: true, revalidateOnReconnect: true, refreshWhenHidden: false, refreshWhenOffline: false, shouldRetryOnError: true, suspense: false, compare: dequal, isPaused: function () { return false; } }, webPreset);\nexport { cache };\nexport default defaultConfig;\n","import { useEffect, useLayoutEffect } from 'react';\nexport var IS_SERVER = typeof window === 'undefined' ||\n    // @ts-ignore\n    !!(typeof Deno !== 'undefined' && Deno && Deno.version && Deno.version.deno);\n// polyfill for requestAnimationFrame\nexport var rAF = IS_SERVER\n    ? null\n    : window['requestAnimationFrame']\n        ? function (f) { return window['requestAnimationFrame'](f); }\n        : function (f) { return setTimeout(f, 1); };\n// React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser.\nexport var useIsomorphicLayoutEffect = IS_SERVER ? useEffect : useLayoutEffect;\n","import { createContext } from 'react';\nvar SWRConfigContext = createContext({});\nSWRConfigContext.displayName = 'SWRConfigContext';\nexport default SWRConfigContext;\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\n// TODO: use @ts-expect-error\nimport { useCallback, useContext, useState, useRef, useMemo, useDebugValue } from 'react';\nimport defaultConfig, { cache } from './config';\nimport { IS_SERVER, rAF, useIsomorphicLayoutEffect } from './env';\nimport SWRConfigContext from './swr-config-context';\n// global state managers\nvar CONCURRENT_PROMISES = {};\nvar CONCURRENT_PROMISES_TS = {};\nvar FOCUS_REVALIDATORS = {};\nvar RECONNECT_REVALIDATORS = {};\nvar CACHE_REVALIDATORS = {};\nvar MUTATION_TS = {};\nvar MUTATION_END_TS = {};\n// generate strictly increasing timestamps\nvar now = (function () {\n    var ts = 0;\n    return function () { return ++ts; };\n})();\n// setup DOM events listeners for `focus` and `reconnect` actions\nif (!IS_SERVER) {\n    var revalidate_1 = function (revalidators) {\n        if (!defaultConfig.isDocumentVisible() || !defaultConfig.isOnline())\n            return;\n        for (var key in revalidators) {\n            if (revalidators[key][0])\n                revalidators[key][0]();\n        }\n    };\n    if (typeof defaultConfig.registerOnFocus === 'function') {\n        defaultConfig.registerOnFocus(function () { return revalidate_1(FOCUS_REVALIDATORS); });\n    }\n    if (typeof defaultConfig.registerOnReconnect === 'function') {\n        defaultConfig.registerOnReconnect(function () { return revalidate_1(RECONNECT_REVALIDATORS); });\n    }\n}\nvar trigger = function (_key, shouldRevalidate) {\n    if (shouldRevalidate === void 0) { shouldRevalidate = true; }\n    // we are ignoring the second argument which correspond to the arguments\n    // the fetcher will receive when key is an array\n    var _a = cache.serializeKey(_key), key = _a[0], keyErr = _a[2], keyValidating = _a[3];\n    if (!key)\n        return Promise.resolve();\n    var updaters = CACHE_REVALIDATORS[key];\n    if (key && updaters) {\n        var currentData = cache.get(key);\n        var currentError = cache.get(keyErr);\n        var currentIsValidating = cache.get(keyValidating);\n        var promises = [];\n        for (var i = 0; i < updaters.length; ++i) {\n            promises.push(updaters[i](shouldRevalidate, currentData, currentError, currentIsValidating, i > 0));\n        }\n        // return new updated value\n        return Promise.all(promises).then(function () { return cache.get(key); });\n    }\n    return Promise.resolve(cache.get(key));\n};\nvar broadcastState = function (key, data, error, isValidating) {\n    var updaters = CACHE_REVALIDATORS[key];\n    if (key && updaters) {\n        for (var i = 0; i < updaters.length; ++i) {\n            updaters[i](false, data, error, isValidating);\n        }\n    }\n};\nvar mutate = function (_key, _data, shouldRevalidate) {\n    if (shouldRevalidate === void 0) { shouldRevalidate = true; }\n    return __awaiter(void 0, void 0, void 0, function () {\n        var _a, key, keyErr, beforeMutationTs, beforeConcurrentPromisesTs, data, error, isAsyncMutation, err_1, shouldAbort, updaters, promises, i;\n        return __generator(this, function (_b) {\n            switch (_b.label) {\n                case 0:\n                    _a = cache.serializeKey(_key), key = _a[0], keyErr = _a[2];\n                    if (!key)\n                        return [2 /*return*/];\n                    // if there is no new data to update, let's just revalidate the key\n                    if (typeof _data === 'undefined')\n                        return [2 /*return*/, trigger(_key, shouldRevalidate)\n                            // update global timestamps\n                        ];\n                    // update global timestamps\n                    MUTATION_TS[key] = now() - 1;\n                    MUTATION_END_TS[key] = 0;\n                    beforeMutationTs = MUTATION_TS[key];\n                    beforeConcurrentPromisesTs = CONCURRENT_PROMISES_TS[key];\n                    isAsyncMutation = false;\n                    if (_data && typeof _data === 'function') {\n                        // `_data` is a function, call it passing current cache value\n                        try {\n                            _data = _data(cache.get(key));\n                        }\n                        catch (err) {\n                            // if `_data` function throws an error synchronously, it shouldn't be cached\n                            _data = undefined;\n                            error = err;\n                        }\n                    }\n                    if (!(_data && typeof _data.then === 'function')) return [3 /*break*/, 5];\n                    // `_data` is a promise\n                    isAsyncMutation = true;\n                    _b.label = 1;\n                case 1:\n                    _b.trys.push([1, 3, , 4]);\n                    return [4 /*yield*/, _data];\n                case 2:\n                    data = _b.sent();\n                    return [3 /*break*/, 4];\n                case 3:\n                    err_1 = _b.sent();\n                    error = err_1;\n                    return [3 /*break*/, 4];\n                case 4: return [3 /*break*/, 6];\n                case 5:\n                    data = _data;\n                    _b.label = 6;\n                case 6:\n                    shouldAbort = function () {\n                        // check if other mutations have occurred since we've started this mutation\n                        if (beforeMutationTs !== MUTATION_TS[key] ||\n                            beforeConcurrentPromisesTs !== CONCURRENT_PROMISES_TS[key]) {\n                            if (error)\n                                throw error;\n                            return true;\n                        }\n                    };\n                    // if there's a race we don't update cache or broadcast change, just return the data\n                    if (shouldAbort())\n                        return [2 /*return*/, data];\n                    if (typeof data !== 'undefined') {\n                        // update cached data\n                        cache.set(key, data);\n                    }\n                    // always update or reset the error\n                    cache.set(keyErr, error);\n                    // reset the timestamp to mark the mutation has ended\n                    MUTATION_END_TS[key] = now() - 1;\n                    if (!isAsyncMutation) {\n                        // we skip broadcasting if there's another mutation happened synchronously\n                        if (shouldAbort())\n                            return [2 /*return*/, data];\n                    }\n                    updaters = CACHE_REVALIDATORS[key];\n                    if (updaters) {\n                        promises = [];\n                        for (i = 0; i < updaters.length; ++i) {\n                            promises.push(updaters[i](!!shouldRevalidate, data, error, undefined, i > 0));\n                        }\n                        // return new updated value\n                        return [2 /*return*/, Promise.all(promises).then(function () {\n                                if (error)\n                                    throw error;\n                                return cache.get(key);\n                            })];\n                    }\n                    // throw error or return data to be used by caller of mutate\n                    if (error)\n                        throw error;\n                    return [2 /*return*/, data];\n            }\n        });\n    });\n};\nfunction useSWR() {\n    var _this = this;\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var _key = args[0];\n    var config = Object.assign({}, defaultConfig, useContext(SWRConfigContext), args.length > 2\n        ? args[2]\n        : args.length === 2 && typeof args[1] === 'object'\n            ? args[1]\n            : {});\n    // in typescript args.length > 2 is not same as args.lenth === 3\n    // we do a safe type assertion here\n    // args.length === 3\n    var fn = (args.length > 2\n        ? args[1]\n        : args.length === 2 && typeof args[1] === 'function'\n            ? args[1]\n            : /**\n                  pass fn as null will disable revalidate\n                  https://paco.sh/blog/shared-hook-state-with-swr\n                */\n                args[1] === null\n                    ? args[1]\n                    : config.fetcher);\n    // we assume `key` as the identifier of the request\n    // `key` can change but `fn` shouldn't\n    // (because `revalidate` only depends on `key`)\n    // `keyErr` is the cache key for error objects\n    var _a = cache.serializeKey(_key), key = _a[0], fnArgs = _a[1], keyErr = _a[2], keyValidating = _a[3];\n    var configRef = useRef(config);\n    useIsomorphicLayoutEffect(function () {\n        configRef.current = config;\n    });\n    var willRevalidateOnMount = function () {\n        return (config.revalidateOnMount ||\n            (!config.initialData && config.revalidateOnMount === undefined));\n    };\n    var resolveData = function () {\n        var cachedData = cache.get(key);\n        return typeof cachedData === 'undefined' ? config.initialData : cachedData;\n    };\n    var resolveIsValidating = function () {\n        return !!cache.get(keyValidating) || (key && willRevalidateOnMount());\n    };\n    var initialData = resolveData();\n    var initialError = cache.get(keyErr);\n    var initialIsValidating = resolveIsValidating();\n    // if a state is accessed (data, error or isValidating),\n    // we add the state to dependencies so if the state is\n    // updated in the future, we can trigger a rerender\n    var stateDependencies = useRef({\n        data: false,\n        error: false,\n        isValidating: false\n    });\n    var stateRef = useRef({\n        data: initialData,\n        error: initialError,\n        isValidating: initialIsValidating\n    });\n    // display the data label in the React DevTools next to SWR hooks\n    useDebugValue(stateRef.current.data);\n    var rerender = useState({})[1];\n    var dispatch = useCallback(function (payload) {\n        var shouldUpdateState = false;\n        for (var k in payload) {\n            // @ts-ignore\n            if (stateRef.current[k] === payload[k]) {\n                continue;\n            }\n            // @ts-ignore\n            stateRef.current[k] = payload[k];\n            // @ts-ignore\n            if (stateDependencies.current[k]) {\n                shouldUpdateState = true;\n            }\n        }\n        if (shouldUpdateState) {\n            // if component is unmounted, should skip rerender\n            // if component is not mounted, should skip rerender\n            if (unmountedRef.current || !initialMountedRef.current)\n                return;\n            rerender({});\n        }\n    }, \n    // config.suspense isn't allowed to change during the lifecycle\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    []);\n    // error ref inside revalidate (is last request errored?)\n    var unmountedRef = useRef(false);\n    var keyRef = useRef(key);\n    // check if component is mounted in suspense mode\n    var initialMountedRef = useRef(false);\n    // do unmount check for callbacks\n    var eventsCallback = useCallback(function (event) {\n        var _a;\n        var params = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            params[_i - 1] = arguments[_i];\n        }\n        if (unmountedRef.current)\n            return;\n        if (!initialMountedRef.current)\n            return;\n        if (key !== keyRef.current)\n            return;\n        // @ts-ignore\n        (_a = configRef.current)[event].apply(_a, params);\n    }, [key]);\n    var boundMutate = useCallback(function (data, shouldRevalidate) {\n        return mutate(keyRef.current, data, shouldRevalidate);\n    }, []);\n    var addRevalidator = function (revalidators, callback) {\n        if (!revalidators[key]) {\n            revalidators[key] = [callback];\n        }\n        else {\n            revalidators[key].push(callback);\n        }\n        return function () {\n            var keyedRevalidators = revalidators[key];\n            var index = keyedRevalidators.indexOf(callback);\n            if (index >= 0) {\n                // O(1): faster than splice\n                keyedRevalidators[index] =\n                    keyedRevalidators[keyedRevalidators.length - 1];\n                keyedRevalidators.pop();\n            }\n        };\n    };\n    // start a revalidation\n    var revalidate = useCallback(function (revalidateOpts) {\n        if (revalidateOpts === void 0) { revalidateOpts = {}; }\n        return __awaiter(_this, void 0, void 0, function () {\n            var _a, retryCount, _b, dedupe, loading, shouldDeduping, newData, startAt, newState, err_2;\n            return __generator(this, function (_c) {\n                switch (_c.label) {\n                    case 0:\n                        if (!key || !fn)\n                            return [2 /*return*/, false];\n                        if (unmountedRef.current)\n                            return [2 /*return*/, false];\n                        if (configRef.current.isPaused())\n                            return [2 /*return*/, false];\n                        _a = revalidateOpts.retryCount, retryCount = _a === void 0 ? 0 : _a, _b = revalidateOpts.dedupe, dedupe = _b === void 0 ? false : _b;\n                        loading = true;\n                        shouldDeduping = typeof CONCURRENT_PROMISES[key] !== 'undefined' && dedupe;\n                        _c.label = 1;\n                    case 1:\n                        _c.trys.push([1, 6, , 7]);\n                        dispatch({\n                            isValidating: true\n                        });\n                        cache.set(keyValidating, true);\n                        if (!shouldDeduping) {\n                            // also update other hooks\n                            broadcastState(key, stateRef.current.data, stateRef.current.error, true);\n                        }\n                        newData = void 0;\n                        startAt = void 0;\n                        if (!shouldDeduping) return [3 /*break*/, 3];\n                        // there's already an ongoing request,\n                        // this one needs to be deduplicated.\n                        startAt = CONCURRENT_PROMISES_TS[key];\n                        return [4 /*yield*/, CONCURRENT_PROMISES[key]];\n                    case 2:\n                        newData = _c.sent();\n                        return [3 /*break*/, 5];\n                    case 3:\n                        // if no cache being rendered currently (it shows a blank page),\n                        // we trigger the loading slow event.\n                        if (config.loadingTimeout && !cache.get(key)) {\n                            setTimeout(function () {\n                                if (loading)\n                                    eventsCallback('onLoadingSlow', key, config);\n                            }, config.loadingTimeout);\n                        }\n                        if (fnArgs !== null) {\n                            CONCURRENT_PROMISES[key] = fn.apply(void 0, fnArgs);\n                        }\n                        else {\n                            CONCURRENT_PROMISES[key] = fn(key);\n                        }\n                        CONCURRENT_PROMISES_TS[key] = startAt = now();\n                        return [4 /*yield*/, CONCURRENT_PROMISES[key]];\n                    case 4:\n                        newData = _c.sent();\n                        setTimeout(function () {\n                            delete CONCURRENT_PROMISES[key];\n                            delete CONCURRENT_PROMISES_TS[key];\n                        }, config.dedupingInterval);\n                        // trigger the success event,\n                        // only do this for the original request.\n                        eventsCallback('onSuccess', newData, key, config);\n                        _c.label = 5;\n                    case 5:\n                        // if there're other ongoing request(s), started after the current one,\n                        // we need to ignore the current one to avoid possible race conditions:\n                        //   req1------------------>res1        (current one)\n                        //        req2---------------->res2\n                        // the request that fired later will always be kept.\n                        if (CONCURRENT_PROMISES_TS[key] > startAt) {\n                            return [2 /*return*/, false];\n                        }\n                        // if there're other mutations(s), overlapped with the current revalidation:\n                        // case 1:\n                        //   req------------------>res\n                        //       mutate------>end\n                        // case 2:\n                        //         req------------>res\n                        //   mutate------>end\n                        // case 3:\n                        //   req------------------>res\n                        //       mutate-------...---------->\n                        // we have to ignore the revalidation result (res) because it's no longer fresh.\n                        // meanwhile, a new revalidation should be triggered when the mutation ends.\n                        if (MUTATION_TS[key] &&\n                            // case 1\n                            (startAt <= MUTATION_TS[key] ||\n                                // case 2\n                                startAt <= MUTATION_END_TS[key] ||\n                                // case 3\n                                MUTATION_END_TS[key] === 0)) {\n                            dispatch({ isValidating: false });\n                            return [2 /*return*/, false];\n                        }\n                        cache.set(keyErr, undefined);\n                        cache.set(keyValidating, false);\n                        newState = {\n                            isValidating: false\n                        };\n                        if (typeof stateRef.current.error !== 'undefined') {\n                            // we don't have an error\n                            newState.error = undefined;\n                        }\n                        if (!config.compare(stateRef.current.data, newData)) {\n                            // deep compare to avoid extra re-render\n                            // data changed\n                            newState.data = newData;\n                        }\n                        if (!config.compare(cache.get(key), newData)) {\n                            cache.set(key, newData);\n                        }\n                        // merge the new state\n                        dispatch(newState);\n                        if (!shouldDeduping) {\n                            // also update other hooks\n                            broadcastState(key, newData, newState.error, false);\n                        }\n                        return [3 /*break*/, 7];\n                    case 6:\n                        err_2 = _c.sent();\n                        delete CONCURRENT_PROMISES[key];\n                        delete CONCURRENT_PROMISES_TS[key];\n                        if (configRef.current.isPaused()) {\n                            dispatch({\n                                isValidating: false\n                            });\n                            return [2 /*return*/, false];\n                        }\n                        cache.set(keyErr, err_2);\n                        // get a new error\n                        // don't use deep equal for errors\n                        if (stateRef.current.error !== err_2) {\n                            // we keep the stale data\n                            dispatch({\n                                isValidating: false,\n                                error: err_2\n                            });\n                            if (!shouldDeduping) {\n                                // also broadcast to update other hooks\n                                broadcastState(key, undefined, err_2, false);\n                            }\n                        }\n                        // events and retry\n                        eventsCallback('onError', err_2, key, config);\n                        if (config.shouldRetryOnError) {\n                            // when retrying, we always enable deduping\n                            eventsCallback('onErrorRetry', err_2, key, config, revalidate, {\n                                retryCount: retryCount + 1,\n                                dedupe: true\n                            });\n                        }\n                        return [3 /*break*/, 7];\n                    case 7:\n                        loading = false;\n                        return [2 /*return*/, true];\n                }\n            });\n        });\n    }, \n    // dispatch is immutable, and `eventsCallback`, `fnArgs`, `keyErr`, and `keyValidating` are based on `key`,\n    // so we can them from the deps array.\n    //\n    // FIXME:\n    // `fn` and `config` might be changed during the lifecycle,\n    // but they might be changed every render like this.\n    // useSWR('key', () => fetch('/api/'), { suspense: true })\n    // So we omit the values from the deps array\n    // even though it might cause unexpected behaviors.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [key]);\n    // mounted (client side rendering)\n    useIsomorphicLayoutEffect(function () {\n        if (!key)\n            return undefined;\n        // after `key` updates, we need to mark it as mounted\n        unmountedRef.current = false;\n        var isUpdating = initialMountedRef.current;\n        initialMountedRef.current = true;\n        // after the component is mounted (hydrated),\n        // we need to update the data from the cache\n        // and trigger a revalidation\n        var currentHookData = stateRef.current.data;\n        var latestKeyedData = resolveData();\n        // update the state if the key changed (not the inital render) or cache updated\n        keyRef.current = key;\n        if (!config.compare(currentHookData, latestKeyedData)) {\n            dispatch({ data: latestKeyedData });\n        }\n        // revalidate with deduping\n        var softRevalidate = function () { return revalidate({ dedupe: true }); };\n        // trigger a revalidation\n        if (isUpdating || willRevalidateOnMount()) {\n            if (typeof latestKeyedData !== 'undefined' && !IS_SERVER) {\n                // delay revalidate if there's cache\n                // to not block the rendering\n                // @ts-ignore it's safe to use requestAnimationFrame in browser\n                rAF(softRevalidate);\n            }\n            else {\n                softRevalidate();\n            }\n        }\n        var pending = false;\n        var onFocus = function () {\n            if (pending || !configRef.current.revalidateOnFocus)\n                return;\n            pending = true;\n            softRevalidate();\n            setTimeout(function () { return (pending = false); }, configRef.current.focusThrottleInterval);\n        };\n        var onReconnect = function () {\n            if (configRef.current.revalidateOnReconnect) {\n                softRevalidate();\n            }\n        };\n        // register global cache update listener\n        var onUpdate = function (shouldRevalidate, updatedData, updatedError, updatedIsValidating, dedupe) {\n            if (shouldRevalidate === void 0) { shouldRevalidate = true; }\n            if (dedupe === void 0) { dedupe = true; }\n            // update hook state\n            var newState = {};\n            var needUpdate = false;\n            if (typeof updatedData !== 'undefined' &&\n                !config.compare(stateRef.current.data, updatedData)) {\n                newState.data = updatedData;\n                needUpdate = true;\n            }\n            // always update error\n            // because it can be `undefined`\n            if (stateRef.current.error !== updatedError) {\n                newState.error = updatedError;\n                needUpdate = true;\n            }\n            if (typeof updatedIsValidating !== 'undefined' &&\n                stateRef.current.isValidating !== updatedIsValidating) {\n                newState.isValidating = updatedIsValidating;\n                needUpdate = true;\n            }\n            if (needUpdate) {\n                dispatch(newState);\n            }\n            if (shouldRevalidate) {\n                if (dedupe) {\n                    return softRevalidate();\n                }\n                else {\n                    return revalidate();\n                }\n            }\n            return false;\n        };\n        var unsubFocus = addRevalidator(FOCUS_REVALIDATORS, onFocus);\n        var unsubReconnect = addRevalidator(RECONNECT_REVALIDATORS, onReconnect);\n        var unsubUpdate = addRevalidator(CACHE_REVALIDATORS, onUpdate);\n        return function () {\n            // cleanup\n            dispatch = function () { return null; };\n            // mark it as unmounted\n            unmountedRef.current = true;\n            unsubFocus();\n            unsubReconnect();\n            unsubUpdate();\n        };\n    }, [key, revalidate]);\n    useIsomorphicLayoutEffect(function () {\n        var timer = null;\n        var tick = function () { return __awaiter(_this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        if (!(!stateRef.current.error &&\n                            (configRef.current.refreshWhenHidden ||\n                                configRef.current.isDocumentVisible()) &&\n                            (configRef.current.refreshWhenOffline || configRef.current.isOnline()))) return [3 /*break*/, 2];\n                        // only revalidate when the page is visible\n                        // if API request errored, we stop polling in this round\n                        // and let the error retry function handle it\n                        return [4 /*yield*/, revalidate({ dedupe: true })];\n                    case 1:\n                        // only revalidate when the page is visible\n                        // if API request errored, we stop polling in this round\n                        // and let the error retry function handle it\n                        _a.sent();\n                        _a.label = 2;\n                    case 2:\n                        // Read the latest refreshInterval\n                        if (configRef.current.refreshInterval && timer) {\n                            timer = setTimeout(tick, configRef.current.refreshInterval);\n                        }\n                        return [2 /*return*/];\n                }\n            });\n        }); };\n        if (configRef.current.refreshInterval) {\n            timer = setTimeout(tick, configRef.current.refreshInterval);\n        }\n        return function () {\n            if (timer) {\n                clearTimeout(timer);\n                timer = null;\n            }\n        };\n    }, [\n        config.refreshInterval,\n        config.refreshWhenHidden,\n        config.refreshWhenOffline,\n        revalidate\n    ]);\n    // suspense\n    var latestData;\n    var latestError;\n    if (config.suspense) {\n        // in suspense mode, we can't return empty state\n        // (it should be suspended)\n        // try to get data and error from cache\n        latestData = cache.get(key);\n        latestError = cache.get(keyErr);\n        if (typeof latestData === 'undefined') {\n            latestData = initialData;\n        }\n        if (typeof latestError === 'undefined') {\n            latestError = initialError;\n        }\n        if (typeof latestData === 'undefined' &&\n            typeof latestError === 'undefined') {\n            // need to start the request if it hasn't\n            if (!CONCURRENT_PROMISES[key]) {\n                // trigger revalidate immediately\n                // to get the promise\n                // in this revalidate, should not rerender\n                revalidate();\n            }\n            if (CONCURRENT_PROMISES[key] &&\n                typeof CONCURRENT_PROMISES[key].then === 'function') {\n                // if it is a promise\n                throw CONCURRENT_PROMISES[key];\n            }\n            // it's a value, return it directly (override)\n            latestData = CONCURRENT_PROMISES[key];\n        }\n        if (typeof latestData === 'undefined' && latestError) {\n            // in suspense mode, throw error if there's no content\n            throw latestError;\n        }\n    }\n    // define returned state\n    // can be memorized since the state is a ref\n    var memoizedState = useMemo(function () {\n        // revalidate will be deprecated in the 1.x release\n        // because mutate() covers the same use case of revalidate().\n        // This remains only for backward compatibility\n        var state = { revalidate: revalidate, mutate: boundMutate };\n        Object.defineProperties(state, {\n            error: {\n                // `key` might be changed in the upcoming hook re-render,\n                // but the previous state will stay\n                // so we need to match the latest key and data (fallback to `initialData`)\n                get: function () {\n                    stateDependencies.current.error = true;\n                    if (config.suspense) {\n                        return latestError;\n                    }\n                    return keyRef.current === key ? stateRef.current.error : initialError;\n                },\n                enumerable: true\n            },\n            data: {\n                get: function () {\n                    stateDependencies.current.data = true;\n                    if (config.suspense) {\n                        return latestData;\n                    }\n                    return keyRef.current === key ? stateRef.current.data : initialData;\n                },\n                enumerable: true\n            },\n            isValidating: {\n                get: function () {\n                    stateDependencies.current.isValidating = true;\n                    return key ? stateRef.current.isValidating : false;\n                },\n                enumerable: true\n            }\n        });\n        return state;\n        // `config.suspense` isn't allowed to change during the lifecycle.\n        // `boundMutate` is immutable, and the immutability of `revalidate` depends on `key`\n        // so we can omit them from the deps array,\n        // but we put it to enable react-hooks/exhaustive-deps rule.\n        // `initialData` and `initialError` are not initial values\n        // because they are changed during the lifecycle\n        // so we should add them in the deps array.\n    }, [\n        revalidate,\n        initialData,\n        initialError,\n        boundMutate,\n        key,\n        config.suspense,\n        latestError,\n        latestData\n    ]);\n    return memoizedState;\n}\nObject.defineProperty(SWRConfigContext.Provider, 'default', {\n    value: defaultConfig\n});\nvar SWRConfig = SWRConfigContext.Provider;\nexport { trigger, mutate, SWRConfig };\nexport default useSWR;\n","// `useSWR` and related APIs\nimport { default as useSWR } from './use-swr';\nexport default useSWR;\nexport * from './use-swr';\n// `useSWRInfinite`\nexport { useSWRInfinite } from './use-swr-infinite';\n// Cache related, to be replaced by the new APIs\nexport { cache } from './config';\n","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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/AssertionError\n */\nimport { VERSION } from './util.js';\n/**\n * Error object thrown when an assertion failed. This is an ECMA-262 Error,\n * extended with a `code` property.\n * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error.\n */\nvar AssertionError = /** @class */ (function (_super) {\n    __extends(AssertionError, _super);\n    /**\n     * @param {number} code Error code.\n     */\n    function AssertionError(code) {\n        var _this = this;\n        var path = VERSION === 'latest' ? VERSION : 'v' + VERSION.split('-')[0];\n        var message = 'Assertion failed. See https://openlayers.org/en/' +\n            path +\n            '/doc/errors/#' +\n            code +\n            ' for details.';\n        _this = _super.call(this, message) || this;\n        /**\n         * Error code. The meaning of the code can be found on\n         * https://openlayers.org/en/latest/doc/errors/ (replace `latest` with\n         * the version found in the OpenLayers script's header comment if a version\n         * other than the latest is used).\n         * @type {number}\n         * @api\n         */\n        _this.code = code;\n        /**\n         * @type {string}\n         */\n        _this.name = 'AssertionError';\n        // Re-assign message, see https://github.com/Rich-Harris/buble/issues/40\n        _this.message = message;\n        return _this;\n    }\n    return AssertionError;\n}(Error));\nexport default AssertionError;\n//# sourceMappingURL=AssertionError.js.map","/**\n * @module ol/Disposable\n */\n/**\n * @classdesc\n * Objects that need to clean up after themselves.\n */\nvar Disposable = /** @class */ (function () {\n    function Disposable() {\n        /**\n         * The object has already been disposed.\n         * @type {boolean}\n         * @protected\n         */\n        this.disposed = false;\n    }\n    /**\n     * Clean up.\n     */\n    Disposable.prototype.dispose = function () {\n        if (!this.disposed) {\n            this.disposed = true;\n            this.disposeInternal();\n        }\n    };\n    /**\n     * Extension point for disposable objects.\n     * @protected\n     */\n    Disposable.prototype.disposeInternal = function () { };\n    return Disposable;\n}());\nexport default Disposable;\n//# sourceMappingURL=Disposable.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/Feature\n */\nimport BaseObject from './Object.js';\nimport EventType from './events/EventType.js';\nimport { assert } from './asserts.js';\nimport { listen, unlistenByKey } from './events.js';\n/**\n * @typedef {typeof Feature|typeof import(\"./render/Feature.js\").default} FeatureClass\n */\n/**\n * @typedef {Feature<import(\"./geom/Geometry.js\").default>|import(\"./render/Feature.js\").default} FeatureLike\n */\n/***\n * @template Return\n * @typedef {import(\"./Observable\").OnSignature<import(\"./Observable\").EventTypes, import(\"./events/Event.js\").default, Return> &\n *   import(\"./Observable\").OnSignature<import(\"./ObjectEventType\").Types|'change:geometry', import(\"./Object\").ObjectEvent, Return> &\n *   import(\"./Observable\").CombinedOnSignature<import(\"./Observable\").EventTypes|import(\"./ObjectEventType\").Types\n *     |'change:geometry', Return>} FeatureOnSignature\n */\n/***\n * @template Geometry\n * @typedef {Object<string, *> & { geometry?: Geometry }} ObjectWithGeometry\n */\n/**\n * @classdesc\n * A vector object for geographic features with a geometry and other\n * attribute properties, similar to the features in vector file formats like\n * GeoJSON.\n *\n * Features can be styled individually with `setStyle`; otherwise they use the\n * style of their vector layer.\n *\n * Note that attribute properties are set as {@link module:ol/Object} properties on\n * the feature object, so they are observable, and have get/set accessors.\n *\n * Typically, a feature has a single geometry property. You can set the\n * geometry using the `setGeometry` method and get it with `getGeometry`.\n * It is possible to store more than one geometry on a feature using attribute\n * properties. By default, the geometry used for rendering is identified by\n * the property name `geometry`. If you want to use another geometry property\n * for rendering, use the `setGeometryName` method to change the attribute\n * property associated with the geometry for the feature.  For example:\n *\n * ```js\n *\n * import Feature from 'ol/Feature';\n * import Polygon from 'ol/geom/Polygon';\n * import Point from 'ol/geom/Point';\n *\n * var feature = new Feature({\n *   geometry: new Polygon(polyCoords),\n *   labelPoint: new Point(labelCoords),\n *   name: 'My Polygon'\n * });\n *\n * // get the polygon geometry\n * var poly = feature.getGeometry();\n *\n * // Render the feature as a point using the coordinates from labelPoint\n * feature.setGeometryName('labelPoint');\n *\n * // get the point geometry\n * var point = feature.getGeometry();\n * ```\n *\n * @api\n * @template {import(\"./geom/Geometry.js\").default} Geometry\n */\nvar Feature = /** @class */ (function (_super) {\n    __extends(Feature, _super);\n    /**\n     * @param {Geometry|ObjectWithGeometry<Geometry>} [opt_geometryOrProperties]\n     *     You may pass a Geometry object directly, or an object literal containing\n     *     properties. If you pass an object literal, you may include a Geometry\n     *     associated with a `geometry` key.\n     */\n    function Feature(opt_geometryOrProperties) {\n        var _this = _super.call(this) || this;\n        /***\n         * @type {FeatureOnSignature<import(\"./events\").EventsKey>}\n         */\n        _this.on;\n        /***\n         * @type {FeatureOnSignature<import(\"./events\").EventsKey>}\n         */\n        _this.once;\n        /***\n         * @type {FeatureOnSignature<void>}\n         */\n        _this.un;\n        /**\n         * @private\n         * @type {number|string|undefined}\n         */\n        _this.id_ = undefined;\n        /**\n         * @type {string}\n         * @private\n         */\n        _this.geometryName_ = 'geometry';\n        /**\n         * User provided style.\n         * @private\n         * @type {import(\"./style/Style.js\").StyleLike}\n         */\n        _this.style_ = null;\n        /**\n         * @private\n         * @type {import(\"./style/Style.js\").StyleFunction|undefined}\n         */\n        _this.styleFunction_ = undefined;\n        /**\n         * @private\n         * @type {?import(\"./events.js\").EventsKey}\n         */\n        _this.geometryChangeKey_ = null;\n        _this.addChangeListener(_this.geometryName_, _this.handleGeometryChanged_);\n        if (opt_geometryOrProperties) {\n            if (typeof (\n            /** @type {?} */ (opt_geometryOrProperties).getSimplifiedGeometry) === 'function') {\n                var geometry = /** @type {Geometry} */ (opt_geometryOrProperties);\n                _this.setGeometry(geometry);\n            }\n            else {\n                /** @type {Object<string, *>} */\n                var properties = opt_geometryOrProperties;\n                _this.setProperties(properties);\n            }\n        }\n        return _this;\n    }\n    /**\n     * Clone this feature. If the original feature has a geometry it\n     * is also cloned. The feature id is not set in the clone.\n     * @return {Feature<Geometry>} The clone.\n     * @api\n     */\n    Feature.prototype.clone = function () {\n        var clone = /** @type {Feature<Geometry>} */ (new Feature(this.hasProperties() ? this.getProperties() : null));\n        clone.setGeometryName(this.getGeometryName());\n        var geometry = this.getGeometry();\n        if (geometry) {\n            clone.setGeometry(/** @type {Geometry} */ (geometry.clone()));\n        }\n        var style = this.getStyle();\n        if (style) {\n            clone.setStyle(style);\n        }\n        return clone;\n    };\n    /**\n     * Get the feature's default geometry.  A feature may have any number of named\n     * geometries.  The \"default\" geometry (the one that is rendered by default) is\n     * set when calling {@link module:ol/Feature~Feature#setGeometry}.\n     * @return {Geometry|undefined} The default geometry for the feature.\n     * @api\n     * @observable\n     */\n    Feature.prototype.getGeometry = function () {\n        return /** @type {Geometry|undefined} */ (this.get(this.geometryName_));\n    };\n    /**\n     * Get the feature identifier.  This is a stable identifier for the feature and\n     * is either set when reading data from a remote source or set explicitly by\n     * calling {@link module:ol/Feature~Feature#setId}.\n     * @return {number|string|undefined} Id.\n     * @api\n     */\n    Feature.prototype.getId = function () {\n        return this.id_;\n    };\n    /**\n     * Get the name of the feature's default geometry.  By default, the default\n     * geometry is named `geometry`.\n     * @return {string} Get the property name associated with the default geometry\n     *     for this feature.\n     * @api\n     */\n    Feature.prototype.getGeometryName = function () {\n        return this.geometryName_;\n    };\n    /**\n     * Get the feature's style. Will return what was provided to the\n     * {@link module:ol/Feature~Feature#setStyle} method.\n     * @return {import(\"./style/Style.js\").StyleLike|undefined} The feature style.\n     * @api\n     */\n    Feature.prototype.getStyle = function () {\n        return this.style_;\n    };\n    /**\n     * Get the feature's style function.\n     * @return {import(\"./style/Style.js\").StyleFunction|undefined} Return a function\n     * representing the current style of this feature.\n     * @api\n     */\n    Feature.prototype.getStyleFunction = function () {\n        return this.styleFunction_;\n    };\n    /**\n     * @private\n     */\n    Feature.prototype.handleGeometryChange_ = function () {\n        this.changed();\n    };\n    /**\n     * @private\n     */\n    Feature.prototype.handleGeometryChanged_ = function () {\n        if (this.geometryChangeKey_) {\n            unlistenByKey(this.geometryChangeKey_);\n            this.geometryChangeKey_ = null;\n        }\n        var geometry = this.getGeometry();\n        if (geometry) {\n            this.geometryChangeKey_ = listen(geometry, EventType.CHANGE, this.handleGeometryChange_, this);\n        }\n        this.changed();\n    };\n    /**\n     * Set the default geometry for the feature.  This will update the property\n     * with the name returned by {@link module:ol/Feature~Feature#getGeometryName}.\n     * @param {Geometry|undefined} geometry The new geometry.\n     * @api\n     * @observable\n     */\n    Feature.prototype.setGeometry = function (geometry) {\n        this.set(this.geometryName_, geometry);\n    };\n    /**\n     * Set the style for the feature to override the layer style.  This can be a\n     * single style object, an array of styles, or a function that takes a\n     * resolution and returns an array of styles. To unset the feature style, call\n     * `setStyle()` without arguments or a falsey value.\n     * @param {import(\"./style/Style.js\").StyleLike} [opt_style] Style for this feature.\n     * @api\n     * @fires module:ol/events/Event~BaseEvent#event:change\n     */\n    Feature.prototype.setStyle = function (opt_style) {\n        this.style_ = opt_style;\n        this.styleFunction_ = !opt_style\n            ? undefined\n            : createStyleFunction(opt_style);\n        this.changed();\n    };\n    /**\n     * Set the feature id.  The feature id is considered stable and may be used when\n     * requesting features or comparing identifiers returned from a remote source.\n     * The feature id can be used with the\n     * {@link module:ol/source/Vector~VectorSource#getFeatureById} method.\n     * @param {number|string|undefined} id The feature id.\n     * @api\n     * @fires module:ol/events/Event~BaseEvent#event:change\n     */\n    Feature.prototype.setId = function (id) {\n        this.id_ = id;\n        this.changed();\n    };\n    /**\n     * Set the property name to be used when getting the feature's default geometry.\n     * When calling {@link module:ol/Feature~Feature#getGeometry}, the value of the property with\n     * this name will be returned.\n     * @param {string} name The property name of the default geometry.\n     * @api\n     */\n    Feature.prototype.setGeometryName = function (name) {\n        this.removeChangeListener(this.geometryName_, this.handleGeometryChanged_);\n        this.geometryName_ = name;\n        this.addChangeListener(this.geometryName_, this.handleGeometryChanged_);\n        this.handleGeometryChanged_();\n    };\n    return Feature;\n}(BaseObject));\n/**\n * Convert the provided object into a feature style function.  Functions passed\n * through unchanged.  Arrays of Style or single style objects wrapped\n * in a new feature style function.\n * @param {!import(\"./style/Style.js\").StyleFunction|!Array<import(\"./style/Style.js\").default>|!import(\"./style/Style.js\").default} obj\n *     A feature style function, a single style, or an array of styles.\n * @return {import(\"./style/Style.js\").StyleFunction} A style function.\n */\nexport function createStyleFunction(obj) {\n    if (typeof obj === 'function') {\n        return obj;\n    }\n    else {\n        /**\n         * @type {Array<import(\"./style/Style.js\").default>}\n         */\n        var styles_1;\n        if (Array.isArray(obj)) {\n            styles_1 = obj;\n        }\n        else {\n            assert(typeof ( /** @type {?} */(obj).getZIndex) === 'function', 41); // Expected an `import(\"./style/Style.js\").Style` or an array of `import(\"./style/Style.js\").Style`\n            var style = /** @type {import(\"./style/Style.js\").default} */ (obj);\n            styles_1 = [style];\n        }\n        return function () {\n            return styles_1;\n        };\n    }\n}\nexport default Feature;\n//# sourceMappingURL=Feature.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/Object\n */\nimport Event from './events/Event.js';\nimport ObjectEventType from './ObjectEventType.js';\nimport Observable from './Observable.js';\nimport { assign, isEmpty } from './obj.js';\nimport { getUid } from './util.js';\n/**\n * @classdesc\n * Events emitted by {@link module:ol/Object~BaseObject} instances are instances of this type.\n */\nvar ObjectEvent = /** @class */ (function (_super) {\n    __extends(ObjectEvent, _super);\n    /**\n     * @param {string} type The event type.\n     * @param {string} key The property name.\n     * @param {*} oldValue The old value for `key`.\n     */\n    function ObjectEvent(type, key, oldValue) {\n        var _this = _super.call(this, type) || this;\n        /**\n         * The name of the property whose value is changing.\n         * @type {string}\n         * @api\n         */\n        _this.key = key;\n        /**\n         * The old value. To get the new value use `e.target.get(e.key)` where\n         * `e` is the event object.\n         * @type {*}\n         * @api\n         */\n        _this.oldValue = oldValue;\n        return _this;\n    }\n    return ObjectEvent;\n}(Event));\nexport { ObjectEvent };\n/***\n * @template Return\n * @typedef {import(\"./Observable\").OnSignature<import(\"./Observable\").EventTypes, import(\"./events/Event.js\").default, Return> &\n *    import(\"./Observable\").OnSignature<import(\"./ObjectEventType\").Types, ObjectEvent, Return> &\n *    import(\"./Observable\").CombinedOnSignature<import(\"./Observable\").EventTypes|import(\"./ObjectEventType\").Types, Return>} ObjectOnSignature\n */\n/**\n * @classdesc\n * Abstract base class; normally only used for creating subclasses and not\n * instantiated in apps.\n * Most non-trivial classes inherit from this.\n *\n * This extends {@link module:ol/Observable} with observable\n * properties, where each property is observable as well as the object as a\n * whole.\n *\n * Classes that inherit from this have pre-defined properties, to which you can\n * add your owns. The pre-defined properties are listed in this documentation as\n * 'Observable Properties', and have their own accessors; for example,\n * {@link module:ol/Map~Map} has a `target` property, accessed with\n * `getTarget()` and changed with `setTarget()`. Not all properties are however\n * settable. There are also general-purpose accessors `get()` and `set()`. For\n * example, `get('target')` is equivalent to `getTarget()`.\n *\n * The `set` accessors trigger a change event, and you can monitor this by\n * registering a listener. For example, {@link module:ol/View~View} has a\n * `center` property, so `view.on('change:center', function(evt) {...});` would\n * call the function whenever the value of the center property changes. Within\n * the function, `evt.target` would be the view, so `evt.target.getCenter()`\n * would return the new center.\n *\n * You can add your own observable properties with\n * `object.set('prop', 'value')`, and retrieve that with `object.get('prop')`.\n * You can listen for changes on that property value with\n * `object.on('change:prop', listener)`. You can get a list of all\n * properties with {@link module:ol/Object~BaseObject#getProperties}.\n *\n * Note that the observable properties are separate from standard JS properties.\n * You can, for example, give your map object a title with\n * `map.title='New title'` and with `map.set('title', 'Another title')`. The\n * first will be a `hasOwnProperty`; the second will appear in\n * `getProperties()`. Only the second is observable.\n *\n * Properties can be deleted by using the unset method. E.g.\n * object.unset('foo').\n *\n * @fires ObjectEvent\n * @api\n */\nvar BaseObject = /** @class */ (function (_super) {\n    __extends(BaseObject, _super);\n    /**\n     * @param {Object<string, *>} [opt_values] An object with key-value pairs.\n     */\n    function BaseObject(opt_values) {\n        var _this = _super.call(this) || this;\n        /***\n         * @type {ObjectOnSignature<import(\"./events\").EventsKey>}\n         */\n        _this.on;\n        /***\n         * @type {ObjectOnSignature<import(\"./events\").EventsKey>}\n         */\n        _this.once;\n        /***\n         * @type {ObjectOnSignature<void>}\n         */\n        _this.un;\n        // Call {@link module:ol/util.getUid} to ensure that the order of objects' ids is\n        // the same as the order in which they were created.  This also helps to\n        // ensure that object properties are always added in the same order, which\n        // helps many JavaScript engines generate faster code.\n        getUid(_this);\n        /**\n         * @private\n         * @type {Object<string, *>}\n         */\n        _this.values_ = null;\n        if (opt_values !== undefined) {\n            _this.setProperties(opt_values);\n        }\n        return _this;\n    }\n    /**\n     * Gets a value.\n     * @param {string} key Key name.\n     * @return {*} Value.\n     * @api\n     */\n    BaseObject.prototype.get = function (key) {\n        var value;\n        if (this.values_ && this.values_.hasOwnProperty(key)) {\n            value = this.values_[key];\n        }\n        return value;\n    };\n    /**\n     * Get a list of object property names.\n     * @return {Array<string>} List of property names.\n     * @api\n     */\n    BaseObject.prototype.getKeys = function () {\n        return (this.values_ && Object.keys(this.values_)) || [];\n    };\n    /**\n     * Get an object of all property names and values.\n     * @return {Object<string, *>} Object.\n     * @api\n     */\n    BaseObject.prototype.getProperties = function () {\n        return (this.values_ && assign({}, this.values_)) || {};\n    };\n    /**\n     * @return {boolean} The object has properties.\n     */\n    BaseObject.prototype.hasProperties = function () {\n        return !!this.values_;\n    };\n    /**\n     * @param {string} key Key name.\n     * @param {*} oldValue Old value.\n     */\n    BaseObject.prototype.notify = function (key, oldValue) {\n        var eventType;\n        eventType = \"change:\" + key;\n        this.dispatchEvent(new ObjectEvent(eventType, key, oldValue));\n        eventType = ObjectEventType.PROPERTYCHANGE;\n        this.dispatchEvent(new ObjectEvent(eventType, key, oldValue));\n    };\n    /**\n     * @param {string} key Key name.\n     * @param {import(\"./events.js\").Listener} listener Listener.\n     */\n    BaseObject.prototype.addChangeListener = function (key, listener) {\n        this.addEventListener(\"change:\" + key, listener);\n    };\n    /**\n     * @param {string} key Key name.\n     * @param {import(\"./events.js\").Listener} listener Listener.\n     */\n    BaseObject.prototype.removeChangeListener = function (key, listener) {\n        this.removeEventListener(\"change:\" + key, listener);\n    };\n    /**\n     * Sets a value.\n     * @param {string} key Key name.\n     * @param {*} value Value.\n     * @param {boolean} [opt_silent] Update without triggering an event.\n     * @api\n     */\n    BaseObject.prototype.set = function (key, value, opt_silent) {\n        var values = this.values_ || (this.values_ = {});\n        if (opt_silent) {\n            values[key] = value;\n        }\n        else {\n            var oldValue = values[key];\n            values[key] = value;\n            if (oldValue !== value) {\n                this.notify(key, oldValue);\n            }\n        }\n    };\n    /**\n     * Sets a collection of key-value pairs.  Note that this changes any existing\n     * properties and adds new ones (it does not remove any existing properties).\n     * @param {Object<string, *>} values Values.\n     * @param {boolean} [opt_silent] Update without triggering an event.\n     * @api\n     */\n    BaseObject.prototype.setProperties = function (values, opt_silent) {\n        for (var key in values) {\n            this.set(key, values[key], opt_silent);\n        }\n    };\n    /**\n     * Apply any properties from another object without triggering events.\n     * @param {BaseObject} source The source object.\n     * @protected\n     */\n    BaseObject.prototype.applyProperties = function (source) {\n        if (!source.values_) {\n            return;\n        }\n        assign(this.values_ || (this.values_ = {}), source.values_);\n    };\n    /**\n     * Unsets a property.\n     * @param {string} key Key name.\n     * @param {boolean} [opt_silent] Unset without triggering an event.\n     * @api\n     */\n    BaseObject.prototype.unset = function (key, opt_silent) {\n        if (this.values_ && key in this.values_) {\n            var oldValue = this.values_[key];\n            delete this.values_[key];\n            if (isEmpty(this.values_)) {\n                this.values_ = null;\n            }\n            if (!opt_silent) {\n                this.notify(key, oldValue);\n            }\n        }\n    };\n    return BaseObject;\n}(Observable));\nexport default BaseObject;\n//# sourceMappingURL=Object.js.map","/**\n * @module ol/ObjectEventType\n */\n/**\n * @enum {string}\n */\nexport default {\n    /**\n     * Triggered when a property is changed.\n     * @event module:ol/Object.ObjectEvent#propertychange\n     * @api\n     */\n    PROPERTYCHANGE: 'propertychange',\n};\n/**\n * @typedef {'propertychange'} Types\n */\n//# sourceMappingURL=ObjectEventType.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/Observable\n */\nimport EventTarget from './events/Target.js';\nimport EventType from './events/EventType.js';\nimport { listen, listenOnce, unlistenByKey } from './events.js';\n/***\n * @template {string} Type\n * @template {Event|import(\"./events/Event.js\").default} EventClass\n * @template Return\n * @typedef {(type: Type, listener: (event: EventClass) => ?) => Return} OnSignature\n */\n/***\n * @template {string} Type\n * @template Return\n * @typedef {(type: Type[], listener: (event: Event|import(\"./events/Event\").default) => ?) => Return extends void ? void : Return[]} CombinedOnSignature\n */\n/**\n * @typedef {'change'|'error'} EventTypes\n */\n/***\n * @template Return\n * @typedef {OnSignature<EventTypes, import(\"./events/Event.js\").default, Return> & CombinedOnSignature<EventTypes, Return>} ObservableOnSignature\n */\n/**\n * @classdesc\n * Abstract base class; normally only used for creating subclasses and not\n * instantiated in apps.\n * An event target providing convenient methods for listener registration\n * and unregistration. A generic `change` event is always available through\n * {@link module:ol/Observable~Observable#changed}.\n *\n * @fires import(\"./events/Event.js\").default\n * @api\n */\nvar Observable = /** @class */ (function (_super) {\n    __extends(Observable, _super);\n    function Observable() {\n        var _this = _super.call(this) || this;\n        _this.on =\n            /** @type {ObservableOnSignature<import(\"./events\").EventsKey>} */ (_this.onInternal);\n        _this.once =\n            /** @type {ObservableOnSignature<import(\"./events\").EventsKey>} */ (_this.onceInternal);\n        _this.un = /** @type {ObservableOnSignature<void>} */ (_this.unInternal);\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.revision_ = 0;\n        return _this;\n    }\n    /**\n     * Increases the revision counter and dispatches a 'change' event.\n     * @api\n     */\n    Observable.prototype.changed = function () {\n        ++this.revision_;\n        this.dispatchEvent(EventType.CHANGE);\n    };\n    /**\n     * Get the version number for this object.  Each time the object is modified,\n     * its version number will be incremented.\n     * @return {number} Revision.\n     * @api\n     */\n    Observable.prototype.getRevision = function () {\n        return this.revision_;\n    };\n    /**\n     * @param {string|Array<string>} type Type.\n     * @param {function((Event|import(\"./events/Event\").default)): ?} listener Listener.\n     * @return {import(\"./events.js\").EventsKey|Array<import(\"./events.js\").EventsKey>} Event key.\n     * @protected\n     */\n    Observable.prototype.onInternal = function (type, listener) {\n        if (Array.isArray(type)) {\n            var len = type.length;\n            var keys = new Array(len);\n            for (var i = 0; i < len; ++i) {\n                keys[i] = listen(this, type[i], listener);\n            }\n            return keys;\n        }\n        else {\n            return listen(this, /** @type {string} */ (type), listener);\n        }\n    };\n    /**\n     * @param {string|Array<string>} type Type.\n     * @param {function((Event|import(\"./events/Event\").default)): ?} listener Listener.\n     * @return {import(\"./events.js\").EventsKey|Array<import(\"./events.js\").EventsKey>} Event key.\n     * @protected\n     */\n    Observable.prototype.onceInternal = function (type, listener) {\n        var key;\n        if (Array.isArray(type)) {\n            var len = type.length;\n            key = new Array(len);\n            for (var i = 0; i < len; ++i) {\n                key[i] = listenOnce(this, type[i], listener);\n            }\n        }\n        else {\n            key = listenOnce(this, /** @type {string} */ (type), listener);\n        }\n        /** @type {Object} */ (listener).ol_key = key;\n        return key;\n    };\n    /**\n     * Unlisten for a certain type of event.\n     * @param {string|Array<string>} type Type.\n     * @param {function((Event|import(\"./events/Event\").default)): ?} listener Listener.\n     * @protected\n     */\n    Observable.prototype.unInternal = function (type, listener) {\n        var key = /** @type {Object} */ (listener).ol_key;\n        if (key) {\n            unByKey(key);\n        }\n        else if (Array.isArray(type)) {\n            for (var i = 0, ii = type.length; i < ii; ++i) {\n                this.removeEventListener(type[i], listener);\n            }\n        }\n        else {\n            this.removeEventListener(type, listener);\n        }\n    };\n    return Observable;\n}(EventTarget));\n/**\n * Listen for a certain type of event.\n * @function\n * @param {string|Array<string>} type The event type or array of event types.\n * @param {function((Event|import(\"./events/Event\").default)): ?} listener The listener function.\n * @return {import(\"./events.js\").EventsKey|Array<import(\"./events.js\").EventsKey>} Unique key for the listener. If\n *     called with an array of event types as the first argument, the return\n *     will be an array of keys.\n * @api\n */\nObservable.prototype.on;\n/**\n * Listen once for a certain type of event.\n * @function\n * @param {string|Array<string>} type The event type or array of event types.\n * @param {function((Event|import(\"./events/Event\").default)): ?} listener The listener function.\n * @return {import(\"./events.js\").EventsKey|Array<import(\"./events.js\").EventsKey>} Unique key for the listener. If\n *     called with an array of event types as the first argument, the return\n *     will be an array of keys.\n * @api\n */\nObservable.prototype.once;\n/**\n * Unlisten for a certain type of event.\n * @function\n * @param {string|Array<string>} type The event type or array of event types.\n * @param {function((Event|import(\"./events/Event\").default)): ?} listener The listener function.\n * @api\n */\nObservable.prototype.un;\n/**\n * Removes an event listener using the key returned by `on()` or `once()`.\n * @param {import(\"./events.js\").EventsKey|Array<import(\"./events.js\").EventsKey>} key The key returned by `on()`\n *     or `once()` (or an array of keys).\n * @api\n */\nexport function unByKey(key) {\n    if (Array.isArray(key)) {\n        for (var i = 0, ii = key.length; i < ii; ++i) {\n            unlistenByKey(key[i]);\n        }\n    }\n    else {\n        unlistenByKey(/** @type {import(\"./events.js\").EventsKey} */ (key));\n    }\n}\nexport default Observable;\n//# sourceMappingURL=Observable.js.map","/**\n * @module ol/array\n */\n/**\n * Performs a binary search on the provided sorted list and returns the index of the item if found. If it can't be found it'll return -1.\n * https://github.com/darkskyapp/binary-search\n *\n * @param {Array<*>} haystack Items to search through.\n * @param {*} needle The item to look for.\n * @param {Function} [opt_comparator] Comparator function.\n * @return {number} The index of the item if found, -1 if not.\n */\nexport function binarySearch(haystack, needle, opt_comparator) {\n    var mid, cmp;\n    var comparator = opt_comparator || numberSafeCompareFunction;\n    var low = 0;\n    var high = haystack.length;\n    var found = false;\n    while (low < high) {\n        /* Note that \"(low + high) >>> 1\" may overflow, and results in a typecast\n         * to double (which gives the wrong results). */\n        mid = low + ((high - low) >> 1);\n        cmp = +comparator(haystack[mid], needle);\n        if (cmp < 0.0) {\n            /* Too low. */\n            low = mid + 1;\n        }\n        else {\n            /* Key found or too high */\n            high = mid;\n            found = !cmp;\n        }\n    }\n    /* Key not found. */\n    return found ? low : ~low;\n}\n/**\n * Compare function for array sort that is safe for numbers.\n * @param {*} a The first object to be compared.\n * @param {*} b The second object to be compared.\n * @return {number} A negative number, zero, or a positive number as the first\n *     argument is less than, equal to, or greater than the second.\n */\nexport function numberSafeCompareFunction(a, b) {\n    return a > b ? 1 : a < b ? -1 : 0;\n}\n/**\n * Whether the array contains the given object.\n * @param {Array<*>} arr The array to test for the presence of the element.\n * @param {*} obj The object for which to test.\n * @return {boolean} The object is in the array.\n */\nexport function includes(arr, obj) {\n    return arr.indexOf(obj) >= 0;\n}\n/**\n * {@link module:ol/tilegrid/TileGrid~TileGrid#getZForResolution} can use a function\n * of this type to determine which nearest resolution to use.\n *\n * This function takes a `{number}` representing a value between two array entries,\n * a `{number}` representing the value of the nearest higher entry and\n * a `{number}` representing the value of the nearest lower entry\n * as arguments and returns a `{number}`. If a negative number or zero is returned\n * the lower value will be used, if a positive number is returned the higher value\n * will be used.\n * @typedef {function(number, number, number): number} NearestDirectionFunction\n * @api\n */\n/**\n * @param {Array<number>} arr Array in descending order.\n * @param {number} target Target.\n * @param {number|NearestDirectionFunction} direction\n *    0 means return the nearest,\n *    > 0 means return the largest nearest,\n *    < 0 means return the smallest nearest.\n * @return {number} Index.\n */\nexport function linearFindNearest(arr, target, direction) {\n    var n = arr.length;\n    if (arr[0] <= target) {\n        return 0;\n    }\n    else if (target <= arr[n - 1]) {\n        return n - 1;\n    }\n    else {\n        var i = void 0;\n        if (direction > 0) {\n            for (i = 1; i < n; ++i) {\n                if (arr[i] < target) {\n                    return i - 1;\n                }\n            }\n        }\n        else if (direction < 0) {\n            for (i = 1; i < n; ++i) {\n                if (arr[i] <= target) {\n                    return i;\n                }\n            }\n        }\n        else {\n            for (i = 1; i < n; ++i) {\n                if (arr[i] == target) {\n                    return i;\n                }\n                else if (arr[i] < target) {\n                    if (typeof direction === 'function') {\n                        if (direction(target, arr[i - 1], arr[i]) > 0) {\n                            return i - 1;\n                        }\n                        else {\n                            return i;\n                        }\n                    }\n                    else if (arr[i - 1] - target < target - arr[i]) {\n                        return i - 1;\n                    }\n                    else {\n                        return i;\n                    }\n                }\n            }\n        }\n        return n - 1;\n    }\n}\n/**\n * @param {Array<*>} arr Array.\n * @param {number} begin Begin index.\n * @param {number} end End index.\n */\nexport function reverseSubArray(arr, begin, end) {\n    while (begin < end) {\n        var tmp = arr[begin];\n        arr[begin] = arr[end];\n        arr[end] = tmp;\n        ++begin;\n        --end;\n    }\n}\n/**\n * @param {Array<VALUE>} arr The array to modify.\n * @param {!Array<VALUE>|VALUE} data The elements or arrays of elements to add to arr.\n * @template VALUE\n */\nexport function extend(arr, data) {\n    var extension = Array.isArray(data) ? data : [data];\n    var length = extension.length;\n    for (var i = 0; i < length; i++) {\n        arr[arr.length] = extension[i];\n    }\n}\n/**\n * @param {Array<VALUE>} arr The array to modify.\n * @param {VALUE} obj The element to remove.\n * @template VALUE\n * @return {boolean} If the element was removed.\n */\nexport function remove(arr, obj) {\n    var i = arr.indexOf(obj);\n    var found = i > -1;\n    if (found) {\n        arr.splice(i, 1);\n    }\n    return found;\n}\n/**\n * @param {Array<VALUE>} arr The array to search in.\n * @param {function(VALUE, number, ?) : boolean} func The function to compare.\n * @template VALUE\n * @return {VALUE|null} The element found or null.\n */\nexport function find(arr, func) {\n    var length = arr.length >>> 0;\n    var value;\n    for (var i = 0; i < length; i++) {\n        value = arr[i];\n        if (func(value, i, arr)) {\n            return value;\n        }\n    }\n    return null;\n}\n/**\n * @param {Array|Uint8ClampedArray} arr1 The first array to compare.\n * @param {Array|Uint8ClampedArray} arr2 The second array to compare.\n * @return {boolean} Whether the two arrays are equal.\n */\nexport function equals(arr1, arr2) {\n    var len1 = arr1.length;\n    if (len1 !== arr2.length) {\n        return false;\n    }\n    for (var i = 0; i < len1; i++) {\n        if (arr1[i] !== arr2[i]) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Sort the passed array such that the relative order of equal elements is preserved.\n * See https://en.wikipedia.org/wiki/Sorting_algorithm#Stability for details.\n * @param {Array<*>} arr The array to sort (modifies original).\n * @param {!function(*, *): number} compareFnc Comparison function.\n * @api\n */\nexport function stableSort(arr, compareFnc) {\n    var length = arr.length;\n    var tmp = Array(arr.length);\n    var i;\n    for (i = 0; i < length; i++) {\n        tmp[i] = { index: i, value: arr[i] };\n    }\n    tmp.sort(function (a, b) {\n        return compareFnc(a.value, b.value) || a.index - b.index;\n    });\n    for (i = 0; i < arr.length; i++) {\n        arr[i] = tmp[i].value;\n    }\n}\n/**\n * @param {Array<*>} arr The array to search in.\n * @param {Function} func Comparison function.\n * @return {number} Return index.\n */\nexport function findIndex(arr, func) {\n    var index;\n    var found = !arr.every(function (el, idx) {\n        index = idx;\n        return !func(el, idx, arr);\n    });\n    return found ? index : -1;\n}\n/**\n * @param {Array<*>} arr The array to test.\n * @param {Function} [opt_func] Comparison function.\n * @param {boolean} [opt_strict] Strictly sorted (default false).\n * @return {boolean} Return index.\n */\nexport function isSorted(arr, opt_func, opt_strict) {\n    var compare = opt_func || numberSafeCompareFunction;\n    return arr.every(function (currentVal, index) {\n        if (index === 0) {\n            return true;\n        }\n        var res = compare(arr[index - 1], currentVal);\n        return !(res > 0 || (opt_strict && res === 0));\n    });\n}\n//# sourceMappingURL=array.js.map","/**\n * @module ol/asserts\n */\nimport AssertionError from './AssertionError.js';\n/**\n * @param {*} assertion Assertion we expected to be truthy.\n * @param {number} errorCode Error code.\n */\nexport function assert(assertion, errorCode) {\n    if (!assertion) {\n        throw new AssertionError(errorCode);\n    }\n}\n//# sourceMappingURL=asserts.js.map","/**\n * @module ol/events\n */\nimport { clear } from './obj.js';\n/**\n * Key to use with {@link module:ol/Observable~Observable#unByKey}.\n * @typedef {Object} EventsKey\n * @property {ListenerFunction} listener Listener.\n * @property {import(\"./events/Target.js\").EventTargetLike} target Target.\n * @property {string} type Type.\n * @api\n */\n/**\n * Listener function. This function is called with an event object as argument.\n * When the function returns `false`, event propagation will stop.\n *\n * @typedef {function((Event|import(\"./events/Event.js\").default)): (void|boolean)} ListenerFunction\n * @api\n */\n/**\n * @typedef {Object} ListenerObject\n * @property {ListenerFunction} handleEvent HandleEvent listener function.\n */\n/**\n * @typedef {ListenerFunction|ListenerObject} Listener\n */\n/**\n * Registers an event listener on an event target. Inspired by\n * https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html\n *\n * This function efficiently binds a `listener` to a `this` object, and returns\n * a key for use with {@link module:ol/events.unlistenByKey}.\n *\n * @param {import(\"./events/Target.js\").EventTargetLike} target Event target.\n * @param {string} type Event type.\n * @param {ListenerFunction} listener Listener.\n * @param {Object} [opt_this] Object referenced by the `this` keyword in the\n *     listener. Default is the `target`.\n * @param {boolean} [opt_once] If true, add the listener as one-off listener.\n * @return {EventsKey} Unique key for the listener.\n */\nexport function listen(target, type, listener, opt_this, opt_once) {\n    if (opt_this && opt_this !== target) {\n        listener = listener.bind(opt_this);\n    }\n    if (opt_once) {\n        var originalListener_1 = listener;\n        listener = function () {\n            target.removeEventListener(type, listener);\n            originalListener_1.apply(this, arguments);\n        };\n    }\n    var eventsKey = {\n        target: target,\n        type: type,\n        listener: listener,\n    };\n    target.addEventListener(type, listener);\n    return eventsKey;\n}\n/**\n * Registers a one-off event listener on an event target. Inspired by\n * https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html\n *\n * This function efficiently binds a `listener` as self-unregistering listener\n * to a `this` object, and returns a key for use with\n * {@link module:ol/events.unlistenByKey} in case the listener needs to be\n * unregistered before it is called.\n *\n * When {@link module:ol/events.listen} is called with the same arguments after this\n * function, the self-unregistering listener will be turned into a permanent\n * listener.\n *\n * @param {import(\"./events/Target.js\").EventTargetLike} target Event target.\n * @param {string} type Event type.\n * @param {ListenerFunction} listener Listener.\n * @param {Object} [opt_this] Object referenced by the `this` keyword in the\n *     listener. Default is the `target`.\n * @return {EventsKey} Key for unlistenByKey.\n */\nexport function listenOnce(target, type, listener, opt_this) {\n    return listen(target, type, listener, opt_this, true);\n}\n/**\n * Unregisters event listeners on an event target. Inspired by\n * https://google.github.io/closure-library/api/source/closure/goog/events/events.js.src.html\n *\n * The argument passed to this function is the key returned from\n * {@link module:ol/events.listen} or {@link module:ol/events.listenOnce}.\n *\n * @param {EventsKey} key The key.\n */\nexport function unlistenByKey(key) {\n    if (key && key.target) {\n        key.target.removeEventListener(key.type, key.listener);\n        clear(key);\n    }\n}\n//# sourceMappingURL=events.js.map","/**\n * @module ol/events/Event\n */\n/**\n * @classdesc\n * Stripped down implementation of the W3C DOM Level 2 Event interface.\n * See https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-interface.\n *\n * This implementation only provides `type` and `target` properties, and\n * `stopPropagation` and `preventDefault` methods. It is meant as base class\n * for higher level events defined in the library, and works with\n * {@link module:ol/events/Target~Target}.\n */\nvar BaseEvent = /** @class */ (function () {\n    /**\n     * @param {string} type Type.\n     */\n    function BaseEvent(type) {\n        /**\n         * @type {boolean}\n         */\n        this.propagationStopped;\n        /**\n         * @type {boolean}\n         */\n        this.defaultPrevented;\n        /**\n         * The event type.\n         * @type {string}\n         * @api\n         */\n        this.type = type;\n        /**\n         * The event target.\n         * @type {Object}\n         * @api\n         */\n        this.target = null;\n    }\n    /**\n     * Prevent default. This means that no emulated `click`, `singleclick` or `doubleclick` events\n     * will be fired.\n     * @api\n     */\n    BaseEvent.prototype.preventDefault = function () {\n        this.defaultPrevented = true;\n    };\n    /**\n     * Stop event propagation.\n     * @api\n     */\n    BaseEvent.prototype.stopPropagation = function () {\n        this.propagationStopped = true;\n    };\n    return BaseEvent;\n}());\n/**\n * @param {Event|import(\"./Event.js\").default} evt Event\n */\nexport function stopPropagation(evt) {\n    evt.stopPropagation();\n}\n/**\n * @param {Event|import(\"./Event.js\").default} evt Event\n */\nexport function preventDefault(evt) {\n    evt.preventDefault();\n}\nexport default BaseEvent;\n//# sourceMappingURL=Event.js.map","/**\n * @module ol/events/EventType\n */\n/**\n * @enum {string}\n * @const\n */\nexport default {\n    /**\n     * Generic change event. Triggered when the revision counter is increased.\n     * @event module:ol/events/Event~BaseEvent#change\n     * @api\n     */\n    CHANGE: 'change',\n    /**\n     * Generic error event. Triggered when an error occurs.\n     * @event module:ol/events/Event~BaseEvent#error\n     * @api\n     */\n    ERROR: 'error',\n    BLUR: 'blur',\n    CLEAR: 'clear',\n    CONTEXTMENU: 'contextmenu',\n    CLICK: 'click',\n    DBLCLICK: 'dblclick',\n    DRAGENTER: 'dragenter',\n    DRAGOVER: 'dragover',\n    DROP: 'drop',\n    FOCUS: 'focus',\n    KEYDOWN: 'keydown',\n    KEYPRESS: 'keypress',\n    LOAD: 'load',\n    RESIZE: 'resize',\n    TOUCHMOVE: 'touchmove',\n    WHEEL: 'wheel',\n};\n//# sourceMappingURL=EventType.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/events/Target\n */\nimport Disposable from '../Disposable.js';\nimport Event from './Event.js';\nimport { VOID } from '../functions.js';\nimport { clear } from '../obj.js';\n/**\n * @typedef {EventTarget|Target} EventTargetLike\n */\n/**\n * @classdesc\n * A simplified implementation of the W3C DOM Level 2 EventTarget interface.\n * See https://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html#Events-EventTarget.\n *\n * There are two important simplifications compared to the specification:\n *\n * 1. The handling of `useCapture` in `addEventListener` and\n *    `removeEventListener`. There is no real capture model.\n * 2. The handling of `stopPropagation` and `preventDefault` on `dispatchEvent`.\n *    There is no event target hierarchy. When a listener calls\n *    `stopPropagation` or `preventDefault` on an event object, it means that no\n *    more listeners after this one will be called. Same as when the listener\n *    returns false.\n */\nvar Target = /** @class */ (function (_super) {\n    __extends(Target, _super);\n    /**\n     * @param {*} [opt_target] Default event target for dispatched events.\n     */\n    function Target(opt_target) {\n        var _this = _super.call(this) || this;\n        /**\n         * @private\n         * @type {*}\n         */\n        _this.eventTarget_ = opt_target;\n        /**\n         * @private\n         * @type {Object<string, number>}\n         */\n        _this.pendingRemovals_ = null;\n        /**\n         * @private\n         * @type {Object<string, number>}\n         */\n        _this.dispatching_ = null;\n        /**\n         * @private\n         * @type {Object<string, Array<import(\"../events.js\").Listener>>}\n         */\n        _this.listeners_ = null;\n        return _this;\n    }\n    /**\n     * @param {string} type Type.\n     * @param {import(\"../events.js\").Listener} listener Listener.\n     */\n    Target.prototype.addEventListener = function (type, listener) {\n        if (!type || !listener) {\n            return;\n        }\n        var listeners = this.listeners_ || (this.listeners_ = {});\n        var listenersForType = listeners[type] || (listeners[type] = []);\n        if (listenersForType.indexOf(listener) === -1) {\n            listenersForType.push(listener);\n        }\n    };\n    /**\n     * Dispatches an event and calls all listeners listening for events\n     * of this type. The event parameter can either be a string or an\n     * Object with a `type` property.\n     *\n     * @param {import(\"./Event.js\").default|string} event Event object.\n     * @return {boolean|undefined} `false` if anyone called preventDefault on the\n     *     event object or if any of the listeners returned false.\n     * @api\n     */\n    Target.prototype.dispatchEvent = function (event) {\n        /** @type {import(\"./Event.js\").default|Event} */\n        var evt = typeof event === 'string' ? new Event(event) : event;\n        var type = evt.type;\n        if (!evt.target) {\n            evt.target = this.eventTarget_ || this;\n        }\n        var listeners = this.listeners_ && this.listeners_[type];\n        var propagate;\n        if (listeners) {\n            var dispatching = this.dispatching_ || (this.dispatching_ = {});\n            var pendingRemovals = this.pendingRemovals_ || (this.pendingRemovals_ = {});\n            if (!(type in dispatching)) {\n                dispatching[type] = 0;\n                pendingRemovals[type] = 0;\n            }\n            ++dispatching[type];\n            for (var i = 0, ii = listeners.length; i < ii; ++i) {\n                if ('handleEvent' in listeners[i]) {\n                    propagate = /** @type {import(\"../events.js\").ListenerObject} */ (listeners[i]).handleEvent(evt);\n                }\n                else {\n                    propagate = /** @type {import(\"../events.js\").ListenerFunction} */ (listeners[i]).call(this, evt);\n                }\n                if (propagate === false || evt.propagationStopped) {\n                    propagate = false;\n                    break;\n                }\n            }\n            --dispatching[type];\n            if (dispatching[type] === 0) {\n                var pr = pendingRemovals[type];\n                delete pendingRemovals[type];\n                while (pr--) {\n                    this.removeEventListener(type, VOID);\n                }\n                delete dispatching[type];\n            }\n            return propagate;\n        }\n    };\n    /**\n     * Clean up.\n     */\n    Target.prototype.disposeInternal = function () {\n        this.listeners_ && clear(this.listeners_);\n    };\n    /**\n     * Get the listeners for a specified event type. Listeners are returned in the\n     * order that they will be called in.\n     *\n     * @param {string} type Type.\n     * @return {Array<import(\"../events.js\").Listener>|undefined} Listeners.\n     */\n    Target.prototype.getListeners = function (type) {\n        return (this.listeners_ && this.listeners_[type]) || undefined;\n    };\n    /**\n     * @param {string} [opt_type] Type. If not provided,\n     *     `true` will be returned if this event target has any listeners.\n     * @return {boolean} Has listeners.\n     */\n    Target.prototype.hasListener = function (opt_type) {\n        if (!this.listeners_) {\n            return false;\n        }\n        return opt_type\n            ? opt_type in this.listeners_\n            : Object.keys(this.listeners_).length > 0;\n    };\n    /**\n     * @param {string} type Type.\n     * @param {import(\"../events.js\").Listener} listener Listener.\n     */\n    Target.prototype.removeEventListener = function (type, listener) {\n        var listeners = this.listeners_ && this.listeners_[type];\n        if (listeners) {\n            var index = listeners.indexOf(listener);\n            if (index !== -1) {\n                if (this.pendingRemovals_ && type in this.pendingRemovals_) {\n                    // make listener a no-op, and remove later in #dispatchEvent()\n                    listeners[index] = VOID;\n                    ++this.pendingRemovals_[type];\n                }\n                else {\n                    listeners.splice(index, 1);\n                    if (listeners.length === 0) {\n                        delete this.listeners_[type];\n                    }\n                }\n            }\n        }\n    };\n    return Target;\n}(Disposable));\nexport default Target;\n//# sourceMappingURL=Target.js.map","/**\n * @module ol/extent\n */\nimport Corner from './extent/Corner.js';\nimport Relationship from './extent/Relationship.js';\nimport { assert } from './asserts.js';\n/**\n * An array of numbers representing an extent: `[minx, miny, maxx, maxy]`.\n * @typedef {Array<number>} Extent\n * @api\n */\n/**\n * Build an extent that includes all given coordinates.\n *\n * @param {Array<import(\"./coordinate.js\").Coordinate>} coordinates Coordinates.\n * @return {Extent} Bounding extent.\n * @api\n */\nexport function boundingExtent(coordinates) {\n    var extent = createEmpty();\n    for (var i = 0, ii = coordinates.length; i < ii; ++i) {\n        extendCoordinate(extent, coordinates[i]);\n    }\n    return extent;\n}\n/**\n * @param {Array<number>} xs Xs.\n * @param {Array<number>} ys Ys.\n * @param {Extent} [opt_extent] Destination extent.\n * @private\n * @return {Extent} Extent.\n */\nfunction _boundingExtentXYs(xs, ys, opt_extent) {\n    var minX = Math.min.apply(null, xs);\n    var minY = Math.min.apply(null, ys);\n    var maxX = Math.max.apply(null, xs);\n    var maxY = Math.max.apply(null, ys);\n    return createOrUpdate(minX, minY, maxX, maxY, opt_extent);\n}\n/**\n * Return extent increased by the provided value.\n * @param {Extent} extent Extent.\n * @param {number} value The amount by which the extent should be buffered.\n * @param {Extent} [opt_extent] Extent.\n * @return {Extent} Extent.\n * @api\n */\nexport function buffer(extent, value, opt_extent) {\n    if (opt_extent) {\n        opt_extent[0] = extent[0] - value;\n        opt_extent[1] = extent[1] - value;\n        opt_extent[2] = extent[2] + value;\n        opt_extent[3] = extent[3] + value;\n        return opt_extent;\n    }\n    else {\n        return [\n            extent[0] - value,\n            extent[1] - value,\n            extent[2] + value,\n            extent[3] + value,\n        ];\n    }\n}\n/**\n * Creates a clone of an extent.\n *\n * @param {Extent} extent Extent to clone.\n * @param {Extent} [opt_extent] Extent.\n * @return {Extent} The clone.\n */\nexport function clone(extent, opt_extent) {\n    if (opt_extent) {\n        opt_extent[0] = extent[0];\n        opt_extent[1] = extent[1];\n        opt_extent[2] = extent[2];\n        opt_extent[3] = extent[3];\n        return opt_extent;\n    }\n    else {\n        return extent.slice();\n    }\n}\n/**\n * @param {Extent} extent Extent.\n * @param {number} x X.\n * @param {number} y Y.\n * @return {number} Closest squared distance.\n */\nexport function closestSquaredDistanceXY(extent, x, y) {\n    var dx, dy;\n    if (x < extent[0]) {\n        dx = extent[0] - x;\n    }\n    else if (extent[2] < x) {\n        dx = x - extent[2];\n    }\n    else {\n        dx = 0;\n    }\n    if (y < extent[1]) {\n        dy = extent[1] - y;\n    }\n    else if (extent[3] < y) {\n        dy = y - extent[3];\n    }\n    else {\n        dy = 0;\n    }\n    return dx * dx + dy * dy;\n}\n/**\n * Check if the passed coordinate is contained or on the edge of the extent.\n *\n * @param {Extent} extent Extent.\n * @param {import(\"./coordinate.js\").Coordinate} coordinate Coordinate.\n * @return {boolean} The coordinate is contained in the extent.\n * @api\n */\nexport function containsCoordinate(extent, coordinate) {\n    return containsXY(extent, coordinate[0], coordinate[1]);\n}\n/**\n * Check if one extent contains another.\n *\n * An extent is deemed contained if it lies completely within the other extent,\n * including if they share one or more edges.\n *\n * @param {Extent} extent1 Extent 1.\n * @param {Extent} extent2 Extent 2.\n * @return {boolean} The second extent is contained by or on the edge of the\n *     first.\n * @api\n */\nexport function containsExtent(extent1, extent2) {\n    return (extent1[0] <= extent2[0] &&\n        extent2[2] <= extent1[2] &&\n        extent1[1] <= extent2[1] &&\n        extent2[3] <= extent1[3]);\n}\n/**\n * Check if the passed coordinate is contained or on the edge of the extent.\n *\n * @param {Extent} extent Extent.\n * @param {number} x X coordinate.\n * @param {number} y Y coordinate.\n * @return {boolean} The x, y values are contained in the extent.\n * @api\n */\nexport function containsXY(extent, x, y) {\n    return extent[0] <= x && x <= extent[2] && extent[1] <= y && y <= extent[3];\n}\n/**\n * Get the relationship between a coordinate and extent.\n * @param {Extent} extent The extent.\n * @param {import(\"./coordinate.js\").Coordinate} coordinate The coordinate.\n * @return {import(\"./extent/Relationship.js\").default} The relationship (bitwise compare with\n *     import(\"./extent/Relationship.js\").Relationship).\n */\nexport function coordinateRelationship(extent, coordinate) {\n    var minX = extent[0];\n    var minY = extent[1];\n    var maxX = extent[2];\n    var maxY = extent[3];\n    var x = coordinate[0];\n    var y = coordinate[1];\n    var relationship = Relationship.UNKNOWN;\n    if (x < minX) {\n        relationship = relationship | Relationship.LEFT;\n    }\n    else if (x > maxX) {\n        relationship = relationship | Relationship.RIGHT;\n    }\n    if (y < minY) {\n        relationship = relationship | Relationship.BELOW;\n    }\n    else if (y > maxY) {\n        relationship = relationship | Relationship.ABOVE;\n    }\n    if (relationship === Relationship.UNKNOWN) {\n        relationship = Relationship.INTERSECTING;\n    }\n    return relationship;\n}\n/**\n * Create an empty extent.\n * @return {Extent} Empty extent.\n * @api\n */\nexport function createEmpty() {\n    return [Infinity, Infinity, -Infinity, -Infinity];\n}\n/**\n * Create a new extent or update the provided extent.\n * @param {number} minX Minimum X.\n * @param {number} minY Minimum Y.\n * @param {number} maxX Maximum X.\n * @param {number} maxY Maximum Y.\n * @param {Extent} [opt_extent] Destination extent.\n * @return {Extent} Extent.\n */\nexport function createOrUpdate(minX, minY, maxX, maxY, opt_extent) {\n    if (opt_extent) {\n        opt_extent[0] = minX;\n        opt_extent[1] = minY;\n        opt_extent[2] = maxX;\n        opt_extent[3] = maxY;\n        return opt_extent;\n    }\n    else {\n        return [minX, minY, maxX, maxY];\n    }\n}\n/**\n * Create a new empty extent or make the provided one empty.\n * @param {Extent} [opt_extent] Extent.\n * @return {Extent} Extent.\n */\nexport function createOrUpdateEmpty(opt_extent) {\n    return createOrUpdate(Infinity, Infinity, -Infinity, -Infinity, opt_extent);\n}\n/**\n * @param {import(\"./coordinate.js\").Coordinate} coordinate Coordinate.\n * @param {Extent} [opt_extent] Extent.\n * @return {Extent} Extent.\n */\nexport function createOrUpdateFromCoordinate(coordinate, opt_extent) {\n    var x = coordinate[0];\n    var y = coordinate[1];\n    return createOrUpdate(x, y, x, y, opt_extent);\n}\n/**\n * @param {Array<import(\"./coordinate.js\").Coordinate>} coordinates Coordinates.\n * @param {Extent} [opt_extent] Extent.\n * @return {Extent} Extent.\n */\nexport function createOrUpdateFromCoordinates(coordinates, opt_extent) {\n    var extent = createOrUpdateEmpty(opt_extent);\n    return extendCoordinates(extent, coordinates);\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 {Extent} [opt_extent] Extent.\n * @return {Extent} Extent.\n */\nexport function createOrUpdateFromFlatCoordinates(flatCoordinates, offset, end, stride, opt_extent) {\n    var extent = createOrUpdateEmpty(opt_extent);\n    return extendFlatCoordinates(extent, flatCoordinates, offset, end, stride);\n}\n/**\n * @param {Array<Array<import(\"./coordinate.js\").Coordinate>>} rings Rings.\n * @param {Extent} [opt_extent] Extent.\n * @return {Extent} Extent.\n */\nexport function createOrUpdateFromRings(rings, opt_extent) {\n    var extent = createOrUpdateEmpty(opt_extent);\n    return extendRings(extent, rings);\n}\n/**\n * Determine if two extents are equivalent.\n * @param {Extent} extent1 Extent 1.\n * @param {Extent} extent2 Extent 2.\n * @return {boolean} The two extents are equivalent.\n * @api\n */\nexport function equals(extent1, extent2) {\n    return (extent1[0] == extent2[0] &&\n        extent1[2] == extent2[2] &&\n        extent1[1] == extent2[1] &&\n        extent1[3] == extent2[3]);\n}\n/**\n * Determine if two extents are approximately equivalent.\n * @param {Extent} extent1 Extent 1.\n * @param {Extent} extent2 Extent 2.\n * @param {number} tolerance Tolerance in extent coordinate units.\n * @return {boolean} The two extents differ by less than the tolerance.\n */\nexport function approximatelyEquals(extent1, extent2, tolerance) {\n    return (Math.abs(extent1[0] - extent2[0]) < tolerance &&\n        Math.abs(extent1[2] - extent2[2]) < tolerance &&\n        Math.abs(extent1[1] - extent2[1]) < tolerance &&\n        Math.abs(extent1[3] - extent2[3]) < tolerance);\n}\n/**\n * Modify an extent to include another extent.\n * @param {Extent} extent1 The extent to be modified.\n * @param {Extent} extent2 The extent that will be included in the first.\n * @return {Extent} A reference to the first (extended) extent.\n * @api\n */\nexport function extend(extent1, extent2) {\n    if (extent2[0] < extent1[0]) {\n        extent1[0] = extent2[0];\n    }\n    if (extent2[2] > extent1[2]) {\n        extent1[2] = extent2[2];\n    }\n    if (extent2[1] < extent1[1]) {\n        extent1[1] = extent2[1];\n    }\n    if (extent2[3] > extent1[3]) {\n        extent1[3] = extent2[3];\n    }\n    return extent1;\n}\n/**\n * @param {Extent} extent Extent.\n * @param {import(\"./coordinate.js\").Coordinate} coordinate Coordinate.\n */\nexport function extendCoordinate(extent, coordinate) {\n    if (coordinate[0] < extent[0]) {\n        extent[0] = coordinate[0];\n    }\n    if (coordinate[0] > extent[2]) {\n        extent[2] = coordinate[0];\n    }\n    if (coordinate[1] < extent[1]) {\n        extent[1] = coordinate[1];\n    }\n    if (coordinate[1] > extent[3]) {\n        extent[3] = coordinate[1];\n    }\n}\n/**\n * @param {Extent} extent Extent.\n * @param {Array<import(\"./coordinate.js\").Coordinate>} coordinates Coordinates.\n * @return {Extent} Extent.\n */\nexport function extendCoordinates(extent, coordinates) {\n    for (var i = 0, ii = coordinates.length; i < ii; ++i) {\n        extendCoordinate(extent, coordinates[i]);\n    }\n    return extent;\n}\n/**\n * @param {Extent} extent Extent.\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @return {Extent} Extent.\n */\nexport function extendFlatCoordinates(extent, flatCoordinates, offset, end, stride) {\n    for (; offset < end; offset += stride) {\n        extendXY(extent, flatCoordinates[offset], flatCoordinates[offset + 1]);\n    }\n    return extent;\n}\n/**\n * @param {Extent} extent Extent.\n * @param {Array<Array<import(\"./coordinate.js\").Coordinate>>} rings Rings.\n * @return {Extent} Extent.\n */\nexport function extendRings(extent, rings) {\n    for (var i = 0, ii = rings.length; i < ii; ++i) {\n        extendCoordinates(extent, rings[i]);\n    }\n    return extent;\n}\n/**\n * @param {Extent} extent Extent.\n * @param {number} x X.\n * @param {number} y Y.\n */\nexport function extendXY(extent, x, y) {\n    extent[0] = Math.min(extent[0], x);\n    extent[1] = Math.min(extent[1], y);\n    extent[2] = Math.max(extent[2], x);\n    extent[3] = Math.max(extent[3], y);\n}\n/**\n * This function calls `callback` for each corner of the extent. If the\n * callback returns a truthy value the function returns that value\n * immediately. Otherwise the function returns `false`.\n * @param {Extent} extent Extent.\n * @param {function(import(\"./coordinate.js\").Coordinate): S} callback Callback.\n * @return {S|boolean} Value.\n * @template S\n */\nexport function forEachCorner(extent, callback) {\n    var val;\n    val = callback(getBottomLeft(extent));\n    if (val) {\n        return val;\n    }\n    val = callback(getBottomRight(extent));\n    if (val) {\n        return val;\n    }\n    val = callback(getTopRight(extent));\n    if (val) {\n        return val;\n    }\n    val = callback(getTopLeft(extent));\n    if (val) {\n        return val;\n    }\n    return false;\n}\n/**\n * Get the size of an extent.\n * @param {Extent} extent Extent.\n * @return {number} Area.\n * @api\n */\nexport function getArea(extent) {\n    var area = 0;\n    if (!isEmpty(extent)) {\n        area = getWidth(extent) * getHeight(extent);\n    }\n    return area;\n}\n/**\n * Get the bottom left coordinate of an extent.\n * @param {Extent} extent Extent.\n * @return {import(\"./coordinate.js\").Coordinate} Bottom left coordinate.\n * @api\n */\nexport function getBottomLeft(extent) {\n    return [extent[0], extent[1]];\n}\n/**\n * Get the bottom right coordinate of an extent.\n * @param {Extent} extent Extent.\n * @return {import(\"./coordinate.js\").Coordinate} Bottom right coordinate.\n * @api\n */\nexport function getBottomRight(extent) {\n    return [extent[2], extent[1]];\n}\n/**\n * Get the center coordinate of an extent.\n * @param {Extent} extent Extent.\n * @return {import(\"./coordinate.js\").Coordinate} Center.\n * @api\n */\nexport function getCenter(extent) {\n    return [(extent[0] + extent[2]) / 2, (extent[1] + extent[3]) / 2];\n}\n/**\n * Get a corner coordinate of an extent.\n * @param {Extent} extent Extent.\n * @param {import(\"./extent/Corner.js\").default} corner Corner.\n * @return {import(\"./coordinate.js\").Coordinate} Corner coordinate.\n */\nexport function getCorner(extent, corner) {\n    var coordinate;\n    if (corner === Corner.BOTTOM_LEFT) {\n        coordinate = getBottomLeft(extent);\n    }\n    else if (corner === Corner.BOTTOM_RIGHT) {\n        coordinate = getBottomRight(extent);\n    }\n    else if (corner === Corner.TOP_LEFT) {\n        coordinate = getTopLeft(extent);\n    }\n    else if (corner === Corner.TOP_RIGHT) {\n        coordinate = getTopRight(extent);\n    }\n    else {\n        assert(false, 13); // Invalid corner\n    }\n    return coordinate;\n}\n/**\n * @param {Extent} extent1 Extent 1.\n * @param {Extent} extent2 Extent 2.\n * @return {number} Enlarged area.\n */\nexport function getEnlargedArea(extent1, extent2) {\n    var minX = Math.min(extent1[0], extent2[0]);\n    var minY = Math.min(extent1[1], extent2[1]);\n    var maxX = Math.max(extent1[2], extent2[2]);\n    var maxY = Math.max(extent1[3], extent2[3]);\n    return (maxX - minX) * (maxY - minY);\n}\n/**\n * @param {import(\"./coordinate.js\").Coordinate} center Center.\n * @param {number} resolution Resolution.\n * @param {number} rotation Rotation.\n * @param {import(\"./size.js\").Size} size Size.\n * @param {Extent} [opt_extent] Destination extent.\n * @return {Extent} Extent.\n */\nexport function getForViewAndSize(center, resolution, rotation, size, opt_extent) {\n    var dx = (resolution * size[0]) / 2;\n    var dy = (resolution * size[1]) / 2;\n    var cosRotation = Math.cos(rotation);\n    var sinRotation = Math.sin(rotation);\n    var xCos = dx * cosRotation;\n    var xSin = dx * sinRotation;\n    var yCos = dy * cosRotation;\n    var ySin = dy * sinRotation;\n    var x = center[0];\n    var y = center[1];\n    var x0 = x - xCos + ySin;\n    var x1 = x - xCos - ySin;\n    var x2 = x + xCos - ySin;\n    var x3 = x + xCos + ySin;\n    var y0 = y - xSin - yCos;\n    var y1 = y - xSin + yCos;\n    var y2 = y + xSin + yCos;\n    var y3 = y + xSin - yCos;\n    return createOrUpdate(Math.min(x0, x1, x2, x3), Math.min(y0, y1, y2, y3), Math.max(x0, x1, x2, x3), Math.max(y0, y1, y2, y3), opt_extent);\n}\n/**\n * Get the height of an extent.\n * @param {Extent} extent Extent.\n * @return {number} Height.\n * @api\n */\nexport function getHeight(extent) {\n    return extent[3] - extent[1];\n}\n/**\n * @param {Extent} extent1 Extent 1.\n * @param {Extent} extent2 Extent 2.\n * @return {number} Intersection area.\n */\nexport function getIntersectionArea(extent1, extent2) {\n    var intersection = getIntersection(extent1, extent2);\n    return getArea(intersection);\n}\n/**\n * Get the intersection of two extents.\n * @param {Extent} extent1 Extent 1.\n * @param {Extent} extent2 Extent 2.\n * @param {Extent} [opt_extent] Optional extent to populate with intersection.\n * @return {Extent} Intersecting extent.\n * @api\n */\nexport function getIntersection(extent1, extent2, opt_extent) {\n    var intersection = opt_extent ? opt_extent : createEmpty();\n    if (intersects(extent1, extent2)) {\n        if (extent1[0] > extent2[0]) {\n            intersection[0] = extent1[0];\n        }\n        else {\n            intersection[0] = extent2[0];\n        }\n        if (extent1[1] > extent2[1]) {\n            intersection[1] = extent1[1];\n        }\n        else {\n            intersection[1] = extent2[1];\n        }\n        if (extent1[2] < extent2[2]) {\n            intersection[2] = extent1[2];\n        }\n        else {\n            intersection[2] = extent2[2];\n        }\n        if (extent1[3] < extent2[3]) {\n            intersection[3] = extent1[3];\n        }\n        else {\n            intersection[3] = extent2[3];\n        }\n    }\n    else {\n        createOrUpdateEmpty(intersection);\n    }\n    return intersection;\n}\n/**\n * @param {Extent} extent Extent.\n * @return {number} Margin.\n */\nexport function getMargin(extent) {\n    return getWidth(extent) + getHeight(extent);\n}\n/**\n * Get the size (width, height) of an extent.\n * @param {Extent} extent The extent.\n * @return {import(\"./size.js\").Size} The extent size.\n * @api\n */\nexport function getSize(extent) {\n    return [extent[2] - extent[0], extent[3] - extent[1]];\n}\n/**\n * Get the top left coordinate of an extent.\n * @param {Extent} extent Extent.\n * @return {import(\"./coordinate.js\").Coordinate} Top left coordinate.\n * @api\n */\nexport function getTopLeft(extent) {\n    return [extent[0], extent[3]];\n}\n/**\n * Get the top right coordinate of an extent.\n * @param {Extent} extent Extent.\n * @return {import(\"./coordinate.js\").Coordinate} Top right coordinate.\n * @api\n */\nexport function getTopRight(extent) {\n    return [extent[2], extent[3]];\n}\n/**\n * Get the width of an extent.\n * @param {Extent} extent Extent.\n * @return {number} Width.\n * @api\n */\nexport function getWidth(extent) {\n    return extent[2] - extent[0];\n}\n/**\n * Determine if one extent intersects another.\n * @param {Extent} extent1 Extent 1.\n * @param {Extent} extent2 Extent.\n * @return {boolean} The two extents intersect.\n * @api\n */\nexport function intersects(extent1, extent2) {\n    return (extent1[0] <= extent2[2] &&\n        extent1[2] >= extent2[0] &&\n        extent1[1] <= extent2[3] &&\n        extent1[3] >= extent2[1]);\n}\n/**\n * Determine if an extent is empty.\n * @param {Extent} extent Extent.\n * @return {boolean} Is empty.\n * @api\n */\nexport function isEmpty(extent) {\n    return extent[2] < extent[0] || extent[3] < extent[1];\n}\n/**\n * @param {Extent} extent Extent.\n * @param {Extent} [opt_extent] Extent.\n * @return {Extent} Extent.\n */\nexport function returnOrUpdate(extent, opt_extent) {\n    if (opt_extent) {\n        opt_extent[0] = extent[0];\n        opt_extent[1] = extent[1];\n        opt_extent[2] = extent[2];\n        opt_extent[3] = extent[3];\n        return opt_extent;\n    }\n    else {\n        return extent;\n    }\n}\n/**\n * @param {Extent} extent Extent.\n * @param {number} value Value.\n */\nexport function scaleFromCenter(extent, value) {\n    var deltaX = ((extent[2] - extent[0]) / 2) * (value - 1);\n    var deltaY = ((extent[3] - extent[1]) / 2) * (value - 1);\n    extent[0] -= deltaX;\n    extent[2] += deltaX;\n    extent[1] -= deltaY;\n    extent[3] += deltaY;\n}\n/**\n * Determine if the segment between two coordinates intersects (crosses,\n * touches, or is contained by) the provided extent.\n * @param {Extent} extent The extent.\n * @param {import(\"./coordinate.js\").Coordinate} start Segment start coordinate.\n * @param {import(\"./coordinate.js\").Coordinate} end Segment end coordinate.\n * @return {boolean} The segment intersects the extent.\n */\nexport function intersectsSegment(extent, start, end) {\n    var intersects = false;\n    var startRel = coordinateRelationship(extent, start);\n    var endRel = coordinateRelationship(extent, end);\n    if (startRel === Relationship.INTERSECTING ||\n        endRel === Relationship.INTERSECTING) {\n        intersects = true;\n    }\n    else {\n        var minX = extent[0];\n        var minY = extent[1];\n        var maxX = extent[2];\n        var maxY = extent[3];\n        var startX = start[0];\n        var startY = start[1];\n        var endX = end[0];\n        var endY = end[1];\n        var slope = (endY - startY) / (endX - startX);\n        var x = void 0, y = void 0;\n        if (!!(endRel & Relationship.ABOVE) && !(startRel & Relationship.ABOVE)) {\n            // potentially intersects top\n            x = endX - (endY - maxY) / slope;\n            intersects = x >= minX && x <= maxX;\n        }\n        if (!intersects &&\n            !!(endRel & Relationship.RIGHT) &&\n            !(startRel & Relationship.RIGHT)) {\n            // potentially intersects right\n            y = endY - (endX - maxX) * slope;\n            intersects = y >= minY && y <= maxY;\n        }\n        if (!intersects &&\n            !!(endRel & Relationship.BELOW) &&\n            !(startRel & Relationship.BELOW)) {\n            // potentially intersects bottom\n            x = endX - (endY - minY) / slope;\n            intersects = x >= minX && x <= maxX;\n        }\n        if (!intersects &&\n            !!(endRel & Relationship.LEFT) &&\n            !(startRel & Relationship.LEFT)) {\n            // potentially intersects left\n            y = endY - (endX - minX) * slope;\n            intersects = y >= minY && y <= maxY;\n        }\n    }\n    return intersects;\n}\n/**\n * Apply a transform function to the extent.\n * @param {Extent} extent Extent.\n * @param {import(\"./proj.js\").TransformFunction} transformFn Transform function.\n * Called with `[minX, minY, maxX, maxY]` extent coordinates.\n * @param {Extent} [opt_extent] Destination extent.\n * @param {number} [opt_stops] Number of stops per side used for the transform.\n * By default only the corners are used.\n * @return {Extent} Extent.\n * @api\n */\nexport function applyTransform(extent, transformFn, opt_extent, opt_stops) {\n    var coordinates = [];\n    if (opt_stops > 1) {\n        var width = extent[2] - extent[0];\n        var height = extent[3] - extent[1];\n        for (var i = 0; i < opt_stops; ++i) {\n            coordinates.push(extent[0] + (width * i) / opt_stops, extent[1], extent[2], extent[1] + (height * i) / opt_stops, extent[2] - (width * i) / opt_stops, extent[3], extent[0], extent[3] - (height * i) / opt_stops);\n        }\n    }\n    else {\n        coordinates = [\n            extent[0],\n            extent[1],\n            extent[2],\n            extent[1],\n            extent[2],\n            extent[3],\n            extent[0],\n            extent[3],\n        ];\n    }\n    transformFn(coordinates, coordinates, 2);\n    var xs = [];\n    var ys = [];\n    for (var i = 0, l = coordinates.length; i < l; i += 2) {\n        xs.push(coordinates[i]);\n        ys.push(coordinates[i + 1]);\n    }\n    return _boundingExtentXYs(xs, ys, opt_extent);\n}\n/**\n * Modifies the provided extent in-place to be within the real world\n * extent.\n *\n * @param {Extent} extent Extent.\n * @param {import(\"./proj/Projection.js\").default} projection Projection\n * @return {Extent} The extent within the real world extent.\n */\nexport function wrapX(extent, projection) {\n    var projectionExtent = projection.getExtent();\n    var center = getCenter(extent);\n    if (projection.canWrapX() &&\n        (center[0] < projectionExtent[0] || center[0] >= projectionExtent[2])) {\n        var worldWidth = getWidth(projectionExtent);\n        var worldsAway = Math.floor((center[0] - projectionExtent[0]) / worldWidth);\n        var offset = worldsAway * worldWidth;\n        extent[0] -= offset;\n        extent[2] -= offset;\n    }\n    return extent;\n}\n//# sourceMappingURL=extent.js.map","/**\n * @module ol/extent/Corner\n */\n/**\n * Extent corner.\n * @enum {string}\n */\nexport default {\n    BOTTOM_LEFT: 'bottom-left',\n    BOTTOM_RIGHT: 'bottom-right',\n    TOP_LEFT: 'top-left',\n    TOP_RIGHT: 'top-right',\n};\n//# sourceMappingURL=Corner.js.map","/**\n * @module ol/extent/Relationship\n */\n/**\n * Relationship to an extent.\n * @enum {number}\n */\nexport default {\n    UNKNOWN: 0,\n    INTERSECTING: 1,\n    ABOVE: 2,\n    RIGHT: 4,\n    BELOW: 8,\n    LEFT: 16,\n};\n//# sourceMappingURL=Relationship.js.map","/**\n * @module ol/format/FormatType\n */\n/**\n * @enum {string}\n */\nexport default {\n    ARRAY_BUFFER: 'arraybuffer',\n    JSON: 'json',\n    TEXT: 'text',\n    XML: 'xml',\n};\n//# sourceMappingURL=FormatType.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/GeometryCollection\n */\nimport EventType from '../events/EventType.js';\nimport Geometry from './Geometry.js';\nimport GeometryType from './GeometryType.js';\nimport { closestSquaredDistanceXY, createOrUpdateEmpty, extend, getCenter, } from '../extent.js';\nimport { listen, unlistenByKey } from '../events.js';\n/**\n * @classdesc\n * An array of {@link module:ol/geom/Geometry} objects.\n *\n * @api\n */\nvar GeometryCollection = /** @class */ (function (_super) {\n    __extends(GeometryCollection, _super);\n    /**\n     * @param {Array<Geometry>} [opt_geometries] Geometries.\n     */\n    function GeometryCollection(opt_geometries) {\n        var _this = _super.call(this) || this;\n        /**\n         * @private\n         * @type {Array<Geometry>}\n         */\n        _this.geometries_ = opt_geometries ? opt_geometries : null;\n        /**\n         * @type {Array<import(\"../events.js\").EventsKey>}\n         */\n        _this.changeEventsKeys_ = [];\n        _this.listenGeometriesChange_();\n        return _this;\n    }\n    /**\n     * @private\n     */\n    GeometryCollection.prototype.unlistenGeometriesChange_ = function () {\n        this.changeEventsKeys_.forEach(unlistenByKey);\n        this.changeEventsKeys_.length = 0;\n    };\n    /**\n     * @private\n     */\n    GeometryCollection.prototype.listenGeometriesChange_ = function () {\n        if (!this.geometries_) {\n            return;\n        }\n        for (var i = 0, ii = this.geometries_.length; i < ii; ++i) {\n            this.changeEventsKeys_.push(listen(this.geometries_[i], EventType.CHANGE, this.changed, this));\n        }\n    };\n    /**\n     * Make a complete copy of the geometry.\n     * @return {!GeometryCollection} Clone.\n     * @api\n     */\n    GeometryCollection.prototype.clone = function () {\n        var geometryCollection = new GeometryCollection(null);\n        geometryCollection.setGeometries(this.geometries_);\n        geometryCollection.applyProperties(this);\n        return geometryCollection;\n    };\n    /**\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @param {import(\"../coordinate.js\").Coordinate} closestPoint Closest point.\n     * @param {number} minSquaredDistance Minimum squared distance.\n     * @return {number} Minimum squared distance.\n     */\n    GeometryCollection.prototype.closestPointXY = function (x, y, closestPoint, minSquaredDistance) {\n        if (minSquaredDistance < closestSquaredDistanceXY(this.getExtent(), x, y)) {\n            return minSquaredDistance;\n        }\n        var geometries = this.geometries_;\n        for (var i = 0, ii = geometries.length; i < ii; ++i) {\n            minSquaredDistance = geometries[i].closestPointXY(x, y, closestPoint, minSquaredDistance);\n        }\n        return minSquaredDistance;\n    };\n    /**\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @return {boolean} Contains (x, y).\n     */\n    GeometryCollection.prototype.containsXY = function (x, y) {\n        var geometries = this.geometries_;\n        for (var i = 0, ii = geometries.length; i < ii; ++i) {\n            if (geometries[i].containsXY(x, y)) {\n                return true;\n            }\n        }\n        return false;\n    };\n    /**\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @protected\n     * @return {import(\"../extent.js\").Extent} extent Extent.\n     */\n    GeometryCollection.prototype.computeExtent = function (extent) {\n        createOrUpdateEmpty(extent);\n        var geometries = this.geometries_;\n        for (var i = 0, ii = geometries.length; i < ii; ++i) {\n            extend(extent, geometries[i].getExtent());\n        }\n        return extent;\n    };\n    /**\n     * Return the geometries that make up this geometry collection.\n     * @return {Array<Geometry>} Geometries.\n     * @api\n     */\n    GeometryCollection.prototype.getGeometries = function () {\n        return cloneGeometries(this.geometries_);\n    };\n    /**\n     * @return {Array<Geometry>} Geometries.\n     */\n    GeometryCollection.prototype.getGeometriesArray = function () {\n        return this.geometries_;\n    };\n    /**\n     * @return {Array<Geometry>} Geometries.\n     */\n    GeometryCollection.prototype.getGeometriesArrayRecursive = function () {\n        /** @type {Array<Geometry>} */\n        var geometriesArray = [];\n        var geometries = this.geometries_;\n        for (var i = 0, ii = geometries.length; i < ii; ++i) {\n            if (geometries[i].getType() === this.getType()) {\n                geometriesArray = geometriesArray.concat(\n                /** @type {GeometryCollection} */ (geometries[i]).getGeometriesArrayRecursive());\n            }\n            else {\n                geometriesArray.push(geometries[i]);\n            }\n        }\n        return geometriesArray;\n    };\n    /**\n     * Create a simplified version of this geometry using the Douglas Peucker algorithm.\n     * @param {number} squaredTolerance Squared tolerance.\n     * @return {GeometryCollection} Simplified GeometryCollection.\n     */\n    GeometryCollection.prototype.getSimplifiedGeometry = function (squaredTolerance) {\n        if (this.simplifiedGeometryRevision !== this.getRevision()) {\n            this.simplifiedGeometryMaxMinSquaredTolerance = 0;\n            this.simplifiedGeometryRevision = this.getRevision();\n        }\n        if (squaredTolerance < 0 ||\n            (this.simplifiedGeometryMaxMinSquaredTolerance !== 0 &&\n                squaredTolerance < this.simplifiedGeometryMaxMinSquaredTolerance)) {\n            return this;\n        }\n        var simplifiedGeometries = [];\n        var geometries = this.geometries_;\n        var simplified = false;\n        for (var i = 0, ii = geometries.length; i < ii; ++i) {\n            var geometry = geometries[i];\n            var simplifiedGeometry = geometry.getSimplifiedGeometry(squaredTolerance);\n            simplifiedGeometries.push(simplifiedGeometry);\n            if (simplifiedGeometry !== geometry) {\n                simplified = true;\n            }\n        }\n        if (simplified) {\n            var simplifiedGeometryCollection = new GeometryCollection(null);\n            simplifiedGeometryCollection.setGeometriesArray(simplifiedGeometries);\n            return simplifiedGeometryCollection;\n        }\n        else {\n            this.simplifiedGeometryMaxMinSquaredTolerance = squaredTolerance;\n            return this;\n        }\n    };\n    /**\n     * Get the type of this geometry.\n     * @return {import(\"./GeometryType.js\").default} Geometry type.\n     * @api\n     */\n    GeometryCollection.prototype.getType = function () {\n        return GeometryType.GEOMETRY_COLLECTION;\n    };\n    /**\n     * Test if the geometry and the passed extent intersect.\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @return {boolean} `true` if the geometry and the extent intersect.\n     * @api\n     */\n    GeometryCollection.prototype.intersectsExtent = function (extent) {\n        var geometries = this.geometries_;\n        for (var i = 0, ii = geometries.length; i < ii; ++i) {\n            if (geometries[i].intersectsExtent(extent)) {\n                return true;\n            }\n        }\n        return false;\n    };\n    /**\n     * @return {boolean} Is empty.\n     */\n    GeometryCollection.prototype.isEmpty = function () {\n        return this.geometries_.length === 0;\n    };\n    /**\n     * Rotate the geometry around a given coordinate. This modifies the geometry\n     * coordinates in place.\n     * @param {number} angle Rotation angle in radians.\n     * @param {import(\"../coordinate.js\").Coordinate} anchor The rotation center.\n     * @api\n     */\n    GeometryCollection.prototype.rotate = function (angle, anchor) {\n        var geometries = this.geometries_;\n        for (var i = 0, ii = geometries.length; i < ii; ++i) {\n            geometries[i].rotate(angle, anchor);\n        }\n        this.changed();\n    };\n    /**\n     * Scale the geometry (with an optional origin).  This modifies the geometry\n     * coordinates in place.\n     * @abstract\n     * @param {number} sx The scaling factor in the x-direction.\n     * @param {number} [opt_sy] The scaling factor in the y-direction (defaults to sx).\n     * @param {import(\"../coordinate.js\").Coordinate} [opt_anchor] The scale origin (defaults to the center\n     *     of the geometry extent).\n     * @api\n     */\n    GeometryCollection.prototype.scale = function (sx, opt_sy, opt_anchor) {\n        var anchor = opt_anchor;\n        if (!anchor) {\n            anchor = getCenter(this.getExtent());\n        }\n        var geometries = this.geometries_;\n        for (var i = 0, ii = geometries.length; i < ii; ++i) {\n            geometries[i].scale(sx, opt_sy, anchor);\n        }\n        this.changed();\n    };\n    /**\n     * Set the geometries that make up this geometry collection.\n     * @param {Array<Geometry>} geometries Geometries.\n     * @api\n     */\n    GeometryCollection.prototype.setGeometries = function (geometries) {\n        this.setGeometriesArray(cloneGeometries(geometries));\n    };\n    /**\n     * @param {Array<Geometry>} geometries Geometries.\n     */\n    GeometryCollection.prototype.setGeometriesArray = function (geometries) {\n        this.unlistenGeometriesChange_();\n        this.geometries_ = geometries;\n        this.listenGeometriesChange_();\n        this.changed();\n    };\n    /**\n     * Apply a transform function to the coordinates of the geometry.\n     * The geometry is modified in place.\n     * If you do not want the geometry modified in place, first `clone()` it and\n     * then use this function on the clone.\n     * @param {import(\"../proj.js\").TransformFunction} transformFn Transform function.\n     * Called with a flat array of geometry coordinates.\n     * @api\n     */\n    GeometryCollection.prototype.applyTransform = function (transformFn) {\n        var geometries = this.geometries_;\n        for (var i = 0, ii = geometries.length; i < ii; ++i) {\n            geometries[i].applyTransform(transformFn);\n        }\n        this.changed();\n    };\n    /**\n     * Translate the geometry.  This modifies the geometry coordinates in place.  If\n     * instead you want a new geometry, first `clone()` this geometry.\n     * @param {number} deltaX Delta X.\n     * @param {number} deltaY Delta Y.\n     * @api\n     */\n    GeometryCollection.prototype.translate = function (deltaX, deltaY) {\n        var geometries = this.geometries_;\n        for (var i = 0, ii = geometries.length; i < ii; ++i) {\n            geometries[i].translate(deltaX, deltaY);\n        }\n        this.changed();\n    };\n    /**\n     * Clean up.\n     */\n    GeometryCollection.prototype.disposeInternal = function () {\n        this.unlistenGeometriesChange_();\n        _super.prototype.disposeInternal.call(this);\n    };\n    return GeometryCollection;\n}(Geometry));\n/**\n * @param {Array<Geometry>} geometries Geometries.\n * @return {Array<Geometry>} Cloned geometries.\n */\nfunction cloneGeometries(geometries) {\n    var clonedGeometries = [];\n    for (var i = 0, ii = geometries.length; i < ii; ++i) {\n        clonedGeometries.push(geometries[i].clone());\n    }\n    return clonedGeometries;\n}\nexport default GeometryCollection;\n//# sourceMappingURL=GeometryCollection.js.map","/**\n * @module ol/format/Feature\n */\nimport Units from '../proj/Units.js';\nimport { abstract } from '../util.js';\nimport { assign } from '../obj.js';\nimport { equivalent as equivalentProjection, get as getProjection, transformExtent, } from '../proj.js';\n/**\n * @typedef {Object} ReadOptions\n * @property {import(\"../proj.js\").ProjectionLike} [dataProjection] Projection of the data we are reading.\n * If not provided, the projection will be derived from the data (where possible) or\n * the `dataProjection` of the format is assigned (where set). If the projection\n * can not be derived from the data and if no `dataProjection` is set for a format,\n * the features will not be reprojected.\n * @property {import(\"../extent.js\").Extent} [extent] Tile extent in map units of the tile being read.\n * This is only required when reading data with tile pixels as geometry units. When configured,\n * a `dataProjection` with `TILE_PIXELS` as `units` and the tile's pixel extent as `extent` needs to be\n * provided.\n * @property {import(\"../proj.js\").ProjectionLike} [featureProjection] Projection of the feature geometries\n * created by the format reader. If not provided, features will be returned in the\n * `dataProjection`.\n */\n/**\n * @typedef {Object} WriteOptions\n * @property {import(\"../proj.js\").ProjectionLike} [dataProjection] Projection of the data we are writing.\n * If not provided, the `dataProjection` of the format is assigned (where set).\n * If no `dataProjection` is set for a format, the features will be returned\n * in the `featureProjection`.\n * @property {import(\"../proj.js\").ProjectionLike} [featureProjection] Projection of the feature geometries\n * that will be serialized by the format writer. If not provided, geometries are assumed\n * to be in the `dataProjection` if that is set; in other words, they are not transformed.\n * @property {boolean} [rightHanded] When writing geometries, follow the right-hand\n * rule for linear ring orientation.  This means that polygons will have counter-clockwise\n * exterior rings and clockwise interior rings.  By default, coordinates are serialized\n * as they are provided at construction.  If `true`, the right-hand rule will\n * be applied.  If `false`, the left-hand rule will be applied (clockwise for\n * exterior and counter-clockwise for interior rings).  Note that not all\n * formats support this.  The GeoJSON format does use this property when writing\n * geometries.\n * @property {number} [decimals] Maximum number of decimal places for coordinates.\n * Coordinates are stored internally as floats, but floating-point arithmetic can create\n * coordinates with a large number of decimal places, not generally wanted on output.\n * Set a number here to round coordinates. Can also be used to ensure that\n * coordinates read in can be written back out with the same number of decimals.\n * Default is no rounding.\n */\n/**\n * @classdesc\n * Abstract base class; normally only used for creating subclasses and not\n * instantiated in apps.\n * Base class for feature formats.\n * {@link module:ol/format/Feature~FeatureFormat} subclasses provide the ability to decode and encode\n * {@link module:ol/Feature~Feature} objects from a variety of commonly used geospatial\n * file formats.  See the documentation for each format for more details.\n *\n * @abstract\n * @api\n */\nvar FeatureFormat = /** @class */ (function () {\n    function FeatureFormat() {\n        /**\n         * @protected\n         * @type {import(\"../proj/Projection.js\").default|undefined}\n         */\n        this.dataProjection = undefined;\n        /**\n         * @protected\n         * @type {import(\"../proj/Projection.js\").default|undefined}\n         */\n        this.defaultFeatureProjection = undefined;\n        /**\n         * A list media types supported by the format in descending order of preference.\n         * @type {Array<string>}\n         */\n        this.supportedMediaTypes = null;\n    }\n    /**\n     * Adds the data projection to the read options.\n     * @param {Document|Element|Object|string} source Source.\n     * @param {ReadOptions} [opt_options] Options.\n     * @return {ReadOptions|undefined} Options.\n     * @protected\n     */\n    FeatureFormat.prototype.getReadOptions = function (source, opt_options) {\n        var options;\n        if (opt_options) {\n            var dataProjection = opt_options.dataProjection\n                ? getProjection(opt_options.dataProjection)\n                : this.readProjection(source);\n            if (opt_options.extent &&\n                dataProjection &&\n                dataProjection.getUnits() === Units.TILE_PIXELS) {\n                dataProjection = getProjection(dataProjection);\n                dataProjection.setWorldExtent(opt_options.extent);\n            }\n            options = {\n                dataProjection: dataProjection,\n                featureProjection: opt_options.featureProjection,\n            };\n        }\n        return this.adaptOptions(options);\n    };\n    /**\n     * Sets the `dataProjection` on the options, if no `dataProjection`\n     * is set.\n     * @param {WriteOptions|ReadOptions|undefined} options\n     *     Options.\n     * @protected\n     * @return {WriteOptions|ReadOptions|undefined}\n     *     Updated options.\n     */\n    FeatureFormat.prototype.adaptOptions = function (options) {\n        return assign({\n            dataProjection: this.dataProjection,\n            featureProjection: this.defaultFeatureProjection,\n        }, options);\n    };\n    /**\n     * @abstract\n     * @return {import(\"./FormatType.js\").default} Format.\n     */\n    FeatureFormat.prototype.getType = function () {\n        return abstract();\n    };\n    /**\n     * Read a single feature from a source.\n     *\n     * @abstract\n     * @param {Document|Element|Object|string} source Source.\n     * @param {ReadOptions} [opt_options] Read options.\n     * @return {import(\"../Feature.js\").FeatureLike} Feature.\n     */\n    FeatureFormat.prototype.readFeature = function (source, opt_options) {\n        return abstract();\n    };\n    /**\n     * Read all features from a source.\n     *\n     * @abstract\n     * @param {Document|Element|ArrayBuffer|Object|string} source Source.\n     * @param {ReadOptions} [opt_options] Read options.\n     * @return {Array<import(\"../Feature.js\").FeatureLike>} Features.\n     */\n    FeatureFormat.prototype.readFeatures = function (source, opt_options) {\n        return abstract();\n    };\n    /**\n     * Read a single geometry from a source.\n     *\n     * @abstract\n     * @param {Document|Element|Object|string} source Source.\n     * @param {ReadOptions} [opt_options] Read options.\n     * @return {import(\"../geom/Geometry.js\").default} Geometry.\n     */\n    FeatureFormat.prototype.readGeometry = function (source, opt_options) {\n        return abstract();\n    };\n    /**\n     * Read the projection from a source.\n     *\n     * @abstract\n     * @param {Document|Element|Object|string} source Source.\n     * @return {import(\"../proj/Projection.js\").default|undefined} Projection.\n     */\n    FeatureFormat.prototype.readProjection = function (source) {\n        return abstract();\n    };\n    /**\n     * Encode a feature in this format.\n     *\n     * @abstract\n     * @param {import(\"../Feature.js\").default} feature Feature.\n     * @param {WriteOptions} [opt_options] Write options.\n     * @return {string|ArrayBuffer} Result.\n     */\n    FeatureFormat.prototype.writeFeature = function (feature, opt_options) {\n        return abstract();\n    };\n    /**\n     * Encode an array of features in this format.\n     *\n     * @abstract\n     * @param {Array<import(\"../Feature.js\").default>} features Features.\n     * @param {WriteOptions} [opt_options] Write options.\n     * @return {string|ArrayBuffer} Result.\n     */\n    FeatureFormat.prototype.writeFeatures = function (features, opt_options) {\n        return abstract();\n    };\n    /**\n     * Write a single geometry in this format.\n     *\n     * @abstract\n     * @param {import(\"../geom/Geometry.js\").default} geometry Geometry.\n     * @param {WriteOptions} [opt_options] Write options.\n     * @return {string|ArrayBuffer} Result.\n     */\n    FeatureFormat.prototype.writeGeometry = function (geometry, opt_options) {\n        return abstract();\n    };\n    return FeatureFormat;\n}());\nexport default FeatureFormat;\n/**\n * @param {import(\"../geom/Geometry.js\").default} geometry Geometry.\n * @param {boolean} write Set to true for writing, false for reading.\n * @param {WriteOptions|ReadOptions} [opt_options] Options.\n * @return {import(\"../geom/Geometry.js\").default} Transformed geometry.\n */\nexport function transformGeometryWithOptions(geometry, write, opt_options) {\n    var featureProjection = opt_options\n        ? getProjection(opt_options.featureProjection)\n        : null;\n    var dataProjection = opt_options\n        ? getProjection(opt_options.dataProjection)\n        : null;\n    var transformed;\n    if (featureProjection &&\n        dataProjection &&\n        !equivalentProjection(featureProjection, dataProjection)) {\n        transformed = (write ? geometry.clone() : geometry).transform(write ? featureProjection : dataProjection, write ? dataProjection : featureProjection);\n    }\n    else {\n        transformed = geometry;\n    }\n    if (write &&\n        opt_options &&\n        /** @type {WriteOptions} */ (opt_options).decimals !== undefined) {\n        var power_1 = Math.pow(10, \n        /** @type {WriteOptions} */ (opt_options).decimals);\n        // if decimals option on write, round each coordinate appropriately\n        /**\n         * @param {Array<number>} coordinates Coordinates.\n         * @return {Array<number>} Transformed coordinates.\n         */\n        var transform = function (coordinates) {\n            for (var i = 0, ii = coordinates.length; i < ii; ++i) {\n                coordinates[i] = Math.round(coordinates[i] * power_1) / power_1;\n            }\n            return coordinates;\n        };\n        if (transformed === geometry) {\n            transformed = geometry.clone();\n        }\n        transformed.applyTransform(transform);\n    }\n    return transformed;\n}\n/**\n * @param {import(\"../extent.js\").Extent} extent Extent.\n * @param {ReadOptions} [opt_options] Read options.\n * @return {import(\"../extent.js\").Extent} Transformed extent.\n */\nexport function transformExtentWithOptions(extent, opt_options) {\n    var featureProjection = opt_options\n        ? getProjection(opt_options.featureProjection)\n        : null;\n    var dataProjection = opt_options\n        ? getProjection(opt_options.dataProjection)\n        : null;\n    if (featureProjection &&\n        dataProjection &&\n        !equivalentProjection(featureProjection, dataProjection)) {\n        return transformExtent(extent, dataProjection, featureProjection);\n    }\n    else {\n        return extent;\n    }\n}\n//# sourceMappingURL=Feature.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/format/JSONFeature\n */\nimport FeatureFormat from './Feature.js';\nimport FormatType from './FormatType.js';\nimport { abstract } from '../util.js';\n/**\n * @classdesc\n * Abstract base class; normally only used for creating subclasses and not\n * instantiated in apps.\n * Base class for JSON feature formats.\n *\n * @abstract\n */\nvar JSONFeature = /** @class */ (function (_super) {\n    __extends(JSONFeature, _super);\n    function JSONFeature() {\n        return _super.call(this) || this;\n    }\n    /**\n     * @return {import(\"./FormatType.js\").default} Format.\n     */\n    JSONFeature.prototype.getType = function () {\n        return FormatType.JSON;\n    };\n    /**\n     * Read a feature.  Only works for a single feature. Use `readFeatures` to\n     * read a feature collection.\n     *\n     * @param {ArrayBuffer|Document|Element|Object|string} source Source.\n     * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n     * @return {import(\"../Feature.js\").default} Feature.\n     * @api\n     */\n    JSONFeature.prototype.readFeature = function (source, opt_options) {\n        return this.readFeatureFromObject(getObject(source), this.getReadOptions(source, opt_options));\n    };\n    /**\n     * Read all features.  Works with both a single feature and a feature\n     * collection.\n     *\n     * @param {ArrayBuffer|Document|Element|Object|string} source Source.\n     * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n     * @return {Array<import(\"../Feature.js\").default>} Features.\n     * @api\n     */\n    JSONFeature.prototype.readFeatures = function (source, opt_options) {\n        return this.readFeaturesFromObject(getObject(source), this.getReadOptions(source, opt_options));\n    };\n    /**\n     * @abstract\n     * @param {Object} object Object.\n     * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n     * @protected\n     * @return {import(\"../Feature.js\").default} Feature.\n     */\n    JSONFeature.prototype.readFeatureFromObject = function (object, opt_options) {\n        return abstract();\n    };\n    /**\n     * @abstract\n     * @param {Object} object Object.\n     * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n     * @protected\n     * @return {Array<import(\"../Feature.js\").default>} Features.\n     */\n    JSONFeature.prototype.readFeaturesFromObject = function (object, opt_options) {\n        return abstract();\n    };\n    /**\n     * Read a geometry.\n     *\n     * @param {ArrayBuffer|Document|Element|Object|string} source Source.\n     * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n     * @return {import(\"../geom/Geometry.js\").default} Geometry.\n     * @api\n     */\n    JSONFeature.prototype.readGeometry = function (source, opt_options) {\n        return this.readGeometryFromObject(getObject(source), this.getReadOptions(source, opt_options));\n    };\n    /**\n     * @abstract\n     * @param {Object} object Object.\n     * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n     * @protected\n     * @return {import(\"../geom/Geometry.js\").default} Geometry.\n     */\n    JSONFeature.prototype.readGeometryFromObject = function (object, opt_options) {\n        return abstract();\n    };\n    /**\n     * Read the projection.\n     *\n     * @param {ArrayBuffer|Document|Element|Object|string} source Source.\n     * @return {import(\"../proj/Projection.js\").default} Projection.\n     * @api\n     */\n    JSONFeature.prototype.readProjection = function (source) {\n        return this.readProjectionFromObject(getObject(source));\n    };\n    /**\n     * @abstract\n     * @param {Object} object Object.\n     * @protected\n     * @return {import(\"../proj/Projection.js\").default} Projection.\n     */\n    JSONFeature.prototype.readProjectionFromObject = function (object) {\n        return abstract();\n    };\n    /**\n     * Encode a feature as string.\n     *\n     * @param {import(\"../Feature.js\").default} feature Feature.\n     * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n     * @return {string} Encoded feature.\n     * @api\n     */\n    JSONFeature.prototype.writeFeature = function (feature, opt_options) {\n        return JSON.stringify(this.writeFeatureObject(feature, opt_options));\n    };\n    /**\n     * @abstract\n     * @param {import(\"../Feature.js\").default} feature Feature.\n     * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n     * @return {Object} Object.\n     */\n    JSONFeature.prototype.writeFeatureObject = function (feature, opt_options) {\n        return abstract();\n    };\n    /**\n     * Encode an array of features as string.\n     *\n     * @param {Array<import(\"../Feature.js\").default>} features Features.\n     * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n     * @return {string} Encoded features.\n     * @api\n     */\n    JSONFeature.prototype.writeFeatures = function (features, opt_options) {\n        return JSON.stringify(this.writeFeaturesObject(features, opt_options));\n    };\n    /**\n     * @abstract\n     * @param {Array<import(\"../Feature.js\").default>} features Features.\n     * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n     * @return {Object} Object.\n     */\n    JSONFeature.prototype.writeFeaturesObject = function (features, opt_options) {\n        return abstract();\n    };\n    /**\n     * Encode a geometry as string.\n     *\n     * @param {import(\"../geom/Geometry.js\").default} geometry Geometry.\n     * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n     * @return {string} Encoded geometry.\n     * @api\n     */\n    JSONFeature.prototype.writeGeometry = function (geometry, opt_options) {\n        return JSON.stringify(this.writeGeometryObject(geometry, opt_options));\n    };\n    /**\n     * @abstract\n     * @param {import(\"../geom/Geometry.js\").default} geometry Geometry.\n     * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n     * @return {Object} Object.\n     */\n    JSONFeature.prototype.writeGeometryObject = function (geometry, opt_options) {\n        return abstract();\n    };\n    return JSONFeature;\n}(FeatureFormat));\n/**\n * @param {Document|Element|Object|string} source Source.\n * @return {Object} Object.\n */\nfunction getObject(source) {\n    if (typeof source === 'string') {\n        var object = JSON.parse(source);\n        return object ? /** @type {Object} */ (object) : null;\n    }\n    else if (source !== null) {\n        return source;\n    }\n    else {\n        return null;\n    }\n}\nexport default JSONFeature;\n//# sourceMappingURL=JSONFeature.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 * @param {number} [opt_dimension] Destination dimension (default is `2`)\n * @return {Array<number>} Destination.\n */\nexport function interpolatePoint(flatCoordinates, offset, end, stride, fraction, opt_dest, opt_dimension) {\n    var o, t;\n    var n = (end - offset) / stride;\n    if (n === 1) {\n        o = offset;\n    }\n    else if (n === 2) {\n        o = offset;\n        t = fraction;\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            t =\n                (target - cumulativeLengths[-index - 2]) /\n                    (cumulativeLengths[-index - 1] - cumulativeLengths[-index - 2]);\n            o = offset + (-index - 2) * stride;\n        }\n        else {\n            o = offset + index * stride;\n        }\n    }\n    var dimension = opt_dimension > 1 ? opt_dimension : 2;\n    var dest = opt_dest ? opt_dest : new Array(dimension);\n    for (var i = 0; i < dimension; ++i) {\n        dest[i] =\n            o === undefined\n                ? NaN\n                : t === undefined\n                    ? flatCoordinates[o + i]\n                    : lerp(flatCoordinates[o + i], flatCoordinates[o + stride + i], t);\n    }\n    return dest;\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","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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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 GeometryLayout from './GeometryLayout.js';\nimport GeometryType from './GeometryType.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { assignClosestPoint, maxSquaredDelta } from './flat/closest.js';\nimport { closestSquaredDistanceXY } from '../extent.js';\nimport { deflateCoordinates } from './flat/deflate.js';\nimport { douglasPeucker } from './flat/simplify.js';\nimport { extend } from '../array.js';\nimport { forEach as forEachSegment } from './flat/segments.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';\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 {import(\"./GeometryLayout.js\").default} [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, \n            /** @type {Array<number>} */ (coordinates));\n        }\n        else {\n            _this.setCoordinates(\n            /** @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     * @api\n     */\n    LineString.prototype.clone = function () {\n        var lineString = new LineString(this.flatCoordinates.slice(), this.layout);\n        lineString.applyProperties(this);\n        return lineString;\n    };\n    /**\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @param {import(\"../coordinate.js\").Coordinate} closestPoint Closest point.\n     * @param {number} minSquaredDistance Minimum squared distance.\n     * @return {number} Minimum squared distance.\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     * @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, this.stride);\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     * @param {number} squaredTolerance Squared tolerance.\n     * @return {LineString} Simplified LineString.\n     * @protected\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     * Get the type of this geometry.\n     * @return {import(\"./GeometryType.js\").default} Geometry type.\n     * @api\n     */\n    LineString.prototype.getType = function () {\n        return GeometryType.LINE_STRING;\n    };\n    /**\n     * Test if the geometry and the passed extent intersect.\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @return {boolean} `true` if the geometry and the extent intersect.\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 {import(\"./GeometryLayout.js\").default} [opt_layout] Layout.\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","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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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 GeometryLayout from './GeometryLayout.js';\nimport GeometryType from './GeometryType.js';\nimport LineString from './LineString.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { arrayMaxSquaredDelta, assignClosestArrayPoint } from './flat/closest.js';\nimport { closestSquaredDistanceXY } from '../extent.js';\nimport { deflateCoordinatesArray } from './flat/deflate.js';\nimport { douglasPeuckerArray } from './flat/simplify.js';\nimport { extend } from '../array.js';\nimport { inflateCoordinatesArray } from './flat/inflate.js';\nimport { interpolatePoint, lineStringsCoordinateAtM, } from './flat/interpolate.js';\nimport { intersectsLineStringArray } from './flat/intersectsextent.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 {import(\"./GeometryLayout.js\").default} [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(\n            /** @type {Array<Array<import(\"../coordinate.js\").Coordinate>>} */ (coordinates), opt_layout);\n        }\n        else if (opt_layout !== undefined && opt_ends) {\n            _this.setFlatCoordinates(opt_layout, \n            /** @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     * @api\n     */\n    MultiLineString.prototype.clone = function () {\n        var multiLineString = new MultiLineString(this.flatCoordinates.slice(), this.layout, this.ends_.slice());\n        multiLineString.applyProperties(this);\n        return multiLineString;\n    };\n    /**\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @param {import(\"../coordinate.js\").Coordinate} closestPoint Closest point.\n     * @param {number} minSquaredDistance Minimum squared distance.\n     * @return {number} Minimum squared distance.\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     * @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     * @param {number} squaredTolerance Squared tolerance.\n     * @return {MultiLineString} Simplified MultiLineString.\n     * @protected\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     * Get the type of this geometry.\n     * @return {import(\"./GeometryType.js\").default} Geometry type.\n     * @api\n     */\n    MultiLineString.prototype.getType = function () {\n        return GeometryType.MULTI_LINE_STRING;\n    };\n    /**\n     * Test if the geometry and the passed extent intersect.\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @return {boolean} `true` if the geometry and the extent intersect.\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     * @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","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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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 GeometryType from './GeometryType.js';\nimport Point from './Point.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { closestSquaredDistanceXY, containsXY } from '../extent.js';\nimport { deflateCoordinates } from './flat/deflate.js';\nimport { extend } from '../array.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, \n            /** @type {Array<number>} */ (coordinates));\n        }\n        else {\n            _this.setCoordinates(\n            /** @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     * @api\n     */\n    MultiPoint.prototype.clone = function () {\n        var multiPoint = new MultiPoint(this.flatCoordinates.slice(), this.layout);\n        multiPoint.applyProperties(this);\n        return multiPoint;\n    };\n    /**\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @param {import(\"../coordinate.js\").Coordinate} closestPoint Closest point.\n     * @param {number} minSquaredDistance Minimum squared distance.\n     * @return {number} Minimum squared distance.\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     * @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\n            ? 0\n            : 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     * Get the type of this geometry.\n     * @return {import(\"./GeometryType.js\").default} Geometry type.\n     * @api\n     */\n    MultiPoint.prototype.getType = function () {\n        return GeometryType.MULTI_POINT;\n    };\n    /**\n     * Test if the geometry and the passed extent intersect.\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @return {boolean} `true` if the geometry and the extent intersect.\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     * @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","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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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 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 { assignClosestMultiArrayPoint, multiArrayMaxSquaredDelta, } from './flat/closest.js';\nimport { closestSquaredDistanceXY } from '../extent.js';\nimport { deflateMultiCoordinatesArray } from './flat/deflate.js';\nimport { extend } from '../array.js';\nimport { getInteriorPointsOfMultiArray } from './flat/interiorpoint.js';\nimport { inflateMultiCoordinatesArray } from './flat/inflate.js';\nimport { intersectsLinearRingMultiArray } from './flat/intersectsextent.js';\nimport { linearRingssAreOriented, orientLinearRingsArray, } from './flat/orient.js';\nimport { linearRingss as linearRingssArea } from './flat/area.js';\nimport { linearRingss as linearRingssCenter } from './flat/center.js';\nimport { linearRingssContainsXY } from './flat/contains.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 {import(\"./GeometryLayout.js\").default} [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, \n            /** @type {Array<number>} */ (coordinates));\n            _this.endss_ = opt_endss;\n        }\n        else {\n            _this.setCoordinates(\n            /** @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     * @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        var multiPolygon = new MultiPolygon(this.flatCoordinates.slice(), this.layout, newEndss);\n        multiPolygon.applyProperties(this);\n        return multiPolygon;\n    };\n    /**\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @param {import(\"../coordinate.js\").Coordinate} closestPoint Closest point.\n     * @param {number} minSquaredDistance Minimum squared distance.\n     * @return {number} Minimum squared distance.\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     * @param {number} x X.\n     * @param {number} y Y.\n     * @return {boolean} Contains (x, y).\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     * @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 = orientLinearRingsArray(this.orientedFlatCoordinates_, 0, this.endss_, this.stride);\n            }\n            this.orientedRevision_ = this.getRevision();\n        }\n        return this.orientedFlatCoordinates_;\n    };\n    /**\n     * @param {number} squaredTolerance Squared tolerance.\n     * @return {MultiPolygon} Simplified MultiPolygon.\n     * @protected\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     * Get the type of this geometry.\n     * @return {import(\"./GeometryType.js\").default} Geometry type.\n     * @api\n     */\n    MultiPolygon.prototype.getType = function () {\n        return GeometryType.MULTI_POLYGON;\n    };\n    /**\n     * Test if the geometry and the passed extent intersect.\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @return {boolean} `true` if the geometry and the extent intersect.\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 {import(\"./GeometryLayout.js\").default} [opt_layout] Layout.\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 =\n                lastEnds.length === 0 ? 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/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","/**\n * @module ol/format/GeoJSON\n */\nvar __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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport Feature from '../Feature.js';\nimport GeometryCollection from '../geom/GeometryCollection.js';\nimport GeometryType from '../geom/GeometryType.js';\nimport JSONFeature from './JSONFeature.js';\nimport LineString from '../geom/LineString.js';\nimport MultiLineString from '../geom/MultiLineString.js';\nimport MultiPoint from '../geom/MultiPoint.js';\nimport MultiPolygon from '../geom/MultiPolygon.js';\nimport Point from '../geom/Point.js';\nimport Polygon from '../geom/Polygon.js';\nimport { assert } from '../asserts.js';\nimport { assign, isEmpty } from '../obj.js';\nimport { get as getProjection } from '../proj.js';\nimport { transformGeometryWithOptions } from './Feature.js';\n/**\n * @typedef {import(\"geojson\").GeoJSON} GeoJSONObject\n * @typedef {import(\"geojson\").Feature} GeoJSONFeature\n * @typedef {import(\"geojson\").FeatureCollection} GeoJSONFeatureCollection\n * @typedef {import(\"geojson\").Geometry} GeoJSONGeometry\n * @typedef {import(\"geojson\").Point} GeoJSONPoint\n * @typedef {import(\"geojson\").LineString} GeoJSONLineString\n * @typedef {import(\"geojson\").Polygon} GeoJSONPolygon\n * @typedef {import(\"geojson\").MultiPoint} GeoJSONMultiPoint\n * @typedef {import(\"geojson\").MultiLineString} GeoJSONMultiLineString\n * @typedef {import(\"geojson\").MultiPolygon} GeoJSONMultiPolygon\n * @typedef {import(\"geojson\").GeometryCollection} GeoJSONGeometryCollection\n */\n/**\n * @typedef {Object} Options\n * @property {import(\"../proj.js\").ProjectionLike} [dataProjection='EPSG:4326'] Default data projection.\n * @property {import(\"../proj.js\").ProjectionLike} [featureProjection] Projection for features read or\n * written by the format.  Options passed to read or write methods will take precedence.\n * @property {string} [geometryName] Geometry name to use when creating features.\n * @property {boolean} [extractGeometryName=false] Certain GeoJSON providers include\n * the geometry_name field in the feature GeoJSON. If set to `true` the GeoJSON reader\n * will look for that field to set the geometry name. If both this field is set to `true`\n * and a `geometryName` is provided, the `geometryName` will take precedence.\n */\n/**\n * @classdesc\n * Feature format for reading and writing data in the GeoJSON format.\n *\n * @api\n */\nvar GeoJSON = /** @class */ (function (_super) {\n    __extends(GeoJSON, _super);\n    /**\n     * @param {Options} [opt_options] Options.\n     */\n    function GeoJSON(opt_options) {\n        var _this = this;\n        var options = opt_options ? opt_options : {};\n        _this = _super.call(this) || this;\n        /**\n         * @type {import(\"../proj/Projection.js\").default}\n         */\n        _this.dataProjection = getProjection(options.dataProjection ? options.dataProjection : 'EPSG:4326');\n        if (options.featureProjection) {\n            _this.defaultFeatureProjection = getProjection(options.featureProjection);\n        }\n        /**\n         * Name of the geometry attribute for features.\n         * @type {string|undefined}\n         * @private\n         */\n        _this.geometryName_ = options.geometryName;\n        /**\n         * Look for the geometry name in the feature GeoJSON\n         * @type {boolean|undefined}\n         * @private\n         */\n        _this.extractGeometryName_ = options.extractGeometryName;\n        _this.supportedMediaTypes = [\n            'application/geo+json',\n            'application/vnd.geo+json',\n        ];\n        return _this;\n    }\n    /**\n     * @param {Object} object Object.\n     * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n     * @protected\n     * @return {import(\"../Feature.js\").default} Feature.\n     */\n    GeoJSON.prototype.readFeatureFromObject = function (object, opt_options) {\n        /**\n         * @type {GeoJSONFeature}\n         */\n        var geoJSONFeature = null;\n        if (object['type'] === 'Feature') {\n            geoJSONFeature = /** @type {GeoJSONFeature} */ (object);\n        }\n        else {\n            geoJSONFeature = {\n                'type': 'Feature',\n                'geometry': /** @type {GeoJSONGeometry} */ (object),\n                'properties': null,\n            };\n        }\n        var geometry = readGeometry(geoJSONFeature['geometry'], opt_options);\n        var feature = new Feature();\n        if (this.geometryName_) {\n            feature.setGeometryName(this.geometryName_);\n        }\n        else if (this.extractGeometryName_ &&\n            'geometry_name' in geoJSONFeature !== undefined) {\n            feature.setGeometryName(geoJSONFeature['geometry_name']);\n        }\n        feature.setGeometry(geometry);\n        if ('id' in geoJSONFeature) {\n            feature.setId(geoJSONFeature['id']);\n        }\n        if (geoJSONFeature['properties']) {\n            feature.setProperties(geoJSONFeature['properties'], true);\n        }\n        return feature;\n    };\n    /**\n     * @param {Object} object Object.\n     * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n     * @protected\n     * @return {Array<Feature>} Features.\n     */\n    GeoJSON.prototype.readFeaturesFromObject = function (object, opt_options) {\n        var geoJSONObject = /** @type {GeoJSONObject} */ (object);\n        /** @type {Array<import(\"../Feature.js\").default>} */\n        var features = null;\n        if (geoJSONObject['type'] === 'FeatureCollection') {\n            var geoJSONFeatureCollection = /** @type {GeoJSONFeatureCollection} */ (object);\n            features = [];\n            var geoJSONFeatures = geoJSONFeatureCollection['features'];\n            for (var i = 0, ii = geoJSONFeatures.length; i < ii; ++i) {\n                features.push(this.readFeatureFromObject(geoJSONFeatures[i], opt_options));\n            }\n        }\n        else {\n            features = [this.readFeatureFromObject(object, opt_options)];\n        }\n        return features;\n    };\n    /**\n     * @param {GeoJSONGeometry} object Object.\n     * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n     * @protected\n     * @return {import(\"../geom/Geometry.js\").default} Geometry.\n     */\n    GeoJSON.prototype.readGeometryFromObject = function (object, opt_options) {\n        return readGeometry(object, opt_options);\n    };\n    /**\n     * @param {Object} object Object.\n     * @protected\n     * @return {import(\"../proj/Projection.js\").default} Projection.\n     */\n    GeoJSON.prototype.readProjectionFromObject = function (object) {\n        var crs = object['crs'];\n        var projection;\n        if (crs) {\n            if (crs['type'] == 'name') {\n                projection = getProjection(crs['properties']['name']);\n            }\n            else if (crs['type'] === 'EPSG') {\n                projection = getProjection('EPSG:' + crs['properties']['code']);\n            }\n            else {\n                assert(false, 36); // Unknown SRS type\n            }\n        }\n        else {\n            projection = this.dataProjection;\n        }\n        return /** @type {import(\"../proj/Projection.js\").default} */ (projection);\n    };\n    /**\n     * Encode a feature as a GeoJSON Feature object.\n     *\n     * @param {import(\"../Feature.js\").default} feature Feature.\n     * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n     * @return {GeoJSONFeature} Object.\n     * @api\n     */\n    GeoJSON.prototype.writeFeatureObject = function (feature, opt_options) {\n        opt_options = this.adaptOptions(opt_options);\n        /** @type {GeoJSONFeature} */\n        var object = {\n            'type': 'Feature',\n            geometry: null,\n            properties: null,\n        };\n        var id = feature.getId();\n        if (id !== undefined) {\n            object.id = id;\n        }\n        if (!feature.hasProperties()) {\n            return object;\n        }\n        var properties = feature.getProperties();\n        var geometry = feature.getGeometry();\n        if (geometry) {\n            object.geometry = writeGeometry(geometry, opt_options);\n            delete properties[feature.getGeometryName()];\n        }\n        if (!isEmpty(properties)) {\n            object.properties = properties;\n        }\n        return object;\n    };\n    /**\n     * Encode an array of features as a GeoJSON object.\n     *\n     * @param {Array<import(\"../Feature.js\").default>} features Features.\n     * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n     * @return {GeoJSONFeatureCollection} GeoJSON Object.\n     * @api\n     */\n    GeoJSON.prototype.writeFeaturesObject = function (features, opt_options) {\n        opt_options = this.adaptOptions(opt_options);\n        var objects = [];\n        for (var i = 0, ii = features.length; i < ii; ++i) {\n            objects.push(this.writeFeatureObject(features[i], opt_options));\n        }\n        return {\n            type: 'FeatureCollection',\n            features: objects,\n        };\n    };\n    /**\n     * Encode a geometry as a GeoJSON object.\n     *\n     * @param {import(\"../geom/Geometry.js\").default} geometry Geometry.\n     * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n     * @return {GeoJSONGeometry|GeoJSONGeometryCollection} Object.\n     * @api\n     */\n    GeoJSON.prototype.writeGeometryObject = function (geometry, opt_options) {\n        return writeGeometry(geometry, this.adaptOptions(opt_options));\n    };\n    return GeoJSON;\n}(JSONFeature));\n/**\n * @param {GeoJSONGeometry|GeoJSONGeometryCollection} object Object.\n * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n * @return {import(\"../geom/Geometry.js\").default} Geometry.\n */\nfunction readGeometry(object, opt_options) {\n    if (!object) {\n        return null;\n    }\n    /**\n     * @type {import(\"../geom/Geometry.js\").default}\n     */\n    var geometry;\n    switch (object['type']) {\n        case GeometryType.POINT: {\n            geometry = readPointGeometry(/** @type {GeoJSONPoint} */ (object));\n            break;\n        }\n        case GeometryType.LINE_STRING: {\n            geometry = readLineStringGeometry(\n            /** @type {GeoJSONLineString} */ (object));\n            break;\n        }\n        case GeometryType.POLYGON: {\n            geometry = readPolygonGeometry(/** @type {GeoJSONPolygon} */ (object));\n            break;\n        }\n        case GeometryType.MULTI_POINT: {\n            geometry = readMultiPointGeometry(\n            /** @type {GeoJSONMultiPoint} */ (object));\n            break;\n        }\n        case GeometryType.MULTI_LINE_STRING: {\n            geometry = readMultiLineStringGeometry(\n            /** @type {GeoJSONMultiLineString} */ (object));\n            break;\n        }\n        case GeometryType.MULTI_POLYGON: {\n            geometry = readMultiPolygonGeometry(\n            /** @type {GeoJSONMultiPolygon} */ (object));\n            break;\n        }\n        case GeometryType.GEOMETRY_COLLECTION: {\n            geometry = readGeometryCollectionGeometry(\n            /** @type {GeoJSONGeometryCollection} */ (object));\n            break;\n        }\n        default: {\n            throw new Error('Unsupported GeoJSON type: ' + object.type);\n        }\n    }\n    return transformGeometryWithOptions(geometry, false, opt_options);\n}\n/**\n * @param {GeoJSONGeometryCollection} object Object.\n * @param {import(\"./Feature.js\").ReadOptions} [opt_options] Read options.\n * @return {GeometryCollection} Geometry collection.\n */\nfunction readGeometryCollectionGeometry(object, opt_options) {\n    var geometries = object['geometries'].map(\n    /**\n     * @param {GeoJSONGeometry} geometry Geometry.\n     * @return {import(\"../geom/Geometry.js\").default} geometry Geometry.\n     */\n    function (geometry) {\n        return readGeometry(geometry, opt_options);\n    });\n    return new GeometryCollection(geometries);\n}\n/**\n * @param {GeoJSONPoint} object Object.\n * @return {Point} Point.\n */\nfunction readPointGeometry(object) {\n    return new Point(object['coordinates']);\n}\n/**\n * @param {GeoJSONLineString} object Object.\n * @return {LineString} LineString.\n */\nfunction readLineStringGeometry(object) {\n    return new LineString(object['coordinates']);\n}\n/**\n * @param {GeoJSONMultiLineString} object Object.\n * @return {MultiLineString} MultiLineString.\n */\nfunction readMultiLineStringGeometry(object) {\n    return new MultiLineString(object['coordinates']);\n}\n/**\n * @param {GeoJSONMultiPoint} object Object.\n * @return {MultiPoint} MultiPoint.\n */\nfunction readMultiPointGeometry(object) {\n    return new MultiPoint(object['coordinates']);\n}\n/**\n * @param {GeoJSONMultiPolygon} object Object.\n * @return {MultiPolygon} MultiPolygon.\n */\nfunction readMultiPolygonGeometry(object) {\n    return new MultiPolygon(object['coordinates']);\n}\n/**\n * @param {GeoJSONPolygon} object Object.\n * @return {Polygon} Polygon.\n */\nfunction readPolygonGeometry(object) {\n    return new Polygon(object['coordinates']);\n}\n/**\n * @param {import(\"../geom/Geometry.js\").default} geometry Geometry.\n * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n * @return {GeoJSONGeometry} GeoJSON geometry.\n */\nfunction writeGeometry(geometry, opt_options) {\n    geometry = transformGeometryWithOptions(geometry, true, opt_options);\n    var type = geometry.getType();\n    /** @type {GeoJSONGeometry} */\n    var geoJSON;\n    switch (type) {\n        case GeometryType.POINT: {\n            geoJSON = writePointGeometry(\n            /** @type {Point} */ (geometry), opt_options);\n            break;\n        }\n        case GeometryType.LINE_STRING: {\n            geoJSON = writeLineStringGeometry(\n            /** @type {LineString} */ (geometry), opt_options);\n            break;\n        }\n        case GeometryType.POLYGON: {\n            geoJSON = writePolygonGeometry(\n            /** @type {Polygon} */ (geometry), opt_options);\n            break;\n        }\n        case GeometryType.MULTI_POINT: {\n            geoJSON = writeMultiPointGeometry(\n            /** @type {MultiPoint} */ (geometry), opt_options);\n            break;\n        }\n        case GeometryType.MULTI_LINE_STRING: {\n            geoJSON = writeMultiLineStringGeometry(\n            /** @type {MultiLineString} */ (geometry), opt_options);\n            break;\n        }\n        case GeometryType.MULTI_POLYGON: {\n            geoJSON = writeMultiPolygonGeometry(\n            /** @type {MultiPolygon} */ (geometry), opt_options);\n            break;\n        }\n        case GeometryType.GEOMETRY_COLLECTION: {\n            geoJSON = writeGeometryCollectionGeometry(\n            /** @type {GeometryCollection} */ (geometry), opt_options);\n            break;\n        }\n        case GeometryType.CIRCLE: {\n            geoJSON = {\n                type: 'GeometryCollection',\n                geometries: [],\n            };\n            break;\n        }\n        default: {\n            throw new Error('Unsupported geometry type: ' + type);\n        }\n    }\n    return geoJSON;\n}\n/**\n * @param {GeometryCollection} geometry Geometry.\n * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n * @return {GeoJSONGeometryCollection} GeoJSON geometry collection.\n */\nfunction writeGeometryCollectionGeometry(geometry, opt_options) {\n    var geometries = geometry.getGeometriesArray().map(function (geometry) {\n        var options = assign({}, opt_options);\n        delete options.featureProjection;\n        return writeGeometry(geometry, options);\n    });\n    return {\n        type: 'GeometryCollection',\n        geometries: geometries,\n    };\n}\n/**\n * @param {LineString} geometry Geometry.\n * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n * @return {GeoJSONGeometry} GeoJSON geometry.\n */\nfunction writeLineStringGeometry(geometry, opt_options) {\n    return {\n        type: 'LineString',\n        coordinates: geometry.getCoordinates(),\n    };\n}\n/**\n * @param {MultiLineString} geometry Geometry.\n * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n * @return {GeoJSONGeometry} GeoJSON geometry.\n */\nfunction writeMultiLineStringGeometry(geometry, opt_options) {\n    return {\n        type: 'MultiLineString',\n        coordinates: geometry.getCoordinates(),\n    };\n}\n/**\n * @param {MultiPoint} geometry Geometry.\n * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n * @return {GeoJSONGeometry} GeoJSON geometry.\n */\nfunction writeMultiPointGeometry(geometry, opt_options) {\n    return {\n        type: 'MultiPoint',\n        coordinates: geometry.getCoordinates(),\n    };\n}\n/**\n * @param {MultiPolygon} geometry Geometry.\n * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n * @return {GeoJSONGeometry} GeoJSON geometry.\n */\nfunction writeMultiPolygonGeometry(geometry, opt_options) {\n    var right;\n    if (opt_options) {\n        right = opt_options.rightHanded;\n    }\n    return {\n        type: 'MultiPolygon',\n        coordinates: geometry.getCoordinates(right),\n    };\n}\n/**\n * @param {Point} geometry Geometry.\n * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n * @return {GeoJSONGeometry} GeoJSON geometry.\n */\nfunction writePointGeometry(geometry, opt_options) {\n    return {\n        type: 'Point',\n        coordinates: geometry.getCoordinates(),\n    };\n}\n/**\n * @param {Polygon} geometry Geometry.\n * @param {import(\"./Feature.js\").WriteOptions} [opt_options] Write options.\n * @return {GeoJSONGeometry} GeoJSON geometry.\n */\nfunction writePolygonGeometry(geometry, opt_options) {\n    var right;\n    if (opt_options) {\n        right = opt_options.rightHanded;\n    }\n    return {\n        type: 'Polygon',\n        coordinates: geometry.getCoordinates(right),\n    };\n}\nexport default GeoJSON;\n//# sourceMappingURL=GeoJSON.js.map","/**\n * @module ol/functions\n */\nimport { equals as arrayEquals } from './array.js';\n/**\n * Always returns true.\n * @return {boolean} true.\n */\nexport function TRUE() {\n    return true;\n}\n/**\n * Always returns false.\n * @return {boolean} false.\n */\nexport function FALSE() {\n    return false;\n}\n/**\n * A reusable function, used e.g. as a default for callbacks.\n *\n * @return {void} Nothing.\n */\nexport function VOID() { }\n/**\n * Wrap a function in another function that remembers the last return.  If the\n * returned function is called twice in a row with the same arguments and the same\n * this object, it will return the value from the first call in the second call.\n *\n * @param {function(...any): ReturnType} fn The function to memoize.\n * @return {function(...any): ReturnType} The memoized function.\n * @template ReturnType\n */\nexport function memoizeOne(fn) {\n    var called = false;\n    /** @type {ReturnType} */\n    var lastResult;\n    /** @type {Array<any>} */\n    var lastArgs;\n    var lastThis;\n    return function () {\n        var nextArgs = Array.prototype.slice.call(arguments);\n        if (!called || this !== lastThis || !arrayEquals(nextArgs, lastArgs)) {\n            called = true;\n            lastThis = this;\n            lastArgs = nextArgs;\n            lastResult = fn.apply(this, arguments);\n        }\n        return lastResult;\n    };\n}\n//# sourceMappingURL=functions.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/Geometry\n */\nimport BaseObject from '../Object.js';\nimport Units from '../proj/Units.js';\nimport { abstract } from '../util.js';\nimport { compose as composeTransform, create as createTransform, } from '../transform.js';\nimport { createEmpty, createOrUpdateEmpty, getHeight, returnOrUpdate, } from '../extent.js';\nimport { get as getProjection, getTransform } from '../proj.js';\nimport { memoizeOne } from '../functions.js';\nimport { transform2D } from './flat/transform.js';\n/**\n * @type {import(\"../transform.js\").Transform}\n */\nvar tmpTransform = createTransform();\n/**\n * @classdesc\n * Abstract base class; normally only used for creating subclasses and not\n * instantiated in apps.\n * Base class for vector geometries.\n *\n * To get notified of changes to the geometry, register a listener for the\n * generic `change` event on your geometry instance.\n *\n * @abstract\n * @api\n */\nvar Geometry = /** @class */ (function (_super) {\n    __extends(Geometry, _super);\n    function Geometry() {\n        var _this = _super.call(this) || this;\n        /**\n         * @private\n         * @type {import(\"../extent.js\").Extent}\n         */\n        _this.extent_ = createEmpty();\n        /**\n         * @private\n         * @type {number}\n         */\n        _this.extentRevision_ = -1;\n        /**\n         * @protected\n         * @type {number}\n         */\n        _this.simplifiedGeometryMaxMinSquaredTolerance = 0;\n        /**\n         * @protected\n         * @type {number}\n         */\n        _this.simplifiedGeometryRevision = 0;\n        /**\n         * Get a transformed and simplified version of the geometry.\n         * @abstract\n         * @param {number} revision The geometry revision.\n         * @param {number} squaredTolerance Squared tolerance.\n         * @param {import(\"../proj.js\").TransformFunction} [opt_transform] Optional transform function.\n         * @return {Geometry} Simplified geometry.\n         */\n        _this.simplifyTransformedInternal = memoizeOne(function (revision, squaredTolerance, opt_transform) {\n            if (!opt_transform) {\n                return this.getSimplifiedGeometry(squaredTolerance);\n            }\n            var clone = this.clone();\n            clone.applyTransform(opt_transform);\n            return clone.getSimplifiedGeometry(squaredTolerance);\n        });\n        return _this;\n    }\n    /**\n     * Get a transformed and simplified version of the geometry.\n     * @abstract\n     * @param {number} squaredTolerance Squared tolerance.\n     * @param {import(\"../proj.js\").TransformFunction} [opt_transform] Optional transform function.\n     * @return {Geometry} Simplified geometry.\n     */\n    Geometry.prototype.simplifyTransformed = function (squaredTolerance, opt_transform) {\n        return this.simplifyTransformedInternal(this.getRevision(), squaredTolerance, opt_transform);\n    };\n    /**\n     * Make a complete copy of the geometry.\n     * @abstract\n     * @return {!Geometry} Clone.\n     */\n    Geometry.prototype.clone = function () {\n        return abstract();\n    };\n    /**\n     * @abstract\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @param {import(\"../coordinate.js\").Coordinate} closestPoint Closest point.\n     * @param {number} minSquaredDistance Minimum squared distance.\n     * @return {number} Minimum squared distance.\n     */\n    Geometry.prototype.closestPointXY = function (x, y, closestPoint, minSquaredDistance) {\n        return abstract();\n    };\n    /**\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @return {boolean} Contains (x, y).\n     */\n    Geometry.prototype.containsXY = function (x, y) {\n        var coord = this.getClosestPoint([x, y]);\n        return coord[0] === x && coord[1] === y;\n    };\n    /**\n     * Return the closest point of the geometry to the passed point as\n     * {@link module:ol/coordinate~Coordinate coordinate}.\n     * @param {import(\"../coordinate.js\").Coordinate} point Point.\n     * @param {import(\"../coordinate.js\").Coordinate} [opt_closestPoint] Closest point.\n     * @return {import(\"../coordinate.js\").Coordinate} Closest point.\n     * @api\n     */\n    Geometry.prototype.getClosestPoint = function (point, opt_closestPoint) {\n        var closestPoint = opt_closestPoint ? opt_closestPoint : [NaN, NaN];\n        this.closestPointXY(point[0], point[1], closestPoint, Infinity);\n        return closestPoint;\n    };\n    /**\n     * Returns true if this geometry includes the specified coordinate. If the\n     * coordinate is on the boundary of the geometry, returns false.\n     * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n     * @return {boolean} Contains coordinate.\n     * @api\n     */\n    Geometry.prototype.intersectsCoordinate = function (coordinate) {\n        return this.containsXY(coordinate[0], coordinate[1]);\n    };\n    /**\n     * @abstract\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @protected\n     * @return {import(\"../extent.js\").Extent} extent Extent.\n     */\n    Geometry.prototype.computeExtent = function (extent) {\n        return abstract();\n    };\n    /**\n     * Get the extent of the geometry.\n     * @param {import(\"../extent.js\").Extent} [opt_extent] Extent.\n     * @return {import(\"../extent.js\").Extent} extent Extent.\n     * @api\n     */\n    Geometry.prototype.getExtent = function (opt_extent) {\n        if (this.extentRevision_ != this.getRevision()) {\n            var extent = this.computeExtent(this.extent_);\n            if (isNaN(extent[0]) || isNaN(extent[1])) {\n                createOrUpdateEmpty(extent);\n            }\n            this.extentRevision_ = this.getRevision();\n        }\n        return returnOrUpdate(this.extent_, opt_extent);\n    };\n    /**\n     * Rotate the geometry around a given coordinate. This modifies the geometry\n     * coordinates in place.\n     * @abstract\n     * @param {number} angle Rotation angle in radians.\n     * @param {import(\"../coordinate.js\").Coordinate} anchor The rotation center.\n     * @api\n     */\n    Geometry.prototype.rotate = function (angle, anchor) {\n        abstract();\n    };\n    /**\n     * Scale the geometry (with an optional origin).  This modifies the geometry\n     * coordinates in place.\n     * @abstract\n     * @param {number} sx The scaling factor in the x-direction.\n     * @param {number} [opt_sy] The scaling factor in the y-direction (defaults to sx).\n     * @param {import(\"../coordinate.js\").Coordinate} [opt_anchor] The scale origin (defaults to the center\n     *     of the geometry extent).\n     * @api\n     */\n    Geometry.prototype.scale = function (sx, opt_sy, opt_anchor) {\n        abstract();\n    };\n    /**\n     * Create a simplified version of this geometry.  For linestrings, this uses\n     * the [Douglas Peucker](https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm)\n     * algorithm.  For polygons, a quantization-based\n     * simplification is used to preserve topology.\n     * @param {number} tolerance The tolerance distance for simplification.\n     * @return {Geometry} A new, simplified version of the original geometry.\n     * @api\n     */\n    Geometry.prototype.simplify = function (tolerance) {\n        return this.getSimplifiedGeometry(tolerance * tolerance);\n    };\n    /**\n     * Create a simplified version of this geometry using the Douglas Peucker\n     * algorithm.\n     * See https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm.\n     * @abstract\n     * @param {number} squaredTolerance Squared tolerance.\n     * @return {Geometry} Simplified geometry.\n     */\n    Geometry.prototype.getSimplifiedGeometry = function (squaredTolerance) {\n        return abstract();\n    };\n    /**\n     * Get the type of this geometry.\n     * @abstract\n     * @return {import(\"./GeometryType.js\").default} Geometry type.\n     */\n    Geometry.prototype.getType = function () {\n        return abstract();\n    };\n    /**\n     * Apply a transform function to the coordinates of the geometry.\n     * The geometry is modified in place.\n     * If you do not want the geometry modified in place, first `clone()` it and\n     * then use this function on the clone.\n     * @abstract\n     * @param {import(\"../proj.js\").TransformFunction} transformFn Transform function.\n     * Called with a flat array of geometry coordinates.\n     */\n    Geometry.prototype.applyTransform = function (transformFn) {\n        abstract();\n    };\n    /**\n     * Test if the geometry and the passed extent intersect.\n     * @abstract\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @return {boolean} `true` if the geometry and the extent intersect.\n     */\n    Geometry.prototype.intersectsExtent = function (extent) {\n        return abstract();\n    };\n    /**\n     * Translate the geometry.  This modifies the geometry coordinates in place.  If\n     * instead you want a new geometry, first `clone()` this geometry.\n     * @abstract\n     * @param {number} deltaX Delta X.\n     * @param {number} deltaY Delta Y.\n     * @api\n     */\n    Geometry.prototype.translate = function (deltaX, deltaY) {\n        abstract();\n    };\n    /**\n     * Transform each coordinate of the geometry from one coordinate reference\n     * system to another. The geometry is modified in place.\n     * For example, a line will be transformed to a line and a circle to a circle.\n     * If you do not want the geometry modified in place, first `clone()` it and\n     * then use this function on the clone.\n     *\n     * @param {import(\"../proj.js\").ProjectionLike} source The current projection.  Can be a\n     *     string identifier or a {@link module:ol/proj/Projection~Projection} object.\n     * @param {import(\"../proj.js\").ProjectionLike} destination The desired projection.  Can be a\n     *     string identifier or a {@link module:ol/proj/Projection~Projection} object.\n     * @return {Geometry} This geometry.  Note that original geometry is\n     *     modified in place.\n     * @api\n     */\n    Geometry.prototype.transform = function (source, destination) {\n        /** @type {import(\"../proj/Projection.js\").default} */\n        var sourceProj = getProjection(source);\n        var transformFn = sourceProj.getUnits() == Units.TILE_PIXELS\n            ? function (inCoordinates, outCoordinates, stride) {\n                var pixelExtent = sourceProj.getExtent();\n                var projectedExtent = sourceProj.getWorldExtent();\n                var scale = getHeight(projectedExtent) / getHeight(pixelExtent);\n                composeTransform(tmpTransform, projectedExtent[0], projectedExtent[3], scale, -scale, 0, 0, 0);\n                transform2D(inCoordinates, 0, inCoordinates.length, stride, tmpTransform, outCoordinates);\n                return getTransform(sourceProj, destination)(inCoordinates, outCoordinates, stride);\n            }\n            : getTransform(sourceProj, destination);\n        this.applyTransform(transformFn);\n        return this;\n    };\n    return Geometry;\n}(BaseObject));\nexport default Geometry;\n//# sourceMappingURL=Geometry.js.map","/**\n * @module ol/geom/GeometryLayout\n */\n/**\n * The coordinate layout for geometries, indicating whether a 3rd or 4th z ('Z')\n * or measure ('M') coordinate is available. Supported values are `'XY'`,\n * `'XYZ'`, `'XYM'`, `'XYZM'`.\n * @enum {string}\n */\nexport default {\n    XY: 'XY',\n    XYZ: 'XYZ',\n    XYM: 'XYM',\n    XYZM: 'XYZM',\n};\n//# sourceMappingURL=GeometryLayout.js.map","/**\n * @module ol/geom/GeometryType\n */\n/**\n * The geometry type. One of `'Point'`, `'LineString'`, `'LinearRing'`,\n * `'Polygon'`, `'MultiPoint'`, `'MultiLineString'`, `'MultiPolygon'`,\n * `'GeometryCollection'`, `'Circle'`.\n * @enum {string}\n */\nexport default {\n    POINT: 'Point',\n    LINE_STRING: 'LineString',\n    LINEAR_RING: 'LinearRing',\n    POLYGON: 'Polygon',\n    MULTI_POINT: 'MultiPoint',\n    MULTI_LINE_STRING: 'MultiLineString',\n    MULTI_POLYGON: 'MultiPolygon',\n    GEOMETRY_COLLECTION: 'GeometryCollection',\n    CIRCLE: 'Circle',\n};\n//# sourceMappingURL=GeometryType.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/Point\n */\nimport GeometryType from './GeometryType.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { containsXY, createOrUpdateFromCoordinate } from '../extent.js';\nimport { deflateCoordinate } from './flat/deflate.js';\nimport { squaredDistance as squaredDx } from '../math.js';\n/**\n * @classdesc\n * Point geometry.\n *\n * @api\n */\nvar Point = /** @class */ (function (_super) {\n    __extends(Point, _super);\n    /**\n     * @param {import(\"../coordinate.js\").Coordinate} coordinates Coordinates.\n     * @param {import(\"./GeometryLayout.js\").default} [opt_layout] Layout.\n     */\n    function Point(coordinates, opt_layout) {\n        var _this = _super.call(this) || this;\n        _this.setCoordinates(coordinates, opt_layout);\n        return _this;\n    }\n    /**\n     * Make a complete copy of the geometry.\n     * @return {!Point} Clone.\n     * @api\n     */\n    Point.prototype.clone = function () {\n        var point = new Point(this.flatCoordinates.slice(), this.layout);\n        point.applyProperties(this);\n        return point;\n    };\n    /**\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @param {import(\"../coordinate.js\").Coordinate} closestPoint Closest point.\n     * @param {number} minSquaredDistance Minimum squared distance.\n     * @return {number} Minimum squared distance.\n     */\n    Point.prototype.closestPointXY = function (x, y, closestPoint, minSquaredDistance) {\n        var flatCoordinates = this.flatCoordinates;\n        var squaredDistance = squaredDx(x, y, flatCoordinates[0], flatCoordinates[1]);\n        if (squaredDistance < minSquaredDistance) {\n            var stride = this.stride;\n            for (var i = 0; i < stride; ++i) {\n                closestPoint[i] = flatCoordinates[i];\n            }\n            closestPoint.length = stride;\n            return squaredDistance;\n        }\n        else {\n            return minSquaredDistance;\n        }\n    };\n    /**\n     * Return the coordinate of the point.\n     * @return {import(\"../coordinate.js\").Coordinate} Coordinates.\n     * @api\n     */\n    Point.prototype.getCoordinates = function () {\n        return !this.flatCoordinates ? [] : this.flatCoordinates.slice();\n    };\n    /**\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @protected\n     * @return {import(\"../extent.js\").Extent} extent Extent.\n     */\n    Point.prototype.computeExtent = function (extent) {\n        return createOrUpdateFromCoordinate(this.flatCoordinates, extent);\n    };\n    /**\n     * Get the type of this geometry.\n     * @return {import(\"./GeometryType.js\").default} Geometry type.\n     * @api\n     */\n    Point.prototype.getType = function () {\n        return GeometryType.POINT;\n    };\n    /**\n     * Test if the geometry and the passed extent intersect.\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @return {boolean} `true` if the geometry and the extent intersect.\n     * @api\n     */\n    Point.prototype.intersectsExtent = function (extent) {\n        return containsXY(extent, this.flatCoordinates[0], this.flatCoordinates[1]);\n    };\n    /**\n     * @param {!Array<*>} coordinates Coordinates.\n     * @param {import(\"./GeometryLayout.js\").default} [opt_layout] Layout.\n     * @api\n     */\n    Point.prototype.setCoordinates = function (coordinates, opt_layout) {\n        this.setLayout(opt_layout, coordinates, 0);\n        if (!this.flatCoordinates) {\n            this.flatCoordinates = [];\n        }\n        this.flatCoordinates.length = deflateCoordinate(this.flatCoordinates, 0, coordinates, this.stride);\n        this.changed();\n    };\n    return Point;\n}(SimpleGeometry));\nexport default Point;\n//# sourceMappingURL=Point.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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 GeometryLayout from './GeometryLayout.js';\nimport GeometryType from './GeometryType.js';\nimport SimpleGeometry from './SimpleGeometry.js';\nimport { assignClosestPoint, maxSquaredDelta } from './flat/closest.js';\nimport { closestSquaredDistanceXY } from '../extent.js';\nimport { deflateCoordinates } from './flat/deflate.js';\nimport { douglasPeucker } from './flat/simplify.js';\nimport { inflateCoordinates } from './flat/inflate.js';\nimport { linearRing as linearRingArea } from './flat/area.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 {import(\"./GeometryLayout.js\").default} [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, \n            /** @type {Array<number>} */ (coordinates));\n        }\n        else {\n            _this.setCoordinates(\n            /** @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     * @api\n     */\n    LinearRing.prototype.clone = function () {\n        return new LinearRing(this.flatCoordinates.slice(), this.layout);\n    };\n    /**\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @param {import(\"../coordinate.js\").Coordinate} closestPoint Closest point.\n     * @param {number} minSquaredDistance Minimum squared distance.\n     * @return {number} Minimum squared distance.\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     * @api\n     */\n    LinearRing.prototype.getCoordinates = function () {\n        return inflateCoordinates(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride);\n    };\n    /**\n     * @param {number} squaredTolerance Squared tolerance.\n     * @return {LinearRing} Simplified LinearRing.\n     * @protected\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     * Get the type of this geometry.\n     * @return {import(\"./GeometryType.js\").default} Geometry type.\n     * @api\n     */\n    LinearRing.prototype.getType = function () {\n        return GeometryType.LINEAR_RING;\n    };\n    /**\n     * Test if the geometry and the passed extent intersect.\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @return {boolean} `true` if the geometry and the extent intersect.\n     * @api\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 {import(\"./GeometryLayout.js\").default} [opt_layout] Layout.\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","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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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 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 { arrayMaxSquaredDelta, assignClosestArrayPoint } from './flat/closest.js';\nimport { closestSquaredDistanceXY, getCenter } from '../extent.js';\nimport { deflateCoordinatesArray } from './flat/deflate.js';\nimport { extend } from '../array.js';\nimport { getInteriorPointOfArray } from './flat/interiorpoint.js';\nimport { inflateCoordinatesArray } from './flat/inflate.js';\nimport { intersectsLinearRingArray } from './flat/intersectsextent.js';\nimport { linearRingsAreOriented, orientLinearRings } from './flat/orient.js';\nimport { linearRings as linearRingsArea } from './flat/area.js';\nimport { linearRingsContainsXY } from './flat/contains.js';\nimport { modulo } from '../math.js';\nimport { quantizeArray } from './flat/simplify.js';\nimport { offset as sphereOffset } from '../sphere.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 {import(\"./GeometryLayout.js\").default} [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, \n            /** @type {Array<number>} */ (coordinates));\n            _this.ends_ = opt_ends;\n        }\n        else {\n            _this.setCoordinates(\n            /** @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     * @api\n     */\n    Polygon.prototype.clone = function () {\n        var polygon = new Polygon(this.flatCoordinates.slice(), this.layout, this.ends_.slice());\n        polygon.applyProperties(this);\n        return polygon;\n    };\n    /**\n     * @param {number} x X.\n     * @param {number} y Y.\n     * @param {import(\"../coordinate.js\").Coordinate} closestPoint Closest point.\n     * @param {number} minSquaredDistance Minimum squared distance.\n     * @return {number} Minimum squared distance.\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     * @param {number} x X.\n     * @param {number} y Y.\n     * @return {boolean} Contains (x, y).\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     * @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 = orientLinearRings(this.orientedFlatCoordinates_, 0, this.ends_, this.stride);\n            }\n            this.orientedRevision_ = this.getRevision();\n        }\n        return this.orientedFlatCoordinates_;\n    };\n    /**\n     * @param {number} squaredTolerance Squared tolerance.\n     * @return {Polygon} Simplified Polygon.\n     * @protected\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     * Get the type of this geometry.\n     * @return {import(\"./GeometryType.js\").default} Geometry type.\n     * @api\n     */\n    Polygon.prototype.getType = function () {\n        return GeometryType.POLYGON;\n    };\n    /**\n     * Test if the geometry and the passed extent intersect.\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @return {boolean} `true` if the geometry and the extent intersect.\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 {import(\"./GeometryLayout.js\").default} [opt_layout] Layout.\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 in meters.\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, [\n        flatCoordinates.length,\n    ]);\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 = [\n        minX,\n        minY,\n        minX,\n        maxY,\n        maxX,\n        maxY,\n        maxX,\n        minY,\n        minX,\n        minY,\n    ];\n    return new Polygon(flatCoordinates, GeometryLayout.XY, [\n        flatCoordinates.length,\n    ]);\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 *     counter-clockwise radians. 0 means East. 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 *     counter-clockwise radians. 0 means East. 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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/SimpleGeometry\n */\nimport Geometry from './Geometry.js';\nimport GeometryLayout from './GeometryLayout.js';\nimport { abstract } from '../util.js';\nimport { createOrUpdateFromFlatCoordinates, getCenter } from '../extent.js';\nimport { rotate, scale, transform2D, translate } from './flat/transform.js';\n/**\n * @classdesc\n * Abstract base class; only used for creating subclasses; do not instantiate\n * in apps, as cannot be rendered.\n *\n * @abstract\n * @api\n */\nvar SimpleGeometry = /** @class */ (function (_super) {\n    __extends(SimpleGeometry, _super);\n    function SimpleGeometry() {\n        var _this = _super.call(this) || this;\n        /**\n         * @protected\n         * @type {import(\"./GeometryLayout.js\").default}\n         */\n        _this.layout = GeometryLayout.XY;\n        /**\n         * @protected\n         * @type {number}\n         */\n        _this.stride = 2;\n        /**\n         * @protected\n         * @type {Array<number>}\n         */\n        _this.flatCoordinates = null;\n        return _this;\n    }\n    /**\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @protected\n     * @return {import(\"../extent.js\").Extent} extent Extent.\n     */\n    SimpleGeometry.prototype.computeExtent = function (extent) {\n        return createOrUpdateFromFlatCoordinates(this.flatCoordinates, 0, this.flatCoordinates.length, this.stride, extent);\n    };\n    /**\n     * @abstract\n     * @return {Array<*>} Coordinates.\n     */\n    SimpleGeometry.prototype.getCoordinates = function () {\n        return abstract();\n    };\n    /**\n     * Return the first coordinate of the geometry.\n     * @return {import(\"../coordinate.js\").Coordinate} First coordinate.\n     * @api\n     */\n    SimpleGeometry.prototype.getFirstCoordinate = function () {\n        return this.flatCoordinates.slice(0, this.stride);\n    };\n    /**\n     * @return {Array<number>} Flat coordinates.\n     */\n    SimpleGeometry.prototype.getFlatCoordinates = function () {\n        return this.flatCoordinates;\n    };\n    /**\n     * Return the last coordinate of the geometry.\n     * @return {import(\"../coordinate.js\").Coordinate} Last point.\n     * @api\n     */\n    SimpleGeometry.prototype.getLastCoordinate = function () {\n        return this.flatCoordinates.slice(this.flatCoordinates.length - this.stride);\n    };\n    /**\n     * Return the {@link module:ol/geom/GeometryLayout layout} of the geometry.\n     * @return {import(\"./GeometryLayout.js\").default} Layout.\n     * @api\n     */\n    SimpleGeometry.prototype.getLayout = function () {\n        return this.layout;\n    };\n    /**\n     * Create a simplified version of this geometry using the Douglas Peucker algorithm.\n     * @param {number} squaredTolerance Squared tolerance.\n     * @return {SimpleGeometry} Simplified geometry.\n     */\n    SimpleGeometry.prototype.getSimplifiedGeometry = function (squaredTolerance) {\n        if (this.simplifiedGeometryRevision !== this.getRevision()) {\n            this.simplifiedGeometryMaxMinSquaredTolerance = 0;\n            this.simplifiedGeometryRevision = this.getRevision();\n        }\n        // If squaredTolerance is negative or if we know that simplification will not\n        // have any effect then just return this.\n        if (squaredTolerance < 0 ||\n            (this.simplifiedGeometryMaxMinSquaredTolerance !== 0 &&\n                squaredTolerance <= this.simplifiedGeometryMaxMinSquaredTolerance)) {\n            return this;\n        }\n        var simplifiedGeometry = this.getSimplifiedGeometryInternal(squaredTolerance);\n        var simplifiedFlatCoordinates = simplifiedGeometry.getFlatCoordinates();\n        if (simplifiedFlatCoordinates.length < this.flatCoordinates.length) {\n            return simplifiedGeometry;\n        }\n        else {\n            // Simplification did not actually remove any coordinates.  We now know\n            // that any calls to getSimplifiedGeometry with a squaredTolerance less\n            // than or equal to the current squaredTolerance will also not have any\n            // effect.  This allows us to short circuit simplification (saving CPU\n            // cycles) and prevents the cache of simplified geometries from filling\n            // up with useless identical copies of this geometry (saving memory).\n            this.simplifiedGeometryMaxMinSquaredTolerance = squaredTolerance;\n            return this;\n        }\n    };\n    /**\n     * @param {number} squaredTolerance Squared tolerance.\n     * @return {SimpleGeometry} Simplified geometry.\n     * @protected\n     */\n    SimpleGeometry.prototype.getSimplifiedGeometryInternal = function (squaredTolerance) {\n        return this;\n    };\n    /**\n     * @return {number} Stride.\n     */\n    SimpleGeometry.prototype.getStride = function () {\n        return this.stride;\n    };\n    /**\n     * @param {import(\"./GeometryLayout.js\").default} layout Layout.\n     * @param {Array<number>} flatCoordinates Flat coordinates.\n     */\n    SimpleGeometry.prototype.setFlatCoordinates = function (layout, flatCoordinates) {\n        this.stride = getStrideForLayout(layout);\n        this.layout = layout;\n        this.flatCoordinates = flatCoordinates;\n    };\n    /**\n     * @abstract\n     * @param {!Array<*>} coordinates Coordinates.\n     * @param {import(\"./GeometryLayout.js\").default} [opt_layout] Layout.\n     */\n    SimpleGeometry.prototype.setCoordinates = function (coordinates, opt_layout) {\n        abstract();\n    };\n    /**\n     * @param {import(\"./GeometryLayout.js\").default|undefined} layout Layout.\n     * @param {Array<*>} coordinates Coordinates.\n     * @param {number} nesting Nesting.\n     * @protected\n     */\n    SimpleGeometry.prototype.setLayout = function (layout, coordinates, nesting) {\n        /** @type {number} */\n        var stride;\n        if (layout) {\n            stride = getStrideForLayout(layout);\n        }\n        else {\n            for (var i = 0; i < nesting; ++i) {\n                if (coordinates.length === 0) {\n                    this.layout = GeometryLayout.XY;\n                    this.stride = 2;\n                    return;\n                }\n                else {\n                    coordinates = /** @type {Array} */ (coordinates[0]);\n                }\n            }\n            stride = coordinates.length;\n            layout = getLayoutForStride(stride);\n        }\n        this.layout = layout;\n        this.stride = stride;\n    };\n    /**\n     * Apply a transform function to the coordinates of the geometry.\n     * The geometry is modified in place.\n     * If you do not want the geometry modified in place, first `clone()` it and\n     * then use this function on the clone.\n     * @param {import(\"../proj.js\").TransformFunction} transformFn Transform function.\n     * Called with a flat array of geometry coordinates.\n     * @api\n     */\n    SimpleGeometry.prototype.applyTransform = function (transformFn) {\n        if (this.flatCoordinates) {\n            transformFn(this.flatCoordinates, this.flatCoordinates, this.stride);\n            this.changed();\n        }\n    };\n    /**\n     * Rotate the geometry around a given coordinate. This modifies the geometry\n     * coordinates in place.\n     * @param {number} angle Rotation angle in counter-clockwise radians.\n     * @param {import(\"../coordinate.js\").Coordinate} anchor The rotation center.\n     * @api\n     */\n    SimpleGeometry.prototype.rotate = function (angle, anchor) {\n        var flatCoordinates = this.getFlatCoordinates();\n        if (flatCoordinates) {\n            var stride = this.getStride();\n            rotate(flatCoordinates, 0, flatCoordinates.length, stride, angle, anchor, flatCoordinates);\n            this.changed();\n        }\n    };\n    /**\n     * Scale the geometry (with an optional origin).  This modifies the geometry\n     * coordinates in place.\n     * @param {number} sx The scaling factor in the x-direction.\n     * @param {number} [opt_sy] The scaling factor in the y-direction (defaults to sx).\n     * @param {import(\"../coordinate.js\").Coordinate} [opt_anchor] The scale origin (defaults to the center\n     *     of the geometry extent).\n     * @api\n     */\n    SimpleGeometry.prototype.scale = function (sx, opt_sy, opt_anchor) {\n        var sy = opt_sy;\n        if (sy === undefined) {\n            sy = sx;\n        }\n        var anchor = opt_anchor;\n        if (!anchor) {\n            anchor = getCenter(this.getExtent());\n        }\n        var flatCoordinates = this.getFlatCoordinates();\n        if (flatCoordinates) {\n            var stride = this.getStride();\n            scale(flatCoordinates, 0, flatCoordinates.length, stride, sx, sy, anchor, flatCoordinates);\n            this.changed();\n        }\n    };\n    /**\n     * Translate the geometry.  This modifies the geometry coordinates in place.  If\n     * instead you want a new geometry, first `clone()` this geometry.\n     * @param {number} deltaX Delta X.\n     * @param {number} deltaY Delta Y.\n     * @api\n     */\n    SimpleGeometry.prototype.translate = function (deltaX, deltaY) {\n        var flatCoordinates = this.getFlatCoordinates();\n        if (flatCoordinates) {\n            var stride = this.getStride();\n            translate(flatCoordinates, 0, flatCoordinates.length, stride, deltaX, deltaY, flatCoordinates);\n            this.changed();\n        }\n    };\n    return SimpleGeometry;\n}(Geometry));\n/**\n * @param {number} stride Stride.\n * @return {import(\"./GeometryLayout.js\").default} layout Layout.\n */\nfunction getLayoutForStride(stride) {\n    var layout;\n    if (stride == 2) {\n        layout = GeometryLayout.XY;\n    }\n    else if (stride == 3) {\n        layout = GeometryLayout.XYZ;\n    }\n    else if (stride == 4) {\n        layout = GeometryLayout.XYZM;\n    }\n    return /** @type {import(\"./GeometryLayout.js\").default} */ (layout);\n}\n/**\n * @param {import(\"./GeometryLayout.js\").default} layout Layout.\n * @return {number} Stride.\n */\nexport function getStrideForLayout(layout) {\n    var stride;\n    if (layout == GeometryLayout.XY) {\n        stride = 2;\n    }\n    else if (layout == GeometryLayout.XYZ || layout == GeometryLayout.XYM) {\n        stride = 3;\n    }\n    else if (layout == GeometryLayout.XYZM) {\n        stride = 4;\n    }\n    return /** @type {number} */ (stride);\n}\n/**\n * @param {SimpleGeometry} simpleGeometry Simple geometry.\n * @param {import(\"../transform.js\").Transform} transform Transform.\n * @param {Array<number>} [opt_dest] Destination.\n * @return {Array<number>} Transformed flat coordinates.\n */\nexport function transformGeom2D(simpleGeometry, transform, opt_dest) {\n    var flatCoordinates = simpleGeometry.getFlatCoordinates();\n    if (!flatCoordinates) {\n        return null;\n    }\n    else {\n        var stride = simpleGeometry.getStride();\n        return transform2D(flatCoordinates, 0, flatCoordinates.length, stride, transform, opt_dest);\n    }\n}\nexport default SimpleGeometry;\n//# sourceMappingURL=SimpleGeometry.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/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 +=\n                stride *\n                    Math.max(((Math.sqrt(squaredDistance) - Math.sqrt(minSquaredDistance)) /\n                        maxDelta) |\n                        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","/**\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    // https://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","/**\n * @module ol/geom/flat/deflate\n */\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {import(\"../../coordinate.js\").Coordinate} coordinate Coordinate.\n * @param {number} stride Stride.\n * @return {number} offset Offset.\n */\nexport function deflateCoordinate(flatCoordinates, offset, coordinate, stride) {\n    for (var i = 0, ii = coordinate.length; i < ii; ++i) {\n        flatCoordinates[offset++] = coordinate[i];\n    }\n    return offset;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<import(\"../../coordinate.js\").Coordinate>} coordinates Coordinates.\n * @param {number} stride Stride.\n * @return {number} offset Offset.\n */\nexport function deflateCoordinates(flatCoordinates, offset, coordinates, stride) {\n    for (var i = 0, ii = coordinates.length; i < ii; ++i) {\n        var coordinate = coordinates[i];\n        for (var j = 0; j < stride; ++j) {\n            flatCoordinates[offset++] = coordinate[j];\n        }\n    }\n    return offset;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<import(\"../../coordinate.js\").Coordinate>>} coordinatess Coordinatess.\n * @param {number} stride Stride.\n * @param {Array<number>} [opt_ends] Ends.\n * @return {Array<number>} Ends.\n */\nexport function deflateCoordinatesArray(flatCoordinates, offset, coordinatess, stride, opt_ends) {\n    var ends = opt_ends ? opt_ends : [];\n    var i = 0;\n    for (var j = 0, jj = coordinatess.length; j < jj; ++j) {\n        var end = deflateCoordinates(flatCoordinates, offset, coordinatess[j], stride);\n        ends[i++] = end;\n        offset = end;\n    }\n    ends.length = i;\n    return ends;\n}\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {Array<Array<Array<import(\"../../coordinate.js\").Coordinate>>>} coordinatesss Coordinatesss.\n * @param {number} stride Stride.\n * @param {Array<Array<number>>} [opt_endss] Endss.\n * @return {Array<Array<number>>} Endss.\n */\nexport function deflateMultiCoordinatesArray(flatCoordinates, offset, coordinatesss, stride, opt_endss) {\n    var endss = opt_endss ? opt_endss : [];\n    var i = 0;\n    for (var j = 0, jj = coordinatesss.length; j < jj; ++j) {\n        var ends = deflateCoordinatesArray(flatCoordinates, offset, coordinatesss[j], stride, endss[i]);\n        endss[i++] = ends;\n        offset = ends[ends.length - 1];\n    }\n    endss.length = i;\n    return endss;\n}\n//# sourceMappingURL=deflate.js.map","/**\n * @module ol/geom/flat/inflate\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 {Array<import(\"../../coordinate.js\").Coordinate>} [opt_coordinates] Coordinates.\n * @return {Array<import(\"../../coordinate.js\").Coordinate>} Coordinates.\n */\nexport function inflateCoordinates(flatCoordinates, offset, end, stride, opt_coordinates) {\n    var coordinates = opt_coordinates !== undefined ? opt_coordinates : [];\n    var i = 0;\n    for (var j = offset; j < end; j += stride) {\n        coordinates[i++] = flatCoordinates.slice(j, j + stride);\n    }\n    coordinates.length = i;\n    return coordinates;\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 {Array<Array<import(\"../../coordinate.js\").Coordinate>>} [opt_coordinatess] Coordinatess.\n * @return {Array<Array<import(\"../../coordinate.js\").Coordinate>>} Coordinatess.\n */\nexport function inflateCoordinatesArray(flatCoordinates, offset, ends, stride, opt_coordinatess) {\n    var coordinatess = opt_coordinatess !== undefined ? opt_coordinatess : [];\n    var i = 0;\n    for (var j = 0, jj = ends.length; j < jj; ++j) {\n        var end = ends[j];\n        coordinatess[i++] = inflateCoordinates(flatCoordinates, offset, end, stride, coordinatess[i]);\n        offset = end;\n    }\n    coordinatess.length = i;\n    return coordinatess;\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<Array<Array<import(\"../../coordinate.js\").Coordinate>>>} [opt_coordinatesss]\n *     Coordinatesss.\n * @return {Array<Array<Array<import(\"../../coordinate.js\").Coordinate>>>} Coordinatesss.\n */\nexport function inflateMultiCoordinatesArray(flatCoordinates, offset, endss, stride, opt_coordinatesss) {\n    var coordinatesss = opt_coordinatesss !== undefined ? opt_coordinatesss : [];\n    var i = 0;\n    for (var j = 0, jj = endss.length; j < jj; ++j) {\n        var ends = endss[j];\n        coordinatesss[i++] = inflateCoordinatesArray(flatCoordinates, offset, ends, stride, coordinatesss[i]);\n        offset = ends[ends.length - 1];\n    }\n    coordinatesss.length = i;\n    return coordinatesss;\n}\n//# sourceMappingURL=inflate.js.map","/**\n * @module ol/geom/flat/interiorpoint\n */\nimport { linearRingsContainsXY } from './contains.js';\nimport { numberSafeCompareFunction } from '../../array.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/intersectsextent\n */\nimport { containsExtent, createEmpty, extendFlatCoordinates, intersects, intersectsSegment, } from '../../extent.js';\nimport { forEach as forEachSegment } from './segments.js';\nimport { linearRingContainsExtent, linearRingContainsXY } from './contains.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] && coordinatesExtent[2] <= extent[2]) {\n        return true;\n    }\n    if (coordinatesExtent[1] >= extent[1] && 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/geom/flat/length\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} Length.\n */\nexport function lineStringLength(flatCoordinates, offset, end, stride) {\n    var x1 = flatCoordinates[offset];\n    var y1 = flatCoordinates[offset + 1];\n    var length = 0;\n    for (var i = offset + stride; i < end; i += stride) {\n        var x2 = flatCoordinates[i];\n        var y2 = flatCoordinates[i + 1];\n        length += Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));\n        x1 = x2;\n        y1 = y2;\n    }\n    return length;\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} Perimeter.\n */\nexport function linearRingLength(flatCoordinates, offset, end, stride) {\n    var perimeter = lineStringLength(flatCoordinates, offset, end, stride);\n    var dx = flatCoordinates[end - stride] - flatCoordinates[offset];\n    var dy = flatCoordinates[end - stride + 1] - flatCoordinates[offset + 1];\n    perimeter += Math.sqrt(dx * dx + dy * dy);\n    return perimeter;\n}\n//# sourceMappingURL=length.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 * Is the linear ring oriented clockwise in a coordinate system with a bottom-left\n * coordinate origin? For a coordinate system with a top-left coordinate origin,\n * the ring's orientation is clockwise when this 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 * @return {boolean} Is clockwise.\n */\nexport function linearRingIsClockwise(flatCoordinates, offset, end, stride) {\n    // https://stackoverflow.com/q/1165647/clockwise-method#1165943\n    // https://github.com/OSGeo/gdal/blob/master/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 ? undefined : 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","/**\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 ret;\n    offset += stride;\n    for (; offset < end; offset += stride) {\n        ret = callback(flatCoordinates.slice(offset - stride, offset), flatCoordinates.slice(offset, offset + stride));\n        if (ret) {\n            return ret;\n        }\n    }\n    return false;\n}\n//# sourceMappingURL=segments.js.map","/**\n * @module ol/geom/flat/simplify\n */\n// Based on simplify-js https://github.com/mourner/simplify-js\n// Copyright (c) 2012, Vladimir Agafonkin\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions are met:\n//\n//    1. Redistributions of source code must retain the above copyright notice,\n//       this list of conditions and the following disclaimer.\n//\n//    2. Redistributions in binary form must reproduce the above copyright\n//       notice, this list of conditions and the following disclaimer in the\n//       documentation and/or other materials provided with the distribution.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n// POSSIBILITY OF SUCH DAMAGE.\nimport { squaredDistance, squaredSegmentDistance } 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} squaredTolerance Squared tolerance.\n * @param {boolean} highQuality Highest quality.\n * @param {Array<number>} [opt_simplifiedFlatCoordinates] Simplified flat\n *     coordinates.\n * @return {Array<number>} Simplified line string.\n */\nexport function simplifyLineString(flatCoordinates, offset, end, stride, squaredTolerance, highQuality, opt_simplifiedFlatCoordinates) {\n    var simplifiedFlatCoordinates = opt_simplifiedFlatCoordinates !== undefined\n        ? opt_simplifiedFlatCoordinates\n        : [];\n    if (!highQuality) {\n        end = radialDistance(flatCoordinates, offset, end, stride, squaredTolerance, simplifiedFlatCoordinates, 0);\n        flatCoordinates = simplifiedFlatCoordinates;\n        offset = 0;\n        stride = 2;\n    }\n    simplifiedFlatCoordinates.length = douglasPeucker(flatCoordinates, offset, end, stride, squaredTolerance, simplifiedFlatCoordinates, 0);\n    return simplifiedFlatCoordinates;\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} squaredTolerance Squared tolerance.\n * @param {Array<number>} simplifiedFlatCoordinates Simplified flat\n *     coordinates.\n * @param {number} simplifiedOffset Simplified offset.\n * @return {number} Simplified offset.\n */\nexport function douglasPeucker(flatCoordinates, offset, end, stride, squaredTolerance, simplifiedFlatCoordinates, simplifiedOffset) {\n    var n = (end - offset) / stride;\n    if (n < 3) {\n        for (; offset < end; offset += stride) {\n            simplifiedFlatCoordinates[simplifiedOffset++] = flatCoordinates[offset];\n            simplifiedFlatCoordinates[simplifiedOffset++] =\n                flatCoordinates[offset + 1];\n        }\n        return simplifiedOffset;\n    }\n    /** @type {Array<number>} */\n    var markers = new Array(n);\n    markers[0] = 1;\n    markers[n - 1] = 1;\n    /** @type {Array<number>} */\n    var stack = [offset, end - stride];\n    var index = 0;\n    while (stack.length > 0) {\n        var last = stack.pop();\n        var first = stack.pop();\n        var maxSquaredDistance = 0;\n        var x1 = flatCoordinates[first];\n        var y1 = flatCoordinates[first + 1];\n        var x2 = flatCoordinates[last];\n        var y2 = flatCoordinates[last + 1];\n        for (var i = first + stride; i < last; i += stride) {\n            var x = flatCoordinates[i];\n            var y = flatCoordinates[i + 1];\n            var squaredDistance_1 = squaredSegmentDistance(x, y, x1, y1, x2, y2);\n            if (squaredDistance_1 > maxSquaredDistance) {\n                index = i;\n                maxSquaredDistance = squaredDistance_1;\n            }\n        }\n        if (maxSquaredDistance > squaredTolerance) {\n            markers[(index - offset) / stride] = 1;\n            if (first + stride < index) {\n                stack.push(first, index);\n            }\n            if (index + stride < last) {\n                stack.push(index, last);\n            }\n        }\n    }\n    for (var i = 0; i < n; ++i) {\n        if (markers[i]) {\n            simplifiedFlatCoordinates[simplifiedOffset++] =\n                flatCoordinates[offset + i * stride];\n            simplifiedFlatCoordinates[simplifiedOffset++] =\n                flatCoordinates[offset + i * stride + 1];\n        }\n    }\n    return simplifiedOffset;\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} squaredTolerance Squared tolerance.\n * @param {Array<number>} simplifiedFlatCoordinates Simplified flat\n *     coordinates.\n * @param {number} simplifiedOffset Simplified offset.\n * @param {Array<number>} simplifiedEnds Simplified ends.\n * @return {number} Simplified offset.\n */\nexport function douglasPeuckerArray(flatCoordinates, offset, ends, stride, squaredTolerance, simplifiedFlatCoordinates, simplifiedOffset, simplifiedEnds) {\n    for (var i = 0, ii = ends.length; i < ii; ++i) {\n        var end = ends[i];\n        simplifiedOffset = douglasPeucker(flatCoordinates, offset, end, stride, squaredTolerance, simplifiedFlatCoordinates, simplifiedOffset);\n        simplifiedEnds.push(simplifiedOffset);\n        offset = end;\n    }\n    return simplifiedOffset;\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} squaredTolerance Squared tolerance.\n * @param {Array<number>} simplifiedFlatCoordinates Simplified flat\n *     coordinates.\n * @param {number} simplifiedOffset Simplified offset.\n * @param {Array<Array<number>>} simplifiedEndss Simplified endss.\n * @return {number} Simplified offset.\n */\nexport function douglasPeuckerMultiArray(flatCoordinates, offset, endss, stride, squaredTolerance, simplifiedFlatCoordinates, simplifiedOffset, simplifiedEndss) {\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        var ends = endss[i];\n        var simplifiedEnds = [];\n        simplifiedOffset = douglasPeuckerArray(flatCoordinates, offset, ends, stride, squaredTolerance, simplifiedFlatCoordinates, simplifiedOffset, simplifiedEnds);\n        simplifiedEndss.push(simplifiedEnds);\n        offset = ends[ends.length - 1];\n    }\n    return simplifiedOffset;\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} squaredTolerance Squared tolerance.\n * @param {Array<number>} simplifiedFlatCoordinates Simplified flat\n *     coordinates.\n * @param {number} simplifiedOffset Simplified offset.\n * @return {number} Simplified offset.\n */\nexport function radialDistance(flatCoordinates, offset, end, stride, squaredTolerance, simplifiedFlatCoordinates, simplifiedOffset) {\n    if (end <= offset + stride) {\n        // zero or one point, no simplification possible, so copy and return\n        for (; offset < end; offset += stride) {\n            simplifiedFlatCoordinates[simplifiedOffset++] = flatCoordinates[offset];\n            simplifiedFlatCoordinates[simplifiedOffset++] =\n                flatCoordinates[offset + 1];\n        }\n        return simplifiedOffset;\n    }\n    var x1 = flatCoordinates[offset];\n    var y1 = flatCoordinates[offset + 1];\n    // copy first point\n    simplifiedFlatCoordinates[simplifiedOffset++] = x1;\n    simplifiedFlatCoordinates[simplifiedOffset++] = y1;\n    var x2 = x1;\n    var y2 = y1;\n    for (offset += stride; offset < end; offset += stride) {\n        x2 = flatCoordinates[offset];\n        y2 = flatCoordinates[offset + 1];\n        if (squaredDistance(x1, y1, x2, y2) > squaredTolerance) {\n            // copy point at offset\n            simplifiedFlatCoordinates[simplifiedOffset++] = x2;\n            simplifiedFlatCoordinates[simplifiedOffset++] = y2;\n            x1 = x2;\n            y1 = y2;\n        }\n    }\n    if (x2 != x1 || y2 != y1) {\n        // copy last point\n        simplifiedFlatCoordinates[simplifiedOffset++] = x2;\n        simplifiedFlatCoordinates[simplifiedOffset++] = y2;\n    }\n    return simplifiedOffset;\n}\n/**\n * @param {number} value Value.\n * @param {number} tolerance Tolerance.\n * @return {number} Rounded value.\n */\nexport function snap(value, tolerance) {\n    return tolerance * Math.round(value / tolerance);\n}\n/**\n * Simplifies a line string using an algorithm designed by Tim Schaub.\n * Coordinates are snapped to the nearest value in a virtual grid and\n * consecutive duplicate coordinates are discarded.  This effectively preserves\n * topology as the simplification of any subsection of a line string is\n * independent of the rest of the line string.  This means that, for examples,\n * the common edge between two polygons will be simplified to the same line\n * string independently in both polygons.  This implementation uses a single\n * pass over the coordinates and eliminates intermediate collinear points.\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} tolerance Tolerance.\n * @param {Array<number>} simplifiedFlatCoordinates Simplified flat\n *     coordinates.\n * @param {number} simplifiedOffset Simplified offset.\n * @return {number} Simplified offset.\n */\nexport function quantize(flatCoordinates, offset, end, stride, tolerance, simplifiedFlatCoordinates, simplifiedOffset) {\n    // do nothing if the line is empty\n    if (offset == end) {\n        return simplifiedOffset;\n    }\n    // snap the first coordinate (P1)\n    var x1 = snap(flatCoordinates[offset], tolerance);\n    var y1 = snap(flatCoordinates[offset + 1], tolerance);\n    offset += stride;\n    // add the first coordinate to the output\n    simplifiedFlatCoordinates[simplifiedOffset++] = x1;\n    simplifiedFlatCoordinates[simplifiedOffset++] = y1;\n    // find the next coordinate that does not snap to the same value as the first\n    // coordinate (P2)\n    var x2, y2;\n    do {\n        x2 = snap(flatCoordinates[offset], tolerance);\n        y2 = snap(flatCoordinates[offset + 1], tolerance);\n        offset += stride;\n        if (offset == end) {\n            // all coordinates snap to the same value, the line collapses to a point\n            // push the last snapped value anyway to ensure that the output contains\n            // at least two points\n            // FIXME should we really return at least two points anyway?\n            simplifiedFlatCoordinates[simplifiedOffset++] = x2;\n            simplifiedFlatCoordinates[simplifiedOffset++] = y2;\n            return simplifiedOffset;\n        }\n    } while (x2 == x1 && y2 == y1);\n    while (offset < end) {\n        // snap the next coordinate (P3)\n        var x3 = snap(flatCoordinates[offset], tolerance);\n        var y3 = snap(flatCoordinates[offset + 1], tolerance);\n        offset += stride;\n        // skip P3 if it is equal to P2\n        if (x3 == x2 && y3 == y2) {\n            continue;\n        }\n        // calculate the delta between P1 and P2\n        var dx1 = x2 - x1;\n        var dy1 = y2 - y1;\n        // calculate the delta between P3 and P1\n        var dx2 = x3 - x1;\n        var dy2 = y3 - y1;\n        // if P1, P2, and P3 are colinear and P3 is further from P1 than P2 is from\n        // P1 in the same direction then P2 is on the straight line between P1 and\n        // P3\n        if (dx1 * dy2 == dy1 * dx2 &&\n            ((dx1 < 0 && dx2 < dx1) || dx1 == dx2 || (dx1 > 0 && dx2 > dx1)) &&\n            ((dy1 < 0 && dy2 < dy1) || dy1 == dy2 || (dy1 > 0 && dy2 > dy1))) {\n            // discard P2 and set P2 = P3\n            x2 = x3;\n            y2 = y3;\n            continue;\n        }\n        // either P1, P2, and P3 are not colinear, or they are colinear but P3 is\n        // between P3 and P1 or on the opposite half of the line to P2.  add P2,\n        // and continue with P1 = P2 and P2 = P3\n        simplifiedFlatCoordinates[simplifiedOffset++] = x2;\n        simplifiedFlatCoordinates[simplifiedOffset++] = y2;\n        x1 = x2;\n        y1 = y2;\n        x2 = x3;\n        y2 = y3;\n    }\n    // add the last point (P2)\n    simplifiedFlatCoordinates[simplifiedOffset++] = x2;\n    simplifiedFlatCoordinates[simplifiedOffset++] = y2;\n    return simplifiedOffset;\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} tolerance Tolerance.\n * @param {Array<number>} simplifiedFlatCoordinates Simplified flat\n *     coordinates.\n * @param {number} simplifiedOffset Simplified offset.\n * @param {Array<number>} simplifiedEnds Simplified ends.\n * @return {number} Simplified offset.\n */\nexport function quantizeArray(flatCoordinates, offset, ends, stride, tolerance, simplifiedFlatCoordinates, simplifiedOffset, simplifiedEnds) {\n    for (var i = 0, ii = ends.length; i < ii; ++i) {\n        var end = ends[i];\n        simplifiedOffset = quantize(flatCoordinates, offset, end, stride, tolerance, simplifiedFlatCoordinates, simplifiedOffset);\n        simplifiedEnds.push(simplifiedOffset);\n        offset = end;\n    }\n    return simplifiedOffset;\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} tolerance Tolerance.\n * @param {Array<number>} simplifiedFlatCoordinates Simplified flat\n *     coordinates.\n * @param {number} simplifiedOffset Simplified offset.\n * @param {Array<Array<number>>} simplifiedEndss Simplified endss.\n * @return {number} Simplified offset.\n */\nexport function quantizeMultiArray(flatCoordinates, offset, endss, stride, tolerance, simplifiedFlatCoordinates, simplifiedOffset, simplifiedEndss) {\n    for (var i = 0, ii = endss.length; i < ii; ++i) {\n        var ends = endss[i];\n        var simplifiedEnds = [];\n        simplifiedOffset = quantizeArray(flatCoordinates, offset, ends, stride, tolerance, simplifiedFlatCoordinates, simplifiedOffset, simplifiedEnds);\n        simplifiedEndss.push(simplifiedEnds);\n        offset = ends[ends.length - 1];\n    }\n    return simplifiedOffset;\n}\n//# sourceMappingURL=simplify.js.map","/**\n * @module ol/geom/flat/transform\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(\"../../transform.js\").Transform} transform Transform.\n * @param {Array<number>} [opt_dest] Destination.\n * @return {Array<number>} Transformed coordinates.\n */\nexport function transform2D(flatCoordinates, offset, end, stride, transform, opt_dest) {\n    var dest = opt_dest ? opt_dest : [];\n    var i = 0;\n    for (var j = offset; j < end; j += stride) {\n        var x = flatCoordinates[j];\n        var y = flatCoordinates[j + 1];\n        dest[i++] = transform[0] * x + transform[2] * y + transform[4];\n        dest[i++] = transform[1] * x + transform[3] * y + transform[5];\n    }\n    if (opt_dest && dest.length != i) {\n        dest.length = i;\n    }\n    return dest;\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} angle Angle.\n * @param {Array<number>} anchor Rotation anchor point.\n * @param {Array<number>} [opt_dest] Destination.\n * @return {Array<number>} Transformed coordinates.\n */\nexport function rotate(flatCoordinates, offset, end, stride, angle, anchor, opt_dest) {\n    var dest = opt_dest ? opt_dest : [];\n    var cos = Math.cos(angle);\n    var sin = Math.sin(angle);\n    var anchorX = anchor[0];\n    var anchorY = anchor[1];\n    var i = 0;\n    for (var j = offset; j < end; j += stride) {\n        var deltaX = flatCoordinates[j] - anchorX;\n        var deltaY = flatCoordinates[j + 1] - anchorY;\n        dest[i++] = anchorX + deltaX * cos - deltaY * sin;\n        dest[i++] = anchorY + deltaX * sin + deltaY * cos;\n        for (var k = j + 2; k < j + stride; ++k) {\n            dest[i++] = flatCoordinates[k];\n        }\n    }\n    if (opt_dest && dest.length != i) {\n        dest.length = i;\n    }\n    return dest;\n}\n/**\n * Scale the 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} sx Scale factor in the x-direction.\n * @param {number} sy Scale factor in the y-direction.\n * @param {Array<number>} anchor Scale anchor point.\n * @param {Array<number>} [opt_dest] Destination.\n * @return {Array<number>} Transformed coordinates.\n */\nexport function scale(flatCoordinates, offset, end, stride, sx, sy, anchor, opt_dest) {\n    var dest = opt_dest ? opt_dest : [];\n    var anchorX = anchor[0];\n    var anchorY = anchor[1];\n    var i = 0;\n    for (var j = offset; j < end; j += stride) {\n        var deltaX = flatCoordinates[j] - anchorX;\n        var deltaY = flatCoordinates[j + 1] - anchorY;\n        dest[i++] = anchorX + sx * deltaX;\n        dest[i++] = anchorY + sy * deltaY;\n        for (var k = j + 2; k < j + stride; ++k) {\n            dest[i++] = flatCoordinates[k];\n        }\n    }\n    if (opt_dest && dest.length != i) {\n        dest.length = i;\n    }\n    return dest;\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} deltaX Delta X.\n * @param {number} deltaY Delta Y.\n * @param {Array<number>} [opt_dest] Destination.\n * @return {Array<number>} Transformed coordinates.\n */\nexport function translate(flatCoordinates, offset, end, stride, deltaX, deltaY, opt_dest) {\n    var dest = opt_dest ? opt_dest : [];\n    var i = 0;\n    for (var j = offset; j < end; j += stride) {\n        dest[i++] = flatCoordinates[j] + deltaX;\n        dest[i++] = flatCoordinates[j + 1] + deltaY;\n        for (var k = j + 2; k < j + stride; ++k) {\n            dest[i++] = flatCoordinates[k];\n        }\n    }\n    if (opt_dest && dest.length != i) {\n        dest.length = i;\n    }\n    return dest;\n}\n//# sourceMappingURL=transform.js.map","/**\n * @module ol/has\n */\nvar ua = typeof navigator !== 'undefined' && typeof navigator.userAgent !== 'undefined'\n    ? navigator.userAgent.toLowerCase()\n    : '';\n/**\n * User agent string says we are dealing with Firefox as browser.\n * @type {boolean}\n */\nexport var FIREFOX = ua.indexOf('firefox') !== -1;\n/**\n * User agent string says we are dealing with Safari as browser.\n * @type {boolean}\n */\nexport var SAFARI = ua.indexOf('safari') !== -1 && ua.indexOf('chrom') == -1;\n/**\n * User agent string says we are dealing with a WebKit engine.\n * @type {boolean}\n */\nexport var WEBKIT = ua.indexOf('webkit') !== -1 && ua.indexOf('edge') == -1;\n/**\n * User agent string says we are dealing with a Mac as platform.\n * @type {boolean}\n */\nexport var MAC = ua.indexOf('macintosh') !== -1;\n/**\n * The ratio between physical pixels and device-independent pixels\n * (dips) on the device (`window.devicePixelRatio`).\n * @const\n * @type {number}\n * @api\n */\nexport var DEVICE_PIXEL_RATIO = typeof devicePixelRatio !== 'undefined' ? devicePixelRatio : 1;\n/**\n * The execution context is a worker with OffscreenCanvas available.\n * @const\n * @type {boolean}\n */\nexport var WORKER_OFFSCREEN_CANVAS = typeof WorkerGlobalScope !== 'undefined' &&\n    typeof OffscreenCanvas !== 'undefined' &&\n    self instanceof WorkerGlobalScope; //eslint-disable-line\n/**\n * Image.prototype.decode() is supported.\n * @type {boolean}\n */\nexport var IMAGE_DECODE = typeof Image !== 'undefined' && Image.prototype.decode;\n/**\n * @type {boolean}\n */\nexport var PASSIVE_EVENT_LISTENERS = (function () {\n    var passive = false;\n    try {\n        var options = Object.defineProperty({}, 'passive', {\n            get: function () {\n                passive = true;\n            },\n        });\n        window.addEventListener('_', null, options);\n        window.removeEventListener('_', null, options);\n    }\n    catch (error) {\n        // passive not supported\n    }\n    return passive;\n})();\n//# sourceMappingURL=has.js.map","/**\n * @module ol/math\n */\n/**\n * Takes a number and clamps it to within the provided bounds.\n * @param {number} value The input number.\n * @param {number} min The minimum value to return.\n * @param {number} max The maximum value to return.\n * @return {number} The input number if it is within bounds, or the nearest\n *     number within the bounds.\n */\nexport function clamp(value, min, max) {\n    return Math.min(Math.max(value, min), max);\n}\n/**\n * Return the hyperbolic cosine of a given number. The method will use the\n * native `Math.cosh` function if it is available, otherwise the hyperbolic\n * cosine will be calculated via the reference implementation of the Mozilla\n * developer network.\n *\n * @param {number} x X.\n * @return {number} Hyperbolic cosine of x.\n */\nexport var cosh = (function () {\n    // Wrapped in a iife, to save the overhead of checking for the native\n    // implementation on every invocation.\n    var cosh;\n    if ('cosh' in Math) {\n        // The environment supports the native Math.cosh function, use it…\n        cosh = Math.cosh;\n    }\n    else {\n        // … else, use the reference implementation of MDN:\n        cosh = function (x) {\n            var y = /** @type {Math} */ (Math).exp(x);\n            return (y + 1 / y) / 2;\n        };\n    }\n    return cosh;\n})();\n/**\n * Return the base 2 logarithm of a given number. The method will use the\n * native `Math.log2` function if it is available, otherwise the base 2\n * logarithm will be calculated via the reference implementation of the\n * Mozilla developer network.\n *\n * @param {number} x X.\n * @return {number} Base 2 logarithm of x.\n */\nexport var log2 = (function () {\n    // Wrapped in a iife, to save the overhead of checking for the native\n    // implementation on every invocation.\n    var log2;\n    if ('log2' in Math) {\n        // The environment supports the native Math.log2 function, use it…\n        log2 = Math.log2;\n    }\n    else {\n        // … else, use the reference implementation of MDN:\n        log2 = function (x) {\n            return Math.log(x) * Math.LOG2E;\n        };\n    }\n    return log2;\n})();\n/**\n * Returns the square of the closest distance between the point (x, y) and the\n * line segment (x1, y1) to (x2, y2).\n * @param {number} x X.\n * @param {number} y Y.\n * @param {number} x1 X1.\n * @param {number} y1 Y1.\n * @param {number} x2 X2.\n * @param {number} y2 Y2.\n * @return {number} Squared distance.\n */\nexport function squaredSegmentDistance(x, y, x1, y1, x2, y2) {\n    var dx = x2 - x1;\n    var dy = y2 - y1;\n    if (dx !== 0 || dy !== 0) {\n        var t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy);\n        if (t > 1) {\n            x1 = x2;\n            y1 = y2;\n        }\n        else if (t > 0) {\n            x1 += dx * t;\n            y1 += dy * t;\n        }\n    }\n    return squaredDistance(x, y, x1, y1);\n}\n/**\n * Returns the square of the distance between the points (x1, y1) and (x2, y2).\n * @param {number} x1 X1.\n * @param {number} y1 Y1.\n * @param {number} x2 X2.\n * @param {number} y2 Y2.\n * @return {number} Squared distance.\n */\nexport function squaredDistance(x1, y1, x2, y2) {\n    var dx = x2 - x1;\n    var dy = y2 - y1;\n    return dx * dx + dy * dy;\n}\n/**\n * Solves system of linear equations using Gaussian elimination method.\n *\n * @param {Array<Array<number>>} mat Augmented matrix (n x n + 1 column)\n *                                     in row-major order.\n * @return {Array<number>} The resulting vector.\n */\nexport function solveLinearSystem(mat) {\n    var n = mat.length;\n    for (var i = 0; i < n; i++) {\n        // Find max in the i-th column (ignoring i - 1 first rows)\n        var maxRow = i;\n        var maxEl = Math.abs(mat[i][i]);\n        for (var r = i + 1; r < n; r++) {\n            var absValue = Math.abs(mat[r][i]);\n            if (absValue > maxEl) {\n                maxEl = absValue;\n                maxRow = r;\n            }\n        }\n        if (maxEl === 0) {\n            return null; // matrix is singular\n        }\n        // Swap max row with i-th (current) row\n        var tmp = mat[maxRow];\n        mat[maxRow] = mat[i];\n        mat[i] = tmp;\n        // Subtract the i-th row to make all the remaining rows 0 in the i-th column\n        for (var j = i + 1; j < n; j++) {\n            var coef = -mat[j][i] / mat[i][i];\n            for (var k = i; k < n + 1; k++) {\n                if (i == k) {\n                    mat[j][k] = 0;\n                }\n                else {\n                    mat[j][k] += coef * mat[i][k];\n                }\n            }\n        }\n    }\n    // Solve Ax=b for upper triangular matrix A (mat)\n    var x = new Array(n);\n    for (var l = n - 1; l >= 0; l--) {\n        x[l] = mat[l][n] / mat[l][l];\n        for (var m = l - 1; m >= 0; m--) {\n            mat[m][n] -= mat[m][l] * x[l];\n        }\n    }\n    return x;\n}\n/**\n * Converts radians to to degrees.\n *\n * @param {number} angleInRadians Angle in radians.\n * @return {number} Angle in degrees.\n */\nexport function toDegrees(angleInRadians) {\n    return (angleInRadians * 180) / Math.PI;\n}\n/**\n * Converts degrees to radians.\n *\n * @param {number} angleInDegrees Angle in degrees.\n * @return {number} Angle in radians.\n */\nexport function toRadians(angleInDegrees) {\n    return (angleInDegrees * Math.PI) / 180;\n}\n/**\n * Returns the modulo of a / b, depending on the sign of b.\n *\n * @param {number} a Dividend.\n * @param {number} b Divisor.\n * @return {number} Modulo.\n */\nexport function modulo(a, b) {\n    var r = a % b;\n    return r * b < 0 ? r + b : r;\n}\n/**\n * Calculates the linearly interpolated value of x between a and b.\n *\n * @param {number} a Number\n * @param {number} b Number\n * @param {number} x Value to be interpolated.\n * @return {number} Interpolated value.\n */\nexport function lerp(a, b, x) {\n    return a + x * (b - a);\n}\n//# sourceMappingURL=math.js.map","/**\n * @module ol/obj\n */\n/**\n * Polyfill for Object.assign().  Assigns enumerable and own properties from\n * one or more source objects to a target object.\n * See https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign.\n *\n * @param {!Object} target The target object.\n * @param {...Object} var_sources The source object(s).\n * @return {!Object} The modified target object.\n */\nexport var assign = typeof Object.assign === 'function'\n    ? Object.assign\n    : function (target, var_sources) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n        var output = Object(target);\n        for (var i = 1, ii = arguments.length; i < ii; ++i) {\n            var source = arguments[i];\n            if (source !== undefined && source !== null) {\n                for (var key in source) {\n                    if (source.hasOwnProperty(key)) {\n                        output[key] = source[key];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n/**\n * Removes all properties from an object.\n * @param {Object} object The object to clear.\n */\nexport function clear(object) {\n    for (var property in object) {\n        delete object[property];\n    }\n}\n/**\n * Polyfill for Object.values().  Get an array of property values from an object.\n * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values\n *\n * @param {!Object<K,V>} object The object from which to get the values.\n * @return {!Array<V>} The property values.\n * @template K,V\n */\nexport var getValues = typeof Object.values === 'function'\n    ? Object.values\n    : function (object) {\n        var values = [];\n        for (var property in object) {\n            values.push(object[property]);\n        }\n        return values;\n    };\n/**\n * Determine if an object has any properties.\n * @param {Object} object The object to check.\n * @return {boolean} The object is empty.\n */\nexport function isEmpty(object) {\n    var property;\n    for (property in object) {\n        return false;\n    }\n    return !property;\n}\n//# sourceMappingURL=obj.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/proj/epsg3857\n */\nimport Projection from './Projection.js';\nimport Units from './Units.js';\nimport { cosh } from '../math.js';\n/**\n * Radius of WGS84 sphere\n *\n * @const\n * @type {number}\n */\nexport var RADIUS = 6378137;\n/**\n * @const\n * @type {number}\n */\nexport var HALF_SIZE = Math.PI * RADIUS;\n/**\n * @const\n * @type {import(\"../extent.js\").Extent}\n */\nexport var EXTENT = [-HALF_SIZE, -HALF_SIZE, HALF_SIZE, HALF_SIZE];\n/**\n * @const\n * @type {import(\"../extent.js\").Extent}\n */\nexport var WORLD_EXTENT = [-180, -85, 180, 85];\n/**\n * Maximum safe value in y direction\n * @const\n * @type {number}\n */\nexport var MAX_SAFE_Y = RADIUS * Math.log(Math.tan(Math.PI / 2));\n/**\n * @classdesc\n * Projection object for web/spherical Mercator (EPSG:3857).\n */\nvar EPSG3857Projection = /** @class */ (function (_super) {\n    __extends(EPSG3857Projection, _super);\n    /**\n     * @param {string} code Code.\n     */\n    function EPSG3857Projection(code) {\n        return _super.call(this, {\n            code: code,\n            units: Units.METERS,\n            extent: EXTENT,\n            global: true,\n            worldExtent: WORLD_EXTENT,\n            getPointResolution: function (resolution, point) {\n                return resolution / cosh(point[1] / RADIUS);\n            },\n        }) || this;\n    }\n    return EPSG3857Projection;\n}(Projection));\n/**\n * Projections equal to EPSG:3857.\n *\n * @const\n * @type {Array<import(\"./Projection.js\").default>}\n */\nexport var PROJECTIONS = [\n    new EPSG3857Projection('EPSG:3857'),\n    new EPSG3857Projection('EPSG:102100'),\n    new EPSG3857Projection('EPSG:102113'),\n    new EPSG3857Projection('EPSG:900913'),\n    new EPSG3857Projection('http://www.opengis.net/def/crs/EPSG/0/3857'),\n    new EPSG3857Projection('http://www.opengis.net/gml/srs/epsg.xml#3857'),\n];\n/**\n * Transformation from EPSG:4326 to EPSG:3857.\n *\n * @param {Array<number>} input Input array of coordinate values.\n * @param {Array<number>} [opt_output] Output array of coordinate values.\n * @param {number} [opt_dimension] Dimension (default is `2`).\n * @return {Array<number>} Output array of coordinate values.\n */\nexport function fromEPSG4326(input, opt_output, opt_dimension) {\n    var length = input.length;\n    var dimension = opt_dimension > 1 ? opt_dimension : 2;\n    var output = opt_output;\n    if (output === undefined) {\n        if (dimension > 2) {\n            // preserve values beyond second dimension\n            output = input.slice();\n        }\n        else {\n            output = new Array(length);\n        }\n    }\n    for (var i = 0; i < length; i += dimension) {\n        output[i] = (HALF_SIZE * input[i]) / 180;\n        var y = RADIUS * Math.log(Math.tan((Math.PI * (+input[i + 1] + 90)) / 360));\n        if (y > MAX_SAFE_Y) {\n            y = MAX_SAFE_Y;\n        }\n        else if (y < -MAX_SAFE_Y) {\n            y = -MAX_SAFE_Y;\n        }\n        output[i + 1] = y;\n    }\n    return output;\n}\n/**\n * Transformation from EPSG:3857 to EPSG:4326.\n *\n * @param {Array<number>} input Input array of coordinate values.\n * @param {Array<number>} [opt_output] Output array of coordinate values.\n * @param {number} [opt_dimension] Dimension (default is `2`).\n * @return {Array<number>} Output array of coordinate values.\n */\nexport function toEPSG4326(input, opt_output, opt_dimension) {\n    var length = input.length;\n    var dimension = opt_dimension > 1 ? opt_dimension : 2;\n    var output = opt_output;\n    if (output === undefined) {\n        if (dimension > 2) {\n            // preserve values beyond second dimension\n            output = input.slice();\n        }\n        else {\n            output = new Array(length);\n        }\n    }\n    for (var i = 0; i < length; i += dimension) {\n        output[i] = (180 * input[i]) / HALF_SIZE;\n        output[i + 1] =\n            (360 * Math.atan(Math.exp(input[i + 1] / RADIUS))) / Math.PI - 90;\n    }\n    return output;\n}\n//# sourceMappingURL=epsg3857.js.map","/**\n * @module ol/proj/Projection\n */\nimport { METERS_PER_UNIT } from './Units.js';\n/**\n * @typedef {Object} Options\n * @property {string} code The SRS identifier code, e.g. `EPSG:4326`.\n * @property {import(\"./Units.js\").default|string} [units] Units. Required unless a\n * proj4 projection is defined for `code`.\n * @property {import(\"../extent.js\").Extent} [extent] The validity extent for the SRS.\n * @property {string} [axisOrientation='enu'] The axis orientation as specified in Proj4.\n * @property {boolean} [global=false] Whether the projection is valid for the whole globe.\n * @property {number} [metersPerUnit] The meters per unit for the SRS.\n * If not provided, the `units` are used to get the meters per unit from the {@link module:ol/proj/Units~METERS_PER_UNIT}\n * lookup table.\n * @property {import(\"../extent.js\").Extent} [worldExtent] The world extent for the SRS.\n * @property {function(number, import(\"../coordinate.js\").Coordinate):number} [getPointResolution]\n * Function to determine resolution at a point. The function is called with a\n * `number` view resolution and a {@link module:ol/coordinate~Coordinate Coordinate} as arguments, and returns\n * the `number` resolution in projection units at the passed coordinate. If this is `undefined`,\n * the default {@link module:ol/proj.getPointResolution getPointResolution()} function will be used.\n */\n/**\n * @classdesc\n * Projection definition class. One of these is created for each projection\n * supported in the application and stored in the {@link module:ol/proj} namespace.\n * You can use these in applications, but this is not required, as API params\n * and options use {@link module:ol/proj~ProjectionLike} which means the simple string\n * code will suffice.\n *\n * You can use {@link module:ol/proj.get} to retrieve the object for a particular\n * projection.\n *\n * The library includes definitions for `EPSG:4326` and `EPSG:3857`, together\n * with the following aliases:\n * * `EPSG:4326`: CRS:84, urn:ogc:def:crs:EPSG:6.6:4326,\n *     urn:ogc:def:crs:OGC:1.3:CRS84, urn:ogc:def:crs:OGC:2:84,\n *     http://www.opengis.net/gml/srs/epsg.xml#4326,\n *     urn:x-ogc:def:crs:EPSG:4326\n * * `EPSG:3857`: EPSG:102100, EPSG:102113, EPSG:900913,\n *     urn:ogc:def:crs:EPSG:6.18:3:3857,\n *     http://www.opengis.net/gml/srs/epsg.xml#3857\n *\n * If you use [proj4js](https://github.com/proj4js/proj4js), aliases can\n * be added using `proj4.defs()`. After all required projection definitions are\n * added, call the {@link module:ol/proj/proj4.register} function.\n *\n * @api\n */\nvar Projection = /** @class */ (function () {\n    /**\n     * @param {Options} options Projection options.\n     */\n    function Projection(options) {\n        /**\n         * @private\n         * @type {string}\n         */\n        this.code_ = options.code;\n        /**\n         * Units of projected coordinates. When set to `TILE_PIXELS`, a\n         * `this.extent_` and `this.worldExtent_` must be configured properly for each\n         * tile.\n         * @private\n         * @type {import(\"./Units.js\").default}\n         */\n        this.units_ = /** @type {import(\"./Units.js\").default} */ (options.units);\n        /**\n         * Validity extent of the projection in projected coordinates. For projections\n         * with `TILE_PIXELS` units, this is the extent of the tile in\n         * tile pixel space.\n         * @private\n         * @type {import(\"../extent.js\").Extent}\n         */\n        this.extent_ = options.extent !== undefined ? options.extent : null;\n        /**\n         * Extent of the world in EPSG:4326. For projections with\n         * `TILE_PIXELS` units, this is the extent of the tile in\n         * projected coordinate space.\n         * @private\n         * @type {import(\"../extent.js\").Extent}\n         */\n        this.worldExtent_ =\n            options.worldExtent !== undefined ? options.worldExtent : null;\n        /**\n         * @private\n         * @type {string}\n         */\n        this.axisOrientation_ =\n            options.axisOrientation !== undefined ? options.axisOrientation : 'enu';\n        /**\n         * @private\n         * @type {boolean}\n         */\n        this.global_ = options.global !== undefined ? options.global : false;\n        /**\n         * @private\n         * @type {boolean}\n         */\n        this.canWrapX_ = !!(this.global_ && this.extent_);\n        /**\n         * @private\n         * @type {function(number, import(\"../coordinate.js\").Coordinate):number|undefined}\n         */\n        this.getPointResolutionFunc_ = options.getPointResolution;\n        /**\n         * @private\n         * @type {import(\"../tilegrid/TileGrid.js\").default}\n         */\n        this.defaultTileGrid_ = null;\n        /**\n         * @private\n         * @type {number|undefined}\n         */\n        this.metersPerUnit_ = options.metersPerUnit;\n    }\n    /**\n     * @return {boolean} The projection is suitable for wrapping the x-axis\n     */\n    Projection.prototype.canWrapX = function () {\n        return this.canWrapX_;\n    };\n    /**\n     * Get the code for this projection, e.g. 'EPSG:4326'.\n     * @return {string} Code.\n     * @api\n     */\n    Projection.prototype.getCode = function () {\n        return this.code_;\n    };\n    /**\n     * Get the validity extent for this projection.\n     * @return {import(\"../extent.js\").Extent} Extent.\n     * @api\n     */\n    Projection.prototype.getExtent = function () {\n        return this.extent_;\n    };\n    /**\n     * Get the units of this projection.\n     * @return {import(\"./Units.js\").default} Units.\n     * @api\n     */\n    Projection.prototype.getUnits = function () {\n        return this.units_;\n    };\n    /**\n     * Get the amount of meters per unit of this projection.  If the projection is\n     * not configured with `metersPerUnit` or a units identifier, the return is\n     * `undefined`.\n     * @return {number|undefined} Meters.\n     * @api\n     */\n    Projection.prototype.getMetersPerUnit = function () {\n        return this.metersPerUnit_ || METERS_PER_UNIT[this.units_];\n    };\n    /**\n     * Get the world extent for this projection.\n     * @return {import(\"../extent.js\").Extent} Extent.\n     * @api\n     */\n    Projection.prototype.getWorldExtent = function () {\n        return this.worldExtent_;\n    };\n    /**\n     * Get the axis orientation of this projection.\n     * Example values are:\n     * enu - the default easting, northing, elevation.\n     * neu - northing, easting, up - useful for \"lat/long\" geographic coordinates,\n     *     or south orientated transverse mercator.\n     * wnu - westing, northing, up - some planetary coordinate systems have\n     *     \"west positive\" coordinate systems\n     * @return {string} Axis orientation.\n     * @api\n     */\n    Projection.prototype.getAxisOrientation = function () {\n        return this.axisOrientation_;\n    };\n    /**\n     * Is this projection a global projection which spans the whole world?\n     * @return {boolean} Whether the projection is global.\n     * @api\n     */\n    Projection.prototype.isGlobal = function () {\n        return this.global_;\n    };\n    /**\n     * Set if the projection is a global projection which spans the whole world\n     * @param {boolean} global Whether the projection is global.\n     * @api\n     */\n    Projection.prototype.setGlobal = function (global) {\n        this.global_ = global;\n        this.canWrapX_ = !!(global && this.extent_);\n    };\n    /**\n     * @return {import(\"../tilegrid/TileGrid.js\").default} The default tile grid.\n     */\n    Projection.prototype.getDefaultTileGrid = function () {\n        return this.defaultTileGrid_;\n    };\n    /**\n     * @param {import(\"../tilegrid/TileGrid.js\").default} tileGrid The default tile grid.\n     */\n    Projection.prototype.setDefaultTileGrid = function (tileGrid) {\n        this.defaultTileGrid_ = tileGrid;\n    };\n    /**\n     * Set the validity extent for this projection.\n     * @param {import(\"../extent.js\").Extent} extent Extent.\n     * @api\n     */\n    Projection.prototype.setExtent = function (extent) {\n        this.extent_ = extent;\n        this.canWrapX_ = !!(this.global_ && extent);\n    };\n    /**\n     * Set the world extent for this projection.\n     * @param {import(\"../extent.js\").Extent} worldExtent World extent\n     *     [minlon, minlat, maxlon, maxlat].\n     * @api\n     */\n    Projection.prototype.setWorldExtent = function (worldExtent) {\n        this.worldExtent_ = worldExtent;\n    };\n    /**\n     * Set the getPointResolution function (see {@link module:ol/proj.getPointResolution}\n     * for this projection.\n     * @param {function(number, import(\"../coordinate.js\").Coordinate):number} func Function\n     * @api\n     */\n    Projection.prototype.setGetPointResolution = function (func) {\n        this.getPointResolutionFunc_ = func;\n    };\n    /**\n     * Get the custom point resolution function for this projection (if set).\n     * @return {function(number, import(\"../coordinate.js\").Coordinate):number|undefined} The custom point\n     * resolution function (if set).\n     */\n    Projection.prototype.getPointResolutionFunc = function () {\n        return this.getPointResolutionFunc_;\n    };\n    return Projection;\n}());\nexport default Projection;\n//# sourceMappingURL=Projection.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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\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/proj/epsg4326\n */\nimport Projection from './Projection.js';\nimport Units from './Units.js';\n/**\n * Semi-major radius of the WGS84 ellipsoid.\n *\n * @const\n * @type {number}\n */\nexport var RADIUS = 6378137;\n/**\n * Extent of the EPSG:4326 projection which is the whole world.\n *\n * @const\n * @type {import(\"../extent.js\").Extent}\n */\nexport var EXTENT = [-180, -90, 180, 90];\n/**\n * @const\n * @type {number}\n */\nexport var METERS_PER_UNIT = (Math.PI * RADIUS) / 180;\n/**\n * @classdesc\n * Projection object for WGS84 geographic coordinates (EPSG:4326).\n *\n * Note that OpenLayers does not strictly comply with the EPSG definition.\n * The EPSG registry defines 4326 as a CRS for Latitude,Longitude (y,x).\n * OpenLayers treats EPSG:4326 as a pseudo-projection, with x,y coordinates.\n */\nvar EPSG4326Projection = /** @class */ (function (_super) {\n    __extends(EPSG4326Projection, _super);\n    /**\n     * @param {string} code Code.\n     * @param {string} [opt_axisOrientation] Axis orientation.\n     */\n    function EPSG4326Projection(code, opt_axisOrientation) {\n        return _super.call(this, {\n            code: code,\n            units: Units.DEGREES,\n            extent: EXTENT,\n            axisOrientation: opt_axisOrientation,\n            global: true,\n            metersPerUnit: METERS_PER_UNIT,\n            worldExtent: EXTENT,\n        }) || this;\n    }\n    return EPSG4326Projection;\n}(Projection));\n/**\n * Projections equal to EPSG:4326.\n *\n * @const\n * @type {Array<import(\"./Projection.js\").default>}\n */\nexport var PROJECTIONS = [\n    new EPSG4326Projection('CRS:84'),\n    new EPSG4326Projection('EPSG:4326', 'neu'),\n    new EPSG4326Projection('urn:ogc:def:crs:OGC:1.3:CRS84'),\n    new EPSG4326Projection('urn:ogc:def:crs:OGC:2:84'),\n    new EPSG4326Projection('http://www.opengis.net/def/crs/OGC/1.3/CRS84', 'neu'),\n    new EPSG4326Projection('http://www.opengis.net/gml/srs/epsg.xml#4326', 'neu'),\n    new EPSG4326Projection('http://www.opengis.net/def/crs/EPSG/0/4326', 'neu'),\n];\n//# sourceMappingURL=epsg4326.js.map","/**\n * @module ol/proj/projections\n */\n/**\n * @type {Object<string, import(\"./Projection.js\").default>}\n */\nvar cache = {};\n/**\n * Clear the projections cache.\n */\nexport function clear() {\n    cache = {};\n}\n/**\n * Get a cached projection by code.\n * @param {string} code The code for the projection.\n * @return {import(\"./Projection.js\").default} The projection (if cached).\n */\nexport function get(code) {\n    return (cache[code] ||\n        cache[code.replace(/urn:(x-)?ogc:def:crs:EPSG:(.*:)?(\\w+)$/, 'EPSG:$3')] ||\n        null);\n}\n/**\n * Add a projection to the cache.\n * @param {string} code The projection code.\n * @param {import(\"./Projection.js\").default} projection The projection to cache.\n */\nexport function add(code, projection) {\n    cache[code] = projection;\n}\n//# sourceMappingURL=projections.js.map","/**\n * @module ol/proj/transforms\n */\nimport { isEmpty } from '../obj.js';\n/**\n * @private\n * @type {!Object<string, Object<string, import(\"../proj.js\").TransformFunction>>}\n */\nvar transforms = {};\n/**\n * Clear the transform cache.\n */\nexport function clear() {\n    transforms = {};\n}\n/**\n * Registers a conversion function to convert coordinates from the source\n * projection to the destination projection.\n *\n * @param {import(\"./Projection.js\").default} source Source.\n * @param {import(\"./Projection.js\").default} destination Destination.\n * @param {import(\"../proj.js\").TransformFunction} transformFn Transform.\n */\nexport function add(source, destination, transformFn) {\n    var sourceCode = source.getCode();\n    var destinationCode = destination.getCode();\n    if (!(sourceCode in transforms)) {\n        transforms[sourceCode] = {};\n    }\n    transforms[sourceCode][destinationCode] = transformFn;\n}\n/**\n * Unregisters the conversion function to convert coordinates from the source\n * projection to the destination projection.  This method is used to clean up\n * cached transforms during testing.\n *\n * @param {import(\"./Projection.js\").default} source Source projection.\n * @param {import(\"./Projection.js\").default} destination Destination projection.\n * @return {import(\"../proj.js\").TransformFunction} transformFn The unregistered transform.\n */\nexport function remove(source, destination) {\n    var sourceCode = source.getCode();\n    var destinationCode = destination.getCode();\n    var transform = transforms[sourceCode][destinationCode];\n    delete transforms[sourceCode][destinationCode];\n    if (isEmpty(transforms[sourceCode])) {\n        delete transforms[sourceCode];\n    }\n    return transform;\n}\n/**\n * Get a transform given a source code and a destination code.\n * @param {string} sourceCode The code for the source projection.\n * @param {string} destinationCode The code for the destination projection.\n * @return {import(\"../proj.js\").TransformFunction|undefined} The transform function (if found).\n */\nexport function get(sourceCode, destinationCode) {\n    var transform;\n    if (sourceCode in transforms && destinationCode in transforms[sourceCode]) {\n        transform = transforms[sourceCode][destinationCode];\n    }\n    return transform;\n}\n//# sourceMappingURL=transforms.js.map","/**\n * @module ol/sphere\n */\nimport GeometryType from './geom/GeometryType.js';\nimport { toDegrees, toRadians } from './math.js';\n/**\n * Object literal with options for the {@link getLength} or {@link getArea}\n * functions.\n * @typedef {Object} SphereMetricOptions\n * @property {import(\"./proj.js\").ProjectionLike} [projection='EPSG:3857']\n * Projection of the  geometry.  By default, the geometry is assumed to be in\n * Web Mercator.\n * @property {number} [radius=6371008.8] Sphere radius.  By default, the\n * [mean Earth radius](https://en.wikipedia.org/wiki/Earth_radius#Mean_radius)\n * for the WGS84 ellipsoid is used.\n */\n/**\n * The mean Earth radius (1/3 * (2a + b)) for the WGS84 ellipsoid.\n * https://en.wikipedia.org/wiki/Earth_radius#Mean_radius\n * @type {number}\n */\nexport var DEFAULT_RADIUS = 6371008.8;\n/**\n * Get the great circle distance (in meters) between two geographic coordinates.\n * @param {Array} c1 Starting coordinate.\n * @param {Array} c2 Ending coordinate.\n * @param {number} [opt_radius] The sphere radius to use.  Defaults to the Earth's\n *     mean radius using the WGS84 ellipsoid.\n * @return {number} The great circle distance between the points (in meters).\n * @api\n */\nexport function getDistance(c1, c2, opt_radius) {\n    var radius = opt_radius || DEFAULT_RADIUS;\n    var lat1 = toRadians(c1[1]);\n    var lat2 = toRadians(c2[1]);\n    var deltaLatBy2 = (lat2 - lat1) / 2;\n    var deltaLonBy2 = toRadians(c2[0] - c1[0]) / 2;\n    var a = Math.sin(deltaLatBy2) * Math.sin(deltaLatBy2) +\n        Math.sin(deltaLonBy2) *\n            Math.sin(deltaLonBy2) *\n            Math.cos(lat1) *\n            Math.cos(lat2);\n    return 2 * radius * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n}\n/**\n * Get the cumulative great circle length of linestring coordinates (geographic).\n * @param {Array} coordinates Linestring coordinates.\n * @param {number} radius The sphere radius to use.\n * @return {number} The length (in meters).\n */\nfunction getLengthInternal(coordinates, radius) {\n    var length = 0;\n    for (var i = 0, ii = coordinates.length; i < ii - 1; ++i) {\n        length += getDistance(coordinates[i], coordinates[i + 1], radius);\n    }\n    return length;\n}\n/**\n * Get the spherical length of a geometry.  This length is the sum of the\n * great circle distances between coordinates.  For polygons, the length is\n * the sum of all rings.  For points, the length is zero.  For multi-part\n * geometries, the length is the sum of the length of each part.\n * @param {import(\"./geom/Geometry.js\").default} geometry A geometry.\n * @param {SphereMetricOptions} [opt_options] Options for the\n * length calculation.  By default, geometries are assumed to be in 'EPSG:3857'.\n * You can change this by providing a `projection` option.\n * @return {number} The spherical length (in meters).\n * @api\n */\nexport function getLength(geometry, opt_options) {\n    var options = opt_options || {};\n    var radius = options.radius || DEFAULT_RADIUS;\n    var projection = options.projection || 'EPSG:3857';\n    var type = geometry.getType();\n    if (type !== GeometryType.GEOMETRY_COLLECTION) {\n        geometry = geometry.clone().transform(projection, 'EPSG:4326');\n    }\n    var length = 0;\n    var coordinates, coords, i, ii, j, jj;\n    switch (type) {\n        case GeometryType.POINT:\n        case GeometryType.MULTI_POINT: {\n            break;\n        }\n        case GeometryType.LINE_STRING:\n        case GeometryType.LINEAR_RING: {\n            coordinates = /** @type {import(\"./geom/SimpleGeometry.js\").default} */ (geometry).getCoordinates();\n            length = getLengthInternal(coordinates, radius);\n            break;\n        }\n        case GeometryType.MULTI_LINE_STRING:\n        case GeometryType.POLYGON: {\n            coordinates = /** @type {import(\"./geom/SimpleGeometry.js\").default} */ (geometry).getCoordinates();\n            for (i = 0, ii = coordinates.length; i < ii; ++i) {\n                length += getLengthInternal(coordinates[i], radius);\n            }\n            break;\n        }\n        case GeometryType.MULTI_POLYGON: {\n            coordinates = /** @type {import(\"./geom/SimpleGeometry.js\").default} */ (geometry).getCoordinates();\n            for (i = 0, ii = coordinates.length; i < ii; ++i) {\n                coords = coordinates[i];\n                for (j = 0, jj = coords.length; j < jj; ++j) {\n                    length += getLengthInternal(coords[j], radius);\n                }\n            }\n            break;\n        }\n        case GeometryType.GEOMETRY_COLLECTION: {\n            var geometries = \n            /** @type {import(\"./geom/GeometryCollection.js\").default} */ (geometry).getGeometries();\n            for (i = 0, ii = geometries.length; i < ii; ++i) {\n                length += getLength(geometries[i], opt_options);\n            }\n            break;\n        }\n        default: {\n            throw new Error('Unsupported geometry type: ' + type);\n        }\n    }\n    return length;\n}\n/**\n * Returns the spherical area for a list of coordinates.\n *\n * [Reference](https://trs.jpl.nasa.gov/handle/2014/40409)\n * Robert. G. Chamberlain and William H. Duquette, \"Some Algorithms for\n * Polygons on a Sphere\", JPL Publication 07-03, Jet Propulsion\n * Laboratory, Pasadena, CA, June 2007\n *\n * @param {Array<import(\"./coordinate.js\").Coordinate>} coordinates List of coordinates of a linear\n * ring. If the ring is oriented clockwise, the area will be positive,\n * otherwise it will be negative.\n * @param {number} radius The sphere radius.\n * @return {number} Area (in square meters).\n */\nfunction getAreaInternal(coordinates, radius) {\n    var area = 0;\n    var len = coordinates.length;\n    var x1 = coordinates[len - 1][0];\n    var y1 = coordinates[len - 1][1];\n    for (var i = 0; i < len; i++) {\n        var x2 = coordinates[i][0];\n        var y2 = coordinates[i][1];\n        area +=\n            toRadians(x2 - x1) *\n                (2 + Math.sin(toRadians(y1)) + Math.sin(toRadians(y2)));\n        x1 = x2;\n        y1 = y2;\n    }\n    return (area * radius * radius) / 2.0;\n}\n/**\n * Get the spherical area of a geometry.  This is the area (in meters) assuming\n * that polygon edges are segments of great circles on a sphere.\n * @param {import(\"./geom/Geometry.js\").default} geometry A geometry.\n * @param {SphereMetricOptions} [opt_options] Options for the area\n *     calculation.  By default, geometries are assumed to be in 'EPSG:3857'.\n *     You can change this by providing a `projection` option.\n * @return {number} The spherical area (in square meters).\n * @api\n */\nexport function getArea(geometry, opt_options) {\n    var options = opt_options || {};\n    var radius = options.radius || DEFAULT_RADIUS;\n    var projection = options.projection || 'EPSG:3857';\n    var type = geometry.getType();\n    if (type !== GeometryType.GEOMETRY_COLLECTION) {\n        geometry = geometry.clone().transform(projection, 'EPSG:4326');\n    }\n    var area = 0;\n    var coordinates, coords, i, ii, j, jj;\n    switch (type) {\n        case GeometryType.POINT:\n        case GeometryType.MULTI_POINT:\n        case GeometryType.LINE_STRING:\n        case GeometryType.MULTI_LINE_STRING:\n        case GeometryType.LINEAR_RING: {\n            break;\n        }\n        case GeometryType.POLYGON: {\n            coordinates = /** @type {import(\"./geom/Polygon.js\").default} */ (geometry).getCoordinates();\n            area = Math.abs(getAreaInternal(coordinates[0], radius));\n            for (i = 1, ii = coordinates.length; i < ii; ++i) {\n                area -= Math.abs(getAreaInternal(coordinates[i], radius));\n            }\n            break;\n        }\n        case GeometryType.MULTI_POLYGON: {\n            coordinates = /** @type {import(\"./geom/SimpleGeometry.js\").default} */ (geometry).getCoordinates();\n            for (i = 0, ii = coordinates.length; i < ii; ++i) {\n                coords = coordinates[i];\n                area += Math.abs(getAreaInternal(coords[0], radius));\n                for (j = 1, jj = coords.length; j < jj; ++j) {\n                    area -= Math.abs(getAreaInternal(coords[j], radius));\n                }\n            }\n            break;\n        }\n        case GeometryType.GEOMETRY_COLLECTION: {\n            var geometries = \n            /** @type {import(\"./geom/GeometryCollection.js\").default} */ (geometry).getGeometries();\n            for (i = 0, ii = geometries.length; i < ii; ++i) {\n                area += getArea(geometries[i], opt_options);\n            }\n            break;\n        }\n        default: {\n            throw new Error('Unsupported geometry type: ' + type);\n        }\n    }\n    return area;\n}\n/**\n * Returns the coordinate at the given distance and bearing from `c1`.\n *\n * @param {import(\"./coordinate.js\").Coordinate} c1 The origin point (`[lon, lat]` in degrees).\n * @param {number} distance The great-circle distance between the origin\n *     point and the target point.\n * @param {number} bearing The bearing (in radians).\n * @param {number} [opt_radius] The sphere radius to use.  Defaults to the Earth's\n *     mean radius using the WGS84 ellipsoid.\n * @return {import(\"./coordinate.js\").Coordinate} The target point.\n */\nexport function offset(c1, distance, bearing, opt_radius) {\n    var radius = opt_radius || DEFAULT_RADIUS;\n    var lat1 = toRadians(c1[1]);\n    var lon1 = toRadians(c1[0]);\n    var dByR = distance / radius;\n    var lat = Math.asin(Math.sin(lat1) * Math.cos(dByR) +\n        Math.cos(lat1) * Math.sin(dByR) * Math.cos(bearing));\n    var lon = lon1 +\n        Math.atan2(Math.sin(bearing) * Math.sin(dByR) * Math.cos(lat1), Math.cos(dByR) - Math.sin(lat1) * Math.sin(lat));\n    return [toDegrees(lon), toDegrees(lat)];\n}\n//# sourceMappingURL=sphere.js.map","/**\n * @module ol/proj\n */\n/**\n * The ol/proj module stores:\n * * a list of {@link module:ol/proj/Projection}\n * objects, one for each projection supported by the application\n * * a list of transform functions needed to convert coordinates in one projection\n * into another.\n *\n * The static functions are the methods used to maintain these.\n * Each transform function can handle not only simple coordinate pairs, but also\n * large arrays of coordinates such as vector geometries.\n *\n * When loaded, the library adds projection objects for EPSG:4326 (WGS84\n * geographic coordinates) and EPSG:3857 (Web or Spherical Mercator, as used\n * for example by Bing Maps or OpenStreetMap), together with the relevant\n * transform functions.\n *\n * Additional transforms may be added by using the http://proj4js.org/\n * library (version 2.2 or later). You can use the full build supplied by\n * Proj4js, or create a custom build to support those projections you need; see\n * the Proj4js website for how to do this. You also need the Proj4js definitions\n * for the required projections. These definitions can be obtained from\n * https://epsg.io/, and are a JS function, so can be loaded in a script\n * tag (as in the examples) or pasted into your application.\n *\n * After all required projection definitions are added to proj4's registry (by\n * using `proj4.defs()`), simply call `register(proj4)` from the `ol/proj/proj4`\n * package. Existing transforms are not changed by this function. See\n * examples/wms-image-custom-proj for an example of this.\n *\n * Additional projection definitions can be registered with `proj4.defs()` any\n * time. Just make sure to call `register(proj4)` again; for example, with user-supplied data where you don't\n * know in advance what projections are needed, you can initially load minimal\n * support and then load whichever are requested.\n *\n * Note that Proj4js does not support projection extents. If you want to add\n * one for creating default tile grids, you can add it after the Projection\n * object has been created with `setExtent`, for example,\n * `get('EPSG:1234').setExtent(extent)`.\n *\n * In addition to Proj4js support, any transform functions can be added with\n * {@link module:ol/proj.addCoordinateTransforms}. To use this, you must first create\n * a {@link module:ol/proj/Projection} object for the new projection and add it with\n * {@link module:ol/proj.addProjection}. You can then add the forward and inverse\n * functions with {@link module:ol/proj.addCoordinateTransforms}. See\n * examples/wms-custom-proj for an example of this.\n *\n * Note that if no transforms are needed and you only need to define the\n * projection, just add a {@link module:ol/proj/Projection} with\n * {@link module:ol/proj.addProjection}. See examples/wms-no-proj for an example of\n * this.\n */\nimport Projection from './proj/Projection.js';\nimport Units, { METERS_PER_UNIT } from './proj/Units.js';\nimport { PROJECTIONS as EPSG3857_PROJECTIONS, fromEPSG4326, toEPSG4326, } from './proj/epsg3857.js';\nimport { PROJECTIONS as EPSG4326_PROJECTIONS } from './proj/epsg4326.js';\nimport { add as addProj, clear as clearProj, get as getProj, } from './proj/projections.js';\nimport { add as addTransformFunc, clear as clearTransformFuncs, get as getTransformFunc, } from './proj/transforms.js';\nimport { applyTransform, getWidth } from './extent.js';\nimport { clamp, modulo } from './math.js';\nimport { getDistance } from './sphere.js';\nimport { getWorldsAway } from './coordinate.js';\n/**\n * A projection as {@link module:ol/proj/Projection}, SRS identifier\n * string or undefined.\n * @typedef {Projection|string|undefined} ProjectionLike\n * @api\n */\n/**\n * A transform function accepts an array of input coordinate values, an optional\n * output array, and an optional dimension (default should be 2).  The function\n * transforms the input coordinate values, populates the output array, and\n * returns the output array.\n *\n * @typedef {function(Array<number>, Array<number>=, number=): Array<number>} TransformFunction\n * @api\n */\nexport { METERS_PER_UNIT };\nexport { Projection };\n/**\n * @param {Array<number>} input Input coordinate array.\n * @param {Array<number>} [opt_output] Output array of coordinate values.\n * @param {number} [opt_dimension] Dimension.\n * @return {Array<number>} Output coordinate array (new array, same coordinate\n *     values).\n */\nexport function cloneTransform(input, opt_output, opt_dimension) {\n    var output;\n    if (opt_output !== undefined) {\n        for (var i = 0, ii = input.length; i < ii; ++i) {\n            opt_output[i] = input[i];\n        }\n        output = opt_output;\n    }\n    else {\n        output = input.slice();\n    }\n    return output;\n}\n/**\n * @param {Array<number>} input Input coordinate array.\n * @param {Array<number>} [opt_output] Output array of coordinate values.\n * @param {number} [opt_dimension] Dimension.\n * @return {Array<number>} Input coordinate array (same array as input).\n */\nexport function identityTransform(input, opt_output, opt_dimension) {\n    if (opt_output !== undefined && input !== opt_output) {\n        for (var i = 0, ii = input.length; i < ii; ++i) {\n            opt_output[i] = input[i];\n        }\n        input = opt_output;\n    }\n    return input;\n}\n/**\n * Add a Projection object to the list of supported projections that can be\n * looked up by their code.\n *\n * @param {Projection} projection Projection instance.\n * @api\n */\nexport function addProjection(projection) {\n    addProj(projection.getCode(), projection);\n    addTransformFunc(projection, projection, cloneTransform);\n}\n/**\n * @param {Array<Projection>} projections Projections.\n */\nexport function addProjections(projections) {\n    projections.forEach(addProjection);\n}\n/**\n * Fetches a Projection object for the code specified.\n *\n * @param {ProjectionLike} projectionLike Either a code string which is\n *     a combination of authority and identifier such as \"EPSG:4326\", or an\n *     existing projection object, or undefined.\n * @return {Projection} Projection object, or null if not in list.\n * @api\n */\nexport function get(projectionLike) {\n    return typeof projectionLike === 'string'\n        ? getProj(/** @type {string} */ (projectionLike))\n        : /** @type {Projection} */ (projectionLike) || null;\n}\n/**\n * Get the resolution of the point in degrees or distance units.\n * For projections with degrees as the unit this will simply return the\n * provided resolution. For other projections the point resolution is\n * by default estimated by transforming the 'point' pixel to EPSG:4326,\n * measuring its width and height on the normal sphere,\n * and taking the average of the width and height.\n * A custom function can be provided for a specific projection, either\n * by setting the `getPointResolution` option in the\n * {@link module:ol/proj/Projection~Projection} constructor or by using\n * {@link module:ol/proj/Projection~Projection#setGetPointResolution} to change an existing\n * projection object.\n * @param {ProjectionLike} projection The projection.\n * @param {number} resolution Nominal resolution in projection units.\n * @param {import(\"./coordinate.js\").Coordinate} point Point to find adjusted resolution at.\n * @param {import(\"./proj/Units.js\").default} [opt_units] Units to get the point resolution in.\n * Default is the projection's units.\n * @return {number} Point resolution.\n * @api\n */\nexport function getPointResolution(projection, resolution, point, opt_units) {\n    projection = get(projection);\n    var pointResolution;\n    var getter = projection.getPointResolutionFunc();\n    if (getter) {\n        pointResolution = getter(resolution, point);\n        if (opt_units && opt_units !== projection.getUnits()) {\n            var metersPerUnit = projection.getMetersPerUnit();\n            if (metersPerUnit) {\n                pointResolution =\n                    (pointResolution * metersPerUnit) / METERS_PER_UNIT[opt_units];\n            }\n        }\n    }\n    else {\n        var units = projection.getUnits();\n        if ((units == Units.DEGREES && !opt_units) || opt_units == Units.DEGREES) {\n            pointResolution = resolution;\n        }\n        else {\n            // Estimate point resolution by transforming the center pixel to EPSG:4326,\n            // measuring its width and height on the normal sphere, and taking the\n            // average of the width and height.\n            var toEPSG4326_1 = getTransformFromProjections(projection, get('EPSG:4326'));\n            if (toEPSG4326_1 === identityTransform && units !== Units.DEGREES) {\n                // no transform is available\n                pointResolution = resolution * projection.getMetersPerUnit();\n            }\n            else {\n                var vertices = [\n                    point[0] - resolution / 2,\n                    point[1],\n                    point[0] + resolution / 2,\n                    point[1],\n                    point[0],\n                    point[1] - resolution / 2,\n                    point[0],\n                    point[1] + resolution / 2,\n                ];\n                vertices = toEPSG4326_1(vertices, vertices, 2);\n                var width = getDistance(vertices.slice(0, 2), vertices.slice(2, 4));\n                var height = getDistance(vertices.slice(4, 6), vertices.slice(6, 8));\n                pointResolution = (width + height) / 2;\n            }\n            var metersPerUnit = opt_units\n                ? METERS_PER_UNIT[opt_units]\n                : projection.getMetersPerUnit();\n            if (metersPerUnit !== undefined) {\n                pointResolution /= metersPerUnit;\n            }\n        }\n    }\n    return pointResolution;\n}\n/**\n * Registers transformation functions that don't alter coordinates. Those allow\n * to transform between projections with equal meaning.\n *\n * @param {Array<Projection>} projections Projections.\n * @api\n */\nexport function addEquivalentProjections(projections) {\n    addProjections(projections);\n    projections.forEach(function (source) {\n        projections.forEach(function (destination) {\n            if (source !== destination) {\n                addTransformFunc(source, destination, cloneTransform);\n            }\n        });\n    });\n}\n/**\n * Registers transformation functions to convert coordinates in any projection\n * in projection1 to any projection in projection2.\n *\n * @param {Array<Projection>} projections1 Projections with equal\n *     meaning.\n * @param {Array<Projection>} projections2 Projections with equal\n *     meaning.\n * @param {TransformFunction} forwardTransform Transformation from any\n *   projection in projection1 to any projection in projection2.\n * @param {TransformFunction} inverseTransform Transform from any projection\n *   in projection2 to any projection in projection1..\n */\nexport function addEquivalentTransforms(projections1, projections2, forwardTransform, inverseTransform) {\n    projections1.forEach(function (projection1) {\n        projections2.forEach(function (projection2) {\n            addTransformFunc(projection1, projection2, forwardTransform);\n            addTransformFunc(projection2, projection1, inverseTransform);\n        });\n    });\n}\n/**\n * Clear all cached projections and transforms.\n */\nexport function clearAllProjections() {\n    clearProj();\n    clearTransformFuncs();\n}\n/**\n * @param {Projection|string|undefined} projection Projection.\n * @param {string} defaultCode Default code.\n * @return {Projection} Projection.\n */\nexport function createProjection(projection, defaultCode) {\n    if (!projection) {\n        return get(defaultCode);\n    }\n    else if (typeof projection === 'string') {\n        return get(projection);\n    }\n    else {\n        return /** @type {Projection} */ (projection);\n    }\n}\n/**\n * Creates a {@link module:ol/proj~TransformFunction} from a simple 2D coordinate transform\n * function.\n * @param {function(import(\"./coordinate.js\").Coordinate): import(\"./coordinate.js\").Coordinate} coordTransform Coordinate\n *     transform.\n * @return {TransformFunction} Transform function.\n */\nexport function createTransformFromCoordinateTransform(coordTransform) {\n    return (\n    /**\n     * @param {Array<number>} input Input.\n     * @param {Array<number>} [opt_output] Output.\n     * @param {number} [opt_dimension] Dimension.\n     * @return {Array<number>} Output.\n     */\n    function (input, opt_output, opt_dimension) {\n        var length = input.length;\n        var dimension = opt_dimension !== undefined ? opt_dimension : 2;\n        var output = opt_output !== undefined ? opt_output : new Array(length);\n        for (var i = 0; i < length; i += dimension) {\n            var point = coordTransform([input[i], input[i + 1]]);\n            output[i] = point[0];\n            output[i + 1] = point[1];\n            for (var j = dimension - 1; j >= 2; --j) {\n                output[i + j] = input[i + j];\n            }\n        }\n        return output;\n    });\n}\n/**\n * Registers coordinate transform functions to convert coordinates between the\n * source projection and the destination projection.\n * The forward and inverse functions convert coordinate pairs; this function\n * converts these into the functions used internally which also handle\n * extents and coordinate arrays.\n *\n * @param {ProjectionLike} source Source projection.\n * @param {ProjectionLike} destination Destination projection.\n * @param {function(import(\"./coordinate.js\").Coordinate): import(\"./coordinate.js\").Coordinate} forward The forward transform\n *     function (that is, from the source projection to the destination\n *     projection) that takes a {@link module:ol/coordinate~Coordinate} as argument and returns\n *     the transformed {@link module:ol/coordinate~Coordinate}.\n * @param {function(import(\"./coordinate.js\").Coordinate): import(\"./coordinate.js\").Coordinate} inverse The inverse transform\n *     function (that is, from the destination projection to the source\n *     projection) that takes a {@link module:ol/coordinate~Coordinate} as argument and returns\n *     the transformed {@link module:ol/coordinate~Coordinate}.\n * @api\n */\nexport function addCoordinateTransforms(source, destination, forward, inverse) {\n    var sourceProj = get(source);\n    var destProj = get(destination);\n    addTransformFunc(sourceProj, destProj, createTransformFromCoordinateTransform(forward));\n    addTransformFunc(destProj, sourceProj, createTransformFromCoordinateTransform(inverse));\n}\n/**\n * Transforms a coordinate from longitude/latitude to a different projection.\n * @param {import(\"./coordinate.js\").Coordinate} coordinate Coordinate as longitude and latitude, i.e.\n *     an array with longitude as 1st and latitude as 2nd element.\n * @param {ProjectionLike} [opt_projection] Target projection. The\n *     default is Web Mercator, i.e. 'EPSG:3857'.\n * @return {import(\"./coordinate.js\").Coordinate} Coordinate projected to the target projection.\n * @api\n */\nexport function fromLonLat(coordinate, opt_projection) {\n    return transform(coordinate, 'EPSG:4326', opt_projection !== undefined ? opt_projection : 'EPSG:3857');\n}\n/**\n * Transforms a coordinate to longitude/latitude.\n * @param {import(\"./coordinate.js\").Coordinate} coordinate Projected coordinate.\n * @param {ProjectionLike} [opt_projection] Projection of the coordinate.\n *     The default is Web Mercator, i.e. 'EPSG:3857'.\n * @return {import(\"./coordinate.js\").Coordinate} Coordinate as longitude and latitude, i.e. an array\n *     with longitude as 1st and latitude as 2nd element.\n * @api\n */\nexport function toLonLat(coordinate, opt_projection) {\n    var lonLat = transform(coordinate, opt_projection !== undefined ? opt_projection : 'EPSG:3857', 'EPSG:4326');\n    var lon = lonLat[0];\n    if (lon < -180 || lon > 180) {\n        lonLat[0] = modulo(lon + 180, 360) - 180;\n    }\n    return lonLat;\n}\n/**\n * Checks if two projections are the same, that is every coordinate in one\n * projection does represent the same geographic point as the same coordinate in\n * the other projection.\n *\n * @param {Projection} projection1 Projection 1.\n * @param {Projection} projection2 Projection 2.\n * @return {boolean} Equivalent.\n * @api\n */\nexport function equivalent(projection1, projection2) {\n    if (projection1 === projection2) {\n        return true;\n    }\n    var equalUnits = projection1.getUnits() === projection2.getUnits();\n    if (projection1.getCode() === projection2.getCode()) {\n        return equalUnits;\n    }\n    else {\n        var transformFunc = getTransformFromProjections(projection1, projection2);\n        return transformFunc === cloneTransform && equalUnits;\n    }\n}\n/**\n * Searches in the list of transform functions for the function for converting\n * coordinates from the source projection to the destination projection.\n *\n * @param {Projection} sourceProjection Source Projection object.\n * @param {Projection} destinationProjection Destination Projection\n *     object.\n * @return {TransformFunction} Transform function.\n */\nexport function getTransformFromProjections(sourceProjection, destinationProjection) {\n    var sourceCode = sourceProjection.getCode();\n    var destinationCode = destinationProjection.getCode();\n    var transformFunc = getTransformFunc(sourceCode, destinationCode);\n    if (!transformFunc) {\n        transformFunc = identityTransform;\n    }\n    return transformFunc;\n}\n/**\n * Given the projection-like objects, searches for a transformation\n * function to convert a coordinates array from the source projection to the\n * destination projection.\n *\n * @param {ProjectionLike} source Source.\n * @param {ProjectionLike} destination Destination.\n * @return {TransformFunction} Transform function.\n * @api\n */\nexport function getTransform(source, destination) {\n    var sourceProjection = get(source);\n    var destinationProjection = get(destination);\n    return getTransformFromProjections(sourceProjection, destinationProjection);\n}\n/**\n * Transforms a coordinate from source projection to destination projection.\n * This returns a new coordinate (and does not modify the original).\n *\n * See {@link module:ol/proj.transformExtent} for extent transformation.\n * See the transform method of {@link module:ol/geom/Geometry~Geometry} and its\n * subclasses for geometry transforms.\n *\n * @param {import(\"./coordinate.js\").Coordinate} coordinate Coordinate.\n * @param {ProjectionLike} source Source projection-like.\n * @param {ProjectionLike} destination Destination projection-like.\n * @return {import(\"./coordinate.js\").Coordinate} Coordinate.\n * @api\n */\nexport function transform(coordinate, source, destination) {\n    var transformFunc = getTransform(source, destination);\n    return transformFunc(coordinate, undefined, coordinate.length);\n}\n/**\n * Transforms an extent from source projection to destination projection.  This\n * returns a new extent (and does not modify the original).\n *\n * @param {import(\"./extent.js\").Extent} extent The extent to transform.\n * @param {ProjectionLike} source Source projection-like.\n * @param {ProjectionLike} destination Destination projection-like.\n * @param {number} [opt_stops] Number of stops per side used for the transform.\n * By default only the corners are used.\n * @return {import(\"./extent.js\").Extent} The transformed extent.\n * @api\n */\nexport function transformExtent(extent, source, destination, opt_stops) {\n    var transformFunc = getTransform(source, destination);\n    return applyTransform(extent, transformFunc, undefined, opt_stops);\n}\n/**\n * Transforms the given point to the destination projection.\n *\n * @param {import(\"./coordinate.js\").Coordinate} point Point.\n * @param {Projection} sourceProjection Source projection.\n * @param {Projection} destinationProjection Destination projection.\n * @return {import(\"./coordinate.js\").Coordinate} Point.\n */\nexport function transformWithProjections(point, sourceProjection, destinationProjection) {\n    var transformFunc = getTransformFromProjections(sourceProjection, destinationProjection);\n    return transformFunc(point);\n}\n/**\n * @type {?Projection}\n */\nvar userProjection = null;\n/**\n * Set the projection for coordinates supplied from and returned by API methods.\n * Note that this method is not yet a part of the stable API.  Support for user\n * projections is not yet complete and should be considered experimental.\n * @param {ProjectionLike} projection The user projection.\n */\nexport function setUserProjection(projection) {\n    userProjection = get(projection);\n}\n/**\n * Clear the user projection if set.  Note that this method is not yet a part of\n * the stable API.  Support for user projections is not yet complete and should\n * be considered experimental.\n */\nexport function clearUserProjection() {\n    userProjection = null;\n}\n/**\n * Get the projection for coordinates supplied from and returned by API methods.\n * Note that this method is not yet a part of the stable API.  Support for user\n * projections is not yet complete and should be considered experimental.\n * @return {?Projection} The user projection (or null if not set).\n */\nexport function getUserProjection() {\n    return userProjection;\n}\n/**\n * Use geographic coordinates (WGS-84 datum) in API methods.  Note that this\n * method is not yet a part of the stable API.  Support for user projections is\n * not yet complete and should be considered experimental.\n */\nexport function useGeographic() {\n    setUserProjection('EPSG:4326');\n}\n/**\n * Return a coordinate transformed into the user projection.  If no user projection\n * is set, the original coordinate is returned.\n * @param {Array<number>} coordinate Input coordinate.\n * @param {ProjectionLike} sourceProjection The input coordinate projection.\n * @return {Array<number>} The input coordinate in the user projection.\n */\nexport function toUserCoordinate(coordinate, sourceProjection) {\n    if (!userProjection) {\n        return coordinate;\n    }\n    return transform(coordinate, sourceProjection, userProjection);\n}\n/**\n * Return a coordinate transformed from the user projection.  If no user projection\n * is set, the original coordinate is returned.\n * @param {Array<number>} coordinate Input coordinate.\n * @param {ProjectionLike} destProjection The destination projection.\n * @return {Array<number>} The input coordinate transformed.\n */\nexport function fromUserCoordinate(coordinate, destProjection) {\n    if (!userProjection) {\n        return coordinate;\n    }\n    return transform(coordinate, userProjection, destProjection);\n}\n/**\n * Return an extent transformed into the user projection.  If no user projection\n * is set, the original extent is returned.\n * @param {import(\"./extent.js\").Extent} extent Input extent.\n * @param {ProjectionLike} sourceProjection The input extent projection.\n * @return {import(\"./extent.js\").Extent} The input extent in the user projection.\n */\nexport function toUserExtent(extent, sourceProjection) {\n    if (!userProjection) {\n        return extent;\n    }\n    return transformExtent(extent, sourceProjection, userProjection);\n}\n/**\n * Return an extent transformed from the user projection.  If no user projection\n * is set, the original extent is returned.\n * @param {import(\"./extent.js\").Extent} extent Input extent.\n * @param {ProjectionLike} destProjection The destination projection.\n * @return {import(\"./extent.js\").Extent} The input extent transformed.\n */\nexport function fromUserExtent(extent, destProjection) {\n    if (!userProjection) {\n        return extent;\n    }\n    return transformExtent(extent, userProjection, destProjection);\n}\n/**\n * Return the resolution in user projection units per pixel. If no user projection\n * is set, or source or user projection are missing units, the original resolution\n * is returned.\n * @param {number} resolution Resolution in input projection units per pixel.\n * @param {ProjectionLike} sourceProjection The input projection.\n * @return {number} Resolution in user projection units per pixel.\n */\nexport function toUserResolution(resolution, sourceProjection) {\n    if (!userProjection) {\n        return resolution;\n    }\n    var sourceUnits = get(sourceProjection).getUnits();\n    var userUnits = userProjection.getUnits();\n    return sourceUnits && userUnits\n        ? (resolution * METERS_PER_UNIT[sourceUnits]) / METERS_PER_UNIT[userUnits]\n        : resolution;\n}\n/**\n * Return the resolution in user projection units per pixel. If no user projection\n * is set, or source or user projection are missing units, the original resolution\n * is returned.\n * @param {number} resolution Resolution in user projection units per pixel.\n * @param {ProjectionLike} destProjection The destination projection.\n * @return {number} Resolution in destination projection units per pixel.\n */\nexport function fromUserResolution(resolution, destProjection) {\n    if (!userProjection) {\n        return resolution;\n    }\n    var sourceUnits = get(destProjection).getUnits();\n    var userUnits = userProjection.getUnits();\n    return sourceUnits && userUnits\n        ? (resolution * METERS_PER_UNIT[userUnits]) / METERS_PER_UNIT[sourceUnits]\n        : resolution;\n}\n/**\n * Creates a safe coordinate transform function from a coordinate transform function.\n * \"Safe\" means that it can handle wrapping of x-coordinates for global projections,\n * and that coordinates exceeding the source projection validity extent's range will be\n * clamped to the validity range.\n * @param {Projection} sourceProj Source projection.\n * @param {Projection} destProj Destination projection.\n * @param {function(import(\"./coordinate.js\").Coordinate): import(\"./coordinate.js\").Coordinate} transform Transform function (source to destiation).\n * @return {function(import(\"./coordinate.js\").Coordinate): import(\"./coordinate.js\").Coordinate} Safe transform function (source to destiation).\n */\nexport function createSafeCoordinateTransform(sourceProj, destProj, transform) {\n    return function (coord) {\n        var sourceX = coord[0];\n        var sourceY = coord[1];\n        var transformed, worldsAway;\n        if (sourceProj.canWrapX()) {\n            var sourceExtent = sourceProj.getExtent();\n            var sourceExtentWidth = getWidth(sourceExtent);\n            worldsAway = getWorldsAway(coord, sourceProj, sourceExtentWidth);\n            if (worldsAway) {\n                // Move x to the real world\n                sourceX = sourceX - worldsAway * sourceExtentWidth;\n            }\n            sourceX = clamp(sourceX, sourceExtent[0], sourceExtent[2]);\n            sourceY = clamp(sourceY, sourceExtent[1], sourceExtent[3]);\n            transformed = transform([sourceX, sourceY]);\n        }\n        else {\n            transformed = transform(coord);\n        }\n        if (worldsAway && destProj.canWrapX()) {\n            // Move transformed coordinate back to the offset world\n            transformed[0] += worldsAway * getWidth(destProj.getExtent());\n        }\n        return transformed;\n    };\n}\n/**\n * Add transforms to and from EPSG:4326 and EPSG:3857.  This function is called\n * by when this module is executed and should only need to be called again after\n * `clearAllProjections()` is called (e.g. in tests).\n */\nexport function addCommon() {\n    // Add transformations that don't alter coordinates to convert within set of\n    // projections with equal meaning.\n    addEquivalentProjections(EPSG3857_PROJECTIONS);\n    addEquivalentProjections(EPSG4326_PROJECTIONS);\n    // Add transformations to convert EPSG:4326 like coordinates to EPSG:3857 like\n    // coordinates and back.\n    addEquivalentTransforms(EPSG4326_PROJECTIONS, EPSG3857_PROJECTIONS, fromEPSG4326, toEPSG4326);\n}\naddCommon();\n//# sourceMappingURL=proj.js.map","/**\n * @module ol/proj/Units\n */\n/**\n * Projection units: `'degrees'`, `'ft'`, `'m'`, `'pixels'`, `'tile-pixels'` or\n * `'us-ft'`.\n * @enum {string}\n */\nvar Units = {\n    /**\n     * Radians\n     * @api\n     */\n    RADIANS: 'radians',\n    /**\n     * Degrees\n     * @api\n     */\n    DEGREES: 'degrees',\n    /**\n     * Feet\n     * @api\n     */\n    FEET: 'ft',\n    /**\n     * Meters\n     * @api\n     */\n    METERS: 'm',\n    /**\n     * Pixels\n     * @api\n     */\n    PIXELS: 'pixels',\n    /**\n     * Tile Pixels\n     * @api\n     */\n    TILE_PIXELS: 'tile-pixels',\n    /**\n     * US Feet\n     * @api\n     */\n    USFEET: 'us-ft',\n};\n/**\n * See http://duff.ess.washington.edu/data/raster/drg/docs/geotiff.txt\n * @type {Object<number, Units>}\n */\nvar unitByCode = {\n    '9001': Units.METERS,\n    '9002': Units.FEET,\n    '9003': Units.USFEET,\n    '9101': Units.RADIANS,\n    '9102': Units.DEGREES,\n};\n/**\n * @param {number} code Unit code.\n * @return {Units} Units.\n */\nexport function fromCode(code) {\n    return unitByCode[code];\n}\n/**\n * Meters per unit lookup table.\n * @const\n * @type {Object<Units, number>}\n * @api\n */\nexport var METERS_PER_UNIT = {};\n// use the radius of the Normal sphere\nMETERS_PER_UNIT[Units.RADIANS] = 6370997 / (2 * Math.PI);\nMETERS_PER_UNIT[Units.DEGREES] = (2 * Math.PI * 6370997) / 360;\nMETERS_PER_UNIT[Units.FEET] = 0.3048;\nMETERS_PER_UNIT[Units.METERS] = 1;\nMETERS_PER_UNIT[Units.USFEET] = 1200 / 3937;\nexport default Units;\n//# sourceMappingURL=Units.js.map","/**\n * @module ol/transform\n */\nimport { WORKER_OFFSCREEN_CANVAS } from './has.js';\nimport { assert } from './asserts.js';\n/**\n * An array representing an affine 2d transformation for use with\n * {@link module:ol/transform} functions. The array has 6 elements.\n * @typedef {!Array<number>} Transform\n * @api\n */\n/**\n * Collection of affine 2d transformation functions. The functions work on an\n * array of 6 elements. The element order is compatible with the [SVGMatrix\n * interface](https://developer.mozilla.org/en-US/docs/Web/API/SVGMatrix) and is\n * a subset (elements a to f) of a 3×3 matrix:\n * ```\n * [ a c e ]\n * [ b d f ]\n * [ 0 0 1 ]\n * ```\n */\n/**\n * @private\n * @type {Transform}\n */\nvar tmp_ = new Array(6);\n/**\n * Create an identity transform.\n * @return {!Transform} Identity transform.\n */\nexport function create() {\n    return [1, 0, 0, 1, 0, 0];\n}\n/**\n * Resets the given transform to an identity transform.\n * @param {!Transform} transform Transform.\n * @return {!Transform} Transform.\n */\nexport function reset(transform) {\n    return set(transform, 1, 0, 0, 1, 0, 0);\n}\n/**\n * Multiply the underlying matrices of two transforms and return the result in\n * the first transform.\n * @param {!Transform} transform1 Transform parameters of matrix 1.\n * @param {!Transform} transform2 Transform parameters of matrix 2.\n * @return {!Transform} transform1 multiplied with transform2.\n */\nexport function multiply(transform1, transform2) {\n    var a1 = transform1[0];\n    var b1 = transform1[1];\n    var c1 = transform1[2];\n    var d1 = transform1[3];\n    var e1 = transform1[4];\n    var f1 = transform1[5];\n    var a2 = transform2[0];\n    var b2 = transform2[1];\n    var c2 = transform2[2];\n    var d2 = transform2[3];\n    var e2 = transform2[4];\n    var f2 = transform2[5];\n    transform1[0] = a1 * a2 + c1 * b2;\n    transform1[1] = b1 * a2 + d1 * b2;\n    transform1[2] = a1 * c2 + c1 * d2;\n    transform1[3] = b1 * c2 + d1 * d2;\n    transform1[4] = a1 * e2 + c1 * f2 + e1;\n    transform1[5] = b1 * e2 + d1 * f2 + f1;\n    return transform1;\n}\n/**\n * Set the transform components a-f on a given transform.\n * @param {!Transform} transform Transform.\n * @param {number} a The a component of the transform.\n * @param {number} b The b component of the transform.\n * @param {number} c The c component of the transform.\n * @param {number} d The d component of the transform.\n * @param {number} e The e component of the transform.\n * @param {number} f The f component of the transform.\n * @return {!Transform} Matrix with transform applied.\n */\nexport function set(transform, a, b, c, d, e, f) {\n    transform[0] = a;\n    transform[1] = b;\n    transform[2] = c;\n    transform[3] = d;\n    transform[4] = e;\n    transform[5] = f;\n    return transform;\n}\n/**\n * Set transform on one matrix from another matrix.\n * @param {!Transform} transform1 Matrix to set transform to.\n * @param {!Transform} transform2 Matrix to set transform from.\n * @return {!Transform} transform1 with transform from transform2 applied.\n */\nexport function setFromArray(transform1, transform2) {\n    transform1[0] = transform2[0];\n    transform1[1] = transform2[1];\n    transform1[2] = transform2[2];\n    transform1[3] = transform2[3];\n    transform1[4] = transform2[4];\n    transform1[5] = transform2[5];\n    return transform1;\n}\n/**\n * Transforms the given coordinate with the given transform returning the\n * resulting, transformed coordinate. The coordinate will be modified in-place.\n *\n * @param {Transform} transform The transformation.\n * @param {import(\"./coordinate.js\").Coordinate|import(\"./pixel.js\").Pixel} coordinate The coordinate to transform.\n * @return {import(\"./coordinate.js\").Coordinate|import(\"./pixel.js\").Pixel} return coordinate so that operations can be\n *     chained together.\n */\nexport function apply(transform, coordinate) {\n    var x = coordinate[0];\n    var y = coordinate[1];\n    coordinate[0] = transform[0] * x + transform[2] * y + transform[4];\n    coordinate[1] = transform[1] * x + transform[3] * y + transform[5];\n    return coordinate;\n}\n/**\n * Applies rotation to the given transform.\n * @param {!Transform} transform Transform.\n * @param {number} angle Angle in radians.\n * @return {!Transform} The rotated transform.\n */\nexport function rotate(transform, angle) {\n    var cos = Math.cos(angle);\n    var sin = Math.sin(angle);\n    return multiply(transform, set(tmp_, cos, sin, -sin, cos, 0, 0));\n}\n/**\n * Applies scale to a given transform.\n * @param {!Transform} transform Transform.\n * @param {number} x Scale factor x.\n * @param {number} y Scale factor y.\n * @return {!Transform} The scaled transform.\n */\nexport function scale(transform, x, y) {\n    return multiply(transform, set(tmp_, x, 0, 0, y, 0, 0));\n}\n/**\n * Creates a scale transform.\n * @param {!Transform} target Transform to overwrite.\n * @param {number} x Scale factor x.\n * @param {number} y Scale factor y.\n * @return {!Transform} The scale transform.\n */\nexport function makeScale(target, x, y) {\n    return set(target, x, 0, 0, y, 0, 0);\n}\n/**\n * Applies translation to the given transform.\n * @param {!Transform} transform Transform.\n * @param {number} dx Translation x.\n * @param {number} dy Translation y.\n * @return {!Transform} The translated transform.\n */\nexport function translate(transform, dx, dy) {\n    return multiply(transform, set(tmp_, 1, 0, 0, 1, dx, dy));\n}\n/**\n * Creates a composite transform given an initial translation, scale, rotation, and\n * final translation (in that order only, not commutative).\n * @param {!Transform} transform The transform (will be modified in place).\n * @param {number} dx1 Initial translation x.\n * @param {number} dy1 Initial translation y.\n * @param {number} sx Scale factor x.\n * @param {number} sy Scale factor y.\n * @param {number} angle Rotation (in counter-clockwise radians).\n * @param {number} dx2 Final translation x.\n * @param {number} dy2 Final translation y.\n * @return {!Transform} The composite transform.\n */\nexport function compose(transform, dx1, dy1, sx, sy, angle, dx2, dy2) {\n    var sin = Math.sin(angle);\n    var cos = Math.cos(angle);\n    transform[0] = sx * cos;\n    transform[1] = sy * sin;\n    transform[2] = -sx * sin;\n    transform[3] = sy * cos;\n    transform[4] = dx2 * sx * cos - dy2 * sx * sin + dx1;\n    transform[5] = dx2 * sy * sin + dy2 * sy * cos + dy1;\n    return transform;\n}\n/**\n * Creates a composite transform given an initial translation, scale, rotation, and\n * final translation (in that order only, not commutative). The resulting transform\n * string can be applied as `transform` property of an HTMLElement's style.\n * @param {number} dx1 Initial translation x.\n * @param {number} dy1 Initial translation y.\n * @param {number} sx Scale factor x.\n * @param {number} sy Scale factor y.\n * @param {number} angle Rotation (in counter-clockwise radians).\n * @param {number} dx2 Final translation x.\n * @param {number} dy2 Final translation y.\n * @return {string} The composite css transform.\n * @api\n */\nexport function composeCssTransform(dx1, dy1, sx, sy, angle, dx2, dy2) {\n    return toString(compose(create(), dx1, dy1, sx, sy, angle, dx2, dy2));\n}\n/**\n * Invert the given transform.\n * @param {!Transform} source The source transform to invert.\n * @return {!Transform} The inverted (source) transform.\n */\nexport function invert(source) {\n    return makeInverse(source, source);\n}\n/**\n * Invert the given transform.\n * @param {!Transform} target Transform to be set as the inverse of\n *     the source transform.\n * @param {!Transform} source The source transform to invert.\n * @return {!Transform} The inverted (target) transform.\n */\nexport function makeInverse(target, source) {\n    var det = determinant(source);\n    assert(det !== 0, 32); // Transformation matrix cannot be inverted\n    var a = source[0];\n    var b = source[1];\n    var c = source[2];\n    var d = source[3];\n    var e = source[4];\n    var f = source[5];\n    target[0] = d / det;\n    target[1] = -b / det;\n    target[2] = -c / det;\n    target[3] = a / det;\n    target[4] = (c * f - d * e) / det;\n    target[5] = -(a * f - b * e) / det;\n    return target;\n}\n/**\n * Returns the determinant of the given matrix.\n * @param {!Transform} mat Matrix.\n * @return {number} Determinant.\n */\nexport function determinant(mat) {\n    return mat[0] * mat[3] - mat[1] * mat[2];\n}\n/**\n * @type {HTMLElement}\n * @private\n */\nvar transformStringDiv;\n/**\n * A rounded string version of the transform.  This can be used\n * for CSS transforms.\n * @param {!Transform} mat Matrix.\n * @return {string} The transform as a string.\n */\nexport function toString(mat) {\n    var transformString = 'matrix(' + mat.join(', ') + ')';\n    if (WORKER_OFFSCREEN_CANVAS) {\n        return transformString;\n    }\n    var node = transformStringDiv || (transformStringDiv = document.createElement('div'));\n    node.style.transform = transformString;\n    return node.style.transform;\n}\n//# sourceMappingURL=transform.js.map","/**\n * @module ol/util\n */\n/**\n * @return {?} Any return.\n */\nexport function abstract() {\n    return /** @type {?} */ ((function () {\n        throw new Error('Unimplemented abstract method.');\n    })());\n}\n/**\n * Counter for getUid.\n * @type {number}\n * @private\n */\nvar uidCounter_ = 0;\n/**\n * Gets a unique ID for an object. This mutates the object so that further calls\n * with the same object as a parameter returns the same value. Unique IDs are generated\n * as a strictly increasing sequence. Adapted from goog.getUid.\n *\n * @param {Object} obj The object to get the unique ID for.\n * @return {string} The unique ID for the object.\n * @api\n */\nexport function getUid(obj) {\n    return obj.ol_uid || (obj.ol_uid = String(++uidCounter_));\n}\n/**\n * OpenLayers version.\n * @type {string}\n */\nexport var VERSION = '6.9.0';\n//# sourceMappingURL=util.js.map"],"names":["COMPLETE_NOTIFICATION","createNotification","undefined","kind","value","error","Subscriber","_super","destination","_this","call","this","isStopped","add","EMPTY_OBSERVER","create","next","complete","SafeSubscriber","prototype","handleStoppedNotification","nextNotification","_next","err","_error","_complete","unsubscribe","closed","Subscription","observerOrNext","isFunction","context_1","config","Object","bind","wrapForErrorHandling","noop","defaultErrorHandler","handler","instance","args","_i","arguments","length","apply","reportUnhandledError","notification","subscriber","onStoppedNotification","timeoutProvider","UnsubscriptionError","errors","message","map","i","toString","join","name","initialTeardown","_parentage","_teardowns","empty","e_1","_a","e_2","_b","Array","isArray","_parentage_1","_parentage_1_1","done","remove","e_1_1","return","e","_teardowns_1","_teardowns_1_1","teardown_1","execTeardown","push","e_2_1","teardown","_hasParent","_addParent","parent","includes","_removeParent","arrRemove","EMPTY","EMPTY_SUBSCRIPTION","isSubscription","onUnhandledError","Promise","useDeprecatedSynchronousErrorHandling","useDeprecatedNextContext","OperatorSubscriber","onNext","onComplete","onError","onFinalize","filter","predicate","thisArg","source","index","subscribe","project","setTimeout","delegate","clearTimeout","handle","arr","item","indexOf","splice","createErrorClass","createImpl","ctorFunc","Error","stack","constructor","context","errorContext","cb","isRoot","errorThrown","captureError","operate","init","lift","hasLift","liftedSource","TypeError","extendStatics","d","b","setPrototypeOf","__proto__","p","hasOwnProperty","__extends","String","__","__awaiter","_arguments","P","generator","resolve","reject","fulfilled","step","rejected","result","then","__generator","body","f","y","t","g","_","label","sent","trys","ops","verb","Symbol","iterator","n","v","op","pop","__values","o","s","m","__read","r","ar","__spreadArray","to","from","il","j","__await","__asyncGenerator","asyncIterator","q","a","resume","fulfill","settle","shift","__asyncValues","has","table","WeakMap","counter","Cache","initialData","cache","Map","entries","subs","get","key","_key","serializeKey","set","notify","keys","clear","delete","_hash","hash","listener","isSubscribed","online","isOnline","isDocumentVisible","document","visibilityState","fetcher","url","fetch","res","json","registerOnFocus","window","addEventListener","registerOnReconnect","__assign","assign","slowConnection","navigator","effectiveType","onLoadingSlow","onSuccess","onErrorRetry","revalidate","opts","errorRetryCount","retryCount","count","Math","min","timeout","random","errorRetryInterval","focusThrottleInterval","dedupingInterval","loadingTimeout","refreshInterval","revalidateOnFocus","revalidateOnReconnect","refreshWhenHidden","refreshWhenOffline","shouldRetryOnError","suspense","compare","dequal","foo","bar","ctor","len","Date","getTime","RegExp","isPaused","IS_SERVER","Deno","version","deno","rAF","useEffect","useLayoutEffect","createContext","displayName","ts","CONCURRENT_PROMISES","CONCURRENT_PROMISES_TS","FOCUS_REVALIDATORS","RECONNECT_REVALIDATORS","CACHE_REVALIDATORS","MUTATION_TS","MUTATION_END_TS","now","revalidate_1","revalidators","trigger","shouldRevalidate","keyErr","keyValidating","updaters","currentData","currentError","currentIsValidating","promises","all","broadcastState","data","isValidating","mutate","_data","beforeMutationTs","beforeConcurrentPromisesTs","isAsyncMutation","err_1","shouldAbort","defineProperty","SWRConfig","useContext","fn","fnArgs","configRef","useRef","current","willRevalidateOnMount","revalidateOnMount","resolveData","cachedData","resolveIsValidating","initialError","initialIsValidating","stateDependencies","stateRef","useDebugValue","latestData","latestError","rerender","useState","dispatch","useCallback","payload","shouldUpdateState","k","unmountedRef","initialMountedRef","keyRef","eventsCallback","event","params","boundMutate","addRevalidator","callback","keyedRevalidators","revalidateOpts","dedupe","loading","shouldDeduping","newData","startAt","newState","err_2","_c","isUpdating","currentHookData","latestKeyedData","softRevalidate","pending","unsubFocus","unsubReconnect","unsubUpdate","updatedData","updatedError","updatedIsValidating","needUpdate","timer","tick","memoizedState","useMemo","state","defineProperties","enumerable","AssertionError","code","Disposable","disposed","dispose","disposeInternal","Feature","opt_geometryOrProperties","on","once","un","id_","geometryName_","style_","styleFunction_","geometryChangeKey_","addChangeListener","handleGeometryChanged_","geometry","setGeometry","properties","setProperties","clone","hasProperties","getProperties","setGeometryName","getGeometryName","getGeometry","style","getStyle","setStyle","getId","getStyleFunction","handleGeometryChange_","changed","opt_style","obj","styles_1","createStyleFunction","setId","id","removeChangeListener","ObjectEvent","type","oldValue","BaseObject","opt_values","values_","getKeys","eventType","dispatchEvent","removeEventListener","opt_silent","values","applyProperties","unset","PROPERTYCHANGE","Observable","revision_","getRevision","onInternal","onceInternal","ol_key","unInternal","ii","unByKey","binarySearch","haystack","needle","opt_comparator","mid","cmp","comparator","numberSafeCompareFunction","low","high","found","linearFindNearest","target","direction","reverseSubArray","begin","end","tmp","extend","extension","equals","arr1","arr2","len1","isSorted","opt_func","opt_strict","every","currentVal","assert","assertion","errorCode","listen","opt_this","opt_once","originalListener_1","eventsKey","listenOnce","unlistenByKey","BaseEvent","propagationStopped","defaultPrevented","preventDefault","stopPropagation","evt","CHANGE","ERROR","BLUR","CLEAR","CONTEXTMENU","CLICK","DBLCLICK","DRAGENTER","DRAGOVER","DROP","FOCUS","KEYDOWN","KEYPRESS","LOAD","RESIZE","TOUCHMOVE","WHEEL","Target","opt_target","eventTarget_","pendingRemovals_","dispatching_","listeners_","listeners","listenersForType","propagate","dispatching","pendingRemovals","handleEvent","pr","getListeners","hasListener","opt_type","boundingExtent","coordinates","extent","createEmpty","extendCoordinate","buffer","opt_extent","slice","closestSquaredDistanceXY","x","dx","dy","containsCoordinate","coordinate","containsXY","containsExtent","extent1","extent2","coordinateRelationship","minX","minY","maxX","maxY","relationship","Infinity","createOrUpdate","createOrUpdateEmpty","createOrUpdateFromCoordinate","createOrUpdateFromFlatCoordinates","flatCoordinates","offset","stride","extendFlatCoordinates","extendXY","max","forEachCorner","val","getBottomLeft","getBottomRight","getTopRight","getTopLeft","getArea","area","isEmpty","getWidth","getHeight","getCenter","getCorner","corner","getForViewAndSize","center","resolution","rotation","size","cosRotation","cos","sinRotation","sin","xCos","xSin","yCos","ySin","x0","x1","x2","x3","y0","y1","y2","y3","getIntersection","intersection","intersects","returnOrUpdate","intersectsSegment","start","startRel","endRel","startX","startY","endX","endY","slope","applyTransform","transformFn","opt_stops","width","height","xs","ys","l","_boundingExtentXYs","wrapX","projection","projectionExtent","getExtent","canWrapX","worldWidth","floor","BOTTOM_LEFT","BOTTOM_RIGHT","TOP_LEFT","TOP_RIGHT","UNKNOWN","INTERSECTING","ABOVE","RIGHT","BELOW","LEFT","ARRAY_BUFFER","JSON","TEXT","XML","cloneGeometries","geometries","clonedGeometries","GeometryCollection","opt_geometries","geometries_","changeEventsKeys_","listenGeometriesChange_","unlistenGeometriesChange_","forEach","EventType","geometryCollection","setGeometries","closestPointXY","closestPoint","minSquaredDistance","computeExtent","getGeometries","getGeometriesArray","getGeometriesArrayRecursive","geometriesArray","getType","concat","getSimplifiedGeometry","squaredTolerance","simplifiedGeometryRevision","simplifiedGeometryMaxMinSquaredTolerance","simplifiedGeometries","simplified","simplifiedGeometry","simplifiedGeometryCollection","setGeometriesArray","GeometryType","intersectsExtent","rotate","angle","anchor","scale","sx","opt_sy","opt_anchor","translate","deltaX","deltaY","Geometry","FeatureFormat","dataProjection","defaultFeatureProjection","supportedMediaTypes","getReadOptions","opt_options","options","readProjection","getUnits","Units","setWorldExtent","featureProjection","adaptOptions","readFeature","readFeatures","readGeometry","writeFeature","feature","writeFeatures","features","writeGeometry","transformGeometryWithOptions","write","transformed","transform","decimals","power_1","pow","round","getObject","object","parse","JSONFeature","FormatType","readFeatureFromObject","readFeaturesFromObject","readGeometryFromObject","readProjectionFromObject","stringify","writeFeatureObject","writeFeaturesObject","writeGeometryObject","interpolatePoint","fraction","opt_dest","opt_dimension","length_1","cumulativeLengths","sqrt","dimension","dest","NaN","lineStringCoordinateAtM","extrapolate","lo","hi","m0","LineString","opt_layout","flatMidpoint_","flatMidpointRevision_","maxDelta_","maxDeltaRevision_","setCoordinates","setFlatCoordinates","appendCoordinate","lineString","layout","forEachSegment","getCoordinateAtM","opt_extrapolate","GeometryLayout","getCoordinates","inflate","getCoordinateAt","getLength","getFlatMidpoint","getSimplifiedGeometryInternal","simplifiedFlatCoordinates","setLayout","deflate","SimpleGeometry","MultiLineString","opt_ends","ends_","getLayout","lineStrings","ends","getFlatCoordinates","appendLineString","multiLineString","opt_interpolate","interpolate","lineStringsCoordinateAtM","getEnds","getLineString","getLineStrings","getFlatMidpoints","midpoints","midpoint","simplifiedEnds","MultiPoint","appendPoint","point","multiPoint","squaredDistance","getPoint","Point","getPoints","points","MultiPolygon","opt_endss","endss_","flatInteriorPointsRevision_","flatInteriorPoints_","orientedRevision_","orientedFlatCoordinates_","polygons","endss","polygon","jj","appendPolygon","newEndss","multiPolygon","getOrientedFlatCoordinates","opt_right","orient","getEndss","getFlatInteriorPoints","flatCenters","linearRingss","getInteriorPoints","simplifiedEndss","getPolygon","prevEnds","Polygon","getPolygons","lastEnds","readPointGeometry","readLineStringGeometry","readPolygonGeometry","readMultiPointGeometry","readMultiLineStringGeometry","readMultiPolygonGeometry","readGeometryCollectionGeometry","geoJSON","writePointGeometry","writeLineStringGeometry","right","rightHanded","writePolygonGeometry","writeMultiPointGeometry","writeMultiLineStringGeometry","writeMultiPolygonGeometry","writeGeometryCollectionGeometry","GeoJSON","geometryName","extractGeometryName_","extractGeometryName","geoJSONFeature","geoJSONFeatures","crs","objects","TRUE","FALSE","VOID","memoizeOne","lastResult","lastArgs","lastThis","called","nextArgs","tmpTransform","extent_","extentRevision_","simplifyTransformedInternal","revision","opt_transform","simplifyTransformed","coord","getClosestPoint","opt_closestPoint","intersectsCoordinate","isNaN","simplify","tolerance","sourceProj","inCoordinates","outCoordinates","pixelExtent","projectedExtent","getWorldExtent","XY","XYZ","XYM","XYZM","POINT","LINE_STRING","LINEAR_RING","POLYGON","MULTI_POINT","MULTI_LINE_STRING","MULTI_POLYGON","GEOMETRY_COLLECTION","CIRCLE","LinearRing","flatInteriorPointRevision_","flatInteriorPoint_","appendLinearRing","linearRing","getFlatInteriorPoint","flatCenter","getInteriorPoint","getLinearRingCount","getLinearRing","getLinearRings","linearRings","fromExtent","fromCircle","circle","opt_sides","opt_angle","sides","getStride","arrayLength","radius","startAngle","PI","makeRegular","getRadius","getFirstCoordinate","getLastCoordinate","getStrideForLayout","nesting","getLayoutForStride","sy","transformGeom2D","simpleGeometry","twiceArea","assignClosest","offset1","offset2","maxSquaredDelta","squaredDelta","arrayMaxSquaredDelta","multiArrayMaxSquaredDelta","assignClosestPoint","maxDelta","isRing","opt_tmpPoint","tmpPoint","assignClosestArrayPoint","assignClosestMultiArrayPoint","linearRingContainsExtent","linearRingContainsXY","wn","linearRingsContainsXY","linearRingssContainsXY","deflateCoordinate","deflateCoordinates","deflateCoordinatesArray","coordinatess","deflateMultiCoordinatesArray","coordinatesss","inflateCoordinates","opt_coordinates","inflateCoordinatesArray","opt_coordinatess","inflateMultiCoordinatesArray","opt_coordinatesss","getInteriorPointOfArray","flatCentersOffset","intersections","rr","pointX","maxSegmentLength","sort","segmentLength","abs","getInteriorPointsOfMultiArray","interiorPoints","intersectsLineString","coordinatesExtent","point1","point2","intersectsLineStringArray","intersectsLinearRingArray","intersectsLinearRing","intersectsLinearRingMultiArray","lineStringLength","linearRingIsClockwise","edge","linearRingsAreOriented","isClockwise","linearRingssAreOriented","orientLinearRings","orientLinearRingsArray","ret","douglasPeucker","simplifiedOffset","markers","last","first","maxSquaredDistance","squaredDistance_1","douglasPeuckerArray","snap","quantize","dx1","dy1","dx2","dy2","quantizeArray","quantizeMultiArray","transform2D","anchorX","anchorY","ua","userAgent","toLowerCase","FIREFOX","WEBKIT","MAC","DEVICE_PIXEL_RATIO","devicePixelRatio","WORKER_OFFSCREEN_CANVAS","WorkerGlobalScope","OffscreenCanvas","self","IMAGE_DECODE","Image","decode","PASSIVE_EVENT_LISTENERS","passive","clamp","cosh","exp","log2","log","LOG2E","squaredSegmentDistance","solveLinearSystem","mat","maxRow","maxEl","absValue","coef","toRadians","angleInDegrees","modulo","lerp","var_sources","output","property","getValues","Projection","code_","units_","worldExtent_","worldExtent","axisOrientation_","axisOrientation","global_","global","canWrapX_","getPointResolutionFunc_","getPointResolution","defaultTileGrid_","metersPerUnit_","metersPerUnit","getCode","getMetersPerUnit","getAxisOrientation","isGlobal","setGlobal","getDefaultTileGrid","setDefaultTileGrid","tileGrid","setExtent","setGetPointResolution","func","getPointResolutionFunc","RADIUS","HALF_SIZE","EXTENT","WORLD_EXTENT","MAX_SAFE_Y","tan","EPSG3857Projection","units","PROJECTIONS","fromEPSG4326","input","opt_output","toEPSG4326","atan","EPSG4326Projection","opt_axisOrientation","transforms","sourceCode","destinationCode","DEFAULT_RADIUS","getDistance","c1","c2","opt_radius","lat1","lat2","deltaLatBy2","deltaLonBy2","atan2","cloneTransform","identityTransform","addProjection","projectionLike","replace","opt_units","pointResolution","getter","toEPSG4326_1","getTransformFromProjections","vertices","addEquivalentProjections","projections","addProjections","createProjection","defaultCode","fromLonLat","opt_projection","equivalent","projection1","projection2","equalUnits","sourceProjection","destinationProjection","transformFunc","getTransform","transformExtent","projections2","forwardTransform","inverseTransform","userProjection","getUserProjection","toUserCoordinate","fromUserCoordinate","destProjection","toUserExtent","fromUserExtent","toUserResolution","sourceUnits","userUnits","RADIANS","DEGREES","FEET","METERS","PIXELS","TILE_PIXELS","USFEET","METERS_PER_UNIT","transformStringDiv","c","setFromArray","transform1","transform2","makeScale","compose","makeInverse","det","transformString","node","createElement","abstract","uidCounter_","getUid","ol_uid","VERSION"],"sourceRoot":""}