{"mappings":"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","sources":["node_modules/ol/src/events/Event.js","node_modules/ol/src/ObjectEventType.js","node_modules/ol/src/Disposable.js","node_modules/ol/src/array.js","node_modules/ol/src/functions.js","node_modules/ol/src/obj.js","node_modules/ol/src/events/Target.js","node_modules/ol/src/events/EventType.js","node_modules/ol/src/events.js","node_modules/ol/src/Observable.js","node_modules/ol/src/util.js","node_modules/ol/src/Object.js","node_modules/ol/src/MapEventType.js","node_modules/ol/src/has.js","node_modules/ol/src/dom.js","node_modules/ol/src/control/Control.js","node_modules/ol/src/css.js","node_modules/ol/src/layer/Property.js","node_modules/ol/src/AssertionError.js","node_modules/ol/src/asserts.js","node_modules/ol/src/math.js","node_modules/ol/src/layer/Base.js","node_modules/ol/src/render/EventType.js","node_modules/ol/src/source/State.js","node_modules/ol/src/layer/Layer.js","node_modules/ol/src/control/Attribution.js","node_modules/ol/src/CollectionEventType.js","node_modules/ol/src/Collection.js","node_modules/ol/src/easing.js","node_modules/ol/src/control/Rotate.js","node_modules/ol/src/control/Zoom.js","node_modules/ol/src/proj/Units.js","node_modules/ol/src/proj/Projection.js","node_modules/ol/src/proj/epsg3857.js","node_modules/ol/src/proj/epsg4326.js","node_modules/ol/src/proj/projections.js","node_modules/ol/src/proj/transforms.js","node_modules/ol/src/extent/Corner.js","node_modules/ol/src/extent/Relationship.js","node_modules/ol/src/extent.js","node_modules/ol/src/geom/GeometryType.js","node_modules/ol/src/sphere.js","node_modules/ol/src/coordinate.js","node_modules/ol/src/proj.js","node_modules/ol/src/control/ScaleLine.js","node_modules/ol/src/control.js","node_modules/ol/src/Feature.js","node_modules/ol/src/style/IconAnchorUnits.js","node_modules/ol/src/style/IconOrigin.js","node_modules/ol/src/ImageState.js","node_modules/ol/src/size.js","node_modules/ol/src/style/Image.js","node_modules/ol/src/color.js","node_modules/ol/src/style/IconImageCache.js","node_modules/ol/src/ImageBase.js","node_modules/ol/src/Image.js","node_modules/ol/src/style/IconImage.js","node_modules/ol/src/style/Icon.js","node_modules/ol/src/colorlike.js","node_modules/ol/src/transform.js","node_modules/ol/src/render/canvas.js","node_modules/ol/src/style/RegularShape.js","node_modules/ol/src/style/Circle.js","node_modules/ol/src/style/Fill.js","node_modules/ol/src/style/Stroke.js","node_modules/ol/src/style/Style.js","node_modules/ol/src/renderer/Map.js","node_modules/ol/src/render/Event.js","node_modules/ol/src/renderer/Composite.js","node_modules/ol/src/layer/Group.js","node_modules/ol/src/MapEvent.js","node_modules/ol/src/MapBrowserEvent.js","node_modules/ol/src/MapBrowserEventType.js","node_modules/ol/src/pointer/EventType.js","node_modules/ol/src/MapBrowserEventHandler.js","node_modules/ol/src/MapProperty.js","node_modules/ol/src/structs/PriorityQueue.js","node_modules/ol/src/TileState.js","node_modules/ol/src/TileQueue.js","node_modules/ol/src/ViewHint.js","node_modules/ol/src/ViewProperty.js","node_modules/ol/src/centerconstraint.js","node_modules/ol/src/resolutionconstraint.js","node_modules/ol/src/rotationconstraint.js","node_modules/ol/src/geom/GeometryLayout.js","node_modules/ol/src/geom/flat/transform.js","node_modules/ol/src/geom/Geometry.js","node_modules/ol/src/geom/SimpleGeometry.js","node_modules/ol/src/geom/flat/closest.js","node_modules/ol/src/geom/flat/deflate.js","node_modules/ol/src/geom/flat/simplify.js","node_modules/ol/src/geom/flat/inflate.js","node_modules/ol/src/geom/flat/area.js","node_modules/ol/src/geom/LinearRing.js","node_modules/ol/src/geom/Point.js","node_modules/ol/src/geom/flat/contains.js","node_modules/ol/src/geom/flat/interiorpoint.js","node_modules/ol/src/geom/flat/intersectsextent.js","node_modules/ol/src/geom/flat/segments.js","node_modules/ol/src/geom/flat/reverse.js","node_modules/ol/src/geom/flat/orient.js","node_modules/ol/src/geom/Polygon.js","node_modules/ol/src/View.js","node_modules/ol/src/tilegrid/common.js","node_modules/ol/src/PluggableMap.js","node_modules/ol/src/interaction/Property.js","node_modules/ol/src/interaction/Interaction.js","node_modules/ol/src/interaction/DoubleClickZoom.js","node_modules/ol/src/interaction/Pointer.js","node_modules/ol/src/events/condition.js","node_modules/ol/src/interaction/DragPan.js","node_modules/ol/src/interaction/DragRotate.js","node_modules/ol/src/render/Box.js","node_modules/ol/src/interaction/DragBox.js","node_modules/ol/src/interaction/DragZoom.js","node_modules/ol/src/events/KeyCode.js","node_modules/ol/src/interaction/KeyboardPan.js","node_modules/ol/src/interaction/KeyboardZoom.js","node_modules/ol/src/Kinetic.js","node_modules/ol/src/interaction/MouseWheelZoom.js","node_modules/ol/src/interaction/PinchRotate.js","node_modules/ol/src/interaction/PinchZoom.js","node_modules/ol/src/Map.js","node_modules/ol/src/interaction.js","node_modules/ol/src/OverlayPositioning.js","node_modules/ol/src/Overlay.js","node_modules/ol/src/layer/TileProperty.js","node_modules/ol/src/layer/BaseTile.js","node_modules/ol/src/renderer/Layer.js","node_modules/ol/src/renderer/canvas/Layer.js","node_modules/ol/src/TileRange.js","node_modules/ol/src/renderer/canvas/TileLayer.js","node_modules/ol/src/layer/Tile.js","node_modules/ol/src/source/common.js","node_modules/ol/src/Tile.js","node_modules/ol/src/ImageTile.js","node_modules/ol/src/reproj.js","node_modules/ol/src/reproj/Triangulation.js","node_modules/ol/src/reproj/Tile.js","node_modules/ol/src/reproj/common.js","node_modules/ol/src/structs/LRUCache.js","node_modules/ol/src/tilecoord.js","node_modules/ol/src/TileCache.js","node_modules/ol/src/source/TileEventType.js","node_modules/ol/src/source/Source.js","node_modules/ol/src/tilegrid/TileGrid.js","node_modules/ol/src/tilegrid.js","node_modules/ol/src/source/Tile.js","node_modules/ol/src/tileurlfunction.js","node_modules/ol/src/source/UrlTile.js","node_modules/ol/src/source/TileImage.js","node_modules/ol/src/source/WMSServerType.js","node_modules/ol/src/uri.js","node_modules/ol/src/source/TileWMS.js","node_modules/ol/src/string.js","node_modules/rbush/rbush.min.js","node_modules/ol/src/layer/BaseVector.js","node_modules/ol/src/render/canvas/Instruction.js","node_modules/ol/src/render/VectorContext.js","node_modules/ol/src/render/canvas/Builder.js","node_modules/ol/src/render/canvas/ImageBuilder.js","node_modules/ol/src/render/canvas/LineStringBuilder.js","node_modules/ol/src/render/canvas/PolygonBuilder.js","node_modules/ol/src/style/TextPlacement.js","node_modules/ol/src/geom/flat/straightchunk.js","node_modules/ol/src/render/canvas/TextBuilder.js","node_modules/ol/src/render/canvas/BuilderGroup.js","node_modules/ol/src/render/canvas/BuilderType.js","node_modules/ol/src/geom/flat/textpath.js","node_modules/ol/src/geom/flat/length.js","node_modules/ol/src/render/canvas/Executor.js","node_modules/ol/src/render/canvas/ExecutorGroup.js","node_modules/ol/src/render/canvas/Immediate.js","node_modules/ol/src/renderer/vector.js","node_modules/ol/src/renderer/canvas/VectorLayer.js","node_modules/ol/src/render/canvas/hitdetect.js","node_modules/ol/src/layer/Vector.js","node_modules/ol/src/structs/RBush.js","node_modules/ol/src/source/VectorEventType.js","node_modules/ol/src/loadingstrategy.js","node_modules/ol/src/format/FormatType.js","node_modules/ol/src/featureloader.js","node_modules/ol/src/source/Vector.js","node_modules/ol/src/source/XYZ.js","main.js"],"sourcesContent":["/**\n * @module ol/events/Event\n */\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 */\nclass BaseEvent {\n  /**\n   * @param {string} type Type.\n   */\n  constructor(type) {\n    /**\n     * @type {boolean}\n     */\n    this.propagationStopped;\n\n    /**\n     * The event type.\n     * @type {string}\n     * @api\n     */\n    this.type = type;\n\n    /**\n     * The event target.\n     * @type {Object}\n     * @api\n     */\n    this.target = null;\n  }\n\n  /**\n   * Stop event propagation.\n   * @api\n   */\n  preventDefault() {\n    this.propagationStopped = true;\n  }\n\n  /**\n   * Stop event propagation.\n   * @api\n   */\n  stopPropagation() {\n    this.propagationStopped = true;\n  }\n}\n\n/**\n * @param {Event|import(\"./Event.js\").default} evt Event\n */\nexport function stopPropagation(evt) {\n  evt.stopPropagation();\n}\n\n/**\n * @param {Event|import(\"./Event.js\").default} evt Event\n */\nexport function preventDefault(evt) {\n  evt.preventDefault();\n}\n\nexport default BaseEvent;\n","/**\n * @module ol/ObjectEventType\n */\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 * @module ol/Disposable\n */\n\n/**\n * @classdesc\n * Objects that need to clean up after themselves.\n */\nclass Disposable {\n  constructor() {\n    /**\n     * The object has already been disposed.\n     * @type {boolean}\n     * @protected\n     */\n    this.disposed = false;\n  }\n\n  /**\n   * Clean up.\n   */\n  dispose() {\n    if (!this.disposed) {\n      this.disposed = true;\n      this.disposeInternal();\n    }\n  }\n\n  /**\n   * Extension point for disposable objects.\n   * @protected\n   */\n  disposeInternal() {}\n}\n\nexport default Disposable;\n","/**\n * @module ol/array\n */\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  let mid, cmp;\n  const comparator = opt_comparator || numberSafeCompareFunction;\n  let low = 0;\n  let high = haystack.length;\n  let found = false;\n\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\n    if (cmp < 0.0) {\n      /* Too low. */\n      low = mid + 1;\n    } else {\n      /* Key found or too high */\n      high = mid;\n      found = !cmp;\n    }\n  }\n\n  /* Key not found. */\n  return found ? low : ~low;\n}\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/**\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/**\n * @param {Array<number>} arr Array.\n * @param {number} target Target.\n * @param {number} direction 0 means return the nearest, > 0\n *    means return the largest nearest, < 0 means return the\n *    smallest nearest.\n * @return {number} Index.\n */\nexport function linearFindNearest(arr, target, direction) {\n  const n = arr.length;\n  if (arr[0] <= target) {\n    return 0;\n  } else if (target <= arr[n - 1]) {\n    return n - 1;\n  } else {\n    let i;\n    if (direction > 0) {\n      for (i = 1; i < n; ++i) {\n        if (arr[i] < target) {\n          return i - 1;\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    } else {\n      for (i = 1; i < n; ++i) {\n        if (arr[i] == target) {\n          return i;\n        } else if (arr[i] < target) {\n          if (arr[i - 1] - target < target - arr[i]) {\n            return i - 1;\n          } else {\n            return i;\n          }\n        }\n      }\n    }\n    return n - 1;\n  }\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    const tmp = arr[begin];\n    arr[begin] = arr[end];\n    arr[end] = tmp;\n    ++begin;\n    --end;\n  }\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  const extension = Array.isArray(data) ? data : [data];\n  const length = extension.length;\n  for (let i = 0; i < length; i++) {\n    arr[arr.length] = extension[i];\n  }\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  const i = arr.indexOf(obj);\n  const found = i > -1;\n  if (found) {\n    arr.splice(i, 1);\n  }\n  return found;\n}\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  const length = arr.length >>> 0;\n  let value;\n\n  for (let 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/**\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  const len1 = arr1.length;\n  if (len1 !== arr2.length) {\n    return false;\n  }\n  for (let i = 0; i < len1; i++) {\n    if (arr1[i] !== arr2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Sort the passed array such that the relative order of equal elements is preverved.\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  const length = arr.length;\n  const tmp = Array(arr.length);\n  let 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/**\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  let index;\n  const found = !arr.every(function (el, idx) {\n    index = idx;\n    return !func(el, idx, arr);\n  });\n  return found ? index : -1;\n}\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  const compare = opt_func || numberSafeCompareFunction;\n  return arr.every(function (currentVal, index) {\n    if (index === 0) {\n      return true;\n    }\n    const res = compare(arr[index - 1], currentVal);\n    return !(res > 0 || (opt_strict && res === 0));\n  });\n}\n","/**\n * @module ol/functions\n */\n\nimport {equals as arrayEquals} from './array.js';\n\n/**\n * Always returns true.\n * @returns {boolean} true.\n */\nexport function TRUE() {\n  return true;\n}\n\n/**\n * Always returns false.\n * @returns {boolean} false.\n */\nexport function FALSE() {\n  return false;\n}\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/**\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  let called = false;\n\n  /** @type {ReturnType} */\n  let lastResult;\n\n  /** @type {Array<any>} */\n  let lastArgs;\n\n  let lastThis;\n\n  return function () {\n    const 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","/**\n * @module ol/obj\n */\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 const assign =\n  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\n        const output = Object(target);\n        for (let i = 1, ii = arguments.length; i < ii; ++i) {\n          const source = arguments[i];\n          if (source !== undefined && source !== null) {\n            for (const key in source) {\n              if (source.hasOwnProperty(key)) {\n                output[key] = source[key];\n              }\n            }\n          }\n        }\n        return output;\n      };\n\n/**\n * Removes all properties from an object.\n * @param {Object} object The object to clear.\n */\nexport function clear(object) {\n  for (const property in object) {\n    delete object[property];\n  }\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 const getValues =\n  typeof Object.values === 'function'\n    ? Object.values\n    : function (object) {\n        const values = [];\n        for (const property in object) {\n          values.push(object[property]);\n        }\n        return values;\n      };\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  let property;\n  for (property in object) {\n    return false;\n  }\n  return !property;\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/**\n * @typedef {EventTarget|Target} EventTargetLike\n */\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 */\nclass Target extends Disposable {\n  /**\n   * @param {*=} opt_target Default event target for dispatched events.\n   */\n  constructor(opt_target) {\n    super();\n\n    /**\n     * @private\n     * @type {*}\n     */\n    this.eventTarget_ = opt_target;\n\n    /**\n     * @private\n     * @type {Object<string, number>}\n     */\n    this.pendingRemovals_ = null;\n\n    /**\n     * @private\n     * @type {Object<string, number>}\n     */\n    this.dispatching_ = null;\n\n    /**\n     * @private\n     * @type {Object<string, Array<import(\"../events.js\").Listener>>}\n     */\n    this.listeners_ = null;\n  }\n\n  /**\n   * @param {string} type Type.\n   * @param {import(\"../events.js\").Listener} listener Listener.\n   */\n  addEventListener(type, listener) {\n    if (!type || !listener) {\n      return;\n    }\n    const listeners = this.listeners_ || (this.listeners_ = {});\n    const listenersForType = listeners[type] || (listeners[type] = []);\n    if (listenersForType.indexOf(listener) === -1) {\n      listenersForType.push(listener);\n    }\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  dispatchEvent(event) {\n    /** @type {import(\"./Event.js\").default|Event} */\n    const evt = typeof event === 'string' ? new Event(event) : event;\n    const type = evt.type;\n    if (!evt.target) {\n      evt.target = this.eventTarget_ || this;\n    }\n    const listeners = this.listeners_ && this.listeners_[type];\n    let propagate;\n    if (listeners) {\n      const dispatching = this.dispatching_ || (this.dispatching_ = {});\n      const pendingRemovals =\n        this.pendingRemovals_ || (this.pendingRemovals_ = {});\n      if (!(type in dispatching)) {\n        dispatching[type] = 0;\n        pendingRemovals[type] = 0;\n      }\n      ++dispatching[type];\n      for (let i = 0, ii = listeners.length; i < ii; ++i) {\n        if ('handleEvent' in listeners[i]) {\n          propagate = /** @type {import(\"../events.js\").ListenerObject} */ (listeners[\n            i\n          ]).handleEvent(evt);\n        } else {\n          propagate = /** @type {import(\"../events.js\").ListenerFunction} */ (listeners[\n            i\n          ]).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        let 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  /**\n   * Clean up.\n   */\n  disposeInternal() {\n    this.listeners_ && clear(this.listeners_);\n  }\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  getListeners(type) {\n    return (this.listeners_ && this.listeners_[type]) || undefined;\n  }\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  hasListener(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  /**\n   * @param {string} type Type.\n   * @param {import(\"../events.js\").Listener} listener Listener.\n   */\n  removeEventListener(type, listener) {\n    const listeners = this.listeners_ && this.listeners_[type];\n    if (listeners) {\n      const 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        } else {\n          listeners.splice(index, 1);\n          if (listeners.length === 0) {\n            delete this.listeners_[type];\n          }\n        }\n      }\n    }\n  }\n}\n\nexport default Target;\n","/**\n * @module ol/events/EventType\n */\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  /**\n   * Generic error event. Triggered when an error occurs.\n   * @event module:ol/events/Event~BaseEvent#error\n   * @api\n   */\n  ERROR: 'error',\n\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","/**\n * @module ol/events\n */\nimport {clear} from './obj.js';\n\n/**\n * Key to use with {@link module:ol/Observable~Observable#unByKey}.\n * @typedef {Object} EventsKey\n * @property {ListenerFunction} listener\n * @property {import(\"./events/Target.js\").EventTargetLike} target\n * @property {string} type\n * @api\n */\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/**\n * @typedef {Object} ListenerObject\n * @property {ListenerFunction} handleEvent\n */\n\n/**\n * @typedef {ListenerFunction|ListenerObject} Listener\n */\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    const originalListener = listener;\n    listener = function () {\n      target.removeEventListener(type, listener);\n      originalListener.apply(this, arguments);\n    };\n  }\n  const eventsKey = {\n    target: target,\n    type: type,\n    listener: listener,\n  };\n  target.addEventListener(type, listener);\n  return eventsKey;\n}\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/**\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","/**\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/**\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 */\nclass Observable extends EventTarget {\n  constructor() {\n    super();\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.revision_ = 0;\n  }\n\n  /**\n   * Increases the revision counter and dispatches a 'change' event.\n   * @api\n   */\n  changed() {\n    ++this.revision_;\n    this.dispatchEvent(EventType.CHANGE);\n  }\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  getRevision() {\n    return this.revision_;\n  }\n\n  /**\n   * Listen for a certain type of event.\n   * @param {string|Array<string>} type The event type or array of event types.\n   * @param {function(?): ?} 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   */\n  on(type, listener) {\n    if (Array.isArray(type)) {\n      const len = type.length;\n      const keys = new Array(len);\n      for (let i = 0; i < len; ++i) {\n        keys[i] = listen(this, type[i], listener);\n      }\n      return keys;\n    } else {\n      return listen(this, /** @type {string} */ (type), listener);\n    }\n  }\n\n  /**\n   * Listen once for a certain type of event.\n   * @param {string|Array<string>} type The event type or array of event types.\n   * @param {function(?): ?} 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   */\n  once(type, listener) {\n    let key;\n    if (Array.isArray(type)) {\n      const len = type.length;\n      key = new Array(len);\n      for (let i = 0; i < len; ++i) {\n        key[i] = listenOnce(this, type[i], listener);\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  /**\n   * Unlisten for a certain type of event.\n   * @param {string|Array<string>} type The event type or array of event types.\n   * @param {function(?): ?} listener The listener function.\n   * @api\n   */\n  un(type, listener) {\n    const key = /** @type {Object} */ (listener).ol_key;\n    if (key) {\n      unByKey(key);\n    } else if (Array.isArray(type)) {\n      for (let i = 0, ii = type.length; i < ii; ++i) {\n        this.removeEventListener(type[i], listener);\n      }\n    } else {\n      this.removeEventListener(type, listener);\n    }\n  }\n}\n\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 (let i = 0, ii = key.length; i < ii; ++i) {\n      unlistenByKey(key[i]);\n    }\n  } else {\n    unlistenByKey(/** @type {import(\"./events.js\").EventsKey} */ (key));\n  }\n}\n\nexport default Observable;\n","/**\n * @module ol/util\n */\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/**\n * Counter for getUid.\n * @type {number}\n * @private\n */\nlet uidCounter_ = 0;\n\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/**\n * OpenLayers version.\n * @type {string}\n */\nexport const VERSION = 'latest';\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/**\n * @classdesc\n * Events emitted by {@link module:ol/Object~BaseObject} instances are instances of this type.\n */\nexport class ObjectEvent extends Event {\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  constructor(type, key, oldValue) {\n    super(type);\n\n    /**\n     * The name of the property whose value is changing.\n     * @type {string}\n     * @api\n     */\n    this.key = key;\n\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  }\n}\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 */\nclass BaseObject extends Observable {\n  /**\n   * @param {Object<string, *>=} opt_values An object with key-value pairs.\n   */\n  constructor(opt_values) {\n    super();\n\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    /**\n     * @private\n     * @type {Object<string, *>}\n     */\n    this.values_ = null;\n\n    if (opt_values !== undefined) {\n      this.setProperties(opt_values);\n    }\n  }\n\n  /**\n   * Gets a value.\n   * @param {string} key Key name.\n   * @return {*} Value.\n   * @api\n   */\n  get(key) {\n    let value;\n    if (this.values_ && this.values_.hasOwnProperty(key)) {\n      value = this.values_[key];\n    }\n    return value;\n  }\n\n  /**\n   * Get a list of object property names.\n   * @return {Array<string>} List of property names.\n   * @api\n   */\n  getKeys() {\n    return (this.values_ && Object.keys(this.values_)) || [];\n  }\n\n  /**\n   * Get an object of all property names and values.\n   * @return {Object<string, *>} Object.\n   * @api\n   */\n  getProperties() {\n    return (this.values_ && assign({}, this.values_)) || {};\n  }\n\n  /**\n   * @return {boolean} The object has properties.\n   */\n  hasProperties() {\n    return !!this.values_;\n  }\n\n  /**\n   * @param {string} key Key name.\n   * @param {*} oldValue Old value.\n   */\n  notify(key, oldValue) {\n    let eventType;\n    eventType = getChangeEventType(key);\n    this.dispatchEvent(new ObjectEvent(eventType, key, oldValue));\n    eventType = ObjectEventType.PROPERTYCHANGE;\n    this.dispatchEvent(new ObjectEvent(eventType, key, oldValue));\n  }\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  set(key, value, opt_silent) {\n    const values = this.values_ || (this.values_ = {});\n    if (opt_silent) {\n      values[key] = value;\n    } else {\n      const oldValue = values[key];\n      values[key] = value;\n      if (oldValue !== value) {\n        this.notify(key, oldValue);\n      }\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  setProperties(values, opt_silent) {\n    for (const key in values) {\n      this.set(key, values[key], opt_silent);\n    }\n  }\n\n  /**\n   * Apply any properties from another object without triggering events.\n   * @param {BaseObject} source The source object.\n   * @protected\n   */\n  applyProperties(source) {\n    if (!source.values_) {\n      return;\n    }\n    assign(this.values_ || (this.values_ = {}), source.values_);\n  }\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  unset(key, opt_silent) {\n    if (this.values_ && key in this.values_) {\n      const 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}\n\n/**\n * @type {Object<string, string>}\n */\nconst changeEventTypeCache = {};\n\n/**\n * @param {string} key Key name.\n * @return {string} Change name.\n */\nexport function getChangeEventType(key) {\n  return changeEventTypeCache.hasOwnProperty(key)\n    ? changeEventTypeCache[key]\n    : (changeEventTypeCache[key] = 'change:' + key);\n}\n\nexport default BaseObject;\n","/**\n * @module ol/MapEventType\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  /**\n   * Triggered after a map frame is rendered.\n   * @event module:ol/MapEvent~MapEvent#postrender\n   * @api\n   */\n  POSTRENDER: 'postrender',\n\n  /**\n   * Triggered when the map starts moving.\n   * @event module:ol/MapEvent~MapEvent#movestart\n   * @api\n   */\n  MOVESTART: 'movestart',\n\n  /**\n   * Triggered after the map is moved.\n   * @event module:ol/MapEvent~MapEvent#moveend\n   * @api\n   */\n  MOVEEND: 'moveend',\n};\n","/**\n * @module ol/has\n */\n\nconst ua =\n  typeof navigator !== 'undefined' && typeof navigator.userAgent !== 'undefined'\n    ? navigator.userAgent.toLowerCase()\n    : '';\n\n/**\n * User agent string says we are dealing with Firefox as browser.\n * @type {boolean}\n */\nexport const FIREFOX = ua.indexOf('firefox') !== -1;\n\n/**\n * User agent string says we are dealing with Safari as browser.\n * @type {boolean}\n */\nexport const SAFARI = ua.indexOf('safari') !== -1 && ua.indexOf('chrom') == -1;\n\n/**\n * User agent string says we are dealing with a WebKit engine.\n * @type {boolean}\n */\nexport const WEBKIT = ua.indexOf('webkit') !== -1 && ua.indexOf('edge') == -1;\n\n/**\n * User agent string says we are dealing with a Mac as platform.\n * @type {boolean}\n */\nexport const MAC = ua.indexOf('macintosh') !== -1;\n\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 const DEVICE_PIXEL_RATIO =\n  typeof devicePixelRatio !== 'undefined' ? devicePixelRatio : 1;\n\n/**\n * The execution context is a worker with OffscreenCanvas available.\n * @const\n * @type {boolean}\n */\nexport const WORKER_OFFSCREEN_CANVAS =\n  typeof WorkerGlobalScope !== 'undefined' &&\n  typeof OffscreenCanvas !== 'undefined' &&\n  self instanceof WorkerGlobalScope; //eslint-disable-line\n\n/**\n * Image.prototype.decode() is supported.\n * @type {boolean}\n */\nexport const IMAGE_DECODE =\n  typeof Image !== 'undefined' && Image.prototype.decode;\n\n/**\n * @type {boolean}\n */\nexport const PASSIVE_EVENT_LISTENERS = (function () {\n  let passive = false;\n  try {\n    const options = Object.defineProperty({}, 'passive', {\n      get: function () {\n        passive = true;\n      },\n    });\n\n    window.addEventListener('_', null, options);\n    window.removeEventListener('_', null, options);\n  } catch (error) {\n    // passive not supported\n  }\n  return passive;\n})();\n","import {WORKER_OFFSCREEN_CANVAS} from './has.js';\n\n/**\n * @module ol/dom\n */\n\n//FIXME Move this function to the canvas module\n/**\n * Create an html canvas element and returns its 2d context.\n * @param {number=} opt_width Canvas width.\n * @param {number=} opt_height Canvas height.\n * @param {Array<HTMLCanvasElement>=} opt_canvasPool Canvas pool to take existing canvas from.\n * @return {CanvasRenderingContext2D} The context.\n */\nexport function createCanvasContext2D(opt_width, opt_height, opt_canvasPool) {\n  const canvas =\n    opt_canvasPool && opt_canvasPool.length\n      ? opt_canvasPool.shift()\n      : WORKER_OFFSCREEN_CANVAS\n      ? new OffscreenCanvas(opt_width || 300, opt_height || 300)\n      : document.createElement('canvas');\n  if (opt_width) {\n    canvas.width = opt_width;\n  }\n  if (opt_height) {\n    canvas.height = opt_height;\n  }\n  //FIXME Allow OffscreenCanvasRenderingContext2D as return type\n  return /** @type {CanvasRenderingContext2D} */ (canvas.getContext('2d'));\n}\n\n/**\n * Get the current computed width for the given element including margin,\n * padding and border.\n * Equivalent to jQuery's `$(el).outerWidth(true)`.\n * @param {!HTMLElement} element Element.\n * @return {number} The width.\n */\nexport function outerWidth(element) {\n  let width = element.offsetWidth;\n  const style = getComputedStyle(element);\n  width += parseInt(style.marginLeft, 10) + parseInt(style.marginRight, 10);\n\n  return width;\n}\n\n/**\n * Get the current computed height for the given element including margin,\n * padding and border.\n * Equivalent to jQuery's `$(el).outerHeight(true)`.\n * @param {!HTMLElement} element Element.\n * @return {number} The height.\n */\nexport function outerHeight(element) {\n  let height = element.offsetHeight;\n  const style = getComputedStyle(element);\n  height += parseInt(style.marginTop, 10) + parseInt(style.marginBottom, 10);\n\n  return height;\n}\n\n/**\n * @param {Node} newNode Node to replace old node\n * @param {Node} oldNode The node to be replaced\n */\nexport function replaceNode(newNode, oldNode) {\n  const parent = oldNode.parentNode;\n  if (parent) {\n    parent.replaceChild(newNode, oldNode);\n  }\n}\n\n/**\n * @param {Node} node The node to remove.\n * @returns {Node} The node that was removed or null.\n */\nexport function removeNode(node) {\n  return node && node.parentNode ? node.parentNode.removeChild(node) : null;\n}\n\n/**\n * @param {Node} node The node to remove the children from.\n */\nexport function removeChildren(node) {\n  while (node.lastChild) {\n    node.removeChild(node.lastChild);\n  }\n}\n\n/**\n * Transform the children of a parent node so they match the\n * provided list of children.  This function aims to efficiently\n * remove, add, and reorder child nodes while maintaining a simple\n * implementation (it is not guaranteed to minimize DOM operations).\n * @param {Node} node The parent node whose children need reworking.\n * @param {Array<Node>} children The desired children.\n */\nexport function replaceChildren(node, children) {\n  const oldChildren = node.childNodes;\n\n  for (let i = 0; true; ++i) {\n    const oldChild = oldChildren[i];\n    const newChild = children[i];\n\n    // check if our work is done\n    if (!oldChild && !newChild) {\n      break;\n    }\n\n    // check if children match\n    if (oldChild === newChild) {\n      continue;\n    }\n\n    // check if a new child needs to be added\n    if (!oldChild) {\n      node.appendChild(newChild);\n      continue;\n    }\n\n    // check if an old child needs to be removed\n    if (!newChild) {\n      node.removeChild(oldChild);\n      --i;\n      continue;\n    }\n\n    // reorder\n    node.insertBefore(newChild, oldChild);\n  }\n}\n","/**\n * @module ol/control/Control\n */\nimport BaseObject from '../Object.js';\nimport MapEventType from '../MapEventType.js';\nimport {VOID} from '../functions.js';\nimport {listen, unlistenByKey} from '../events.js';\nimport {removeNode} from '../dom.js';\n\n/**\n * @typedef {Object} Options\n * @property {HTMLElement} [element] The element is the control's\n * container element. This only needs to be specified if you're developing\n * a custom control.\n * @property {function(import(\"../MapEvent.js\").default):void} [render] Function called when\n * the control should be re-rendered. This is called in a `requestAnimationFrame`\n * callback.\n * @property {HTMLElement|string} [target] Specify a target if you want\n * the control to be rendered outside of the map's viewport.\n */\n\n/**\n * @classdesc\n * A control is a visible widget with a DOM element in a fixed position on the\n * screen. They can involve user input (buttons), or be informational only;\n * the position is determined using CSS. By default these are placed in the\n * container with CSS class name `ol-overlaycontainer-stopevent`, but can use\n * any outside DOM element.\n *\n * This is the base class for controls. You can use it for simple custom\n * controls by creating the element with listeners, creating an instance:\n * ```js\n * var myControl = new Control({element: myElement});\n * ```\n * and then adding this to the map.\n *\n * The main advantage of having this as a control rather than a simple separate\n * DOM element is that preventing propagation is handled for you. Controls\n * will also be objects in a {@link module:ol/Collection~Collection}, so you can use their methods.\n *\n * You can also extend this base for your own control class. See\n * examples/custom-controls for an example of how to do this.\n *\n * @api\n */\nclass Control extends BaseObject {\n  /**\n   * @param {Options} options Control options.\n   */\n  constructor(options) {\n    super();\n\n    const element = options.element;\n    if (element && !options.target && !element.style.pointerEvents) {\n      element.style.pointerEvents = 'auto';\n    }\n\n    /**\n     * @protected\n     * @type {HTMLElement}\n     */\n    this.element = element ? element : null;\n\n    /**\n     * @private\n     * @type {HTMLElement}\n     */\n    this.target_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../PluggableMap.js\").default}\n     */\n    this.map_ = null;\n\n    /**\n     * @protected\n     * @type {!Array<import(\"../events.js\").EventsKey>}\n     */\n    this.listenerKeys = [];\n\n    if (options.render) {\n      this.render = options.render;\n    }\n\n    if (options.target) {\n      this.setTarget(options.target);\n    }\n  }\n\n  /**\n   * Clean up.\n   */\n  disposeInternal() {\n    removeNode(this.element);\n    super.disposeInternal();\n  }\n\n  /**\n   * Get the map associated with this control.\n   * @return {import(\"../PluggableMap.js\").default} Map.\n   * @api\n   */\n  getMap() {\n    return this.map_;\n  }\n\n  /**\n   * Remove the control from its current map and attach it to the new map.\n   * Subclasses may set up event handlers to get notified about changes to\n   * the map here.\n   * @param {import(\"../PluggableMap.js\").default} map Map.\n   * @api\n   */\n  setMap(map) {\n    if (this.map_) {\n      removeNode(this.element);\n    }\n    for (let i = 0, ii = this.listenerKeys.length; i < ii; ++i) {\n      unlistenByKey(this.listenerKeys[i]);\n    }\n    this.listenerKeys.length = 0;\n    this.map_ = map;\n    if (this.map_) {\n      const target = this.target_\n        ? this.target_\n        : map.getOverlayContainerStopEvent();\n      target.appendChild(this.element);\n      if (this.render !== VOID) {\n        this.listenerKeys.push(\n          listen(map, MapEventType.POSTRENDER, this.render, this)\n        );\n      }\n      map.render();\n    }\n  }\n\n  /**\n   * Renders the control.\n   * @param {import(\"../MapEvent.js\").default} mapEvent Map event.\n   * @api\n   */\n  render(mapEvent) {}\n\n  /**\n   * This function is used to set a target element for the control. It has no\n   * effect if it is called after the control has been added to the map (i.e.\n   * after `setMap` is called on the control). If no `target` is set in the\n   * options passed to the control constructor and if `setTarget` is not called\n   * then the control is added to the map's overlay container.\n   * @param {HTMLElement|string} target Target.\n   * @api\n   */\n  setTarget(target) {\n    this.target_ =\n      typeof target === 'string' ? document.getElementById(target) : target;\n  }\n}\n\nexport default Control;\n","/**\n * @module ol/css\n */\n\n/**\n * @typedef {Object} FontParameters\n * @property {string} style\n * @property {string} variant\n * @property {string} weight\n * @property {string} size\n * @property {string} lineHeight\n * @property {string} family\n * @property {Array<string>} families\n */\n\n/**\n * The CSS class for hidden feature.\n *\n * @const\n * @type {string}\n */\nexport const CLASS_HIDDEN = 'ol-hidden';\n\n/**\n * The CSS class that we'll give the DOM elements to have them selectable.\n *\n * @const\n * @type {string}\n */\nexport const CLASS_SELECTABLE = 'ol-selectable';\n\n/**\n * The CSS class that we'll give the DOM elements to have them unselectable.\n *\n * @const\n * @type {string}\n */\nexport const CLASS_UNSELECTABLE = 'ol-unselectable';\n\n/**\n * The CSS class for unsupported feature.\n *\n * @const\n * @type {string}\n */\nexport const CLASS_UNSUPPORTED = 'ol-unsupported';\n\n/**\n * The CSS class for controls.\n *\n * @const\n * @type {string}\n */\nexport const CLASS_CONTROL = 'ol-control';\n\n/**\n * The CSS class that we'll give the DOM elements that are collapsed, i.e.\n * to those elements which usually can be expanded.\n *\n * @const\n * @type {string}\n */\nexport const CLASS_COLLAPSED = 'ol-collapsed';\n\n/**\n * From http://stackoverflow.com/questions/10135697/regex-to-parse-any-css-font\n * @type {RegExp}\n */\nconst fontRegEx = new RegExp(\n  [\n    '^\\\\s*(?=(?:(?:[-a-z]+\\\\s*){0,2}(italic|oblique))?)',\n    '(?=(?:(?:[-a-z]+\\\\s*){0,2}(small-caps))?)',\n    '(?=(?:(?:[-a-z]+\\\\s*){0,2}(bold(?:er)?|lighter|[1-9]00 ))?)',\n    '(?:(?:normal|\\\\1|\\\\2|\\\\3)\\\\s*){0,3}((?:xx?-)?',\n    '(?:small|large)|medium|smaller|larger|[\\\\.\\\\d]+(?:\\\\%|in|[cem]m|ex|p[ctx]))',\n    '(?:\\\\s*\\\\/\\\\s*(normal|[\\\\.\\\\d]+(?:\\\\%|in|[cem]m|ex|p[ctx])?))',\n    '?\\\\s*([-,\\\\\"\\\\\\'\\\\sa-z]+?)\\\\s*$',\n  ].join(''),\n  'i'\n);\nconst fontRegExMatchIndex = [\n  'style',\n  'variant',\n  'weight',\n  'size',\n  'lineHeight',\n  'family',\n];\n\n/**\n * Get the list of font families from a font spec.  Note that this doesn't work\n * for font families that have commas in them.\n * @param {string} fontSpec The CSS font property.\n * @return {FontParameters} The font parameters (or null if the input spec is invalid).\n */\nexport const getFontParameters = function (fontSpec) {\n  const match = fontSpec.match(fontRegEx);\n  if (!match) {\n    return null;\n  }\n  const style = /** @type {FontParameters} */ ({\n    lineHeight: 'normal',\n    size: '1.2em',\n    style: 'normal',\n    weight: 'normal',\n    variant: 'normal',\n  });\n  for (let i = 0, ii = fontRegExMatchIndex.length; i < ii; ++i) {\n    const value = match[i + 1];\n    if (value !== undefined) {\n      style[fontRegExMatchIndex[i]] = value;\n    }\n  }\n  style.families = style.family.split(/,\\s?/);\n  return style;\n};\n","/**\n * @module ol/layer/Property\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  OPACITY: 'opacity',\n  VISIBLE: 'visible',\n  EXTENT: 'extent',\n  Z_INDEX: 'zIndex',\n  MAX_RESOLUTION: 'maxResolution',\n  MIN_RESOLUTION: 'minResolution',\n  MAX_ZOOM: 'maxZoom',\n  MIN_ZOOM: 'minZoom',\n  SOURCE: 'source',\n};\n","/**\n * @module ol/AssertionError\n */\nimport {VERSION} from './util.js';\n\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 */\nclass AssertionError extends Error {\n  /**\n   * @param {number} code Error code.\n   */\n  constructor(code) {\n    const path = VERSION === 'latest' ? VERSION : 'v' + VERSION.split('-')[0];\n    const message =\n      'Assertion failed. See https://openlayers.org/en/' +\n      path +\n      '/doc/errors/#' +\n      code +\n      ' for details.';\n\n    super(message);\n\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    /**\n     * @type {string}\n     */\n    this.name = 'AssertionError';\n\n    // Re-assign message, see https://github.com/Rich-Harris/buble/issues/40\n    this.message = message;\n  }\n}\n\nexport default AssertionError;\n","/**\n * @module ol/asserts\n */\nimport AssertionError from './AssertionError.js';\n\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","/**\n * @module ol/math\n */\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/**\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 const cosh = (function () {\n  // Wrapped in a iife, to save the overhead of checking for the native\n  // implementation on every invocation.\n  let cosh;\n  if ('cosh' in Math) {\n    // The environment supports the native Math.cosh function, use it…\n    cosh = Math.cosh;\n  } else {\n    // … else, use the reference implementation of MDN:\n    cosh = function (x) {\n      const y = /** @type {Math} */ (Math).exp(x);\n      return (y + 1 / y) / 2;\n    };\n  }\n  return cosh;\n})();\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 const log2 = (function () {\n  // Wrapped in a iife, to save the overhead of checking for the native\n  // implementation on every invocation.\n  let log2;\n  if ('log2' in Math) {\n    // The environment supports the native Math.log2 function, use it…\n    log2 = Math.log2;\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/**\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  const dx = x2 - x1;\n  const dy = y2 - y1;\n  if (dx !== 0 || dy !== 0) {\n    const t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy);\n    if (t > 1) {\n      x1 = x2;\n      y1 = y2;\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/**\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  const dx = x2 - x1;\n  const dy = y2 - y1;\n  return dx * dx + dy * dy;\n}\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  const n = mat.length;\n\n  for (let i = 0; i < n; i++) {\n    // Find max in the i-th column (ignoring i - 1 first rows)\n    let maxRow = i;\n    let maxEl = Math.abs(mat[i][i]);\n    for (let r = i + 1; r < n; r++) {\n      const absValue = Math.abs(mat[r][i]);\n      if (absValue > maxEl) {\n        maxEl = absValue;\n        maxRow = r;\n      }\n    }\n\n    if (maxEl === 0) {\n      return null; // matrix is singular\n    }\n\n    // Swap max row with i-th (current) row\n    const tmp = mat[maxRow];\n    mat[maxRow] = mat[i];\n    mat[i] = tmp;\n\n    // Subtract the i-th row to make all the remaining rows 0 in the i-th column\n    for (let j = i + 1; j < n; j++) {\n      const coef = -mat[j][i] / mat[i][i];\n      for (let k = i; k < n + 1; k++) {\n        if (i == k) {\n          mat[j][k] = 0;\n        } else {\n          mat[j][k] += coef * mat[i][k];\n        }\n      }\n    }\n  }\n\n  // Solve Ax=b for upper triangular matrix A (mat)\n  const x = new Array(n);\n  for (let l = n - 1; l >= 0; l--) {\n    x[l] = mat[l][n] / mat[l][l];\n    for (let m = l - 1; m >= 0; m--) {\n      mat[m][n] -= mat[m][l] * x[l];\n    }\n  }\n  return x;\n}\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/**\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/**\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  const r = a % b;\n  return r * b < 0 ? r + b : r;\n}\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","/**\n * @module ol/layer/Base\n */\nimport BaseObject from '../Object.js';\nimport LayerProperty from './Property.js';\nimport {abstract} from '../util.js';\nimport {assert} from '../asserts.js';\nimport {assign} from '../obj.js';\nimport {clamp} from '../math.js';\n\n/**\n * @typedef {Object} Options\n * @property {string} [className='ol-layer'] A CSS class name to set to the layer element.\n * @property {number} [opacity=1] Opacity (0, 1).\n * @property {boolean} [visible=true] Visibility.\n * @property {import(\"../extent.js\").Extent} [extent] The bounding extent for layer rendering.  The layer will not be\n * rendered outside of this extent.\n * @property {number} [zIndex] The z-index for layer rendering.  At rendering time, the layers\n * will be ordered, first by Z-index and then by position. When `undefined`, a `zIndex` of 0 is assumed\n * for layers that are added to the map's `layers` collection, or `Infinity` when the layer's `setMap()`\n * method was used.\n * @property {number} [minResolution] The minimum resolution (inclusive) at which this layer will be\n * visible.\n * @property {number} [maxResolution] The maximum resolution (exclusive) below which this layer will\n * be visible.\n * @property {number} [minZoom] The minimum view zoom level (exclusive) above which this layer will be\n * visible.\n * @property {number} [maxZoom] The maximum view zoom level (inclusive) at which this layer will\n * be visible.\n */\n\n/**\n * @classdesc\n * Abstract base class; normally only used for creating subclasses and not\n * instantiated in apps.\n * Note that with {@link module:ol/layer/Base} and all its subclasses, any property set in\n * the options is set as a {@link module:ol/Object} property on the layer object, so\n * is observable, and has get/set accessors.\n *\n * @api\n */\nclass BaseLayer extends BaseObject {\n  /**\n   * @param {Options} options Layer options.\n   */\n  constructor(options) {\n    super();\n\n    /**\n     * @type {Object<string, *>}\n     */\n    const properties = assign({}, options);\n\n    properties[LayerProperty.OPACITY] =\n      options.opacity !== undefined ? options.opacity : 1;\n    assert(typeof properties[LayerProperty.OPACITY] === 'number', 64); // Layer opacity must be a number\n\n    properties[LayerProperty.VISIBLE] =\n      options.visible !== undefined ? options.visible : true;\n    properties[LayerProperty.Z_INDEX] = options.zIndex;\n    properties[LayerProperty.MAX_RESOLUTION] =\n      options.maxResolution !== undefined ? options.maxResolution : Infinity;\n    properties[LayerProperty.MIN_RESOLUTION] =\n      options.minResolution !== undefined ? options.minResolution : 0;\n    properties[LayerProperty.MIN_ZOOM] =\n      options.minZoom !== undefined ? options.minZoom : -Infinity;\n    properties[LayerProperty.MAX_ZOOM] =\n      options.maxZoom !== undefined ? options.maxZoom : Infinity;\n\n    /**\n     * @type {string}\n     * @private\n     */\n    this.className_ =\n      properties.className !== undefined ? options.className : 'ol-layer';\n    delete properties.className;\n\n    this.setProperties(properties);\n\n    /**\n     * @type {import(\"./Layer.js\").State}\n     * @private\n     */\n    this.state_ = null;\n  }\n\n  /**\n   * @return {string} CSS class name.\n   */\n  getClassName() {\n    return this.className_;\n  }\n\n  /**\n   * This method is not meant to be called by layers or layer renderers because the state\n   * is incorrect if the layer is included in a layer group.\n   *\n   * @param {boolean=} opt_managed Layer is managed.\n   * @return {import(\"./Layer.js\").State} Layer state.\n   */\n  getLayerState(opt_managed) {\n    /** @type {import(\"./Layer.js\").State} */\n    const state =\n      this.state_ ||\n      /** @type {?} */ ({\n        layer: this,\n        managed: opt_managed === undefined ? true : opt_managed,\n      });\n    const zIndex = this.getZIndex();\n    state.opacity = clamp(Math.round(this.getOpacity() * 100) / 100, 0, 1);\n    state.sourceState = this.getSourceState();\n    state.visible = this.getVisible();\n    state.extent = this.getExtent();\n    state.zIndex =\n      zIndex !== undefined ? zIndex : state.managed === false ? Infinity : 0;\n    state.maxResolution = this.getMaxResolution();\n    state.minResolution = Math.max(this.getMinResolution(), 0);\n    state.minZoom = this.getMinZoom();\n    state.maxZoom = this.getMaxZoom();\n    this.state_ = state;\n\n    return state;\n  }\n\n  /**\n   * @abstract\n   * @param {Array<import(\"./Layer.js\").default>=} opt_array Array of layers (to be\n   *     modified in place).\n   * @return {Array<import(\"./Layer.js\").default>} Array of layers.\n   */\n  getLayersArray(opt_array) {\n    return abstract();\n  }\n\n  /**\n   * @abstract\n   * @param {Array<import(\"./Layer.js\").State>=} opt_states Optional list of layer\n   *     states (to be modified in place).\n   * @return {Array<import(\"./Layer.js\").State>} List of layer states.\n   */\n  getLayerStatesArray(opt_states) {\n    return abstract();\n  }\n\n  /**\n   * Return the {@link module:ol/extent~Extent extent} of the layer or `undefined` if it\n   * will be visible regardless of extent.\n   * @return {import(\"../extent.js\").Extent|undefined} The layer extent.\n   * @observable\n   * @api\n   */\n  getExtent() {\n    return /** @type {import(\"../extent.js\").Extent|undefined} */ (this.get(\n      LayerProperty.EXTENT\n    ));\n  }\n\n  /**\n   * Return the maximum resolution of the layer.\n   * @return {number} The maximum resolution of the layer.\n   * @observable\n   * @api\n   */\n  getMaxResolution() {\n    return /** @type {number} */ (this.get(LayerProperty.MAX_RESOLUTION));\n  }\n\n  /**\n   * Return the minimum resolution of the layer.\n   * @return {number} The minimum resolution of the layer.\n   * @observable\n   * @api\n   */\n  getMinResolution() {\n    return /** @type {number} */ (this.get(LayerProperty.MIN_RESOLUTION));\n  }\n\n  /**\n   * Return the minimum zoom level of the layer.\n   * @return {number} The minimum zoom level of the layer.\n   * @observable\n   * @api\n   */\n  getMinZoom() {\n    return /** @type {number} */ (this.get(LayerProperty.MIN_ZOOM));\n  }\n\n  /**\n   * Return the maximum zoom level of the layer.\n   * @return {number} The maximum zoom level of the layer.\n   * @observable\n   * @api\n   */\n  getMaxZoom() {\n    return /** @type {number} */ (this.get(LayerProperty.MAX_ZOOM));\n  }\n\n  /**\n   * Return the opacity of the layer (between 0 and 1).\n   * @return {number} The opacity of the layer.\n   * @observable\n   * @api\n   */\n  getOpacity() {\n    return /** @type {number} */ (this.get(LayerProperty.OPACITY));\n  }\n\n  /**\n   * @abstract\n   * @return {import(\"../source/State.js\").default} Source state.\n   */\n  getSourceState() {\n    return abstract();\n  }\n\n  /**\n   * Return the visibility of the layer (`true` or `false`).\n   * @return {boolean} The visibility of the layer.\n   * @observable\n   * @api\n   */\n  getVisible() {\n    return /** @type {boolean} */ (this.get(LayerProperty.VISIBLE));\n  }\n\n  /**\n   * Return the Z-index of the layer, which is used to order layers before\n   * rendering. The default Z-index is 0.\n   * @return {number} The Z-index of the layer.\n   * @observable\n   * @api\n   */\n  getZIndex() {\n    return /** @type {number} */ (this.get(LayerProperty.Z_INDEX));\n  }\n\n  /**\n   * Set the extent at which the layer is visible.  If `undefined`, the layer\n   * will be visible at all extents.\n   * @param {import(\"../extent.js\").Extent|undefined} extent The extent of the layer.\n   * @observable\n   * @api\n   */\n  setExtent(extent) {\n    this.set(LayerProperty.EXTENT, extent);\n  }\n\n  /**\n   * Set the maximum resolution at which the layer is visible.\n   * @param {number} maxResolution The maximum resolution of the layer.\n   * @observable\n   * @api\n   */\n  setMaxResolution(maxResolution) {\n    this.set(LayerProperty.MAX_RESOLUTION, maxResolution);\n  }\n\n  /**\n   * Set the minimum resolution at which the layer is visible.\n   * @param {number} minResolution The minimum resolution of the layer.\n   * @observable\n   * @api\n   */\n  setMinResolution(minResolution) {\n    this.set(LayerProperty.MIN_RESOLUTION, minResolution);\n  }\n\n  /**\n   * Set the maximum zoom (exclusive) at which the layer is visible.\n   * Note that the zoom levels for layer visibility are based on the\n   * view zoom level, which may be different from a tile source zoom level.\n   * @param {number} maxZoom The maximum zoom of the layer.\n   * @observable\n   * @api\n   */\n  setMaxZoom(maxZoom) {\n    this.set(LayerProperty.MAX_ZOOM, maxZoom);\n  }\n\n  /**\n   * Set the minimum zoom (inclusive) at which the layer is visible.\n   * Note that the zoom levels for layer visibility are based on the\n   * view zoom level, which may be different from a tile source zoom level.\n   * @param {number} minZoom The minimum zoom of the layer.\n   * @observable\n   * @api\n   */\n  setMinZoom(minZoom) {\n    this.set(LayerProperty.MIN_ZOOM, minZoom);\n  }\n\n  /**\n   * Set the opacity of the layer, allowed values range from 0 to 1.\n   * @param {number} opacity The opacity of the layer.\n   * @observable\n   * @api\n   */\n  setOpacity(opacity) {\n    assert(typeof opacity === 'number', 64); // Layer opacity must be a number\n    this.set(LayerProperty.OPACITY, opacity);\n  }\n\n  /**\n   * Set the visibility of the layer (`true` or `false`).\n   * @param {boolean} visible The visibility of the layer.\n   * @observable\n   * @api\n   */\n  setVisible(visible) {\n    this.set(LayerProperty.VISIBLE, visible);\n  }\n\n  /**\n   * Set Z-index of the layer, which is used to order layers before rendering.\n   * The default Z-index is 0.\n   * @param {number} zindex The z-index of the layer.\n   * @observable\n   * @api\n   */\n  setZIndex(zindex) {\n    this.set(LayerProperty.Z_INDEX, zindex);\n  }\n\n  /**\n   * Clean up.\n   */\n  disposeInternal() {\n    if (this.state_) {\n      this.state_.layer = null;\n      this.state_ = null;\n    }\n    super.disposeInternal();\n  }\n}\n\nexport default BaseLayer;\n","/**\n * @module ol/render/EventType\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  /**\n   * Triggered before a layer is rendered.\n   * @event module:ol/render/Event~RenderEvent#prerender\n   * @api\n   */\n  PRERENDER: 'prerender',\n\n  /**\n   * Triggered after a layer is rendered.\n   * @event module:ol/render/Event~RenderEvent#postrender\n   * @api\n   */\n  POSTRENDER: 'postrender',\n\n  /**\n   * Triggered before layers are rendered.\n   * The event object will not have a `context` set.\n   * @event module:ol/render/Event~RenderEvent#precompose\n   * @api\n   */\n  PRECOMPOSE: 'precompose',\n\n  /**\n   * Triggered after all layers are rendered.\n   * The event object will not have a `context` set.\n   * @event module:ol/render/Event~RenderEvent#postcompose\n   * @api\n   */\n  POSTCOMPOSE: 'postcompose',\n\n  /**\n   * Triggered when rendering is complete, i.e. all sources and tiles have\n   * finished loading for the current viewport, and all tiles are faded in.\n   * The event object will not have a `context` set.\n   * @event module:ol/render/Event~RenderEvent#rendercomplete\n   * @api\n   */\n  RENDERCOMPLETE: 'rendercomplete',\n};\n","/**\n * @module ol/source/State\n */\n\n/**\n * @enum {string}\n * State of the source, one of 'undefined', 'loading', 'ready' or 'error'.\n */\nexport default {\n  UNDEFINED: 'undefined',\n  LOADING: 'loading',\n  READY: 'ready',\n  ERROR: 'error',\n};\n","/**\n * @module ol/layer/Layer\n */\nimport BaseLayer from './Base.js';\nimport EventType from '../events/EventType.js';\nimport LayerProperty from './Property.js';\nimport RenderEventType from '../render/EventType.js';\nimport SourceState from '../source/State.js';\nimport {assert} from '../asserts.js';\nimport {assign} from '../obj.js';\nimport {getChangeEventType} from '../Object.js';\nimport {listen, unlistenByKey} from '../events.js';\n\n/**\n * @typedef {function(import(\"../PluggableMap.js\").FrameState):HTMLElement} RenderFunction\n */\n\n/**\n * @typedef {Object} Options\n * @property {string} [className='ol-layer'] A CSS class name to set to the layer element.\n * @property {number} [opacity=1] Opacity (0, 1).\n * @property {boolean} [visible=true] Visibility.\n * @property {import(\"../extent.js\").Extent} [extent] The bounding extent for layer rendering.  The layer will not be\n * rendered outside of this extent.\n * @property {number} [zIndex] The z-index for layer rendering.  At rendering time, the layers\n * will be ordered, first by Z-index and then by position. When `undefined`, a `zIndex` of 0 is assumed\n * for layers that are added to the map's `layers` collection, or `Infinity` when the layer's `setMap()`\n * method was used.\n * @property {number} [minResolution] The minimum resolution (inclusive) at which this layer will be\n * visible.\n * @property {number} [maxResolution] The maximum resolution (exclusive) below which this layer will\n * be visible.\n * @property {number} [minZoom] The minimum view zoom level (exclusive) above which this layer will be\n * visible.\n * @property {number} [maxZoom] The maximum view zoom level (inclusive) at which this layer will\n * be visible.\n * @property {import(\"../source/Source.js\").default} [source] Source for this layer.  If not provided to the constructor,\n * the source can be set by calling {@link module:ol/layer/Layer#setSource layer.setSource(source)} after\n * construction.\n * @property {import(\"../PluggableMap.js\").default} [map] Map.\n * @property {RenderFunction} [render] Render function. Takes the frame state as input and is expected to return an\n * HTML element. Will overwrite the default rendering for the layer.\n */\n\n/**\n * @typedef {Object} State\n * @property {import(\"./Layer.js\").default} layer\n * @property {number} opacity Opacity, the value is rounded to two digits to appear after the decimal point.\n * @property {import(\"../source/State.js\").default} sourceState\n * @property {boolean} visible\n * @property {boolean} managed\n * @property {import(\"../extent.js\").Extent} [extent]\n * @property {number} zIndex\n * @property {number} maxResolution\n * @property {number} minResolution\n * @property {number} minZoom\n * @property {number} maxZoom\n */\n\n/**\n * @classdesc\n * Base class from which all layer types are derived. This should only be instantiated\n * in the case where a custom layer is be added to the map with a custom `render` function.\n * Such a function can be specified in the `options` object, and is expected to return an HTML element.\n *\n * A visual representation of raster or vector map data.\n * Layers group together those properties that pertain to how the data is to be\n * displayed, irrespective of the source of that data.\n *\n * Layers are usually added to a map with {@link module:ol/Map#addLayer}. Components\n * like {@link module:ol/interaction/Select~Select} use unmanaged layers\n * internally. These unmanaged layers are associated with the map using\n * {@link module:ol/layer/Layer~Layer#setMap} instead.\n *\n * A generic `change` event is fired when the state of the source changes.\n *\n * Please note that for performance reasons several layers might get rendered to\n * the same HTML element, which will cause {@link module:ol/Map~Map#forEachLayerAtPixel} to\n * give false positives. To avoid this, apply different `className` properties to the\n * layers at creation time.\n *\n * @fires import(\"../render/Event.js\").RenderEvent#prerender\n * @fires import(\"../render/Event.js\").RenderEvent#postrender\n *\n * @template {import(\"../source/Source.js\").default} SourceType\n * @api\n */\nclass Layer extends BaseLayer {\n  /**\n   * @param {Options} options Layer options.\n   */\n  constructor(options) {\n    const baseOptions = assign({}, options);\n    delete baseOptions.source;\n\n    super(baseOptions);\n\n    /**\n     * @private\n     * @type {?import(\"../events.js\").EventsKey}\n     */\n    this.mapPrecomposeKey_ = null;\n\n    /**\n     * @private\n     * @type {?import(\"../events.js\").EventsKey}\n     */\n    this.mapRenderKey_ = null;\n\n    /**\n     * @private\n     * @type {?import(\"../events.js\").EventsKey}\n     */\n    this.sourceChangeKey_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../renderer/Layer.js\").default}\n     */\n    this.renderer_ = null;\n\n    // Overwrite default render method with a custom one\n    if (options.render) {\n      this.render = options.render;\n    }\n\n    if (options.map) {\n      this.setMap(options.map);\n    }\n\n    this.addEventListener(\n      getChangeEventType(LayerProperty.SOURCE),\n      this.handleSourcePropertyChange_\n    );\n\n    const source = options.source\n      ? /** @type {SourceType} */ (options.source)\n      : null;\n    this.setSource(source);\n  }\n\n  /**\n   * @param {Array<import(\"./Layer.js\").default>=} opt_array Array of layers (to be modified in place).\n   * @return {Array<import(\"./Layer.js\").default>} Array of layers.\n   */\n  getLayersArray(opt_array) {\n    const array = opt_array ? opt_array : [];\n    array.push(this);\n    return array;\n  }\n\n  /**\n   * @param {Array<import(\"./Layer.js\").State>=} opt_states Optional list of layer states (to be modified in place).\n   * @return {Array<import(\"./Layer.js\").State>} List of layer states.\n   */\n  getLayerStatesArray(opt_states) {\n    const states = opt_states ? opt_states : [];\n    states.push(this.getLayerState());\n    return states;\n  }\n\n  /**\n   * Get the layer source.\n   * @return {SourceType} The layer source (or `null` if not yet set).\n   * @observable\n   * @api\n   */\n  getSource() {\n    return /** @type {SourceType} */ (this.get(LayerProperty.SOURCE)) || null;\n  }\n\n  /**\n   * @return {import(\"../source/State.js\").default} Source state.\n   */\n  getSourceState() {\n    const source = this.getSource();\n    return !source ? SourceState.UNDEFINED : source.getState();\n  }\n\n  /**\n   * @private\n   */\n  handleSourceChange_() {\n    this.changed();\n  }\n\n  /**\n   * @private\n   */\n  handleSourcePropertyChange_() {\n    if (this.sourceChangeKey_) {\n      unlistenByKey(this.sourceChangeKey_);\n      this.sourceChangeKey_ = null;\n    }\n    const source = this.getSource();\n    if (source) {\n      this.sourceChangeKey_ = listen(\n        source,\n        EventType.CHANGE,\n        this.handleSourceChange_,\n        this\n      );\n    }\n    this.changed();\n  }\n\n  /**\n   * @param {import(\"../pixel\").Pixel} pixel Pixel.\n   * @return {Promise<Array<import(\"../Feature\").default>>} Promise that resolves with\n   * an array of features.\n   */\n  getFeatures(pixel) {\n    return this.renderer_.getFeatures(pixel);\n  }\n\n  /**\n   * In charge to manage the rendering of the layer. One layer type is\n   * bounded with one layer renderer.\n   * @param {?import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {HTMLElement} target Target which the renderer may (but need not) use\n   * for rendering its content.\n   * @return {HTMLElement} The rendered element.\n   */\n  render(frameState, target) {\n    const layerRenderer = this.getRenderer();\n\n    if (layerRenderer.prepareFrame(frameState)) {\n      return layerRenderer.renderFrame(frameState, target);\n    }\n  }\n\n  /**\n   * Sets the layer to be rendered on top of other layers on a map. The map will\n   * not manage this layer in its layers collection, and the callback in\n   * {@link module:ol/Map#forEachLayerAtPixel} will receive `null` as layer. This\n   * is useful for temporary layers. To remove an unmanaged layer from the map,\n   * use `#setMap(null)`.\n   *\n   * To add the layer to a map and have it managed by the map, use\n   * {@link module:ol/Map#addLayer} instead.\n   * @param {import(\"../PluggableMap.js\").default} map Map.\n   * @api\n   */\n  setMap(map) {\n    if (this.mapPrecomposeKey_) {\n      unlistenByKey(this.mapPrecomposeKey_);\n      this.mapPrecomposeKey_ = null;\n    }\n    if (!map) {\n      this.changed();\n    }\n    if (this.mapRenderKey_) {\n      unlistenByKey(this.mapRenderKey_);\n      this.mapRenderKey_ = null;\n    }\n    if (map) {\n      this.mapPrecomposeKey_ = listen(\n        map,\n        RenderEventType.PRECOMPOSE,\n        function (evt) {\n          const renderEvent = /** @type {import(\"../render/Event.js\").default} */ (evt);\n          const layerStatesArray = renderEvent.frameState.layerStatesArray;\n          const layerState = this.getLayerState(false);\n          // A layer can only be added to the map once. Use either `layer.setMap()` or `map.addLayer()`, not both.\n          assert(\n            !layerStatesArray.some(function (arrayLayerState) {\n              return arrayLayerState.layer === layerState.layer;\n            }),\n            67\n          );\n          layerStatesArray.push(layerState);\n        },\n        this\n      );\n      this.mapRenderKey_ = listen(this, EventType.CHANGE, map.render, map);\n      this.changed();\n    }\n  }\n\n  /**\n   * Set the layer source.\n   * @param {SourceType} source The layer source.\n   * @observable\n   * @api\n   */\n  setSource(source) {\n    this.set(LayerProperty.SOURCE, source);\n  }\n\n  /**\n   * Get the renderer for this layer.\n   * @return {import(\"../renderer/Layer.js\").default} The layer renderer.\n   */\n  getRenderer() {\n    if (!this.renderer_) {\n      this.renderer_ = this.createRenderer();\n    }\n    return this.renderer_;\n  }\n\n  /**\n   * @return {boolean} The layer has a renderer.\n   */\n  hasRenderer() {\n    return !!this.renderer_;\n  }\n\n  /**\n   * Create a renderer for this layer.\n   * @return {import(\"../renderer/Layer.js\").default} A layer renderer.\n   * @protected\n   */\n  createRenderer() {\n    return null;\n  }\n\n  /**\n   * Clean up.\n   */\n  disposeInternal() {\n    this.setSource(null);\n    super.disposeInternal();\n  }\n}\n\n/**\n * Return `true` if the layer is visible and if the provided view state\n * has resolution and zoom levels that are in range of the layer's min/max.\n * @param {State} layerState Layer state.\n * @param {import(\"../View.js\").State} viewState View state.\n * @return {boolean} The layer is visible at the given view state.\n */\nexport function inView(layerState, viewState) {\n  if (!layerState.visible) {\n    return false;\n  }\n  const resolution = viewState.resolution;\n  if (\n    resolution < layerState.minResolution ||\n    resolution >= layerState.maxResolution\n  ) {\n    return false;\n  }\n  const zoom = viewState.zoom;\n  return zoom > layerState.minZoom && zoom <= layerState.maxZoom;\n}\n\nexport default Layer;\n","/**\n * @module ol/control/Attribution\n */\nimport Control from './Control.js';\nimport EventType from '../events/EventType.js';\nimport {CLASS_COLLAPSED, CLASS_CONTROL, CLASS_UNSELECTABLE} from '../css.js';\nimport {equals} from '../array.js';\nimport {inView} from '../layer/Layer.js';\nimport {removeChildren, replaceNode} from '../dom.js';\n\n/**\n * @typedef {Object} Options\n * @property {string} [className='ol-attribution'] CSS class name.\n * @property {HTMLElement|string} [target] Specify a target if you\n * want the control to be rendered outside of the map's\n * viewport.\n * @property {boolean} [collapsible] Specify if attributions can\n * be collapsed. If not specified, sources control this behavior with their\n * `attributionsCollapsible` setting.\n * @property {boolean} [collapsed=true] Specify if attributions should\n * be collapsed at startup.\n * @property {string} [tipLabel='Attributions'] Text label to use for the button tip.\n * @property {string} [label='i'] Text label to use for the\n * collapsed attributions button.\n * Instead of text, also an element (e.g. a `span` element) can be used.\n * @property {string} [expandClassName=className + '-expand'] CSS class name for the\n * collapsed attributions button.\n * @property {string|HTMLElement} [collapseLabel='»'] Text label to use\n * for the expanded attributions button.\n * Instead of text, also an element (e.g. a `span` element) can be used.\n * @property {string} [collapseClassName=className + '-collapse'] CSS class name for the\n * expanded attributions button.\n * @property {function(import(\"../MapEvent.js\").default):void} [render] Function called when\n * the control should be re-rendered. This is called in a `requestAnimationFrame`\n * callback.\n */\n\n/**\n * @classdesc\n * Control to show all the attributions associated with the layer sources\n * in the map. This control is one of the default controls included in maps.\n * By default it will show in the bottom right portion of the map, but this can\n * be changed by using a css selector for `.ol-attribution`.\n *\n * @api\n */\nclass Attribution extends Control {\n  /**\n   * @param {Options=} opt_options Attribution options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    super({\n      element: document.createElement('div'),\n      render: options.render,\n      target: options.target,\n    });\n\n    /**\n     * @private\n     * @type {HTMLElement}\n     */\n    this.ulElement_ = document.createElement('ul');\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.collapsed_ =\n      options.collapsed !== undefined ? options.collapsed : true;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.userCollapsed_ = this.collapsed_;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.overrideCollapsible_ = options.collapsible !== undefined;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.collapsible_ =\n      options.collapsible !== undefined ? options.collapsible : true;\n\n    if (!this.collapsible_) {\n      this.collapsed_ = false;\n    }\n\n    const className =\n      options.className !== undefined ? options.className : 'ol-attribution';\n\n    const tipLabel =\n      options.tipLabel !== undefined ? options.tipLabel : 'Attributions';\n\n    const expandClassName =\n      options.expandClassName !== undefined\n        ? options.expandClassName\n        : className + '-expand';\n\n    const collapseLabel =\n      options.collapseLabel !== undefined ? options.collapseLabel : '\\u00BB';\n\n    const collapseClassName =\n      options.collapseClassName !== undefined\n        ? options.collapseClassName\n        : className + '-collpase';\n\n    if (typeof collapseLabel === 'string') {\n      /**\n       * @private\n       * @type {HTMLElement}\n       */\n      this.collapseLabel_ = document.createElement('span');\n      this.collapseLabel_.textContent = collapseLabel;\n      this.collapseLabel_.className = collapseClassName;\n    } else {\n      this.collapseLabel_ = collapseLabel;\n    }\n\n    const label = options.label !== undefined ? options.label : 'i';\n\n    if (typeof label === 'string') {\n      /**\n       * @private\n       * @type {HTMLElement}\n       */\n      this.label_ = document.createElement('span');\n      this.label_.textContent = label;\n      this.label_.className = expandClassName;\n    } else {\n      this.label_ = label;\n    }\n\n    const activeLabel =\n      this.collapsible_ && !this.collapsed_ ? this.collapseLabel_ : this.label_;\n    const button = document.createElement('button');\n    button.setAttribute('type', 'button');\n    button.title = tipLabel;\n    button.appendChild(activeLabel);\n\n    button.addEventListener(\n      EventType.CLICK,\n      this.handleClick_.bind(this),\n      false\n    );\n\n    const cssClasses =\n      className +\n      ' ' +\n      CLASS_UNSELECTABLE +\n      ' ' +\n      CLASS_CONTROL +\n      (this.collapsed_ && this.collapsible_ ? ' ' + CLASS_COLLAPSED : '') +\n      (this.collapsible_ ? '' : ' ol-uncollapsible');\n    const element = this.element;\n    element.className = cssClasses;\n    element.appendChild(this.ulElement_);\n    element.appendChild(button);\n\n    /**\n     * A list of currently rendered resolutions.\n     * @type {Array<string>}\n     * @private\n     */\n    this.renderedAttributions_ = [];\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.renderedVisible_ = true;\n  }\n\n  /**\n   * Collect a list of visible attributions and set the collapsible state.\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   * @return {Array<string>} Attributions.\n   * @private\n   */\n  collectSourceAttributions_(frameState) {\n    /**\n     * Used to determine if an attribution already exists.\n     * @type {!Object<string, boolean>}\n     */\n    const lookup = {};\n\n    /**\n     * A list of visible attributions.\n     * @type {Array<string>}\n     */\n    const visibleAttributions = [];\n\n    let collapsible = true;\n    const layerStatesArray = frameState.layerStatesArray;\n    for (let i = 0, ii = layerStatesArray.length; i < ii; ++i) {\n      const layerState = layerStatesArray[i];\n      if (!inView(layerState, frameState.viewState)) {\n        continue;\n      }\n\n      const source = /** @type {import(\"../layer/Layer.js\").default} */ (layerState.layer).getSource();\n      if (!source) {\n        continue;\n      }\n\n      const attributionGetter = source.getAttributions();\n      if (!attributionGetter) {\n        continue;\n      }\n\n      const attributions = attributionGetter(frameState);\n      if (!attributions) {\n        continue;\n      }\n\n      collapsible =\n        collapsible && source.getAttributionsCollapsible() !== false;\n\n      if (Array.isArray(attributions)) {\n        for (let j = 0, jj = attributions.length; j < jj; ++j) {\n          if (!(attributions[j] in lookup)) {\n            visibleAttributions.push(attributions[j]);\n            lookup[attributions[j]] = true;\n          }\n        }\n      } else {\n        if (!(attributions in lookup)) {\n          visibleAttributions.push(attributions);\n          lookup[attributions] = true;\n        }\n      }\n    }\n    if (!this.overrideCollapsible_) {\n      this.setCollapsible(collapsible);\n    }\n    return visibleAttributions;\n  }\n\n  /**\n   * @private\n   * @param {?import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   */\n  updateElement_(frameState) {\n    if (!frameState) {\n      if (this.renderedVisible_) {\n        this.element.style.display = 'none';\n        this.renderedVisible_ = false;\n      }\n      return;\n    }\n\n    const attributions = this.collectSourceAttributions_(frameState);\n\n    const visible = attributions.length > 0;\n    if (this.renderedVisible_ != visible) {\n      this.element.style.display = visible ? '' : 'none';\n      this.renderedVisible_ = visible;\n    }\n\n    if (equals(attributions, this.renderedAttributions_)) {\n      return;\n    }\n\n    removeChildren(this.ulElement_);\n\n    // append the attributions\n    for (let i = 0, ii = attributions.length; i < ii; ++i) {\n      const element = document.createElement('li');\n      element.innerHTML = attributions[i];\n      this.ulElement_.appendChild(element);\n    }\n\n    this.renderedAttributions_ = attributions;\n  }\n\n  /**\n   * @param {MouseEvent} event The event to handle\n   * @private\n   */\n  handleClick_(event) {\n    event.preventDefault();\n    this.handleToggle_();\n    this.userCollapsed_ = this.collapsed_;\n  }\n\n  /**\n   * @private\n   */\n  handleToggle_() {\n    this.element.classList.toggle(CLASS_COLLAPSED);\n    if (this.collapsed_) {\n      replaceNode(this.collapseLabel_, this.label_);\n    } else {\n      replaceNode(this.label_, this.collapseLabel_);\n    }\n    this.collapsed_ = !this.collapsed_;\n  }\n\n  /**\n   * Return `true` if the attribution is collapsible, `false` otherwise.\n   * @return {boolean} True if the widget is collapsible.\n   * @api\n   */\n  getCollapsible() {\n    return this.collapsible_;\n  }\n\n  /**\n   * Set whether the attribution should be collapsible.\n   * @param {boolean} collapsible True if the widget is collapsible.\n   * @api\n   */\n  setCollapsible(collapsible) {\n    if (this.collapsible_ === collapsible) {\n      return;\n    }\n    this.collapsible_ = collapsible;\n    this.element.classList.toggle('ol-uncollapsible');\n    if (this.userCollapsed_) {\n      this.handleToggle_();\n    }\n  }\n\n  /**\n   * Collapse or expand the attribution according to the passed parameter. Will\n   * not do anything if the attribution isn't collapsible or if the current\n   * collapsed state is already the one requested.\n   * @param {boolean} collapsed True if the widget is collapsed.\n   * @api\n   */\n  setCollapsed(collapsed) {\n    this.userCollapsed_ = collapsed;\n    if (!this.collapsible_ || this.collapsed_ === collapsed) {\n      return;\n    }\n    this.handleToggle_();\n  }\n\n  /**\n   * Return `true` when the attribution is currently collapsed or `false`\n   * otherwise.\n   * @return {boolean} True if the widget is collapsed.\n   * @api\n   */\n  getCollapsed() {\n    return this.collapsed_;\n  }\n\n  /**\n   * Update the attribution element.\n   * @param {import(\"../MapEvent.js\").default} mapEvent Map event.\n   * @override\n   */\n  render(mapEvent) {\n    this.updateElement_(mapEvent.frameState);\n  }\n}\n\nexport default Attribution;\n","/**\n * @module ol/CollectionEventType\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  /**\n   * Triggered when an item is added to the collection.\n   * @event module:ol/Collection.CollectionEvent#add\n   * @api\n   */\n  ADD: 'add',\n  /**\n   * Triggered when an item is removed from the collection.\n   * @event module:ol/Collection.CollectionEvent#remove\n   * @api\n   */\n  REMOVE: 'remove',\n};\n","/**\n * @module ol/Collection\n */\nimport AssertionError from './AssertionError.js';\nimport BaseObject from './Object.js';\nimport CollectionEventType from './CollectionEventType.js';\nimport Event from './events/Event.js';\n\n/**\n * @enum {string}\n * @private\n */\nconst Property = {\n  LENGTH: 'length',\n};\n\n/**\n * @classdesc\n * Events emitted by {@link module:ol/Collection~Collection} instances are instances of this\n * type.\n */\nexport class CollectionEvent extends Event {\n  /**\n   * @param {import(\"./CollectionEventType.js\").default} type Type.\n   * @param {*=} opt_element Element.\n   * @param {number=} opt_index The index of the added or removed element.\n   */\n  constructor(type, opt_element, opt_index) {\n    super(type);\n\n    /**\n     * The element that is added to or removed from the collection.\n     * @type {*}\n     * @api\n     */\n    this.element = opt_element;\n\n    /**\n     * The index of the added or removed element.\n     * @type {number}\n     * @api\n     */\n    this.index = opt_index;\n  }\n}\n\n/**\n * @typedef {Object} Options\n * @property {boolean} [unique=false] Disallow the same item from being added to\n * the collection twice.\n */\n\n/**\n * @classdesc\n * An expanded version of standard JS Array, adding convenience methods for\n * manipulation. Add and remove changes to the Collection trigger a Collection\n * event. Note that this does not cover changes to the objects _within_ the\n * Collection; they trigger events on the appropriate object, not on the\n * Collection as a whole.\n *\n * @fires CollectionEvent\n *\n * @template T\n * @api\n */\nclass Collection extends BaseObject {\n  /**\n   * @param {Array<T>=} opt_array Array.\n   * @param {Options=} opt_options Collection options.\n   */\n  constructor(opt_array, opt_options) {\n    super();\n\n    const options = opt_options || {};\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.unique_ = !!options.unique;\n\n    /**\n     * @private\n     * @type {!Array<T>}\n     */\n    this.array_ = opt_array ? opt_array : [];\n\n    if (this.unique_) {\n      for (let i = 0, ii = this.array_.length; i < ii; ++i) {\n        this.assertUnique_(this.array_[i], i);\n      }\n    }\n\n    this.updateLength_();\n  }\n\n  /**\n   * Remove all elements from the collection.\n   * @api\n   */\n  clear() {\n    while (this.getLength() > 0) {\n      this.pop();\n    }\n  }\n\n  /**\n   * Add elements to the collection.  This pushes each item in the provided array\n   * to the end of the collection.\n   * @param {!Array<T>} arr Array.\n   * @return {Collection<T>} This collection.\n   * @api\n   */\n  extend(arr) {\n    for (let i = 0, ii = arr.length; i < ii; ++i) {\n      this.push(arr[i]);\n    }\n    return this;\n  }\n\n  /**\n   * Iterate over each element, calling the provided callback.\n   * @param {function(T, number, Array<T>): *} f The function to call\n   *     for every element. This function takes 3 arguments (the element, the\n   *     index and the array). The return value is ignored.\n   * @api\n   */\n  forEach(f) {\n    const array = this.array_;\n    for (let i = 0, ii = array.length; i < ii; ++i) {\n      f(array[i], i, array);\n    }\n  }\n\n  /**\n   * Get a reference to the underlying Array object. Warning: if the array\n   * is mutated, no events will be dispatched by the collection, and the\n   * collection's \"length\" property won't be in sync with the actual length\n   * of the array.\n   * @return {!Array<T>} Array.\n   * @api\n   */\n  getArray() {\n    return this.array_;\n  }\n\n  /**\n   * Get the element at the provided index.\n   * @param {number} index Index.\n   * @return {T} Element.\n   * @api\n   */\n  item(index) {\n    return this.array_[index];\n  }\n\n  /**\n   * Get the length of this collection.\n   * @return {number} The length of the array.\n   * @observable\n   * @api\n   */\n  getLength() {\n    return this.get(Property.LENGTH);\n  }\n\n  /**\n   * Insert an element at the provided index.\n   * @param {number} index Index.\n   * @param {T} elem Element.\n   * @api\n   */\n  insertAt(index, elem) {\n    if (this.unique_) {\n      this.assertUnique_(elem);\n    }\n    this.array_.splice(index, 0, elem);\n    this.updateLength_();\n    this.dispatchEvent(\n      new CollectionEvent(CollectionEventType.ADD, elem, index)\n    );\n  }\n\n  /**\n   * Remove the last element of the collection and return it.\n   * Return `undefined` if the collection is empty.\n   * @return {T|undefined} Element.\n   * @api\n   */\n  pop() {\n    return this.removeAt(this.getLength() - 1);\n  }\n\n  /**\n   * Insert the provided element at the end of the collection.\n   * @param {T} elem Element.\n   * @return {number} New length of the collection.\n   * @api\n   */\n  push(elem) {\n    if (this.unique_) {\n      this.assertUnique_(elem);\n    }\n    const n = this.getLength();\n    this.insertAt(n, elem);\n    return this.getLength();\n  }\n\n  /**\n   * Remove the first occurrence of an element from the collection.\n   * @param {T} elem Element.\n   * @return {T|undefined} The removed element or undefined if none found.\n   * @api\n   */\n  remove(elem) {\n    const arr = this.array_;\n    for (let i = 0, ii = arr.length; i < ii; ++i) {\n      if (arr[i] === elem) {\n        return this.removeAt(i);\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Remove the element at the provided index and return it.\n   * Return `undefined` if the collection does not contain this index.\n   * @param {number} index Index.\n   * @return {T|undefined} Value.\n   * @api\n   */\n  removeAt(index) {\n    const prev = this.array_[index];\n    this.array_.splice(index, 1);\n    this.updateLength_();\n    this.dispatchEvent(\n      new CollectionEvent(CollectionEventType.REMOVE, prev, index)\n    );\n    return prev;\n  }\n\n  /**\n   * Set the element at the provided index.\n   * @param {number} index Index.\n   * @param {T} elem Element.\n   * @api\n   */\n  setAt(index, elem) {\n    const n = this.getLength();\n    if (index < n) {\n      if (this.unique_) {\n        this.assertUnique_(elem, index);\n      }\n      const prev = this.array_[index];\n      this.array_[index] = elem;\n      this.dispatchEvent(\n        new CollectionEvent(CollectionEventType.REMOVE, prev, index)\n      );\n      this.dispatchEvent(\n        new CollectionEvent(CollectionEventType.ADD, elem, index)\n      );\n    } else {\n      for (let j = n; j < index; ++j) {\n        this.insertAt(j, undefined);\n      }\n      this.insertAt(index, elem);\n    }\n  }\n\n  /**\n   * @private\n   */\n  updateLength_() {\n    this.set(Property.LENGTH, this.array_.length);\n  }\n\n  /**\n   * @private\n   * @param {T} elem Element.\n   * @param {number=} opt_except Optional index to ignore.\n   */\n  assertUnique_(elem, opt_except) {\n    for (let i = 0, ii = this.array_.length; i < ii; ++i) {\n      if (this.array_[i] === elem && i !== opt_except) {\n        throw new AssertionError(58);\n      }\n    }\n  }\n}\n\nexport default Collection;\n","/**\n * @module ol/easing\n */\n\n/**\n * Start slow and speed up.\n * @param {number} t Input between 0 and 1.\n * @return {number} Output between 0 and 1.\n * @api\n */\nexport function easeIn(t) {\n  return Math.pow(t, 3);\n}\n\n/**\n * Start fast and slow down.\n * @param {number} t Input between 0 and 1.\n * @return {number} Output between 0 and 1.\n * @api\n */\nexport function easeOut(t) {\n  return 1 - easeIn(1 - t);\n}\n\n/**\n * Start slow, speed up, and then slow down again.\n * @param {number} t Input between 0 and 1.\n * @return {number} Output between 0 and 1.\n * @api\n */\nexport function inAndOut(t) {\n  return 3 * t * t - 2 * t * t * t;\n}\n\n/**\n * Maintain a constant speed over time.\n * @param {number} t Input between 0 and 1.\n * @return {number} Output between 0 and 1.\n * @api\n */\nexport function linear(t) {\n  return t;\n}\n\n/**\n * Start slow, speed up, and at the very end slow down again.  This has the\n * same general behavior as {@link module:ol/easing~inAndOut}, but the final\n * slowdown is delayed.\n * @param {number} t Input between 0 and 1.\n * @return {number} Output between 0 and 1.\n * @api\n */\nexport function upAndDown(t) {\n  if (t < 0.5) {\n    return inAndOut(2 * t);\n  } else {\n    return 1 - inAndOut(2 * (t - 0.5));\n  }\n}\n","/**\n * @module ol/control/Rotate\n */\nimport Control from './Control.js';\nimport EventType from '../events/EventType.js';\nimport {CLASS_CONTROL, CLASS_HIDDEN, CLASS_UNSELECTABLE} from '../css.js';\nimport {easeOut} from '../easing.js';\n\n/**\n * @typedef {Object} Options\n * @property {string} [className='ol-rotate'] CSS class name.\n * @property {string|HTMLElement} [label='⇧'] Text label to use for the rotate button.\n * Instead of text, also an element (e.g. a `span` element) can be used.\n * @property {string} [tipLabel='Reset rotation'] Text label to use for the rotate tip.\n * @property {string} [compassClassName='ol-compass'] CSS class name for the compass.\n * @property {number} [duration=250] Animation duration in milliseconds.\n * @property {boolean} [autoHide=true] Hide the control when rotation is 0.\n * @property {function(import(\"../MapEvent.js\").default):void} [render] Function called when the control should\n * be re-rendered. This is called in a `requestAnimationFrame` callback.\n * @property {function():void} [resetNorth] Function called when the control is clicked.\n * This will override the default `resetNorth`.\n * @property {HTMLElement|string} [target] Specify a target if you want the control to be\n * rendered outside of the map's viewport.\n */\n\n/**\n * @classdesc\n * A button control to reset rotation to 0.\n * To style this control use css selector `.ol-rotate`. A `.ol-hidden` css\n * selector is added to the button when the rotation is 0.\n *\n * @api\n */\nclass Rotate extends Control {\n  /**\n   * @param {Options=} opt_options Rotate options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    super({\n      element: document.createElement('div'),\n      render: options.render,\n      target: options.target,\n    });\n\n    const className =\n      options.className !== undefined ? options.className : 'ol-rotate';\n\n    const label = options.label !== undefined ? options.label : '\\u21E7';\n\n    const compassClassName =\n      options.compassClassName !== undefined\n        ? options.compassClassName\n        : 'ol-compass';\n\n    /**\n     * @type {HTMLElement}\n     * @private\n     */\n    this.label_ = null;\n\n    if (typeof label === 'string') {\n      this.label_ = document.createElement('span');\n      this.label_.className = compassClassName;\n      this.label_.textContent = label;\n    } else {\n      this.label_ = label;\n      this.label_.classList.add(compassClassName);\n    }\n\n    const tipLabel = options.tipLabel ? options.tipLabel : 'Reset rotation';\n\n    const button = document.createElement('button');\n    button.className = className + '-reset';\n    button.setAttribute('type', 'button');\n    button.title = tipLabel;\n    button.appendChild(this.label_);\n\n    button.addEventListener(\n      EventType.CLICK,\n      this.handleClick_.bind(this),\n      false\n    );\n\n    const cssClasses =\n      className + ' ' + CLASS_UNSELECTABLE + ' ' + CLASS_CONTROL;\n    const element = this.element;\n    element.className = cssClasses;\n    element.appendChild(button);\n\n    this.callResetNorth_ = options.resetNorth ? options.resetNorth : undefined;\n\n    /**\n     * @type {number}\n     * @private\n     */\n    this.duration_ = options.duration !== undefined ? options.duration : 250;\n\n    /**\n     * @type {boolean}\n     * @private\n     */\n    this.autoHide_ = options.autoHide !== undefined ? options.autoHide : true;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.rotation_ = undefined;\n\n    if (this.autoHide_) {\n      this.element.classList.add(CLASS_HIDDEN);\n    }\n  }\n\n  /**\n   * @param {MouseEvent} event The event to handle\n   * @private\n   */\n  handleClick_(event) {\n    event.preventDefault();\n    if (this.callResetNorth_ !== undefined) {\n      this.callResetNorth_();\n    } else {\n      this.resetNorth_();\n    }\n  }\n\n  /**\n   * @private\n   */\n  resetNorth_() {\n    const map = this.getMap();\n    const view = map.getView();\n    if (!view) {\n      // the map does not have a view, so we can't act\n      // upon it\n      return;\n    }\n    const rotation = view.getRotation();\n    if (rotation !== undefined) {\n      if (this.duration_ > 0 && rotation % (2 * Math.PI) !== 0) {\n        view.animate({\n          rotation: 0,\n          duration: this.duration_,\n          easing: easeOut,\n        });\n      } else {\n        view.setRotation(0);\n      }\n    }\n  }\n\n  /**\n   * Update the rotate control element.\n   * @param {import(\"../MapEvent.js\").default} mapEvent Map event.\n   * @override\n   */\n  render(mapEvent) {\n    const frameState = mapEvent.frameState;\n    if (!frameState) {\n      return;\n    }\n    const rotation = frameState.viewState.rotation;\n    if (rotation != this.rotation_) {\n      const transform = 'rotate(' + rotation + 'rad)';\n      if (this.autoHide_) {\n        const contains = this.element.classList.contains(CLASS_HIDDEN);\n        if (!contains && rotation === 0) {\n          this.element.classList.add(CLASS_HIDDEN);\n        } else if (contains && rotation !== 0) {\n          this.element.classList.remove(CLASS_HIDDEN);\n        }\n      }\n      this.label_.style.transform = transform;\n    }\n    this.rotation_ = rotation;\n  }\n}\n\nexport default Rotate;\n","/**\n * @module ol/control/Zoom\n */\nimport Control from './Control.js';\nimport EventType from '../events/EventType.js';\nimport {CLASS_CONTROL, CLASS_UNSELECTABLE} from '../css.js';\nimport {easeOut} from '../easing.js';\n\n/**\n * @typedef {Object} Options\n * @property {number} [duration=250] Animation duration in milliseconds.\n * @property {string} [className='ol-zoom'] CSS class name.\n * @property {string} [zoomInClassName=className + '-in'] CSS class name for the zoom-in button.\n * @property {string} [zoomOutClassName=className + '-out'] CSS class name for the zoom-out button.\n * @property {string|HTMLElement} [zoomInLabel='+'] Text label to use for the zoom-in\n * button. Instead of text, also an element (e.g. a `span` element) can be used.\n * @property {string|HTMLElement} [zoomOutLabel='-'] Text label to use for the zoom-out button.\n * Instead of text, also an element (e.g. a `span` element) can be used.\n * @property {string} [zoomInTipLabel='Zoom in'] Text label to use for the button tip.\n * @property {string} [zoomOutTipLabel='Zoom out'] Text label to use for the button tip.\n * @property {number} [delta=1] The zoom delta applied on each click.\n * @property {HTMLElement|string} [target] Specify a target if you want the control to be\n * rendered outside of the map's viewport.\n */\n\n/**\n * @classdesc\n * A control with 2 buttons, one for zoom in and one for zoom out.\n * This control is one of the default controls of a map. To style this control\n * use css selectors `.ol-zoom-in` and `.ol-zoom-out`.\n *\n * @api\n */\nclass Zoom extends Control {\n  /**\n   * @param {Options=} opt_options Zoom options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    super({\n      element: document.createElement('div'),\n      target: options.target,\n    });\n\n    const className =\n      options.className !== undefined ? options.className : 'ol-zoom';\n\n    const delta = options.delta !== undefined ? options.delta : 1;\n\n    const zoomInClassName =\n      options.zoomInClassName !== undefined\n        ? options.zoomInClassName\n        : className + '-in';\n\n    const zoomOutClassName =\n      options.zoomOutClassName !== undefined\n        ? options.zoomOutClassName\n        : className + '-out';\n\n    const zoomInLabel =\n      options.zoomInLabel !== undefined ? options.zoomInLabel : '+';\n    const zoomOutLabel =\n      options.zoomOutLabel !== undefined ? options.zoomOutLabel : '\\u2212';\n\n    const zoomInTipLabel =\n      options.zoomInTipLabel !== undefined ? options.zoomInTipLabel : 'Zoom in';\n    const zoomOutTipLabel =\n      options.zoomOutTipLabel !== undefined\n        ? options.zoomOutTipLabel\n        : 'Zoom out';\n\n    const inElement = document.createElement('button');\n    inElement.className = zoomInClassName;\n    inElement.setAttribute('type', 'button');\n    inElement.title = zoomInTipLabel;\n    inElement.appendChild(\n      typeof zoomInLabel === 'string'\n        ? document.createTextNode(zoomInLabel)\n        : zoomInLabel\n    );\n\n    inElement.addEventListener(\n      EventType.CLICK,\n      this.handleClick_.bind(this, delta),\n      false\n    );\n\n    const outElement = document.createElement('button');\n    outElement.className = zoomOutClassName;\n    outElement.setAttribute('type', 'button');\n    outElement.title = zoomOutTipLabel;\n    outElement.appendChild(\n      typeof zoomOutLabel === 'string'\n        ? document.createTextNode(zoomOutLabel)\n        : zoomOutLabel\n    );\n\n    outElement.addEventListener(\n      EventType.CLICK,\n      this.handleClick_.bind(this, -delta),\n      false\n    );\n\n    const cssClasses =\n      className + ' ' + CLASS_UNSELECTABLE + ' ' + CLASS_CONTROL;\n    const element = this.element;\n    element.className = cssClasses;\n    element.appendChild(inElement);\n    element.appendChild(outElement);\n\n    /**\n     * @type {number}\n     * @private\n     */\n    this.duration_ = options.duration !== undefined ? options.duration : 250;\n  }\n\n  /**\n   * @param {number} delta Zoom delta.\n   * @param {MouseEvent} event The event to handle\n   * @private\n   */\n  handleClick_(delta, event) {\n    event.preventDefault();\n    this.zoomByDelta_(delta);\n  }\n\n  /**\n   * @param {number} delta Zoom delta.\n   * @private\n   */\n  zoomByDelta_(delta) {\n    const map = this.getMap();\n    const view = map.getView();\n    if (!view) {\n      // the map does not have a view, so we can't act\n      // upon it\n      return;\n    }\n    const currentZoom = view.getZoom();\n    if (currentZoom !== undefined) {\n      const newZoom = view.getConstrainedZoom(currentZoom + delta);\n      if (this.duration_ > 0) {\n        if (view.getAnimating()) {\n          view.cancelAnimations();\n        }\n        view.animate({\n          zoom: newZoom,\n          duration: this.duration_,\n          easing: easeOut,\n        });\n      } else {\n        view.setZoom(newZoom);\n      }\n    }\n  }\n}\n\nexport default Zoom;\n","/**\n * @module ol/proj/Units\n */\n\n/**\n * Projection units: `'degrees'`, `'ft'`, `'m'`, `'pixels'`, `'tile-pixels'` or\n * `'us-ft'`.\n * @enum {string}\n */\nconst Units = {\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/**\n * Meters per unit lookup table.\n * @const\n * @type {Object<Units, number>}\n * @api\n */\nexport const METERS_PER_UNIT = {};\n// use the radius of the Normal sphere\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;\n\nexport default Units;\n","/**\n * @module ol/proj/Projection\n */\nimport {METERS_PER_UNIT} from './Units.js';\n\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 an `{import(\"../coordinate.js\").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} function will be used.\n */\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 */\nclass Projection {\n  /**\n   * @param {Options} options Projection options.\n   */\n  constructor(options) {\n    /**\n     * @private\n     * @type {string}\n     */\n    this.code_ = options.code;\n\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    /**\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    /**\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    /**\n     * @private\n     * @type {string}\n     */\n    this.axisOrientation_ =\n      options.axisOrientation !== undefined ? options.axisOrientation : 'enu';\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.global_ = options.global !== undefined ? options.global : false;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.canWrapX_ = !!(this.global_ && this.extent_);\n\n    /**\n     * @private\n     * @type {function(number, import(\"../coordinate.js\").Coordinate):number|undefined}\n     */\n    this.getPointResolutionFunc_ = options.getPointResolution;\n\n    /**\n     * @private\n     * @type {import(\"../tilegrid/TileGrid.js\").default}\n     */\n    this.defaultTileGrid_ = null;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.metersPerUnit_ = options.metersPerUnit;\n  }\n\n  /**\n   * @return {boolean} The projection is suitable for wrapping the x-axis\n   */\n  canWrapX() {\n    return this.canWrapX_;\n  }\n\n  /**\n   * Get the code for this projection, e.g. 'EPSG:4326'.\n   * @return {string} Code.\n   * @api\n   */\n  getCode() {\n    return this.code_;\n  }\n\n  /**\n   * Get the validity extent for this projection.\n   * @return {import(\"../extent.js\").Extent} Extent.\n   * @api\n   */\n  getExtent() {\n    return this.extent_;\n  }\n\n  /**\n   * Get the units of this projection.\n   * @return {import(\"./Units.js\").default} Units.\n   * @api\n   */\n  getUnits() {\n    return this.units_;\n  }\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  getMetersPerUnit() {\n    return this.metersPerUnit_ || METERS_PER_UNIT[this.units_];\n  }\n\n  /**\n   * Get the world extent for this projection.\n   * @return {import(\"../extent.js\").Extent} Extent.\n   * @api\n   */\n  getWorldExtent() {\n    return this.worldExtent_;\n  }\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  getAxisOrientation() {\n    return this.axisOrientation_;\n  }\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  isGlobal() {\n    return this.global_;\n  }\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  setGlobal(global) {\n    this.global_ = global;\n    this.canWrapX_ = !!(global && this.extent_);\n  }\n\n  /**\n   * @return {import(\"../tilegrid/TileGrid.js\").default} The default tile grid.\n   */\n  getDefaultTileGrid() {\n    return this.defaultTileGrid_;\n  }\n\n  /**\n   * @param {import(\"../tilegrid/TileGrid.js\").default} tileGrid The default tile grid.\n   */\n  setDefaultTileGrid(tileGrid) {\n    this.defaultTileGrid_ = tileGrid;\n  }\n\n  /**\n   * Set the validity extent for this projection.\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @api\n   */\n  setExtent(extent) {\n    this.extent_ = extent;\n    this.canWrapX_ = !!(this.global_ && extent);\n  }\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  setWorldExtent(worldExtent) {\n    this.worldExtent_ = worldExtent;\n  }\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  setGetPointResolution(func) {\n    this.getPointResolutionFunc_ = func;\n  }\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  getPointResolutionFunc() {\n    return this.getPointResolutionFunc_;\n  }\n}\n\nexport default Projection;\n","/**\n * @module ol/proj/epsg3857\n */\nimport Projection from './Projection.js';\nimport Units from './Units.js';\nimport {cosh} from '../math.js';\n\n/**\n * Radius of WGS84 sphere\n *\n * @const\n * @type {number}\n */\nexport const RADIUS = 6378137;\n\n/**\n * @const\n * @type {number}\n */\nexport const HALF_SIZE = Math.PI * RADIUS;\n\n/**\n * @const\n * @type {import(\"../extent.js\").Extent}\n */\nexport const EXTENT = [-HALF_SIZE, -HALF_SIZE, HALF_SIZE, HALF_SIZE];\n\n/**\n * @const\n * @type {import(\"../extent.js\").Extent}\n */\nexport const WORLD_EXTENT = [-180, -85, 180, 85];\n\n/**\n * Maximum safe value in y direction\n * @const\n * @type {number}\n */\nexport const MAX_SAFE_Y = RADIUS * Math.log(Math.tan(Math.PI / 2));\n\n/**\n * @classdesc\n * Projection object for web/spherical Mercator (EPSG:3857).\n */\nclass EPSG3857Projection extends Projection {\n  /**\n   * @param {string} code Code.\n   */\n  constructor(code) {\n    super({\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    });\n  }\n}\n\n/**\n * Projections equal to EPSG:3857.\n *\n * @const\n * @type {Array<import(\"./Projection.js\").default>}\n */\nexport const 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/gml/srs/epsg.xml#3857'),\n];\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  const length = input.length;\n  const dimension = opt_dimension > 1 ? opt_dimension : 2;\n  let output = opt_output;\n  if (output === undefined) {\n    if (dimension > 2) {\n      // preserve values beyond second dimension\n      output = input.slice();\n    } else {\n      output = new Array(length);\n    }\n  }\n  for (let i = 0; i < length; i += dimension) {\n    output[i] = (HALF_SIZE * input[i]) / 180;\n    let 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    } else if (y < -MAX_SAFE_Y) {\n      y = -MAX_SAFE_Y;\n    }\n    output[i + 1] = y;\n  }\n  return output;\n}\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  const length = input.length;\n  const dimension = opt_dimension > 1 ? opt_dimension : 2;\n  let output = opt_output;\n  if (output === undefined) {\n    if (dimension > 2) {\n      // preserve values beyond second dimension\n      output = input.slice();\n    } else {\n      output = new Array(length);\n    }\n  }\n  for (let 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","/**\n * @module ol/proj/epsg4326\n */\nimport Projection from './Projection.js';\nimport Units from './Units.js';\n\n/**\n * Semi-major radius of the WGS84 ellipsoid.\n *\n * @const\n * @type {number}\n */\nexport const RADIUS = 6378137;\n\n/**\n * Extent of the EPSG:4326 projection which is the whole world.\n *\n * @const\n * @type {import(\"../extent.js\").Extent}\n */\nexport const EXTENT = [-180, -90, 180, 90];\n\n/**\n * @const\n * @type {number}\n */\nexport const METERS_PER_UNIT = (Math.PI * RADIUS) / 180;\n\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 */\nclass EPSG4326Projection extends Projection {\n  /**\n   * @param {string} code Code.\n   * @param {string=} opt_axisOrientation Axis orientation.\n   */\n  constructor(code, opt_axisOrientation) {\n    super({\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    });\n  }\n}\n\n/**\n * Projections equal to EPSG:4326.\n *\n * @const\n * @type {Array<import(\"./Projection.js\").default>}\n */\nexport const 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/gml/srs/epsg.xml#4326', 'neu'),\n];\n","/**\n * @module ol/proj/projections\n */\n\n/**\n * @type {Object<string, import(\"./Projection.js\").default>}\n */\nlet cache = {};\n\n/**\n * Clear the projections cache.\n */\nexport function clear() {\n  cache = {};\n}\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 (\n    cache[code] ||\n    cache[code.replace(/urn:(x-)?ogc:def:crs:EPSG:(.*:)?(\\w+)$/, 'EPSG:$3')] ||\n    null\n  );\n}\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","/**\n * @module ol/proj/transforms\n */\nimport {isEmpty} from '../obj.js';\n\n/**\n * @private\n * @type {!Object<string, Object<string, import(\"../proj.js\").TransformFunction>>}\n */\nlet transforms = {};\n\n/**\n * Clear the transform cache.\n */\nexport function clear() {\n  transforms = {};\n}\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  const sourceCode = source.getCode();\n  const destinationCode = destination.getCode();\n  if (!(sourceCode in transforms)) {\n    transforms[sourceCode] = {};\n  }\n  transforms[sourceCode][destinationCode] = transformFn;\n}\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  const sourceCode = source.getCode();\n  const destinationCode = destination.getCode();\n  const 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/**\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  let transform;\n  if (sourceCode in transforms && destinationCode in transforms[sourceCode]) {\n    transform = transforms[sourceCode][destinationCode];\n  }\n  return transform;\n}\n","/**\n * @module ol/extent/Corner\n */\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","/**\n * @module ol/extent/Relationship\n */\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","/**\n * @module ol/extent\n */\nimport Corner from './extent/Corner.js';\nimport Relationship from './extent/Relationship.js';\nimport {assert} from './asserts.js';\n\n/**\n * An array of numbers representing an extent: `[minx, miny, maxx, maxy]`.\n * @typedef {Array<number>} Extent\n * @api\n */\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  const extent = createEmpty();\n  for (let i = 0, ii = coordinates.length; i < ii; ++i) {\n    extendCoordinate(extent, coordinates[i]);\n  }\n  return extent;\n}\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  const minX = Math.min.apply(null, xs);\n  const minY = Math.min.apply(null, ys);\n  const maxX = Math.max.apply(null, xs);\n  const maxY = Math.max.apply(null, ys);\n  return createOrUpdate(minX, minY, maxX, maxY, opt_extent);\n}\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  } else {\n    return [\n      extent[0] - value,\n      extent[1] - value,\n      extent[2] + value,\n      extent[3] + value,\n    ];\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  } else {\n    return extent.slice();\n  }\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  let dx, dy;\n  if (x < extent[0]) {\n    dx = extent[0] - x;\n  } else if (extent[2] < x) {\n    dx = x - extent[2];\n  } else {\n    dx = 0;\n  }\n  if (y < extent[1]) {\n    dy = extent[1] - y;\n  } else if (extent[3] < y) {\n    dy = y - extent[3];\n  } else {\n    dy = 0;\n  }\n  return dx * dx + dy * dy;\n}\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/**\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 (\n    extent1[0] <= extent2[0] &&\n    extent2[2] <= extent1[2] &&\n    extent1[1] <= extent2[1] &&\n    extent2[3] <= extent1[3]\n  );\n}\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/**\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  const minX = extent[0];\n  const minY = extent[1];\n  const maxX = extent[2];\n  const maxY = extent[3];\n  const x = coordinate[0];\n  const y = coordinate[1];\n  let relationship = Relationship.UNKNOWN;\n  if (x < minX) {\n    relationship = relationship | Relationship.LEFT;\n  } else if (x > maxX) {\n    relationship = relationship | Relationship.RIGHT;\n  }\n  if (y < minY) {\n    relationship = relationship | Relationship.BELOW;\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/**\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/**\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  } else {\n    return [minX, minY, maxX, maxY];\n  }\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/**\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  const x = coordinate[0];\n  const y = coordinate[1];\n  return createOrUpdate(x, y, x, y, opt_extent);\n}\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  const extent = createOrUpdateEmpty(opt_extent);\n  return extendCoordinates(extent, coordinates);\n}\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {Extent=} opt_extent Extent.\n * @return {Extent} Extent.\n */\nexport function createOrUpdateFromFlatCoordinates(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  opt_extent\n) {\n  const extent = createOrUpdateEmpty(opt_extent);\n  return extendFlatCoordinates(extent, flatCoordinates, offset, end, stride);\n}\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  const extent = createOrUpdateEmpty(opt_extent);\n  return extendRings(extent, rings);\n}\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 (\n    extent1[0] == extent2[0] &&\n    extent1[2] == extent2[2] &&\n    extent1[1] == extent2[1] &&\n    extent1[3] == extent2[3]\n  );\n}\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 (\n    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\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/**\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/**\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 (let i = 0, ii = coordinates.length; i < ii; ++i) {\n    extendCoordinate(extent, coordinates[i]);\n  }\n  return extent;\n}\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(\n  extent,\n  flatCoordinates,\n  offset,\n  end,\n  stride\n) {\n  for (; offset < end; offset += stride) {\n    extendXY(extent, flatCoordinates[offset], flatCoordinates[offset + 1]);\n  }\n  return extent;\n}\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 (let i = 0, ii = rings.length; i < ii; ++i) {\n    extendCoordinates(extent, rings[i]);\n  }\n  return extent;\n}\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/**\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  let 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/**\n * Get the size of an extent.\n * @param {Extent} extent Extent.\n * @return {number} Area.\n * @api\n */\nexport function getArea(extent) {\n  let area = 0;\n  if (!isEmpty(extent)) {\n    area = getWidth(extent) * getHeight(extent);\n  }\n  return area;\n}\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/**\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/**\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/**\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  let coordinate;\n  if (corner === Corner.BOTTOM_LEFT) {\n    coordinate = getBottomLeft(extent);\n  } else if (corner === Corner.BOTTOM_RIGHT) {\n    coordinate = getBottomRight(extent);\n  } else if (corner === Corner.TOP_LEFT) {\n    coordinate = getTopLeft(extent);\n  } else if (corner === Corner.TOP_RIGHT) {\n    coordinate = getTopRight(extent);\n  } else {\n    assert(false, 13); // Invalid corner\n  }\n  return coordinate;\n}\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  const minX = Math.min(extent1[0], extent2[0]);\n  const minY = Math.min(extent1[1], extent2[1]);\n  const maxX = Math.max(extent1[2], extent2[2]);\n  const maxY = Math.max(extent1[3], extent2[3]);\n  return (maxX - minX) * (maxY - minY);\n}\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(\n  center,\n  resolution,\n  rotation,\n  size,\n  opt_extent\n) {\n  const dx = (resolution * size[0]) / 2;\n  const dy = (resolution * size[1]) / 2;\n  const cosRotation = Math.cos(rotation);\n  const sinRotation = Math.sin(rotation);\n  const xCos = dx * cosRotation;\n  const xSin = dx * sinRotation;\n  const yCos = dy * cosRotation;\n  const ySin = dy * sinRotation;\n  const x = center[0];\n  const y = center[1];\n  const x0 = x - xCos + ySin;\n  const x1 = x - xCos - ySin;\n  const x2 = x + xCos - ySin;\n  const x3 = x + xCos + ySin;\n  const y0 = y - xSin - yCos;\n  const y1 = y - xSin + yCos;\n  const y2 = y + xSin + yCos;\n  const y3 = y + xSin - yCos;\n  return createOrUpdate(\n    Math.min(x0, x1, x2, x3),\n    Math.min(y0, y1, y2, y3),\n    Math.max(x0, x1, x2, x3),\n    Math.max(y0, y1, y2, y3),\n    opt_extent\n  );\n}\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/**\n * @param {Extent} extent1 Extent 1.\n * @param {Extent} extent2 Extent 2.\n * @return {number} Intersection area.\n */\nexport function getIntersectionArea(extent1, extent2) {\n  const intersection = getIntersection(extent1, extent2);\n  return getArea(intersection);\n}\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  const intersection = opt_extent ? opt_extent : createEmpty();\n  if (intersects(extent1, extent2)) {\n    if (extent1[0] > extent2[0]) {\n      intersection[0] = extent1[0];\n    } else {\n      intersection[0] = extent2[0];\n    }\n    if (extent1[1] > extent2[1]) {\n      intersection[1] = extent1[1];\n    } else {\n      intersection[1] = extent2[1];\n    }\n    if (extent1[2] < extent2[2]) {\n      intersection[2] = extent1[2];\n    } else {\n      intersection[2] = extent2[2];\n    }\n    if (extent1[3] < extent2[3]) {\n      intersection[3] = extent1[3];\n    } else {\n      intersection[3] = extent2[3];\n    }\n  } else {\n    createOrUpdateEmpty(intersection);\n  }\n  return intersection;\n}\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/**\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/**\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/**\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/**\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/**\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 (\n    extent1[0] <= extent2[2] &&\n    extent1[2] >= extent2[0] &&\n    extent1[1] <= extent2[3] &&\n    extent1[3] >= extent2[1]\n  );\n}\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/**\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  } else {\n    return extent;\n  }\n}\n\n/**\n * @param {Extent} extent Extent.\n * @param {number} value Value.\n */\nexport function scaleFromCenter(extent, value) {\n  const deltaX = ((extent[2] - extent[0]) / 2) * (value - 1);\n  const 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/**\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  let intersects = false;\n  const startRel = coordinateRelationship(extent, start);\n  const endRel = coordinateRelationship(extent, end);\n  if (\n    startRel === Relationship.INTERSECTING ||\n    endRel === Relationship.INTERSECTING\n  ) {\n    intersects = true;\n  } else {\n    const minX = extent[0];\n    const minY = extent[1];\n    const maxX = extent[2];\n    const maxY = extent[3];\n    const startX = start[0];\n    const startY = start[1];\n    const endX = end[0];\n    const endY = end[1];\n    const slope = (endY - startY) / (endX - startX);\n    let x, y;\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 (\n      !intersects &&\n      !!(endRel & Relationship.RIGHT) &&\n      !(startRel & Relationship.RIGHT)\n    ) {\n      // potentially intersects right\n      y = endY - (endX - maxX) * slope;\n      intersects = y >= minY && y <= maxY;\n    }\n    if (\n      !intersects &&\n      !!(endRel & Relationship.BELOW) &&\n      !(startRel & Relationship.BELOW)\n    ) {\n      // potentially intersects bottom\n      x = endX - (endY - minY) / slope;\n      intersects = x >= minX && x <= maxX;\n    }\n    if (\n      !intersects &&\n      !!(endRel & Relationship.LEFT) &&\n      !(startRel & Relationship.LEFT)\n    ) {\n      // potentially intersects left\n      y = endY - (endX - minX) * slope;\n      intersects = y >= minY && y <= maxY;\n    }\n  }\n  return intersects;\n}\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  let coordinates = [];\n  if (opt_stops > 1) {\n    const width = extent[2] - extent[0];\n    const height = extent[3] - extent[1];\n    for (let i = 0; i < opt_stops; ++i) {\n      coordinates.push(\n        extent[0] + (width * i) / opt_stops,\n        extent[1],\n        extent[2],\n        extent[1] + (height * i) / opt_stops,\n        extent[2] - (width * i) / opt_stops,\n        extent[3],\n        extent[0],\n        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  const xs = [];\n  const ys = [];\n  for (let 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/**\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  const projectionExtent = projection.getExtent();\n  const center = getCenter(extent);\n  if (\n    projection.canWrapX() &&\n    (center[0] < projectionExtent[0] || center[0] >= projectionExtent[2])\n  ) {\n    const worldWidth = getWidth(projectionExtent);\n    const worldsAway = Math.floor(\n      (center[0] - projectionExtent[0]) / worldWidth\n    );\n    const offset = worldsAway * worldWidth;\n    extent[0] -= offset;\n    extent[2] -= offset;\n  }\n  return extent;\n}\n","/**\n * @module ol/geom/GeometryType\n */\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","/**\n * @module ol/sphere\n */\nimport GeometryType from './geom/GeometryType.js';\nimport {toDegrees, toRadians} from './math.js';\n\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/**\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 const DEFAULT_RADIUS = 6371008.8;\n\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  const radius = opt_radius || DEFAULT_RADIUS;\n  const lat1 = toRadians(c1[1]);\n  const lat2 = toRadians(c2[1]);\n  const deltaLatBy2 = (lat2 - lat1) / 2;\n  const deltaLonBy2 = toRadians(c2[0] - c1[0]) / 2;\n  const a =\n    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/**\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  let length = 0;\n  for (let 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/**\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  const options = opt_options || {};\n  const radius = options.radius || DEFAULT_RADIUS;\n  const projection = options.projection || 'EPSG:3857';\n  const type = geometry.getType();\n  if (type !== GeometryType.GEOMETRY_COLLECTION) {\n    geometry = geometry.clone().transform(projection, 'EPSG:4326');\n  }\n  let length = 0;\n  let 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      const geometries = /** @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/**\n * Returns the spherical area for a list of coordinates.\n *\n * [Reference](https://trs-new.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  let area = 0;\n  const len = coordinates.length;\n  let x1 = coordinates[len - 1][0];\n  let y1 = coordinates[len - 1][1];\n  for (let i = 0; i < len; i++) {\n    const x2 = coordinates[i][0];\n    const 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/**\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  const options = opt_options || {};\n  const radius = options.radius || DEFAULT_RADIUS;\n  const projection = options.projection || 'EPSG:3857';\n  const type = geometry.getType();\n  if (type !== GeometryType.GEOMETRY_COLLECTION) {\n    geometry = geometry.clone().transform(projection, 'EPSG:4326');\n  }\n  let area = 0;\n  let 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      const geometries = /** @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/**\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  const radius = opt_radius || DEFAULT_RADIUS;\n  const lat1 = toRadians(c1[1]);\n  const lon1 = toRadians(c1[0]);\n  const dByR = distance / radius;\n  const lat = Math.asin(\n    Math.sin(lat1) * Math.cos(dByR) +\n      Math.cos(lat1) * Math.sin(dByR) * Math.cos(bearing)\n  );\n  const lon =\n    lon1 +\n    Math.atan2(\n      Math.sin(bearing) * Math.sin(dByR) * Math.cos(lat1),\n      Math.cos(dByR) - Math.sin(lat1) * Math.sin(lat)\n    );\n  return [toDegrees(lon), toDegrees(lat)];\n}\n","/**\n * @module ol/coordinate\n */\nimport {getWidth} from './extent.js';\nimport {modulo} from './math.js';\nimport {padNumber} from './string.js';\n\n/**\n * An array of numbers representing an xy coordinate. Example: `[16, 48]`.\n * @typedef {Array<number>} Coordinate\n * @api\n */\n\n/**\n * A function that takes a {@link module:ol/coordinate~Coordinate} and\n * transforms it into a `{string}`.\n *\n * @typedef {function((Coordinate|undefined)): string} CoordinateFormat\n * @api\n */\n\n/**\n * Add `delta` to `coordinate`. `coordinate` is modified in place and returned\n * by the function.\n *\n * Example:\n *\n *     import {add} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     add(coord, [-2, 4]);\n *     // coord is now [5.85, 51.983333]\n *\n * @param {Coordinate} coordinate Coordinate.\n * @param {Coordinate} delta Delta.\n * @return {Coordinate} The input coordinate adjusted by\n * the given delta.\n * @api\n */\nexport function add(coordinate, delta) {\n  coordinate[0] += +delta[0];\n  coordinate[1] += +delta[1];\n  return coordinate;\n}\n\n/**\n * Calculates the point closest to the passed coordinate on the passed circle.\n *\n * @param {Coordinate} coordinate The coordinate.\n * @param {import(\"./geom/Circle.js\").default} circle The circle.\n * @return {Coordinate} Closest point on the circumference.\n */\nexport function closestOnCircle(coordinate, circle) {\n  const r = circle.getRadius();\n  const center = circle.getCenter();\n  const x0 = center[0];\n  const y0 = center[1];\n  const x1 = coordinate[0];\n  const y1 = coordinate[1];\n\n  let dx = x1 - x0;\n  const dy = y1 - y0;\n  if (dx === 0 && dy === 0) {\n    dx = 1;\n  }\n  const d = Math.sqrt(dx * dx + dy * dy);\n\n  const x = x0 + (r * dx) / d;\n  const y = y0 + (r * dy) / d;\n\n  return [x, y];\n}\n\n/**\n * Calculates the point closest to the passed coordinate on the passed segment.\n * This is the foot of the perpendicular of the coordinate to the segment when\n * the foot is on the segment, or the closest segment coordinate when the foot\n * is outside the segment.\n *\n * @param {Coordinate} coordinate The coordinate.\n * @param {Array<Coordinate>} segment The two coordinates\n * of the segment.\n * @return {Coordinate} The foot of the perpendicular of\n * the coordinate to the segment.\n */\nexport function closestOnSegment(coordinate, segment) {\n  const x0 = coordinate[0];\n  const y0 = coordinate[1];\n  const start = segment[0];\n  const end = segment[1];\n  const x1 = start[0];\n  const y1 = start[1];\n  const x2 = end[0];\n  const y2 = end[1];\n  const dx = x2 - x1;\n  const dy = y2 - y1;\n  const along =\n    dx === 0 && dy === 0\n      ? 0\n      : (dx * (x0 - x1) + dy * (y0 - y1)) / (dx * dx + dy * dy || 0);\n  let x, y;\n  if (along <= 0) {\n    x = x1;\n    y = y1;\n  } else if (along >= 1) {\n    x = x2;\n    y = y2;\n  } else {\n    x = x1 + along * dx;\n    y = y1 + along * dy;\n  }\n  return [x, y];\n}\n\n/**\n * Returns a {@link module:ol/coordinate~CoordinateFormat} function that can be\n * used to format\n * a {Coordinate} to a string.\n *\n * Example without specifying the fractional digits:\n *\n *     import {createStringXY} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     var stringifyFunc = createStringXY();\n *     var out = stringifyFunc(coord);\n *     // out is now '8, 48'\n *\n * Example with explicitly specifying 2 fractional digits:\n *\n *     import {createStringXY} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     var stringifyFunc = createStringXY(2);\n *     var out = stringifyFunc(coord);\n *     // out is now '7.85, 47.98'\n *\n * @param {number=} opt_fractionDigits The number of digits to include\n *    after the decimal point. Default is `0`.\n * @return {CoordinateFormat} Coordinate format.\n * @api\n */\nexport function createStringXY(opt_fractionDigits) {\n  return (\n    /**\n     * @param {Coordinate} coordinate Coordinate.\n     * @return {string} String XY.\n     */\n    function (coordinate) {\n      return toStringXY(coordinate, opt_fractionDigits);\n    }\n  );\n}\n\n/**\n * @param {string} hemispheres Hemispheres.\n * @param {number} degrees Degrees.\n * @param {number=} opt_fractionDigits The number of digits to include\n *    after the decimal point. Default is `0`.\n * @return {string} String.\n */\nexport function degreesToStringHDMS(hemispheres, degrees, opt_fractionDigits) {\n  const normalizedDegrees = modulo(degrees + 180, 360) - 180;\n  const x = Math.abs(3600 * normalizedDegrees);\n  const dflPrecision = opt_fractionDigits || 0;\n  const precision = Math.pow(10, dflPrecision);\n\n  let deg = Math.floor(x / 3600);\n  let min = Math.floor((x - deg * 3600) / 60);\n  let sec = x - deg * 3600 - min * 60;\n  sec = Math.ceil(sec * precision) / precision;\n\n  if (sec >= 60) {\n    sec = 0;\n    min += 1;\n  }\n\n  if (min >= 60) {\n    min = 0;\n    deg += 1;\n  }\n\n  return (\n    deg +\n    '\\u00b0 ' +\n    padNumber(min, 2) +\n    '\\u2032 ' +\n    padNumber(sec, 2, dflPrecision) +\n    '\\u2033' +\n    (normalizedDegrees == 0\n      ? ''\n      : ' ' + hemispheres.charAt(normalizedDegrees < 0 ? 1 : 0))\n  );\n}\n\n/**\n * Transforms the given {@link module:ol/coordinate~Coordinate} to a string\n * using the given string template. The strings `{x}` and `{y}` in the template\n * will be replaced with the first and second coordinate values respectively.\n *\n * Example without specifying the fractional digits:\n *\n *     import {format} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     var template = 'Coordinate is ({x}|{y}).';\n *     var out = format(coord, template);\n *     // out is now 'Coordinate is (8|48).'\n *\n * Example explicitly specifying the fractional digits:\n *\n *     import {format} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     var template = 'Coordinate is ({x}|{y}).';\n *     var out = format(coord, template, 2);\n *     // out is now 'Coordinate is (7.85|47.98).'\n *\n * @param {Coordinate} coordinate Coordinate.\n * @param {string} template A template string with `{x}` and `{y}` placeholders\n *     that will be replaced by first and second coordinate values.\n * @param {number=} opt_fractionDigits The number of digits to include\n *    after the decimal point. Default is `0`.\n * @return {string} Formatted coordinate.\n * @api\n */\nexport function format(coordinate, template, opt_fractionDigits) {\n  if (coordinate) {\n    return template\n      .replace('{x}', coordinate[0].toFixed(opt_fractionDigits))\n      .replace('{y}', coordinate[1].toFixed(opt_fractionDigits));\n  } else {\n    return '';\n  }\n}\n\n/**\n * @param {Coordinate} coordinate1 First coordinate.\n * @param {Coordinate} coordinate2 Second coordinate.\n * @return {boolean} The two coordinates are equal.\n */\nexport function equals(coordinate1, coordinate2) {\n  let equals = true;\n  for (let i = coordinate1.length - 1; i >= 0; --i) {\n    if (coordinate1[i] != coordinate2[i]) {\n      equals = false;\n      break;\n    }\n  }\n  return equals;\n}\n\n/**\n * Rotate `coordinate` by `angle`. `coordinate` is modified in place and\n * returned by the function.\n *\n * Example:\n *\n *     import {rotate} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     var rotateRadians = Math.PI / 2; // 90 degrees\n *     rotate(coord, rotateRadians);\n *     // coord is now [-47.983333, 7.85]\n *\n * @param {Coordinate} coordinate Coordinate.\n * @param {number} angle Angle in radian.\n * @return {Coordinate} Coordinate.\n * @api\n */\nexport function rotate(coordinate, angle) {\n  const cosAngle = Math.cos(angle);\n  const sinAngle = Math.sin(angle);\n  const x = coordinate[0] * cosAngle - coordinate[1] * sinAngle;\n  const y = coordinate[1] * cosAngle + coordinate[0] * sinAngle;\n  coordinate[0] = x;\n  coordinate[1] = y;\n  return coordinate;\n}\n\n/**\n * Scale `coordinate` by `scale`. `coordinate` is modified in place and returned\n * by the function.\n *\n * Example:\n *\n *     import {scale as scaleCoordinate} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     var scale = 1.2;\n *     scaleCoordinate(coord, scale);\n *     // coord is now [9.42, 57.5799996]\n *\n * @param {Coordinate} coordinate Coordinate.\n * @param {number} scale Scale factor.\n * @return {Coordinate} Coordinate.\n */\nexport function scale(coordinate, scale) {\n  coordinate[0] *= scale;\n  coordinate[1] *= scale;\n  return coordinate;\n}\n\n/**\n * @param {Coordinate} coord1 First coordinate.\n * @param {Coordinate} coord2 Second coordinate.\n * @return {number} Squared distance between coord1 and coord2.\n */\nexport function squaredDistance(coord1, coord2) {\n  const dx = coord1[0] - coord2[0];\n  const dy = coord1[1] - coord2[1];\n  return dx * dx + dy * dy;\n}\n\n/**\n * @param {Coordinate} coord1 First coordinate.\n * @param {Coordinate} coord2 Second coordinate.\n * @return {number} Distance between coord1 and coord2.\n */\nexport function distance(coord1, coord2) {\n  return Math.sqrt(squaredDistance(coord1, coord2));\n}\n\n/**\n * Calculate the squared distance from a coordinate to a line segment.\n *\n * @param {Coordinate} coordinate Coordinate of the point.\n * @param {Array<Coordinate>} segment Line segment (2\n * coordinates).\n * @return {number} Squared distance from the point to the line segment.\n */\nexport function squaredDistanceToSegment(coordinate, segment) {\n  return squaredDistance(coordinate, closestOnSegment(coordinate, segment));\n}\n\n/**\n * Format a geographic coordinate with the hemisphere, degrees, minutes, and\n * seconds.\n *\n * Example without specifying fractional digits:\n *\n *     import {toStringHDMS} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     var out = toStringHDMS(coord);\n *     // out is now '47° 58′ 60″ N 7° 50′ 60″ E'\n *\n * Example explicitly specifying 1 fractional digit:\n *\n *     import {toStringHDMS} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     var out = toStringHDMS(coord, 1);\n *     // out is now '47° 58′ 60.0″ N 7° 50′ 60.0″ E'\n *\n * @param {Coordinate} coordinate Coordinate.\n * @param {number=} opt_fractionDigits The number of digits to include\n *    after the decimal point. Default is `0`.\n * @return {string} Hemisphere, degrees, minutes and seconds.\n * @api\n */\nexport function toStringHDMS(coordinate, opt_fractionDigits) {\n  if (coordinate) {\n    return (\n      degreesToStringHDMS('NS', coordinate[1], opt_fractionDigits) +\n      ' ' +\n      degreesToStringHDMS('EW', coordinate[0], opt_fractionDigits)\n    );\n  } else {\n    return '';\n  }\n}\n\n/**\n * Format a coordinate as a comma delimited string.\n *\n * Example without specifying fractional digits:\n *\n *     import {toStringXY} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     var out = toStringXY(coord);\n *     // out is now '8, 48'\n *\n * Example explicitly specifying 1 fractional digit:\n *\n *     import {toStringXY} from 'ol/coordinate';\n *\n *     var coord = [7.85, 47.983333];\n *     var out = toStringXY(coord, 1);\n *     // out is now '7.8, 48.0'\n *\n * @param {Coordinate} coordinate Coordinate.\n * @param {number=} opt_fractionDigits The number of digits to include\n *    after the decimal point. Default is `0`.\n * @return {string} XY.\n * @api\n */\nexport function toStringXY(coordinate, opt_fractionDigits) {\n  return format(coordinate, '{x}, {y}', opt_fractionDigits);\n}\n\n/**\n * Modifies the provided coordinate in-place to be within the real world\n * extent. The lower projection extent boundary is inclusive, the upper one\n * exclusive.\n *\n * @param {Coordinate} coordinate Coordinate.\n * @param {import(\"./proj/Projection.js\").default} projection Projection.\n * @return {Coordinate} The coordinate within the real world extent.\n */\nexport function wrapX(coordinate, projection) {\n  if (projection.canWrapX()) {\n    const worldWidth = getWidth(projection.getExtent());\n    const worldsAway = getWorldsAway(coordinate, projection, worldWidth);\n    if (worldsAway) {\n      coordinate[0] -= worldsAway * worldWidth;\n    }\n  }\n  return coordinate;\n}\n/**\n * @param {Coordinate} coordinate Coordinate.\n * @param {import(\"./proj/Projection.js\").default} projection Projection.\n * @param {number=} opt_sourceExtentWidth Width of the source extent.\n * @return {number} Offset in world widths.\n */\nexport function getWorldsAway(coordinate, projection, opt_sourceExtentWidth) {\n  const projectionExtent = projection.getExtent();\n  let worldsAway = 0;\n  if (\n    projection.canWrapX() &&\n    (coordinate[0] < projectionExtent[0] || coordinate[0] > projectionExtent[2])\n  ) {\n    const sourceExtentWidth =\n      opt_sourceExtentWidth || getWidth(projectionExtent);\n    worldsAway = Math.floor(\n      (coordinate[0] - projectionExtent[0]) / sourceExtentWidth\n    );\n  }\n  return worldsAway;\n}\n","/**\n * @module ol/proj\n */\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 {\n  PROJECTIONS as EPSG3857_PROJECTIONS,\n  fromEPSG4326,\n  toEPSG4326,\n} from './proj/epsg3857.js';\nimport {PROJECTIONS as EPSG4326_PROJECTIONS} from './proj/epsg4326.js';\nimport {\n  add as addProj,\n  clear as clearProj,\n  get as getProj,\n} from './proj/projections.js';\nimport {\n  add as addTransformFunc,\n  clear as clearTransformFuncs,\n  get as getTransformFunc,\n} 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/**\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/**\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 */\n\nexport {METERS_PER_UNIT};\n\nexport {Projection};\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>} Output coordinate array (new array, same coordinate\n *     values).\n */\nexport function cloneTransform(input, opt_output, opt_dimension) {\n  let output;\n  if (opt_output !== undefined) {\n    for (let i = 0, ii = input.length; i < ii; ++i) {\n      opt_output[i] = input[i];\n    }\n    output = opt_output;\n  } else {\n    output = input.slice();\n  }\n  return output;\n}\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 (let 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/**\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/**\n * @param {Array<Projection>} projections Projections.\n */\nexport function addProjections(projections) {\n  projections.forEach(addProjection);\n}\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/**\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  let pointResolution;\n  const getter = projection.getPointResolutionFunc();\n  if (getter) {\n    pointResolution = getter(resolution, point);\n    if (opt_units && opt_units !== projection.getUnits()) {\n      const metersPerUnit = projection.getMetersPerUnit();\n      if (metersPerUnit) {\n        pointResolution =\n          (pointResolution * metersPerUnit) / METERS_PER_UNIT[opt_units];\n      }\n    }\n  } else {\n    const units = projection.getUnits();\n    if ((units == Units.DEGREES && !opt_units) || opt_units == Units.DEGREES) {\n      pointResolution = resolution;\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      const toEPSG4326 = getTransformFromProjections(\n        projection,\n        get('EPSG:4326')\n      );\n      if (toEPSG4326 === identityTransform && units !== Units.DEGREES) {\n        // no transform is available\n        pointResolution = resolution * projection.getMetersPerUnit();\n      } else {\n        let 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(vertices, vertices, 2);\n        const width = getDistance(vertices.slice(0, 2), vertices.slice(2, 4));\n        const height = getDistance(vertices.slice(4, 6), vertices.slice(6, 8));\n        pointResolution = (width + height) / 2;\n      }\n      const 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/**\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/**\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(\n  projections1,\n  projections2,\n  forwardTransform,\n  inverseTransform\n) {\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/**\n * Clear all cached projections and transforms.\n */\nexport function clearAllProjections() {\n  clearProj();\n  clearTransformFuncs();\n}\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  } else if (typeof projection === 'string') {\n    return get(projection);\n  } else {\n    return /** @type {Projection} */ (projection);\n  }\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      const length = input.length;\n      const dimension = opt_dimension !== undefined ? opt_dimension : 2;\n      const output = opt_output !== undefined ? opt_output : new Array(length);\n      for (let i = 0; i < length; i += dimension) {\n        const point = coordTransform([input[i], input[i + 1]]);\n        output[i] = point[0];\n        output[i + 1] = point[1];\n        for (let j = dimension - 1; j >= 2; --j) {\n          output[i + j] = input[i + j];\n        }\n      }\n      return output;\n    }\n  );\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  const sourceProj = get(source);\n  const destProj = get(destination);\n  addTransformFunc(\n    sourceProj,\n    destProj,\n    createTransformFromCoordinateTransform(forward)\n  );\n  addTransformFunc(\n    destProj,\n    sourceProj,\n    createTransformFromCoordinateTransform(inverse)\n  );\n}\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(\n    coordinate,\n    'EPSG:4326',\n    opt_projection !== undefined ? opt_projection : 'EPSG:3857'\n  );\n}\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  const lonLat = transform(\n    coordinate,\n    opt_projection !== undefined ? opt_projection : 'EPSG:3857',\n    'EPSG:4326'\n  );\n  const lon = lonLat[0];\n  if (lon < -180 || lon > 180) {\n    lonLat[0] = modulo(lon + 180, 360) - 180;\n  }\n  return lonLat;\n}\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  const equalUnits = projection1.getUnits() === projection2.getUnits();\n  if (projection1.getCode() === projection2.getCode()) {\n    return equalUnits;\n  } else {\n    const transformFunc = getTransformFromProjections(projection1, projection2);\n    return transformFunc === cloneTransform && equalUnits;\n  }\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(\n  sourceProjection,\n  destinationProjection\n) {\n  const sourceCode = sourceProjection.getCode();\n  const destinationCode = destinationProjection.getCode();\n  let transformFunc = getTransformFunc(sourceCode, destinationCode);\n  if (!transformFunc) {\n    transformFunc = identityTransform;\n  }\n  return transformFunc;\n}\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  const sourceProjection = get(source);\n  const destinationProjection = get(destination);\n  return getTransformFromProjections(sourceProjection, destinationProjection);\n}\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  const transformFunc = getTransform(source, destination);\n  return transformFunc(coordinate, undefined, coordinate.length);\n}\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  const transformFunc = getTransform(source, destination);\n  return applyTransform(extent, transformFunc, undefined, opt_stops);\n}\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(\n  point,\n  sourceProjection,\n  destinationProjection\n) {\n  const transformFunc = getTransformFromProjections(\n    sourceProjection,\n    destinationProjection\n  );\n  return transformFunc(point);\n}\n\n/**\n * @type {?Projection}\n */\nlet userProjection = null;\n\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/**\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/**\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 * @returns {?Projection} The user projection (or null if not set).\n */\nexport function getUserProjection() {\n  return userProjection;\n}\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/**\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 * @returns {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/**\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 * @returns {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/**\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 * @returns {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/**\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 * @returns {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/**\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    let sourceX = coord[0];\n    let sourceY = coord[1];\n    let transformed, worldsAway;\n    if (sourceProj.canWrapX()) {\n      const sourceExtent = sourceProj.getExtent();\n      const 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    } 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/**\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(\n    EPSG4326_PROJECTIONS,\n    EPSG3857_PROJECTIONS,\n    fromEPSG4326,\n    toEPSG4326\n  );\n}\n\naddCommon();\n","/**\n * @module ol/control/ScaleLine\n */\nimport Control from './Control.js';\nimport ProjUnits from '../proj/Units.js';\nimport {CLASS_UNSELECTABLE} from '../css.js';\nimport {METERS_PER_UNIT, getPointResolution} from '../proj.js';\nimport {assert} from '../asserts.js';\nimport {getChangeEventType} from '../Object.js';\n\n/**\n * @type {string}\n */\nconst UNITS_PROP = 'units';\n\n/**\n * Units for the scale line. Supported values are `'degrees'`, `'imperial'`,\n * `'nautical'`, `'metric'`, `'us'`.\n * @enum {string}\n */\nexport const Units = {\n  DEGREES: 'degrees',\n  IMPERIAL: 'imperial',\n  NAUTICAL: 'nautical',\n  METRIC: 'metric',\n  US: 'us',\n};\n\n/**\n * @const\n * @type {Array<number>}\n */\nconst LEADING_DIGITS = [1, 2, 5];\n\n/**\n * @const\n * @type {number}\n */\nconst DEFAULT_DPI = 25.4 / 0.28;\n\n/**\n * @typedef {Object} Options\n * @property {string} [className='ol-scale-line'] CSS Class name.\n * @property {number} [minWidth=64] Minimum width in pixels at the OGC default dpi. The width will be\n * adjusted to match the dpi used.\n * @property {function(import(\"../MapEvent.js\").default):void} [render] Function called when the control\n * should be re-rendered. This is called in a `requestAnimationFrame` callback.\n * @property {HTMLElement|string} [target] Specify a target if you want the control\n * to be rendered outside of the map's viewport.\n * @property {import(\"./ScaleLine.js\").Units|string} [units='metric'] Units.\n * @property {boolean} [bar=false] Render scalebars instead of a line.\n * @property {number} [steps=4] Number of steps the scalebar should use. Use even numbers\n * for best results. Only applies when `bar` is `true`.\n * @property {boolean} [text=false] Render the text scale above of the scalebar. Only applies\n * when `bar` is `true`.\n * @property {number|undefined} [dpi=undefined] dpi of output device such as printer. Only applies\n * when `bar` is `true`. If undefined the OGC default screen pixel size of 0.28mm will be assumed.\n */\n\n/**\n * @classdesc\n * A control displaying rough y-axis distances, calculated for the center of the\n * viewport. For conformal projections (e.g. EPSG:3857, the default view\n * projection in OpenLayers), the scale is valid for all directions.\n * No scale line will be shown when the y-axis distance of a pixel at the\n * viewport center cannot be calculated in the view projection.\n * By default the scale line will show in the bottom left portion of the map,\n * but this can be changed by using the css selector `.ol-scale-line`.\n * When specifying `bar` as `true`, a scalebar will be rendered instead\n * of a scaleline.\n *\n * @api\n */\nclass ScaleLine extends Control {\n  /**\n   * @param {Options=} opt_options Scale line options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    const className =\n      options.className !== undefined\n        ? options.className\n        : options.bar\n        ? 'ol-scale-bar'\n        : 'ol-scale-line';\n\n    super({\n      element: document.createElement('div'),\n      render: options.render,\n      target: options.target,\n    });\n\n    /**\n     * @private\n     * @type {HTMLElement}\n     */\n    this.innerElement_ = document.createElement('div');\n    this.innerElement_.className = className + '-inner';\n\n    this.element.className = className + ' ' + CLASS_UNSELECTABLE;\n    this.element.appendChild(this.innerElement_);\n\n    /**\n     * @private\n     * @type {?import(\"../View.js\").State}\n     */\n    this.viewState_ = null;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.minWidth_ = options.minWidth !== undefined ? options.minWidth : 64;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.renderedVisible_ = false;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.renderedWidth_ = undefined;\n\n    /**\n     * @private\n     * @type {string}\n     */\n    this.renderedHTML_ = '';\n\n    this.addEventListener(\n      getChangeEventType(UNITS_PROP),\n      this.handleUnitsChanged_\n    );\n\n    this.setUnits(options.units || Units.METRIC);\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.scaleBar_ = options.bar || false;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.scaleBarSteps_ = options.steps || 4;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.scaleBarText_ = options.text || false;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.dpi_ = options.dpi || undefined;\n  }\n\n  /**\n   * Return the units to use in the scale line.\n   * @return {import(\"./ScaleLine.js\").Units} The units\n   * to use in the scale line.\n   * @observable\n   * @api\n   */\n  getUnits() {\n    return this.get(UNITS_PROP);\n  }\n\n  /**\n   * @private\n   */\n  handleUnitsChanged_() {\n    this.updateElement_();\n  }\n\n  /**\n   * Set the units to use in the scale line.\n   * @param {import(\"./ScaleLine.js\").Units} units The units to use in the scale line.\n   * @observable\n   * @api\n   */\n  setUnits(units) {\n    this.set(UNITS_PROP, units);\n  }\n\n  /**\n   * Specify the dpi of output device such as printer.\n   * @param {number|undefined} dpi The dpi of output device.\n   * @api\n   */\n  setDpi(dpi) {\n    this.dpi_ = dpi;\n  }\n\n  /**\n   * @private\n   */\n  updateElement_() {\n    const viewState = this.viewState_;\n\n    if (!viewState) {\n      if (this.renderedVisible_) {\n        this.element.style.display = 'none';\n        this.renderedVisible_ = false;\n      }\n      return;\n    }\n\n    const center = viewState.center;\n    const projection = viewState.projection;\n    const units = this.getUnits();\n    const pointResolutionUnits =\n      units == Units.DEGREES ? ProjUnits.DEGREES : ProjUnits.METERS;\n    let pointResolution = getPointResolution(\n      projection,\n      viewState.resolution,\n      center,\n      pointResolutionUnits\n    );\n\n    const minWidth =\n      (this.minWidth_ * (this.dpi_ || DEFAULT_DPI)) / DEFAULT_DPI;\n\n    let nominalCount = minWidth * pointResolution;\n    let suffix = '';\n    if (units == Units.DEGREES) {\n      const metersPerDegree = METERS_PER_UNIT[ProjUnits.DEGREES];\n      nominalCount *= metersPerDegree;\n      if (nominalCount < metersPerDegree / 60) {\n        suffix = '\\u2033'; // seconds\n        pointResolution *= 3600;\n      } else if (nominalCount < metersPerDegree) {\n        suffix = '\\u2032'; // minutes\n        pointResolution *= 60;\n      } else {\n        suffix = '\\u00b0'; // degrees\n      }\n    } else if (units == Units.IMPERIAL) {\n      if (nominalCount < 0.9144) {\n        suffix = 'in';\n        pointResolution /= 0.0254;\n      } else if (nominalCount < 1609.344) {\n        suffix = 'ft';\n        pointResolution /= 0.3048;\n      } else {\n        suffix = 'mi';\n        pointResolution /= 1609.344;\n      }\n    } else if (units == Units.NAUTICAL) {\n      pointResolution /= 1852;\n      suffix = 'nm';\n    } else if (units == Units.METRIC) {\n      if (nominalCount < 0.001) {\n        suffix = 'μm';\n        pointResolution *= 1000000;\n      } else if (nominalCount < 1) {\n        suffix = 'mm';\n        pointResolution *= 1000;\n      } else if (nominalCount < 1000) {\n        suffix = 'm';\n      } else {\n        suffix = 'km';\n        pointResolution /= 1000;\n      }\n    } else if (units == Units.US) {\n      if (nominalCount < 0.9144) {\n        suffix = 'in';\n        pointResolution *= 39.37;\n      } else if (nominalCount < 1609.344) {\n        suffix = 'ft';\n        pointResolution /= 0.30480061;\n      } else {\n        suffix = 'mi';\n        pointResolution /= 1609.3472;\n      }\n    } else {\n      assert(false, 33); // Invalid units\n    }\n\n    let i = 3 * Math.floor(Math.log(minWidth * pointResolution) / Math.log(10));\n    let count, width, decimalCount;\n    while (true) {\n      decimalCount = Math.floor(i / 3);\n      const decimal = Math.pow(10, decimalCount);\n      count = LEADING_DIGITS[((i % 3) + 3) % 3] * decimal;\n      width = Math.round(count / pointResolution);\n      if (isNaN(width)) {\n        this.element.style.display = 'none';\n        this.renderedVisible_ = false;\n        return;\n      } else if (width >= minWidth) {\n        break;\n      }\n      ++i;\n    }\n    let html;\n    if (this.scaleBar_) {\n      html = this.createScaleBar(width, count, suffix);\n    } else {\n      html = count.toFixed(decimalCount < 0 ? -decimalCount : 0) + ' ' + suffix;\n    }\n\n    if (this.renderedHTML_ != html) {\n      this.innerElement_.innerHTML = html;\n      this.renderedHTML_ = html;\n    }\n\n    if (this.renderedWidth_ != width) {\n      this.innerElement_.style.width = width + 'px';\n      this.renderedWidth_ = width;\n    }\n\n    if (!this.renderedVisible_) {\n      this.element.style.display = '';\n      this.renderedVisible_ = true;\n    }\n  }\n\n  /**\n   * @private\n   * @param {number} width The current width of the scalebar.\n   * @param {number} scale The current scale.\n   * @param {string} suffix The suffix to append to the scale text.\n   * @returns {string} The stringified HTML of the scalebar.\n   */\n  createScaleBar(width, scale, suffix) {\n    const mapScale =\n      '1 : ' + Math.round(this.getScaleForResolution()).toLocaleString();\n    const scaleSteps = [];\n    const stepWidth = width / this.scaleBarSteps_;\n    let backgroundColor = '#ffffff';\n    for (let i = 0; i < this.scaleBarSteps_; i++) {\n      if (i === 0) {\n        // create the first marker at position 0\n        scaleSteps.push(this.createMarker('absolute', i));\n      }\n      scaleSteps.push(\n        '<div>' +\n          '<div ' +\n          'class=\"ol-scale-singlebar\" ' +\n          'style=' +\n          '\"width: ' +\n          stepWidth +\n          'px;' +\n          'background-color: ' +\n          backgroundColor +\n          ';\"' +\n          '>' +\n          '</div>' +\n          this.createMarker('relative', i) +\n          /*render text every second step, except when only 2 steps */\n          (i % 2 === 0 || this.scaleBarSteps_ === 2\n            ? this.createStepText(i, width, false, scale, suffix)\n            : '') +\n          '</div>'\n      );\n      if (i === this.scaleBarSteps_ - 1) {\n        {\n          /*render text at the end */\n        }\n        scaleSteps.push(this.createStepText(i + 1, width, true, scale, suffix));\n      }\n      // switch colors of steps between black and white\n      if (backgroundColor === '#ffffff') {\n        backgroundColor = '#000000';\n      } else {\n        backgroundColor = '#ffffff';\n      }\n    }\n\n    let scaleBarText;\n    if (this.scaleBarText_) {\n      scaleBarText =\n        '<div ' +\n        'class=\"ol-scale-text\" ' +\n        'style=\"width: ' +\n        width +\n        'px;\">' +\n        mapScale +\n        '</div>';\n    } else {\n      scaleBarText = '';\n    }\n    const container =\n      '<div ' +\n      'style=\"display: flex;\">' +\n      scaleBarText +\n      scaleSteps.join('') +\n      '</div>';\n    return container;\n  }\n\n  /**\n   * Creates a marker at given position\n   * @param {string} position - The position, absolute or relative\n   * @param {number} i - The iterator\n   * @returns {string} The stringified div containing the marker\n   */\n  createMarker(position, i) {\n    const top = position === 'absolute' ? 3 : -10;\n    return (\n      '<div ' +\n      'class=\"ol-scale-step-marker\" ' +\n      'style=\"position: ' +\n      position +\n      ';' +\n      'top: ' +\n      top +\n      'px;\"' +\n      '></div>'\n    );\n  }\n\n  /**\n   * Creates the label for a marker marker at given position\n   * @param {number} i - The iterator\n   * @param {number} width - The width the scalebar will currently use\n   * @param {boolean} isLast - Flag indicating if we add the last step text\n   * @param {number} scale - The current scale for the whole scalebar\n   * @param {string} suffix - The suffix for the scale\n   * @returns {string} The stringified div containing the step text\n   */\n  createStepText(i, width, isLast, scale, suffix) {\n    const length =\n      i === 0 ? 0 : Math.round((scale / this.scaleBarSteps_) * i * 100) / 100;\n    const lengthString = length + (i === 0 ? '' : ' ' + suffix);\n    const margin = i === 0 ? -3 : (width / this.scaleBarSteps_) * -1;\n    const minWidth = i === 0 ? 0 : (width / this.scaleBarSteps_) * 2;\n    return (\n      '<div ' +\n      'class=\"ol-scale-step-text\" ' +\n      'style=\"' +\n      'margin-left: ' +\n      margin +\n      'px;' +\n      'text-align: ' +\n      (i === 0 ? 'left' : 'center') +\n      '; ' +\n      'min-width: ' +\n      minWidth +\n      'px;' +\n      'left: ' +\n      (isLast ? width + 'px' : 'unset') +\n      ';\"' +\n      '>' +\n      lengthString +\n      '</div>'\n    );\n  }\n\n  /**\n   * Returns the appropriate scale for the given resolution and units.\n   * @return {number} The appropriate scale.\n   */\n  getScaleForResolution() {\n    const resolution = getPointResolution(\n      this.viewState_.projection,\n      this.viewState_.resolution,\n      this.viewState_.center\n    );\n    const dpi = this.dpi_ || DEFAULT_DPI;\n    const mpu = this.viewState_.projection.getMetersPerUnit();\n    const inchesPerMeter = 1000 / 25.4;\n    return parseFloat(resolution.toString()) * mpu * inchesPerMeter * dpi;\n  }\n\n  /**\n   * Update the scale line element.\n   * @param {import(\"../MapEvent.js\").default} mapEvent Map event.\n   * @override\n   */\n  render(mapEvent) {\n    const frameState = mapEvent.frameState;\n    if (!frameState) {\n      this.viewState_ = null;\n    } else {\n      this.viewState_ = frameState.viewState;\n    }\n    this.updateElement_();\n  }\n}\n\nexport default ScaleLine;\n","/**\n * @module ol/control\n */\nimport Attribution from './control/Attribution.js';\nimport Collection from './Collection.js';\nimport Rotate from './control/Rotate.js';\nimport Zoom from './control/Zoom.js';\n\nexport {default as Attribution} from './control/Attribution.js';\nexport {default as Control} from './control/Control.js';\nexport {default as FullScreen} from './control/FullScreen.js';\nexport {default as MousePosition} from './control/MousePosition.js';\nexport {default as OverviewMap} from './control/OverviewMap.js';\nexport {default as Rotate} from './control/Rotate.js';\nexport {default as ScaleLine} from './control/ScaleLine.js';\nexport {default as Zoom} from './control/Zoom.js';\nexport {default as ZoomSlider} from './control/ZoomSlider.js';\nexport {default as ZoomToExtent} from './control/ZoomToExtent.js';\n\n/**\n * @typedef {Object} DefaultsOptions\n * @property {boolean} [attribution=true] Include\n * {@link module:ol/control/Attribution~Attribution}.\n * @property {import(\"./control/Attribution.js\").Options} [attributionOptions]\n * Options for {@link module:ol/control/Attribution~Attribution}.\n * @property {boolean} [rotate=true] Include\n * {@link module:ol/control/Rotate~Rotate}.\n * @property {import(\"./control/Rotate.js\").Options} [rotateOptions] Options\n * for {@link module:ol/control/Rotate~Rotate}.\n * @property {boolean} [zoom] Include {@link module:ol/control/Zoom~Zoom}.\n * @property {import(\"./control/Zoom.js\").Options} [zoomOptions] Options for\n * {@link module:ol/control/Zoom~Zoom}.\n * @api\n */\n\n/**\n * Set of controls included in maps by default. Unless configured otherwise,\n * this returns a collection containing an instance of each of the following\n * controls:\n * * {@link module:ol/control/Zoom~Zoom}\n * * {@link module:ol/control/Rotate~Rotate}\n * * {@link module:ol/control/Attribution~Attribution}\n *\n * @param {DefaultsOptions=} opt_options\n * Defaults options.\n * @return {Collection<import(\"./control/Control.js\").default>}\n * Controls.\n * @api\n */\nexport function defaults(opt_options) {\n  const options = opt_options ? opt_options : {};\n\n  const controls = new Collection();\n\n  const zoomControl = options.zoom !== undefined ? options.zoom : true;\n  if (zoomControl) {\n    controls.push(new Zoom(options.zoomOptions));\n  }\n\n  const rotateControl = options.rotate !== undefined ? options.rotate : true;\n  if (rotateControl) {\n    controls.push(new Rotate(options.rotateOptions));\n  }\n\n  const attributionControl =\n    options.attribution !== undefined ? options.attribution : true;\n  if (attributionControl) {\n    controls.push(new Attribution(options.attributionOptions));\n  }\n\n  return controls;\n}\n","/**\n * @module ol/Feature\n */\nimport BaseObject, {getChangeEventType} from './Object.js';\nimport EventType from './events/EventType.js';\nimport {assert} from './asserts.js';\nimport {listen, unlistenByKey} from './events.js';\n\n/**\n * @typedef {typeof Feature|typeof import(\"./render/Feature.js\").default} FeatureClass\n */\n\n/**\n * @typedef {Feature|import(\"./render/Feature.js\").default} FeatureLike\n */\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 */\nclass Feature extends BaseObject {\n  /**\n   * @param {Geometry|Object<string, *>=} 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  constructor(opt_geometryOrProperties) {\n    super();\n\n    /**\n     * @private\n     * @type {number|string|undefined}\n     */\n    this.id_ = undefined;\n\n    /**\n     * @type {string}\n     * @private\n     */\n    this.geometryName_ = 'geometry';\n\n    /**\n     * User provided style.\n     * @private\n     * @type {import(\"./style/Style.js\").StyleLike}\n     */\n    this.style_ = null;\n\n    /**\n     * @private\n     * @type {import(\"./style/Style.js\").StyleFunction|undefined}\n     */\n    this.styleFunction_ = undefined;\n\n    /**\n     * @private\n     * @type {?import(\"./events.js\").EventsKey}\n     */\n    this.geometryChangeKey_ = null;\n\n    this.addEventListener(\n      getChangeEventType(this.geometryName_),\n      this.handleGeometryChanged_\n    );\n\n    if (opt_geometryOrProperties) {\n      if (\n        typeof (\n          /** @type {?} */ (opt_geometryOrProperties).getSimplifiedGeometry\n        ) === 'function'\n      ) {\n        const geometry = /** @type {Geometry} */ (opt_geometryOrProperties);\n        this.setGeometry(geometry);\n      } else {\n        /** @type {Object<string, *>} */\n        const properties = opt_geometryOrProperties;\n        this.setProperties(properties);\n      }\n    }\n  }\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} The clone.\n   * @api\n   */\n  clone() {\n    const clone = new Feature(\n      this.hasProperties() ? this.getProperties() : null\n    );\n    clone.setGeometryName(this.getGeometryName());\n    const geometry = this.getGeometry();\n    if (geometry) {\n      clone.setGeometry(geometry.clone());\n    }\n    const style = this.getStyle();\n    if (style) {\n      clone.setStyle(style);\n    }\n    return clone;\n  }\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  getGeometry() {\n    return /** @type {Geometry|undefined} */ (this.get(this.geometryName_));\n  }\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  getId() {\n    return this.id_;\n  }\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  getGeometryName() {\n    return this.geometryName_;\n  }\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  getStyle() {\n    return this.style_;\n  }\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  getStyleFunction() {\n    return this.styleFunction_;\n  }\n\n  /**\n   * @private\n   */\n  handleGeometryChange_() {\n    this.changed();\n  }\n\n  /**\n   * @private\n   */\n  handleGeometryChanged_() {\n    if (this.geometryChangeKey_) {\n      unlistenByKey(this.geometryChangeKey_);\n      this.geometryChangeKey_ = null;\n    }\n    const geometry = this.getGeometry();\n    if (geometry) {\n      this.geometryChangeKey_ = listen(\n        geometry,\n        EventType.CHANGE,\n        this.handleGeometryChange_,\n        this\n      );\n    }\n    this.changed();\n  }\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  setGeometry(geometry) {\n    this.set(this.geometryName_, geometry);\n  }\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  setStyle(opt_style) {\n    this.style_ = opt_style;\n    this.styleFunction_ = !opt_style\n      ? undefined\n      : createStyleFunction(opt_style);\n    this.changed();\n  }\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  setId(id) {\n    this.id_ = id;\n    this.changed();\n  }\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  setGeometryName(name) {\n    this.removeEventListener(\n      getChangeEventType(this.geometryName_),\n      this.handleGeometryChanged_\n    );\n    this.geometryName_ = name;\n    this.addEventListener(\n      getChangeEventType(this.geometryName_),\n      this.handleGeometryChanged_\n    );\n    this.handleGeometryChanged_();\n  }\n}\n\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  } else {\n    /**\n     * @type {Array<import(\"./style/Style.js\").default>}\n     */\n    let styles;\n    if (Array.isArray(obj)) {\n      styles = obj;\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      const style = /** @type {import(\"./style/Style.js\").default} */ (obj);\n      styles = [style];\n    }\n    return function () {\n      return styles;\n    };\n  }\n}\nexport default Feature;\n","/**\n * @module ol/style/IconAnchorUnits\n */\n\n/**\n * Icon anchor units. One of 'fraction', 'pixels'.\n * @enum {string}\n */\nexport default {\n  /**\n   * Anchor is a fraction\n   * @api\n   */\n  FRACTION: 'fraction',\n  /**\n   * Anchor is in pixels\n   * @api\n   */\n  PIXELS: 'pixels',\n};\n","/**\n * @module ol/style/IconOrigin\n */\n\n/**\n * Icon origin. One of 'bottom-left', 'bottom-right', 'top-left', 'top-right'.\n * @enum {string}\n */\nexport default {\n  /**\n   * Origin is at bottom left\n   * @api\n   */\n  BOTTOM_LEFT: 'bottom-left',\n  /**\n   * Origin is at bottom right\n   * @api\n   */\n  BOTTOM_RIGHT: 'bottom-right',\n  /**\n   * Origin is at top left\n   * @api\n   */\n  TOP_LEFT: 'top-left',\n  /**\n   * Origin is at top right\n   * @api\n   */\n  TOP_RIGHT: 'top-right',\n};\n","/**\n * @module ol/ImageState\n */\n\n/**\n * @enum {number}\n */\nexport default {\n  IDLE: 0,\n  LOADING: 1,\n  LOADED: 2,\n  ERROR: 3,\n  EMPTY: 4,\n};\n","/**\n * @module ol/size\n */\n\n/**\n * An array of numbers representing a size: `[width, height]`.\n * @typedef {Array<number>} Size\n * @api\n */\n\n/**\n * Returns a buffered size.\n * @param {Size} size Size.\n * @param {number} num The amount by which to buffer.\n * @param {Size=} opt_size Optional reusable size array.\n * @return {Size} The buffered size.\n */\nexport function buffer(size, num, opt_size) {\n  if (opt_size === undefined) {\n    opt_size = [0, 0];\n  }\n  opt_size[0] = size[0] + 2 * num;\n  opt_size[1] = size[1] + 2 * num;\n  return opt_size;\n}\n\n/**\n * Determines if a size has a positive area.\n * @param {Size} size The size to test.\n * @return {boolean} The size has a positive area.\n */\nexport function hasArea(size) {\n  return size[0] > 0 && size[1] > 0;\n}\n\n/**\n * Returns a size scaled by a ratio. The result will be an array of integers.\n * @param {Size} size Size.\n * @param {number} ratio Ratio.\n * @param {Size=} opt_size Optional reusable size array.\n * @return {Size} The scaled size.\n */\nexport function scale(size, ratio, opt_size) {\n  if (opt_size === undefined) {\n    opt_size = [0, 0];\n  }\n  opt_size[0] = (size[0] * ratio + 0.5) | 0;\n  opt_size[1] = (size[1] * ratio + 0.5) | 0;\n  return opt_size;\n}\n\n/**\n * Returns an `Size` array for the passed in number (meaning: square) or\n * `Size` array.\n * (meaning: non-square),\n * @param {number|Size} size Width and height.\n * @param {Size=} opt_size Optional reusable size array.\n * @return {Size} Size.\n * @api\n */\nexport function toSize(size, opt_size) {\n  if (Array.isArray(size)) {\n    return size;\n  } else {\n    if (opt_size === undefined) {\n      opt_size = [size, size];\n    } else {\n      opt_size[0] = size;\n      opt_size[1] = size;\n    }\n    return opt_size;\n  }\n}\n","/**\n * @module ol/style/Image\n */\nimport {abstract} from '../util.js';\nimport {toSize} from '../size.js';\n\n/**\n * @typedef {Object} Options\n * @property {number} opacity\n * @property {boolean} rotateWithView\n * @property {number} rotation\n * @property {number|import(\"../size.js\").Size} scale\n * @property {Array<number>} displacement\n */\n\n/**\n * @classdesc\n * A base class used for creating subclasses and not instantiated in\n * apps. Base class for {@link module:ol/style/Icon~Icon}, {@link module:ol/style/Circle~CircleStyle} and\n * {@link module:ol/style/RegularShape~RegularShape}.\n * @abstract\n * @api\n */\nclass ImageStyle {\n  /**\n   * @param {Options} options Options.\n   */\n  constructor(options) {\n    /**\n     * @private\n     * @type {number}\n     */\n    this.opacity_ = options.opacity;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.rotateWithView_ = options.rotateWithView;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.rotation_ = options.rotation;\n\n    /**\n     * @private\n     * @type {number|import(\"../size.js\").Size}\n     */\n    this.scale_ = options.scale;\n\n    /**\n     * @private\n     * @type {import(\"../size.js\").Size}\n     */\n    this.scaleArray_ = toSize(options.scale);\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.displacement_ = options.displacement;\n  }\n\n  /**\n   * Clones the style.\n   * @return {ImageStyle} The cloned style.\n   * @api\n   */\n  clone() {\n    const scale = this.getScale();\n    return new ImageStyle({\n      opacity: this.getOpacity(),\n      scale: Array.isArray(scale) ? scale.slice() : scale,\n      rotation: this.getRotation(),\n      rotateWithView: this.getRotateWithView(),\n      displacement: this.getDisplacement().slice(),\n    });\n  }\n\n  /**\n   * Get the symbolizer opacity.\n   * @return {number} Opacity.\n   * @api\n   */\n  getOpacity() {\n    return this.opacity_;\n  }\n\n  /**\n   * Determine whether the symbolizer rotates with the map.\n   * @return {boolean} Rotate with map.\n   * @api\n   */\n  getRotateWithView() {\n    return this.rotateWithView_;\n  }\n\n  /**\n   * Get the symoblizer rotation.\n   * @return {number} Rotation.\n   * @api\n   */\n  getRotation() {\n    return this.rotation_;\n  }\n\n  /**\n   * Get the symbolizer scale.\n   * @return {number|import(\"../size.js\").Size} Scale.\n   * @api\n   */\n  getScale() {\n    return this.scale_;\n  }\n\n  /**\n   * Get the symbolizer scale array.\n   * @return {import(\"../size.js\").Size} Scale array.\n   */\n  getScaleArray() {\n    return this.scaleArray_;\n  }\n\n  /**\n   * Get the displacement of the shape\n   * @return {Array<number>} Shape's center displacement\n   * @api\n   */\n  getDisplacement() {\n    return this.displacement_;\n  }\n\n  /**\n   * Get the anchor point in pixels. The anchor determines the center point for the\n   * symbolizer.\n   * @abstract\n   * @return {Array<number>} Anchor.\n   */\n  getAnchor() {\n    return abstract();\n  }\n\n  /**\n   * Get the image element for the symbolizer.\n   * @abstract\n   * @param {number} pixelRatio Pixel ratio.\n   * @return {HTMLCanvasElement|HTMLVideoElement|HTMLImageElement} Image element.\n   */\n  getImage(pixelRatio) {\n    return abstract();\n  }\n\n  /**\n   * @abstract\n   * @return {HTMLCanvasElement|HTMLVideoElement|HTMLImageElement} Image element.\n   */\n  getHitDetectionImage() {\n    return abstract();\n  }\n\n  /*\n   * Get the image pixel ratio.\n   * @param {number} pixelRatio Pixel ratio.\n   * */\n  getPixelRatio(pixelRatio) {\n    return 1;\n  }\n\n  /**\n   * @abstract\n   * @return {import(\"../ImageState.js\").default} Image state.\n   */\n  getImageState() {\n    return abstract();\n  }\n\n  /**\n   * @abstract\n   * @return {import(\"../size.js\").Size} Image size.\n   */\n  getImageSize() {\n    return abstract();\n  }\n\n  /**\n   * @abstract\n   * @return {import(\"../size.js\").Size} Size of the hit-detection image.\n   */\n  getHitDetectionImageSize() {\n    return abstract();\n  }\n\n  /**\n   * Get the origin of the symbolizer.\n   * @abstract\n   * @return {Array<number>} Origin.\n   */\n  getOrigin() {\n    return abstract();\n  }\n\n  /**\n   * Get the size of the symbolizer (in pixels).\n   * @abstract\n   * @return {import(\"../size.js\").Size} Size.\n   */\n  getSize() {\n    return abstract();\n  }\n\n  /**\n   * Set the opacity.\n   *\n   * @param {number} opacity Opacity.\n   * @api\n   */\n  setOpacity(opacity) {\n    this.opacity_ = opacity;\n  }\n\n  /**\n   * Set whether to rotate the style with the view.\n   *\n   * @param {boolean} rotateWithView Rotate with map.\n   * @api\n   */\n  setRotateWithView(rotateWithView) {\n    this.rotateWithView_ = rotateWithView;\n  }\n\n  /**\n   * Set the rotation.\n   *\n   * @param {number} rotation Rotation.\n   * @api\n   */\n  setRotation(rotation) {\n    this.rotation_ = rotation;\n  }\n  /**\n   * Set the scale.\n   *\n   * @param {number|import(\"../size.js\").Size} scale Scale.\n   * @api\n   */\n  setScale(scale) {\n    this.scale_ = scale;\n    this.scaleArray_ = toSize(scale);\n  }\n\n  /**\n   * @abstract\n   * @param {function(import(\"../events/Event.js\").default): void} listener Listener function.\n   */\n  listenImageChange(listener) {\n    abstract();\n  }\n\n  /**\n   * Load not yet loaded URI.\n   * @abstract\n   */\n  load() {\n    abstract();\n  }\n\n  /**\n   * @abstract\n   * @param {function(import(\"../events/Event.js\").default): void} listener Listener function.\n   */\n  unlistenImageChange(listener) {\n    abstract();\n  }\n}\n\nexport default ImageStyle;\n","/**\n * @module ol/color\n */\nimport {assert} from './asserts.js';\nimport {clamp} from './math.js';\n\n/**\n * A color represented as a short array [red, green, blue, alpha].\n * red, green, and blue should be integers in the range 0..255 inclusive.\n * alpha should be a float in the range 0..1 inclusive. If no alpha value is\n * given then `1` will be used.\n * @typedef {Array<number>} Color\n * @api\n */\n\n/**\n * This RegExp matches # followed by 3, 4, 6, or 8 hex digits.\n * @const\n * @type {RegExp}\n * @private\n */\nconst HEX_COLOR_RE_ = /^#([a-f0-9]{3}|[a-f0-9]{4}(?:[a-f0-9]{2}){0,2})$/i;\n\n/**\n * Regular expression for matching potential named color style strings.\n * @const\n * @type {RegExp}\n * @private\n */\nconst NAMED_COLOR_RE_ = /^([a-z]*)$|^hsla?\\(.*\\)$/i;\n\n/**\n * Return the color as an rgba string.\n * @param {Color|string} color Color.\n * @return {string} Rgba string.\n * @api\n */\nexport function asString(color) {\n  if (typeof color === 'string') {\n    return color;\n  } else {\n    return toString(color);\n  }\n}\n\n/**\n * Return named color as an rgba string.\n * @param {string} color Named color.\n * @return {string} Rgb string.\n */\nfunction fromNamed(color) {\n  const el = document.createElement('div');\n  el.style.color = color;\n  if (el.style.color !== '') {\n    document.body.appendChild(el);\n    const rgb = getComputedStyle(el).color;\n    document.body.removeChild(el);\n    return rgb;\n  } else {\n    return '';\n  }\n}\n\n/**\n * @param {string} s String.\n * @return {Color} Color.\n */\nexport const fromString = (function () {\n  // We maintain a small cache of parsed strings.  To provide cheap LRU-like\n  // semantics, whenever the cache grows too large we simply delete an\n  // arbitrary 25% of the entries.\n\n  /**\n   * @const\n   * @type {number}\n   */\n  const MAX_CACHE_SIZE = 1024;\n\n  /**\n   * @type {Object<string, Color>}\n   */\n  const cache = {};\n\n  /**\n   * @type {number}\n   */\n  let cacheSize = 0;\n\n  return (\n    /**\n     * @param {string} s String.\n     * @return {Color} Color.\n     */\n    function (s) {\n      let color;\n      if (cache.hasOwnProperty(s)) {\n        color = cache[s];\n      } else {\n        if (cacheSize >= MAX_CACHE_SIZE) {\n          let i = 0;\n          for (const key in cache) {\n            if ((i++ & 3) === 0) {\n              delete cache[key];\n              --cacheSize;\n            }\n          }\n        }\n        color = fromStringInternal_(s);\n        cache[s] = color;\n        ++cacheSize;\n      }\n      return color;\n    }\n  );\n})();\n\n/**\n * Return the color as an array. This function maintains a cache of calculated\n * arrays which means the result should not be modified.\n * @param {Color|string} color Color.\n * @return {Color} Color.\n * @api\n */\nexport function asArray(color) {\n  if (Array.isArray(color)) {\n    return color;\n  } else {\n    return fromString(color);\n  }\n}\n\n/**\n * @param {string} s String.\n * @private\n * @return {Color} Color.\n */\nfunction fromStringInternal_(s) {\n  let r, g, b, a, color;\n\n  if (NAMED_COLOR_RE_.exec(s)) {\n    s = fromNamed(s);\n  }\n\n  if (HEX_COLOR_RE_.exec(s)) {\n    // hex\n    const n = s.length - 1; // number of hex digits\n    let d; // number of digits per channel\n    if (n <= 4) {\n      d = 1;\n    } else {\n      d = 2;\n    }\n    const hasAlpha = n === 4 || n === 8;\n    r = parseInt(s.substr(1 + 0 * d, d), 16);\n    g = parseInt(s.substr(1 + 1 * d, d), 16);\n    b = parseInt(s.substr(1 + 2 * d, d), 16);\n    if (hasAlpha) {\n      a = parseInt(s.substr(1 + 3 * d, d), 16);\n    } else {\n      a = 255;\n    }\n    if (d == 1) {\n      r = (r << 4) + r;\n      g = (g << 4) + g;\n      b = (b << 4) + b;\n      if (hasAlpha) {\n        a = (a << 4) + a;\n      }\n    }\n    color = [r, g, b, a / 255];\n  } else if (s.indexOf('rgba(') == 0) {\n    // rgba()\n    color = s.slice(5, -1).split(',').map(Number);\n    normalize(color);\n  } else if (s.indexOf('rgb(') == 0) {\n    // rgb()\n    color = s.slice(4, -1).split(',').map(Number);\n    color.push(1);\n    normalize(color);\n  } else {\n    assert(false, 14); // Invalid color\n  }\n  return color;\n}\n\n/**\n * TODO this function is only used in the test, we probably shouldn't export it\n * @param {Color} color Color.\n * @return {Color} Clamped color.\n */\nexport function normalize(color) {\n  color[0] = clamp((color[0] + 0.5) | 0, 0, 255);\n  color[1] = clamp((color[1] + 0.5) | 0, 0, 255);\n  color[2] = clamp((color[2] + 0.5) | 0, 0, 255);\n  color[3] = clamp(color[3], 0, 1);\n  return color;\n}\n\n/**\n * @param {Color} color Color.\n * @return {string} String.\n */\nexport function toString(color) {\n  let r = color[0];\n  if (r != (r | 0)) {\n    r = (r + 0.5) | 0;\n  }\n  let g = color[1];\n  if (g != (g | 0)) {\n    g = (g + 0.5) | 0;\n  }\n  let b = color[2];\n  if (b != (b | 0)) {\n    b = (b + 0.5) | 0;\n  }\n  const a = color[3] === undefined ? 1 : color[3];\n  return 'rgba(' + r + ',' + g + ',' + b + ',' + a + ')';\n}\n\n/**\n * @param {string} s String.\n * @return {boolean} Whether the string is actually a valid color\n */\nexport function isStringColor(s) {\n  if (NAMED_COLOR_RE_.test(s)) {\n    s = fromNamed(s);\n  }\n  return (\n    HEX_COLOR_RE_.test(s) || s.indexOf('rgba(') === 0 || s.indexOf('rgb(') === 0\n  );\n}\n","/**\n * @module ol/style/IconImageCache\n */\nimport {asString} from '../color.js';\n\n/**\n * @classdesc\n * Singleton class. Available through {@link module:ol/style/IconImageCache~shared}.\n */\nclass IconImageCache {\n  constructor() {\n    /**\n     * @type {!Object<string, import(\"./IconImage.js\").default>}\n     * @private\n     */\n    this.cache_ = {};\n\n    /**\n     * @type {number}\n     * @private\n     */\n    this.cacheSize_ = 0;\n\n    /**\n     * @type {number}\n     * @private\n     */\n    this.maxCacheSize_ = 32;\n  }\n\n  /**\n   * FIXME empty description for jsdoc\n   */\n  clear() {\n    this.cache_ = {};\n    this.cacheSize_ = 0;\n  }\n\n  /**\n   * @return {boolean} Can expire cache.\n   */\n  canExpireCache() {\n    return this.cacheSize_ > this.maxCacheSize_;\n  }\n\n  /**\n   * FIXME empty description for jsdoc\n   */\n  expire() {\n    if (this.canExpireCache()) {\n      let i = 0;\n      for (const key in this.cache_) {\n        const iconImage = this.cache_[key];\n        if ((i++ & 3) === 0 && !iconImage.hasListener()) {\n          delete this.cache_[key];\n          --this.cacheSize_;\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {string} src Src.\n   * @param {?string} crossOrigin Cross origin.\n   * @param {import(\"../color.js\").Color} color Color.\n   * @return {import(\"./IconImage.js\").default} Icon image.\n   */\n  get(src, crossOrigin, color) {\n    const key = getKey(src, crossOrigin, color);\n    return key in this.cache_ ? this.cache_[key] : null;\n  }\n\n  /**\n   * @param {string} src Src.\n   * @param {?string} crossOrigin Cross origin.\n   * @param {import(\"../color.js\").Color} color Color.\n   * @param {import(\"./IconImage.js\").default} iconImage Icon image.\n   */\n  set(src, crossOrigin, color, iconImage) {\n    const key = getKey(src, crossOrigin, color);\n    this.cache_[key] = iconImage;\n    ++this.cacheSize_;\n  }\n\n  /**\n   * Set the cache size of the icon cache. Default is `32`. Change this value when\n   * your map uses more than 32 different icon images and you are not caching icon\n   * styles on the application level.\n   * @param {number} maxCacheSize Cache max size.\n   * @api\n   */\n  setSize(maxCacheSize) {\n    this.maxCacheSize_ = maxCacheSize;\n    this.expire();\n  }\n}\n\n/**\n * @param {string} src Src.\n * @param {?string} crossOrigin Cross origin.\n * @param {import(\"../color.js\").Color} color Color.\n * @return {string} Cache key.\n */\nfunction getKey(src, crossOrigin, color) {\n  const colorString = color ? asString(color) : 'null';\n  return crossOrigin + ':' + src + ':' + colorString;\n}\n\nexport default IconImageCache;\n\n/**\n * The {@link module:ol/style/IconImageCache~IconImageCache} for\n * {@link module:ol/style/Icon~Icon} images.\n * @api\n */\nexport const shared = new IconImageCache();\n","/**\n * @module ol/ImageBase\n */\nimport EventTarget from './events/Target.js';\nimport EventType from './events/EventType.js';\nimport {abstract} from './util.js';\n\n/**\n * @abstract\n */\nclass ImageBase extends EventTarget {\n  /**\n   * @param {import(\"./extent.js\").Extent} extent Extent.\n   * @param {number|undefined} resolution Resolution.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {import(\"./ImageState.js\").default} state State.\n   */\n  constructor(extent, resolution, pixelRatio, state) {\n    super();\n\n    /**\n     * @protected\n     * @type {import(\"./extent.js\").Extent}\n     */\n    this.extent = extent;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.pixelRatio_ = pixelRatio;\n\n    /**\n     * @protected\n     * @type {number|undefined}\n     */\n    this.resolution = resolution;\n\n    /**\n     * @protected\n     * @type {import(\"./ImageState.js\").default}\n     */\n    this.state = state;\n  }\n\n  /**\n   * @protected\n   */\n  changed() {\n    this.dispatchEvent(EventType.CHANGE);\n  }\n\n  /**\n   * @return {import(\"./extent.js\").Extent} Extent.\n   */\n  getExtent() {\n    return this.extent;\n  }\n\n  /**\n   * @abstract\n   * @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.\n   */\n  getImage() {\n    return abstract();\n  }\n\n  /**\n   * @return {number} PixelRatio.\n   */\n  getPixelRatio() {\n    return this.pixelRatio_;\n  }\n\n  /**\n   * @return {number} Resolution.\n   */\n  getResolution() {\n    return /** @type {number} */ (this.resolution);\n  }\n\n  /**\n   * @return {import(\"./ImageState.js\").default} State.\n   */\n  getState() {\n    return this.state;\n  }\n\n  /**\n   * Load not yet loaded URI.\n   * @abstract\n   */\n  load() {\n    abstract();\n  }\n}\n\nexport default ImageBase;\n","/**\n * @module ol/Image\n */\nimport EventType from './events/EventType.js';\nimport ImageBase from './ImageBase.js';\nimport ImageState from './ImageState.js';\nimport {IMAGE_DECODE} from './has.js';\nimport {getHeight} from './extent.js';\nimport {listenOnce, unlistenByKey} from './events.js';\n\n/**\n * A function that takes an {@link module:ol/Image~Image} for the image and a\n * `{string}` for the src as arguments. It is supposed to make it so the\n * underlying image {@link module:ol/Image~Image#getImage} is assigned the\n * content specified by the src. If not specified, the default is\n *\n *     function(image, src) {\n *       image.getImage().src = src;\n *     }\n *\n * Providing a custom `imageLoadFunction` can be useful to load images with\n * post requests or - in general - through XHR requests, where the src of the\n * image element would be set to a data URI when the content is loaded.\n *\n * @typedef {function(ImageWrapper, string): void} LoadFunction\n * @api\n */\n\nclass ImageWrapper extends ImageBase {\n  /**\n   * @param {import(\"./extent.js\").Extent} extent Extent.\n   * @param {number|undefined} resolution Resolution.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {string} src Image source URI.\n   * @param {?string} crossOrigin Cross origin.\n   * @param {LoadFunction} imageLoadFunction Image load function.\n   */\n  constructor(\n    extent,\n    resolution,\n    pixelRatio,\n    src,\n    crossOrigin,\n    imageLoadFunction\n  ) {\n    super(extent, resolution, pixelRatio, ImageState.IDLE);\n\n    /**\n     * @private\n     * @type {string}\n     */\n    this.src_ = src;\n\n    /**\n     * @private\n     * @type {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement}\n     */\n    this.image_ = new Image();\n    if (crossOrigin !== null) {\n      this.image_.crossOrigin = crossOrigin;\n    }\n\n    /**\n     * @private\n     * @type {?function():void}\n     */\n    this.unlisten_ = null;\n\n    /**\n     * @protected\n     * @type {import(\"./ImageState.js\").default}\n     */\n    this.state = ImageState.IDLE;\n\n    /**\n     * @private\n     * @type {LoadFunction}\n     */\n    this.imageLoadFunction_ = imageLoadFunction;\n  }\n\n  /**\n   * @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.\n   * @api\n   */\n  getImage() {\n    return this.image_;\n  }\n\n  /**\n   * Tracks loading or read errors.\n   *\n   * @private\n   */\n  handleImageError_() {\n    this.state = ImageState.ERROR;\n    this.unlistenImage_();\n    this.changed();\n  }\n\n  /**\n   * Tracks successful image load.\n   *\n   * @private\n   */\n  handleImageLoad_() {\n    if (this.resolution === undefined) {\n      this.resolution = getHeight(this.extent) / this.image_.height;\n    }\n    this.state = ImageState.LOADED;\n    this.unlistenImage_();\n    this.changed();\n  }\n\n  /**\n   * Load the image or retry if loading previously failed.\n   * Loading is taken care of by the tile queue, and calling this method is\n   * only needed for preloading or for reloading in case of an error.\n   * @api\n   */\n  load() {\n    if (this.state == ImageState.IDLE || this.state == ImageState.ERROR) {\n      this.state = ImageState.LOADING;\n      this.changed();\n      this.imageLoadFunction_(this, this.src_);\n      this.unlisten_ = listenImage(\n        this.image_,\n        this.handleImageLoad_.bind(this),\n        this.handleImageError_.bind(this)\n      );\n    }\n  }\n\n  /**\n   * @param {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} image Image.\n   */\n  setImage(image) {\n    this.image_ = image;\n  }\n\n  /**\n   * Discards event handlers which listen for load completion or errors.\n   *\n   * @private\n   */\n  unlistenImage_() {\n    if (this.unlisten_) {\n      this.unlisten_();\n      this.unlisten_ = null;\n    }\n  }\n}\n\n/**\n * @param {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} image Image element.\n * @param {function():any} loadHandler Load callback function.\n * @param {function():any} errorHandler Error callback function.\n * @return {function():void} Callback to stop listening.\n */\nexport function listenImage(image, loadHandler, errorHandler) {\n  const img = /** @type {HTMLImageElement} */ (image);\n\n  if (img.src && IMAGE_DECODE) {\n    const promise = img.decode();\n    let listening = true;\n    const unlisten = function () {\n      listening = false;\n    };\n    promise\n      .then(function () {\n        if (listening) {\n          loadHandler();\n        }\n      })\n      .catch(function (error) {\n        if (listening) {\n          // FIXME: Unconditionally call errorHandler() when this bug is fixed upstream:\n          //        https://bugs.webkit.org/show_bug.cgi?id=198527\n          if (\n            error.name === 'EncodingError' &&\n            error.message === 'Invalid image type.'\n          ) {\n            loadHandler();\n          } else {\n            errorHandler();\n          }\n        }\n      });\n    return unlisten;\n  }\n\n  const listenerKeys = [\n    listenOnce(img, EventType.LOAD, loadHandler),\n    listenOnce(img, EventType.ERROR, errorHandler),\n  ];\n  return function unlisten() {\n    listenerKeys.forEach(unlistenByKey);\n  };\n}\n\nexport default ImageWrapper;\n","/**\n * @module ol/style/IconImage\n */\n\nimport EventTarget from '../events/Target.js';\nimport EventType from '../events/EventType.js';\nimport ImageState from '../ImageState.js';\nimport {asString} from '../color.js';\nimport {createCanvasContext2D} from '../dom.js';\nimport {shared as iconImageCache} from './IconImageCache.js';\nimport {listenImage} from '../Image.js';\n\n/**\n * @type {CanvasRenderingContext2D}\n */\nlet taintedTestContext = null;\n\nclass IconImage extends EventTarget {\n  /**\n   * @param {HTMLImageElement|HTMLCanvasElement} image Image.\n   * @param {string|undefined} src Src.\n   * @param {import(\"../size.js\").Size} size Size.\n   * @param {?string} crossOrigin Cross origin.\n   * @param {import(\"../ImageState.js\").default} imageState Image state.\n   * @param {import(\"../color.js\").Color} color Color.\n   */\n  constructor(image, src, size, crossOrigin, imageState, color) {\n    super();\n\n    /**\n     * @private\n     * @type {HTMLImageElement|HTMLCanvasElement}\n     */\n    this.hitDetectionImage_ = null;\n\n    /**\n     * @private\n     * @type {HTMLImageElement|HTMLCanvasElement}\n     */\n    this.image_ = !image ? new Image() : image;\n\n    if (crossOrigin !== null) {\n      /** @type {HTMLImageElement} */ (this.image_).crossOrigin = crossOrigin;\n    }\n\n    /**\n     * @private\n     * @type {Object<number, HTMLCanvasElement>}\n     */\n    this.canvas_ = {};\n\n    /**\n     * @private\n     * @type {import(\"../color.js\").Color}\n     */\n    this.color_ = color;\n\n    /**\n     * @private\n     * @type {?function():void}\n     */\n    this.unlisten_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../ImageState.js\").default}\n     */\n    this.imageState_ = imageState;\n\n    /**\n     * @private\n     * @type {import(\"../size.js\").Size}\n     */\n    this.size_ = size;\n\n    /**\n     * @private\n     * @type {string|undefined}\n     */\n    this.src_ = src;\n\n    /**\n     * @private\n     */\n    this.tainted_;\n  }\n\n  /**\n   * @private\n   * @return {boolean} The image canvas is tainted.\n   */\n  isTainted_() {\n    if (this.tainted_ === undefined && this.imageState_ === ImageState.LOADED) {\n      if (!taintedTestContext) {\n        taintedTestContext = createCanvasContext2D(1, 1);\n      }\n      taintedTestContext.drawImage(this.image_, 0, 0);\n      try {\n        taintedTestContext.getImageData(0, 0, 1, 1);\n        this.tainted_ = false;\n      } catch (e) {\n        taintedTestContext = null;\n        this.tainted_ = true;\n      }\n    }\n    return this.tainted_ === true;\n  }\n\n  /**\n   * @private\n   */\n  dispatchChangeEvent_() {\n    this.dispatchEvent(EventType.CHANGE);\n  }\n\n  /**\n   * @private\n   */\n  handleImageError_() {\n    this.imageState_ = ImageState.ERROR;\n    this.unlistenImage_();\n    this.dispatchChangeEvent_();\n  }\n\n  /**\n   * @private\n   */\n  handleImageLoad_() {\n    this.imageState_ = ImageState.LOADED;\n    if (this.size_) {\n      this.image_.width = this.size_[0];\n      this.image_.height = this.size_[1];\n    } else {\n      this.size_ = [this.image_.width, this.image_.height];\n    }\n    this.unlistenImage_();\n    this.dispatchChangeEvent_();\n  }\n\n  /**\n   * @param {number} pixelRatio Pixel ratio.\n   * @return {HTMLImageElement|HTMLCanvasElement} Image or Canvas element.\n   */\n  getImage(pixelRatio) {\n    this.replaceColor_(pixelRatio);\n    return this.canvas_[pixelRatio] ? this.canvas_[pixelRatio] : this.image_;\n  }\n\n  /**\n   * @param {number} pixelRatio Pixel ratio.\n   * @return {number} Image or Canvas element.\n   */\n  getPixelRatio(pixelRatio) {\n    this.replaceColor_(pixelRatio);\n    return this.canvas_[pixelRatio] ? pixelRatio : 1;\n  }\n\n  /**\n   * @return {import(\"../ImageState.js\").default} Image state.\n   */\n  getImageState() {\n    return this.imageState_;\n  }\n\n  /**\n   * @return {HTMLImageElement|HTMLCanvasElement} Image element.\n   */\n  getHitDetectionImage() {\n    if (!this.hitDetectionImage_) {\n      if (this.isTainted_()) {\n        const width = this.size_[0];\n        const height = this.size_[1];\n        const context = createCanvasContext2D(width, height);\n        context.fillRect(0, 0, width, height);\n        this.hitDetectionImage_ = context.canvas;\n      } else {\n        this.hitDetectionImage_ = this.image_;\n      }\n    }\n    return this.hitDetectionImage_;\n  }\n\n  /**\n   * Get the size of the icon (in pixels).\n   * @return {import(\"../size.js\").Size} Image size.\n   */\n  getSize() {\n    return this.size_;\n  }\n\n  /**\n   * @return {string|undefined} Image src.\n   */\n  getSrc() {\n    return this.src_;\n  }\n\n  /**\n   * Load not yet loaded URI.\n   */\n  load() {\n    if (this.imageState_ == ImageState.IDLE) {\n      this.imageState_ = ImageState.LOADING;\n      try {\n        /** @type {HTMLImageElement} */ (this.image_).src = this.src_;\n      } catch (e) {\n        this.handleImageError_();\n      }\n      this.unlisten_ = listenImage(\n        this.image_,\n        this.handleImageLoad_.bind(this),\n        this.handleImageError_.bind(this)\n      );\n    }\n  }\n\n  /**\n   * @param {number} pixelRatio Pixel ratio.\n   * @private\n   */\n  replaceColor_(pixelRatio) {\n    if (!this.color_ || this.canvas_[pixelRatio]) {\n      return;\n    }\n\n    const canvas = document.createElement('canvas');\n    this.canvas_[pixelRatio] = canvas;\n\n    canvas.width = Math.ceil(this.image_.width * pixelRatio);\n    canvas.height = Math.ceil(this.image_.height * pixelRatio);\n\n    const ctx = canvas.getContext('2d');\n    ctx.scale(pixelRatio, pixelRatio);\n    ctx.drawImage(this.image_, 0, 0);\n\n    ctx.globalCompositeOperation = 'multiply';\n    // Internet Explorer 11 does not support the multiply operation.\n    // If the canvas is tainted in Internet Explorer this still produces\n    // a solid color image with the shape of the icon.\n    if (ctx.globalCompositeOperation === 'multiply' || this.isTainted_()) {\n      ctx.fillStyle = asString(this.color_);\n      ctx.fillRect(0, 0, canvas.width, canvas.height);\n\n      ctx.globalCompositeOperation = 'destination-in';\n      ctx.drawImage(this.image_, 0, 0);\n    } else {\n      const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);\n      const data = imgData.data;\n      const r = this.color_[0] / 255.0;\n      const g = this.color_[1] / 255.0;\n      const b = this.color_[2] / 255.0;\n      const a = this.color_[3];\n\n      for (let i = 0, ii = data.length; i < ii; i += 4) {\n        data[i] *= r;\n        data[i + 1] *= g;\n        data[i + 2] *= b;\n        data[i + 3] *= a;\n      }\n      ctx.putImageData(imgData, 0, 0);\n    }\n  }\n\n  /**\n   * Discards event handlers which listen for load completion or errors.\n   *\n   * @private\n   */\n  unlistenImage_() {\n    if (this.unlisten_) {\n      this.unlisten_();\n      this.unlisten_ = null;\n    }\n  }\n}\n\n/**\n * @param {HTMLImageElement|HTMLCanvasElement} image Image.\n * @param {string} src Src.\n * @param {import(\"../size.js\").Size} size Size.\n * @param {?string} crossOrigin Cross origin.\n * @param {import(\"../ImageState.js\").default} imageState Image state.\n * @param {import(\"../color.js\").Color} color Color.\n * @return {IconImage} Icon image.\n */\nexport function get(image, src, size, crossOrigin, imageState, color) {\n  let iconImage = iconImageCache.get(src, crossOrigin, color);\n  if (!iconImage) {\n    iconImage = new IconImage(image, src, size, crossOrigin, imageState, color);\n    iconImageCache.set(src, crossOrigin, color, iconImage);\n  }\n  return iconImage;\n}\n\nexport default IconImage;\n","/**\n * @module ol/style/Icon\n */\nimport EventType from '../events/EventType.js';\nimport IconAnchorUnits from './IconAnchorUnits.js';\nimport IconOrigin from './IconOrigin.js';\nimport ImageState from '../ImageState.js';\nimport ImageStyle from './Image.js';\nimport {asArray} from '../color.js';\nimport {assert} from '../asserts.js';\nimport {get as getIconImage} from './IconImage.js';\nimport {getUid} from '../util.js';\n\n/**\n * @typedef {Object} Options\n * @property {Array<number>} [anchor=[0.5, 0.5]] Anchor. Default value is the icon center.\n * @property {import(\"./IconOrigin.js\").default} [anchorOrigin='top-left'] Origin of the anchor: `bottom-left`, `bottom-right`,\n * `top-left` or `top-right`.\n * @property {import(\"./IconAnchorUnits.js\").default} [anchorXUnits='fraction'] Units in which the anchor x value is\n * specified. A value of `'fraction'` indicates the x value is a fraction of the icon. A value of `'pixels'` indicates\n * the x value in pixels.\n * @property {import(\"./IconAnchorUnits.js\").default} [anchorYUnits='fraction'] Units in which the anchor y value is\n * specified. A value of `'fraction'` indicates the y value is a fraction of the icon. A value of `'pixels'` indicates\n * the y value in pixels.\n * @property {import(\"../color.js\").Color|string} [color] Color to tint the icon. If not specified,\n * the icon will be left as is.\n * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images. Note that you must provide a\n * `crossOrigin` value if you want to access pixel data with the Canvas renderer.\n * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.\n * @property {HTMLImageElement|HTMLCanvasElement} [img] Image object for the icon. If the `src` option is not provided then the\n * provided image must already be loaded. And in that case, it is required\n * to provide the size of the image, with the `imgSize` option.\n * @property {Array<number>} [offset=[0, 0]] Offset, which, together with the size and the offset origin, define the\n * sub-rectangle to use from the original icon image.\n * @property {Array<number>} [displacement=[0,0]] Displacement the icon\n * @property {import(\"./IconOrigin.js\").default} [offsetOrigin='top-left'] Origin of the offset: `bottom-left`, `bottom-right`,\n * `top-left` or `top-right`.\n * @property {number} [opacity=1] Opacity of the icon.\n * @property {number|import(\"../size.js\").Size} [scale=1] Scale.\n * @property {boolean} [rotateWithView=false] Whether to rotate the icon with the view.\n * @property {number} [rotation=0] Rotation in radians (positive rotation clockwise).\n * @property {import(\"../size.js\").Size} [size] Icon size in pixel. Can be used together with `offset` to define the\n * sub-rectangle to use from the origin (sprite) icon image.\n * @property {import(\"../size.js\").Size} [imgSize] Image size in pixels. Only required if `img` is set and `src` is not, and\n * for SVG images in Internet Explorer 11. The provided `imgSize` needs to match the actual size of the image.\n * @property {string} [src] Image source URI.\n */\n\n/**\n * @classdesc\n * Set icon style for vector features.\n * @api\n */\nclass Icon extends ImageStyle {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options || {};\n\n    /**\n     * @type {number}\n     */\n    const opacity = options.opacity !== undefined ? options.opacity : 1;\n\n    /**\n     * @type {number}\n     */\n    const rotation = options.rotation !== undefined ? options.rotation : 0;\n\n    /**\n     * @type {number|import(\"../size.js\").Size}\n     */\n    const scale = options.scale !== undefined ? options.scale : 1;\n\n    /**\n     * @type {boolean}\n     */\n    const rotateWithView =\n      options.rotateWithView !== undefined ? options.rotateWithView : false;\n\n    super({\n      opacity: opacity,\n      rotation: rotation,\n      scale: scale,\n      displacement:\n        options.displacement !== undefined ? options.displacement : [0, 0],\n      rotateWithView: rotateWithView,\n    });\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.anchor_ = options.anchor !== undefined ? options.anchor : [0.5, 0.5];\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.normalizedAnchor_ = null;\n\n    /**\n     * @private\n     * @type {import(\"./IconOrigin.js\").default}\n     */\n    this.anchorOrigin_ =\n      options.anchorOrigin !== undefined\n        ? options.anchorOrigin\n        : IconOrigin.TOP_LEFT;\n\n    /**\n     * @private\n     * @type {import(\"./IconAnchorUnits.js\").default}\n     */\n    this.anchorXUnits_ =\n      options.anchorXUnits !== undefined\n        ? options.anchorXUnits\n        : IconAnchorUnits.FRACTION;\n\n    /**\n     * @private\n     * @type {import(\"./IconAnchorUnits.js\").default}\n     */\n    this.anchorYUnits_ =\n      options.anchorYUnits !== undefined\n        ? options.anchorYUnits\n        : IconAnchorUnits.FRACTION;\n\n    /**\n     * @private\n     * @type {?string}\n     */\n    this.crossOrigin_ =\n      options.crossOrigin !== undefined ? options.crossOrigin : null;\n\n    /**\n     * @type {HTMLImageElement|HTMLCanvasElement}\n     */\n    const image = options.img !== undefined ? options.img : null;\n\n    /**\n     * @type {import(\"../size.js\").Size}\n     */\n    const imgSize = options.imgSize !== undefined ? options.imgSize : null;\n\n    /**\n     * @type {string|undefined}\n     */\n    let src = options.src;\n\n    assert(!(src !== undefined && image), 4); // `image` and `src` cannot be provided at the same time\n    assert(!image || (image && imgSize), 5); // `imgSize` must be set when `image` is provided\n\n    if ((src === undefined || src.length === 0) && image) {\n      src = /** @type {HTMLImageElement} */ (image).src || getUid(image);\n    }\n    assert(src !== undefined && src.length > 0, 6); // A defined and non-empty `src` or `image` must be provided\n\n    /**\n     * @type {import(\"../ImageState.js\").default}\n     */\n    const imageState =\n      options.src !== undefined ? ImageState.IDLE : ImageState.LOADED;\n\n    /**\n     * @private\n     * @type {import(\"../color.js\").Color}\n     */\n    this.color_ = options.color !== undefined ? asArray(options.color) : null;\n\n    /**\n     * @private\n     * @type {import(\"./IconImage.js\").default}\n     */\n    this.iconImage_ = getIconImage(\n      image,\n      /** @type {string} */ (src),\n      imgSize,\n      this.crossOrigin_,\n      imageState,\n      this.color_\n    );\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.offset_ = options.offset !== undefined ? options.offset : [0, 0];\n    /**\n     * @private\n     * @type {import(\"./IconOrigin.js\").default}\n     */\n    this.offsetOrigin_ =\n      options.offsetOrigin !== undefined\n        ? options.offsetOrigin\n        : IconOrigin.TOP_LEFT;\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.origin_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../size.js\").Size}\n     */\n    this.size_ = options.size !== undefined ? options.size : null;\n  }\n\n  /**\n   * Clones the style. The underlying Image/HTMLCanvasElement is not cloned.\n   * @return {Icon} The cloned style.\n   * @api\n   */\n  clone() {\n    const scale = this.getScale();\n    return new Icon({\n      anchor: this.anchor_.slice(),\n      anchorOrigin: this.anchorOrigin_,\n      anchorXUnits: this.anchorXUnits_,\n      anchorYUnits: this.anchorYUnits_,\n      crossOrigin: this.crossOrigin_,\n      color:\n        this.color_ && this.color_.slice\n          ? this.color_.slice()\n          : this.color_ || undefined,\n      src: this.getSrc(),\n      offset: this.offset_.slice(),\n      offsetOrigin: this.offsetOrigin_,\n      size: this.size_ !== null ? this.size_.slice() : undefined,\n      opacity: this.getOpacity(),\n      scale: Array.isArray(scale) ? scale.slice() : scale,\n      rotation: this.getRotation(),\n      rotateWithView: this.getRotateWithView(),\n    });\n  }\n\n  /**\n   * Get the anchor point in pixels. The anchor determines the center point for the\n   * symbolizer.\n   * @return {Array<number>} Anchor.\n   * @api\n   */\n  getAnchor() {\n    if (this.normalizedAnchor_) {\n      return this.normalizedAnchor_;\n    }\n    let anchor = this.anchor_;\n    const size = this.getSize();\n    if (\n      this.anchorXUnits_ == IconAnchorUnits.FRACTION ||\n      this.anchorYUnits_ == IconAnchorUnits.FRACTION\n    ) {\n      if (!size) {\n        return null;\n      }\n      anchor = this.anchor_.slice();\n      if (this.anchorXUnits_ == IconAnchorUnits.FRACTION) {\n        anchor[0] *= size[0];\n      }\n      if (this.anchorYUnits_ == IconAnchorUnits.FRACTION) {\n        anchor[1] *= size[1];\n      }\n    }\n\n    if (this.anchorOrigin_ != IconOrigin.TOP_LEFT) {\n      if (!size) {\n        return null;\n      }\n      if (anchor === this.anchor_) {\n        anchor = this.anchor_.slice();\n      }\n      if (\n        this.anchorOrigin_ == IconOrigin.TOP_RIGHT ||\n        this.anchorOrigin_ == IconOrigin.BOTTOM_RIGHT\n      ) {\n        anchor[0] = -anchor[0] + size[0];\n      }\n      if (\n        this.anchorOrigin_ == IconOrigin.BOTTOM_LEFT ||\n        this.anchorOrigin_ == IconOrigin.BOTTOM_RIGHT\n      ) {\n        anchor[1] = -anchor[1] + size[1];\n      }\n    }\n    this.normalizedAnchor_ = anchor;\n    return this.normalizedAnchor_;\n  }\n\n  /**\n   * Set the anchor point. The anchor determines the center point for the\n   * symbolizer.\n   *\n   * @param {Array<number>} anchor Anchor.\n   * @api\n   */\n  setAnchor(anchor) {\n    this.anchor_ = anchor;\n    this.normalizedAnchor_ = null;\n  }\n\n  /**\n   * Get the icon color.\n   * @return {import(\"../color.js\").Color} Color.\n   * @api\n   */\n  getColor() {\n    return this.color_;\n  }\n\n  /**\n   * Get the image icon.\n   * @param {number} pixelRatio Pixel ratio.\n   * @return {HTMLImageElement|HTMLCanvasElement} Image or Canvas element.\n   * @api\n   */\n  getImage(pixelRatio) {\n    return this.iconImage_.getImage(pixelRatio);\n  }\n\n  /**\n   * Get the pixel ratio.\n   * @param {number} pixelRatio Pixel ratio.\n   * @return {number} The pixel ration of the image.\n   * @api\n   */\n  getPixelRatio(pixelRatio) {\n    return this.iconImage_.getPixelRatio(pixelRatio);\n  }\n\n  /**\n   * @return {import(\"../size.js\").Size} Image size.\n   */\n  getImageSize() {\n    return this.iconImage_.getSize();\n  }\n\n  /**\n   * @return {import(\"../size.js\").Size} Size of the hit-detection image.\n   */\n  getHitDetectionImageSize() {\n    return this.getImageSize();\n  }\n\n  /**\n   * @return {import(\"../ImageState.js\").default} Image state.\n   */\n  getImageState() {\n    return this.iconImage_.getImageState();\n  }\n\n  /**\n   * @return {HTMLImageElement|HTMLCanvasElement} Image element.\n   */\n  getHitDetectionImage() {\n    return this.iconImage_.getHitDetectionImage();\n  }\n\n  /**\n   * Get the origin of the symbolizer.\n   * @return {Array<number>} Origin.\n   * @api\n   */\n  getOrigin() {\n    if (this.origin_) {\n      return this.origin_;\n    }\n    let offset = this.offset_;\n    const displacement = this.getDisplacement();\n\n    if (this.offsetOrigin_ != IconOrigin.TOP_LEFT) {\n      const size = this.getSize();\n      const iconImageSize = this.iconImage_.getSize();\n      if (!size || !iconImageSize) {\n        return null;\n      }\n      offset = offset.slice();\n      if (\n        this.offsetOrigin_ == IconOrigin.TOP_RIGHT ||\n        this.offsetOrigin_ == IconOrigin.BOTTOM_RIGHT\n      ) {\n        offset[0] = iconImageSize[0] - size[0] - offset[0];\n      }\n      if (\n        this.offsetOrigin_ == IconOrigin.BOTTOM_LEFT ||\n        this.offsetOrigin_ == IconOrigin.BOTTOM_RIGHT\n      ) {\n        offset[1] = iconImageSize[1] - size[1] - offset[1];\n      }\n    }\n    offset[0] += displacement[0];\n    offset[1] += displacement[1];\n    this.origin_ = offset;\n    return this.origin_;\n  }\n\n  /**\n   * Get the image URL.\n   * @return {string|undefined} Image src.\n   * @api\n   */\n  getSrc() {\n    return this.iconImage_.getSrc();\n  }\n\n  /**\n   * Get the size of the icon (in pixels).\n   * @return {import(\"../size.js\").Size} Image size.\n   * @api\n   */\n  getSize() {\n    return !this.size_ ? this.iconImage_.getSize() : this.size_;\n  }\n\n  /**\n   * @param {function(import(\"../events/Event.js\").default): void} listener Listener function.\n   */\n  listenImageChange(listener) {\n    this.iconImage_.addEventListener(EventType.CHANGE, listener);\n  }\n\n  /**\n   * Load not yet loaded URI.\n   * When rendering a feature with an icon style, the vector renderer will\n   * automatically call this method. However, you might want to call this\n   * method yourself for preloading or other purposes.\n   * @api\n   */\n  load() {\n    this.iconImage_.load();\n  }\n\n  /**\n   * @param {function(import(\"../events/Event.js\").default): void} listener Listener function.\n   */\n  unlistenImageChange(listener) {\n    this.iconImage_.removeEventListener(EventType.CHANGE, listener);\n  }\n}\n\nexport default Icon;\n","/**\n * @module ol/colorlike\n */\nimport {toString} from './color.js';\n\n/**\n * A type accepted by CanvasRenderingContext2D.fillStyle\n * or CanvasRenderingContext2D.strokeStyle.\n * Represents a color, pattern, or gradient. The origin for patterns and\n * gradients as fill style is an increment of 512 css pixels from map coordinate\n * `[0, 0]`. For seamless repeat patterns, width and height of the pattern image\n * must be a factor of two (2, 4, 8, ..., 512).\n *\n * @typedef {string|CanvasPattern|CanvasGradient} ColorLike\n * @api\n */\n\n/**\n * @param {import(\"./color.js\").Color|ColorLike} color Color.\n * @return {ColorLike} The color as an {@link ol/colorlike~ColorLike}.\n * @api\n */\nexport function asColorLike(color) {\n  if (Array.isArray(color)) {\n    return toString(color);\n  } else {\n    return color;\n  }\n}\n","/**\n * @module ol/transform\n */\nimport {assert} from './asserts.js';\n\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/**\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/**\n * @private\n * @type {Transform}\n */\nconst tmp_ = new Array(6);\n\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/**\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/**\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  const a1 = transform1[0];\n  const b1 = transform1[1];\n  const c1 = transform1[2];\n  const d1 = transform1[3];\n  const e1 = transform1[4];\n  const f1 = transform1[5];\n  const a2 = transform2[0];\n  const b2 = transform2[1];\n  const c2 = transform2[2];\n  const d2 = transform2[3];\n  const e2 = transform2[4];\n  const f2 = transform2[5];\n\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\n  return transform1;\n}\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/**\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/**\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  const x = coordinate[0];\n  const 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/**\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  const cos = Math.cos(angle);\n  const sin = Math.sin(angle);\n  return multiply(transform, set(tmp_, cos, sin, -sin, cos, 0, 0));\n}\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/**\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/**\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/**\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  const sin = Math.sin(angle);\n  const 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/**\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` porperty 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/**\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/**\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  const det = determinant(source);\n  assert(det !== 0, 32); // Transformation matrix cannot be inverted\n\n  const a = source[0];\n  const b = source[1];\n  const c = source[2];\n  const d = source[3];\n  const e = source[4];\n  const f = source[5];\n\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\n  return target;\n}\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/**\n * A 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  return 'matrix(' + mat.join(', ') + ')';\n}\n","/**\n * @module ol/render/canvas\n */\nimport BaseObject from '../Object.js';\nimport EventTarget from '../events/Target.js';\nimport {WORKER_OFFSCREEN_CANVAS} from '../has.js';\nimport {clear} from '../obj.js';\nimport {createCanvasContext2D} from '../dom.js';\nimport {getFontParameters} from '../css.js';\nimport {toString} from '../transform.js';\n\n/**\n * @typedef {Object} FillState\n * @property {import(\"../colorlike.js\").ColorLike} fillStyle\n */\n\n/**\n * @typedef Label\n * @property {number} width\n * @property {number} height\n * @property {Array<string|number>} contextInstructions\n */\n\n/**\n * @typedef {Object} FillStrokeState\n * @property {import(\"../colorlike.js\").ColorLike} [currentFillStyle]\n * @property {import(\"../colorlike.js\").ColorLike} [currentStrokeStyle]\n * @property {CanvasLineCap} [currentLineCap]\n * @property {Array<number>} currentLineDash\n * @property {number} [currentLineDashOffset]\n * @property {CanvasLineJoin} [currentLineJoin]\n * @property {number} [currentLineWidth]\n * @property {number} [currentMiterLimit]\n * @property {number} [lastStroke]\n * @property {import(\"../colorlike.js\").ColorLike} [fillStyle]\n * @property {import(\"../colorlike.js\").ColorLike} [strokeStyle]\n * @property {CanvasLineCap} [lineCap]\n * @property {Array<number>} lineDash\n * @property {number} [lineDashOffset]\n * @property {CanvasLineJoin} [lineJoin]\n * @property {number} [lineWidth]\n * @property {number} [miterLimit]\n */\n\n/**\n * @typedef {Object} StrokeState\n * @property {CanvasLineCap} lineCap\n * @property {Array<number>} lineDash\n * @property {number} lineDashOffset\n * @property {CanvasLineJoin} lineJoin\n * @property {number} lineWidth\n * @property {number} miterLimit\n * @property {import(\"../colorlike.js\").ColorLike} strokeStyle\n */\n\n/**\n * @typedef {Object} TextState\n * @property {string} font\n * @property {string} [textAlign]\n * @property {string} textBaseline\n * @property {string} [placement]\n * @property {number} [maxAngle]\n * @property {boolean} [overflow]\n * @property {import(\"../style/Fill.js\").default} [backgroundFill]\n * @property {import(\"../style/Stroke.js\").default} [backgroundStroke]\n * @property {import(\"../size.js\").Size} [scale]\n * @property {Array<number>} [padding]\n */\n\n/**\n * @typedef {Object} SerializableInstructions\n * @property {Array<*>} instructions The rendering instructions.\n * @property {Array<*>} hitDetectionInstructions The rendering hit detection instructions.\n * @property {Array<number>} coordinates The array of all coordinates.\n * @property {!Object<string, TextState>} [textStates] The text states (decluttering).\n * @property {!Object<string, FillState>} [fillStates] The fill states (decluttering).\n * @property {!Object<string, StrokeState>} [strokeStates] The stroke states (decluttering).\n */\n\n/**\n * @typedef {Object<number, import(\"./canvas/Executor.js\").ReplayImageOrLabelArgs>} DeclutterImageWithText\n */\n\n/**\n * @const\n * @type {string}\n */\nexport const defaultFont = '10px sans-serif';\n\n/**\n * @const\n * @type {import(\"../colorlike.js\").ColorLike}\n */\nexport const defaultFillStyle = '#000';\n\n/**\n * @const\n * @type {CanvasLineCap}\n */\nexport const defaultLineCap = 'round';\n\n/**\n * @const\n * @type {Array<number>}\n */\nexport const defaultLineDash = [];\n\n/**\n * @const\n * @type {number}\n */\nexport const defaultLineDashOffset = 0;\n\n/**\n * @const\n * @type {CanvasLineJoin}\n */\nexport const defaultLineJoin = 'round';\n\n/**\n * @const\n * @type {number}\n */\nexport const defaultMiterLimit = 10;\n\n/**\n * @const\n * @type {import(\"../colorlike.js\").ColorLike}\n */\nexport const defaultStrokeStyle = '#000';\n\n/**\n * @const\n * @type {string}\n */\nexport const defaultTextAlign = 'center';\n\n/**\n * @const\n * @type {string}\n */\nexport const defaultTextBaseline = 'middle';\n\n/**\n * @const\n * @type {Array<number>}\n */\nexport const defaultPadding = [0, 0, 0, 0];\n\n/**\n * @const\n * @type {number}\n */\nexport const defaultLineWidth = 1;\n\n/**\n * @type {BaseObject}\n */\nexport const checkedFonts = new BaseObject();\n\n/**\n * The label cache for text rendering. To change the default cache size of 2048\n * entries, use {@link module:ol/structs/LRUCache#setSize}.\n * Deprecated - there is no label cache any more.\n * @type {?}\n * @api\n * @deprecated\n */\nexport const labelCache = new EventTarget();\nlabelCache.setSize = function () {\n  console.warn('labelCache is deprecated.'); //eslint-disable-line\n};\n\n/**\n * @type {CanvasRenderingContext2D}\n */\nlet measureContext = null;\n\n/**\n * @type {string}\n */\nlet measureFont;\n\n/**\n * @type {!Object<string, number>}\n */\nexport const textHeights = {};\n\n/**\n * Clears the label cache when a font becomes available.\n * @param {string} fontSpec CSS font spec.\n */\nexport const registerFont = (function () {\n  const retries = 100;\n  const size = '32px ';\n  const referenceFonts = ['monospace', 'serif'];\n  const len = referenceFonts.length;\n  const text = 'wmytzilWMYTZIL@#/&?$%10\\uF013';\n  let interval, referenceWidth;\n\n  /**\n   * @param {string} fontStyle Css font-style\n   * @param {string} fontWeight Css font-weight\n   * @param {*} fontFamily Css font-family\n   * @return {boolean} Font with style and weight is available\n   */\n  function isAvailable(fontStyle, fontWeight, fontFamily) {\n    let available = true;\n    for (let i = 0; i < len; ++i) {\n      const referenceFont = referenceFonts[i];\n      referenceWidth = measureTextWidth(\n        fontStyle + ' ' + fontWeight + ' ' + size + referenceFont,\n        text\n      );\n      if (fontFamily != referenceFont) {\n        const width = measureTextWidth(\n          fontStyle +\n            ' ' +\n            fontWeight +\n            ' ' +\n            size +\n            fontFamily +\n            ',' +\n            referenceFont,\n          text\n        );\n        // If width and referenceWidth are the same, then the fallback was used\n        // instead of the font we wanted, so the font is not available.\n        available = available && width != referenceWidth;\n      }\n    }\n    if (available) {\n      return true;\n    }\n    return false;\n  }\n\n  function check() {\n    let done = true;\n    const fonts = checkedFonts.getKeys();\n    for (let i = 0, ii = fonts.length; i < ii; ++i) {\n      const font = fonts[i];\n      if (checkedFonts.get(font) < retries) {\n        if (isAvailable.apply(this, font.split('\\n'))) {\n          clear(textHeights);\n          // Make sure that loaded fonts are picked up by Safari\n          measureContext = null;\n          measureFont = undefined;\n          checkedFonts.set(font, retries);\n        } else {\n          checkedFonts.set(font, checkedFonts.get(font) + 1, true);\n          done = false;\n        }\n      }\n    }\n    if (done) {\n      clearInterval(interval);\n      interval = undefined;\n    }\n  }\n\n  return function (fontSpec) {\n    const font = getFontParameters(fontSpec);\n    if (!font) {\n      return;\n    }\n    const families = font.families;\n    for (let i = 0, ii = families.length; i < ii; ++i) {\n      const family = families[i];\n      const key = font.style + '\\n' + font.weight + '\\n' + family;\n      if (checkedFonts.get(key) === undefined) {\n        checkedFonts.set(key, retries, true);\n        if (!isAvailable(font.style, font.weight, family)) {\n          checkedFonts.set(key, 0, true);\n          if (interval === undefined) {\n            interval = setInterval(check, 32);\n          }\n        }\n      }\n    }\n  };\n})();\n\n/**\n * @param {string} font Font to use for measuring.\n * @return {import(\"../size.js\").Size} Measurement.\n */\nexport const measureTextHeight = (function () {\n  /**\n   * @type {HTMLDivElement}\n   */\n  let div;\n  return function (fontSpec) {\n    let height = textHeights[fontSpec];\n    if (height == undefined) {\n      if (WORKER_OFFSCREEN_CANVAS) {\n        const font = getFontParameters(fontSpec);\n        const metrics = measureText(fontSpec, 'Žg');\n        const lineHeight = isNaN(Number(font.lineHeight))\n          ? 1.2\n          : Number(font.lineHeight);\n        height =\n          lineHeight *\n          (metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent);\n      } else {\n        if (!div) {\n          div = document.createElement('div');\n          div.innerHTML = 'M';\n          div.style.margin = '0 !important';\n          div.style.padding = '0 !important';\n          div.style.position = 'absolute !important';\n          div.style.left = '-99999px !important';\n        }\n        div.style.font = fontSpec;\n        document.body.appendChild(div);\n        height = div.offsetHeight;\n        document.body.removeChild(div);\n      }\n      textHeights[fontSpec] = height;\n    }\n    return height;\n  };\n})();\n\n/**\n * @param {string} font Font.\n * @param {string} text Text.\n * @return {TextMetrics} Text metrics.\n */\nfunction measureText(font, text) {\n  if (!measureContext) {\n    measureContext = createCanvasContext2D(1, 1);\n  }\n  if (font != measureFont) {\n    measureContext.font = font;\n    measureFont = measureContext.font;\n  }\n  return measureContext.measureText(text);\n}\n\n/**\n * @param {string} font Font.\n * @param {string} text Text.\n * @return {number} Width.\n */\nexport function measureTextWidth(font, text) {\n  return measureText(font, text).width;\n}\n\n/**\n * Measure text width using a cache.\n * @param {string} font The font.\n * @param {string} text The text to measure.\n * @param {Object<string, number>} cache A lookup of cached widths by text.\n * @returns {number} The text width.\n */\nexport function measureAndCacheTextWidth(font, text, cache) {\n  if (text in cache) {\n    return cache[text];\n  }\n  const width = measureTextWidth(font, text);\n  cache[text] = width;\n  return width;\n}\n\n/**\n * @param {string} font Font to use for measuring.\n * @param {Array<string>} lines Lines to measure.\n * @param {Array<number>} widths Array will be populated with the widths of\n * each line.\n * @return {number} Width of the whole text.\n */\nexport function measureTextWidths(font, lines, widths) {\n  const numLines = lines.length;\n  let width = 0;\n  for (let i = 0; i < numLines; ++i) {\n    const currentWidth = measureTextWidth(font, lines[i]);\n    width = Math.max(width, currentWidth);\n    widths.push(currentWidth);\n  }\n  return width;\n}\n\n/**\n * @param {CanvasRenderingContext2D} context Context.\n * @param {number} rotation Rotation.\n * @param {number} offsetX X offset.\n * @param {number} offsetY Y offset.\n */\nexport function rotateAtOffset(context, rotation, offsetX, offsetY) {\n  if (rotation !== 0) {\n    context.translate(offsetX, offsetY);\n    context.rotate(rotation);\n    context.translate(-offsetX, -offsetY);\n  }\n}\n\n/**\n * @param {CanvasRenderingContext2D} context Context.\n * @param {import(\"../transform.js\").Transform|null} transform Transform.\n * @param {number} opacity Opacity.\n * @param {Label|HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} labelOrImage Label.\n * @param {number} originX Origin X.\n * @param {number} originY Origin Y.\n * @param {number} w Width.\n * @param {number} h Height.\n * @param {number} x X.\n * @param {number} y Y.\n * @param {import(\"../size.js\").Size} scale Scale.\n */\nexport function drawImageOrLabel(\n  context,\n  transform,\n  opacity,\n  labelOrImage,\n  originX,\n  originY,\n  w,\n  h,\n  x,\n  y,\n  scale\n) {\n  context.save();\n\n  if (opacity !== 1) {\n    context.globalAlpha *= opacity;\n  }\n  if (transform) {\n    context.setTransform.apply(context, transform);\n  }\n\n  if (/** @type {*} */ (labelOrImage).contextInstructions) {\n    // label\n    context.translate(x, y);\n    context.scale(scale[0], scale[1]);\n    executeLabelInstructions(/** @type {Label} */ (labelOrImage), context);\n  } else if (scale[0] < 0 || scale[1] < 0) {\n    // flipped image\n    context.translate(x, y);\n    context.scale(scale[0], scale[1]);\n    context.drawImage(\n      /** @type {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} */ (labelOrImage),\n      originX,\n      originY,\n      w,\n      h,\n      0,\n      0,\n      w,\n      h\n    );\n  } else {\n    // if image not flipped translate and scale can be avoided\n    context.drawImage(\n      /** @type {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} */ (labelOrImage),\n      originX,\n      originY,\n      w,\n      h,\n      x,\n      y,\n      w * scale[0],\n      h * scale[1]\n    );\n  }\n\n  context.restore();\n}\n\n/**\n * @param {Label} label Label.\n * @param {CanvasRenderingContext2D} context Context.\n */\nfunction executeLabelInstructions(label, context) {\n  const contextInstructions = label.contextInstructions;\n  for (let i = 0, ii = contextInstructions.length; i < ii; i += 2) {\n    if (Array.isArray(contextInstructions[i + 1])) {\n      context[contextInstructions[i]].apply(\n        context,\n        contextInstructions[i + 1]\n      );\n    } else {\n      context[contextInstructions[i]] = contextInstructions[i + 1];\n    }\n  }\n}\n\n/**\n * @type {HTMLCanvasElement}\n * @private\n */\nlet createTransformStringCanvas = null;\n\n/**\n * @param {import(\"../transform.js\").Transform} transform Transform.\n * @return {string} CSS transform.\n */\nexport function createTransformString(transform) {\n  if (WORKER_OFFSCREEN_CANVAS) {\n    return toString(transform);\n  } else {\n    if (!createTransformStringCanvas) {\n      createTransformStringCanvas = createCanvasContext2D(1, 1).canvas;\n    }\n    createTransformStringCanvas.style.transform = toString(transform);\n    return createTransformStringCanvas.style.transform;\n  }\n}\n","/**\n * @module ol/style/RegularShape\n */\n\nimport ImageState from '../ImageState.js';\nimport ImageStyle from './Image.js';\nimport {asArray} from '../color.js';\nimport {asColorLike} from '../colorlike.js';\nimport {createCanvasContext2D} from '../dom.js';\nimport {\n  defaultFillStyle,\n  defaultLineCap,\n  defaultLineJoin,\n  defaultLineWidth,\n  defaultMiterLimit,\n  defaultStrokeStyle,\n} from '../render/canvas.js';\n\n/**\n * Specify radius for regular polygons, or radius1 and radius2 for stars.\n * @typedef {Object} Options\n * @property {import(\"./Fill.js\").default} [fill] Fill style.\n * @property {number} points Number of points for stars and regular polygons. In case of a polygon, the number of points\n * is the number of sides.\n * @property {number} [radius] Radius of a regular polygon.\n * @property {number} [radius1] Outer radius of a star.\n * @property {number} [radius2] Inner radius of a star.\n * @property {number} [angle=0] Shape's angle in radians. A value of 0 will have one of the shape's point facing up.\n * @property {Array<number>} [displacement=[0,0]] Displacement of the shape\n * @property {import(\"./Stroke.js\").default} [stroke] Stroke style.\n * @property {number} [rotation=0] Rotation in radians (positive rotation clockwise).\n * @property {boolean} [rotateWithView=false] Whether to rotate the shape with the view.\n * @property {number|import(\"../size.js\").Size} [scale=1] Scale. Unless two dimensional scaling is required a better\n * result may be obtained with appropriate settings for `radius`, `radius1` and `radius2`.\n */\n\n/**\n * @typedef {Object} RenderOptions\n * @property {import(\"../colorlike.js\").ColorLike} [strokeStyle]\n * @property {number} strokeWidth\n * @property {number} size\n * @property {CanvasLineCap} lineCap\n * @property {Array<number>} lineDash\n * @property {number} lineDashOffset\n * @property {CanvasLineJoin} lineJoin\n * @property {number} miterLimit\n */\n\n/**\n * @classdesc\n * Set regular shape style for vector features. The resulting shape will be\n * a regular polygon when `radius` is provided, or a star when `radius1` and\n * `radius2` are provided.\n * @api\n */\nclass RegularShape extends ImageStyle {\n  /**\n   * @param {Options} options Options.\n   */\n  constructor(options) {\n    /**\n     * @type {boolean}\n     */\n    const rotateWithView =\n      options.rotateWithView !== undefined ? options.rotateWithView : false;\n\n    super({\n      opacity: 1,\n      rotateWithView: rotateWithView,\n      rotation: options.rotation !== undefined ? options.rotation : 0,\n      scale: options.scale !== undefined ? options.scale : 1,\n      displacement:\n        options.displacement !== undefined ? options.displacement : [0, 0],\n    });\n\n    /**\n     * @private\n     * @type {Object<number, HTMLCanvasElement>}\n     */\n    this.canvas_ = {};\n\n    /**\n     * @private\n     * @type {HTMLCanvasElement}\n     */\n    this.hitDetectionCanvas_ = null;\n\n    /**\n     * @private\n     * @type {import(\"./Fill.js\").default}\n     */\n    this.fill_ = options.fill !== undefined ? options.fill : null;\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.origin_ = [0, 0];\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.points_ = options.points;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.radius_ =\n      options.radius !== undefined ? options.radius : options.radius1;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.radius2_ = options.radius2;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.angle_ = options.angle !== undefined ? options.angle : 0;\n\n    /**\n     * @private\n     * @type {import(\"./Stroke.js\").default}\n     */\n    this.stroke_ = options.stroke !== undefined ? options.stroke : null;\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.anchor_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../size.js\").Size}\n     */\n    this.size_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../size.js\").Size}\n     */\n    this.imageSize_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../size.js\").Size}\n     */\n    this.hitDetectionImageSize_ = null;\n\n    this.render();\n  }\n\n  /**\n   * Clones the style.\n   * @return {RegularShape} The cloned style.\n   * @api\n   */\n  clone() {\n    const scale = this.getScale();\n    const style = new RegularShape({\n      fill: this.getFill() ? this.getFill().clone() : undefined,\n      points: this.getPoints(),\n      radius: this.getRadius(),\n      radius2: this.getRadius2(),\n      angle: this.getAngle(),\n      stroke: this.getStroke() ? this.getStroke().clone() : undefined,\n      rotation: this.getRotation(),\n      rotateWithView: this.getRotateWithView(),\n      scale: Array.isArray(scale) ? scale.slice() : scale,\n      displacement: this.getDisplacement().slice(),\n    });\n    style.setOpacity(this.getOpacity());\n    return style;\n  }\n\n  /**\n   * Get the anchor point in pixels. The anchor determines the center point for the\n   * symbolizer.\n   * @return {Array<number>} Anchor.\n   * @api\n   */\n  getAnchor() {\n    return this.anchor_;\n  }\n\n  /**\n   * Get the angle used in generating the shape.\n   * @return {number} Shape's rotation in radians.\n   * @api\n   */\n  getAngle() {\n    return this.angle_;\n  }\n\n  /**\n   * Get the fill style for the shape.\n   * @return {import(\"./Fill.js\").default} Fill style.\n   * @api\n   */\n  getFill() {\n    return this.fill_;\n  }\n\n  /**\n   * @return {HTMLCanvasElement} Image element.\n   */\n  getHitDetectionImage() {\n    if (!this.hitDetectionCanvas_) {\n      const renderOptions = this.createRenderOptions();\n\n      this.createHitDetectionCanvas_(renderOptions);\n    }\n    return this.hitDetectionCanvas_;\n  }\n\n  /**\n   * Get the image icon.\n   * @param {number} pixelRatio Pixel ratio.\n   * @return {HTMLCanvasElement} Image or Canvas element.\n   * @api\n   */\n  getImage(pixelRatio) {\n    if (!this.canvas_[pixelRatio || 1]) {\n      const renderOptions = this.createRenderOptions();\n\n      const context = createCanvasContext2D(\n        renderOptions.size * pixelRatio || 1,\n        renderOptions.size * pixelRatio || 1\n      );\n\n      this.draw_(renderOptions, context, 0, 0, pixelRatio || 1);\n\n      this.canvas_[pixelRatio || 1] = context.canvas;\n    }\n    return this.canvas_[pixelRatio || 1];\n  }\n\n  /*\n   * Get the image pixel ratio.\n   * @param {number} pixelRatio Pixel ratio.\n   * */\n  getPixelRatio(pixelRatio) {\n    return pixelRatio;\n  }\n\n  /**\n   * @return {import(\"../size.js\").Size} Image size.\n   */\n  getImageSize() {\n    return this.imageSize_;\n  }\n\n  /**\n   * @return {import(\"../size.js\").Size} Size of the hit-detection image.\n   */\n  getHitDetectionImageSize() {\n    return this.hitDetectionImageSize_;\n  }\n\n  /**\n   * @return {import(\"../ImageState.js\").default} Image state.\n   */\n  getImageState() {\n    return ImageState.LOADED;\n  }\n\n  /**\n   * Get the origin of the symbolizer.\n   * @return {Array<number>} Origin.\n   * @api\n   */\n  getOrigin() {\n    return this.origin_;\n  }\n\n  /**\n   * Get the number of points for generating the shape.\n   * @return {number} Number of points for stars and regular polygons.\n   * @api\n   */\n  getPoints() {\n    return this.points_;\n  }\n\n  /**\n   * Get the (primary) radius for the shape.\n   * @return {number} Radius.\n   * @api\n   */\n  getRadius() {\n    return this.radius_;\n  }\n\n  /**\n   * Get the secondary radius for the shape.\n   * @return {number|undefined} Radius2.\n   * @api\n   */\n  getRadius2() {\n    return this.radius2_;\n  }\n\n  /**\n   * Get the size of the symbolizer (in pixels).\n   * @return {import(\"../size.js\").Size} Size.\n   * @api\n   */\n  getSize() {\n    return this.size_;\n  }\n\n  /**\n   * Get the stroke style for the shape.\n   * @return {import(\"./Stroke.js\").default} Stroke style.\n   * @api\n   */\n  getStroke() {\n    return this.stroke_;\n  }\n\n  /**\n   * @param {function(import(\"../events/Event.js\").default): void} listener Listener function.\n   */\n  listenImageChange(listener) {}\n\n  /**\n   * Load not yet loaded URI.\n   */\n  load() {}\n\n  /**\n   * @param {function(import(\"../events/Event.js\").default): void} listener Listener function.\n   */\n  unlistenImageChange(listener) {}\n\n  /**\n   * @returns {RenderOptions}  The render options\n   * @protected\n   */\n  createRenderOptions() {\n    let lineCap = defaultLineCap;\n    let lineJoin = defaultLineJoin;\n    let miterLimit = 0;\n    let lineDash = null;\n    let lineDashOffset = 0;\n    let strokeStyle;\n    let strokeWidth = 0;\n\n    if (this.stroke_) {\n      strokeStyle = this.stroke_.getColor();\n      if (strokeStyle === null) {\n        strokeStyle = defaultStrokeStyle;\n      }\n      strokeStyle = asColorLike(strokeStyle);\n      strokeWidth = this.stroke_.getWidth();\n      if (strokeWidth === undefined) {\n        strokeWidth = defaultLineWidth;\n      }\n      lineDash = this.stroke_.getLineDash();\n      lineDashOffset = this.stroke_.getLineDashOffset();\n      lineJoin = this.stroke_.getLineJoin();\n      if (lineJoin === undefined) {\n        lineJoin = defaultLineJoin;\n      }\n      lineCap = this.stroke_.getLineCap();\n      if (lineCap === undefined) {\n        lineCap = defaultLineCap;\n      }\n      miterLimit = this.stroke_.getMiterLimit();\n      if (miterLimit === undefined) {\n        miterLimit = defaultMiterLimit;\n      }\n    }\n\n    const size = 2 * (this.radius_ + strokeWidth) + 1;\n\n    return {\n      strokeStyle: strokeStyle,\n      strokeWidth: strokeWidth,\n      size: size,\n      lineCap: lineCap,\n      lineDash: lineDash,\n      lineDashOffset: lineDashOffset,\n      lineJoin: lineJoin,\n      miterLimit: miterLimit,\n    };\n  }\n\n  /**\n   * @protected\n   */\n  render() {\n    const renderOptions = this.createRenderOptions();\n\n    const context = createCanvasContext2D(\n      renderOptions.size,\n      renderOptions.size\n    );\n\n    this.draw_(renderOptions, context, 0, 0, 1);\n\n    this.canvas_ = {};\n    this.canvas_[1] = context.canvas;\n\n    // canvas.width and height are rounded to the closest integer\n    const size = context.canvas.width;\n    const imageSize = size;\n    const displacement = this.getDisplacement();\n\n    this.hitDetectionImageSize_ = [renderOptions.size, renderOptions.size];\n    this.createHitDetectionCanvas_(renderOptions);\n\n    this.anchor_ = [size / 2 - displacement[0], size / 2 + displacement[1]];\n    this.size_ = [size, size];\n    this.imageSize_ = [imageSize, imageSize];\n  }\n\n  /**\n   * @private\n   * @param {RenderOptions} renderOptions Render options.\n   * @param {CanvasRenderingContext2D} context The rendering context.\n   * @param {number} x The origin for the symbol (x).\n   * @param {number} y The origin for the symbol (y).\n   * @param {number} pixelRatio The pixel ratio.\n   */\n  draw_(renderOptions, context, x, y, pixelRatio) {\n    let i, angle0, radiusC;\n\n    // reset transform\n    context.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);\n\n    // then move to (x, y)\n    context.translate(x, y);\n\n    context.beginPath();\n\n    let points = this.points_;\n    if (points === Infinity) {\n      context.arc(\n        renderOptions.size / 2,\n        renderOptions.size / 2,\n        this.radius_,\n        0,\n        2 * Math.PI,\n        true\n      );\n    } else {\n      const radius2 =\n        this.radius2_ !== undefined ? this.radius2_ : this.radius_;\n      if (radius2 !== this.radius_) {\n        points = 2 * points;\n      }\n      for (i = 0; i <= points; i++) {\n        angle0 = (i * 2 * Math.PI) / points - Math.PI / 2 + this.angle_;\n        radiusC = i % 2 === 0 ? this.radius_ : radius2;\n        context.lineTo(\n          renderOptions.size / 2 + radiusC * Math.cos(angle0),\n          renderOptions.size / 2 + radiusC * Math.sin(angle0)\n        );\n      }\n    }\n\n    if (this.fill_) {\n      let color = this.fill_.getColor();\n      if (color === null) {\n        color = defaultFillStyle;\n      }\n      context.fillStyle = asColorLike(color);\n      context.fill();\n    }\n    if (this.stroke_) {\n      context.strokeStyle = renderOptions.strokeStyle;\n      context.lineWidth = renderOptions.strokeWidth;\n      if (context.setLineDash && renderOptions.lineDash) {\n        context.setLineDash(renderOptions.lineDash);\n        context.lineDashOffset = renderOptions.lineDashOffset;\n      }\n      context.lineCap = renderOptions.lineCap;\n      context.lineJoin = renderOptions.lineJoin;\n      context.miterLimit = renderOptions.miterLimit;\n      context.stroke();\n    }\n    context.closePath();\n  }\n\n  /**\n   * @private\n   * @param {RenderOptions} renderOptions Render options.\n   */\n  createHitDetectionCanvas_(renderOptions) {\n    this.hitDetectionCanvas_ = this.getImage(1);\n    if (this.fill_) {\n      let color = this.fill_.getColor();\n\n      // determine if fill is transparent (or pattern or gradient)\n      let opacity = 0;\n      if (typeof color === 'string') {\n        color = asArray(color);\n      }\n      if (color === null) {\n        opacity = 1;\n      } else if (Array.isArray(color)) {\n        opacity = color.length === 4 ? color[3] : 1;\n      }\n      if (opacity === 0) {\n        // if a transparent fill style is set, create an extra hit-detection image\n        // with a default fill style\n        const context = createCanvasContext2D(\n          renderOptions.size,\n          renderOptions.size\n        );\n        this.hitDetectionCanvas_ = context.canvas;\n\n        this.drawHitDetectionCanvas_(renderOptions, context, 0, 0);\n      }\n    }\n  }\n\n  /**\n   * @private\n   * @param {RenderOptions} renderOptions Render options.\n   * @param {CanvasRenderingContext2D} context The context.\n   * @param {number} x The origin for the symbol (x).\n   * @param {number} y The origin for the symbol (y).\n   */\n  drawHitDetectionCanvas_(renderOptions, context, x, y) {\n    // move to (x, y)\n    context.translate(x, y);\n\n    context.beginPath();\n\n    let points = this.points_;\n    if (points === Infinity) {\n      context.arc(\n        renderOptions.size / 2,\n        renderOptions.size / 2,\n        this.radius_,\n        0,\n        2 * Math.PI,\n        true\n      );\n    } else {\n      const radius2 =\n        this.radius2_ !== undefined ? this.radius2_ : this.radius_;\n      if (radius2 !== this.radius_) {\n        points = 2 * points;\n      }\n      let i, radiusC, angle0;\n      for (i = 0; i <= points; i++) {\n        angle0 = (i * 2 * Math.PI) / points - Math.PI / 2 + this.angle_;\n        radiusC = i % 2 === 0 ? this.radius_ : radius2;\n        context.lineTo(\n          renderOptions.size / 2 + radiusC * Math.cos(angle0),\n          renderOptions.size / 2 + radiusC * Math.sin(angle0)\n        );\n      }\n    }\n\n    context.fillStyle = defaultFillStyle;\n    context.fill();\n    if (this.stroke_) {\n      context.strokeStyle = renderOptions.strokeStyle;\n      context.lineWidth = renderOptions.strokeWidth;\n      if (renderOptions.lineDash) {\n        context.setLineDash(renderOptions.lineDash);\n        context.lineDashOffset = renderOptions.lineDashOffset;\n      }\n      context.stroke();\n    }\n    context.closePath();\n  }\n}\n\nexport default RegularShape;\n","/**\n * @module ol/style/Circle\n */\n\nimport RegularShape from './RegularShape.js';\n\n/**\n * @typedef {Object} Options\n * @property {import(\"./Fill.js\").default} [fill] Fill style.\n * @property {number} radius Circle radius.\n * @property {import(\"./Stroke.js\").default} [stroke] Stroke style.\n * @property {Array<number>} [displacement=[0,0]] displacement\n * @property {number|import(\"../size.js\").Size} [scale=1] Scale. A two dimensional scale will produce an ellipse.\n * Unless two dimensional scaling is required a better result may be obtained with an appropriate setting for `radius`.\n * @property {number} [rotation=0] Rotation in radians\n * (positive rotation clockwise, meaningful only when used in conjunction with a two dimensional scale).\n * @property {boolean} [rotateWithView=false] Whether to rotate the shape with the view\n * (meaningful only when used in conjunction with a two dimensional scale).\n */\n\n/**\n * @classdesc\n * Set circle style for vector features.\n * @api\n */\nclass CircleStyle extends RegularShape {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    super({\n      points: Infinity,\n      fill: options.fill,\n      radius: options.radius,\n      stroke: options.stroke,\n      scale: options.scale !== undefined ? options.scale : 1,\n      rotation: options.rotation !== undefined ? options.rotation : 0,\n      rotateWithView:\n        options.rotateWithView !== undefined ? options.rotateWithView : false,\n      displacement:\n        options.displacement !== undefined ? options.displacement : [0, 0],\n    });\n  }\n\n  /**\n   * Clones the style.\n   * @return {CircleStyle} The cloned style.\n   * @api\n   */\n  clone() {\n    const scale = this.getScale();\n    const style = new CircleStyle({\n      fill: this.getFill() ? this.getFill().clone() : undefined,\n      stroke: this.getStroke() ? this.getStroke().clone() : undefined,\n      radius: this.getRadius(),\n      scale: Array.isArray(scale) ? scale.slice() : scale,\n      rotation: this.getRotation(),\n      rotateWithView: this.getRotateWithView(),\n      displacement: this.getDisplacement().slice(),\n    });\n    style.setOpacity(this.getOpacity());\n    return style;\n  }\n\n  /**\n   * Set the circle radius.\n   *\n   * @param {number} radius Circle radius.\n   * @api\n   */\n  setRadius(radius) {\n    this.radius_ = radius;\n    this.render();\n  }\n}\n\nexport default CircleStyle;\n","/**\n * @module ol/style/Fill\n */\n\n/**\n * @typedef {Object} Options\n * @property {import(\"../color.js\").Color|import(\"../colorlike.js\").ColorLike} [color=null] A color, gradient or pattern.\n * See {@link module:ol/color~Color} and {@link module:ol/colorlike~ColorLike} for possible formats.\n * Default null; if null, the Canvas/renderer default black will be used.\n */\n\n/**\n * @classdesc\n * Set fill style for vector features.\n * @api\n */\nclass Fill {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options || {};\n\n    /**\n     * @private\n     * @type {import(\"../color.js\").Color|import(\"../colorlike.js\").ColorLike}\n     */\n    this.color_ = options.color !== undefined ? options.color : null;\n  }\n\n  /**\n   * Clones the style. The color is not cloned if it is an {@link module:ol/colorlike~ColorLike}.\n   * @return {Fill} The cloned style.\n   * @api\n   */\n  clone() {\n    const color = this.getColor();\n    return new Fill({\n      color: Array.isArray(color) ? color.slice() : color || undefined,\n    });\n  }\n\n  /**\n   * Get the fill color.\n   * @return {import(\"../color.js\").Color|import(\"../colorlike.js\").ColorLike} Color.\n   * @api\n   */\n  getColor() {\n    return this.color_;\n  }\n\n  /**\n   * Set the color.\n   *\n   * @param {import(\"../color.js\").Color|import(\"../colorlike.js\").ColorLike} color Color.\n   * @api\n   */\n  setColor(color) {\n    this.color_ = color;\n  }\n}\n\nexport default Fill;\n","/**\n * @module ol/style/Stroke\n */\n\n/**\n * @typedef {Object} Options\n * @property {import(\"../color.js\").Color|import(\"../colorlike.js\").ColorLike} [color] A color, gradient or pattern.\n * See {@link module:ol/color~Color} and {@link module:ol/colorlike~ColorLike} for possible formats.\n * Default null; if null, the Canvas/renderer default black will be used.\n * @property {CanvasLineCap} [lineCap='round'] Line cap style: `butt`, `round`, or `square`.\n * @property {CanvasLineJoin} [lineJoin='round'] Line join style: `bevel`, `round`, or `miter`.\n * @property {Array<number>} [lineDash] Line dash pattern. Default is `null` (no dash).\n * Please note that Internet Explorer 10 and lower do not support the `setLineDash` method on\n * the `CanvasRenderingContext2D` and therefore this option will have no visual effect in these browsers.\n * @property {number} [lineDashOffset=0] Line dash offset.\n * @property {number} [miterLimit=10] Miter limit.\n * @property {number} [width] Width.\n */\n\n/**\n * @classdesc\n * Set stroke style for vector features.\n * Note that the defaults given are the Canvas defaults, which will be used if\n * option is not defined. The `get` functions return whatever was entered in\n * the options; they will not return the default.\n * @api\n */\nclass Stroke {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options || {};\n\n    /**\n     * @private\n     * @type {import(\"../color.js\").Color|import(\"../colorlike.js\").ColorLike}\n     */\n    this.color_ = options.color !== undefined ? options.color : null;\n\n    /**\n     * @private\n     * @type {CanvasLineCap|undefined}\n     */\n    this.lineCap_ = options.lineCap;\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.lineDash_ = options.lineDash !== undefined ? options.lineDash : null;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.lineDashOffset_ = options.lineDashOffset;\n\n    /**\n     * @private\n     * @type {CanvasLineJoin|undefined}\n     */\n    this.lineJoin_ = options.lineJoin;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.miterLimit_ = options.miterLimit;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.width_ = options.width;\n  }\n\n  /**\n   * Clones the style.\n   * @return {Stroke} The cloned style.\n   * @api\n   */\n  clone() {\n    const color = this.getColor();\n    return new Stroke({\n      color: Array.isArray(color) ? color.slice() : color || undefined,\n      lineCap: this.getLineCap(),\n      lineDash: this.getLineDash() ? this.getLineDash().slice() : undefined,\n      lineDashOffset: this.getLineDashOffset(),\n      lineJoin: this.getLineJoin(),\n      miterLimit: this.getMiterLimit(),\n      width: this.getWidth(),\n    });\n  }\n\n  /**\n   * Get the stroke color.\n   * @return {import(\"../color.js\").Color|import(\"../colorlike.js\").ColorLike} Color.\n   * @api\n   */\n  getColor() {\n    return this.color_;\n  }\n\n  /**\n   * Get the line cap type for the stroke.\n   * @return {CanvasLineCap|undefined} Line cap.\n   * @api\n   */\n  getLineCap() {\n    return this.lineCap_;\n  }\n\n  /**\n   * Get the line dash style for the stroke.\n   * @return {Array<number>} Line dash.\n   * @api\n   */\n  getLineDash() {\n    return this.lineDash_;\n  }\n\n  /**\n   * Get the line dash offset for the stroke.\n   * @return {number|undefined} Line dash offset.\n   * @api\n   */\n  getLineDashOffset() {\n    return this.lineDashOffset_;\n  }\n\n  /**\n   * Get the line join type for the stroke.\n   * @return {CanvasLineJoin|undefined} Line join.\n   * @api\n   */\n  getLineJoin() {\n    return this.lineJoin_;\n  }\n\n  /**\n   * Get the miter limit for the stroke.\n   * @return {number|undefined} Miter limit.\n   * @api\n   */\n  getMiterLimit() {\n    return this.miterLimit_;\n  }\n\n  /**\n   * Get the stroke width.\n   * @return {number|undefined} Width.\n   * @api\n   */\n  getWidth() {\n    return this.width_;\n  }\n\n  /**\n   * Set the color.\n   *\n   * @param {import(\"../color.js\").Color|import(\"../colorlike.js\").ColorLike} color Color.\n   * @api\n   */\n  setColor(color) {\n    this.color_ = color;\n  }\n\n  /**\n   * Set the line cap.\n   *\n   * @param {CanvasLineCap|undefined} lineCap Line cap.\n   * @api\n   */\n  setLineCap(lineCap) {\n    this.lineCap_ = lineCap;\n  }\n\n  /**\n   * Set the line dash.\n   *\n   * Please note that Internet Explorer 10 and lower [do not support][mdn] the\n   * `setLineDash` method on the `CanvasRenderingContext2D` and therefore this\n   * property will have no visual effect in these browsers.\n   *\n   * [mdn]: https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/setLineDash#Browser_compatibility\n   *\n   * @param {Array<number>} lineDash Line dash.\n   * @api\n   */\n  setLineDash(lineDash) {\n    this.lineDash_ = lineDash;\n  }\n\n  /**\n   * Set the line dash offset.\n   *\n   * @param {number|undefined} lineDashOffset Line dash offset.\n   * @api\n   */\n  setLineDashOffset(lineDashOffset) {\n    this.lineDashOffset_ = lineDashOffset;\n  }\n\n  /**\n   * Set the line join.\n   *\n   * @param {CanvasLineJoin|undefined} lineJoin Line join.\n   * @api\n   */\n  setLineJoin(lineJoin) {\n    this.lineJoin_ = lineJoin;\n  }\n\n  /**\n   * Set the miter limit.\n   *\n   * @param {number|undefined} miterLimit Miter limit.\n   * @api\n   */\n  setMiterLimit(miterLimit) {\n    this.miterLimit_ = miterLimit;\n  }\n\n  /**\n   * Set the width.\n   *\n   * @param {number|undefined} width Width.\n   * @api\n   */\n  setWidth(width) {\n    this.width_ = width;\n  }\n}\n\nexport default Stroke;\n","/**\n * @module ol/style/Style\n */\n\nimport CircleStyle from './Circle.js';\nimport Fill from './Fill.js';\nimport GeometryType from '../geom/GeometryType.js';\nimport Stroke from './Stroke.js';\nimport {assert} from '../asserts.js';\n\n/**\n * A function that takes an {@link module:ol/Feature} and a `{number}`\n * representing the view's resolution. The function should return a\n * {@link module:ol/style/Style} or an array of them. This way e.g. a\n * vector layer can be styled. If the function returns `undefined`, the\n * feature will not be rendered.\n *\n * @typedef {function(import(\"../Feature.js\").FeatureLike, number):(Style|Array<Style>|void)} StyleFunction\n */\n\n/**\n * A {@link Style}, an array of {@link Style}, or a {@link StyleFunction}.\n * @typedef {Style|Array<Style>|StyleFunction} StyleLike\n */\n\n/**\n * A function that takes an {@link module:ol/Feature} as argument and returns an\n * {@link module:ol/geom/Geometry} that will be rendered and styled for the feature.\n *\n * @typedef {function(import(\"../Feature.js\").FeatureLike):\n *     (import(\"../geom/Geometry.js\").default|import(\"../render/Feature.js\").default|undefined)} GeometryFunction\n */\n\n/**\n * Custom renderer function. Takes two arguments:\n *\n * 1. The pixel coordinates of the geometry in GeoJSON notation.\n * 2. The {@link module:ol/render~State} of the layer renderer.\n *\n * @typedef {function((import(\"../coordinate.js\").Coordinate|Array<import(\"../coordinate.js\").Coordinate>|Array<Array<import(\"../coordinate.js\").Coordinate>>),import(\"../render.js\").State): void}\n * RenderFunction\n */\n\n/**\n * @typedef {Object} Options\n * @property {string|import(\"../geom/Geometry.js\").default|GeometryFunction} [geometry] Feature property or geometry\n * or function returning a geometry to render for this style.\n * @property {import(\"./Fill.js\").default} [fill] Fill style.\n * @property {import(\"./Image.js\").default} [image] Image style.\n * @property {RenderFunction} [renderer] Custom renderer. When configured, `fill`, `stroke` and `image` will be\n * ignored, and the provided function will be called with each render frame for each geometry.\n * @property {import(\"./Stroke.js\").default} [stroke] Stroke style.\n * @property {import(\"./Text.js\").default} [text] Text style.\n * @property {number} [zIndex] Z index.\n */\n\n/**\n * @classdesc\n * Container for vector feature rendering styles. Any changes made to the style\n * or its children through `set*()` methods will not take effect until the\n * feature or layer that uses the style is re-rendered.\n *\n * ## Feature styles\n *\n * If no style is defined, the following default style is used:\n * ```js\n *  import {Fill, Stroke, Circle, Style} from 'ol/style';\n *\n *  var fill = new Fill({\n *    color: 'rgba(255,255,255,0.4)'\n *  });\n *  var stroke = new Stroke({\n *    color: '#3399CC',\n *    width: 1.25\n *  });\n *  var styles = [\n *    new Style({\n *      image: new Circle({\n *        fill: fill,\n *        stroke: stroke,\n *        radius: 5\n *      }),\n *      fill: fill,\n *      stroke: stroke\n *    })\n *  ];\n * ```\n *\n * A separate editing style has the following defaults:\n * ```js\n *  import {Fill, Stroke, Circle, Style} from 'ol/style';\n *  import GeometryType from 'ol/geom/GeometryType';\n *\n *  var white = [255, 255, 255, 1];\n *  var blue = [0, 153, 255, 1];\n *  var width = 3;\n *  styles[GeometryType.POLYGON] = [\n *    new Style({\n *      fill: new Fill({\n *        color: [255, 255, 255, 0.5]\n *      })\n *    })\n *  ];\n *  styles[GeometryType.MULTI_POLYGON] =\n *      styles[GeometryType.POLYGON];\n *  styles[GeometryType.LINE_STRING] = [\n *    new Style({\n *      stroke: new Stroke({\n *        color: white,\n *        width: width + 2\n *      })\n *    }),\n *    new Style({\n *      stroke: new Stroke({\n *        color: blue,\n *        width: width\n *      })\n *    })\n *  ];\n *  styles[GeometryType.MULTI_LINE_STRING] =\n *      styles[GeometryType.LINE_STRING];\n *  styles[GeometryType.POINT] = [\n *    new Style({\n *      image: new Circle({\n *        radius: width * 2,\n *        fill: new Fill({\n *          color: blue\n *        }),\n *        stroke: new Stroke({\n *          color: white,\n *          width: width / 2\n *        })\n *      }),\n *      zIndex: Infinity\n *    })\n *  ];\n *  styles[GeometryType.MULTI_POINT] =\n *      styles[GeometryType.POINT];\n *  styles[GeometryType.GEOMETRY_COLLECTION] =\n *      styles[GeometryType.POLYGON].concat(\n *          styles[GeometryType.LINE_STRING],\n *          styles[GeometryType.POINT]\n *      );\n * ```\n *\n * @api\n */\nclass Style {\n  /**\n   * @param {Options=} opt_options Style options.\n   */\n  constructor(opt_options) {\n    const options = opt_options || {};\n\n    /**\n     * @private\n     * @type {string|import(\"../geom/Geometry.js\").default|GeometryFunction}\n     */\n    this.geometry_ = null;\n\n    /**\n     * @private\n     * @type {!GeometryFunction}\n     */\n    this.geometryFunction_ = defaultGeometryFunction;\n\n    if (options.geometry !== undefined) {\n      this.setGeometry(options.geometry);\n    }\n\n    /**\n     * @private\n     * @type {import(\"./Fill.js\").default}\n     */\n    this.fill_ = options.fill !== undefined ? options.fill : null;\n\n    /**\n     * @private\n     * @type {import(\"./Image.js\").default}\n     */\n    this.image_ = options.image !== undefined ? options.image : null;\n\n    /**\n     * @private\n     * @type {RenderFunction|null}\n     */\n    this.renderer_ = options.renderer !== undefined ? options.renderer : null;\n\n    /**\n     * @private\n     * @type {import(\"./Stroke.js\").default}\n     */\n    this.stroke_ = options.stroke !== undefined ? options.stroke : null;\n\n    /**\n     * @private\n     * @type {import(\"./Text.js\").default}\n     */\n    this.text_ = options.text !== undefined ? options.text : null;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.zIndex_ = options.zIndex;\n  }\n\n  /**\n   * Clones the style.\n   * @return {Style} The cloned style.\n   * @api\n   */\n  clone() {\n    let geometry = this.getGeometry();\n    if (geometry && typeof geometry === 'object') {\n      geometry = /** @type {import(\"../geom/Geometry.js\").default} */ (geometry).clone();\n    }\n    return new Style({\n      geometry: geometry,\n      fill: this.getFill() ? this.getFill().clone() : undefined,\n      image: this.getImage() ? this.getImage().clone() : undefined,\n      stroke: this.getStroke() ? this.getStroke().clone() : undefined,\n      text: this.getText() ? this.getText().clone() : undefined,\n      zIndex: this.getZIndex(),\n    });\n  }\n\n  /**\n   * Get the custom renderer function that was configured with\n   * {@link #setRenderer} or the `renderer` constructor option.\n   * @return {RenderFunction|null} Custom renderer function.\n   * @api\n   */\n  getRenderer() {\n    return this.renderer_;\n  }\n\n  /**\n   * Sets a custom renderer function for this style. When set, `fill`, `stroke`\n   * and `image` options of the style will be ignored.\n   * @param {RenderFunction|null} renderer Custom renderer function.\n   * @api\n   */\n  setRenderer(renderer) {\n    this.renderer_ = renderer;\n  }\n\n  /**\n   * Get the geometry to be rendered.\n   * @return {string|import(\"../geom/Geometry.js\").default|GeometryFunction}\n   * Feature property or geometry or function that returns the geometry that will\n   * be rendered with this style.\n   * @api\n   */\n  getGeometry() {\n    return this.geometry_;\n  }\n\n  /**\n   * Get the function used to generate a geometry for rendering.\n   * @return {!GeometryFunction} Function that is called with a feature\n   * and returns the geometry to render instead of the feature's geometry.\n   * @api\n   */\n  getGeometryFunction() {\n    return this.geometryFunction_;\n  }\n\n  /**\n   * Get the fill style.\n   * @return {import(\"./Fill.js\").default} Fill style.\n   * @api\n   */\n  getFill() {\n    return this.fill_;\n  }\n\n  /**\n   * Set the fill style.\n   * @param {import(\"./Fill.js\").default} fill Fill style.\n   * @api\n   */\n  setFill(fill) {\n    this.fill_ = fill;\n  }\n\n  /**\n   * Get the image style.\n   * @return {import(\"./Image.js\").default} Image style.\n   * @api\n   */\n  getImage() {\n    return this.image_;\n  }\n\n  /**\n   * Set the image style.\n   * @param {import(\"./Image.js\").default} image Image style.\n   * @api\n   */\n  setImage(image) {\n    this.image_ = image;\n  }\n\n  /**\n   * Get the stroke style.\n   * @return {import(\"./Stroke.js\").default} Stroke style.\n   * @api\n   */\n  getStroke() {\n    return this.stroke_;\n  }\n\n  /**\n   * Set the stroke style.\n   * @param {import(\"./Stroke.js\").default} stroke Stroke style.\n   * @api\n   */\n  setStroke(stroke) {\n    this.stroke_ = stroke;\n  }\n\n  /**\n   * Get the text style.\n   * @return {import(\"./Text.js\").default} Text style.\n   * @api\n   */\n  getText() {\n    return this.text_;\n  }\n\n  /**\n   * Set the text style.\n   * @param {import(\"./Text.js\").default} text Text style.\n   * @api\n   */\n  setText(text) {\n    this.text_ = text;\n  }\n\n  /**\n   * Get the z-index for the style.\n   * @return {number|undefined} ZIndex.\n   * @api\n   */\n  getZIndex() {\n    return this.zIndex_;\n  }\n\n  /**\n   * Set a geometry that is rendered instead of the feature's geometry.\n   *\n   * @param {string|import(\"../geom/Geometry.js\").default|GeometryFunction} geometry\n   *     Feature property or geometry or function returning a geometry to render\n   *     for this style.\n   * @api\n   */\n  setGeometry(geometry) {\n    if (typeof geometry === 'function') {\n      this.geometryFunction_ = geometry;\n    } else if (typeof geometry === 'string') {\n      this.geometryFunction_ = function (feature) {\n        return /** @type {import(\"../geom/Geometry.js\").default} */ (feature.get(\n          geometry\n        ));\n      };\n    } else if (!geometry) {\n      this.geometryFunction_ = defaultGeometryFunction;\n    } else if (geometry !== undefined) {\n      this.geometryFunction_ = function () {\n        return /** @type {import(\"../geom/Geometry.js\").default} */ (geometry);\n      };\n    }\n    this.geometry_ = geometry;\n  }\n\n  /**\n   * Set the z-index.\n   *\n   * @param {number|undefined} zIndex ZIndex.\n   * @api\n   */\n  setZIndex(zIndex) {\n    this.zIndex_ = zIndex;\n  }\n}\n\n/**\n * Convert the provided object into a style function.  Functions passed through\n * unchanged.  Arrays of Style or single style objects wrapped in a\n * new style function.\n * @param {StyleFunction|Array<Style>|Style} obj\n *     A style function, a single style, or an array of styles.\n * @return {StyleFunction} A style function.\n */\nexport function toFunction(obj) {\n  let styleFunction;\n\n  if (typeof obj === 'function') {\n    styleFunction = obj;\n  } else {\n    /**\n     * @type {Array<Style>}\n     */\n    let styles;\n    if (Array.isArray(obj)) {\n      styles = obj;\n    } else {\n      assert(typeof (/** @type {?} */ (obj).getZIndex) === 'function', 41); // Expected an `Style` or an array of `Style`\n      const style = /** @type {Style} */ (obj);\n      styles = [style];\n    }\n    styleFunction = function () {\n      return styles;\n    };\n  }\n  return styleFunction;\n}\n\n/**\n * @type {Array<Style>}\n */\nlet defaultStyles = null;\n\n/**\n * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n * @param {number} resolution Resolution.\n * @return {Array<Style>} Style.\n */\nexport function createDefaultStyle(feature, resolution) {\n  // We don't use an immediately-invoked function\n  // and a closure so we don't get an error at script evaluation time in\n  // browsers that do not support Canvas. (import(\"./Circle.js\").CircleStyle does\n  // canvas.getContext('2d') at construction time, which will cause an.error\n  // in such browsers.)\n  if (!defaultStyles) {\n    const fill = new Fill({\n      color: 'rgba(255,255,255,0.4)',\n    });\n    const stroke = new Stroke({\n      color: '#3399CC',\n      width: 1.25,\n    });\n    defaultStyles = [\n      new Style({\n        image: new CircleStyle({\n          fill: fill,\n          stroke: stroke,\n          radius: 5,\n        }),\n        fill: fill,\n        stroke: stroke,\n      }),\n    ];\n  }\n  return defaultStyles;\n}\n\n/**\n * Default styles for editing features.\n * @return {Object<import(\"../geom/GeometryType.js\").default, Array<Style>>} Styles\n */\nexport function createEditingStyle() {\n  /** @type {Object<import(\"../geom/GeometryType.js\").default, Array<Style>>} */\n  const styles = {};\n  const white = [255, 255, 255, 1];\n  const blue = [0, 153, 255, 1];\n  const width = 3;\n  styles[GeometryType.POLYGON] = [\n    new Style({\n      fill: new Fill({\n        color: [255, 255, 255, 0.5],\n      }),\n    }),\n  ];\n  styles[GeometryType.MULTI_POLYGON] = styles[GeometryType.POLYGON];\n\n  styles[GeometryType.LINE_STRING] = [\n    new Style({\n      stroke: new Stroke({\n        color: white,\n        width: width + 2,\n      }),\n    }),\n    new Style({\n      stroke: new Stroke({\n        color: blue,\n        width: width,\n      }),\n    }),\n  ];\n  styles[GeometryType.MULTI_LINE_STRING] = styles[GeometryType.LINE_STRING];\n\n  styles[GeometryType.CIRCLE] = styles[GeometryType.POLYGON].concat(\n    styles[GeometryType.LINE_STRING]\n  );\n\n  styles[GeometryType.POINT] = [\n    new Style({\n      image: new CircleStyle({\n        radius: width * 2,\n        fill: new Fill({\n          color: blue,\n        }),\n        stroke: new Stroke({\n          color: white,\n          width: width / 2,\n        }),\n      }),\n      zIndex: Infinity,\n    }),\n  ];\n  styles[GeometryType.MULTI_POINT] = styles[GeometryType.POINT];\n\n  styles[GeometryType.GEOMETRY_COLLECTION] = styles[\n    GeometryType.POLYGON\n  ].concat(styles[GeometryType.LINE_STRING], styles[GeometryType.POINT]);\n\n  return styles;\n}\n\n/**\n * Function that is called with a feature and returns its default geometry.\n * @param {import(\"../Feature.js\").FeatureLike} feature Feature to get the geometry for.\n * @return {import(\"../geom/Geometry.js\").default|import(\"../render/Feature.js\").default|undefined} Geometry to render.\n */\nfunction defaultGeometryFunction(feature) {\n  return feature.getGeometry();\n}\n\nexport default Style;\n","/**\n * @module ol/renderer/Map\n */\nimport Disposable from '../Disposable.js';\nimport {TRUE} from '../functions.js';\nimport {abstract} from '../util.js';\nimport {compose as composeTransform, makeInverse} from '../transform.js';\nimport {getWidth} from '../extent.js';\nimport {shared as iconImageCache} from '../style/IconImageCache.js';\nimport {inView} from '../layer/Layer.js';\nimport {wrapX} from '../coordinate.js';\n\n/**\n * @typedef HitMatch\n * @property {import(\"../Feature.js\").FeatureLike} feature\n * @property {import(\"../layer/Layer.js\").default} layer\n * @property {import(\"../geom/SimpleGeometry.js\").default} geometry\n * @property {number} distanceSq\n * @property {import(\"./vector.js\").FeatureCallback<T>} callback\n * @template T\n */\n\n/**\n * @abstract\n */\nclass MapRenderer extends Disposable {\n  /**\n   * @param {import(\"../PluggableMap.js\").default} map Map.\n   */\n  constructor(map) {\n    super();\n\n    /**\n     * @private\n     * @type {import(\"../PluggableMap.js\").default}\n     */\n    this.map_ = map;\n  }\n\n  /**\n   * @abstract\n   * @param {import(\"../render/EventType.js\").default} type Event type.\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   */\n  dispatchRenderEvent(type, frameState) {\n    abstract();\n  }\n\n  /**\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState FrameState.\n   * @protected\n   */\n  calculateMatrices2D(frameState) {\n    const viewState = frameState.viewState;\n    const coordinateToPixelTransform = frameState.coordinateToPixelTransform;\n    const pixelToCoordinateTransform = frameState.pixelToCoordinateTransform;\n\n    composeTransform(\n      coordinateToPixelTransform,\n      frameState.size[0] / 2,\n      frameState.size[1] / 2,\n      1 / viewState.resolution,\n      -1 / viewState.resolution,\n      -viewState.rotation,\n      -viewState.center[0],\n      -viewState.center[1]\n    );\n\n    makeInverse(pixelToCoordinateTransform, coordinateToPixelTransform);\n  }\n\n  /**\n   * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState FrameState.\n   * @param {number} hitTolerance Hit tolerance in pixels.\n   * @param {boolean} checkWrapped Check for wrapped geometries.\n   * @param {import(\"./vector.js\").FeatureCallback<T>} callback Feature callback.\n   * @param {S} thisArg Value to use as `this` when executing `callback`.\n   * @param {function(this: U, import(\"../layer/Layer.js\").default): boolean} layerFilter Layer filter\n   *     function, only layers which are visible and for which this function\n   *     returns `true` will be tested for features.  By default, all visible\n   *     layers will be tested.\n   * @param {U} thisArg2 Value to use as `this` when executing `layerFilter`.\n   * @return {T|undefined} Callback result.\n   * @template S,T,U\n   */\n  forEachFeatureAtCoordinate(\n    coordinate,\n    frameState,\n    hitTolerance,\n    checkWrapped,\n    callback,\n    thisArg,\n    layerFilter,\n    thisArg2\n  ) {\n    let result;\n    const viewState = frameState.viewState;\n\n    /**\n     * @param {boolean} managed Managed layer.\n     * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n     * @param {import(\"../layer/Layer.js\").default} layer Layer.\n     * @param {import(\"../geom/Geometry.js\").default} geometry Geometry.\n     * @return {T|undefined} Callback result.\n     */\n    function forEachFeatureAtCoordinate(managed, feature, layer, geometry) {\n      return callback.call(thisArg, feature, managed ? layer : null, geometry);\n    }\n\n    const projection = viewState.projection;\n\n    const translatedCoordinate = wrapX(coordinate.slice(), projection);\n    const offsets = [[0, 0]];\n    if (projection.canWrapX() && checkWrapped) {\n      const projectionExtent = projection.getExtent();\n      const worldWidth = getWidth(projectionExtent);\n      offsets.push([-worldWidth, 0], [worldWidth, 0]);\n    }\n\n    const layerStates = frameState.layerStatesArray;\n    const numLayers = layerStates.length;\n\n    const matches = /** @type {Array<HitMatch<T>>} */ ([]);\n    const tmpCoord = [];\n    for (let i = 0; i < offsets.length; i++) {\n      for (let j = numLayers - 1; j >= 0; --j) {\n        const layerState = layerStates[j];\n        const layer = layerState.layer;\n        if (\n          layer.hasRenderer() &&\n          inView(layerState, viewState) &&\n          layerFilter.call(thisArg2, layer)\n        ) {\n          const layerRenderer = layer.getRenderer();\n          const source = layer.getSource();\n          if (layerRenderer && source) {\n            const coordinates = source.getWrapX()\n              ? translatedCoordinate\n              : coordinate;\n            const callback = forEachFeatureAtCoordinate.bind(\n              null,\n              layerState.managed\n            );\n            tmpCoord[0] = coordinates[0] + offsets[i][0];\n            tmpCoord[1] = coordinates[1] + offsets[i][1];\n            result = layerRenderer.forEachFeatureAtCoordinate(\n              tmpCoord,\n              frameState,\n              hitTolerance,\n              callback,\n              matches\n            );\n          }\n          if (result) {\n            return result;\n          }\n        }\n      }\n    }\n    if (matches.length === 0) {\n      return undefined;\n    }\n    const order = 1 / matches.length;\n    matches.forEach((m, i) => (m.distanceSq += i * order));\n    matches.sort((a, b) => a.distanceSq - b.distanceSq);\n    matches.some((m) => {\n      return (result = m.callback(m.feature, m.layer, m.geometry));\n    });\n    return result;\n  }\n\n  /**\n   * @abstract\n   * @param {import(\"../pixel.js\").Pixel} pixel Pixel.\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState FrameState.\n   * @param {number} hitTolerance Hit tolerance in pixels.\n   * @param {function(import(\"../layer/Layer.js\").default, (Uint8ClampedArray|Uint8Array)): T} callback Layer\n   *     callback.\n   * @param {function(import(\"../layer/Layer.js\").default): boolean} layerFilter Layer filter\n   *     function, only layers which are visible and for which this function\n   *     returns `true` will be tested for features.  By default, all visible\n   *     layers will be tested.\n   * @return {T|undefined} Callback result.\n   * @template T\n   */\n  forEachLayerAtPixel(pixel, frameState, hitTolerance, callback, layerFilter) {\n    return abstract();\n  }\n\n  /**\n   * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState FrameState.\n   * @param {number} hitTolerance Hit tolerance in pixels.\n   * @param {boolean} checkWrapped Check for wrapped geometries.\n   * @param {function(this: U, import(\"../layer/Layer.js\").default): boolean} layerFilter Layer filter\n   *     function, only layers which are visible and for which this function\n   *     returns `true` will be tested for features.  By default, all visible\n   *     layers will be tested.\n   * @param {U} thisArg Value to use as `this` when executing `layerFilter`.\n   * @return {boolean} Is there a feature at the given coordinate?\n   * @template U\n   */\n  hasFeatureAtCoordinate(\n    coordinate,\n    frameState,\n    hitTolerance,\n    checkWrapped,\n    layerFilter,\n    thisArg\n  ) {\n    const hasFeature = this.forEachFeatureAtCoordinate(\n      coordinate,\n      frameState,\n      hitTolerance,\n      checkWrapped,\n      TRUE,\n      this,\n      layerFilter,\n      thisArg\n    );\n\n    return hasFeature !== undefined;\n  }\n\n  /**\n   * @return {import(\"../PluggableMap.js\").default} Map.\n   */\n  getMap() {\n    return this.map_;\n  }\n\n  /**\n   * Render.\n   * @abstract\n   * @param {?import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   */\n  renderFrame(frameState) {\n    abstract();\n  }\n\n  /**\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   * @protected\n   */\n  scheduleExpireIconCache(frameState) {\n    if (iconImageCache.canExpireCache()) {\n      frameState.postRenderFunctions.push(expireIconCache);\n    }\n  }\n}\n\n/**\n * @param {import(\"../PluggableMap.js\").default} map Map.\n * @param {import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n */\nfunction expireIconCache(map, frameState) {\n  iconImageCache.expire();\n}\n\nexport default MapRenderer;\n","/**\n * @module ol/render/Event\n */\n\nimport Event from '../events/Event.js';\n\nclass RenderEvent extends Event {\n  /**\n   * @param {import(\"./EventType.js\").default} type Type.\n   * @param {import(\"../transform.js\").Transform=} opt_inversePixelTransform Transform for\n   *     CSS pixels to rendered pixels.\n   * @param {import(\"../PluggableMap.js\").FrameState=} opt_frameState Frame state.\n   * @param {?CanvasRenderingContext2D=} opt_context Context.\n   */\n  constructor(type, opt_inversePixelTransform, opt_frameState, opt_context) {\n    super(type);\n\n    /**\n     * Transform from CSS pixels (relative to the top-left corner of the map viewport)\n     * to rendered pixels on this event's `context`. Only available when a Canvas renderer is used, null otherwise.\n     * @type {import(\"../transform.js\").Transform|undefined}\n     * @api\n     */\n    this.inversePixelTransform = opt_inversePixelTransform;\n\n    /**\n     * An object representing the current render frame state.\n     * @type {import(\"../PluggableMap.js\").FrameState|undefined}\n     * @api\n     */\n    this.frameState = opt_frameState;\n\n    /**\n     * Canvas context. Not available when the event is dispatched by the map. Only available\n     * when a Canvas renderer is used, null otherwise.\n     * @type {CanvasRenderingContext2D|null|undefined}\n     * @api\n     */\n    this.context = opt_context;\n  }\n}\n\nexport default RenderEvent;\n","/**\n * @module ol/renderer/Composite\n */\nimport MapRenderer from './Map.js';\nimport ObjectEventType from '../ObjectEventType.js';\nimport RenderEvent from '../render/Event.js';\nimport RenderEventType from '../render/EventType.js';\nimport SourceState from '../source/State.js';\nimport {CLASS_UNSELECTABLE} from '../css.js';\nimport {checkedFonts} from '../render/canvas.js';\nimport {inView} from '../layer/Layer.js';\nimport {listen, unlistenByKey} from '../events.js';\nimport {replaceChildren} from '../dom.js';\n\n/**\n * @classdesc\n * Canvas map renderer.\n * @api\n */\nclass CompositeMapRenderer extends MapRenderer {\n  /**\n   * @param {import(\"../PluggableMap.js\").default} map Map.\n   */\n  constructor(map) {\n    super(map);\n\n    /**\n     * @type {import(\"../events.js\").EventsKey}\n     */\n    this.fontChangeListenerKey_ = listen(\n      checkedFonts,\n      ObjectEventType.PROPERTYCHANGE,\n      map.redrawText.bind(map)\n    );\n\n    /**\n     * @private\n     * @type {HTMLDivElement}\n     */\n    this.element_ = document.createElement('div');\n    const style = this.element_.style;\n    style.position = 'absolute';\n    style.width = '100%';\n    style.height = '100%';\n    style.zIndex = '0';\n\n    this.element_.className = CLASS_UNSELECTABLE + ' ol-layers';\n\n    const container = map.getViewport();\n    container.insertBefore(this.element_, container.firstChild || null);\n\n    /**\n     * @private\n     * @type {Array<HTMLElement>}\n     */\n    this.children_ = [];\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.renderedVisible_ = true;\n  }\n\n  /**\n   * @param {import(\"../render/EventType.js\").default} type Event type.\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   */\n  dispatchRenderEvent(type, frameState) {\n    const map = this.getMap();\n    if (map.hasListener(type)) {\n      const event = new RenderEvent(type, undefined, frameState);\n      map.dispatchEvent(event);\n    }\n  }\n\n  disposeInternal() {\n    unlistenByKey(this.fontChangeListenerKey_);\n    this.element_.parentNode.removeChild(this.element_);\n    super.disposeInternal();\n  }\n\n  /**\n   * Render.\n   * @param {?import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   */\n  renderFrame(frameState) {\n    if (!frameState) {\n      if (this.renderedVisible_) {\n        this.element_.style.display = 'none';\n        this.renderedVisible_ = false;\n      }\n      return;\n    }\n\n    this.calculateMatrices2D(frameState);\n    this.dispatchRenderEvent(RenderEventType.PRECOMPOSE, frameState);\n\n    const layerStatesArray = frameState.layerStatesArray.sort(function (a, b) {\n      return a.zIndex - b.zIndex;\n    });\n    const viewState = frameState.viewState;\n\n    this.children_.length = 0;\n    /**\n     * @type {Array<import(\"../layer/BaseVector.js\").default>}\n     */\n    const declutterLayers = [];\n    let previousElement = null;\n    for (let i = 0, ii = layerStatesArray.length; i < ii; ++i) {\n      const layerState = layerStatesArray[i];\n      frameState.layerIndex = i;\n      if (\n        !inView(layerState, viewState) ||\n        (layerState.sourceState != SourceState.READY &&\n          layerState.sourceState != SourceState.UNDEFINED)\n      ) {\n        continue;\n      }\n\n      const layer = layerState.layer;\n      const element = layer.render(frameState, previousElement);\n      if (!element) {\n        continue;\n      }\n      if (element !== previousElement) {\n        this.children_.push(element);\n        previousElement = element;\n      }\n      if ('getDeclutter' in layer) {\n        declutterLayers.push(layer);\n      }\n    }\n    for (let i = declutterLayers.length - 1; i >= 0; --i) {\n      declutterLayers[i].renderDeclutter(frameState);\n    }\n\n    replaceChildren(this.element_, this.children_);\n\n    this.dispatchRenderEvent(RenderEventType.POSTCOMPOSE, frameState);\n\n    if (!this.renderedVisible_) {\n      this.element_.style.display = '';\n      this.renderedVisible_ = true;\n    }\n\n    this.scheduleExpireIconCache(frameState);\n  }\n\n  /**\n   * @param {import(\"../pixel.js\").Pixel} pixel Pixel.\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState FrameState.\n   * @param {number} hitTolerance Hit tolerance in pixels.\n   * @param {function(import(\"../layer/Layer.js\").default, (Uint8ClampedArray|Uint8Array)): T} callback Layer\n   *     callback.\n   * @param {function(import(\"../layer/Layer.js\").default): boolean} layerFilter Layer filter\n   *     function, only layers which are visible and for which this function\n   *     returns `true` will be tested for features.  By default, all visible\n   *     layers will be tested.\n   * @return {T|undefined} Callback result.\n   * @template T\n   */\n  forEachLayerAtPixel(pixel, frameState, hitTolerance, callback, layerFilter) {\n    const viewState = frameState.viewState;\n\n    const layerStates = frameState.layerStatesArray;\n    const numLayers = layerStates.length;\n\n    for (let i = numLayers - 1; i >= 0; --i) {\n      const layerState = layerStates[i];\n      const layer = layerState.layer;\n      if (\n        layer.hasRenderer() &&\n        inView(layerState, viewState) &&\n        layerFilter(layer)\n      ) {\n        const layerRenderer = layer.getRenderer();\n        const data = layerRenderer.getDataAtPixel(\n          pixel,\n          frameState,\n          hitTolerance\n        );\n        if (data) {\n          const result = callback(layer, data);\n          if (result) {\n            return result;\n          }\n        }\n      }\n    }\n    return undefined;\n  }\n}\n\nexport default CompositeMapRenderer;\n","/**\n * @module ol/layer/Group\n */\nimport BaseLayer from './Base.js';\nimport Collection from '../Collection.js';\nimport CollectionEventType from '../CollectionEventType.js';\nimport EventType from '../events/EventType.js';\nimport ObjectEventType from '../ObjectEventType.js';\nimport SourceState from '../source/State.js';\nimport {assert} from '../asserts.js';\nimport {assign, clear} from '../obj.js';\nimport {getChangeEventType} from '../Object.js';\nimport {getIntersection} from '../extent.js';\nimport {getUid} from '../util.js';\nimport {listen, unlistenByKey} from '../events.js';\n\n/**\n * @typedef {Object} Options\n * @property {number} [opacity=1] Opacity (0, 1).\n * @property {boolean} [visible=true] Visibility.\n * @property {import(\"../extent.js\").Extent} [extent] The bounding extent for layer rendering.  The layer will not be\n * rendered outside of this extent.\n * @property {number} [zIndex] The z-index for layer rendering.  At rendering time, the layers\n * will be ordered, first by Z-index and then by position. When `undefined`, a `zIndex` of 0 is assumed\n * for layers that are added to the map's `layers` collection, or `Infinity` when the layer's `setMap()`\n * method was used.\n * @property {number} [minResolution] The minimum resolution (inclusive) at which this layer will be\n * visible.\n * @property {number} [maxResolution] The maximum resolution (exclusive) below which this layer will\n * be visible.\n * @property {number} [minZoom] The minimum view zoom level (exclusive) above which this layer will be\n * visible.\n * @property {number} [maxZoom] The maximum view zoom level (inclusive) at which this layer will\n * be visible.\n * @property {number} [minZoom] The minimum view zoom level (exclusive) above which this layer will be\n * visible.\n * @property {number} [maxZoom] The maximum view zoom level (inclusive) at which this layer will\n * be visible.\n * @property {Array<import(\"./Base.js\").default>|import(\"../Collection.js\").default<import(\"./Base.js\").default>} [layers] Child layers.\n */\n\n/**\n * @enum {string}\n * @private\n */\nconst Property = {\n  LAYERS: 'layers',\n};\n\n/**\n * @classdesc\n * A {@link module:ol/Collection~Collection} of layers that are handled together.\n *\n * A generic `change` event is triggered when the group/Collection changes.\n *\n * @api\n */\nclass LayerGroup extends BaseLayer {\n  /**\n   * @param {Options=} opt_options Layer options.\n   */\n  constructor(opt_options) {\n    const options = opt_options || {};\n    const baseOptions = /** @type {Options} */ (assign({}, options));\n    delete baseOptions.layers;\n\n    let layers = options.layers;\n\n    super(baseOptions);\n\n    /**\n     * @private\n     * @type {Array<import(\"../events.js\").EventsKey>}\n     */\n    this.layersListenerKeys_ = [];\n\n    /**\n     * @private\n     * @type {Object<string, Array<import(\"../events.js\").EventsKey>>}\n     */\n    this.listenerKeys_ = {};\n\n    this.addEventListener(\n      getChangeEventType(Property.LAYERS),\n      this.handleLayersChanged_\n    );\n\n    if (layers) {\n      if (Array.isArray(layers)) {\n        layers = new Collection(layers.slice(), {unique: true});\n      } else {\n        assert(typeof (/** @type {?} */ (layers).getArray) === 'function', 43); // Expected `layers` to be an array or a `Collection`\n      }\n    } else {\n      layers = new Collection(undefined, {unique: true});\n    }\n\n    this.setLayers(layers);\n  }\n\n  /**\n   * @private\n   */\n  handleLayerChange_() {\n    this.changed();\n  }\n\n  /**\n   * @private\n   */\n  handleLayersChanged_() {\n    this.layersListenerKeys_.forEach(unlistenByKey);\n    this.layersListenerKeys_.length = 0;\n\n    const layers = this.getLayers();\n    this.layersListenerKeys_.push(\n      listen(layers, CollectionEventType.ADD, this.handleLayersAdd_, this),\n      listen(layers, CollectionEventType.REMOVE, this.handleLayersRemove_, this)\n    );\n\n    for (const id in this.listenerKeys_) {\n      this.listenerKeys_[id].forEach(unlistenByKey);\n    }\n    clear(this.listenerKeys_);\n\n    const layersArray = layers.getArray();\n    for (let i = 0, ii = layersArray.length; i < ii; i++) {\n      const layer = layersArray[i];\n      this.listenerKeys_[getUid(layer)] = [\n        listen(\n          layer,\n          ObjectEventType.PROPERTYCHANGE,\n          this.handleLayerChange_,\n          this\n        ),\n        listen(layer, EventType.CHANGE, this.handleLayerChange_, this),\n      ];\n    }\n\n    this.changed();\n  }\n\n  /**\n   * @param {import(\"../Collection.js\").CollectionEvent} collectionEvent CollectionEvent.\n   * @private\n   */\n  handleLayersAdd_(collectionEvent) {\n    const layer = /** @type {import(\"./Base.js\").default} */ (collectionEvent.element);\n    this.listenerKeys_[getUid(layer)] = [\n      listen(\n        layer,\n        ObjectEventType.PROPERTYCHANGE,\n        this.handleLayerChange_,\n        this\n      ),\n      listen(layer, EventType.CHANGE, this.handleLayerChange_, this),\n    ];\n    this.changed();\n  }\n\n  /**\n   * @param {import(\"../Collection.js\").CollectionEvent} collectionEvent CollectionEvent.\n   * @private\n   */\n  handleLayersRemove_(collectionEvent) {\n    const layer = /** @type {import(\"./Base.js\").default} */ (collectionEvent.element);\n    const key = getUid(layer);\n    this.listenerKeys_[key].forEach(unlistenByKey);\n    delete this.listenerKeys_[key];\n    this.changed();\n  }\n\n  /**\n   * Returns the {@link module:ol/Collection collection} of {@link module:ol/layer/Layer~Layer layers}\n   * in this group.\n   * @return {!import(\"../Collection.js\").default<import(\"./Base.js\").default>} Collection of\n   *   {@link module:ol/layer/Base layers} that are part of this group.\n   * @observable\n   * @api\n   */\n  getLayers() {\n    return /** @type {!import(\"../Collection.js\").default<import(\"./Base.js\").default>} */ (this.get(\n      Property.LAYERS\n    ));\n  }\n\n  /**\n   * Set the {@link module:ol/Collection collection} of {@link module:ol/layer/Layer~Layer layers}\n   * in this group.\n   * @param {!import(\"../Collection.js\").default<import(\"./Base.js\").default>} layers Collection of\n   *   {@link module:ol/layer/Base layers} that are part of this group.\n   * @observable\n   * @api\n   */\n  setLayers(layers) {\n    this.set(Property.LAYERS, layers);\n  }\n\n  /**\n   * @param {Array<import(\"./Layer.js\").default>=} opt_array Array of layers (to be modified in place).\n   * @return {Array<import(\"./Layer.js\").default>} Array of layers.\n   */\n  getLayersArray(opt_array) {\n    const array = opt_array !== undefined ? opt_array : [];\n    this.getLayers().forEach(function (layer) {\n      layer.getLayersArray(array);\n    });\n    return array;\n  }\n\n  /**\n   * @param {Array<import(\"./Layer.js\").State>=} opt_states Optional list of layer states (to be modified in place).\n   * @return {Array<import(\"./Layer.js\").State>} List of layer states.\n   */\n  getLayerStatesArray(opt_states) {\n    const states = opt_states !== undefined ? opt_states : [];\n\n    const pos = states.length;\n\n    this.getLayers().forEach(function (layer) {\n      layer.getLayerStatesArray(states);\n    });\n\n    const ownLayerState = this.getLayerState();\n    for (let i = pos, ii = states.length; i < ii; i++) {\n      const layerState = states[i];\n      layerState.opacity *= ownLayerState.opacity;\n      layerState.visible = layerState.visible && ownLayerState.visible;\n      layerState.maxResolution = Math.min(\n        layerState.maxResolution,\n        ownLayerState.maxResolution\n      );\n      layerState.minResolution = Math.max(\n        layerState.minResolution,\n        ownLayerState.minResolution\n      );\n      layerState.minZoom = Math.max(layerState.minZoom, ownLayerState.minZoom);\n      layerState.maxZoom = Math.min(layerState.maxZoom, ownLayerState.maxZoom);\n      if (ownLayerState.extent !== undefined) {\n        if (layerState.extent !== undefined) {\n          layerState.extent = getIntersection(\n            layerState.extent,\n            ownLayerState.extent\n          );\n        } else {\n          layerState.extent = ownLayerState.extent;\n        }\n      }\n    }\n\n    return states;\n  }\n\n  /**\n   * @return {import(\"../source/State.js\").default} Source state.\n   */\n  getSourceState() {\n    return SourceState.READY;\n  }\n}\n\nexport default LayerGroup;\n","/**\n * @module ol/MapEvent\n */\nimport Event from './events/Event.js';\n\n/**\n * @classdesc\n * Events emitted as map events are instances of this type.\n * See {@link module:ol/PluggableMap~PluggableMap} for which events trigger a map event.\n */\nclass MapEvent extends Event {\n  /**\n   * @param {string} type Event type.\n   * @param {import(\"./PluggableMap.js\").default} map Map.\n   * @param {?import(\"./PluggableMap.js\").FrameState=} opt_frameState Frame state.\n   */\n  constructor(type, map, opt_frameState) {\n    super(type);\n\n    /**\n     * The map where the event occurred.\n     * @type {import(\"./PluggableMap.js\").default}\n     * @api\n     */\n    this.map = map;\n\n    /**\n     * The frame state at the time of the event.\n     * @type {?import(\"./PluggableMap.js\").FrameState}\n     * @api\n     */\n    this.frameState = opt_frameState !== undefined ? opt_frameState : null;\n  }\n}\n\nexport default MapEvent;\n","/**\n * @module ol/MapBrowserEvent\n */\nimport MapEvent from './MapEvent.js';\n\n/**\n * @classdesc\n * Events emitted as map browser events are instances of this type.\n * See {@link module:ol/PluggableMap~PluggableMap} for which events trigger a map browser event.\n * @template {UIEvent} EVENT\n */\nclass MapBrowserEvent extends MapEvent {\n  /**\n   * @param {string} type Event type.\n   * @param {import(\"./PluggableMap.js\").default} map Map.\n   * @param {EVENT} originalEvent Original event.\n   * @param {boolean=} opt_dragging Is the map currently being dragged?\n   * @param {?import(\"./PluggableMap.js\").FrameState=} opt_frameState Frame state.\n   */\n  constructor(type, map, originalEvent, opt_dragging, opt_frameState) {\n    super(type, map, opt_frameState);\n\n    /**\n     * The original browser event.\n     * @const\n     * @type {EVENT}\n     * @api\n     */\n    this.originalEvent = originalEvent;\n\n    /**\n     * The map pixel relative to the viewport corresponding to the original browser event.\n     * @type {?import(\"./pixel.js\").Pixel}\n     */\n    this.pixel_ = null;\n\n    /**\n     * The coordinate in the user projection corresponding to the original browser event.\n     * @type {?import(\"./coordinate.js\").Coordinate}\n     */\n    this.coordinate_ = null;\n\n    /**\n     * Indicates if the map is currently being dragged. Only set for\n     * `POINTERDRAG` and `POINTERMOVE` events. Default is `false`.\n     *\n     * @type {boolean}\n     * @api\n     */\n    this.dragging = opt_dragging !== undefined ? opt_dragging : false;\n  }\n\n  /**\n   * The map pixel relative to the viewport corresponding to the original event.\n   * @type {import(\"./pixel.js\").Pixel}\n   * @api\n   */\n  get pixel() {\n    if (!this.pixel_) {\n      this.pixel_ = this.map.getEventPixel(this.originalEvent);\n    }\n    return this.pixel_;\n  }\n  set pixel(pixel) {\n    this.pixel_ = pixel;\n  }\n\n  /**\n   * The coordinate corresponding to the original browser event.  This will be in the user\n   * projection if one is set.  Otherwise it will be in the view projection.\n   * @type {import(\"./coordinate.js\").Coordinate}\n   * @api\n   */\n  get coordinate() {\n    if (!this.coordinate_) {\n      this.coordinate_ = this.map.getCoordinateFromPixel(this.pixel);\n    }\n    return this.coordinate_;\n  }\n  set coordinate(coordinate) {\n    this.coordinate_ = coordinate;\n  }\n\n  /**\n   * Prevents the default browser action.\n   * See https://developer.mozilla.org/en-US/docs/Web/API/event.preventDefault.\n   * @api\n   */\n  preventDefault() {\n    super.preventDefault();\n    this.originalEvent.preventDefault();\n  }\n\n  /**\n   * Prevents further propagation of the current event.\n   * See https://developer.mozilla.org/en-US/docs/Web/API/event.stopPropagation.\n   * @api\n   */\n  stopPropagation() {\n    super.stopPropagation();\n    this.originalEvent.stopPropagation();\n  }\n}\n\nexport default MapBrowserEvent;\n","/**\n * @module ol/MapBrowserEventType\n */\nimport EventType from './events/EventType.js';\n\n/**\n * Constants for event names.\n * @enum {string}\n */\nexport default {\n  /**\n   * A true single click with no dragging and no double click. Note that this\n   * event is delayed by 250 ms to ensure that it is not a double click.\n   * @event module:ol/MapBrowserEvent~MapBrowserEvent#singleclick\n   * @api\n   */\n  SINGLECLICK: 'singleclick',\n\n  /**\n   * A click with no dragging. A double click will fire two of this.\n   * @event module:ol/MapBrowserEvent~MapBrowserEvent#click\n   * @api\n   */\n  CLICK: EventType.CLICK,\n\n  /**\n   * A true double click, with no dragging.\n   * @event module:ol/MapBrowserEvent~MapBrowserEvent#dblclick\n   * @api\n   */\n  DBLCLICK: EventType.DBLCLICK,\n\n  /**\n   * Triggered when a pointer is dragged.\n   * @event module:ol/MapBrowserEvent~MapBrowserEvent#pointerdrag\n   * @api\n   */\n  POINTERDRAG: 'pointerdrag',\n\n  /**\n   * Triggered when a pointer is moved. Note that on touch devices this is\n   * triggered when the map is panned, so is not the same as mousemove.\n   * @event module:ol/MapBrowserEvent~MapBrowserEvent#pointermove\n   * @api\n   */\n  POINTERMOVE: 'pointermove',\n\n  POINTERDOWN: 'pointerdown',\n  POINTERUP: 'pointerup',\n  POINTEROVER: 'pointerover',\n  POINTEROUT: 'pointerout',\n  POINTERENTER: 'pointerenter',\n  POINTERLEAVE: 'pointerleave',\n  POINTERCANCEL: 'pointercancel',\n};\n","/**\n * @module ol/pointer/EventType\n */\n\n/**\n * Constants for event names.\n * @enum {string}\n */\nexport default {\n  POINTERMOVE: 'pointermove',\n  POINTERDOWN: 'pointerdown',\n  POINTERUP: 'pointerup',\n  POINTEROVER: 'pointerover',\n  POINTEROUT: 'pointerout',\n  POINTERENTER: 'pointerenter',\n  POINTERLEAVE: 'pointerleave',\n  POINTERCANCEL: 'pointercancel',\n};\n","/**\n * @module ol/MapBrowserEventHandler\n */\n\nimport EventTarget from './events/Target.js';\nimport EventType from './events/EventType.js';\nimport MapBrowserEvent from './MapBrowserEvent.js';\nimport MapBrowserEventType from './MapBrowserEventType.js';\nimport PointerEventType from './pointer/EventType.js';\nimport {DEVICE_PIXEL_RATIO, PASSIVE_EVENT_LISTENERS} from './has.js';\nimport {listen, unlistenByKey} from './events.js';\n\nclass MapBrowserEventHandler extends EventTarget {\n  /**\n   * @param {import(\"./PluggableMap.js\").default} map The map with the viewport to listen to events on.\n   * @param {number=} moveTolerance The minimal distance the pointer must travel to trigger a move.\n   */\n  constructor(map, moveTolerance) {\n    super(map);\n\n    /**\n     * This is the element that we will listen to the real events on.\n     * @type {import(\"./PluggableMap.js\").default}\n     * @private\n     */\n    this.map_ = map;\n\n    /**\n     * @type {any}\n     * @private\n     */\n    this.clickTimeoutId_;\n\n    /**\n     * Emulate dblclick and singleclick. Will be true when only one pointer is active.\n     * @type {boolean}\n     */\n    this.emulateClicks_ = false;\n\n    /**\n     * @type {boolean}\n     * @private\n     */\n    this.dragging_ = false;\n\n    /**\n     * @type {!Array<import(\"./events.js\").EventsKey>}\n     * @private\n     */\n    this.dragListenerKeys_ = [];\n\n    /**\n     * @type {number}\n     * @private\n     */\n    this.moveTolerance_ = moveTolerance\n      ? moveTolerance * DEVICE_PIXEL_RATIO\n      : DEVICE_PIXEL_RATIO;\n\n    /**\n     * The most recent \"down\" type event (or null if none have occurred).\n     * Set on pointerdown.\n     * @type {PointerEvent}\n     * @private\n     */\n    this.down_ = null;\n\n    const element = this.map_.getViewport();\n\n    /**\n     * @type {number}\n     * @private\n     */\n    this.activePointers_ = 0;\n\n    /**\n     * @type {!Object<number, boolean>}\n     * @private\n     */\n    this.trackedTouches_ = {};\n\n    this.element_ = element;\n\n    /**\n     * @type {?import(\"./events.js\").EventsKey}\n     * @private\n     */\n    this.pointerdownListenerKey_ = listen(\n      element,\n      PointerEventType.POINTERDOWN,\n      this.handlePointerDown_,\n      this\n    );\n\n    /**\n     * @type {PointerEvent}\n     * @private\n     */\n    this.originalPointerMoveEvent_;\n\n    /**\n     * @type {?import(\"./events.js\").EventsKey}\n     * @private\n     */\n    this.relayedListenerKey_ = listen(\n      element,\n      PointerEventType.POINTERMOVE,\n      this.relayEvent_,\n      this\n    );\n\n    /**\n     * @private\n     */\n    this.boundHandleTouchMove_ = this.handleTouchMove_.bind(this);\n\n    this.element_.addEventListener(\n      EventType.TOUCHMOVE,\n      this.boundHandleTouchMove_,\n      PASSIVE_EVENT_LISTENERS ? {passive: false} : false\n    );\n  }\n\n  /**\n   * @param {PointerEvent} pointerEvent Pointer\n   * event.\n   * @private\n   */\n  emulateClick_(pointerEvent) {\n    let newEvent = new MapBrowserEvent(\n      MapBrowserEventType.CLICK,\n      this.map_,\n      pointerEvent\n    );\n    this.dispatchEvent(newEvent);\n    if (this.clickTimeoutId_ !== undefined) {\n      // double-click\n      clearTimeout(this.clickTimeoutId_);\n      this.clickTimeoutId_ = undefined;\n      newEvent = new MapBrowserEvent(\n        MapBrowserEventType.DBLCLICK,\n        this.map_,\n        pointerEvent\n      );\n      this.dispatchEvent(newEvent);\n    } else {\n      // click\n      this.clickTimeoutId_ = setTimeout(\n        /** @this {MapBrowserEventHandler} */\n        function () {\n          this.clickTimeoutId_ = undefined;\n          const newEvent = new MapBrowserEvent(\n            MapBrowserEventType.SINGLECLICK,\n            this.map_,\n            pointerEvent\n          );\n          this.dispatchEvent(newEvent);\n        }.bind(this),\n        250\n      );\n    }\n  }\n\n  /**\n   * Keeps track on how many pointers are currently active.\n   *\n   * @param {PointerEvent} pointerEvent Pointer\n   * event.\n   * @private\n   */\n  updateActivePointers_(pointerEvent) {\n    const event = pointerEvent;\n\n    if (\n      event.type == MapBrowserEventType.POINTERUP ||\n      event.type == MapBrowserEventType.POINTERCANCEL\n    ) {\n      delete this.trackedTouches_[event.pointerId];\n    } else if (event.type == MapBrowserEventType.POINTERDOWN) {\n      this.trackedTouches_[event.pointerId] = true;\n    }\n    this.activePointers_ = Object.keys(this.trackedTouches_).length;\n  }\n\n  /**\n   * @param {PointerEvent} pointerEvent Pointer\n   * event.\n   * @private\n   */\n  handlePointerUp_(pointerEvent) {\n    this.updateActivePointers_(pointerEvent);\n    const newEvent = new MapBrowserEvent(\n      MapBrowserEventType.POINTERUP,\n      this.map_,\n      pointerEvent\n    );\n    this.dispatchEvent(newEvent);\n\n    // We emulate click events on left mouse button click, touch contact, and pen\n    // contact. isMouseActionButton returns true in these cases (evt.button is set\n    // to 0).\n    // See http://www.w3.org/TR/pointerevents/#button-states\n    // We only fire click, singleclick, and doubleclick if nobody has called\n    // event.stopPropagation() or event.preventDefault().\n    if (\n      this.emulateClicks_ &&\n      !newEvent.propagationStopped &&\n      !this.dragging_ &&\n      this.isMouseActionButton_(pointerEvent)\n    ) {\n      this.emulateClick_(this.down_);\n    }\n\n    if (this.activePointers_ === 0) {\n      this.dragListenerKeys_.forEach(unlistenByKey);\n      this.dragListenerKeys_.length = 0;\n      this.dragging_ = false;\n      this.down_ = null;\n    }\n  }\n\n  /**\n   * @param {PointerEvent} pointerEvent Pointer\n   * event.\n   * @return {boolean} If the left mouse button was pressed.\n   * @private\n   */\n  isMouseActionButton_(pointerEvent) {\n    return pointerEvent.button === 0;\n  }\n\n  /**\n   * @param {PointerEvent} pointerEvent Pointer\n   * event.\n   * @private\n   */\n  handlePointerDown_(pointerEvent) {\n    this.emulateClicks_ = this.activePointers_ === 0;\n    this.updateActivePointers_(pointerEvent);\n    const newEvent = new MapBrowserEvent(\n      MapBrowserEventType.POINTERDOWN,\n      this.map_,\n      pointerEvent\n    );\n    this.dispatchEvent(newEvent);\n\n    this.down_ = pointerEvent;\n\n    if (this.dragListenerKeys_.length === 0) {\n      const doc = this.map_.getOwnerDocument();\n      this.dragListenerKeys_.push(\n        listen(\n          doc,\n          MapBrowserEventType.POINTERMOVE,\n          this.handlePointerMove_,\n          this\n        ),\n        listen(doc, MapBrowserEventType.POINTERUP, this.handlePointerUp_, this),\n        /* Note that the listener for `pointercancel is set up on\n         * `pointerEventHandler_` and not `documentPointerEventHandler_` like\n         * the `pointerup` and `pointermove` listeners.\n         *\n         * The reason for this is the following: `TouchSource.vacuumTouches_()`\n         * issues `pointercancel` events, when there was no `touchend` for a\n         * `touchstart`. Now, let's say a first `touchstart` is registered on\n         * `pointerEventHandler_`. The `documentPointerEventHandler_` is set up.\n         * But `documentPointerEventHandler_` doesn't know about the first\n         * `touchstart`. If there is no `touchend` for the `touchstart`, we can\n         * only receive a `touchcancel` from `pointerEventHandler_`, because it is\n         * only registered there.\n         */\n        listen(\n          this.element_,\n          MapBrowserEventType.POINTERCANCEL,\n          this.handlePointerUp_,\n          this\n        )\n      );\n      if (this.element_.getRootNode && this.element_.getRootNode() !== doc) {\n        this.dragListenerKeys_.push(\n          listen(\n            this.element_.getRootNode(),\n            MapBrowserEventType.POINTERUP,\n            this.handlePointerUp_,\n            this\n          )\n        );\n      }\n    }\n  }\n\n  /**\n   * @param {PointerEvent} pointerEvent Pointer\n   * event.\n   * @private\n   */\n  handlePointerMove_(pointerEvent) {\n    // Between pointerdown and pointerup, pointermove events are triggered.\n    // To avoid a 'false' touchmove event to be dispatched, we test if the pointer\n    // moved a significant distance.\n    if (this.isMoving_(pointerEvent)) {\n      this.dragging_ = true;\n      const newEvent = new MapBrowserEvent(\n        MapBrowserEventType.POINTERDRAG,\n        this.map_,\n        pointerEvent,\n        this.dragging_\n      );\n      this.dispatchEvent(newEvent);\n    }\n  }\n\n  /**\n   * Wrap and relay a pointer event.  Note that this requires that the type\n   * string for the MapBrowserEvent matches the PointerEvent type.\n   * @param {PointerEvent} pointerEvent Pointer\n   * event.\n   * @private\n   */\n  relayEvent_(pointerEvent) {\n    this.originalPointerMoveEvent_ = pointerEvent;\n    const dragging = !!(this.down_ && this.isMoving_(pointerEvent));\n    this.dispatchEvent(\n      new MapBrowserEvent(pointerEvent.type, this.map_, pointerEvent, dragging)\n    );\n  }\n\n  /**\n   * Flexible handling of a `touch-action: none` css equivalent: because calling\n   * `preventDefault()` on a `pointermove` event does not stop native page scrolling\n   * and zooming, we also listen for `touchmove` and call `preventDefault()` on it\n   * when an interaction (currently `DragPan` handles the event.\n   * @param {TouchEvent} event Event.\n   * @private\n   */\n  handleTouchMove_(event) {\n    // Due to https://github.com/mpizenberg/elm-pep/issues/2, `this.originalPointerMoveEvent_`\n    // may not be initialized yet when we get here on a platform without native pointer events.\n    if (\n      !this.originalPointerMoveEvent_ ||\n      this.originalPointerMoveEvent_.defaultPrevented\n    ) {\n      event.preventDefault();\n    }\n  }\n\n  /**\n   * @param {PointerEvent} pointerEvent Pointer\n   * event.\n   * @return {boolean} Is moving.\n   * @private\n   */\n  isMoving_(pointerEvent) {\n    return (\n      this.dragging_ ||\n      Math.abs(pointerEvent.clientX - this.down_.clientX) >\n        this.moveTolerance_ ||\n      Math.abs(pointerEvent.clientY - this.down_.clientY) > this.moveTolerance_\n    );\n  }\n\n  /**\n   * Clean up.\n   */\n  disposeInternal() {\n    if (this.relayedListenerKey_) {\n      unlistenByKey(this.relayedListenerKey_);\n      this.relayedListenerKey_ = null;\n    }\n    this.element_.removeEventListener(\n      EventType.TOUCHMOVE,\n      this.boundHandleTouchMove_\n    );\n\n    if (this.pointerdownListenerKey_) {\n      unlistenByKey(this.pointerdownListenerKey_);\n      this.pointerdownListenerKey_ = null;\n    }\n\n    this.dragListenerKeys_.forEach(unlistenByKey);\n    this.dragListenerKeys_.length = 0;\n\n    this.element_ = null;\n    super.disposeInternal();\n  }\n}\n\nexport default MapBrowserEventHandler;\n","/**\n * @module ol/MapProperty\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  LAYERGROUP: 'layergroup',\n  SIZE: 'size',\n  TARGET: 'target',\n  VIEW: 'view',\n};\n","/**\n * @module ol/structs/PriorityQueue\n */\nimport {assert} from '../asserts.js';\nimport {clear} from '../obj.js';\n\n/**\n * @type {number}\n */\nexport const DROP = Infinity;\n\n/**\n * @classdesc\n * Priority queue.\n *\n * The implementation is inspired from the Closure Library's Heap class and\n * Python's heapq module.\n *\n * See http://closure-library.googlecode.com/svn/docs/closure_goog_structs_heap.js.source.html\n * and http://hg.python.org/cpython/file/2.7/Lib/heapq.py.\n *\n * @template T\n */\nclass PriorityQueue {\n  /**\n   * @param {function(T): number} priorityFunction Priority function.\n   * @param {function(T): string} keyFunction Key function.\n   */\n  constructor(priorityFunction, keyFunction) {\n    /**\n     * @type {function(T): number}\n     * @private\n     */\n    this.priorityFunction_ = priorityFunction;\n\n    /**\n     * @type {function(T): string}\n     * @private\n     */\n    this.keyFunction_ = keyFunction;\n\n    /**\n     * @type {Array<T>}\n     * @private\n     */\n    this.elements_ = [];\n\n    /**\n     * @type {Array<number>}\n     * @private\n     */\n    this.priorities_ = [];\n\n    /**\n     * @type {!Object<string, boolean>}\n     * @private\n     */\n    this.queuedElements_ = {};\n  }\n\n  /**\n   * FIXME empty description for jsdoc\n   */\n  clear() {\n    this.elements_.length = 0;\n    this.priorities_.length = 0;\n    clear(this.queuedElements_);\n  }\n\n  /**\n   * Remove and return the highest-priority element. O(log N).\n   * @return {T} Element.\n   */\n  dequeue() {\n    const elements = this.elements_;\n    const priorities = this.priorities_;\n    const element = elements[0];\n    if (elements.length == 1) {\n      elements.length = 0;\n      priorities.length = 0;\n    } else {\n      elements[0] = elements.pop();\n      priorities[0] = priorities.pop();\n      this.siftUp_(0);\n    }\n    const elementKey = this.keyFunction_(element);\n    delete this.queuedElements_[elementKey];\n    return element;\n  }\n\n  /**\n   * Enqueue an element. O(log N).\n   * @param {T} element Element.\n   * @return {boolean} The element was added to the queue.\n   */\n  enqueue(element) {\n    assert(!(this.keyFunction_(element) in this.queuedElements_), 31); // Tried to enqueue an `element` that was already added to the queue\n    const priority = this.priorityFunction_(element);\n    if (priority != DROP) {\n      this.elements_.push(element);\n      this.priorities_.push(priority);\n      this.queuedElements_[this.keyFunction_(element)] = true;\n      this.siftDown_(0, this.elements_.length - 1);\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * @return {number} Count.\n   */\n  getCount() {\n    return this.elements_.length;\n  }\n\n  /**\n   * Gets the index of the left child of the node at the given index.\n   * @param {number} index The index of the node to get the left child for.\n   * @return {number} The index of the left child.\n   * @private\n   */\n  getLeftChildIndex_(index) {\n    return index * 2 + 1;\n  }\n\n  /**\n   * Gets the index of the right child of the node at the given index.\n   * @param {number} index The index of the node to get the right child for.\n   * @return {number} The index of the right child.\n   * @private\n   */\n  getRightChildIndex_(index) {\n    return index * 2 + 2;\n  }\n\n  /**\n   * Gets the index of the parent of the node at the given index.\n   * @param {number} index The index of the node to get the parent for.\n   * @return {number} The index of the parent.\n   * @private\n   */\n  getParentIndex_(index) {\n    return (index - 1) >> 1;\n  }\n\n  /**\n   * Make this a heap. O(N).\n   * @private\n   */\n  heapify_() {\n    let i;\n    for (i = (this.elements_.length >> 1) - 1; i >= 0; i--) {\n      this.siftUp_(i);\n    }\n  }\n\n  /**\n   * @return {boolean} Is empty.\n   */\n  isEmpty() {\n    return this.elements_.length === 0;\n  }\n\n  /**\n   * @param {string} key Key.\n   * @return {boolean} Is key queued.\n   */\n  isKeyQueued(key) {\n    return key in this.queuedElements_;\n  }\n\n  /**\n   * @param {T} element Element.\n   * @return {boolean} Is queued.\n   */\n  isQueued(element) {\n    return this.isKeyQueued(this.keyFunction_(element));\n  }\n\n  /**\n   * @param {number} index The index of the node to move down.\n   * @private\n   */\n  siftUp_(index) {\n    const elements = this.elements_;\n    const priorities = this.priorities_;\n    const count = elements.length;\n    const element = elements[index];\n    const priority = priorities[index];\n    const startIndex = index;\n\n    while (index < count >> 1) {\n      const lIndex = this.getLeftChildIndex_(index);\n      const rIndex = this.getRightChildIndex_(index);\n\n      const smallerChildIndex =\n        rIndex < count && priorities[rIndex] < priorities[lIndex]\n          ? rIndex\n          : lIndex;\n\n      elements[index] = elements[smallerChildIndex];\n      priorities[index] = priorities[smallerChildIndex];\n      index = smallerChildIndex;\n    }\n\n    elements[index] = element;\n    priorities[index] = priority;\n    this.siftDown_(startIndex, index);\n  }\n\n  /**\n   * @param {number} startIndex The index of the root.\n   * @param {number} index The index of the node to move up.\n   * @private\n   */\n  siftDown_(startIndex, index) {\n    const elements = this.elements_;\n    const priorities = this.priorities_;\n    const element = elements[index];\n    const priority = priorities[index];\n\n    while (index > startIndex) {\n      const parentIndex = this.getParentIndex_(index);\n      if (priorities[parentIndex] > priority) {\n        elements[index] = elements[parentIndex];\n        priorities[index] = priorities[parentIndex];\n        index = parentIndex;\n      } else {\n        break;\n      }\n    }\n    elements[index] = element;\n    priorities[index] = priority;\n  }\n\n  /**\n   * FIXME empty description for jsdoc\n   */\n  reprioritize() {\n    const priorityFunction = this.priorityFunction_;\n    const elements = this.elements_;\n    const priorities = this.priorities_;\n    let index = 0;\n    const n = elements.length;\n    let element, i, priority;\n    for (i = 0; i < n; ++i) {\n      element = elements[i];\n      priority = priorityFunction(element);\n      if (priority == DROP) {\n        delete this.queuedElements_[this.keyFunction_(element)];\n      } else {\n        priorities[index] = priority;\n        elements[index++] = element;\n      }\n    }\n    elements.length = index;\n    priorities.length = index;\n    this.heapify_();\n  }\n}\n\nexport default PriorityQueue;\n","/**\n * @module ol/TileState\n */\n\n/**\n * @enum {number}\n */\nexport default {\n  IDLE: 0,\n  LOADING: 1,\n  LOADED: 2,\n  /**\n   * Indicates that tile loading failed\n   * @type {number}\n   */\n  ERROR: 3,\n  EMPTY: 4,\n};\n","/**\n * @module ol/TileQueue\n */\nimport EventType from './events/EventType.js';\nimport PriorityQueue, {DROP} from './structs/PriorityQueue.js';\nimport TileState from './TileState.js';\n\n/**\n * @typedef {function(import(\"./Tile.js\").default, string, import(\"./coordinate.js\").Coordinate, number): number} PriorityFunction\n */\n\nclass TileQueue extends PriorityQueue {\n  /**\n   * @param {PriorityFunction} tilePriorityFunction Tile priority function.\n   * @param {function(): ?} tileChangeCallback Function called on each tile change event.\n   */\n  constructor(tilePriorityFunction, tileChangeCallback) {\n    super(\n      /**\n       * @param {Array} element Element.\n       * @return {number} Priority.\n       */\n      function (element) {\n        return tilePriorityFunction.apply(null, element);\n      },\n      /**\n       * @param {Array} element Element.\n       * @return {string} Key.\n       */\n      function (element) {\n        return /** @type {import(\"./Tile.js\").default} */ (element[0]).getKey();\n      }\n    );\n\n    /** @private */\n    this.boundHandleTileChange_ = this.handleTileChange.bind(this);\n\n    /**\n     * @private\n     * @type {function(): ?}\n     */\n    this.tileChangeCallback_ = tileChangeCallback;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.tilesLoading_ = 0;\n\n    /**\n     * @private\n     * @type {!Object<string,boolean>}\n     */\n    this.tilesLoadingKeys_ = {};\n  }\n\n  /**\n   * @param {Array} element Element.\n   * @return {boolean} The element was added to the queue.\n   */\n  enqueue(element) {\n    const added = super.enqueue(element);\n    if (added) {\n      const tile = element[0];\n      tile.addEventListener(EventType.CHANGE, this.boundHandleTileChange_);\n    }\n    return added;\n  }\n\n  /**\n   * @return {number} Number of tiles loading.\n   */\n  getTilesLoading() {\n    return this.tilesLoading_;\n  }\n\n  /**\n   * @param {import(\"./events/Event.js\").default} event Event.\n   * @protected\n   */\n  handleTileChange(event) {\n    const tile = /** @type {import(\"./Tile.js\").default} */ (event.target);\n    const state = tile.getState();\n    if (\n      (tile.hifi && state === TileState.LOADED) ||\n      state === TileState.ERROR ||\n      state === TileState.EMPTY\n    ) {\n      tile.removeEventListener(EventType.CHANGE, this.boundHandleTileChange_);\n      const tileKey = tile.getKey();\n      if (tileKey in this.tilesLoadingKeys_) {\n        delete this.tilesLoadingKeys_[tileKey];\n        --this.tilesLoading_;\n      }\n      this.tileChangeCallback_();\n    }\n  }\n\n  /**\n   * @param {number} maxTotalLoading Maximum number tiles to load simultaneously.\n   * @param {number} maxNewLoads Maximum number of new tiles to load.\n   */\n  loadMoreTiles(maxTotalLoading, maxNewLoads) {\n    let newLoads = 0;\n    let state, tile, tileKey;\n    while (\n      this.tilesLoading_ < maxTotalLoading &&\n      newLoads < maxNewLoads &&\n      this.getCount() > 0\n    ) {\n      tile = /** @type {import(\"./Tile.js\").default} */ (this.dequeue()[0]);\n      tileKey = tile.getKey();\n      state = tile.getState();\n      if (state === TileState.IDLE && !(tileKey in this.tilesLoadingKeys_)) {\n        this.tilesLoadingKeys_[tileKey] = true;\n        ++this.tilesLoading_;\n        ++newLoads;\n        tile.load();\n      }\n    }\n  }\n}\n\nexport default TileQueue;\n\n/**\n * @param {import('./PluggableMap.js').FrameState} frameState Frame state.\n * @param {import(\"./Tile.js\").default} tile Tile.\n * @param {string} tileSourceKey Tile source key.\n * @param {import(\"./coordinate.js\").Coordinate} tileCenter Tile center.\n * @param {number} tileResolution Tile resolution.\n * @return {number} Tile priority.\n */\nexport function getTilePriority(\n  frameState,\n  tile,\n  tileSourceKey,\n  tileCenter,\n  tileResolution\n) {\n  // Filter out tiles at higher zoom levels than the current zoom level, or that\n  // are outside the visible extent.\n  if (!frameState || !(tileSourceKey in frameState.wantedTiles)) {\n    return DROP;\n  }\n  if (!frameState.wantedTiles[tileSourceKey][tile.getKey()]) {\n    return DROP;\n  }\n  // Prioritize the highest zoom level tiles closest to the focus.\n  // Tiles at higher zoom levels are prioritized using Math.log(tileResolution).\n  // Within a zoom level, tiles are prioritized by the distance in pixels between\n  // the center of the tile and the center of the viewport.  The factor of 65536\n  // means that the prioritization should behave as desired for tiles up to\n  // 65536 * Math.log(2) = 45426 pixels from the focus.\n  const center = frameState.viewState.center;\n  const deltaX = tileCenter[0] - center[0];\n  const deltaY = tileCenter[1] - center[1];\n  return (\n    65536 * Math.log(tileResolution) +\n    Math.sqrt(deltaX * deltaX + deltaY * deltaY) / tileResolution\n  );\n}\n","/**\n * @module ol/ViewHint\n */\n\n/**\n * @enum {number}\n */\nexport default {\n  ANIMATING: 0,\n  INTERACTING: 1,\n};\n","/**\n * @module ol/ViewProperty\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  CENTER: 'center',\n  RESOLUTION: 'resolution',\n  ROTATION: 'rotation',\n};\n","/**\n * @module ol/centerconstraint\n */\nimport {clamp} from './math.js';\n\n/**\n * @typedef {function((import(\"./coordinate.js\").Coordinate|undefined), number, import(\"./size.js\").Size, boolean=, Array<number>=): (import(\"./coordinate.js\").Coordinate|undefined)} Type\n */\n\n/**\n * @param {import(\"./extent.js\").Extent} extent Extent.\n * @param {boolean} onlyCenter If true, the constraint will only apply to the view center.\n * @param {boolean} smooth If true, the view will be able to go slightly out of the given extent\n * (only during interaction and animation).\n * @return {Type} The constraint.\n */\nexport function createExtent(extent, onlyCenter, smooth) {\n  return (\n    /**\n     * @param {import(\"./coordinate.js\").Coordinate|undefined} center Center.\n     * @param {number} resolution Resolution.\n     * @param {import(\"./size.js\").Size} size Viewport size; unused if `onlyCenter` was specified.\n     * @param {boolean=} opt_isMoving True if an interaction or animation is in progress.\n     * @param {Array<number>=} opt_centerShift Shift between map center and viewport center.\n     * @return {import(\"./coordinate.js\").Coordinate|undefined} Center.\n     */\n    function (center, resolution, size, opt_isMoving, opt_centerShift) {\n      if (center) {\n        const viewWidth = onlyCenter ? 0 : size[0] * resolution;\n        const viewHeight = onlyCenter ? 0 : size[1] * resolution;\n        const shiftX = opt_centerShift ? opt_centerShift[0] : 0;\n        const shiftY = opt_centerShift ? opt_centerShift[1] : 0;\n        let minX = extent[0] + viewWidth / 2 + shiftX;\n        let maxX = extent[2] - viewWidth / 2 + shiftX;\n        let minY = extent[1] + viewHeight / 2 + shiftY;\n        let maxY = extent[3] - viewHeight / 2 + shiftY;\n\n        // note: when zooming out of bounds, min and max values for x and y may\n        // end up inverted (min > max); this has to be accounted for\n        if (minX > maxX) {\n          minX = (maxX + minX) / 2;\n          maxX = minX;\n        }\n        if (minY > maxY) {\n          minY = (maxY + minY) / 2;\n          maxY = minY;\n        }\n\n        let x = clamp(center[0], minX, maxX);\n        let y = clamp(center[1], minY, maxY);\n        const ratio = 30 * resolution;\n\n        // during an interaction, allow some overscroll\n        if (opt_isMoving && smooth) {\n          x +=\n            -ratio * Math.log(1 + Math.max(0, minX - center[0]) / ratio) +\n            ratio * Math.log(1 + Math.max(0, center[0] - maxX) / ratio);\n          y +=\n            -ratio * Math.log(1 + Math.max(0, minY - center[1]) / ratio) +\n            ratio * Math.log(1 + Math.max(0, center[1] - maxY) / ratio);\n        }\n\n        return [x, y];\n      } else {\n        return undefined;\n      }\n    }\n  );\n}\n\n/**\n * @param {import(\"./coordinate.js\").Coordinate=} center Center.\n * @return {import(\"./coordinate.js\").Coordinate|undefined} Center.\n */\nexport function none(center) {\n  return center;\n}\n","/**\n * @module ol/resolutionconstraint\n */\nimport {clamp} from './math.js';\nimport {getHeight, getWidth} from './extent.js';\nimport {linearFindNearest} from './array.js';\n\n/**\n * @typedef {function((number|undefined), number, import(\"./size.js\").Size, boolean=): (number|undefined)} Type\n */\n\n/**\n * Returns a modified resolution taking into account the viewport size and maximum\n * allowed extent.\n * @param {number} resolution Resolution\n * @param {import(\"./extent.js\").Extent} maxExtent Maximum allowed extent.\n * @param {import(\"./size.js\").Size} viewportSize Viewport size.\n * @param {boolean} showFullExtent Whether to show the full extent.\n * @return {number} Capped resolution.\n */\nfunction getViewportClampedResolution(\n  resolution,\n  maxExtent,\n  viewportSize,\n  showFullExtent\n) {\n  const xResolution = getWidth(maxExtent) / viewportSize[0];\n  const yResolution = getHeight(maxExtent) / viewportSize[1];\n\n  if (showFullExtent) {\n    return Math.min(resolution, Math.max(xResolution, yResolution));\n  }\n  return Math.min(resolution, Math.min(xResolution, yResolution));\n}\n\n/**\n * Returns a modified resolution to be between maxResolution and minResolution while\n * still allowing the value to be slightly out of bounds.\n * Note: the computation is based on the logarithm function (ln):\n *  - at 1, ln(x) is 0\n *  - above 1, ln(x) keeps increasing but at a much slower pace than x\n * The final result is clamped to prevent getting too far away from bounds.\n * @param {number} resolution Resolution.\n * @param {number} maxResolution Max resolution.\n * @param {number} minResolution Min resolution.\n * @return {number} Smoothed resolution.\n */\nfunction getSmoothClampedResolution(resolution, maxResolution, minResolution) {\n  let result = Math.min(resolution, maxResolution);\n  const ratio = 50;\n\n  result *=\n    Math.log(1 + ratio * Math.max(0, resolution / maxResolution - 1)) / ratio +\n    1;\n  if (minResolution) {\n    result = Math.max(result, minResolution);\n    result /=\n      Math.log(1 + ratio * Math.max(0, minResolution / resolution - 1)) /\n        ratio +\n      1;\n  }\n  return clamp(result, minResolution / 2, maxResolution * 2);\n}\n\n/**\n * @param {Array<number>} resolutions Resolutions.\n * @param {boolean=} opt_smooth If true, the view will be able to slightly exceed resolution limits. Default: true.\n * @param {import(\"./extent.js\").Extent=} opt_maxExtent Maximum allowed extent.\n * @param {boolean=} opt_showFullExtent If true, allows us to show the full extent. Default: false.\n * @return {Type} Zoom function.\n */\nexport function createSnapToResolutions(\n  resolutions,\n  opt_smooth,\n  opt_maxExtent,\n  opt_showFullExtent\n) {\n  return (\n    /**\n     * @param {number|undefined} resolution Resolution.\n     * @param {number} direction Direction.\n     * @param {import(\"./size.js\").Size} size Viewport size.\n     * @param {boolean=} opt_isMoving True if an interaction or animation is in progress.\n     * @return {number|undefined} Resolution.\n     */\n    function (resolution, direction, size, opt_isMoving) {\n      if (resolution !== undefined) {\n        const maxResolution = resolutions[0];\n        const minResolution = resolutions[resolutions.length - 1];\n        const cappedMaxRes = opt_maxExtent\n          ? getViewportClampedResolution(\n              maxResolution,\n              opt_maxExtent,\n              size,\n              opt_showFullExtent\n            )\n          : maxResolution;\n\n        // during interacting or animating, allow intermediary values\n        if (opt_isMoving) {\n          const smooth = opt_smooth !== undefined ? opt_smooth : true;\n          if (!smooth) {\n            return clamp(resolution, minResolution, cappedMaxRes);\n          }\n          return getSmoothClampedResolution(\n            resolution,\n            cappedMaxRes,\n            minResolution\n          );\n        }\n\n        const capped = Math.min(cappedMaxRes, resolution);\n        const z = Math.floor(linearFindNearest(resolutions, capped, direction));\n        if (resolutions[z] > cappedMaxRes && z < resolutions.length - 1) {\n          return resolutions[z + 1];\n        }\n        return resolutions[z];\n      } else {\n        return undefined;\n      }\n    }\n  );\n}\n\n/**\n * @param {number} power Power.\n * @param {number} maxResolution Maximum resolution.\n * @param {number=} opt_minResolution Minimum resolution.\n * @param {boolean=} opt_smooth If true, the view will be able to slightly exceed resolution limits. Default: true.\n * @param {import(\"./extent.js\").Extent=} opt_maxExtent Maximum allowed extent.\n * @param {boolean=} opt_showFullExtent If true, allows us to show the full extent. Default: false.\n * @return {Type} Zoom function.\n */\nexport function createSnapToPower(\n  power,\n  maxResolution,\n  opt_minResolution,\n  opt_smooth,\n  opt_maxExtent,\n  opt_showFullExtent\n) {\n  return (\n    /**\n     * @param {number|undefined} resolution Resolution.\n     * @param {number} direction Direction.\n     * @param {import(\"./size.js\").Size} size Viewport size.\n     * @param {boolean=} opt_isMoving True if an interaction or animation is in progress.\n     * @return {number|undefined} Resolution.\n     */\n    function (resolution, direction, size, opt_isMoving) {\n      if (resolution !== undefined) {\n        const cappedMaxRes = opt_maxExtent\n          ? getViewportClampedResolution(\n              maxResolution,\n              opt_maxExtent,\n              size,\n              opt_showFullExtent\n            )\n          : maxResolution;\n        const minResolution =\n          opt_minResolution !== undefined ? opt_minResolution : 0;\n\n        // during interacting or animating, allow intermediary values\n        if (opt_isMoving) {\n          const smooth = opt_smooth !== undefined ? opt_smooth : true;\n          if (!smooth) {\n            return clamp(resolution, minResolution, cappedMaxRes);\n          }\n          return getSmoothClampedResolution(\n            resolution,\n            cappedMaxRes,\n            minResolution\n          );\n        }\n\n        const tolerance = 1e-9;\n        const minZoomLevel = Math.ceil(\n          Math.log(maxResolution / cappedMaxRes) / Math.log(power) - tolerance\n        );\n        const offset = -direction * (0.5 - tolerance) + 0.5;\n        const capped = Math.min(cappedMaxRes, resolution);\n        const cappedZoomLevel = Math.floor(\n          Math.log(maxResolution / capped) / Math.log(power) + offset\n        );\n        const zoomLevel = Math.max(minZoomLevel, cappedZoomLevel);\n        const newResolution = maxResolution / Math.pow(power, zoomLevel);\n        return clamp(newResolution, minResolution, cappedMaxRes);\n      } else {\n        return undefined;\n      }\n    }\n  );\n}\n\n/**\n * @param {number} maxResolution Max resolution.\n * @param {number} minResolution Min resolution.\n * @param {boolean=} opt_smooth If true, the view will be able to slightly exceed resolution limits. Default: true.\n * @param {import(\"./extent.js\").Extent=} opt_maxExtent Maximum allowed extent.\n * @param {boolean=} opt_showFullExtent If true, allows us to show the full extent. Default: false.\n * @return {Type} Zoom function.\n */\nexport function createMinMaxResolution(\n  maxResolution,\n  minResolution,\n  opt_smooth,\n  opt_maxExtent,\n  opt_showFullExtent\n) {\n  return (\n    /**\n     * @param {number|undefined} resolution Resolution.\n     * @param {number} direction Direction.\n     * @param {import(\"./size.js\").Size} size Viewport size.\n     * @param {boolean=} opt_isMoving True if an interaction or animation is in progress.\n     * @return {number|undefined} Resolution.\n     */\n    function (resolution, direction, size, opt_isMoving) {\n      if (resolution !== undefined) {\n        const cappedMaxRes = opt_maxExtent\n          ? getViewportClampedResolution(\n              maxResolution,\n              opt_maxExtent,\n              size,\n              opt_showFullExtent\n            )\n          : maxResolution;\n        const smooth = opt_smooth !== undefined ? opt_smooth : true;\n\n        if (!smooth || !opt_isMoving) {\n          return clamp(resolution, minResolution, cappedMaxRes);\n        }\n        return getSmoothClampedResolution(\n          resolution,\n          cappedMaxRes,\n          minResolution\n        );\n      } else {\n        return undefined;\n      }\n    }\n  );\n}\n","/**\n * @module ol/rotationconstraint\n */\nimport {toRadians} from './math.js';\n\n/**\n * @typedef {function((number|undefined), boolean=): (number|undefined)} Type\n */\n\n/**\n * @param {number|undefined} rotation Rotation.\n * @return {number|undefined} Rotation.\n */\nexport function disable(rotation) {\n  if (rotation !== undefined) {\n    return 0;\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * @param {number|undefined} rotation Rotation.\n * @return {number|undefined} Rotation.\n */\nexport function none(rotation) {\n  if (rotation !== undefined) {\n    return rotation;\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * @param {number} n N.\n * @return {Type} Rotation constraint.\n */\nexport function createSnapToN(n) {\n  const theta = (2 * Math.PI) / n;\n  return (\n    /**\n     * @param {number|undefined} rotation Rotation.\n     * @param {boolean=} opt_isMoving True if an interaction or animation is in progress.\n     * @return {number|undefined} Rotation.\n     */\n    function (rotation, opt_isMoving) {\n      if (opt_isMoving) {\n        return rotation;\n      }\n\n      if (rotation !== undefined) {\n        rotation = Math.floor(rotation / theta + 0.5) * theta;\n        return rotation;\n      } else {\n        return undefined;\n      }\n    }\n  );\n}\n\n/**\n * @param {number=} opt_tolerance Tolerance.\n * @return {Type} Rotation constraint.\n */\nexport function createSnapToZero(opt_tolerance) {\n  const tolerance = opt_tolerance || toRadians(5);\n  return (\n    /**\n     * @param {number|undefined} rotation Rotation.\n     * @param {boolean=} opt_isMoving True if an interaction or animation is in progress.\n     * @return {number|undefined} Rotation.\n     */\n    function (rotation, opt_isMoving) {\n      if (opt_isMoving) {\n        return rotation;\n      }\n\n      if (rotation !== undefined) {\n        if (Math.abs(rotation) <= tolerance) {\n          return 0;\n        } else {\n          return rotation;\n        }\n      } else {\n        return undefined;\n      }\n    }\n  );\n}\n","/**\n * @module ol/geom/GeometryLayout\n */\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","/**\n * @module ol/geom/flat/transform\n */\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {import(\"../../transform.js\").Transform} transform Transform.\n * @param {Array<number>=} opt_dest Destination.\n * @return {Array<number>} Transformed coordinates.\n */\nexport function transform2D(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  transform,\n  opt_dest\n) {\n  const dest = opt_dest ? opt_dest : [];\n  let i = 0;\n  for (let j = offset; j < end; j += stride) {\n    const x = flatCoordinates[j];\n    const 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/**\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(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  angle,\n  anchor,\n  opt_dest\n) {\n  const dest = opt_dest ? opt_dest : [];\n  const cos = Math.cos(angle);\n  const sin = Math.sin(angle);\n  const anchorX = anchor[0];\n  const anchorY = anchor[1];\n  let i = 0;\n  for (let j = offset; j < end; j += stride) {\n    const deltaX = flatCoordinates[j] - anchorX;\n    const deltaY = flatCoordinates[j + 1] - anchorY;\n    dest[i++] = anchorX + deltaX * cos - deltaY * sin;\n    dest[i++] = anchorY + deltaX * sin + deltaY * cos;\n    for (let 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/**\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(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  sx,\n  sy,\n  anchor,\n  opt_dest\n) {\n  const dest = opt_dest ? opt_dest : [];\n  const anchorX = anchor[0];\n  const anchorY = anchor[1];\n  let i = 0;\n  for (let j = offset; j < end; j += stride) {\n    const deltaX = flatCoordinates[j] - anchorX;\n    const deltaY = flatCoordinates[j + 1] - anchorY;\n    dest[i++] = anchorX + sx * deltaX;\n    dest[i++] = anchorY + sy * deltaY;\n    for (let 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/**\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(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  deltaX,\n  deltaY,\n  opt_dest\n) {\n  const dest = opt_dest ? opt_dest : [];\n  let i = 0;\n  for (let j = offset; j < end; j += stride) {\n    dest[i++] = flatCoordinates[j] + deltaX;\n    dest[i++] = flatCoordinates[j + 1] + deltaY;\n    for (let 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 * @module ol/geom/Geometry\n */\nimport BaseObject from '../Object.js';\nimport Units from '../proj/Units.js';\nimport {abstract} from '../util.js';\nimport {\n  compose as composeTransform,\n  create as createTransform,\n} from '../transform.js';\nimport {\n  createEmpty,\n  createOrUpdateEmpty,\n  getHeight,\n  returnOrUpdate,\n} from '../extent.js';\nimport {get as getProjection, getTransform} from '../proj.js';\nimport {memoizeOne} from '../functions.js';\nimport {transform2D} from './flat/transform.js';\n\n/**\n * @type {import(\"../transform.js\").Transform}\n */\nconst tmpTransform = createTransform();\n\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 */\nclass Geometry extends BaseObject {\n  constructor() {\n    super();\n\n    /**\n     * @private\n     * @type {import(\"../extent.js\").Extent}\n     */\n    this.extent_ = createEmpty();\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.extentRevision_ = -1;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.simplifiedGeometryMaxMinSquaredTolerance = 0;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.simplifiedGeometryRevision = 0;\n\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 (\n      revision,\n      squaredTolerance,\n      opt_transform\n    ) {\n      if (!opt_transform) {\n        return this.getSimplifiedGeometry(squaredTolerance);\n      }\n      const clone = this.clone();\n      clone.applyTransform(opt_transform);\n      return clone.getSimplifiedGeometry(squaredTolerance);\n    });\n  }\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  simplifyTransformed(squaredTolerance, opt_transform) {\n    return this.simplifyTransformedInternal(\n      this.getRevision(),\n      squaredTolerance,\n      opt_transform\n    );\n  }\n\n  /**\n   * Make a complete copy of the geometry.\n   * @abstract\n   * @return {!Geometry} Clone.\n   */\n  clone() {\n    return abstract();\n  }\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  closestPointXY(x, y, closestPoint, minSquaredDistance) {\n    return abstract();\n  }\n\n  /**\n   * @param {number} x X.\n   * @param {number} y Y.\n   * @return {boolean} Contains (x, y).\n   */\n  containsXY(x, y) {\n    const coord = this.getClosestPoint([x, y]);\n    return coord[0] === x && coord[1] === y;\n  }\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  getClosestPoint(point, opt_closestPoint) {\n    const closestPoint = opt_closestPoint ? opt_closestPoint : [NaN, NaN];\n    this.closestPointXY(point[0], point[1], closestPoint, Infinity);\n    return closestPoint;\n  }\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  intersectsCoordinate(coordinate) {\n    return this.containsXY(coordinate[0], coordinate[1]);\n  }\n\n  /**\n   * @abstract\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @protected\n   * @return {import(\"../extent.js\").Extent} extent Extent.\n   */\n  computeExtent(extent) {\n    return abstract();\n  }\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  getExtent(opt_extent) {\n    if (this.extentRevision_ != this.getRevision()) {\n      const 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  /**\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  rotate(angle, anchor) {\n    abstract();\n  }\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  scale(sx, opt_sy, opt_anchor) {\n    abstract();\n  }\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  simplify(tolerance) {\n    return this.getSimplifiedGeometry(tolerance * tolerance);\n  }\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  getSimplifiedGeometry(squaredTolerance) {\n    return abstract();\n  }\n\n  /**\n   * Get the type of this geometry.\n   * @abstract\n   * @return {import(\"./GeometryType.js\").default} Geometry type.\n   */\n  getType() {\n    return abstract();\n  }\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  applyTransform(transformFn) {\n    abstract();\n  }\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  intersectsExtent(extent) {\n    return abstract();\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   * @abstract\n   * @param {number} deltaX Delta X.\n   * @param {number} deltaY Delta Y.\n   * @api\n   */\n  translate(deltaX, deltaY) {\n    abstract();\n  }\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  transform(source, destination) {\n    /** @type {import(\"../proj/Projection.js\").default} */\n    const sourceProj = getProjection(source);\n    const transformFn =\n      sourceProj.getUnits() == Units.TILE_PIXELS\n        ? function (inCoordinates, outCoordinates, stride) {\n            const pixelExtent = sourceProj.getExtent();\n            const projectedExtent = sourceProj.getWorldExtent();\n            const scale = getHeight(projectedExtent) / getHeight(pixelExtent);\n            composeTransform(\n              tmpTransform,\n              projectedExtent[0],\n              projectedExtent[3],\n              scale,\n              -scale,\n              0,\n              0,\n              0\n            );\n            transform2D(\n              inCoordinates,\n              0,\n              inCoordinates.length,\n              stride,\n              tmpTransform,\n              outCoordinates\n            );\n            return getTransform(sourceProj, destination)(\n              inCoordinates,\n              outCoordinates,\n              stride\n            );\n          }\n        : getTransform(sourceProj, destination);\n    this.applyTransform(transformFn);\n    return this;\n  }\n}\n\nexport default Geometry;\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/**\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 */\nclass SimpleGeometry extends Geometry {\n  constructor() {\n    super();\n\n    /**\n     * @protected\n     * @type {import(\"./GeometryLayout.js\").default}\n     */\n    this.layout = GeometryLayout.XY;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.stride = 2;\n\n    /**\n     * @protected\n     * @type {Array<number>}\n     */\n    this.flatCoordinates = null;\n  }\n\n  /**\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @protected\n   * @return {import(\"../extent.js\").Extent} extent Extent.\n   */\n  computeExtent(extent) {\n    return createOrUpdateFromFlatCoordinates(\n      this.flatCoordinates,\n      0,\n      this.flatCoordinates.length,\n      this.stride,\n      extent\n    );\n  }\n\n  /**\n   * @abstract\n   * @return {Array<*>} Coordinates.\n   */\n  getCoordinates() {\n    return abstract();\n  }\n\n  /**\n   * Return the first coordinate of the geometry.\n   * @return {import(\"../coordinate.js\").Coordinate} First coordinate.\n   * @api\n   */\n  getFirstCoordinate() {\n    return this.flatCoordinates.slice(0, this.stride);\n  }\n\n  /**\n   * @return {Array<number>} Flat coordinates.\n   */\n  getFlatCoordinates() {\n    return this.flatCoordinates;\n  }\n\n  /**\n   * Return the last coordinate of the geometry.\n   * @return {import(\"../coordinate.js\").Coordinate} Last point.\n   * @api\n   */\n  getLastCoordinate() {\n    return this.flatCoordinates.slice(\n      this.flatCoordinates.length - this.stride\n    );\n  }\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  getLayout() {\n    return this.layout;\n  }\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  getSimplifiedGeometry(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 (\n      squaredTolerance < 0 ||\n      (this.simplifiedGeometryMaxMinSquaredTolerance !== 0 &&\n        squaredTolerance <= this.simplifiedGeometryMaxMinSquaredTolerance)\n    ) {\n      return this;\n    }\n\n    const simplifiedGeometry = this.getSimplifiedGeometryInternal(\n      squaredTolerance\n    );\n    const simplifiedFlatCoordinates = simplifiedGeometry.getFlatCoordinates();\n    if (simplifiedFlatCoordinates.length < this.flatCoordinates.length) {\n      return simplifiedGeometry;\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  /**\n   * @param {number} squaredTolerance Squared tolerance.\n   * @return {SimpleGeometry} Simplified geometry.\n   * @protected\n   */\n  getSimplifiedGeometryInternal(squaredTolerance) {\n    return this;\n  }\n\n  /**\n   * @return {number} Stride.\n   */\n  getStride() {\n    return this.stride;\n  }\n\n  /**\n   * @param {import(\"./GeometryLayout.js\").default} layout Layout.\n   * @param {Array<number>} flatCoordinates Flat coordinates.\n   */\n  setFlatCoordinates(layout, flatCoordinates) {\n    this.stride = getStrideForLayout(layout);\n    this.layout = layout;\n    this.flatCoordinates = flatCoordinates;\n  }\n\n  /**\n   * @abstract\n   * @param {!Array<*>} coordinates Coordinates.\n   * @param {import(\"./GeometryLayout.js\").default=} opt_layout Layout.\n   */\n  setCoordinates(coordinates, opt_layout) {\n    abstract();\n  }\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  setLayout(layout, coordinates, nesting) {\n    /** @type {number} */\n    let stride;\n    if (layout) {\n      stride = getStrideForLayout(layout);\n    } else {\n      for (let i = 0; i < nesting; ++i) {\n        if (coordinates.length === 0) {\n          this.layout = GeometryLayout.XY;\n          this.stride = 2;\n          return;\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  /**\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  applyTransform(transformFn) {\n    if (this.flatCoordinates) {\n      transformFn(this.flatCoordinates, this.flatCoordinates, this.stride);\n      this.changed();\n    }\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  rotate(angle, anchor) {\n    const flatCoordinates = this.getFlatCoordinates();\n    if (flatCoordinates) {\n      const stride = this.getStride();\n      rotate(\n        flatCoordinates,\n        0,\n        flatCoordinates.length,\n        stride,\n        angle,\n        anchor,\n        flatCoordinates\n      );\n      this.changed();\n    }\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  scale(sx, opt_sy, opt_anchor) {\n    let sy = opt_sy;\n    if (sy === undefined) {\n      sy = sx;\n    }\n    let anchor = opt_anchor;\n    if (!anchor) {\n      anchor = getCenter(this.getExtent());\n    }\n    const flatCoordinates = this.getFlatCoordinates();\n    if (flatCoordinates) {\n      const stride = this.getStride();\n      scale(\n        flatCoordinates,\n        0,\n        flatCoordinates.length,\n        stride,\n        sx,\n        sy,\n        anchor,\n        flatCoordinates\n      );\n      this.changed();\n    }\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  translate(deltaX, deltaY) {\n    const flatCoordinates = this.getFlatCoordinates();\n    if (flatCoordinates) {\n      const stride = this.getStride();\n      translate(\n        flatCoordinates,\n        0,\n        flatCoordinates.length,\n        stride,\n        deltaX,\n        deltaY,\n        flatCoordinates\n      );\n      this.changed();\n    }\n  }\n}\n\n/**\n * @param {number} stride Stride.\n * @return {import(\"./GeometryLayout.js\").default} layout Layout.\n */\nfunction getLayoutForStride(stride) {\n  let layout;\n  if (stride == 2) {\n    layout = GeometryLayout.XY;\n  } else if (stride == 3) {\n    layout = GeometryLayout.XYZ;\n  } else if (stride == 4) {\n    layout = GeometryLayout.XYZM;\n  }\n  return /** @type {import(\"./GeometryLayout.js\").default} */ (layout);\n}\n\n/**\n * @param {import(\"./GeometryLayout.js\").default} layout Layout.\n * @return {number} Stride.\n */\nexport function getStrideForLayout(layout) {\n  let stride;\n  if (layout == GeometryLayout.XY) {\n    stride = 2;\n  } else if (layout == GeometryLayout.XYZ || layout == GeometryLayout.XYM) {\n    stride = 3;\n  } else if (layout == GeometryLayout.XYZM) {\n    stride = 4;\n  }\n  return /** @type {number} */ (stride);\n}\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  const flatCoordinates = simpleGeometry.getFlatCoordinates();\n  if (!flatCoordinates) {\n    return null;\n  } else {\n    const stride = simpleGeometry.getStride();\n    return transform2D(\n      flatCoordinates,\n      0,\n      flatCoordinates.length,\n      stride,\n      transform,\n      opt_dest\n    );\n  }\n}\n\nexport default SimpleGeometry;\n","/**\n * @module ol/geom/flat/closest\n */\nimport {lerp, squaredDistance as squaredDx} from '../../math.js';\n\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(\n  flatCoordinates,\n  offset1,\n  offset2,\n  stride,\n  x,\n  y,\n  closestPoint\n) {\n  const x1 = flatCoordinates[offset1];\n  const y1 = flatCoordinates[offset1 + 1];\n  const dx = flatCoordinates[offset2] - x1;\n  const dy = flatCoordinates[offset2 + 1] - y1;\n  let offset;\n  if (dx === 0 && dy === 0) {\n    offset = offset1;\n  } else {\n    const t = ((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy);\n    if (t > 1) {\n      offset = offset2;\n    } else if (t > 0) {\n      for (let i = 0; i < stride; ++i) {\n        closestPoint[i] = lerp(\n          flatCoordinates[offset1 + i],\n          flatCoordinates[offset2 + i],\n          t\n        );\n      }\n      closestPoint.length = stride;\n      return;\n    } else {\n      offset = offset1;\n    }\n  }\n  for (let i = 0; i < stride; ++i) {\n    closestPoint[i] = flatCoordinates[offset + i];\n  }\n  closestPoint.length = stride;\n}\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  let x1 = flatCoordinates[offset];\n  let y1 = flatCoordinates[offset + 1];\n  for (offset += stride; offset < end; offset += stride) {\n    const x2 = flatCoordinates[offset];\n    const y2 = flatCoordinates[offset + 1];\n    const 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/**\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(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  max\n) {\n  for (let i = 0, ii = ends.length; i < ii; ++i) {\n    const end = ends[i];\n    max = maxSquaredDelta(flatCoordinates, offset, end, stride, max);\n    offset = end;\n  }\n  return max;\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 {number} max Max squared delta.\n * @return {number} Max squared delta.\n */\nexport function multiArrayMaxSquaredDelta(\n  flatCoordinates,\n  offset,\n  endss,\n  stride,\n  max\n) {\n  for (let i = 0, ii = endss.length; i < ii; ++i) {\n    const ends = endss[i];\n    max = arrayMaxSquaredDelta(flatCoordinates, offset, ends, stride, max);\n    offset = ends[ends.length - 1];\n  }\n  return max;\n}\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {number} 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(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  maxDelta,\n  isRing,\n  x,\n  y,\n  closestPoint,\n  minSquaredDistance,\n  opt_tmpPoint\n) {\n  if (offset == end) {\n    return minSquaredDistance;\n  }\n  let i, squaredDistance;\n  if (maxDelta === 0) {\n    // All points are identical, so just test the first point.\n    squaredDistance = squaredDx(\n      x,\n      y,\n      flatCoordinates[offset],\n      flatCoordinates[offset + 1]\n    );\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    } else {\n      return minSquaredDistance;\n    }\n  }\n  const tmpPoint = opt_tmpPoint ? opt_tmpPoint : [NaN, NaN];\n  let index = offset + stride;\n  while (index < end) {\n    assignClosest(\n      flatCoordinates,\n      index - stride,\n      index,\n      stride,\n      x,\n      y,\n      tmpPoint\n    );\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    } 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(\n          ((Math.sqrt(squaredDistance) - Math.sqrt(minSquaredDistance)) /\n            maxDelta) |\n            0,\n          1\n        );\n    }\n  }\n  if (isRing) {\n    // Check the closing segment.\n    assignClosest(\n      flatCoordinates,\n      end - stride,\n      offset,\n      stride,\n      x,\n      y,\n      tmpPoint\n    );\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/**\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(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  maxDelta,\n  isRing,\n  x,\n  y,\n  closestPoint,\n  minSquaredDistance,\n  opt_tmpPoint\n) {\n  const tmpPoint = opt_tmpPoint ? opt_tmpPoint : [NaN, NaN];\n  for (let i = 0, ii = ends.length; i < ii; ++i) {\n    const end = ends[i];\n    minSquaredDistance = assignClosestPoint(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      maxDelta,\n      isRing,\n      x,\n      y,\n      closestPoint,\n      minSquaredDistance,\n      tmpPoint\n    );\n    offset = end;\n  }\n  return minSquaredDistance;\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 {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(\n  flatCoordinates,\n  offset,\n  endss,\n  stride,\n  maxDelta,\n  isRing,\n  x,\n  y,\n  closestPoint,\n  minSquaredDistance,\n  opt_tmpPoint\n) {\n  const tmpPoint = opt_tmpPoint ? opt_tmpPoint : [NaN, NaN];\n  for (let i = 0, ii = endss.length; i < ii; ++i) {\n    const ends = endss[i];\n    minSquaredDistance = assignClosestArrayPoint(\n      flatCoordinates,\n      offset,\n      ends,\n      stride,\n      maxDelta,\n      isRing,\n      x,\n      y,\n      closestPoint,\n      minSquaredDistance,\n      tmpPoint\n    );\n    offset = ends[ends.length - 1];\n  }\n  return minSquaredDistance;\n}\n","/**\n * @module ol/geom/flat/deflate\n */\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 (let i = 0, ii = coordinate.length; i < ii; ++i) {\n    flatCoordinates[offset++] = coordinate[i];\n  }\n  return offset;\n}\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(\n  flatCoordinates,\n  offset,\n  coordinates,\n  stride\n) {\n  for (let i = 0, ii = coordinates.length; i < ii; ++i) {\n    const coordinate = coordinates[i];\n    for (let j = 0; j < stride; ++j) {\n      flatCoordinates[offset++] = coordinate[j];\n    }\n  }\n  return offset;\n}\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(\n  flatCoordinates,\n  offset,\n  coordinatess,\n  stride,\n  opt_ends\n) {\n  const ends = opt_ends ? opt_ends : [];\n  let i = 0;\n  for (let j = 0, jj = coordinatess.length; j < jj; ++j) {\n    const end = deflateCoordinates(\n      flatCoordinates,\n      offset,\n      coordinatess[j],\n      stride\n    );\n    ends[i++] = end;\n    offset = end;\n  }\n  ends.length = i;\n  return ends;\n}\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(\n  flatCoordinates,\n  offset,\n  coordinatesss,\n  stride,\n  opt_endss\n) {\n  const endss = opt_endss ? opt_endss : [];\n  let i = 0;\n  for (let j = 0, jj = coordinatesss.length; j < jj; ++j) {\n    const ends = deflateCoordinatesArray(\n      flatCoordinates,\n      offset,\n      coordinatesss[j],\n      stride,\n      endss[i]\n    );\n    endss[i++] = ends;\n    offset = ends[ends.length - 1];\n  }\n  endss.length = i;\n  return endss;\n}\n","/**\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.\n\nimport {squaredDistance, squaredSegmentDistance} from '../../math.js';\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 {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(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  squaredTolerance,\n  highQuality,\n  opt_simplifiedFlatCoordinates\n) {\n  const simplifiedFlatCoordinates =\n    opt_simplifiedFlatCoordinates !== undefined\n      ? opt_simplifiedFlatCoordinates\n      : [];\n  if (!highQuality) {\n    end = radialDistance(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      squaredTolerance,\n      simplifiedFlatCoordinates,\n      0\n    );\n    flatCoordinates = simplifiedFlatCoordinates;\n    offset = 0;\n    stride = 2;\n  }\n  simplifiedFlatCoordinates.length = douglasPeucker(\n    flatCoordinates,\n    offset,\n    end,\n    stride,\n    squaredTolerance,\n    simplifiedFlatCoordinates,\n    0\n  );\n  return simplifiedFlatCoordinates;\n}\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {number} 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(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  squaredTolerance,\n  simplifiedFlatCoordinates,\n  simplifiedOffset\n) {\n  const 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  const markers = new Array(n);\n  markers[0] = 1;\n  markers[n - 1] = 1;\n  /** @type {Array<number>} */\n  const stack = [offset, end - stride];\n  let index = 0;\n  while (stack.length > 0) {\n    const last = stack.pop();\n    const first = stack.pop();\n    let maxSquaredDistance = 0;\n    const x1 = flatCoordinates[first];\n    const y1 = flatCoordinates[first + 1];\n    const x2 = flatCoordinates[last];\n    const y2 = flatCoordinates[last + 1];\n    for (let i = first + stride; i < last; i += stride) {\n      const x = flatCoordinates[i];\n      const y = flatCoordinates[i + 1];\n      const squaredDistance = squaredSegmentDistance(x, y, x1, y1, x2, y2);\n      if (squaredDistance > maxSquaredDistance) {\n        index = i;\n        maxSquaredDistance = squaredDistance;\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 (let 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/**\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(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  squaredTolerance,\n  simplifiedFlatCoordinates,\n  simplifiedOffset,\n  simplifiedEnds\n) {\n  for (let i = 0, ii = ends.length; i < ii; ++i) {\n    const end = ends[i];\n    simplifiedOffset = douglasPeucker(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      squaredTolerance,\n      simplifiedFlatCoordinates,\n      simplifiedOffset\n    );\n    simplifiedEnds.push(simplifiedOffset);\n    offset = end;\n  }\n  return simplifiedOffset;\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 {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(\n  flatCoordinates,\n  offset,\n  endss,\n  stride,\n  squaredTolerance,\n  simplifiedFlatCoordinates,\n  simplifiedOffset,\n  simplifiedEndss\n) {\n  for (let i = 0, ii = endss.length; i < ii; ++i) {\n    const ends = endss[i];\n    const simplifiedEnds = [];\n    simplifiedOffset = douglasPeuckerArray(\n      flatCoordinates,\n      offset,\n      ends,\n      stride,\n      squaredTolerance,\n      simplifiedFlatCoordinates,\n      simplifiedOffset,\n      simplifiedEnds\n    );\n    simplifiedEndss.push(simplifiedEnds);\n    offset = ends[ends.length - 1];\n  }\n  return simplifiedOffset;\n}\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {number} 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(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  squaredTolerance,\n  simplifiedFlatCoordinates,\n  simplifiedOffset\n) {\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  let x1 = flatCoordinates[offset];\n  let y1 = flatCoordinates[offset + 1];\n  // copy first point\n  simplifiedFlatCoordinates[simplifiedOffset++] = x1;\n  simplifiedFlatCoordinates[simplifiedOffset++] = y1;\n  let x2 = x1;\n  let 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/**\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/**\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(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  tolerance,\n  simplifiedFlatCoordinates,\n  simplifiedOffset\n) {\n  // do nothing if the line is empty\n  if (offset == end) {\n    return simplifiedOffset;\n  }\n  // snap the first coordinate (P1)\n  let x1 = snap(flatCoordinates[offset], tolerance);\n  let 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  let 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    const x3 = snap(flatCoordinates[offset], tolerance);\n    const 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    const dx1 = x2 - x1;\n    const dy1 = y2 - y1;\n    // calculate the delta between P3 and P1\n    const dx2 = x3 - x1;\n    const 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 (\n      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    ) {\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/**\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(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  tolerance,\n  simplifiedFlatCoordinates,\n  simplifiedOffset,\n  simplifiedEnds\n) {\n  for (let i = 0, ii = ends.length; i < ii; ++i) {\n    const end = ends[i];\n    simplifiedOffset = quantize(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      tolerance,\n      simplifiedFlatCoordinates,\n      simplifiedOffset\n    );\n    simplifiedEnds.push(simplifiedOffset);\n    offset = end;\n  }\n  return simplifiedOffset;\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 {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(\n  flatCoordinates,\n  offset,\n  endss,\n  stride,\n  tolerance,\n  simplifiedFlatCoordinates,\n  simplifiedOffset,\n  simplifiedEndss\n) {\n  for (let i = 0, ii = endss.length; i < ii; ++i) {\n    const ends = endss[i];\n    const simplifiedEnds = [];\n    simplifiedOffset = quantizeArray(\n      flatCoordinates,\n      offset,\n      ends,\n      stride,\n      tolerance,\n      simplifiedFlatCoordinates,\n      simplifiedOffset,\n      simplifiedEnds\n    );\n    simplifiedEndss.push(simplifiedEnds);\n    offset = ends[ends.length - 1];\n  }\n  return simplifiedOffset;\n}\n","/**\n * @module ol/geom/flat/inflate\n */\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {Array<import(\"../../coordinate.js\").Coordinate>=} opt_coordinates Coordinates.\n * @return {Array<import(\"../../coordinate.js\").Coordinate>} Coordinates.\n */\nexport function inflateCoordinates(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  opt_coordinates\n) {\n  const coordinates = opt_coordinates !== undefined ? opt_coordinates : [];\n  let i = 0;\n  for (let 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/**\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(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  opt_coordinatess\n) {\n  const coordinatess = opt_coordinatess !== undefined ? opt_coordinatess : [];\n  let i = 0;\n  for (let j = 0, jj = ends.length; j < jj; ++j) {\n    const end = ends[j];\n    coordinatess[i++] = inflateCoordinates(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      coordinatess[i]\n    );\n    offset = end;\n  }\n  coordinatess.length = i;\n  return coordinatess;\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<Array<Array<import(\"../../coordinate.js\").Coordinate>>>=} opt_coordinatesss\n *     Coordinatesss.\n * @return {Array<Array<Array<import(\"../../coordinate.js\").Coordinate>>>} Coordinatesss.\n */\nexport function inflateMultiCoordinatesArray(\n  flatCoordinates,\n  offset,\n  endss,\n  stride,\n  opt_coordinatesss\n) {\n  const coordinatesss =\n    opt_coordinatesss !== undefined ? opt_coordinatesss : [];\n  let i = 0;\n  for (let j = 0, jj = endss.length; j < jj; ++j) {\n    const ends = endss[j];\n    coordinatesss[i++] = inflateCoordinatesArray(\n      flatCoordinates,\n      offset,\n      ends,\n      stride,\n      coordinatesss[i]\n    );\n    offset = ends[ends.length - 1];\n  }\n  coordinatesss.length = i;\n  return coordinatesss;\n}\n","/**\n * @module ol/geom/flat/area\n */\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @return {number} Area.\n */\nexport function linearRing(flatCoordinates, offset, end, stride) {\n  let twiceArea = 0;\n  let x1 = flatCoordinates[end - stride];\n  let y1 = flatCoordinates[end - stride + 1];\n  for (; offset < end; offset += stride) {\n    const x2 = flatCoordinates[offset];\n    const y2 = flatCoordinates[offset + 1];\n    twiceArea += y1 * x2 - x1 * y2;\n    x1 = x2;\n    y1 = y2;\n  }\n  return twiceArea / 2;\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 * @return {number} Area.\n */\nexport function linearRings(flatCoordinates, offset, ends, stride) {\n  let area = 0;\n  for (let i = 0, ii = ends.length; i < ii; ++i) {\n    const end = ends[i];\n    area += linearRing(flatCoordinates, offset, end, stride);\n    offset = end;\n  }\n  return area;\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 * @return {number} Area.\n */\nexport function linearRingss(flatCoordinates, offset, endss, stride) {\n  let area = 0;\n  for (let i = 0, ii = endss.length; i < ii; ++i) {\n    const ends = endss[i];\n    area += linearRings(flatCoordinates, offset, ends, stride);\n    offset = ends[ends.length - 1];\n  }\n  return area;\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/**\n * @classdesc\n * Linear ring geometry. Only used as part of polygon; cannot be rendered\n * on its own.\n *\n * @api\n */\nclass LinearRing extends SimpleGeometry {\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  constructor(coordinates, opt_layout) {\n    super();\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.maxDelta_ = -1;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.maxDeltaRevision_ = -1;\n\n    if (opt_layout !== undefined && !Array.isArray(coordinates[0])) {\n      this.setFlatCoordinates(\n        opt_layout,\n        /** @type {Array<number>} */ (coordinates)\n      );\n    } else {\n      this.setCoordinates(\n        /** @type {Array<import(\"../coordinate.js\").Coordinate>} */ (coordinates),\n        opt_layout\n      );\n    }\n  }\n\n  /**\n   * Make a complete copy of the geometry.\n   * @return {!LinearRing} Clone.\n   * @api\n   */\n  clone() {\n    return new LinearRing(this.flatCoordinates.slice(), this.layout);\n  }\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  closestPointXY(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(\n        maxSquaredDelta(\n          this.flatCoordinates,\n          0,\n          this.flatCoordinates.length,\n          this.stride,\n          0\n        )\n      );\n      this.maxDeltaRevision_ = this.getRevision();\n    }\n    return assignClosestPoint(\n      this.flatCoordinates,\n      0,\n      this.flatCoordinates.length,\n      this.stride,\n      this.maxDelta_,\n      true,\n      x,\n      y,\n      closestPoint,\n      minSquaredDistance\n    );\n  }\n\n  /**\n   * Return the area of the linear ring on projected plane.\n   * @return {number} Area (on projected plane).\n   * @api\n   */\n  getArea() {\n    return linearRingArea(\n      this.flatCoordinates,\n      0,\n      this.flatCoordinates.length,\n      this.stride\n    );\n  }\n\n  /**\n   * Return the coordinates of the linear ring.\n   * @return {Array<import(\"../coordinate.js\").Coordinate>} Coordinates.\n   * @api\n   */\n  getCoordinates() {\n    return inflateCoordinates(\n      this.flatCoordinates,\n      0,\n      this.flatCoordinates.length,\n      this.stride\n    );\n  }\n\n  /**\n   * @param {number} squaredTolerance Squared tolerance.\n   * @return {LinearRing} Simplified LinearRing.\n   * @protected\n   */\n  getSimplifiedGeometryInternal(squaredTolerance) {\n    const simplifiedFlatCoordinates = [];\n    simplifiedFlatCoordinates.length = douglasPeucker(\n      this.flatCoordinates,\n      0,\n      this.flatCoordinates.length,\n      this.stride,\n      squaredTolerance,\n      simplifiedFlatCoordinates,\n      0\n    );\n    return new LinearRing(simplifiedFlatCoordinates, GeometryLayout.XY);\n  }\n\n  /**\n   * Get the type of this geometry.\n   * @return {import(\"./GeometryType.js\").default} Geometry type.\n   * @api\n   */\n  getType() {\n    return GeometryType.LINEAR_RING;\n  }\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  intersectsExtent(extent) {\n    return false;\n  }\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  setCoordinates(coordinates, opt_layout) {\n    this.setLayout(opt_layout, coordinates, 1);\n    if (!this.flatCoordinates) {\n      this.flatCoordinates = [];\n    }\n    this.flatCoordinates.length = deflateCoordinates(\n      this.flatCoordinates,\n      0,\n      coordinates,\n      this.stride\n    );\n    this.changed();\n  }\n}\n\nexport default LinearRing;\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/**\n * @classdesc\n * Point geometry.\n *\n * @api\n */\nclass Point extends SimpleGeometry {\n  /**\n   * @param {import(\"../coordinate.js\").Coordinate} coordinates Coordinates.\n   * @param {import(\"./GeometryLayout.js\").default=} opt_layout Layout.\n   */\n  constructor(coordinates, opt_layout) {\n    super();\n    this.setCoordinates(coordinates, opt_layout);\n  }\n\n  /**\n   * Make a complete copy of the geometry.\n   * @return {!Point} Clone.\n   * @api\n   */\n  clone() {\n    const point = new Point(this.flatCoordinates.slice(), this.layout);\n    point.applyProperties(this);\n    return point;\n  }\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  closestPointXY(x, y, closestPoint, minSquaredDistance) {\n    const flatCoordinates = this.flatCoordinates;\n    const squaredDistance = squaredDx(\n      x,\n      y,\n      flatCoordinates[0],\n      flatCoordinates[1]\n    );\n    if (squaredDistance < minSquaredDistance) {\n      const stride = this.stride;\n      for (let i = 0; i < stride; ++i) {\n        closestPoint[i] = flatCoordinates[i];\n      }\n      closestPoint.length = stride;\n      return squaredDistance;\n    } else {\n      return minSquaredDistance;\n    }\n  }\n\n  /**\n   * Return the coordinate of the point.\n   * @return {import(\"../coordinate.js\").Coordinate} Coordinates.\n   * @api\n   */\n  getCoordinates() {\n    return !this.flatCoordinates ? [] : this.flatCoordinates.slice();\n  }\n\n  /**\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @protected\n   * @return {import(\"../extent.js\").Extent} extent Extent.\n   */\n  computeExtent(extent) {\n    return createOrUpdateFromCoordinate(this.flatCoordinates, extent);\n  }\n\n  /**\n   * Get the type of this geometry.\n   * @return {import(\"./GeometryType.js\").default} Geometry type.\n   * @api\n   */\n  getType() {\n    return GeometryType.POINT;\n  }\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  intersectsExtent(extent) {\n    return containsXY(extent, this.flatCoordinates[0], this.flatCoordinates[1]);\n  }\n\n  /**\n   * @param {!Array<*>} coordinates Coordinates.\n   * @param {import(\"./GeometryLayout.js\").default=} opt_layout Layout.\n   * @api\n   */\n  setCoordinates(coordinates, opt_layout) {\n    this.setLayout(opt_layout, coordinates, 0);\n    if (!this.flatCoordinates) {\n      this.flatCoordinates = [];\n    }\n    this.flatCoordinates.length = deflateCoordinate(\n      this.flatCoordinates,\n      0,\n      coordinates,\n      this.stride\n    );\n    this.changed();\n  }\n}\n\nexport default Point;\n","/**\n * @module ol/geom/flat/contains\n */\nimport {forEachCorner} from '../../extent.js';\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} Contains extent.\n */\nexport function linearRingContainsExtent(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  extent\n) {\n  const outside = forEachCorner(\n    extent,\n    /**\n     * @param {import(\"../../coordinate.js\").Coordinate} coordinate Coordinate.\n     * @return {boolean} Contains (x, y).\n     */\n    function (coordinate) {\n      return !linearRingContainsXY(\n        flatCoordinates,\n        offset,\n        end,\n        stride,\n        coordinate[0],\n        coordinate[1]\n      );\n    }\n  );\n  return !outside;\n}\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {number} x X.\n * @param {number} y Y.\n * @return {boolean} Contains (x, y).\n */\nexport function linearRingContainsXY(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  x,\n  y\n) {\n  // http://geomalgorithms.com/a03-_inclusion.html\n  // Copyright 2000 softSurfer, 2012 Dan Sunday\n  // This code may be freely used and modified for any purpose\n  // providing that this copyright notice is included with it.\n  // SoftSurfer makes no warranty for this code, and cannot be held\n  // liable for any real or imagined damage resulting from its use.\n  // Users of this code must verify correctness for their application.\n  let wn = 0;\n  let x1 = flatCoordinates[end - stride];\n  let y1 = flatCoordinates[end - stride + 1];\n  for (; offset < end; offset += stride) {\n    const x2 = flatCoordinates[offset];\n    const 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    } 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/**\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(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  x,\n  y\n) {\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 (let i = 1, ii = ends.length; i < ii; ++i) {\n    if (\n      linearRingContainsXY(flatCoordinates, ends[i - 1], ends[i], stride, x, y)\n    ) {\n      return false;\n    }\n  }\n  return true;\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 {number} x X.\n * @param {number} y Y.\n * @return {boolean} Contains (x, y).\n */\nexport function linearRingssContainsXY(\n  flatCoordinates,\n  offset,\n  endss,\n  stride,\n  x,\n  y\n) {\n  if (endss.length === 0) {\n    return false;\n  }\n  for (let i = 0, ii = endss.length; i < ii; ++i) {\n    const 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","/**\n * @module ol/geom/flat/interiorpoint\n */\nimport {linearRingsContainsXY} from './contains.js';\nimport {numberSafeCompareFunction} from '../../array.js';\n\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(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  flatCenters,\n  flatCentersOffset,\n  opt_dest\n) {\n  let i, ii, x, x1, x2, y1, y2;\n  const y = flatCenters[flatCentersOffset + 1];\n  /** @type {Array<number>} */\n  const intersections = [];\n  // Calculate intersections with the horizontal line\n  for (let r = 0, rr = ends.length; r < rr; ++r) {\n    const 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  let pointX = NaN;\n  let 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    const 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  } else {\n    return [pointX, y, maxSegmentLength];\n  }\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(\n  flatCoordinates,\n  offset,\n  endss,\n  stride,\n  flatCenters\n) {\n  let interiorPoints = [];\n  for (let i = 0, ii = endss.length; i < ii; ++i) {\n    const ends = endss[i];\n    interiorPoints = getInteriorPointOfArray(\n      flatCoordinates,\n      offset,\n      ends,\n      stride,\n      flatCenters,\n      2 * i,\n      interiorPoints\n    );\n    offset = ends[ends.length - 1];\n  }\n  return interiorPoints;\n}\n","/**\n * @module ol/geom/flat/intersectsextent\n */\nimport {\n  containsExtent,\n  createEmpty,\n  extendFlatCoordinates,\n  intersects,\n  intersectsSegment,\n} from '../../extent.js';\nimport {forEach as forEachSegment} from './segments.js';\nimport {linearRingContainsExtent, linearRingContainsXY} from './contains.js';\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 intersectsLineString(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  extent\n) {\n  const coordinatesExtent = extendFlatCoordinates(\n    createEmpty(),\n    flatCoordinates,\n    offset,\n    end,\n    stride\n  );\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(\n    flatCoordinates,\n    offset,\n    end,\n    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\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(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  extent\n) {\n  for (let i = 0, ii = ends.length; i < ii; ++i) {\n    if (\n      intersectsLineString(flatCoordinates, offset, ends[i], stride, extent)\n    ) {\n      return true;\n    }\n    offset = ends[i];\n  }\n  return false;\n}\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @param {import(\"../../extent.js\").Extent} extent Extent.\n * @return {boolean} True if the geometry and the extent intersect.\n */\nexport function intersectsLinearRing(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  extent\n) {\n  if (intersectsLineString(flatCoordinates, offset, end, stride, extent)) {\n    return true;\n  }\n  if (\n    linearRingContainsXY(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      extent[0],\n      extent[1]\n    )\n  ) {\n    return true;\n  }\n  if (\n    linearRingContainsXY(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      extent[0],\n      extent[3]\n    )\n  ) {\n    return true;\n  }\n  if (\n    linearRingContainsXY(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      extent[2],\n      extent[1]\n    )\n  ) {\n    return true;\n  }\n  if (\n    linearRingContainsXY(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      extent[2],\n      extent[3]\n    )\n  ) {\n    return true;\n  }\n  return false;\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 intersectsLinearRingArray(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  extent\n) {\n  if (!intersectsLinearRing(flatCoordinates, offset, ends[0], stride, extent)) {\n    return false;\n  }\n  if (ends.length === 1) {\n    return true;\n  }\n  for (let i = 1, ii = ends.length; i < ii; ++i) {\n    if (\n      linearRingContainsExtent(\n        flatCoordinates,\n        ends[i - 1],\n        ends[i],\n        stride,\n        extent\n      )\n    ) {\n      if (\n        !intersectsLineString(\n          flatCoordinates,\n          ends[i - 1],\n          ends[i],\n          stride,\n          extent\n        )\n      ) {\n        return false;\n      }\n    }\n  }\n  return true;\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 {import(\"../../extent.js\").Extent} extent Extent.\n * @return {boolean} True if the geometry and the extent intersect.\n */\nexport function intersectsLinearRingMultiArray(\n  flatCoordinates,\n  offset,\n  endss,\n  stride,\n  extent\n) {\n  for (let i = 0, ii = endss.length; i < ii; ++i) {\n    const ends = endss[i];\n    if (\n      intersectsLinearRingArray(flatCoordinates, offset, ends, stride, extent)\n    ) {\n      return true;\n    }\n    offset = ends[ends.length - 1];\n  }\n  return false;\n}\n","/**\n * @module ol/geom/flat/segments\n */\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  const point1 = [flatCoordinates[offset], flatCoordinates[offset + 1]];\n  const point2 = [];\n  let ret;\n  for (; offset + stride < end; offset += stride) {\n    point2[0] = flatCoordinates[offset + stride];\n    point2[1] = flatCoordinates[offset + stride + 1];\n    ret = callback(point1, point2);\n    if (ret) {\n      return ret;\n    }\n    point1[0] = point2[0];\n    point1[1] = point2[1];\n  }\n  return false;\n}\n","/**\n * @module ol/geom/flat/reverse\n */\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n */\nexport function coordinates(flatCoordinates, offset, end, stride) {\n  while (offset < end - stride) {\n    for (let i = 0; i < stride; ++i) {\n      const 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","/**\n * @module ol/geom/flat/orient\n */\nimport {coordinates as reverseCoordinates} from './reverse.js';\n\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  // http://tinyurl.com/clockwise-method\n  // https://github.com/OSGeo/gdal/blob/trunk/gdal/ogr/ogrlinearring.cpp\n  let edge = 0;\n  let x1 = flatCoordinates[end - stride];\n  let y1 = flatCoordinates[end - stride + 1];\n  for (; offset < end; offset += stride) {\n    const x2 = flatCoordinates[offset];\n    const 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/**\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(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  opt_right\n) {\n  const right = opt_right !== undefined ? opt_right : false;\n  for (let i = 0, ii = ends.length; i < ii; ++i) {\n    const end = ends[i];\n    const isClockwise = linearRingIsClockwise(\n      flatCoordinates,\n      offset,\n      end,\n      stride\n    );\n    if (i === 0) {\n      if ((right && isClockwise) || (!right && !isClockwise)) {\n        return false;\n      }\n    } else {\n      if ((right && !isClockwise) || (!right && isClockwise)) {\n        return false;\n      }\n    }\n    offset = end;\n  }\n  return true;\n}\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(\n  flatCoordinates,\n  offset,\n  endss,\n  stride,\n  opt_right\n) {\n  for (let i = 0, ii = endss.length; i < ii; ++i) {\n    const ends = endss[i];\n    if (\n      !linearRingsAreOriented(flatCoordinates, offset, ends, stride, opt_right)\n    ) {\n      return false;\n    }\n    if (ends.length) {\n      offset = ends[ends.length - 1];\n    }\n  }\n  return true;\n}\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(\n  flatCoordinates,\n  offset,\n  ends,\n  stride,\n  opt_right\n) {\n  const right = opt_right !== undefined ? opt_right : false;\n  for (let i = 0, ii = ends.length; i < ii; ++i) {\n    const end = ends[i];\n    const isClockwise = linearRingIsClockwise(\n      flatCoordinates,\n      offset,\n      end,\n      stride\n    );\n    const reverse =\n      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/**\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(\n  flatCoordinates,\n  offset,\n  endss,\n  stride,\n  opt_right\n) {\n  for (let i = 0, ii = endss.length; i < ii; ++i) {\n    offset = orientLinearRings(\n      flatCoordinates,\n      offset,\n      endss[i],\n      stride,\n      opt_right\n    );\n  }\n  return offset;\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/**\n * @classdesc\n * Polygon geometry.\n *\n * @api\n */\nclass Polygon extends SimpleGeometry {\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  constructor(coordinates, opt_layout, opt_ends) {\n    super();\n\n    /**\n     * @type {Array<number>}\n     * @private\n     */\n    this.ends_ = [];\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.flatInteriorPointRevision_ = -1;\n\n    /**\n     * @private\n     * @type {import(\"../coordinate.js\").Coordinate}\n     */\n    this.flatInteriorPoint_ = null;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.maxDelta_ = -1;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.maxDeltaRevision_ = -1;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.orientedRevision_ = -1;\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.orientedFlatCoordinates_ = null;\n\n    if (opt_layout !== undefined && opt_ends) {\n      this.setFlatCoordinates(\n        opt_layout,\n        /** @type {Array<number>} */ (coordinates)\n      );\n      this.ends_ = opt_ends;\n    } else {\n      this.setCoordinates(\n        /** @type {Array<Array<import(\"../coordinate.js\").Coordinate>>} */ (coordinates),\n        opt_layout\n      );\n    }\n  }\n\n  /**\n   * Append the passed linear ring to this polygon.\n   * @param {LinearRing} linearRing Linear ring.\n   * @api\n   */\n  appendLinearRing(linearRing) {\n    if (!this.flatCoordinates) {\n      this.flatCoordinates = linearRing.getFlatCoordinates().slice();\n    } else {\n      extend(this.flatCoordinates, linearRing.getFlatCoordinates());\n    }\n    this.ends_.push(this.flatCoordinates.length);\n    this.changed();\n  }\n\n  /**\n   * Make a complete copy of the geometry.\n   * @return {!Polygon} Clone.\n   * @api\n   */\n  clone() {\n    const polygon = new Polygon(\n      this.flatCoordinates.slice(),\n      this.layout,\n      this.ends_.slice()\n    );\n    polygon.applyProperties(this);\n    return polygon;\n  }\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  closestPointXY(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(\n        arrayMaxSquaredDelta(\n          this.flatCoordinates,\n          0,\n          this.ends_,\n          this.stride,\n          0\n        )\n      );\n      this.maxDeltaRevision_ = this.getRevision();\n    }\n    return assignClosestArrayPoint(\n      this.flatCoordinates,\n      0,\n      this.ends_,\n      this.stride,\n      this.maxDelta_,\n      true,\n      x,\n      y,\n      closestPoint,\n      minSquaredDistance\n    );\n  }\n\n  /**\n   * @param {number} x X.\n   * @param {number} y Y.\n   * @return {boolean} Contains (x, y).\n   */\n  containsXY(x, y) {\n    return linearRingsContainsXY(\n      this.getOrientedFlatCoordinates(),\n      0,\n      this.ends_,\n      this.stride,\n      x,\n      y\n    );\n  }\n\n  /**\n   * Return the area of the polygon on projected plane.\n   * @return {number} Area (on projected plane).\n   * @api\n   */\n  getArea() {\n    return linearRingsArea(\n      this.getOrientedFlatCoordinates(),\n      0,\n      this.ends_,\n      this.stride\n    );\n  }\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  getCoordinates(opt_right) {\n    let flatCoordinates;\n    if (opt_right !== undefined) {\n      flatCoordinates = this.getOrientedFlatCoordinates().slice();\n      orientLinearRings(flatCoordinates, 0, this.ends_, this.stride, opt_right);\n    } else {\n      flatCoordinates = this.flatCoordinates;\n    }\n\n    return inflateCoordinatesArray(flatCoordinates, 0, this.ends_, this.stride);\n  }\n\n  /**\n   * @return {Array<number>} Ends.\n   */\n  getEnds() {\n    return this.ends_;\n  }\n\n  /**\n   * @return {Array<number>} Interior point.\n   */\n  getFlatInteriorPoint() {\n    if (this.flatInteriorPointRevision_ != this.getRevision()) {\n      const flatCenter = getCenter(this.getExtent());\n      this.flatInteriorPoint_ = getInteriorPointOfArray(\n        this.getOrientedFlatCoordinates(),\n        0,\n        this.ends_,\n        this.stride,\n        flatCenter,\n        0\n      );\n      this.flatInteriorPointRevision_ = this.getRevision();\n    }\n    return this.flatInteriorPoint_;\n  }\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  getInteriorPoint() {\n    return new Point(this.getFlatInteriorPoint(), GeometryLayout.XYM);\n  }\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  getLinearRingCount() {\n    return this.ends_.length;\n  }\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  getLinearRing(index) {\n    if (index < 0 || this.ends_.length <= index) {\n      return null;\n    }\n    return new LinearRing(\n      this.flatCoordinates.slice(\n        index === 0 ? 0 : this.ends_[index - 1],\n        this.ends_[index]\n      ),\n      this.layout\n    );\n  }\n\n  /**\n   * Return the linear rings of the polygon.\n   * @return {Array<LinearRing>} Linear rings.\n   * @api\n   */\n  getLinearRings() {\n    const layout = this.layout;\n    const flatCoordinates = this.flatCoordinates;\n    const ends = this.ends_;\n    const linearRings = [];\n    let offset = 0;\n    for (let i = 0, ii = ends.length; i < ii; ++i) {\n      const end = ends[i];\n      const linearRing = new LinearRing(\n        flatCoordinates.slice(offset, end),\n        layout\n      );\n      linearRings.push(linearRing);\n      offset = end;\n    }\n    return linearRings;\n  }\n\n  /**\n   * @return {Array<number>} Oriented flat coordinates.\n   */\n  getOrientedFlatCoordinates() {\n    if (this.orientedRevision_ != this.getRevision()) {\n      const flatCoordinates = this.flatCoordinates;\n      if (linearRingsAreOriented(flatCoordinates, 0, this.ends_, this.stride)) {\n        this.orientedFlatCoordinates_ = flatCoordinates;\n      } else {\n        this.orientedFlatCoordinates_ = flatCoordinates.slice();\n        this.orientedFlatCoordinates_.length = orientLinearRings(\n          this.orientedFlatCoordinates_,\n          0,\n          this.ends_,\n          this.stride\n        );\n      }\n      this.orientedRevision_ = this.getRevision();\n    }\n    return this.orientedFlatCoordinates_;\n  }\n\n  /**\n   * @param {number} squaredTolerance Squared tolerance.\n   * @return {Polygon} Simplified Polygon.\n   * @protected\n   */\n  getSimplifiedGeometryInternal(squaredTolerance) {\n    const simplifiedFlatCoordinates = [];\n    const simplifiedEnds = [];\n    simplifiedFlatCoordinates.length = quantizeArray(\n      this.flatCoordinates,\n      0,\n      this.ends_,\n      this.stride,\n      Math.sqrt(squaredTolerance),\n      simplifiedFlatCoordinates,\n      0,\n      simplifiedEnds\n    );\n    return new Polygon(\n      simplifiedFlatCoordinates,\n      GeometryLayout.XY,\n      simplifiedEnds\n    );\n  }\n\n  /**\n   * Get the type of this geometry.\n   * @return {import(\"./GeometryType.js\").default} Geometry type.\n   * @api\n   */\n  getType() {\n    return GeometryType.POLYGON;\n  }\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  intersectsExtent(extent) {\n    return intersectsLinearRingArray(\n      this.getOrientedFlatCoordinates(),\n      0,\n      this.ends_,\n      this.stride,\n      extent\n    );\n  }\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  setCoordinates(coordinates, opt_layout) {\n    this.setLayout(opt_layout, coordinates, 2);\n    if (!this.flatCoordinates) {\n      this.flatCoordinates = [];\n    }\n    const ends = deflateCoordinatesArray(\n      this.flatCoordinates,\n      0,\n      coordinates,\n      this.stride,\n      this.ends_\n    );\n    this.flatCoordinates.length = ends.length === 0 ? 0 : ends[ends.length - 1];\n    this.changed();\n  }\n}\n\nexport default Polygon;\n\n/**\n * Create an approximation of a circle on the surface of a sphere.\n * @param {import(\"../coordinate.js\").Coordinate} center Center (`[lon, lat]` in degrees).\n * @param {number} radius The great-circle distance from the center to\n *     the polygon vertices.\n * @param {number=} opt_n Optional number of vertices for the resulting\n *     polygon. Default is `32`.\n * @param {number=} opt_sphereRadius Optional radius for the sphere (defaults to\n *     the Earth's mean radius using the WGS84 ellipsoid).\n * @return {Polygon} The \"circular\" polygon.\n * @api\n */\nexport function circular(center, radius, opt_n, opt_sphereRadius) {\n  const n = opt_n ? opt_n : 32;\n  /** @type {Array<number>} */\n  const flatCoordinates = [];\n  for (let i = 0; i < n; ++i) {\n    extend(\n      flatCoordinates,\n      sphereOffset(center, radius, (2 * Math.PI * i) / n, opt_sphereRadius)\n    );\n  }\n  flatCoordinates.push(flatCoordinates[0], flatCoordinates[1]);\n  return new Polygon(flatCoordinates, GeometryLayout.XY, [\n    flatCoordinates.length,\n  ]);\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  const minX = extent[0];\n  const minY = extent[1];\n  const maxX = extent[2];\n  const maxY = extent[3];\n  const 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/**\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  const sides = opt_sides ? opt_sides : 32;\n  const stride = circle.getStride();\n  const layout = circle.getLayout();\n  const center = circle.getCenter();\n  const arrayLength = stride * (sides + 1);\n  const flatCoordinates = new Array(arrayLength);\n  for (let i = 0; i < arrayLength; i += stride) {\n    flatCoordinates[i] = 0;\n    flatCoordinates[i + 1] = 0;\n    for (let j = 2; j < stride; j++) {\n      flatCoordinates[i + j] = center[j];\n    }\n  }\n  const ends = [flatCoordinates.length];\n  const polygon = new Polygon(flatCoordinates, layout, ends);\n  makeRegular(polygon, center, circle.getRadius(), opt_angle);\n  return polygon;\n}\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  const flatCoordinates = polygon.getFlatCoordinates();\n  const stride = polygon.getStride();\n  const sides = flatCoordinates.length / stride - 1;\n  const startAngle = opt_angle ? opt_angle : 0;\n  for (let i = 0; i <= sides; ++i) {\n    const offset = i * stride;\n    const 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","/**\n * @module ol/View\n */\nimport BaseObject from './Object.js';\nimport GeometryType from './geom/GeometryType.js';\nimport Units from './proj/Units.js';\nimport ViewHint from './ViewHint.js';\nimport ViewProperty from './ViewProperty.js';\nimport {DEFAULT_TILE_SIZE} from './tilegrid/common.js';\nimport {\n  METERS_PER_UNIT,\n  createProjection,\n  fromUserCoordinate,\n  fromUserExtent,\n  getUserProjection,\n  toUserCoordinate,\n  toUserExtent,\n} from './proj.js';\nimport {VOID} from './functions.js';\nimport {\n  add as addCoordinate,\n  equals as coordinatesEqual,\n  rotate as rotateCoordinate,\n} from './coordinate.js';\nimport {assert} from './asserts.js';\nimport {assign} from './obj.js';\nimport {none as centerNone, createExtent} from './centerconstraint.js';\nimport {clamp, modulo} from './math.js';\nimport {createMinMaxResolution} from './resolutionconstraint.js';\nimport {\n  createSnapToN,\n  createSnapToZero,\n  disable,\n  none as rotationNone,\n} from './rotationconstraint.js';\nimport {\n  createSnapToPower,\n  createSnapToResolutions,\n} from './resolutionconstraint.js';\nimport {easeOut} from './easing.js';\nimport {equals} from './coordinate.js';\nimport {\n  getCenter,\n  getForViewAndSize,\n  getHeight,\n  getWidth,\n  isEmpty,\n} from './extent.js';\nimport {inAndOut} from './easing.js';\nimport {linearFindNearest} from './array.js';\nimport {fromExtent as polygonFromExtent} from './geom/Polygon.js';\n\n/**\n * An animation configuration\n *\n * @typedef {Object} Animation\n * @property {import(\"./coordinate.js\").Coordinate} [sourceCenter]\n * @property {import(\"./coordinate.js\").Coordinate} [targetCenter]\n * @property {number} [sourceResolution]\n * @property {number} [targetResolution]\n * @property {number} [sourceRotation]\n * @property {number} [targetRotation]\n * @property {import(\"./coordinate.js\").Coordinate} [anchor]\n * @property {number} start\n * @property {number} duration\n * @property {boolean} complete\n * @property {function(number):number} easing\n * @property {function(boolean):void} callback\n */\n\n/**\n * @typedef {Object} Constraints\n * @property {import(\"./centerconstraint.js\").Type} center\n * @property {import(\"./resolutionconstraint.js\").Type} resolution\n * @property {import(\"./rotationconstraint.js\").Type} rotation\n */\n\n/**\n * @typedef {Object} FitOptions\n * @property {import(\"./size.js\").Size} [size] The size in pixels of the box to fit\n * the extent into. Default is the current size of the first map in the DOM that\n * uses this view, or `[100, 100]` if no such map is found.\n * @property {!Array<number>} [padding=[0, 0, 0, 0]] Padding (in pixels) to be\n * cleared inside the view. Values in the array are top, right, bottom and left\n * padding.\n * @property {boolean} [nearest=false] If the view `constrainResolution` option is `true`,\n * get the nearest extent instead of the closest that actually fits the view.\n * @property {number} [minResolution=0] Minimum resolution that we zoom to.\n * @property {number} [maxZoom] Maximum zoom level that we zoom to. If\n * `minResolution` is given, this property is ignored.\n * @property {number} [duration] The duration of the animation in milliseconds.\n * By default, there is no animation to the target extent.\n * @property {function(number):number} [easing] The easing function used during\n * the animation (defaults to {@link module:ol/easing~inAndOut}).\n * The function will be called for each frame with a number representing a\n * fraction of the animation's duration.  The function should return a number\n * between 0 and 1 representing the progress toward the destination state.\n * @property {function(boolean):void} [callback] Function called when the view is in\n * its final position. The callback will be called with `true` if the animation\n * series completed on its own or `false` if it was cancelled.\n */\n\n/**\n * @typedef {Object} ViewOptions\n * @property {import(\"./coordinate.js\").Coordinate} [center] The initial center for\n * the view. If a user projection is not set, the coordinate system for the center is\n * specified with the `projection` option. Layer sources will not be fetched if this\n * is not set, but the center can be set later with {@link #setCenter}.\n * @property {boolean|number} [constrainRotation=true] Rotation constraint.\n * `false` means no constraint. `true` means no constraint, but snap to zero\n * near zero. A number constrains the rotation to that number of values. For\n * example, `4` will constrain the rotation to 0, 90, 180, and 270 degrees.\n * @property {boolean} [enableRotation=true] Enable rotation.\n * If `false`, a rotation constraint that always sets the rotation to zero is\n * used. The `constrainRotation` option has no effect if `enableRotation` is\n * `false`.\n * @property {import(\"./extent.js\").Extent} [extent] The extent that constrains the\n * view, in other words, nothing outside of this extent can be visible on the map.\n * @property {boolean} [constrainOnlyCenter=false] If true, the extent\n * constraint will only apply to the view center and not the whole extent.\n * @property {boolean} [smoothExtentConstraint=true] If true, the extent\n * constraint will be applied smoothly, i.e. allow the view to go slightly outside\n * of the given `extent`.\n * @property {number} [maxResolution] The maximum resolution used to determine\n * the resolution constraint. It is used together with `minResolution` (or\n * `maxZoom`) and `zoomFactor`. If unspecified it is calculated in such a way\n * that the projection's validity extent fits in a 256x256 px tile. If the\n * projection is Spherical Mercator (the default) then `maxResolution` defaults\n * to `40075016.68557849 / 256 = 156543.03392804097`.\n * @property {number} [minResolution] The minimum resolution used to determine\n * the resolution constraint.  It is used together with `maxResolution` (or\n * `minZoom`) and `zoomFactor`.  If unspecified it is calculated assuming 29\n * zoom levels (with a factor of 2). If the projection is Spherical Mercator\n * (the default) then `minResolution` defaults to\n * `40075016.68557849 / 256 / Math.pow(2, 28) = 0.0005831682455839253`.\n * @property {number} [maxZoom=28] The maximum zoom level used to determine the\n * resolution constraint. It is used together with `minZoom` (or\n * `maxResolution`) and `zoomFactor`.  Note that if `minResolution` is also\n * provided, it is given precedence over `maxZoom`.\n * @property {number} [minZoom=0] The minimum zoom level used to determine the\n * resolution constraint. It is used together with `maxZoom` (or\n * `minResolution`) and `zoomFactor`.  Note that if `maxResolution` is also\n * provided, it is given precedence over `minZoom`.\n * @property {boolean} [multiWorld=false] If `false` the view is constrained so\n * only one world is visible, and you cannot pan off the edge.  If `true` the map\n * may show multiple worlds at low zoom levels.  Only used if the `projection` is\n * global.  Note that if `extent` is also provided it is given precedence.\n * @property {boolean} [constrainResolution=false] If true, the view will always\n * animate to the closest zoom level after an interaction; false means\n * intermediary zoom levels are allowed.\n * @property {boolean} [smoothResolutionConstraint=true] If true, the resolution\n * min/max values will be applied smoothly, i. e. allow the view to exceed slightly\n * the given resolution or zoom bounds.\n * @property {boolean} [showFullExtent=false] Allow the view to be zoomed out to\n * show the full configured extent. By default, when a view is configured with an\n * extent, users will not be able to zoom out so the viewport exceeds the extent in\n * either dimension. This means the full extent may not be visible if the viewport\n * is taller or wider than the aspect ratio of the configured extent. If\n * showFullExtent is true, the user will be able to zoom out so that the viewport\n * exceeds the height or width of the configured extent, but not both, allowing the\n * full extent to be shown.\n * @property {import(\"./proj.js\").ProjectionLike} [projection='EPSG:3857'] The\n * projection. The default is Spherical Mercator.\n * @property {number} [resolution] The initial resolution for the view. The\n * units are `projection` units per pixel (e.g. meters per pixel). An\n * alternative to setting this is to set `zoom`. Layer sources will not be\n * fetched if neither this nor `zoom` are defined, but they can be set later\n * with {@link #setZoom} or {@link #setResolution}.\n * @property {Array<number>} [resolutions] Resolutions to determine the\n * resolution constraint. If set the `maxResolution`, `minResolution`,\n * `minZoom`, `maxZoom`, and `zoomFactor` options are ignored.\n * @property {number} [rotation=0] The initial rotation for the view in radians\n * (positive rotation clockwise, 0 means North).\n * @property {number} [zoom] Only used if `resolution` is not defined. Zoom\n * level used to calculate the initial resolution for the view.\n * @property {number} [zoomFactor=2] The zoom factor used to compute the\n * corresponding resolution.\n * @property {!Array<number>} [padding=[0, 0, 0, 0]] Padding (in css pixels).\n * If the map viewport is partially covered with other content (overlays) along\n * its edges, this setting allows to shift the center of the viewport away from\n * that content. The order of the values is top, right, bottom, left.\n */\n\n/**\n * @typedef {Object} AnimationOptions\n * @property {import(\"./coordinate.js\").Coordinate} [center] The center of the view at the end of\n * the animation.\n * @property {number} [zoom] The zoom level of the view at the end of the\n * animation. This takes precedence over `resolution`.\n * @property {number} [resolution] The resolution of the view at the end\n * of the animation.  If `zoom` is also provided, this option will be ignored.\n * @property {number} [rotation] The rotation of the view at the end of\n * the animation.\n * @property {import(\"./coordinate.js\").Coordinate} [anchor] Optional anchor to remain fixed\n * during a rotation or resolution animation.\n * @property {number} [duration=1000] The duration of the animation in milliseconds.\n * @property {function(number):number} [easing] The easing function used\n * during the animation (defaults to {@link module:ol/easing~inAndOut}).\n * The function will be called for each frame with a number representing a\n * fraction of the animation's duration.  The function should return a number\n * between 0 and 1 representing the progress toward the destination state.\n */\n\n/**\n * @typedef {Object} State\n * @property {import(\"./coordinate.js\").Coordinate} center\n * @property {import(\"./proj/Projection.js\").default} projection\n * @property {number} resolution\n * @property {number} rotation\n * @property {number} zoom\n */\n\n/**\n * Default min zoom level for the map view.\n * @type {number}\n */\nconst DEFAULT_MIN_ZOOM = 0;\n\n/**\n * @classdesc\n * A View object represents a simple 2D view of the map.\n *\n * This is the object to act upon to change the center, resolution,\n * and rotation of the map.\n *\n * A View has a `projection`. The projection determines the\n * coordinate system of the center, and its units determine the units of the\n * resolution (projection units per pixel). The default projection is\n * Spherical Mercator (EPSG:3857).\n *\n * ### The view states\n *\n * A View is determined by three states: `center`, `resolution`,\n * and `rotation`. Each state has a corresponding getter and setter, e.g.\n * `getCenter` and `setCenter` for the `center` state.\n *\n * The `zoom` state is actually not saved on the view: all computations\n * internally use the `resolution` state. Still, the `setZoom` and `getZoom`\n * methods are available, as well as `getResolutionForZoom` and\n * `getZoomForResolution` to switch from one system to the other.\n *\n * ### The constraints\n *\n * `setCenter`, `setResolution` and `setRotation` can be used to change the\n * states of the view, but any constraint defined in the constructor will\n * be applied along the way.\n *\n * A View object can have a *resolution constraint*, a *rotation constraint*\n * and a *center constraint*.\n *\n * The *resolution constraint* typically restricts min/max values and\n * snaps to specific resolutions. It is determined by the following\n * options: `resolutions`, `maxResolution`, `maxZoom` and `zoomFactor`.\n * If `resolutions` is set, the other three options are ignored. See\n * documentation for each option for more information. By default, the view\n * only has a min/max restriction and allow intermediary zoom levels when\n * pinch-zooming for example.\n *\n * The *rotation constraint* snaps to specific angles. It is determined\n * by the following options: `enableRotation` and `constrainRotation`.\n * By default rotation is allowed and its value is snapped to zero when approaching the\n * horizontal.\n *\n * The *center constraint* is determined by the `extent` option. By\n * default the view center is not constrained at all.\n *\n * ### Changing the view state\n *\n * It is important to note that `setZoom`, `setResolution`, `setCenter` and\n * `setRotation` are subject to the above mentioned constraints. As such, it\n * may sometimes not be possible to know in advance the resulting state of the\n * View. For example, calling `setResolution(10)` does not guarantee that\n * `getResolution()` will return `10`.\n *\n * A consequence of this is that, when applying a delta on the view state, one\n * should use `adjustCenter`, `adjustRotation`, `adjustZoom` and `adjustResolution`\n * rather than the corresponding setters. This will let view do its internal\n * computations. Besides, the `adjust*` methods also take an `opt_anchor`\n * argument which allows specifying an origin for the transformation.\n *\n * ### Interacting with the view\n *\n * View constraints are usually only applied when the view is *at rest*, meaning that\n * no interaction or animation is ongoing. As such, if the user puts the view in a\n * state that is not equivalent to a constrained one (e.g. rotating the view when\n * the snap angle is 0), an animation will be triggered at the interaction end to\n * put back the view to a stable state;\n *\n * @api\n */\nclass View extends BaseObject {\n  /**\n   * @param {ViewOptions=} opt_options View options.\n   */\n  constructor(opt_options) {\n    super();\n\n    const options = assign({}, opt_options);\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.hints_ = [0, 0];\n\n    /**\n     * @private\n     * @type {Array<Array<Animation>>}\n     */\n    this.animations_ = [];\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.updateAnimationKey_;\n\n    /**\n     * @private\n     * @const\n     * @type {import(\"./proj/Projection.js\").default}\n     */\n    this.projection_ = createProjection(options.projection, 'EPSG:3857');\n\n    /**\n     * @private\n     * @type {import(\"./size.js\").Size}\n     */\n    this.viewportSize_ = [100, 100];\n\n    /**\n     * @private\n     * @type {import(\"./coordinate.js\").Coordinate|undefined}\n     */\n    this.targetCenter_ = null;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.targetResolution_;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.targetRotation_;\n\n    /**\n     * @private\n     * @type {import(\"./coordinate.js\").Coordinate|undefined}\n     */\n    this.cancelAnchor_ = undefined;\n\n    if (options.center) {\n      options.center = fromUserCoordinate(options.center, this.projection_);\n    }\n    if (options.extent) {\n      options.extent = fromUserExtent(options.extent, this.projection_);\n    }\n\n    this.applyOptions_(options);\n  }\n\n  /**\n   * Set up the view with the given options.\n   * @param {ViewOptions} options View options.\n   */\n  applyOptions_(options) {\n    /**\n     * @type {Object<string, *>}\n     */\n    const properties = {};\n\n    const resolutionConstraintInfo = createResolutionConstraint(options);\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.maxResolution_ = resolutionConstraintInfo.maxResolution;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.minResolution_ = resolutionConstraintInfo.minResolution;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.zoomFactor_ = resolutionConstraintInfo.zoomFactor;\n\n    /**\n     * @private\n     * @type {Array<number>|undefined}\n     */\n    this.resolutions_ = options.resolutions;\n\n    /**\n     * Padding (in css pixels).\n     * If the map viewport is partially covered with other content (overlays) along\n     * its edges, this setting allows to shift the center of the viewport away from that\n     * content. The order of the values in the array is top, right, bottom, left.\n     * The default is no padding, which is equivalent to `[0, 0, 0, 0]`.\n     * @type {Array<number>|undefined}\n     * @api\n     */\n    this.padding = options.padding;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.minZoom_ = resolutionConstraintInfo.minZoom;\n\n    const centerConstraint = createCenterConstraint(options);\n    const resolutionConstraint = resolutionConstraintInfo.constraint;\n    const rotationConstraint = createRotationConstraint(options);\n\n    /**\n     * @private\n     * @type {Constraints}\n     */\n    this.constraints_ = {\n      center: centerConstraint,\n      resolution: resolutionConstraint,\n      rotation: rotationConstraint,\n    };\n\n    this.setRotation(options.rotation !== undefined ? options.rotation : 0);\n    this.setCenterInternal(\n      options.center !== undefined ? options.center : null\n    );\n    if (options.resolution !== undefined) {\n      this.setResolution(options.resolution);\n    } else if (options.zoom !== undefined) {\n      this.setZoom(options.zoom);\n    }\n\n    this.setProperties(properties);\n\n    /**\n     * @private\n     * @type {ViewOptions}\n     */\n    this.options_ = options;\n  }\n\n  /**\n   * Get an updated version of the view options used to construct the view.  The\n   * current resolution (or zoom), center, and rotation are applied to any stored\n   * options.  The provided options can be used to apply new min/max zoom or\n   * resolution limits.\n   * @param {ViewOptions} newOptions New options to be applied.\n   * @return {ViewOptions} New options updated with the current view state.\n   */\n  getUpdatedOptions_(newOptions) {\n    const options = assign({}, this.options_);\n\n    // preserve resolution (or zoom)\n    if (options.resolution !== undefined) {\n      options.resolution = this.getResolution();\n    } else {\n      options.zoom = this.getZoom();\n    }\n\n    // preserve center\n    options.center = this.getCenterInternal();\n\n    // preserve rotation\n    options.rotation = this.getRotation();\n\n    return assign({}, options, newOptions);\n  }\n\n  /**\n   * Animate the view.  The view's center, zoom (or resolution), and rotation\n   * can be animated for smooth transitions between view states.  For example,\n   * to animate the view to a new zoom level:\n   *\n   *     view.animate({zoom: view.getZoom() + 1});\n   *\n   * By default, the animation lasts one second and uses in-and-out easing.  You\n   * can customize this behavior by including `duration` (in milliseconds) and\n   * `easing` options (see {@link module:ol/easing}).\n   *\n   * To chain together multiple animations, call the method with multiple\n   * animation objects.  For example, to first zoom and then pan:\n   *\n   *     view.animate({zoom: 10}, {center: [0, 0]});\n   *\n   * If you provide a function as the last argument to the animate method, it\n   * will get called at the end of an animation series.  The callback will be\n   * called with `true` if the animation series completed on its own or `false`\n   * if it was cancelled.\n   *\n   * Animations are cancelled by user interactions (e.g. dragging the map) or by\n   * calling `view.setCenter()`, `view.setResolution()`, or `view.setRotation()`\n   * (or another method that calls one of these).\n   *\n   * @param {...(AnimationOptions|function(boolean): void)} var_args Animation\n   *     options.  Multiple animations can be run in series by passing multiple\n   *     options objects.  To run multiple animations in parallel, call the method\n   *     multiple times.  An optional callback can be provided as a final\n   *     argument.  The callback will be called with a boolean indicating whether\n   *     the animation completed without being cancelled.\n   * @api\n   */\n  animate(var_args) {\n    if (this.isDef() && !this.getAnimating()) {\n      this.resolveConstraints(0);\n    }\n    const args = new Array(arguments.length);\n    for (let i = 0; i < args.length; ++i) {\n      let options = arguments[i];\n      if (options.center) {\n        options = assign({}, options);\n        options.center = fromUserCoordinate(\n          options.center,\n          this.getProjection()\n        );\n      }\n      if (options.anchor) {\n        options = assign({}, options);\n        options.anchor = fromUserCoordinate(\n          options.anchor,\n          this.getProjection()\n        );\n      }\n      args[i] = options;\n    }\n    this.animateInternal.apply(this, args);\n  }\n\n  /**\n   * @param {...(AnimationOptions|function(boolean): void)} var_args Animation options.\n   */\n  animateInternal(var_args) {\n    let animationCount = arguments.length;\n    let callback;\n    if (\n      animationCount > 1 &&\n      typeof arguments[animationCount - 1] === 'function'\n    ) {\n      callback = arguments[animationCount - 1];\n      --animationCount;\n    }\n    if (!this.isDef()) {\n      // if view properties are not yet set, shortcut to the final state\n      const state = arguments[animationCount - 1];\n      if (state.center) {\n        this.setCenterInternal(state.center);\n      }\n      if (state.zoom !== undefined) {\n        this.setZoom(state.zoom);\n      }\n      if (state.rotation !== undefined) {\n        this.setRotation(state.rotation);\n      }\n      if (callback) {\n        animationCallback(callback, true);\n      }\n      return;\n    }\n    let start = Date.now();\n    let center = this.targetCenter_.slice();\n    let resolution = this.targetResolution_;\n    let rotation = this.targetRotation_;\n    const series = [];\n    for (let i = 0; i < animationCount; ++i) {\n      const options = /** @type {AnimationOptions} */ (arguments[i]);\n\n      const animation = {\n        start: start,\n        complete: false,\n        anchor: options.anchor,\n        duration: options.duration !== undefined ? options.duration : 1000,\n        easing: options.easing || inAndOut,\n        callback: callback,\n      };\n\n      if (options.center) {\n        animation.sourceCenter = center;\n        animation.targetCenter = options.center.slice();\n        center = animation.targetCenter;\n      }\n\n      if (options.zoom !== undefined) {\n        animation.sourceResolution = resolution;\n        animation.targetResolution = this.getResolutionForZoom(options.zoom);\n        resolution = animation.targetResolution;\n      } else if (options.resolution) {\n        animation.sourceResolution = resolution;\n        animation.targetResolution = options.resolution;\n        resolution = animation.targetResolution;\n      }\n\n      if (options.rotation !== undefined) {\n        animation.sourceRotation = rotation;\n        const delta =\n          modulo(options.rotation - rotation + Math.PI, 2 * Math.PI) - Math.PI;\n        animation.targetRotation = rotation + delta;\n        rotation = animation.targetRotation;\n      }\n\n      // check if animation is a no-op\n      if (isNoopAnimation(animation)) {\n        animation.complete = true;\n        // we still push it onto the series for callback handling\n      } else {\n        start += animation.duration;\n      }\n      series.push(animation);\n    }\n    this.animations_.push(series);\n    this.setHint(ViewHint.ANIMATING, 1);\n    this.updateAnimations_();\n  }\n\n  /**\n   * Determine if the view is being animated.\n   * @return {boolean} The view is being animated.\n   * @api\n   */\n  getAnimating() {\n    return this.hints_[ViewHint.ANIMATING] > 0;\n  }\n\n  /**\n   * Determine if the user is interacting with the view, such as panning or zooming.\n   * @return {boolean} The view is being interacted with.\n   * @api\n   */\n  getInteracting() {\n    return this.hints_[ViewHint.INTERACTING] > 0;\n  }\n\n  /**\n   * Cancel any ongoing animations.\n   * @api\n   */\n  cancelAnimations() {\n    this.setHint(ViewHint.ANIMATING, -this.hints_[ViewHint.ANIMATING]);\n    let anchor;\n    for (let i = 0, ii = this.animations_.length; i < ii; ++i) {\n      const series = this.animations_[i];\n      if (series[0].callback) {\n        animationCallback(series[0].callback, false);\n      }\n      if (!anchor) {\n        for (let j = 0, jj = series.length; j < jj; ++j) {\n          const animation = series[j];\n          if (!animation.complete) {\n            anchor = animation.anchor;\n            break;\n          }\n        }\n      }\n    }\n    this.animations_.length = 0;\n    this.cancelAnchor_ = anchor;\n  }\n\n  /**\n   * Update all animations.\n   */\n  updateAnimations_() {\n    if (this.updateAnimationKey_ !== undefined) {\n      cancelAnimationFrame(this.updateAnimationKey_);\n      this.updateAnimationKey_ = undefined;\n    }\n    if (!this.getAnimating()) {\n      return;\n    }\n    const now = Date.now();\n    let more = false;\n    for (let i = this.animations_.length - 1; i >= 0; --i) {\n      const series = this.animations_[i];\n      let seriesComplete = true;\n      for (let j = 0, jj = series.length; j < jj; ++j) {\n        const animation = series[j];\n        if (animation.complete) {\n          continue;\n        }\n        const elapsed = now - animation.start;\n        let fraction =\n          animation.duration > 0 ? elapsed / animation.duration : 1;\n        if (fraction >= 1) {\n          animation.complete = true;\n          fraction = 1;\n        } else {\n          seriesComplete = false;\n        }\n        const progress = animation.easing(fraction);\n        if (animation.sourceCenter) {\n          const x0 = animation.sourceCenter[0];\n          const y0 = animation.sourceCenter[1];\n          const x1 = animation.targetCenter[0];\n          const y1 = animation.targetCenter[1];\n          const x = x0 + progress * (x1 - x0);\n          const y = y0 + progress * (y1 - y0);\n          this.targetCenter_ = [x, y];\n        }\n        if (animation.sourceResolution && animation.targetResolution) {\n          const resolution =\n            progress === 1\n              ? animation.targetResolution\n              : animation.sourceResolution +\n                progress *\n                  (animation.targetResolution - animation.sourceResolution);\n          if (animation.anchor) {\n            const size = this.getViewportSize_(this.getRotation());\n            const constrainedResolution = this.constraints_.resolution(\n              resolution,\n              0,\n              size,\n              true\n            );\n            this.targetCenter_ = this.calculateCenterZoom(\n              constrainedResolution,\n              animation.anchor\n            );\n          }\n          this.targetResolution_ = resolution;\n          this.applyTargetState_(true);\n        }\n        if (\n          animation.sourceRotation !== undefined &&\n          animation.targetRotation !== undefined\n        ) {\n          const rotation =\n            progress === 1\n              ? modulo(animation.targetRotation + Math.PI, 2 * Math.PI) -\n                Math.PI\n              : animation.sourceRotation +\n                progress *\n                  (animation.targetRotation - animation.sourceRotation);\n          if (animation.anchor) {\n            const constrainedRotation = this.constraints_.rotation(\n              rotation,\n              true\n            );\n            this.targetCenter_ = this.calculateCenterRotate(\n              constrainedRotation,\n              animation.anchor\n            );\n          }\n          this.targetRotation_ = rotation;\n        }\n        this.applyTargetState_(true);\n        more = true;\n        if (!animation.complete) {\n          break;\n        }\n      }\n      if (seriesComplete) {\n        this.animations_[i] = null;\n        this.setHint(ViewHint.ANIMATING, -1);\n        const callback = series[0].callback;\n        if (callback) {\n          animationCallback(callback, true);\n        }\n      }\n    }\n    // prune completed series\n    this.animations_ = this.animations_.filter(Boolean);\n    if (more && this.updateAnimationKey_ === undefined) {\n      this.updateAnimationKey_ = requestAnimationFrame(\n        this.updateAnimations_.bind(this)\n      );\n    }\n  }\n\n  /**\n   * @param {number} rotation Target rotation.\n   * @param {import(\"./coordinate.js\").Coordinate} anchor Rotation anchor.\n   * @return {import(\"./coordinate.js\").Coordinate|undefined} Center for rotation and anchor.\n   */\n  calculateCenterRotate(rotation, anchor) {\n    let center;\n    const currentCenter = this.getCenterInternal();\n    if (currentCenter !== undefined) {\n      center = [currentCenter[0] - anchor[0], currentCenter[1] - anchor[1]];\n      rotateCoordinate(center, rotation - this.getRotation());\n      addCoordinate(center, anchor);\n    }\n    return center;\n  }\n\n  /**\n   * @param {number} resolution Target resolution.\n   * @param {import(\"./coordinate.js\").Coordinate} anchor Zoom anchor.\n   * @return {import(\"./coordinate.js\").Coordinate|undefined} Center for resolution and anchor.\n   */\n  calculateCenterZoom(resolution, anchor) {\n    let center;\n    const currentCenter = this.getCenterInternal();\n    const currentResolution = this.getResolution();\n    if (currentCenter !== undefined && currentResolution !== undefined) {\n      const x =\n        anchor[0] -\n        (resolution * (anchor[0] - currentCenter[0])) / currentResolution;\n      const y =\n        anchor[1] -\n        (resolution * (anchor[1] - currentCenter[1])) / currentResolution;\n      center = [x, y];\n    }\n    return center;\n  }\n\n  /**\n   * Returns the current viewport size.\n   * @private\n   * @param {number=} opt_rotation Take into account the rotation of the viewport when giving the size\n   * @return {import(\"./size.js\").Size} Viewport size or `[100, 100]` when no viewport is found.\n   */\n  getViewportSize_(opt_rotation) {\n    const size = this.viewportSize_;\n    if (opt_rotation) {\n      const w = size[0];\n      const h = size[1];\n      return [\n        Math.abs(w * Math.cos(opt_rotation)) +\n          Math.abs(h * Math.sin(opt_rotation)),\n        Math.abs(w * Math.sin(opt_rotation)) +\n          Math.abs(h * Math.cos(opt_rotation)),\n      ];\n    } else {\n      return size;\n    }\n  }\n\n  /**\n   * Stores the viewport size on the view. The viewport size is not read every time from the DOM\n   * to avoid performance hit and layout reflow.\n   * This should be done on map size change.\n   * Note: the constraints are not resolved during an animation to avoid stopping it\n   * @param {import(\"./size.js\").Size=} opt_size Viewport size; if undefined, [100, 100] is assumed\n   */\n  setViewportSize(opt_size) {\n    this.viewportSize_ = Array.isArray(opt_size)\n      ? opt_size.slice()\n      : [100, 100];\n    if (!this.getAnimating()) {\n      this.resolveConstraints(0);\n    }\n  }\n\n  /**\n   * Get the view center.\n   * @return {import(\"./coordinate.js\").Coordinate|undefined} The center of the view.\n   * @observable\n   * @api\n   */\n  getCenter() {\n    const center = this.getCenterInternal();\n    if (!center) {\n      return center;\n    }\n    return toUserCoordinate(center, this.getProjection());\n  }\n\n  /**\n   * Get the view center without transforming to user projection.\n   * @return {import(\"./coordinate.js\").Coordinate|undefined} The center of the view.\n   */\n  getCenterInternal() {\n    return /** @type {import(\"./coordinate.js\").Coordinate|undefined} */ (this.get(\n      ViewProperty.CENTER\n    ));\n  }\n\n  /**\n   * @return {Constraints} Constraints.\n   */\n  getConstraints() {\n    return this.constraints_;\n  }\n\n  /**\n   * @return {boolean} Resolution constraint is set\n   */\n  getConstrainResolution() {\n    return this.options_.constrainResolution;\n  }\n\n  /**\n   * @param {Array<number>=} opt_hints Destination array.\n   * @return {Array<number>} Hint.\n   */\n  getHints(opt_hints) {\n    if (opt_hints !== undefined) {\n      opt_hints[0] = this.hints_[0];\n      opt_hints[1] = this.hints_[1];\n      return opt_hints;\n    } else {\n      return this.hints_.slice();\n    }\n  }\n\n  /**\n   * Calculate the extent for the current view state and the passed size.\n   * The size is the pixel dimensions of the box into which the calculated extent\n   * should fit. In most cases you want to get the extent of the entire map,\n   * that is `map.getSize()`.\n   * @param {import(\"./size.js\").Size=} opt_size Box pixel size. If not provided, the size\n   * of the map that uses this view will be used.\n   * @return {import(\"./extent.js\").Extent} Extent.\n   * @api\n   */\n  calculateExtent(opt_size) {\n    const extent = this.calculateExtentInternal(opt_size);\n    return toUserExtent(extent, this.getProjection());\n  }\n\n  /**\n   * @param {import(\"./size.js\").Size=} opt_size Box pixel size. If not provided,\n   * the map's last known viewport size will be used.\n   * @return {import(\"./extent.js\").Extent} Extent.\n   */\n  calculateExtentInternal(opt_size) {\n    const size = opt_size || this.getViewportSize_();\n    const center = /** @type {!import(\"./coordinate.js\").Coordinate} */ (this.getCenterInternal());\n    assert(center, 1); // The view center is not defined\n    const resolution = /** @type {!number} */ (this.getResolution());\n    assert(resolution !== undefined, 2); // The view resolution is not defined\n    const rotation = /** @type {!number} */ (this.getRotation());\n    assert(rotation !== undefined, 3); // The view rotation is not defined\n\n    return getForViewAndSize(center, resolution, rotation, size);\n  }\n\n  /**\n   * Get the maximum resolution of the view.\n   * @return {number} The maximum resolution of the view.\n   * @api\n   */\n  getMaxResolution() {\n    return this.maxResolution_;\n  }\n\n  /**\n   * Get the minimum resolution of the view.\n   * @return {number} The minimum resolution of the view.\n   * @api\n   */\n  getMinResolution() {\n    return this.minResolution_;\n  }\n\n  /**\n   * Get the maximum zoom level for the view.\n   * @return {number} The maximum zoom level.\n   * @api\n   */\n  getMaxZoom() {\n    return /** @type {number} */ (this.getZoomForResolution(\n      this.minResolution_\n    ));\n  }\n\n  /**\n   * Set a new maximum zoom level for the view.\n   * @param {number} zoom The maximum zoom level.\n   * @api\n   */\n  setMaxZoom(zoom) {\n    this.applyOptions_(this.getUpdatedOptions_({maxZoom: zoom}));\n  }\n\n  /**\n   * Get the minimum zoom level for the view.\n   * @return {number} The minimum zoom level.\n   * @api\n   */\n  getMinZoom() {\n    return /** @type {number} */ (this.getZoomForResolution(\n      this.maxResolution_\n    ));\n  }\n\n  /**\n   * Set a new minimum zoom level for the view.\n   * @param {number} zoom The minimum zoom level.\n   * @api\n   */\n  setMinZoom(zoom) {\n    this.applyOptions_(this.getUpdatedOptions_({minZoom: zoom}));\n  }\n\n  /**\n   * Set whether the view shoud allow intermediary zoom levels.\n   * @param {boolean} enabled Whether the resolution is constrained.\n   * @api\n   */\n  setConstrainResolution(enabled) {\n    this.applyOptions_(this.getUpdatedOptions_({constrainResolution: enabled}));\n  }\n\n  /**\n   * Get the view projection.\n   * @return {import(\"./proj/Projection.js\").default} The projection of the view.\n   * @api\n   */\n  getProjection() {\n    return this.projection_;\n  }\n\n  /**\n   * Get the view resolution.\n   * @return {number|undefined} The resolution of the view.\n   * @observable\n   * @api\n   */\n  getResolution() {\n    return /** @type {number|undefined} */ (this.get(ViewProperty.RESOLUTION));\n  }\n\n  /**\n   * Get the resolutions for the view. This returns the array of resolutions\n   * passed to the constructor of the View, or undefined if none were given.\n   * @return {Array<number>|undefined} The resolutions of the view.\n   * @api\n   */\n  getResolutions() {\n    return this.resolutions_;\n  }\n\n  /**\n   * Get the resolution for a provided extent (in map units) and size (in pixels).\n   * @param {import(\"./extent.js\").Extent} extent Extent.\n   * @param {import(\"./size.js\").Size=} opt_size Box pixel size.\n   * @return {number} The resolution at which the provided extent will render at\n   *     the given size.\n   * @api\n   */\n  getResolutionForExtent(extent, opt_size) {\n    return this.getResolutionForExtentInternal(\n      fromUserExtent(extent, this.getProjection()),\n      opt_size\n    );\n  }\n\n  /**\n   * Get the resolution for a provided extent (in map units) and size (in pixels).\n   * @param {import(\"./extent.js\").Extent} extent Extent.\n   * @param {import(\"./size.js\").Size=} opt_size Box pixel size.\n   * @return {number} The resolution at which the provided extent will render at\n   *     the given size.\n   */\n  getResolutionForExtentInternal(extent, opt_size) {\n    const size = opt_size || this.getViewportSize_();\n    const xResolution = getWidth(extent) / size[0];\n    const yResolution = getHeight(extent) / size[1];\n    return Math.max(xResolution, yResolution);\n  }\n\n  /**\n   * Return a function that returns a value between 0 and 1 for a\n   * resolution. Exponential scaling is assumed.\n   * @param {number=} opt_power Power.\n   * @return {function(number): number} Resolution for value function.\n   */\n  getResolutionForValueFunction(opt_power) {\n    const power = opt_power || 2;\n    const maxResolution = this.getConstrainedResolution(this.maxResolution_);\n    const minResolution = this.minResolution_;\n    const max = Math.log(maxResolution / minResolution) / Math.log(power);\n    return (\n      /**\n       * @param {number} value Value.\n       * @return {number} Resolution.\n       */\n      function (value) {\n        const resolution = maxResolution / Math.pow(power, value * max);\n        return resolution;\n      }\n    );\n  }\n\n  /**\n   * Get the view rotation.\n   * @return {number} The rotation of the view in radians.\n   * @observable\n   * @api\n   */\n  getRotation() {\n    return /** @type {number} */ (this.get(ViewProperty.ROTATION));\n  }\n\n  /**\n   * Return a function that returns a resolution for a value between\n   * 0 and 1. Exponential scaling is assumed.\n   * @param {number=} opt_power Power.\n   * @return {function(number): number} Value for resolution function.\n   */\n  getValueForResolutionFunction(opt_power) {\n    const logPower = Math.log(opt_power || 2);\n    const maxResolution = this.getConstrainedResolution(this.maxResolution_);\n    const minResolution = this.minResolution_;\n    const max = Math.log(maxResolution / minResolution) / logPower;\n    return (\n      /**\n       * @param {number} resolution Resolution.\n       * @return {number} Value.\n       */\n      function (resolution) {\n        const value = Math.log(maxResolution / resolution) / logPower / max;\n        return value;\n      }\n    );\n  }\n\n  /**\n   * Returns the size of the viewport minus padding.\n   * @private\n   * @param {number=} opt_rotation Take into account the rotation of the viewport when giving the size\n   * @return {import(\"./size.js\").Size} Viewport size reduced by the padding.\n   */\n  getViewportSizeMinusPadding_(opt_rotation) {\n    let size = this.getViewportSize_(opt_rotation);\n    const padding = this.padding;\n    if (padding) {\n      size = [\n        size[0] - padding[1] - padding[3],\n        size[1] - padding[0] - padding[2],\n      ];\n    }\n    return size;\n  }\n\n  /**\n   * @return {State} View state.\n   */\n  getState() {\n    const projection = this.getProjection();\n    const resolution = /** @type {number} */ (this.getResolution());\n    const rotation = this.getRotation();\n    let center = /** @type {import(\"./coordinate.js\").Coordinate} */ (this.getCenterInternal());\n    const padding = this.padding;\n    if (padding) {\n      const reducedSize = this.getViewportSizeMinusPadding_();\n      center = calculateCenterOn(\n        center,\n        this.getViewportSize_(),\n        [reducedSize[0] / 2 + padding[3], reducedSize[1] / 2 + padding[0]],\n        resolution,\n        rotation\n      );\n    }\n    return {\n      center: center.slice(0),\n      projection: projection !== undefined ? projection : null,\n      resolution: resolution,\n      rotation: rotation,\n      zoom: this.getZoom(),\n    };\n  }\n\n  /**\n   * Get the current zoom level. This method may return non-integer zoom levels\n   * if the view does not constrain the resolution, or if an interaction or\n   * animation is underway.\n   * @return {number|undefined} Zoom.\n   * @api\n   */\n  getZoom() {\n    let zoom;\n    const resolution = this.getResolution();\n    if (resolution !== undefined) {\n      zoom = this.getZoomForResolution(resolution);\n    }\n    return zoom;\n  }\n\n  /**\n   * Get the zoom level for a resolution.\n   * @param {number} resolution The resolution.\n   * @return {number|undefined} The zoom level for the provided resolution.\n   * @api\n   */\n  getZoomForResolution(resolution) {\n    let offset = this.minZoom_ || 0;\n    let max, zoomFactor;\n    if (this.resolutions_) {\n      const nearest = linearFindNearest(this.resolutions_, resolution, 1);\n      offset = nearest;\n      max = this.resolutions_[nearest];\n      if (nearest == this.resolutions_.length - 1) {\n        zoomFactor = 2;\n      } else {\n        zoomFactor = max / this.resolutions_[nearest + 1];\n      }\n    } else {\n      max = this.maxResolution_;\n      zoomFactor = this.zoomFactor_;\n    }\n    return offset + Math.log(max / resolution) / Math.log(zoomFactor);\n  }\n\n  /**\n   * Get the resolution for a zoom level.\n   * @param {number} zoom Zoom level.\n   * @return {number} The view resolution for the provided zoom level.\n   * @api\n   */\n  getResolutionForZoom(zoom) {\n    if (this.resolutions_) {\n      if (this.resolutions_.length <= 1) {\n        return 0;\n      }\n      const baseLevel = clamp(\n        Math.floor(zoom),\n        0,\n        this.resolutions_.length - 2\n      );\n      const zoomFactor =\n        this.resolutions_[baseLevel] / this.resolutions_[baseLevel + 1];\n      return (\n        this.resolutions_[baseLevel] /\n        Math.pow(zoomFactor, clamp(zoom - baseLevel, 0, 1))\n      );\n    } else {\n      return (\n        this.maxResolution_ / Math.pow(this.zoomFactor_, zoom - this.minZoom_)\n      );\n    }\n  }\n\n  /**\n   * Fit the given geometry or extent based on the given map size and border.\n   * The size is pixel dimensions of the box to fit the extent into.\n   * In most cases you will want to use the map size, that is `map.getSize()`.\n   * Takes care of the map angle.\n   * @param {import(\"./geom/SimpleGeometry.js\").default|import(\"./extent.js\").Extent} geometryOrExtent The geometry or\n   *     extent to fit the view to.\n   * @param {FitOptions=} opt_options Options.\n   * @api\n   */\n  fit(geometryOrExtent, opt_options) {\n    /** @type {import(\"./geom/SimpleGeometry.js\").default} */\n    let geometry;\n    assert(\n      Array.isArray(geometryOrExtent) ||\n        typeof (/** @type {?} */ (geometryOrExtent).getSimplifiedGeometry) ===\n          'function',\n      24\n    ); // Invalid extent or geometry provided as `geometry`\n    if (Array.isArray(geometryOrExtent)) {\n      assert(!isEmpty(geometryOrExtent), 25); // Cannot fit empty extent provided as `geometry`\n      const extent = fromUserExtent(geometryOrExtent, this.getProjection());\n      geometry = polygonFromExtent(extent);\n    } else if (geometryOrExtent.getType() === GeometryType.CIRCLE) {\n      const extent = fromUserExtent(\n        geometryOrExtent.getExtent(),\n        this.getProjection()\n      );\n      geometry = polygonFromExtent(extent);\n      geometry.rotate(this.getRotation(), getCenter(extent));\n    } else {\n      const userProjection = getUserProjection();\n      if (userProjection) {\n        geometry = /** @type {import(\"./geom/SimpleGeometry.js\").default} */ (geometryOrExtent\n          .clone()\n          .transform(userProjection, this.getProjection()));\n      } else {\n        geometry = geometryOrExtent;\n      }\n    }\n\n    this.fitInternal(geometry, opt_options);\n  }\n\n  /**\n   * @param {import(\"./geom/SimpleGeometry.js\").default} geometry The geometry.\n   * @param {FitOptions=} opt_options Options.\n   */\n  fitInternal(geometry, opt_options) {\n    const options = opt_options || {};\n    let size = options.size;\n    if (!size) {\n      size = this.getViewportSizeMinusPadding_();\n    }\n    const padding =\n      options.padding !== undefined ? options.padding : [0, 0, 0, 0];\n    const nearest = options.nearest !== undefined ? options.nearest : false;\n    let minResolution;\n    if (options.minResolution !== undefined) {\n      minResolution = options.minResolution;\n    } else if (options.maxZoom !== undefined) {\n      minResolution = this.getResolutionForZoom(options.maxZoom);\n    } else {\n      minResolution = 0;\n    }\n    const coords = geometry.getFlatCoordinates();\n\n    // calculate rotated extent\n    const rotation = this.getRotation();\n    const cosAngle = Math.cos(-rotation);\n    let sinAngle = Math.sin(-rotation);\n    let minRotX = +Infinity;\n    let minRotY = +Infinity;\n    let maxRotX = -Infinity;\n    let maxRotY = -Infinity;\n    const stride = geometry.getStride();\n    for (let i = 0, ii = coords.length; i < ii; i += stride) {\n      const rotX = coords[i] * cosAngle - coords[i + 1] * sinAngle;\n      const rotY = coords[i] * sinAngle + coords[i + 1] * cosAngle;\n      minRotX = Math.min(minRotX, rotX);\n      minRotY = Math.min(minRotY, rotY);\n      maxRotX = Math.max(maxRotX, rotX);\n      maxRotY = Math.max(maxRotY, rotY);\n    }\n\n    // calculate resolution\n    let resolution = this.getResolutionForExtentInternal(\n      [minRotX, minRotY, maxRotX, maxRotY],\n      [size[0] - padding[1] - padding[3], size[1] - padding[0] - padding[2]]\n    );\n    resolution = isNaN(resolution)\n      ? minResolution\n      : Math.max(resolution, minResolution);\n    resolution = this.getConstrainedResolution(resolution, nearest ? 0 : 1);\n\n    // calculate center\n    sinAngle = -sinAngle; // go back to original rotation\n    let centerRotX = (minRotX + maxRotX) / 2;\n    let centerRotY = (minRotY + maxRotY) / 2;\n    centerRotX += ((padding[1] - padding[3]) / 2) * resolution;\n    centerRotY += ((padding[0] - padding[2]) / 2) * resolution;\n    const centerX = centerRotX * cosAngle - centerRotY * sinAngle;\n    const centerY = centerRotY * cosAngle + centerRotX * sinAngle;\n    const center = this.getConstrainedCenter([centerX, centerY], resolution);\n    const callback = options.callback ? options.callback : VOID;\n\n    if (options.duration !== undefined) {\n      this.animateInternal(\n        {\n          resolution: resolution,\n          center: center,\n          duration: options.duration,\n          easing: options.easing,\n        },\n        callback\n      );\n    } else {\n      this.targetResolution_ = resolution;\n      this.targetCenter_ = center;\n      this.applyTargetState_(false, true);\n      animationCallback(callback, true);\n    }\n  }\n\n  /**\n   * Center on coordinate and view position.\n   * @param {import(\"./coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {import(\"./size.js\").Size} size Box pixel size.\n   * @param {import(\"./pixel.js\").Pixel} position Position on the view to center on.\n   * @api\n   */\n  centerOn(coordinate, size, position) {\n    this.centerOnInternal(\n      fromUserCoordinate(coordinate, this.getProjection()),\n      size,\n      position\n    );\n  }\n\n  /**\n   * @param {import(\"./coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {import(\"./size.js\").Size} size Box pixel size.\n   * @param {import(\"./pixel.js\").Pixel} position Position on the view to center on.\n   */\n  centerOnInternal(coordinate, size, position) {\n    this.setCenterInternal(\n      calculateCenterOn(\n        coordinate,\n        size,\n        position,\n        this.getResolution(),\n        this.getRotation()\n      )\n    );\n  }\n\n  /**\n   * Calculates the shift between map and viewport center.\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   * @return {Array<number>|undefined} Center shift.\n   */\n  calculateCenterShift(center, resolution, rotation, size) {\n    let centerShift;\n    const padding = this.padding;\n    if (padding && center) {\n      const reducedSize = this.getViewportSizeMinusPadding_(-rotation);\n      const shiftedCenter = calculateCenterOn(\n        center,\n        size,\n        [reducedSize[0] / 2 + padding[3], reducedSize[1] / 2 + padding[0]],\n        resolution,\n        rotation\n      );\n      centerShift = [\n        center[0] - shiftedCenter[0],\n        center[1] - shiftedCenter[1],\n      ];\n    }\n    return centerShift;\n  }\n\n  /**\n   * @return {boolean} Is defined.\n   */\n  isDef() {\n    return !!this.getCenterInternal() && this.getResolution() !== undefined;\n  }\n\n  /**\n   * Adds relative coordinates to the center of the view. Any extent constraint will apply.\n   * @param {import(\"./coordinate.js\").Coordinate} deltaCoordinates Relative value to add.\n   * @api\n   */\n  adjustCenter(deltaCoordinates) {\n    const center = toUserCoordinate(this.targetCenter_, this.getProjection());\n    this.setCenter([\n      center[0] + deltaCoordinates[0],\n      center[1] + deltaCoordinates[1],\n    ]);\n  }\n\n  /**\n   * Adds relative coordinates to the center of the view. Any extent constraint will apply.\n   * @param {import(\"./coordinate.js\").Coordinate} deltaCoordinates Relative value to add.\n   */\n  adjustCenterInternal(deltaCoordinates) {\n    const center = this.targetCenter_;\n    this.setCenterInternal([\n      center[0] + deltaCoordinates[0],\n      center[1] + deltaCoordinates[1],\n    ]);\n  }\n\n  /**\n   * Multiply the view resolution by a ratio, optionally using an anchor. Any resolution\n   * constraint will apply.\n   * @param {number} ratio The ratio to apply on the view resolution.\n   * @param {import(\"./coordinate.js\").Coordinate=} opt_anchor The origin of the transformation.\n   * @api\n   */\n  adjustResolution(ratio, opt_anchor) {\n    const anchor =\n      opt_anchor && fromUserCoordinate(opt_anchor, this.getProjection());\n    this.adjustResolutionInternal(ratio, anchor);\n  }\n\n  /**\n   * Multiply the view resolution by a ratio, optionally using an anchor. Any resolution\n   * constraint will apply.\n   * @param {number} ratio The ratio to apply on the view resolution.\n   * @param {import(\"./coordinate.js\").Coordinate=} opt_anchor The origin of the transformation.\n   */\n  adjustResolutionInternal(ratio, opt_anchor) {\n    const isMoving = this.getAnimating() || this.getInteracting();\n    const size = this.getViewportSize_(this.getRotation());\n    const newResolution = this.constraints_.resolution(\n      this.targetResolution_ * ratio,\n      0,\n      size,\n      isMoving\n    );\n\n    if (opt_anchor) {\n      this.targetCenter_ = this.calculateCenterZoom(newResolution, opt_anchor);\n    }\n\n    this.targetResolution_ *= ratio;\n    this.applyTargetState_();\n  }\n\n  /**\n   * Adds a value to the view zoom level, optionally using an anchor. Any resolution\n   * constraint will apply.\n   * @param {number} delta Relative value to add to the zoom level.\n   * @param {import(\"./coordinate.js\").Coordinate=} opt_anchor The origin of the transformation.\n   * @api\n   */\n  adjustZoom(delta, opt_anchor) {\n    this.adjustResolution(Math.pow(this.zoomFactor_, -delta), opt_anchor);\n  }\n\n  /**\n   * Adds a value to the view rotation, optionally using an anchor. Any rotation\n   * constraint will apply.\n   * @param {number} delta Relative value to add to the zoom rotation, in radians.\n   * @param {import(\"./coordinate.js\").Coordinate=} opt_anchor The rotation center.\n   * @api\n   */\n  adjustRotation(delta, opt_anchor) {\n    if (opt_anchor) {\n      opt_anchor = fromUserCoordinate(opt_anchor, this.getProjection());\n    }\n    this.adjustRotationInternal(delta, opt_anchor);\n  }\n\n  /**\n   * @param {number} delta Relative value to add to the zoom rotation, in radians.\n   * @param {import(\"./coordinate.js\").Coordinate=} opt_anchor The rotation center.\n   */\n  adjustRotationInternal(delta, opt_anchor) {\n    const isMoving = this.getAnimating() || this.getInteracting();\n    const newRotation = this.constraints_.rotation(\n      this.targetRotation_ + delta,\n      isMoving\n    );\n    if (opt_anchor) {\n      this.targetCenter_ = this.calculateCenterRotate(newRotation, opt_anchor);\n    }\n    this.targetRotation_ += delta;\n    this.applyTargetState_();\n  }\n\n  /**\n   * Set the center of the current view. Any extent constraint will apply.\n   * @param {import(\"./coordinate.js\").Coordinate|undefined} center The center of the view.\n   * @observable\n   * @api\n   */\n  setCenter(center) {\n    this.setCenterInternal(fromUserCoordinate(center, this.getProjection()));\n  }\n\n  /**\n   * Set the center using the view projection (not the user projection).\n   * @param {import(\"./coordinate.js\").Coordinate|undefined} center The center of the view.\n   */\n  setCenterInternal(center) {\n    this.targetCenter_ = center;\n    this.applyTargetState_();\n  }\n\n  /**\n   * @param {import(\"./ViewHint.js\").default} hint Hint.\n   * @param {number} delta Delta.\n   * @return {number} New value.\n   */\n  setHint(hint, delta) {\n    this.hints_[hint] += delta;\n    this.changed();\n    return this.hints_[hint];\n  }\n\n  /**\n   * Set the resolution for this view. Any resolution constraint will apply.\n   * @param {number|undefined} resolution The resolution of the view.\n   * @observable\n   * @api\n   */\n  setResolution(resolution) {\n    this.targetResolution_ = resolution;\n    this.applyTargetState_();\n  }\n\n  /**\n   * Set the rotation for this view. Any rotation constraint will apply.\n   * @param {number} rotation The rotation of the view in radians.\n   * @observable\n   * @api\n   */\n  setRotation(rotation) {\n    this.targetRotation_ = rotation;\n    this.applyTargetState_();\n  }\n\n  /**\n   * Zoom to a specific zoom level. Any resolution constrain will apply.\n   * @param {number} zoom Zoom level.\n   * @api\n   */\n  setZoom(zoom) {\n    this.setResolution(this.getResolutionForZoom(zoom));\n  }\n\n  /**\n   * Recompute rotation/resolution/center based on target values.\n   * Note: we have to compute rotation first, then resolution and center considering that\n   * parameters can influence one another in case a view extent constraint is present.\n   * @param {boolean=} opt_doNotCancelAnims Do not cancel animations.\n   * @param {boolean=} opt_forceMoving Apply constraints as if the view is moving.\n   * @private\n   */\n  applyTargetState_(opt_doNotCancelAnims, opt_forceMoving) {\n    const isMoving =\n      this.getAnimating() || this.getInteracting() || opt_forceMoving;\n\n    // compute rotation\n    const newRotation = this.constraints_.rotation(\n      this.targetRotation_,\n      isMoving\n    );\n    const size = this.getViewportSize_(newRotation);\n    const newResolution = this.constraints_.resolution(\n      this.targetResolution_,\n      0,\n      size,\n      isMoving\n    );\n    const newCenter = this.constraints_.center(\n      this.targetCenter_,\n      newResolution,\n      size,\n      isMoving,\n      this.calculateCenterShift(\n        this.targetCenter_,\n        newResolution,\n        newRotation,\n        size\n      )\n    );\n\n    if (this.get(ViewProperty.ROTATION) !== newRotation) {\n      this.set(ViewProperty.ROTATION, newRotation);\n    }\n    if (this.get(ViewProperty.RESOLUTION) !== newResolution) {\n      this.set(ViewProperty.RESOLUTION, newResolution);\n    }\n    if (\n      !this.get(ViewProperty.CENTER) ||\n      !equals(this.get(ViewProperty.CENTER), newCenter)\n    ) {\n      this.set(ViewProperty.CENTER, newCenter);\n    }\n\n    if (this.getAnimating() && !opt_doNotCancelAnims) {\n      this.cancelAnimations();\n    }\n    this.cancelAnchor_ = undefined;\n  }\n\n  /**\n   * If any constraints need to be applied, an animation will be triggered.\n   * This is typically done on interaction end.\n   * Note: calling this with a duration of 0 will apply the constrained values straight away,\n   * without animation.\n   * @param {number=} opt_duration The animation duration in ms.\n   * @param {number=} opt_resolutionDirection Which direction to zoom.\n   * @param {import(\"./coordinate.js\").Coordinate=} opt_anchor The origin of the transformation.\n   */\n  resolveConstraints(opt_duration, opt_resolutionDirection, opt_anchor) {\n    const duration = opt_duration !== undefined ? opt_duration : 200;\n    const direction = opt_resolutionDirection || 0;\n\n    const newRotation = this.constraints_.rotation(this.targetRotation_);\n    const size = this.getViewportSize_(newRotation);\n    const newResolution = this.constraints_.resolution(\n      this.targetResolution_,\n      direction,\n      size\n    );\n    const newCenter = this.constraints_.center(\n      this.targetCenter_,\n      newResolution,\n      size,\n      false,\n      this.calculateCenterShift(\n        this.targetCenter_,\n        newResolution,\n        newRotation,\n        size\n      )\n    );\n\n    if (duration === 0 && !this.cancelAnchor_) {\n      this.targetResolution_ = newResolution;\n      this.targetRotation_ = newRotation;\n      this.targetCenter_ = newCenter;\n      this.applyTargetState_();\n      return;\n    }\n\n    const anchor =\n      opt_anchor || (duration === 0 ? this.cancelAnchor_ : undefined);\n    this.cancelAnchor_ = undefined;\n\n    if (\n      this.getResolution() !== newResolution ||\n      this.getRotation() !== newRotation ||\n      !this.getCenterInternal() ||\n      !equals(this.getCenterInternal(), newCenter)\n    ) {\n      if (this.getAnimating()) {\n        this.cancelAnimations();\n      }\n\n      this.animateInternal({\n        rotation: newRotation,\n        center: newCenter,\n        resolution: newResolution,\n        duration: duration,\n        easing: easeOut,\n        anchor: anchor,\n      });\n    }\n  }\n\n  /**\n   * Notify the View that an interaction has started.\n   * The view state will be resolved to a stable one if needed\n   * (depending on its constraints).\n   * @api\n   */\n  beginInteraction() {\n    this.resolveConstraints(0);\n\n    this.setHint(ViewHint.INTERACTING, 1);\n  }\n\n  /**\n   * Notify the View that an interaction has ended. The view state will be resolved\n   * to a stable one if needed (depending on its constraints).\n   * @param {number=} opt_duration Animation duration in ms.\n   * @param {number=} opt_resolutionDirection Which direction to zoom.\n   * @param {import(\"./coordinate.js\").Coordinate=} opt_anchor The origin of the transformation.\n   * @api\n   */\n  endInteraction(opt_duration, opt_resolutionDirection, opt_anchor) {\n    const anchor =\n      opt_anchor && fromUserCoordinate(opt_anchor, this.getProjection());\n    this.endInteractionInternal(opt_duration, opt_resolutionDirection, anchor);\n  }\n\n  /**\n   * Notify the View that an interaction has ended. The view state will be resolved\n   * to a stable one if needed (depending on its constraints).\n   * @param {number=} opt_duration Animation duration in ms.\n   * @param {number=} opt_resolutionDirection Which direction to zoom.\n   * @param {import(\"./coordinate.js\").Coordinate=} opt_anchor The origin of the transformation.\n   */\n  endInteractionInternal(opt_duration, opt_resolutionDirection, opt_anchor) {\n    this.setHint(ViewHint.INTERACTING, -1);\n\n    this.resolveConstraints(opt_duration, opt_resolutionDirection, opt_anchor);\n  }\n\n  /**\n   * Get a valid position for the view center according to the current constraints.\n   * @param {import(\"./coordinate.js\").Coordinate|undefined} targetCenter Target center position.\n   * @param {number=} opt_targetResolution Target resolution. If not supplied, the current one will be used.\n   * This is useful to guess a valid center position at a different zoom level.\n   * @return {import(\"./coordinate.js\").Coordinate|undefined} Valid center position.\n   */\n  getConstrainedCenter(targetCenter, opt_targetResolution) {\n    const size = this.getViewportSize_(this.getRotation());\n    return this.constraints_.center(\n      targetCenter,\n      opt_targetResolution || this.getResolution(),\n      size\n    );\n  }\n\n  /**\n   * Get a valid zoom level according to the current view constraints.\n   * @param {number|undefined} targetZoom Target zoom.\n   * @param {number=} [opt_direction=0] Indicate which resolution should be used\n   * by a renderer if the view resolution does not match any resolution of the tile source.\n   * If 0, the nearest resolution will be used. If 1, the nearest lower resolution\n   * will be used. If -1, the nearest higher resolution will be used.\n   * @return {number|undefined} Valid zoom level.\n   */\n  getConstrainedZoom(targetZoom, opt_direction) {\n    const targetRes = this.getResolutionForZoom(targetZoom);\n    return this.getZoomForResolution(\n      this.getConstrainedResolution(targetRes, opt_direction)\n    );\n  }\n\n  /**\n   * Get a valid resolution according to the current view constraints.\n   * @param {number|undefined} targetResolution Target resolution.\n   * @param {number=} [opt_direction=0] Indicate which resolution should be used\n   * by a renderer if the view resolution does not match any resolution of the tile source.\n   * If 0, the nearest resolution will be used. If 1, the nearest lower resolution\n   * will be used. If -1, the nearest higher resolution will be used.\n   * @return {number|undefined} Valid resolution.\n   */\n  getConstrainedResolution(targetResolution, opt_direction) {\n    const direction = opt_direction || 0;\n    const size = this.getViewportSize_(this.getRotation());\n\n    return this.constraints_.resolution(targetResolution, direction, size);\n  }\n}\n\n/**\n * @param {Function} callback Callback.\n * @param {*} returnValue Return value.\n */\nfunction animationCallback(callback, returnValue) {\n  setTimeout(function () {\n    callback(returnValue);\n  }, 0);\n}\n\n/**\n * @param {ViewOptions} options View options.\n * @return {import(\"./centerconstraint.js\").Type} The constraint.\n */\nexport function createCenterConstraint(options) {\n  if (options.extent !== undefined) {\n    const smooth =\n      options.smoothExtentConstraint !== undefined\n        ? options.smoothExtentConstraint\n        : true;\n    return createExtent(options.extent, options.constrainOnlyCenter, smooth);\n  }\n\n  const projection = createProjection(options.projection, 'EPSG:3857');\n  if (options.multiWorld !== true && projection.isGlobal()) {\n    const extent = projection.getExtent().slice();\n    extent[0] = -Infinity;\n    extent[2] = Infinity;\n    return createExtent(extent, false, false);\n  }\n\n  return centerNone;\n}\n\n/**\n * @param {ViewOptions} options View options.\n * @return {{constraint: import(\"./resolutionconstraint.js\").Type, maxResolution: number,\n *     minResolution: number, minZoom: number, zoomFactor: number}} The constraint.\n */\nexport function createResolutionConstraint(options) {\n  let resolutionConstraint;\n  let maxResolution;\n  let minResolution;\n\n  // TODO: move these to be ol constants\n  // see https://github.com/openlayers/openlayers/issues/2076\n  const defaultMaxZoom = 28;\n  const defaultZoomFactor = 2;\n\n  let minZoom =\n    options.minZoom !== undefined ? options.minZoom : DEFAULT_MIN_ZOOM;\n\n  let maxZoom =\n    options.maxZoom !== undefined ? options.maxZoom : defaultMaxZoom;\n\n  const zoomFactor =\n    options.zoomFactor !== undefined ? options.zoomFactor : defaultZoomFactor;\n\n  const multiWorld =\n    options.multiWorld !== undefined ? options.multiWorld : false;\n\n  const smooth =\n    options.smoothResolutionConstraint !== undefined\n      ? options.smoothResolutionConstraint\n      : true;\n\n  const showFullExtent =\n    options.showFullExtent !== undefined ? options.showFullExtent : false;\n\n  const projection = createProjection(options.projection, 'EPSG:3857');\n  const projExtent = projection.getExtent();\n  let constrainOnlyCenter = options.constrainOnlyCenter;\n  let extent = options.extent;\n  if (!multiWorld && !extent && projection.isGlobal()) {\n    constrainOnlyCenter = false;\n    extent = projExtent;\n  }\n\n  if (options.resolutions !== undefined) {\n    const resolutions = options.resolutions;\n    maxResolution = resolutions[minZoom];\n    minResolution =\n      resolutions[maxZoom] !== undefined\n        ? resolutions[maxZoom]\n        : resolutions[resolutions.length - 1];\n\n    if (options.constrainResolution) {\n      resolutionConstraint = createSnapToResolutions(\n        resolutions,\n        smooth,\n        !constrainOnlyCenter && extent,\n        showFullExtent\n      );\n    } else {\n      resolutionConstraint = createMinMaxResolution(\n        maxResolution,\n        minResolution,\n        smooth,\n        !constrainOnlyCenter && extent,\n        showFullExtent\n      );\n    }\n  } else {\n    // calculate the default min and max resolution\n    const size = !projExtent\n      ? // use an extent that can fit the whole world if need be\n        (360 * METERS_PER_UNIT[Units.DEGREES]) / projection.getMetersPerUnit()\n      : Math.max(getWidth(projExtent), getHeight(projExtent));\n\n    const defaultMaxResolution =\n      size / DEFAULT_TILE_SIZE / Math.pow(defaultZoomFactor, DEFAULT_MIN_ZOOM);\n\n    const defaultMinResolution =\n      defaultMaxResolution /\n      Math.pow(defaultZoomFactor, defaultMaxZoom - DEFAULT_MIN_ZOOM);\n\n    // user provided maxResolution takes precedence\n    maxResolution = options.maxResolution;\n    if (maxResolution !== undefined) {\n      minZoom = 0;\n    } else {\n      maxResolution = defaultMaxResolution / Math.pow(zoomFactor, minZoom);\n    }\n\n    // user provided minResolution takes precedence\n    minResolution = options.minResolution;\n    if (minResolution === undefined) {\n      if (options.maxZoom !== undefined) {\n        if (options.maxResolution !== undefined) {\n          minResolution = maxResolution / Math.pow(zoomFactor, maxZoom);\n        } else {\n          minResolution = defaultMaxResolution / Math.pow(zoomFactor, maxZoom);\n        }\n      } else {\n        minResolution = defaultMinResolution;\n      }\n    }\n\n    // given discrete zoom levels, minResolution may be different than provided\n    maxZoom =\n      minZoom +\n      Math.floor(\n        Math.log(maxResolution / minResolution) / Math.log(zoomFactor)\n      );\n    minResolution = maxResolution / Math.pow(zoomFactor, maxZoom - minZoom);\n\n    if (options.constrainResolution) {\n      resolutionConstraint = createSnapToPower(\n        zoomFactor,\n        maxResolution,\n        minResolution,\n        smooth,\n        !constrainOnlyCenter && extent,\n        showFullExtent\n      );\n    } else {\n      resolutionConstraint = createMinMaxResolution(\n        maxResolution,\n        minResolution,\n        smooth,\n        !constrainOnlyCenter && extent,\n        showFullExtent\n      );\n    }\n  }\n  return {\n    constraint: resolutionConstraint,\n    maxResolution: maxResolution,\n    minResolution: minResolution,\n    minZoom: minZoom,\n    zoomFactor: zoomFactor,\n  };\n}\n\n/**\n * @param {ViewOptions} options View options.\n * @return {import(\"./rotationconstraint.js\").Type} Rotation constraint.\n */\nexport function createRotationConstraint(options) {\n  const enableRotation =\n    options.enableRotation !== undefined ? options.enableRotation : true;\n  if (enableRotation) {\n    const constrainRotation = options.constrainRotation;\n    if (constrainRotation === undefined || constrainRotation === true) {\n      return createSnapToZero();\n    } else if (constrainRotation === false) {\n      return rotationNone;\n    } else if (typeof constrainRotation === 'number') {\n      return createSnapToN(constrainRotation);\n    } else {\n      return rotationNone;\n    }\n  } else {\n    return disable;\n  }\n}\n\n/**\n * Determine if an animation involves no view change.\n * @param {Animation} animation The animation.\n * @return {boolean} The animation involves no view change.\n */\nexport function isNoopAnimation(animation) {\n  if (animation.sourceCenter && animation.targetCenter) {\n    if (!coordinatesEqual(animation.sourceCenter, animation.targetCenter)) {\n      return false;\n    }\n  }\n  if (animation.sourceResolution !== animation.targetResolution) {\n    return false;\n  }\n  if (animation.sourceRotation !== animation.targetRotation) {\n    return false;\n  }\n  return true;\n}\n\n/**\n * @param {import(\"./coordinate.js\").Coordinate} coordinate Coordinate.\n * @param {import(\"./size.js\").Size} size Box pixel size.\n * @param {import(\"./pixel.js\").Pixel} position Position on the view to center on.\n * @param {number} resolution Resolution.\n * @param {number} rotation Rotation.\n * @return {import(\"./coordinate.js\").Coordinate} Shifted center.\n */\nfunction calculateCenterOn(coordinate, size, position, resolution, rotation) {\n  // calculate rotated position\n  const cosAngle = Math.cos(-rotation);\n  let sinAngle = Math.sin(-rotation);\n  let rotX = coordinate[0] * cosAngle - coordinate[1] * sinAngle;\n  let rotY = coordinate[1] * cosAngle + coordinate[0] * sinAngle;\n  rotX += (size[0] / 2 - position[0]) * resolution;\n  rotY += (position[1] - size[1] / 2) * resolution;\n\n  // go back to original angle\n  sinAngle = -sinAngle; // go back to original rotation\n  const centerX = rotX * cosAngle - rotY * sinAngle;\n  const centerY = rotY * cosAngle + rotX * sinAngle;\n\n  return [centerX, centerY];\n}\n\nexport default View;\n","/**\n * @module ol/tilegrid/common\n */\n\n/**\n * Default maximum zoom for default tile grids.\n * @type {number}\n */\nexport const DEFAULT_MAX_ZOOM = 42;\n\n/**\n * Default tile size.\n * @type {number}\n */\nexport const DEFAULT_TILE_SIZE = 256;\n","/**\n * @module ol/PluggableMap\n */\nimport BaseObject, {getChangeEventType} from './Object.js';\nimport Collection from './Collection.js';\nimport CollectionEventType from './CollectionEventType.js';\nimport EventType from './events/EventType.js';\nimport LayerGroup from './layer/Group.js';\nimport MapBrowserEvent from './MapBrowserEvent.js';\nimport MapBrowserEventHandler from './MapBrowserEventHandler.js';\nimport MapBrowserEventType from './MapBrowserEventType.js';\nimport MapEvent from './MapEvent.js';\nimport MapEventType from './MapEventType.js';\nimport MapProperty from './MapProperty.js';\nimport ObjectEventType from './ObjectEventType.js';\nimport PointerEventType from './pointer/EventType.js';\nimport RenderEventType from './render/EventType.js';\nimport TileQueue, {getTilePriority} from './TileQueue.js';\nimport View from './View.js';\nimport ViewHint from './ViewHint.js';\nimport {\n  DEVICE_PIXEL_RATIO,\n  IMAGE_DECODE,\n  PASSIVE_EVENT_LISTENERS,\n} from './has.js';\nimport {TRUE} from './functions.js';\nimport {\n  apply as applyTransform,\n  create as createTransform,\n} from './transform.js';\nimport {assert} from './asserts.js';\nimport {\n  clone,\n  createOrUpdateEmpty,\n  equals,\n  getForViewAndSize,\n  isEmpty,\n} from './extent.js';\nimport {fromUserCoordinate, toUserCoordinate} from './proj.js';\nimport {hasArea} from './size.js';\nimport {listen, unlistenByKey} from './events.js';\nimport {removeNode} from './dom.js';\n\n/**\n * State of the current frame. Only `pixelRatio`, `time` and `viewState` should\n * be used in applications.\n * @typedef {Object} FrameState\n * @property {number} pixelRatio The pixel ratio of the frame.\n * @property {number} time The time when rendering of the frame was requested.\n * @property {import(\"./View.js\").State} viewState The state of the current view.\n * @property {boolean} animate\n * @property {import(\"./transform.js\").Transform} coordinateToPixelTransform\n * @property {import(\"rbush\").default} declutterTree\n * @property {null|import(\"./extent.js\").Extent} extent\n * @property {number} index\n * @property {Array<import(\"./layer/Layer.js\").State>} layerStatesArray\n * @property {number} layerIndex\n * @property {import(\"./transform.js\").Transform} pixelToCoordinateTransform\n * @property {Array<PostRenderFunction>} postRenderFunctions\n * @property {import(\"./size.js\").Size} size\n * @property {TileQueue} tileQueue\n * @property {!Object<string, Object<string, boolean>>} usedTiles\n * @property {Array<number>} viewHints\n * @property {!Object<string, Object<string, boolean>>} wantedTiles\n */\n\n/**\n * @typedef {function(PluggableMap, ?FrameState): any} PostRenderFunction\n */\n\n/**\n * @typedef {Object} AtPixelOptions\n * @property {undefined|function(import(\"./layer/Layer.js\").default): boolean} [layerFilter] Layer filter\n * function. The filter function will receive one argument, the\n * {@link module:ol/layer/Layer layer-candidate} and it should return a boolean value.\n * Only layers which are visible and for which this function returns `true`\n * will be tested for features. By default, all visible layers will be tested.\n * @property {number} [hitTolerance=0] Hit-detection tolerance in css pixels. Pixels\n * inside the radius around the given position will be checked for features.\n * @property {boolean} [checkWrapped=true] Check-Wrapped Will check for for wrapped geometries inside the range of\n *   +/- 1 world width. Works only if a projection is used that can be wrapped.\n */\n\n/**\n * @typedef {Object} MapOptionsInternal\n * @property {Collection<import(\"./control/Control.js\").default>} [controls]\n * @property {Collection<import(\"./interaction/Interaction.js\").default>} [interactions]\n * @property {HTMLElement|Document} keyboardEventTarget\n * @property {Collection<import(\"./Overlay.js\").default>} overlays\n * @property {Object<string, *>} values\n */\n\n/**\n * Object literal with config options for the map.\n * @typedef {Object} MapOptions\n * @property {Collection<import(\"./control/Control.js\").default>|Array<import(\"./control/Control.js\").default>} [controls]\n * Controls initially added to the map. If not specified,\n * {@link module:ol/control~defaults} is used.\n * @property {number} [pixelRatio=window.devicePixelRatio] The ratio between\n * physical pixels and device-independent pixels (dips) on the device.\n * @property {Collection<import(\"./interaction/Interaction.js\").default>|Array<import(\"./interaction/Interaction.js\").default>} [interactions]\n * Interactions that are initially added to the map. If not specified,\n * {@link module:ol/interaction~defaults} is used.\n * @property {HTMLElement|Document|string} [keyboardEventTarget] The element to\n * listen to keyboard events on. This determines when the `KeyboardPan` and\n * `KeyboardZoom` interactions trigger. For example, if this option is set to\n * `document` the keyboard interactions will always trigger. If this option is\n * not specified, the element the library listens to keyboard events on is the\n * map target (i.e. the user-provided div for the map). If this is not\n * `document`, the target element needs to be focused for key events to be\n * emitted, requiring that the target element has a `tabindex` attribute.\n * @property {Array<import(\"./layer/Base.js\").default>|Collection<import(\"./layer/Base.js\").default>|LayerGroup} [layers]\n * Layers. If this is not defined, a map with no layers will be rendered. Note\n * that layers are rendered in the order supplied, so if you want, for example,\n * a vector layer to appear on top of a tile layer, it must come after the tile\n * layer.\n * @property {number} [maxTilesLoading=16] Maximum number tiles to load\n * simultaneously.\n * @property {number} [moveTolerance=1] The minimum distance in pixels the\n * cursor must move to be detected as a map move event instead of a click.\n * Increasing this value can make it easier to click on the map.\n * @property {Collection<import(\"./Overlay.js\").default>|Array<import(\"./Overlay.js\").default>} [overlays]\n * Overlays initially added to the map. By default, no overlays are added.\n * @property {HTMLElement|string} [target] The container for the map, either the\n * element itself or the `id` of the element. If not specified at construction\n * time, {@link module:ol/Map~Map#setTarget} must be called for the map to be\n * rendered. If passed by element, the container can be in a secondary document.\n * @property {View} [view] The map's view.  No layer sources will be\n * fetched unless this is specified at construction time or through\n * {@link module:ol/Map~Map#setView}.\n */\n\n/**\n * @fires import(\"./MapBrowserEvent.js\").MapBrowserEvent\n * @fires import(\"./MapEvent.js\").MapEvent\n * @fires import(\"./render/Event.js\").default#precompose\n * @fires import(\"./render/Event.js\").default#postcompose\n * @fires import(\"./render/Event.js\").default#rendercomplete\n * @api\n */\nclass PluggableMap extends BaseObject {\n  /**\n   * @param {MapOptions} options Map options.\n   */\n  constructor(options) {\n    super();\n\n    const optionsInternal = createOptionsInternal(options);\n\n    /** @private */\n    this.boundHandleBrowserEvent_ = this.handleBrowserEvent.bind(this);\n\n    /**\n     * @type {number}\n     * @private\n     */\n    this.maxTilesLoading_ =\n      options.maxTilesLoading !== undefined ? options.maxTilesLoading : 16;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.pixelRatio_ =\n      options.pixelRatio !== undefined\n        ? options.pixelRatio\n        : DEVICE_PIXEL_RATIO;\n\n    /**\n     * @private\n     * @type {*}\n     */\n    this.postRenderTimeoutHandle_;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.animationDelayKey_;\n\n    /**\n     * @private\n     */\n    this.animationDelay_ = /** @this {PluggableMap} */ function () {\n      this.animationDelayKey_ = undefined;\n      this.renderFrame_(Date.now());\n    }.bind(this);\n\n    /**\n     * @private\n     * @type {import(\"./transform.js\").Transform}\n     */\n    this.coordinateToPixelTransform_ = createTransform();\n\n    /**\n     * @private\n     * @type {import(\"./transform.js\").Transform}\n     */\n    this.pixelToCoordinateTransform_ = createTransform();\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.frameIndex_ = 0;\n\n    /**\n     * @private\n     * @type {?FrameState}\n     */\n    this.frameState_ = null;\n\n    /**\n     * The extent at the previous 'moveend' event.\n     * @private\n     * @type {import(\"./extent.js\").Extent}\n     */\n    this.previousExtent_ = null;\n\n    /**\n     * @private\n     * @type {?import(\"./events.js\").EventsKey}\n     */\n    this.viewPropertyListenerKey_ = null;\n\n    /**\n     * @private\n     * @type {?import(\"./events.js\").EventsKey}\n     */\n    this.viewChangeListenerKey_ = null;\n\n    /**\n     * @private\n     * @type {?Array<import(\"./events.js\").EventsKey>}\n     */\n    this.layerGroupPropertyListenerKeys_ = null;\n\n    /**\n     * @private\n     * @type {!HTMLElement}\n     */\n    this.viewport_ = document.createElement('div');\n    this.viewport_.className =\n      'ol-viewport' + ('ontouchstart' in window ? ' ol-touch' : '');\n    this.viewport_.style.position = 'relative';\n    this.viewport_.style.overflow = 'hidden';\n    this.viewport_.style.width = '100%';\n    this.viewport_.style.height = '100%';\n\n    /**\n     * @private\n     * @type {!HTMLElement}\n     */\n    this.overlayContainer_ = document.createElement('div');\n    this.overlayContainer_.style.position = 'absolute';\n    this.overlayContainer_.style.zIndex = '0';\n    this.overlayContainer_.style.width = '100%';\n    this.overlayContainer_.style.height = '100%';\n    this.overlayContainer_.style.pointerEvents = 'none';\n    this.overlayContainer_.className = 'ol-overlaycontainer';\n    this.viewport_.appendChild(this.overlayContainer_);\n\n    /**\n     * @private\n     * @type {!HTMLElement}\n     */\n    this.overlayContainerStopEvent_ = document.createElement('div');\n    this.overlayContainerStopEvent_.style.position = 'absolute';\n    this.overlayContainerStopEvent_.style.zIndex = '0';\n    this.overlayContainerStopEvent_.style.width = '100%';\n    this.overlayContainerStopEvent_.style.height = '100%';\n    this.overlayContainerStopEvent_.style.pointerEvents = 'none';\n    this.overlayContainerStopEvent_.className = 'ol-overlaycontainer-stopevent';\n    this.viewport_.appendChild(this.overlayContainerStopEvent_);\n\n    /**\n     * @private\n     * @type {MapBrowserEventHandler}\n     */\n    this.mapBrowserEventHandler_ = null;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.moveTolerance_ = options.moveTolerance;\n\n    /**\n     * @private\n     * @type {HTMLElement|Document}\n     */\n    this.keyboardEventTarget_ = optionsInternal.keyboardEventTarget;\n\n    /**\n     * @private\n     * @type {?Array<import(\"./events.js\").EventsKey>}\n     */\n    this.keyHandlerKeys_ = null;\n\n    /**\n     * @type {Collection<import(\"./control/Control.js\").default>}\n     * @protected\n     */\n    this.controls = optionsInternal.controls || new Collection();\n\n    /**\n     * @type {Collection<import(\"./interaction/Interaction.js\").default>}\n     * @protected\n     */\n    this.interactions = optionsInternal.interactions || new Collection();\n\n    /**\n     * @type {Collection<import(\"./Overlay.js\").default>}\n     * @private\n     */\n    this.overlays_ = optionsInternal.overlays;\n\n    /**\n     * A lookup of overlays by id.\n     * @private\n     * @type {Object<string, import(\"./Overlay.js\").default>}\n     */\n    this.overlayIdIndex_ = {};\n\n    /**\n     * @type {import(\"./renderer/Map.js\").default}\n     * @private\n     */\n    this.renderer_ = null;\n\n    /**\n     * @type {undefined|function(Event): void}\n     * @private\n     */\n    this.handleResize_;\n\n    /**\n     * @private\n     * @type {!Array<PostRenderFunction>}\n     */\n    this.postRenderFunctions_ = [];\n\n    /**\n     * @private\n     * @type {TileQueue}\n     */\n    this.tileQueue_ = new TileQueue(\n      this.getTilePriority.bind(this),\n      this.handleTileChange_.bind(this)\n    );\n\n    this.addEventListener(\n      getChangeEventType(MapProperty.LAYERGROUP),\n      this.handleLayerGroupChanged_\n    );\n    this.addEventListener(\n      getChangeEventType(MapProperty.VIEW),\n      this.handleViewChanged_\n    );\n    this.addEventListener(\n      getChangeEventType(MapProperty.SIZE),\n      this.handleSizeChanged_\n    );\n    this.addEventListener(\n      getChangeEventType(MapProperty.TARGET),\n      this.handleTargetChanged_\n    );\n\n    // setProperties will trigger the rendering of the map if the map\n    // is \"defined\" already.\n    this.setProperties(optionsInternal.values);\n\n    this.controls.forEach(\n      /**\n       * @param {import(\"./control/Control.js\").default} control Control.\n       * @this {PluggableMap}\n       */\n      function (control) {\n        control.setMap(this);\n      }.bind(this)\n    );\n\n    this.controls.addEventListener(\n      CollectionEventType.ADD,\n      /**\n       * @param {import(\"./Collection.js\").CollectionEvent} event CollectionEvent.\n       */\n      function (event) {\n        event.element.setMap(this);\n      }.bind(this)\n    );\n\n    this.controls.addEventListener(\n      CollectionEventType.REMOVE,\n      /**\n       * @param {import(\"./Collection.js\").CollectionEvent} event CollectionEvent.\n       */\n      function (event) {\n        event.element.setMap(null);\n      }.bind(this)\n    );\n\n    this.interactions.forEach(\n      /**\n       * @param {import(\"./interaction/Interaction.js\").default} interaction Interaction.\n       * @this {PluggableMap}\n       */\n      function (interaction) {\n        interaction.setMap(this);\n      }.bind(this)\n    );\n\n    this.interactions.addEventListener(\n      CollectionEventType.ADD,\n      /**\n       * @param {import(\"./Collection.js\").CollectionEvent} event CollectionEvent.\n       */\n      function (event) {\n        event.element.setMap(this);\n      }.bind(this)\n    );\n\n    this.interactions.addEventListener(\n      CollectionEventType.REMOVE,\n      /**\n       * @param {import(\"./Collection.js\").CollectionEvent} event CollectionEvent.\n       */\n      function (event) {\n        event.element.setMap(null);\n      }.bind(this)\n    );\n\n    this.overlays_.forEach(this.addOverlayInternal_.bind(this));\n\n    this.overlays_.addEventListener(\n      CollectionEventType.ADD,\n      /**\n       * @param {import(\"./Collection.js\").CollectionEvent} event CollectionEvent.\n       */\n      function (event) {\n        this.addOverlayInternal_(\n          /** @type {import(\"./Overlay.js\").default} */ (event.element)\n        );\n      }.bind(this)\n    );\n\n    this.overlays_.addEventListener(\n      CollectionEventType.REMOVE,\n      /**\n       * @param {import(\"./Collection.js\").CollectionEvent} event CollectionEvent.\n       */\n      function (event) {\n        const overlay = /** @type {import(\"./Overlay.js\").default} */ (event.element);\n        const id = overlay.getId();\n        if (id !== undefined) {\n          delete this.overlayIdIndex_[id.toString()];\n        }\n        event.element.setMap(null);\n      }.bind(this)\n    );\n  }\n\n  /**\n   * @abstract\n   * @return {import(\"./renderer/Map.js\").default} The map renderer\n   */\n  createRenderer() {\n    throw new Error('Use a map type that has a createRenderer method');\n  }\n\n  /**\n   * Add the given control to the map.\n   * @param {import(\"./control/Control.js\").default} control Control.\n   * @api\n   */\n  addControl(control) {\n    this.getControls().push(control);\n  }\n\n  /**\n   * Add the given interaction to the map. If you want to add an interaction\n   * at another point of the collection use `getInteraction()` and the methods\n   * available on {@link module:ol/Collection~Collection}. This can be used to\n   * stop the event propagation from the handleEvent function. The interactions\n   * get to handle the events in the reverse order of this collection.\n   * @param {import(\"./interaction/Interaction.js\").default} interaction Interaction to add.\n   * @api\n   */\n  addInteraction(interaction) {\n    this.getInteractions().push(interaction);\n  }\n\n  /**\n   * Adds the given layer to the top of this map. If you want to add a layer\n   * elsewhere in the stack, use `getLayers()` and the methods available on\n   * {@link module:ol/Collection~Collection}.\n   * @param {import(\"./layer/Base.js\").default} layer Layer.\n   * @api\n   */\n  addLayer(layer) {\n    const layers = this.getLayerGroup().getLayers();\n    layers.push(layer);\n  }\n\n  /**\n   * Add the given overlay to the map.\n   * @param {import(\"./Overlay.js\").default} overlay Overlay.\n   * @api\n   */\n  addOverlay(overlay) {\n    this.getOverlays().push(overlay);\n  }\n\n  /**\n   * This deals with map's overlay collection changes.\n   * @param {import(\"./Overlay.js\").default} overlay Overlay.\n   * @private\n   */\n  addOverlayInternal_(overlay) {\n    const id = overlay.getId();\n    if (id !== undefined) {\n      this.overlayIdIndex_[id.toString()] = overlay;\n    }\n    overlay.setMap(this);\n  }\n\n  /**\n   *\n   * Clean up.\n   */\n  disposeInternal() {\n    this.setTarget(null);\n    super.disposeInternal();\n  }\n\n  /**\n   * Detect features that intersect a pixel on the viewport, and execute a\n   * callback with each intersecting feature. Layers included in the detection can\n   * be configured through the `layerFilter` option in `opt_options`.\n   * @param {import(\"./pixel.js\").Pixel} pixel Pixel.\n   * @param {function(import(\"./Feature.js\").FeatureLike, import(\"./layer/Layer.js\").default, import(\"./geom/SimpleGeometry.js\").default): T} callback Feature callback. The callback will be\n   *     called with two arguments. The first argument is one\n   *     {@link module:ol/Feature feature} or\n   *     {@link module:ol/render/Feature render feature} at the pixel, the second is\n   *     the {@link module:ol/layer/Layer layer} of the feature and will be null for\n   *     unmanaged layers. To stop detection, callback functions can return a\n   *     truthy value.\n   * @param {AtPixelOptions=} opt_options Optional options.\n   * @return {T|undefined} Callback result, i.e. the return value of last\n   * callback execution, or the first truthy callback return value.\n   * @template S,T\n   * @api\n   */\n  forEachFeatureAtPixel(pixel, callback, opt_options) {\n    if (!this.frameState_) {\n      return;\n    }\n    const coordinate = this.getCoordinateFromPixelInternal(pixel);\n    opt_options = opt_options !== undefined ? opt_options : {};\n    const hitTolerance =\n      opt_options.hitTolerance !== undefined ? opt_options.hitTolerance : 0;\n    const layerFilter =\n      opt_options.layerFilter !== undefined ? opt_options.layerFilter : TRUE;\n    const checkWrapped = opt_options.checkWrapped !== false;\n    return this.renderer_.forEachFeatureAtCoordinate(\n      coordinate,\n      this.frameState_,\n      hitTolerance,\n      checkWrapped,\n      callback,\n      null,\n      layerFilter,\n      null\n    );\n  }\n\n  /**\n   * Get all features that intersect a pixel on the viewport.\n   * @param {import(\"./pixel.js\").Pixel} pixel Pixel.\n   * @param {AtPixelOptions=} opt_options Optional options.\n   * @return {Array<import(\"./Feature.js\").FeatureLike>} The detected features or\n   * an empty array if none were found.\n   * @api\n   */\n  getFeaturesAtPixel(pixel, opt_options) {\n    const features = [];\n    this.forEachFeatureAtPixel(\n      pixel,\n      function (feature) {\n        features.push(feature);\n      },\n      opt_options\n    );\n    return features;\n  }\n\n  /**\n   * Detect layers that have a color value at a pixel on the viewport, and\n   * execute a callback with each matching layer. Layers included in the\n   * detection can be configured through `opt_layerFilter`.\n   *\n   * Note: this may give false positives unless the map layers have had different `className`\n   * properties assigned to them.\n   *\n   * @param {import(\"./pixel.js\").Pixel} pixel Pixel.\n   * @param {function(this: S, import(\"./layer/Layer.js\").default, (Uint8ClampedArray|Uint8Array)): T} callback\n   *     Layer callback. This callback will receive two arguments: first is the\n   *     {@link module:ol/layer/Layer layer}, second argument is an array representing\n   *     [R, G, B, A] pixel values (0 - 255) and will be `null` for layer types\n   *     that do not currently support this argument. To stop detection, callback\n   *     functions can return a truthy value.\n   * @param {AtPixelOptions=} opt_options Configuration options.\n   * @return {T|undefined} Callback result, i.e. the return value of last\n   * callback execution, or the first truthy callback return value.\n   * @template S,T\n   * @api\n   */\n  forEachLayerAtPixel(pixel, callback, opt_options) {\n    if (!this.frameState_) {\n      return;\n    }\n    const options = opt_options || {};\n    const hitTolerance =\n      options.hitTolerance !== undefined ? options.hitTolerance : 0;\n    const layerFilter = options.layerFilter || TRUE;\n    return this.renderer_.forEachLayerAtPixel(\n      pixel,\n      this.frameState_,\n      hitTolerance,\n      callback,\n      layerFilter\n    );\n  }\n\n  /**\n   * Detect if features intersect a pixel on the viewport. Layers included in the\n   * detection can be configured through `opt_layerFilter`.\n   * @param {import(\"./pixel.js\").Pixel} pixel Pixel.\n   * @param {AtPixelOptions=} opt_options Optional options.\n   * @return {boolean} Is there a feature at the given pixel?\n   * @api\n   */\n  hasFeatureAtPixel(pixel, opt_options) {\n    if (!this.frameState_) {\n      return false;\n    }\n    const coordinate = this.getCoordinateFromPixelInternal(pixel);\n    opt_options = opt_options !== undefined ? opt_options : {};\n    const layerFilter =\n      opt_options.layerFilter !== undefined ? opt_options.layerFilter : TRUE;\n    const hitTolerance =\n      opt_options.hitTolerance !== undefined ? opt_options.hitTolerance : 0;\n    const checkWrapped = opt_options.checkWrapped !== false;\n    return this.renderer_.hasFeatureAtCoordinate(\n      coordinate,\n      this.frameState_,\n      hitTolerance,\n      checkWrapped,\n      layerFilter,\n      null\n    );\n  }\n\n  /**\n   * Returns the coordinate in user projection for a browser event.\n   * @param {MouseEvent} event Event.\n   * @return {import(\"./coordinate.js\").Coordinate} Coordinate.\n   * @api\n   */\n  getEventCoordinate(event) {\n    return this.getCoordinateFromPixel(this.getEventPixel(event));\n  }\n\n  /**\n   * Returns the coordinate in view projection for a browser event.\n   * @param {MouseEvent} event Event.\n   * @return {import(\"./coordinate.js\").Coordinate} Coordinate.\n   */\n  getEventCoordinateInternal(event) {\n    return this.getCoordinateFromPixelInternal(this.getEventPixel(event));\n  }\n\n  /**\n   * Returns the map pixel position for a browser event relative to the viewport.\n   * @param {UIEvent} event Event.\n   * @return {import(\"./pixel.js\").Pixel} Pixel.\n   * @api\n   */\n  getEventPixel(event) {\n    const viewportPosition = this.viewport_.getBoundingClientRect();\n    const eventPosition =\n      //FIXME Are we really calling this with a TouchEvent anywhere?\n      'changedTouches' in event\n        ? /** @type {TouchEvent} */ (event).changedTouches[0]\n        : /** @type {MouseEvent} */ (event);\n\n    return [\n      eventPosition.clientX - viewportPosition.left,\n      eventPosition.clientY - viewportPosition.top,\n    ];\n  }\n\n  /**\n   * Get the target in which this map is rendered.\n   * Note that this returns what is entered as an option or in setTarget:\n   * if that was an element, it returns an element; if a string, it returns that.\n   * @return {HTMLElement|string|undefined} The Element or id of the Element that the\n   *     map is rendered in.\n   * @observable\n   * @api\n   */\n  getTarget() {\n    return /** @type {HTMLElement|string|undefined} */ (this.get(\n      MapProperty.TARGET\n    ));\n  }\n\n  /**\n   * Get the DOM element into which this map is rendered. In contrast to\n   * `getTarget` this method always return an `Element`, or `null` if the\n   * map has no target.\n   * @return {HTMLElement} The element that the map is rendered in.\n   * @api\n   */\n  getTargetElement() {\n    const target = this.getTarget();\n    if (target !== undefined) {\n      return typeof target === 'string'\n        ? document.getElementById(target)\n        : target;\n    } else {\n      return null;\n    }\n  }\n\n  /**\n   * Get the coordinate for a given pixel.  This returns a coordinate in the\n   * user projection.\n   * @param {import(\"./pixel.js\").Pixel} pixel Pixel position in the map viewport.\n   * @return {import(\"./coordinate.js\").Coordinate} The coordinate for the pixel position.\n   * @api\n   */\n  getCoordinateFromPixel(pixel) {\n    return toUserCoordinate(\n      this.getCoordinateFromPixelInternal(pixel),\n      this.getView().getProjection()\n    );\n  }\n\n  /**\n   * Get the coordinate for a given pixel.  This returns a coordinate in the\n   * map view projection.\n   * @param {import(\"./pixel.js\").Pixel} pixel Pixel position in the map viewport.\n   * @return {import(\"./coordinate.js\").Coordinate} The coordinate for the pixel position.\n   */\n  getCoordinateFromPixelInternal(pixel) {\n    const frameState = this.frameState_;\n    if (!frameState) {\n      return null;\n    } else {\n      return applyTransform(\n        frameState.pixelToCoordinateTransform,\n        pixel.slice()\n      );\n    }\n  }\n\n  /**\n   * Get the map controls. Modifying this collection changes the controls\n   * associated with the map.\n   * @return {Collection<import(\"./control/Control.js\").default>} Controls.\n   * @api\n   */\n  getControls() {\n    return this.controls;\n  }\n\n  /**\n   * Get the map overlays. Modifying this collection changes the overlays\n   * associated with the map.\n   * @return {Collection<import(\"./Overlay.js\").default>} Overlays.\n   * @api\n   */\n  getOverlays() {\n    return this.overlays_;\n  }\n\n  /**\n   * Get an overlay by its identifier (the value returned by overlay.getId()).\n   * Note that the index treats string and numeric identifiers as the same. So\n   * `map.getOverlayById(2)` will return an overlay with id `'2'` or `2`.\n   * @param {string|number} id Overlay identifier.\n   * @return {import(\"./Overlay.js\").default} Overlay.\n   * @api\n   */\n  getOverlayById(id) {\n    const overlay = this.overlayIdIndex_[id.toString()];\n    return overlay !== undefined ? overlay : null;\n  }\n\n  /**\n   * Get the map interactions. Modifying this collection changes the interactions\n   * associated with the map.\n   *\n   * Interactions are used for e.g. pan, zoom and rotate.\n   * @return {Collection<import(\"./interaction/Interaction.js\").default>} Interactions.\n   * @api\n   */\n  getInteractions() {\n    return this.interactions;\n  }\n\n  /**\n   * Get the layergroup associated with this map.\n   * @return {LayerGroup} A layer group containing the layers in this map.\n   * @observable\n   * @api\n   */\n  getLayerGroup() {\n    return /** @type {LayerGroup} */ (this.get(MapProperty.LAYERGROUP));\n  }\n\n  /**\n   * Get the collection of layers associated with this map.\n   * @return {!Collection<import(\"./layer/Base.js\").default>} Layers.\n   * @api\n   */\n  getLayers() {\n    const layers = this.getLayerGroup().getLayers();\n    return layers;\n  }\n\n  /**\n   * @return {boolean} Layers have sources that are still loading.\n   */\n  getLoading() {\n    const layerStatesArray = this.getLayerGroup().getLayerStatesArray();\n    for (let i = 0, ii = layerStatesArray.length; i < ii; ++i) {\n      const layer = layerStatesArray[i].layer;\n      const source = /** @type {import(\"./layer/Layer.js\").default} */ (layer).getSource();\n      if (source && source.loading) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Get the pixel for a coordinate.  This takes a coordinate in the user\n   * projection and returns the corresponding pixel.\n   * @param {import(\"./coordinate.js\").Coordinate} coordinate A map coordinate.\n   * @return {import(\"./pixel.js\").Pixel} A pixel position in the map viewport.\n   * @api\n   */\n  getPixelFromCoordinate(coordinate) {\n    const viewCoordinate = fromUserCoordinate(\n      coordinate,\n      this.getView().getProjection()\n    );\n    return this.getPixelFromCoordinateInternal(viewCoordinate);\n  }\n\n  /**\n   * Get the pixel for a coordinate.  This takes a coordinate in the map view\n   * projection and returns the corresponding pixel.\n   * @param {import(\"./coordinate.js\").Coordinate} coordinate A map coordinate.\n   * @return {import(\"./pixel.js\").Pixel} A pixel position in the map viewport.\n   */\n  getPixelFromCoordinateInternal(coordinate) {\n    const frameState = this.frameState_;\n    if (!frameState) {\n      return null;\n    } else {\n      return applyTransform(\n        frameState.coordinateToPixelTransform,\n        coordinate.slice(0, 2)\n      );\n    }\n  }\n\n  /**\n   * Get the map renderer.\n   * @return {import(\"./renderer/Map.js\").default} Renderer\n   */\n  getRenderer() {\n    return this.renderer_;\n  }\n\n  /**\n   * Get the size of this map.\n   * @return {import(\"./size.js\").Size|undefined} The size in pixels of the map in the DOM.\n   * @observable\n   * @api\n   */\n  getSize() {\n    return /** @type {import(\"./size.js\").Size|undefined} */ (this.get(\n      MapProperty.SIZE\n    ));\n  }\n\n  /**\n   * Get the view associated with this map. A view manages properties such as\n   * center and resolution.\n   * @return {View} The view that controls this map.\n   * @observable\n   * @api\n   */\n  getView() {\n    return /** @type {View} */ (this.get(MapProperty.VIEW));\n  }\n\n  /**\n   * Get the element that serves as the map viewport.\n   * @return {HTMLElement} Viewport.\n   * @api\n   */\n  getViewport() {\n    return this.viewport_;\n  }\n\n  /**\n   * Get the element that serves as the container for overlays.  Elements added to\n   * this container will let mousedown and touchstart events through to the map,\n   * so clicks and gestures on an overlay will trigger {@link module:ol/MapBrowserEvent~MapBrowserEvent}\n   * events.\n   * @return {!HTMLElement} The map's overlay container.\n   */\n  getOverlayContainer() {\n    return this.overlayContainer_;\n  }\n\n  /**\n   * Get the element that serves as a container for overlays that don't allow\n   * event propagation. Elements added to this container won't let mousedown and\n   * touchstart events through to the map, so clicks and gestures on an overlay\n   * don't trigger any {@link module:ol/MapBrowserEvent~MapBrowserEvent}.\n   * @return {!HTMLElement} The map's overlay container that stops events.\n   */\n  getOverlayContainerStopEvent() {\n    return this.overlayContainerStopEvent_;\n  }\n\n  /**\n   * @return {!Document} The document where the map is displayed.\n   */\n  getOwnerDocument() {\n    return this.getTargetElement()\n      ? this.getTargetElement().ownerDocument\n      : document;\n  }\n\n  /**\n   * @param {import(\"./Tile.js\").default} tile Tile.\n   * @param {string} tileSourceKey Tile source key.\n   * @param {import(\"./coordinate.js\").Coordinate} tileCenter Tile center.\n   * @param {number} tileResolution Tile resolution.\n   * @return {number} Tile priority.\n   */\n  getTilePriority(tile, tileSourceKey, tileCenter, tileResolution) {\n    return getTilePriority(\n      this.frameState_,\n      tile,\n      tileSourceKey,\n      tileCenter,\n      tileResolution\n    );\n  }\n\n  /**\n   * @param {UIEvent} browserEvent Browser event.\n   * @param {string=} opt_type Type.\n   */\n  handleBrowserEvent(browserEvent, opt_type) {\n    const type = opt_type || browserEvent.type;\n    const mapBrowserEvent = new MapBrowserEvent(type, this, browserEvent);\n    this.handleMapBrowserEvent(mapBrowserEvent);\n  }\n\n  /**\n   * @param {MapBrowserEvent} mapBrowserEvent The event to handle.\n   */\n  handleMapBrowserEvent(mapBrowserEvent) {\n    if (!this.frameState_) {\n      // With no view defined, we cannot translate pixels into geographical\n      // coordinates so interactions cannot be used.\n      return;\n    }\n    const originalEvent = /** @type {PointerEvent} */ (mapBrowserEvent.originalEvent);\n    const eventType = originalEvent.type;\n    if (\n      eventType === PointerEventType.POINTERDOWN ||\n      eventType === EventType.WHEEL ||\n      eventType === EventType.KEYDOWN\n    ) {\n      const doc = this.getOwnerDocument();\n      const rootNode = this.viewport_.getRootNode\n        ? this.viewport_.getRootNode()\n        : doc;\n      const target =\n        'host' in rootNode // ShadowRoot\n          ? /** @type {ShadowRoot} */ (rootNode).elementFromPoint(\n              originalEvent.clientX,\n              originalEvent.clientY\n            )\n          : /** @type {Node} */ (originalEvent.target);\n      if (\n        // Abort if the target is a child of the container for elements whose events are not meant\n        // to be handled by map interactions.\n        this.overlayContainerStopEvent_.contains(target) ||\n        // Abort if the event target is a child of the container that is no longer in the page.\n        // It's possible for the target to no longer be in the page if it has been removed in an\n        // event listener, this might happen in a Control that recreates it's content based on\n        // user interaction either manually or via a render in something like https://reactjs.org/\n        !(rootNode === doc ? doc.documentElement : rootNode).contains(target)\n      ) {\n        return;\n      }\n    }\n    mapBrowserEvent.frameState = this.frameState_;\n    if (this.dispatchEvent(mapBrowserEvent) !== false) {\n      const interactionsArray = this.getInteractions().getArray().slice();\n      for (let i = interactionsArray.length - 1; i >= 0; i--) {\n        const interaction = interactionsArray[i];\n        if (\n          interaction.getMap() !== this ||\n          !interaction.getActive() ||\n          !this.getTargetElement()\n        ) {\n          continue;\n        }\n        const cont = interaction.handleEvent(mapBrowserEvent);\n        if (!cont || mapBrowserEvent.propagationStopped) {\n          break;\n        }\n      }\n    }\n  }\n\n  /**\n   * @protected\n   */\n  handlePostRender() {\n    const frameState = this.frameState_;\n\n    // Manage the tile queue\n    // Image loads are expensive and a limited resource, so try to use them\n    // efficiently:\n    // * When the view is static we allow a large number of parallel tile loads\n    //   to complete the frame as quickly as possible.\n    // * When animating or interacting, image loads can cause janks, so we reduce\n    //   the maximum number of loads per frame and limit the number of parallel\n    //   tile loads to remain reactive to view changes and to reduce the chance of\n    //   loading tiles that will quickly disappear from view.\n    const tileQueue = this.tileQueue_;\n    if (!tileQueue.isEmpty()) {\n      let maxTotalLoading = this.maxTilesLoading_;\n      let maxNewLoads = maxTotalLoading;\n      if (frameState) {\n        const hints = frameState.viewHints;\n        if (hints[ViewHint.ANIMATING] || hints[ViewHint.INTERACTING]) {\n          const lowOnFrameBudget =\n            !IMAGE_DECODE && Date.now() - frameState.time > 8;\n          maxTotalLoading = lowOnFrameBudget ? 0 : 8;\n          maxNewLoads = lowOnFrameBudget ? 0 : 2;\n        }\n      }\n      if (tileQueue.getTilesLoading() < maxTotalLoading) {\n        tileQueue.reprioritize(); // FIXME only call if view has changed\n        tileQueue.loadMoreTiles(maxTotalLoading, maxNewLoads);\n      }\n    }\n\n    if (\n      frameState &&\n      this.hasListener(RenderEventType.RENDERCOMPLETE) &&\n      !frameState.animate &&\n      !this.tileQueue_.getTilesLoading() &&\n      !this.getLoading()\n    ) {\n      this.renderer_.dispatchRenderEvent(\n        RenderEventType.RENDERCOMPLETE,\n        frameState\n      );\n    }\n\n    const postRenderFunctions = this.postRenderFunctions_;\n    for (let i = 0, ii = postRenderFunctions.length; i < ii; ++i) {\n      postRenderFunctions[i](this, frameState);\n    }\n    postRenderFunctions.length = 0;\n  }\n\n  /**\n   * @private\n   */\n  handleSizeChanged_() {\n    if (this.getView() && !this.getView().getAnimating()) {\n      this.getView().resolveConstraints(0);\n    }\n\n    this.render();\n  }\n\n  /**\n   * @private\n   */\n  handleTargetChanged_() {\n    // target may be undefined, null, a string or an Element.\n    // If it's a string we convert it to an Element before proceeding.\n    // If it's not now an Element we remove the viewport from the DOM.\n    // If it's an Element we append the viewport element to it.\n\n    let targetElement;\n    if (this.getTarget()) {\n      targetElement = this.getTargetElement();\n    }\n\n    if (this.mapBrowserEventHandler_) {\n      for (let i = 0, ii = this.keyHandlerKeys_.length; i < ii; ++i) {\n        unlistenByKey(this.keyHandlerKeys_[i]);\n      }\n      this.keyHandlerKeys_ = null;\n      this.viewport_.removeEventListener(\n        EventType.CONTEXTMENU,\n        this.boundHandleBrowserEvent_\n      );\n      this.viewport_.removeEventListener(\n        EventType.WHEEL,\n        this.boundHandleBrowserEvent_\n      );\n      if (this.handleResize_ !== undefined) {\n        removeEventListener(EventType.RESIZE, this.handleResize_, false);\n        this.handleResize_ = undefined;\n      }\n      this.mapBrowserEventHandler_.dispose();\n      this.mapBrowserEventHandler_ = null;\n      removeNode(this.viewport_);\n    }\n\n    if (!targetElement) {\n      if (this.renderer_) {\n        clearTimeout(this.postRenderTimeoutHandle_);\n        this.postRenderTimeoutHandle_ = undefined;\n        this.postRenderFunctions_.length = 0;\n        this.renderer_.dispose();\n        this.renderer_ = null;\n      }\n      if (this.animationDelayKey_) {\n        cancelAnimationFrame(this.animationDelayKey_);\n        this.animationDelayKey_ = undefined;\n      }\n    } else {\n      targetElement.appendChild(this.viewport_);\n      if (!this.renderer_) {\n        this.renderer_ = this.createRenderer();\n      }\n\n      this.mapBrowserEventHandler_ = new MapBrowserEventHandler(\n        this,\n        this.moveTolerance_\n      );\n      for (const key in MapBrowserEventType) {\n        this.mapBrowserEventHandler_.addEventListener(\n          MapBrowserEventType[key],\n          this.handleMapBrowserEvent.bind(this)\n        );\n      }\n      this.viewport_.addEventListener(\n        EventType.CONTEXTMENU,\n        this.boundHandleBrowserEvent_,\n        false\n      );\n      this.viewport_.addEventListener(\n        EventType.WHEEL,\n        this.boundHandleBrowserEvent_,\n        PASSIVE_EVENT_LISTENERS ? {passive: false} : false\n      );\n\n      const keyboardEventTarget = !this.keyboardEventTarget_\n        ? targetElement\n        : this.keyboardEventTarget_;\n      this.keyHandlerKeys_ = [\n        listen(\n          keyboardEventTarget,\n          EventType.KEYDOWN,\n          this.handleBrowserEvent,\n          this\n        ),\n        listen(\n          keyboardEventTarget,\n          EventType.KEYPRESS,\n          this.handleBrowserEvent,\n          this\n        ),\n      ];\n\n      if (!this.handleResize_) {\n        this.handleResize_ = this.updateSize.bind(this);\n        window.addEventListener(EventType.RESIZE, this.handleResize_, false);\n      }\n    }\n\n    this.updateSize();\n    // updateSize calls setSize, so no need to call this.render\n    // ourselves here.\n  }\n\n  /**\n   * @private\n   */\n  handleTileChange_() {\n    this.render();\n  }\n\n  /**\n   * @private\n   */\n  handleViewPropertyChanged_() {\n    this.render();\n  }\n\n  /**\n   * @private\n   */\n  handleViewChanged_() {\n    if (this.viewPropertyListenerKey_) {\n      unlistenByKey(this.viewPropertyListenerKey_);\n      this.viewPropertyListenerKey_ = null;\n    }\n    if (this.viewChangeListenerKey_) {\n      unlistenByKey(this.viewChangeListenerKey_);\n      this.viewChangeListenerKey_ = null;\n    }\n    const view = this.getView();\n    if (view) {\n      this.updateViewportSize_();\n\n      this.viewPropertyListenerKey_ = listen(\n        view,\n        ObjectEventType.PROPERTYCHANGE,\n        this.handleViewPropertyChanged_,\n        this\n      );\n      this.viewChangeListenerKey_ = listen(\n        view,\n        EventType.CHANGE,\n        this.handleViewPropertyChanged_,\n        this\n      );\n\n      view.resolveConstraints(0);\n    }\n    this.render();\n  }\n\n  /**\n   * @private\n   */\n  handleLayerGroupChanged_() {\n    if (this.layerGroupPropertyListenerKeys_) {\n      this.layerGroupPropertyListenerKeys_.forEach(unlistenByKey);\n      this.layerGroupPropertyListenerKeys_ = null;\n    }\n    const layerGroup = this.getLayerGroup();\n    if (layerGroup) {\n      this.layerGroupPropertyListenerKeys_ = [\n        listen(layerGroup, ObjectEventType.PROPERTYCHANGE, this.render, this),\n        listen(layerGroup, EventType.CHANGE, this.render, this),\n      ];\n    }\n    this.render();\n  }\n\n  /**\n   * @return {boolean} Is rendered.\n   */\n  isRendered() {\n    return !!this.frameState_;\n  }\n\n  /**\n   * Requests an immediate render in a synchronous manner.\n   * @api\n   */\n  renderSync() {\n    if (this.animationDelayKey_) {\n      cancelAnimationFrame(this.animationDelayKey_);\n    }\n    this.animationDelay_();\n  }\n\n  /**\n   * Redraws all text after new fonts have loaded\n   */\n  redrawText() {\n    const layerStates = this.getLayerGroup().getLayerStatesArray();\n    for (let i = 0, ii = layerStates.length; i < ii; ++i) {\n      const layer = layerStates[i].layer;\n      if (layer.hasRenderer()) {\n        layer.getRenderer().handleFontsChanged();\n      }\n    }\n  }\n\n  /**\n   * Request a map rendering (at the next animation frame).\n   * @api\n   */\n  render() {\n    if (this.renderer_ && this.animationDelayKey_ === undefined) {\n      this.animationDelayKey_ = requestAnimationFrame(this.animationDelay_);\n    }\n  }\n\n  /**\n   * Remove the given control from the map.\n   * @param {import(\"./control/Control.js\").default} control Control.\n   * @return {import(\"./control/Control.js\").default|undefined} The removed control (or undefined\n   *     if the control was not found).\n   * @api\n   */\n  removeControl(control) {\n    return this.getControls().remove(control);\n  }\n\n  /**\n   * Remove the given interaction from the map.\n   * @param {import(\"./interaction/Interaction.js\").default} interaction Interaction to remove.\n   * @return {import(\"./interaction/Interaction.js\").default|undefined} The removed interaction (or\n   *     undefined if the interaction was not found).\n   * @api\n   */\n  removeInteraction(interaction) {\n    return this.getInteractions().remove(interaction);\n  }\n\n  /**\n   * Removes the given layer from the map.\n   * @param {import(\"./layer/Base.js\").default} layer Layer.\n   * @return {import(\"./layer/Base.js\").default|undefined} The removed layer (or undefined if the\n   *     layer was not found).\n   * @api\n   */\n  removeLayer(layer) {\n    const layers = this.getLayerGroup().getLayers();\n    return layers.remove(layer);\n  }\n\n  /**\n   * Remove the given overlay from the map.\n   * @param {import(\"./Overlay.js\").default} overlay Overlay.\n   * @return {import(\"./Overlay.js\").default|undefined} The removed overlay (or undefined\n   *     if the overlay was not found).\n   * @api\n   */\n  removeOverlay(overlay) {\n    return this.getOverlays().remove(overlay);\n  }\n\n  /**\n   * @param {number} time Time.\n   * @private\n   */\n  renderFrame_(time) {\n    const size = this.getSize();\n    const view = this.getView();\n    const previousFrameState = this.frameState_;\n    /** @type {?FrameState} */\n    let frameState = null;\n    if (size !== undefined && hasArea(size) && view && view.isDef()) {\n      const viewHints = view.getHints(\n        this.frameState_ ? this.frameState_.viewHints : undefined\n      );\n      const viewState = view.getState();\n      frameState = {\n        animate: false,\n        coordinateToPixelTransform: this.coordinateToPixelTransform_,\n        declutterTree: null,\n        extent: getForViewAndSize(\n          viewState.center,\n          viewState.resolution,\n          viewState.rotation,\n          size\n        ),\n        index: this.frameIndex_++,\n        layerIndex: 0,\n        layerStatesArray: this.getLayerGroup().getLayerStatesArray(),\n        pixelRatio: this.pixelRatio_,\n        pixelToCoordinateTransform: this.pixelToCoordinateTransform_,\n        postRenderFunctions: [],\n        size: size,\n        tileQueue: this.tileQueue_,\n        time: time,\n        usedTiles: {},\n        viewState: viewState,\n        viewHints: viewHints,\n        wantedTiles: {},\n      };\n    }\n\n    this.frameState_ = frameState;\n    this.renderer_.renderFrame(frameState);\n\n    if (frameState) {\n      if (frameState.animate) {\n        this.render();\n      }\n      Array.prototype.push.apply(\n        this.postRenderFunctions_,\n        frameState.postRenderFunctions\n      );\n\n      if (previousFrameState) {\n        const moveStart =\n          !this.previousExtent_ ||\n          (!isEmpty(this.previousExtent_) &&\n            !equals(frameState.extent, this.previousExtent_));\n        if (moveStart) {\n          this.dispatchEvent(\n            new MapEvent(MapEventType.MOVESTART, this, previousFrameState)\n          );\n          this.previousExtent_ = createOrUpdateEmpty(this.previousExtent_);\n        }\n      }\n\n      const idle =\n        this.previousExtent_ &&\n        !frameState.viewHints[ViewHint.ANIMATING] &&\n        !frameState.viewHints[ViewHint.INTERACTING] &&\n        !equals(frameState.extent, this.previousExtent_);\n\n      if (idle) {\n        this.dispatchEvent(\n          new MapEvent(MapEventType.MOVEEND, this, frameState)\n        );\n        clone(frameState.extent, this.previousExtent_);\n      }\n    }\n\n    this.dispatchEvent(new MapEvent(MapEventType.POSTRENDER, this, frameState));\n\n    if (!this.postRenderTimeoutHandle_) {\n      this.postRenderTimeoutHandle_ = setTimeout(() => {\n        this.postRenderTimeoutHandle_ = undefined;\n        this.handlePostRender();\n      }, 0);\n    }\n  }\n\n  /**\n   * Sets the layergroup of this map.\n   * @param {LayerGroup} layerGroup A layer group containing the layers in this map.\n   * @observable\n   * @api\n   */\n  setLayerGroup(layerGroup) {\n    this.set(MapProperty.LAYERGROUP, layerGroup);\n  }\n\n  /**\n   * Set the size of this map.\n   * @param {import(\"./size.js\").Size|undefined} size The size in pixels of the map in the DOM.\n   * @observable\n   * @api\n   */\n  setSize(size) {\n    this.set(MapProperty.SIZE, size);\n  }\n\n  /**\n   * Set the target element to render this map into.\n   * @param {HTMLElement|string|undefined} target The Element or id of the Element\n   *     that the map is rendered in.\n   * @observable\n   * @api\n   */\n  setTarget(target) {\n    this.set(MapProperty.TARGET, target);\n  }\n\n  /**\n   * Set the view for this map.\n   * @param {View} view The view that controls this map.\n   * @observable\n   * @api\n   */\n  setView(view) {\n    this.set(MapProperty.VIEW, view);\n  }\n\n  /**\n   * Force a recalculation of the map viewport size.  This should be called when\n   * third-party code changes the size of the map viewport.\n   * @api\n   */\n  updateSize() {\n    const targetElement = this.getTargetElement();\n\n    if (!targetElement) {\n      this.setSize(undefined);\n    } else {\n      const computedStyle = getComputedStyle(targetElement);\n      this.setSize([\n        targetElement.offsetWidth -\n          parseFloat(computedStyle['borderLeftWidth']) -\n          parseFloat(computedStyle['paddingLeft']) -\n          parseFloat(computedStyle['paddingRight']) -\n          parseFloat(computedStyle['borderRightWidth']),\n        targetElement.offsetHeight -\n          parseFloat(computedStyle['borderTopWidth']) -\n          parseFloat(computedStyle['paddingTop']) -\n          parseFloat(computedStyle['paddingBottom']) -\n          parseFloat(computedStyle['borderBottomWidth']),\n      ]);\n    }\n\n    this.updateViewportSize_();\n  }\n\n  /**\n   * Recomputes the viewport size and save it on the view object (if any)\n   * @private\n   */\n  updateViewportSize_() {\n    const view = this.getView();\n    if (view) {\n      let size = undefined;\n      const computedStyle = getComputedStyle(this.viewport_);\n      if (computedStyle.width && computedStyle.height) {\n        size = [\n          parseInt(computedStyle.width, 10),\n          parseInt(computedStyle.height, 10),\n        ];\n      }\n      view.setViewportSize(size);\n    }\n  }\n}\n\n/**\n * @param {MapOptions} options Map options.\n * @return {MapOptionsInternal} Internal map options.\n */\nfunction createOptionsInternal(options) {\n  /**\n   * @type {HTMLElement|Document}\n   */\n  let keyboardEventTarget = null;\n  if (options.keyboardEventTarget !== undefined) {\n    keyboardEventTarget =\n      typeof options.keyboardEventTarget === 'string'\n        ? document.getElementById(options.keyboardEventTarget)\n        : options.keyboardEventTarget;\n  }\n\n  /**\n   * @type {Object<string, *>}\n   */\n  const values = {};\n\n  const layerGroup =\n    options.layers &&\n    typeof (/** @type {?} */ (options.layers).getLayers) === 'function'\n      ? /** @type {LayerGroup} */ (options.layers)\n      : new LayerGroup({layers: /** @type {Collection} */ (options.layers)});\n  values[MapProperty.LAYERGROUP] = layerGroup;\n\n  values[MapProperty.TARGET] = options.target;\n\n  values[MapProperty.VIEW] =\n    options.view !== undefined ? options.view : new View();\n\n  let controls;\n  if (options.controls !== undefined) {\n    if (Array.isArray(options.controls)) {\n      controls = new Collection(options.controls.slice());\n    } else {\n      assert(\n        typeof (/** @type {?} */ (options.controls).getArray) === 'function',\n        47\n      ); // Expected `controls` to be an array or an `import(\"./Collection.js\").Collection`\n      controls = /** @type {Collection} */ (options.controls);\n    }\n  }\n\n  let interactions;\n  if (options.interactions !== undefined) {\n    if (Array.isArray(options.interactions)) {\n      interactions = new Collection(options.interactions.slice());\n    } else {\n      assert(\n        typeof (/** @type {?} */ (options.interactions).getArray) ===\n          'function',\n        48\n      ); // Expected `interactions` to be an array or an `import(\"./Collection.js\").Collection`\n      interactions = /** @type {Collection} */ (options.interactions);\n    }\n  }\n\n  let overlays;\n  if (options.overlays !== undefined) {\n    if (Array.isArray(options.overlays)) {\n      overlays = new Collection(options.overlays.slice());\n    } else {\n      assert(\n        typeof (/** @type {?} */ (options.overlays).getArray) === 'function',\n        49\n      ); // Expected `overlays` to be an array or an `import(\"./Collection.js\").Collection`\n      overlays = options.overlays;\n    }\n  } else {\n    overlays = new Collection();\n  }\n\n  return {\n    controls: controls,\n    interactions: interactions,\n    keyboardEventTarget: keyboardEventTarget,\n    overlays: overlays,\n    values: values,\n  };\n}\nexport default PluggableMap;\n","/**\n * @module ol/interaction/Property\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  ACTIVE: 'active',\n};\n","/**\n * @module ol/interaction/Interaction\n */\nimport BaseObject from '../Object.js';\nimport InteractionProperty from './Property.js';\nimport {easeOut, linear} from '../easing.js';\n\n/**\n * Object literal with config options for interactions.\n * @typedef {Object} InteractionOptions\n * @property {function(import(\"../MapBrowserEvent.js\").default):boolean} handleEvent\n * Method called by the map to notify the interaction that a browser event was\n * dispatched to the map. If the function returns a falsy value, propagation of\n * the event to other interactions in the map's interactions chain will be\n * prevented (this includes functions with no explicit return). The interactions\n * are traversed in reverse order of the interactions collection of the map.\n */\n\n/**\n * @classdesc\n * Abstract base class; normally only used for creating subclasses and not\n * instantiated in apps.\n * User actions that change the state of the map. Some are similar to controls,\n * but are not associated with a DOM element.\n * For example, {@link module:ol/interaction/KeyboardZoom~KeyboardZoom} is\n * functionally the same as {@link module:ol/control/Zoom~Zoom}, but triggered\n * by a keyboard event not a button element event.\n * Although interactions do not have a DOM element, some of them do render\n * vectors and so are visible on the screen.\n * @api\n */\nclass Interaction extends BaseObject {\n  /**\n   * @param {InteractionOptions=} opt_options Options.\n   */\n  constructor(opt_options) {\n    super();\n\n    if (opt_options && opt_options.handleEvent) {\n      this.handleEvent = opt_options.handleEvent;\n    }\n\n    /**\n     * @private\n     * @type {import(\"../PluggableMap.js\").default}\n     */\n    this.map_ = null;\n\n    this.setActive(true);\n  }\n\n  /**\n   * Return whether the interaction is currently active.\n   * @return {boolean} `true` if the interaction is active, `false` otherwise.\n   * @observable\n   * @api\n   */\n  getActive() {\n    return /** @type {boolean} */ (this.get(InteractionProperty.ACTIVE));\n  }\n\n  /**\n   * Get the map associated with this interaction.\n   * @return {import(\"../PluggableMap.js\").default} Map.\n   * @api\n   */\n  getMap() {\n    return this.map_;\n  }\n\n  /**\n   * Handles the {@link module:ol/MapBrowserEvent map browser event}.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n   * @return {boolean} `false` to stop event propagation.\n   * @api\n   */\n  handleEvent(mapBrowserEvent) {\n    return true;\n  }\n\n  /**\n   * Activate or deactivate the interaction.\n   * @param {boolean} active Active.\n   * @observable\n   * @api\n   */\n  setActive(active) {\n    this.set(InteractionProperty.ACTIVE, active);\n  }\n\n  /**\n   * Remove the interaction from its current map and attach it to the new map.\n   * Subclasses may set up event handlers to get notified about changes to\n   * the map here.\n   * @param {import(\"../PluggableMap.js\").default} map Map.\n   */\n  setMap(map) {\n    this.map_ = map;\n  }\n}\n\n/**\n * @param {import(\"../View.js\").default} view View.\n * @param {import(\"../coordinate.js\").Coordinate} delta Delta.\n * @param {number=} opt_duration Duration.\n */\nexport function pan(view, delta, opt_duration) {\n  const currentCenter = view.getCenterInternal();\n  if (currentCenter) {\n    const center = [currentCenter[0] + delta[0], currentCenter[1] + delta[1]];\n    view.animateInternal({\n      duration: opt_duration !== undefined ? opt_duration : 250,\n      easing: linear,\n      center: view.getConstrainedCenter(center),\n    });\n  }\n}\n\n/**\n * @param {import(\"../View.js\").default} view View.\n * @param {number} delta Delta from previous zoom level.\n * @param {import(\"../coordinate.js\").Coordinate=} opt_anchor Anchor coordinate in the user projection.\n * @param {number=} opt_duration Duration.\n */\nexport function zoomByDelta(view, delta, opt_anchor, opt_duration) {\n  const currentZoom = view.getZoom();\n\n  if (currentZoom === undefined) {\n    return;\n  }\n\n  const newZoom = view.getConstrainedZoom(currentZoom + delta);\n  const newResolution = view.getResolutionForZoom(newZoom);\n\n  if (view.getAnimating()) {\n    view.cancelAnimations();\n  }\n  view.animate({\n    resolution: newResolution,\n    anchor: opt_anchor,\n    duration: opt_duration !== undefined ? opt_duration : 250,\n    easing: easeOut,\n  });\n}\n\nexport default Interaction;\n","/**\n * @module ol/interaction/DoubleClickZoom\n */\nimport Interaction, {zoomByDelta} from './Interaction.js';\nimport MapBrowserEventType from '../MapBrowserEventType.js';\n\n/**\n * @typedef {Object} Options\n * @property {number} [duration=250] Animation duration in milliseconds.\n * @property {number} [delta=1] The zoom delta applied on each double click.\n */\n\n/**\n * @classdesc\n * Allows the user to zoom by double-clicking on the map.\n * @api\n */\nclass DoubleClickZoom extends Interaction {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    super();\n\n    const options = opt_options ? opt_options : {};\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.delta_ = options.delta ? options.delta : 1;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.duration_ = options.duration !== undefined ? options.duration : 250;\n  }\n\n  /**\n   * Handles the {@link module:ol/MapBrowserEvent map browser event} (if it was a\n   * doubleclick) and eventually zooms the map.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n   * @return {boolean} `false` to stop event propagation.\n   */\n  handleEvent(mapBrowserEvent) {\n    let stopEvent = false;\n    if (mapBrowserEvent.type == MapBrowserEventType.DBLCLICK) {\n      const browserEvent = /** @type {MouseEvent} */ (mapBrowserEvent.originalEvent);\n      const map = mapBrowserEvent.map;\n      const anchor = mapBrowserEvent.coordinate;\n      const delta = browserEvent.shiftKey ? -this.delta_ : this.delta_;\n      const view = map.getView();\n      zoomByDelta(view, delta, anchor, this.duration_);\n      browserEvent.preventDefault();\n      stopEvent = true;\n    }\n    return !stopEvent;\n  }\n}\n\nexport default DoubleClickZoom;\n","/**\n * @module ol/interaction/Pointer\n */\nimport Interaction from './Interaction.js';\nimport MapBrowserEventType from '../MapBrowserEventType.js';\nimport {getValues} from '../obj.js';\n\n/**\n * @typedef {Object} Options\n * @property {function(import(\"../MapBrowserEvent.js\").default):boolean} [handleDownEvent]\n * Function handling \"down\" events. If the function returns `true` then a drag\n * sequence is started.\n * @property {function(import(\"../MapBrowserEvent.js\").default):void} [handleDragEvent]\n * Function handling \"drag\" events. This function is called on \"move\" events\n * during a drag sequence.\n * @property {function(import(\"../MapBrowserEvent.js\").default):boolean} [handleEvent]\n * Method called by the map to notify the interaction that a browser event was\n * dispatched to the map. The function may return `false` to prevent the\n * propagation of the event to other interactions in the map's interactions\n * chain.\n * @property {function(import(\"../MapBrowserEvent.js\").default):void} [handleMoveEvent]\n * Function handling \"move\" events. This function is called on \"move\" events.\n * This functions is also called during a drag sequence, so during a drag\n * sequence both the `handleDragEvent` function and this function are called.\n * If `handleDownEvent` is defined and it returns true this function will not\n * be called during a drag sequence.\n * @property {function(import(\"../MapBrowserEvent.js\").default):boolean} [handleUpEvent]\n *  Function handling \"up\" events. If the function returns `false` then the\n * current drag sequence is stopped.\n * @property {function(boolean):boolean} [stopDown]\n * Should the down event be propagated to other interactions, or should be\n * stopped?\n */\n\n/**\n * @classdesc\n * Base class that calls user-defined functions on `down`, `move` and `up`\n * events. This class also manages \"drag sequences\".\n *\n * When the `handleDownEvent` user function returns `true` a drag sequence is\n * started. During a drag sequence the `handleDragEvent` user function is\n * called on `move` events. The drag sequence ends when the `handleUpEvent`\n * user function is called and returns `false`.\n * @api\n */\nclass PointerInteraction extends Interaction {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    super(\n      /** @type {import(\"./Interaction.js\").InteractionOptions} */ (options)\n    );\n\n    if (options.handleDownEvent) {\n      this.handleDownEvent = options.handleDownEvent;\n    }\n\n    if (options.handleDragEvent) {\n      this.handleDragEvent = options.handleDragEvent;\n    }\n\n    if (options.handleMoveEvent) {\n      this.handleMoveEvent = options.handleMoveEvent;\n    }\n\n    if (options.handleUpEvent) {\n      this.handleUpEvent = options.handleUpEvent;\n    }\n\n    if (options.stopDown) {\n      this.stopDown = options.stopDown;\n    }\n\n    /**\n     * @type {boolean}\n     * @protected\n     */\n    this.handlingDownUpSequence = false;\n\n    /**\n     * @type {!Object<string, PointerEvent>}\n     * @private\n     */\n    this.trackedPointers_ = {};\n\n    /**\n     * @type {Array<PointerEvent>}\n     * @protected\n     */\n    this.targetPointers = [];\n  }\n\n  /**\n   * Returns the current number of pointers involved in the interaction,\n   * e.g. `2` when two fingers are used.\n   * @return {number} The number of pointers.\n   * @api\n   */\n  getPointerCount() {\n    return this.targetPointers.length;\n  }\n\n  /**\n   * Handle pointer down events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   * @protected\n   */\n  handleDownEvent(mapBrowserEvent) {\n    return false;\n  }\n\n  /**\n   * Handle pointer drag events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @protected\n   */\n  handleDragEvent(mapBrowserEvent) {}\n\n  /**\n   * Handles the {@link module:ol/MapBrowserEvent map browser event} and may call into\n   * other functions, if event sequences like e.g. 'drag' or 'down-up' etc. are\n   * detected.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n   * @return {boolean} `false` to stop event propagation.\n   * @api\n   */\n  handleEvent(mapBrowserEvent) {\n    if (!mapBrowserEvent.originalEvent) {\n      return true;\n    }\n\n    let stopEvent = false;\n    this.updateTrackedPointers_(mapBrowserEvent);\n    if (this.handlingDownUpSequence) {\n      if (mapBrowserEvent.type == MapBrowserEventType.POINTERDRAG) {\n        this.handleDragEvent(mapBrowserEvent);\n        // prevent page scrolling during dragging\n        mapBrowserEvent.originalEvent.preventDefault();\n      } else if (mapBrowserEvent.type == MapBrowserEventType.POINTERUP) {\n        const handledUp = this.handleUpEvent(mapBrowserEvent);\n        this.handlingDownUpSequence =\n          handledUp && this.targetPointers.length > 0;\n      }\n    } else {\n      if (mapBrowserEvent.type == MapBrowserEventType.POINTERDOWN) {\n        const handled = this.handleDownEvent(mapBrowserEvent);\n        this.handlingDownUpSequence = handled;\n        stopEvent = this.stopDown(handled);\n      } else if (mapBrowserEvent.type == MapBrowserEventType.POINTERMOVE) {\n        this.handleMoveEvent(mapBrowserEvent);\n      }\n    }\n    return !stopEvent;\n  }\n\n  /**\n   * Handle pointer move events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @protected\n   */\n  handleMoveEvent(mapBrowserEvent) {}\n\n  /**\n   * Handle pointer up events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   * @protected\n   */\n  handleUpEvent(mapBrowserEvent) {\n    return false;\n  }\n\n  /**\n   * This function is used to determine if \"down\" events should be propagated\n   * to other interactions or should be stopped.\n   * @param {boolean} handled Was the event handled by the interaction?\n   * @return {boolean} Should the `down` event be stopped?\n   */\n  stopDown(handled) {\n    return handled;\n  }\n\n  /**\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @private\n   */\n  updateTrackedPointers_(mapBrowserEvent) {\n    if (isPointerDraggingEvent(mapBrowserEvent)) {\n      const event = mapBrowserEvent.originalEvent;\n\n      const id = event.pointerId.toString();\n      if (mapBrowserEvent.type == MapBrowserEventType.POINTERUP) {\n        delete this.trackedPointers_[id];\n      } else if (mapBrowserEvent.type == MapBrowserEventType.POINTERDOWN) {\n        this.trackedPointers_[id] = event;\n      } else if (id in this.trackedPointers_) {\n        // update only when there was a pointerdown event for this pointer\n        this.trackedPointers_[id] = event;\n      }\n      this.targetPointers = getValues(this.trackedPointers_);\n    }\n  }\n}\n\n/**\n * @param {Array<PointerEvent>} pointerEvents List of events.\n * @return {import(\"../pixel.js\").Pixel} Centroid pixel.\n */\nexport function centroid(pointerEvents) {\n  const length = pointerEvents.length;\n  let clientX = 0;\n  let clientY = 0;\n  for (let i = 0; i < length; i++) {\n    clientX += pointerEvents[i].clientX;\n    clientY += pointerEvents[i].clientY;\n  }\n  return [clientX / length, clientY / length];\n}\n\n/**\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n * @return {boolean} Whether the event is a pointerdown, pointerdrag\n *     or pointerup event.\n */\nfunction isPointerDraggingEvent(mapBrowserEvent) {\n  const type = mapBrowserEvent.type;\n  return (\n    type === MapBrowserEventType.POINTERDOWN ||\n    type === MapBrowserEventType.POINTERDRAG ||\n    type === MapBrowserEventType.POINTERUP\n  );\n}\n\nexport default PointerInteraction;\n","/**\n * @module ol/events/condition\n */\nimport MapBrowserEventType from '../MapBrowserEventType.js';\nimport {FALSE, TRUE} from '../functions.js';\nimport {MAC, WEBKIT} from '../has.js';\nimport {assert} from '../asserts.js';\n\n/**\n * A function that takes an {@link module:ol/MapBrowserEvent} and returns a\n * `{boolean}`. If the condition is met, true should be returned.\n *\n * @typedef {function(this: ?, import(\"../MapBrowserEvent.js\").default): boolean} Condition\n */\n\n/**\n * Creates a condition function that passes when all provided conditions pass.\n * @param {...Condition} var_args Conditions to check.\n * @return {Condition} Condition function.\n */\nexport function all(var_args) {\n  const conditions = arguments;\n  /**\n   * @param {import(\"../MapBrowserEvent.js\").default} event Event.\n   * @return {boolean} All conditions passed.\n   */\n  return function (event) {\n    let pass = true;\n    for (let i = 0, ii = conditions.length; i < ii; ++i) {\n      pass = pass && conditions[i](event);\n      if (!pass) {\n        break;\n      }\n    }\n    return pass;\n  };\n}\n\n/**\n * Return `true` if only the alt-key is pressed, `false` otherwise (e.g. when\n * additionally the shift-key is pressed).\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if only the alt key is pressed.\n * @api\n */\nexport const altKeyOnly = function (mapBrowserEvent) {\n  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (mapBrowserEvent.originalEvent);\n  return (\n    originalEvent.altKey &&\n    !(originalEvent.metaKey || originalEvent.ctrlKey) &&\n    !originalEvent.shiftKey\n  );\n};\n\n/**\n * Return `true` if only the alt-key and shift-key is pressed, `false` otherwise\n * (e.g. when additionally the platform-modifier-key is pressed).\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if only the alt and shift keys are pressed.\n * @api\n */\nexport const altShiftKeysOnly = function (mapBrowserEvent) {\n  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (mapBrowserEvent.originalEvent);\n  return (\n    originalEvent.altKey &&\n    !(originalEvent.metaKey || originalEvent.ctrlKey) &&\n    originalEvent.shiftKey\n  );\n};\n\n/**\n * Return `true` if the map has the focus. This condition requires a map target\n * element with a `tabindex` attribute, e.g. `<div id=\"map\" tabindex=\"1\">`.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} event Map browser event.\n * @return {boolean} The map has the focus.\n * @api\n */\nexport const focus = function (event) {\n  return event.target.getTargetElement().contains(document.activeElement);\n};\n\n/**\n * Return `true` if the map has the focus or no 'tabindex' attribute set.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} event Map browser event.\n * @return {boolean} The map container has the focus or no 'tabindex' attribute.\n */\nexport const focusWithTabindex = function (event) {\n  return event.map.getTargetElement().hasAttribute('tabindex')\n    ? focus(event)\n    : true;\n};\n\n/**\n * Return always true.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True.\n * @api\n */\nexport const always = TRUE;\n\n/**\n * Return `true` if the event is a `click` event, `false` otherwise.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if the event is a map `click` event.\n * @api\n */\nexport const click = function (mapBrowserEvent) {\n  return mapBrowserEvent.type == MapBrowserEventType.CLICK;\n};\n\n/**\n * Return `true` if the event has an \"action\"-producing mouse button.\n *\n * By definition, this includes left-click on windows/linux, and left-click\n * without the ctrl key on Macs.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} The result.\n */\nexport const mouseActionButton = function (mapBrowserEvent) {\n  const originalEvent = /** @type {MouseEvent} */ (mapBrowserEvent.originalEvent);\n  return originalEvent.button == 0 && !(WEBKIT && MAC && originalEvent.ctrlKey);\n};\n\n/**\n * Return always false.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} False.\n * @api\n */\nexport const never = FALSE;\n\n/**\n * Return `true` if the browser event is a `pointermove` event, `false`\n * otherwise.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if the browser event is a `pointermove` event.\n * @api\n */\nexport const pointerMove = function (mapBrowserEvent) {\n  return mapBrowserEvent.type == 'pointermove';\n};\n\n/**\n * Return `true` if the event is a map `singleclick` event, `false` otherwise.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if the event is a map `singleclick` event.\n * @api\n */\nexport const singleClick = function (mapBrowserEvent) {\n  return mapBrowserEvent.type == MapBrowserEventType.SINGLECLICK;\n};\n\n/**\n * Return `true` if the event is a map `dblclick` event, `false` otherwise.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if the event is a map `dblclick` event.\n * @api\n */\nexport const doubleClick = function (mapBrowserEvent) {\n  return mapBrowserEvent.type == MapBrowserEventType.DBLCLICK;\n};\n\n/**\n * Return `true` if no modifier key (alt-, shift- or platform-modifier-key) is\n * pressed.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True only if there no modifier keys are pressed.\n * @api\n */\nexport const noModifierKeys = function (mapBrowserEvent) {\n  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (mapBrowserEvent.originalEvent);\n  return (\n    !originalEvent.altKey &&\n    !(originalEvent.metaKey || originalEvent.ctrlKey) &&\n    !originalEvent.shiftKey\n  );\n};\n\n/**\n * Return `true` if only the platform-modifier-key (the meta-key on Mac,\n * ctrl-key otherwise) is pressed, `false` otherwise (e.g. when additionally\n * the shift-key is pressed).\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if only the platform modifier key is pressed.\n * @api\n */\nexport const platformModifierKeyOnly = function (mapBrowserEvent) {\n  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (mapBrowserEvent.originalEvent);\n  return (\n    !originalEvent.altKey &&\n    (MAC ? originalEvent.metaKey : originalEvent.ctrlKey) &&\n    !originalEvent.shiftKey\n  );\n};\n\n/**\n * Return `true` if only the shift-key is pressed, `false` otherwise (e.g. when\n * additionally the alt-key is pressed).\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if only the shift key is pressed.\n * @api\n */\nexport const shiftKeyOnly = function (mapBrowserEvent) {\n  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (mapBrowserEvent.originalEvent);\n  return (\n    !originalEvent.altKey &&\n    !(originalEvent.metaKey || originalEvent.ctrlKey) &&\n    originalEvent.shiftKey\n  );\n};\n\n/**\n * Return `true` if the target element is not editable, i.e. not a `<input>`-,\n * `<select>`- or `<textarea>`-element, `false` otherwise.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True only if the target element is not editable.\n * @api\n */\nexport const targetNotEditable = function (mapBrowserEvent) {\n  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (mapBrowserEvent.originalEvent);\n  const tagName = /** @type {Element} */ (originalEvent.target).tagName;\n  return tagName !== 'INPUT' && tagName !== 'SELECT' && tagName !== 'TEXTAREA';\n};\n\n/**\n * Return `true` if the event originates from a mouse device.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if the event originates from a mouse device.\n * @api\n */\nexport const mouseOnly = function (mapBrowserEvent) {\n  const pointerEvent = /** @type {import(\"../MapBrowserEvent\").default} */ (mapBrowserEvent)\n    .originalEvent;\n  assert(pointerEvent !== undefined, 56); // mapBrowserEvent must originate from a pointer event\n  // see http://www.w3.org/TR/pointerevents/#widl-PointerEvent-pointerType\n  return pointerEvent.pointerType == 'mouse';\n};\n\n/**\n * Return `true` if the event originates from a touchable device.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if the event originates from a touchable device.\n * @api\n */\nexport const touchOnly = function (mapBrowserEvent) {\n  const pointerEvt = /** @type {import(\"../MapBrowserEvent\").default} */ (mapBrowserEvent)\n    .originalEvent;\n  assert(pointerEvt !== undefined, 56); // mapBrowserEvent must originate from a pointer event\n  // see http://www.w3.org/TR/pointerevents/#widl-PointerEvent-pointerType\n  return pointerEvt.pointerType === 'touch';\n};\n\n/**\n * Return `true` if the event originates from a digital pen.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if the event originates from a digital pen.\n * @api\n */\nexport const penOnly = function (mapBrowserEvent) {\n  const pointerEvt = /** @type {import(\"../MapBrowserEvent\").default} */ (mapBrowserEvent)\n    .originalEvent;\n  assert(pointerEvt !== undefined, 56); // mapBrowserEvent must originate from a pointer event\n  // see http://www.w3.org/TR/pointerevents/#widl-PointerEvent-pointerType\n  return pointerEvt.pointerType === 'pen';\n};\n\n/**\n * Return `true` if the event originates from a primary pointer in\n * contact with the surface or if the left mouse button is pressed.\n * See http://www.w3.org/TR/pointerevents/#button-states.\n *\n * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n * @return {boolean} True if the event originates from a primary pointer.\n * @api\n */\nexport const primaryAction = function (mapBrowserEvent) {\n  const pointerEvent = /** @type {import(\"../MapBrowserEvent\").default} */ (mapBrowserEvent)\n    .originalEvent;\n  assert(pointerEvent !== undefined, 56); // mapBrowserEvent must originate from a pointer event\n  return pointerEvent.isPrimary && pointerEvent.button === 0;\n};\n","/**\n * @module ol/interaction/DragPan\n */\nimport PointerInteraction, {\n  centroid as centroidFromPointers,\n} from './Pointer.js';\nimport {FALSE} from '../functions.js';\nimport {\n  all,\n  focusWithTabindex,\n  noModifierKeys,\n  primaryAction,\n} from '../events/condition.js';\nimport {easeOut} from '../easing.js';\nimport {\n  rotate as rotateCoordinate,\n  scale as scaleCoordinate,\n} from '../coordinate.js';\n\n/**\n * @typedef {Object} Options\n * @property {import(\"../events/condition.js\").Condition} [condition] A function that takes an {@link module:ol/MapBrowserEvent~MapBrowserEvent} and returns a boolean\n * to indicate whether that event should be handled.\n * Default is {@link module:ol/events/condition~noModifierKeys} and {@link module:ol/events/condition~primaryAction}.\n * @property {boolean} [onFocusOnly=false] When the map's target has a `tabindex` attribute set,\n * the interaction will only handle events when the map has the focus.\n * @property {import(\"../Kinetic.js\").default} [kinetic] Kinetic inertia to apply to the pan.\n */\n\n/**\n * @classdesc\n * Allows the user to pan the map by dragging the map.\n * @api\n */\nclass DragPan extends PointerInteraction {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    super({\n      stopDown: FALSE,\n    });\n\n    const options = opt_options ? opt_options : {};\n\n    /**\n     * @private\n     * @type {import(\"../Kinetic.js\").default|undefined}\n     */\n    this.kinetic_ = options.kinetic;\n\n    /**\n     * @type {import(\"../pixel.js\").Pixel}\n     */\n    this.lastCentroid = null;\n\n    /**\n     * @type {number}\n     */\n    this.lastPointersCount_;\n\n    /**\n     * @type {boolean}\n     */\n    this.panning_ = false;\n\n    const condition = options.condition\n      ? options.condition\n      : all(noModifierKeys, primaryAction);\n\n    /**\n     * @private\n     * @type {import(\"../events/condition.js\").Condition}\n     */\n    this.condition_ = options.onFocusOnly\n      ? all(focusWithTabindex, condition)\n      : condition;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.noKinetic_ = false;\n  }\n\n  /**\n   * Handle pointer drag events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   */\n  handleDragEvent(mapBrowserEvent) {\n    if (!this.panning_) {\n      this.panning_ = true;\n      this.getMap().getView().beginInteraction();\n    }\n    const targetPointers = this.targetPointers;\n    const centroid = centroidFromPointers(targetPointers);\n    if (targetPointers.length == this.lastPointersCount_) {\n      if (this.kinetic_) {\n        this.kinetic_.update(centroid[0], centroid[1]);\n      }\n      if (this.lastCentroid) {\n        const delta = [\n          this.lastCentroid[0] - centroid[0],\n          centroid[1] - this.lastCentroid[1],\n        ];\n        const map = mapBrowserEvent.map;\n        const view = map.getView();\n        scaleCoordinate(delta, view.getResolution());\n        rotateCoordinate(delta, view.getRotation());\n        view.adjustCenterInternal(delta);\n      }\n    } else if (this.kinetic_) {\n      // reset so we don't overestimate the kinetic energy after\n      // after one finger down, tiny drag, second finger down\n      this.kinetic_.begin();\n    }\n    this.lastCentroid = centroid;\n    this.lastPointersCount_ = targetPointers.length;\n    mapBrowserEvent.originalEvent.preventDefault();\n  }\n\n  /**\n   * Handle pointer up events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   */\n  handleUpEvent(mapBrowserEvent) {\n    const map = mapBrowserEvent.map;\n    const view = map.getView();\n    if (this.targetPointers.length === 0) {\n      if (!this.noKinetic_ && this.kinetic_ && this.kinetic_.end()) {\n        const distance = this.kinetic_.getDistance();\n        const angle = this.kinetic_.getAngle();\n        const center = view.getCenterInternal();\n        const centerpx = map.getPixelFromCoordinateInternal(center);\n        const dest = map.getCoordinateFromPixelInternal([\n          centerpx[0] - distance * Math.cos(angle),\n          centerpx[1] - distance * Math.sin(angle),\n        ]);\n        view.animateInternal({\n          center: view.getConstrainedCenter(dest),\n          duration: 500,\n          easing: easeOut,\n        });\n      }\n      if (this.panning_) {\n        this.panning_ = false;\n        view.endInteraction();\n      }\n      return false;\n    } else {\n      if (this.kinetic_) {\n        // reset so we don't overestimate the kinetic energy after\n        // after one finger up, tiny drag, second finger up\n        this.kinetic_.begin();\n      }\n      this.lastCentroid = null;\n      return true;\n    }\n  }\n\n  /**\n   * Handle pointer down events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   */\n  handleDownEvent(mapBrowserEvent) {\n    if (this.targetPointers.length > 0 && this.condition_(mapBrowserEvent)) {\n      const map = mapBrowserEvent.map;\n      const view = map.getView();\n      this.lastCentroid = null;\n      // stop any current animation\n      if (view.getAnimating()) {\n        view.cancelAnimations();\n      }\n      if (this.kinetic_) {\n        this.kinetic_.begin();\n      }\n      // No kinetic as soon as more than one pointer on the screen is\n      // detected. This is to prevent nasty pans after pinch.\n      this.noKinetic_ = this.targetPointers.length > 1;\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n\nexport default DragPan;\n","/**\n * @module ol/interaction/DragRotate\n */\nimport PointerInteraction from './Pointer.js';\nimport {FALSE} from '../functions.js';\nimport {\n  altShiftKeysOnly,\n  mouseActionButton,\n  mouseOnly,\n} from '../events/condition.js';\nimport {disable} from '../rotationconstraint.js';\n\n/**\n * @typedef {Object} Options\n * @property {import(\"../events/condition.js\").Condition} [condition] A function that takes an\n * {@link module:ol/MapBrowserEvent~MapBrowserEvent} and returns a boolean\n * to indicate whether that event should be handled.\n * Default is {@link module:ol/events/condition~altShiftKeysOnly}.\n * @property {number} [duration=250] Animation duration in milliseconds.\n */\n\n/**\n * @classdesc\n * Allows the user to rotate the map by clicking and dragging on the map,\n * normally combined with an {@link module:ol/events/condition} that limits\n * it to when the alt and shift keys are held down.\n *\n * This interaction is only supported for mouse devices.\n * @api\n */\nclass DragRotate extends PointerInteraction {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    super({\n      stopDown: FALSE,\n    });\n\n    /**\n     * @private\n     * @type {import(\"../events/condition.js\").Condition}\n     */\n    this.condition_ = options.condition ? options.condition : altShiftKeysOnly;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.lastAngle_ = undefined;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.duration_ = options.duration !== undefined ? options.duration : 250;\n  }\n\n  /**\n   * Handle pointer drag events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   */\n  handleDragEvent(mapBrowserEvent) {\n    if (!mouseOnly(mapBrowserEvent)) {\n      return;\n    }\n\n    const map = mapBrowserEvent.map;\n    const view = map.getView();\n    if (view.getConstraints().rotation === disable) {\n      return;\n    }\n    const size = map.getSize();\n    const offset = mapBrowserEvent.pixel;\n    const theta = Math.atan2(size[1] / 2 - offset[1], offset[0] - size[0] / 2);\n    if (this.lastAngle_ !== undefined) {\n      const delta = theta - this.lastAngle_;\n      view.adjustRotationInternal(-delta);\n    }\n    this.lastAngle_ = theta;\n  }\n\n  /**\n   * Handle pointer up events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   */\n  handleUpEvent(mapBrowserEvent) {\n    if (!mouseOnly(mapBrowserEvent)) {\n      return true;\n    }\n\n    const map = mapBrowserEvent.map;\n    const view = map.getView();\n    view.endInteraction(this.duration_);\n    return false;\n  }\n\n  /**\n   * Handle pointer down events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   */\n  handleDownEvent(mapBrowserEvent) {\n    if (!mouseOnly(mapBrowserEvent)) {\n      return false;\n    }\n\n    if (\n      mouseActionButton(mapBrowserEvent) &&\n      this.condition_(mapBrowserEvent)\n    ) {\n      const map = mapBrowserEvent.map;\n      map.getView().beginInteraction();\n      this.lastAngle_ = undefined;\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n\nexport default DragRotate;\n","/**\n * @module ol/render/Box\n */\n\nimport Disposable from '../Disposable.js';\nimport Polygon from '../geom/Polygon.js';\n\nclass RenderBox extends Disposable {\n  /**\n   * @param {string} className CSS class name.\n   */\n  constructor(className) {\n    super();\n\n    /**\n     * @type {import(\"../geom/Polygon.js\").default}\n     * @private\n     */\n    this.geometry_ = null;\n\n    /**\n     * @type {HTMLDivElement}\n     * @private\n     */\n    this.element_ = document.createElement('div');\n    this.element_.style.position = 'absolute';\n    this.element_.style.pointerEvents = 'auto';\n    this.element_.className = 'ol-box ' + className;\n\n    /**\n     * @private\n     * @type {import(\"../PluggableMap.js\").default}\n     */\n    this.map_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../pixel.js\").Pixel}\n     */\n    this.startPixel_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../pixel.js\").Pixel}\n     */\n    this.endPixel_ = null;\n  }\n\n  /**\n   * Clean up.\n   */\n  disposeInternal() {\n    this.setMap(null);\n  }\n\n  /**\n   * @private\n   */\n  render_() {\n    const startPixel = this.startPixel_;\n    const endPixel = this.endPixel_;\n    const px = 'px';\n    const style = this.element_.style;\n    style.left = Math.min(startPixel[0], endPixel[0]) + px;\n    style.top = Math.min(startPixel[1], endPixel[1]) + px;\n    style.width = Math.abs(endPixel[0] - startPixel[0]) + px;\n    style.height = Math.abs(endPixel[1] - startPixel[1]) + px;\n  }\n\n  /**\n   * @param {import(\"../PluggableMap.js\").default} map Map.\n   */\n  setMap(map) {\n    if (this.map_) {\n      this.map_.getOverlayContainer().removeChild(this.element_);\n      const style = this.element_.style;\n      style.left = 'inherit';\n      style.top = 'inherit';\n      style.width = 'inherit';\n      style.height = 'inherit';\n    }\n    this.map_ = map;\n    if (this.map_) {\n      this.map_.getOverlayContainer().appendChild(this.element_);\n    }\n  }\n\n  /**\n   * @param {import(\"../pixel.js\").Pixel} startPixel Start pixel.\n   * @param {import(\"../pixel.js\").Pixel} endPixel End pixel.\n   */\n  setPixels(startPixel, endPixel) {\n    this.startPixel_ = startPixel;\n    this.endPixel_ = endPixel;\n    this.createOrUpdateGeometry();\n    this.render_();\n  }\n\n  /**\n   * Creates or updates the cached geometry.\n   */\n  createOrUpdateGeometry() {\n    const startPixel = this.startPixel_;\n    const endPixel = this.endPixel_;\n    const pixels = [\n      startPixel,\n      [startPixel[0], endPixel[1]],\n      endPixel,\n      [endPixel[0], startPixel[1]],\n    ];\n    const coordinates = pixels.map(\n      this.map_.getCoordinateFromPixelInternal,\n      this.map_\n    );\n    // close the polygon\n    coordinates[4] = coordinates[0].slice();\n    if (!this.geometry_) {\n      this.geometry_ = new Polygon([coordinates]);\n    } else {\n      this.geometry_.setCoordinates([coordinates]);\n    }\n  }\n\n  /**\n   * @return {import(\"../geom/Polygon.js\").default} Geometry.\n   */\n  getGeometry() {\n    return this.geometry_;\n  }\n}\n\nexport default RenderBox;\n","/**\n * @module ol/interaction/DragBox\n */\n// FIXME draw drag box\nimport Event from '../events/Event.js';\nimport PointerInteraction from './Pointer.js';\nimport RenderBox from '../render/Box.js';\nimport {mouseActionButton} from '../events/condition.js';\n\n/**\n * A function that takes a {@link module:ol/MapBrowserEvent} and two\n * {@link module:ol/pixel~Pixel}s and returns a `{boolean}`. If the condition is met,\n * true should be returned.\n * @typedef {function(this: ?, import(\"../MapBrowserEvent.js\").default, import(\"../pixel.js\").Pixel, import(\"../pixel.js\").Pixel):boolean} EndCondition\n */\n\n/**\n * @typedef {Object} Options\n * @property {string} [className='ol-dragbox'] CSS class name for styling the box.\n * @property {import(\"../events/condition.js\").Condition} [condition] A function that takes an {@link module:ol/MapBrowserEvent~MapBrowserEvent} and returns a boolean\n * to indicate whether that event should be handled.\n * Default is {@link ol/events/condition~mouseActionButton}.\n * @property {number} [minArea=64] The minimum area of the box in pixel, this value is used by the default\n * `boxEndCondition` function.\n * @property {EndCondition} [boxEndCondition] A function that takes a {@link module:ol/MapBrowserEvent~MapBrowserEvent} and two\n * {@link module:ol/pixel~Pixel}s to indicate whether a `boxend` event should be fired.\n * Default is `true` if the area of the box is bigger than the `minArea` option.\n * @property {function(this:DragBox, import(\"../MapBrowserEvent.js\").default):void} [onBoxEnd] Code to execute just\n * before `boxend` is fired.\n */\n\n/**\n * @enum {string}\n */\nconst DragBoxEventType = {\n  /**\n   * Triggered upon drag box start.\n   * @event DragBoxEvent#boxstart\n   * @api\n   */\n  BOXSTART: 'boxstart',\n\n  /**\n   * Triggered on drag when box is active.\n   * @event DragBoxEvent#boxdrag\n   * @api\n   */\n  BOXDRAG: 'boxdrag',\n\n  /**\n   * Triggered upon drag box end.\n   * @event DragBoxEvent#boxend\n   * @api\n   */\n  BOXEND: 'boxend',\n\n  /**\n   * Triggered upon drag box canceled.\n   * @event DragBoxEvent#boxcancel\n   * @api\n   */\n  BOXCANCEL: 'boxcancel',\n};\n\n/**\n * @classdesc\n * Events emitted by {@link module:ol/interaction/DragBox~DragBox} instances are instances of\n * this type.\n */\nexport class DragBoxEvent extends Event {\n  /**\n   * @param {string} type The event type.\n   * @param {import(\"../coordinate.js\").Coordinate} coordinate The event coordinate.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Originating event.\n   */\n  constructor(type, coordinate, mapBrowserEvent) {\n    super(type);\n\n    /**\n     * The coordinate of the drag event.\n     * @const\n     * @type {import(\"../coordinate.js\").Coordinate}\n     * @api\n     */\n    this.coordinate = coordinate;\n\n    /**\n     * @const\n     * @type {import(\"../MapBrowserEvent.js\").default}\n     * @api\n     */\n    this.mapBrowserEvent = mapBrowserEvent;\n  }\n}\n\n/**\n * @classdesc\n * Allows the user to draw a vector box by clicking and dragging on the map,\n * normally combined with an {@link module:ol/events/condition} that limits\n * it to when the shift or other key is held down. This is used, for example,\n * for zooming to a specific area of the map\n * (see {@link module:ol/interaction/DragZoom~DragZoom} and\n * {@link module:ol/interaction/DragRotateAndZoom}).\n *\n * @fires DragBoxEvent\n * @api\n */\nclass DragBox extends PointerInteraction {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    super();\n\n    const options = opt_options ? opt_options : {};\n\n    /**\n     * @type {import(\"../render/Box.js\").default}\n     * @private\n     */\n    this.box_ = new RenderBox(options.className || 'ol-dragbox');\n\n    /**\n     * @type {number}\n     * @private\n     */\n    this.minArea_ = options.minArea !== undefined ? options.minArea : 64;\n\n    if (options.onBoxEnd) {\n      this.onBoxEnd = options.onBoxEnd;\n    }\n\n    /**\n     * @type {import(\"../pixel.js\").Pixel}\n     * @private\n     */\n    this.startPixel_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../events/condition.js\").Condition}\n     */\n    this.condition_ = options.condition ? options.condition : mouseActionButton;\n\n    /**\n     * @private\n     * @type {EndCondition}\n     */\n    this.boxEndCondition_ = options.boxEndCondition\n      ? options.boxEndCondition\n      : this.defaultBoxEndCondition;\n  }\n\n  /**\n   * The default condition for determining whether the boxend event\n   * should fire.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent The originating MapBrowserEvent\n   *     leading to the box end.\n   * @param {import(\"../pixel.js\").Pixel} startPixel The starting pixel of the box.\n   * @param {import(\"../pixel.js\").Pixel} endPixel The end pixel of the box.\n   * @return {boolean} Whether or not the boxend condition should be fired.\n   */\n  defaultBoxEndCondition(mapBrowserEvent, startPixel, endPixel) {\n    const width = endPixel[0] - startPixel[0];\n    const height = endPixel[1] - startPixel[1];\n    return width * width + height * height >= this.minArea_;\n  }\n\n  /**\n   * Returns geometry of last drawn box.\n   * @return {import(\"../geom/Polygon.js\").default} Geometry.\n   * @api\n   */\n  getGeometry() {\n    return this.box_.getGeometry();\n  }\n\n  /**\n   * Handle pointer drag events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   */\n  handleDragEvent(mapBrowserEvent) {\n    this.box_.setPixels(this.startPixel_, mapBrowserEvent.pixel);\n\n    this.dispatchEvent(\n      new DragBoxEvent(\n        DragBoxEventType.BOXDRAG,\n        mapBrowserEvent.coordinate,\n        mapBrowserEvent\n      )\n    );\n  }\n\n  /**\n   * Handle pointer up events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   */\n  handleUpEvent(mapBrowserEvent) {\n    this.box_.setMap(null);\n\n    const completeBox = this.boxEndCondition_(\n      mapBrowserEvent,\n      this.startPixel_,\n      mapBrowserEvent.pixel\n    );\n    if (completeBox) {\n      this.onBoxEnd(mapBrowserEvent);\n    }\n    this.dispatchEvent(\n      new DragBoxEvent(\n        completeBox ? DragBoxEventType.BOXEND : DragBoxEventType.BOXCANCEL,\n        mapBrowserEvent.coordinate,\n        mapBrowserEvent\n      )\n    );\n    return false;\n  }\n\n  /**\n   * Handle pointer down events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   */\n  handleDownEvent(mapBrowserEvent) {\n    if (this.condition_(mapBrowserEvent)) {\n      this.startPixel_ = mapBrowserEvent.pixel;\n      this.box_.setMap(mapBrowserEvent.map);\n      this.box_.setPixels(this.startPixel_, this.startPixel_);\n      this.dispatchEvent(\n        new DragBoxEvent(\n          DragBoxEventType.BOXSTART,\n          mapBrowserEvent.coordinate,\n          mapBrowserEvent\n        )\n      );\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Function to execute just before `onboxend` is fired\n   * @param {import(\"../MapBrowserEvent.js\").default} event Event.\n   */\n  onBoxEnd(event) {}\n}\n\nexport default DragBox;\n","/**\n * @module ol/interaction/DragZoom\n */\nimport DragBox from './DragBox.js';\nimport {\n  createOrUpdateFromCoordinates,\n  getBottomLeft,\n  getCenter,\n  getTopRight,\n  scaleFromCenter,\n} from '../extent.js';\nimport {easeOut} from '../easing.js';\nimport {shiftKeyOnly} from '../events/condition.js';\n\n/**\n * @typedef {Object} Options\n * @property {string} [className='ol-dragzoom'] CSS class name for styling the\n * box.\n * @property {import(\"../events/condition.js\").Condition} [condition] A function that\n * takes an {@link module:ol/MapBrowserEvent~MapBrowserEvent} and returns a\n * boolean to indicate whether that event should be handled.\n * Default is {@link module:ol/events/condition~shiftKeyOnly}.\n * @property {number} [duration=200] Animation duration in milliseconds.\n * @property {boolean} [out=false] Use interaction for zooming out.\n * @property {number} [minArea=64] The minimum area of the box in pixel, this value is used by the parent default\n * `boxEndCondition` function.\n */\n\n/**\n * @classdesc\n * Allows the user to zoom the map by clicking and dragging on the map,\n * normally combined with an {@link module:ol/events/condition} that limits\n * it to when a key, shift by default, is held down.\n *\n * To change the style of the box, use CSS and the `.ol-dragzoom` selector, or\n * your custom one configured with `className`.\n * @api\n */\nclass DragZoom extends DragBox {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    const condition = options.condition ? options.condition : shiftKeyOnly;\n\n    super({\n      condition: condition,\n      className: options.className || 'ol-dragzoom',\n      minArea: options.minArea,\n    });\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.duration_ = options.duration !== undefined ? options.duration : 200;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.out_ = options.out !== undefined ? options.out : false;\n  }\n\n  /**\n   * Function to execute just before `onboxend` is fired\n   * @param {import(\"../MapBrowserEvent.js\").default} event Event.\n   */\n  onBoxEnd(event) {\n    const map = this.getMap();\n    const view = /** @type {!import(\"../View.js\").default} */ (map.getView());\n    const size = /** @type {!import(\"../size.js\").Size} */ (map.getSize());\n    let extent = this.getGeometry().getExtent();\n\n    if (this.out_) {\n      const mapExtent = view.calculateExtentInternal(size);\n      const boxPixelExtent = createOrUpdateFromCoordinates([\n        map.getPixelFromCoordinateInternal(getBottomLeft(extent)),\n        map.getPixelFromCoordinateInternal(getTopRight(extent)),\n      ]);\n      const factor = view.getResolutionForExtentInternal(boxPixelExtent, size);\n\n      scaleFromCenter(mapExtent, 1 / factor);\n      extent = mapExtent;\n    }\n\n    const resolution = view.getConstrainedResolution(\n      view.getResolutionForExtentInternal(extent, size)\n    );\n    const center = view.getConstrainedCenter(getCenter(extent), resolution);\n\n    view.animateInternal({\n      resolution: resolution,\n      center: center,\n      duration: this.duration_,\n      easing: easeOut,\n    });\n  }\n}\n\nexport default DragZoom;\n","/**\n * @module ol/events/KeyCode\n */\n\n/**\n * @enum {number}\n * @const\n */\nexport default {\n  LEFT: 37,\n  UP: 38,\n  RIGHT: 39,\n  DOWN: 40,\n};\n","/**\n * @module ol/interaction/KeyboardPan\n */\nimport EventType from '../events/EventType.js';\nimport Interaction, {pan} from './Interaction.js';\nimport KeyCode from '../events/KeyCode.js';\nimport {noModifierKeys, targetNotEditable} from '../events/condition.js';\nimport {rotate as rotateCoordinate} from '../coordinate.js';\n\n/**\n * @typedef {Object} Options\n * @property {import(\"../events/condition.js\").Condition} [condition] A function that\n * takes an {@link module:ol/MapBrowserEvent~MapBrowserEvent} and returns a\n * boolean to indicate whether that event should be handled. Default is\n * {@link module:ol/events/condition~noModifierKeys} and\n * {@link module:ol/events/condition~targetNotEditable}.\n * @property {number} [duration=100] Animation duration in milliseconds.\n * @property {number} [pixelDelta=128] The amount of pixels to pan on each key\n * press.\n */\n\n/**\n * @classdesc\n * Allows the user to pan the map using keyboard arrows.\n * Note that, although this interaction is by default included in maps,\n * the keys can only be used when browser focus is on the element to which\n * the keyboard events are attached. By default, this is the map div,\n * though you can change this with the `keyboardEventTarget` in\n * {@link module:ol/Map~Map}. `document` never loses focus but, for any other\n * element, focus will have to be on, and returned to, this element if the keys\n * are to function.\n * See also {@link module:ol/interaction/KeyboardZoom~KeyboardZoom}.\n * @api\n */\nclass KeyboardPan extends Interaction {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    super();\n\n    const options = opt_options || {};\n\n    /**\n     * @private\n     * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Browser event.\n     * @return {boolean} Combined condition result.\n     */\n    this.defaultCondition_ = function (mapBrowserEvent) {\n      return (\n        noModifierKeys(mapBrowserEvent) && targetNotEditable(mapBrowserEvent)\n      );\n    };\n\n    /**\n     * @private\n     * @type {import(\"../events/condition.js\").Condition}\n     */\n    this.condition_ =\n      options.condition !== undefined\n        ? options.condition\n        : this.defaultCondition_;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.duration_ = options.duration !== undefined ? options.duration : 100;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.pixelDelta_ =\n      options.pixelDelta !== undefined ? options.pixelDelta : 128;\n  }\n\n  /**\n   * Handles the {@link module:ol/MapBrowserEvent map browser event} if it was a\n   * `KeyEvent`, and decides the direction to pan to (if an arrow key was\n   * pressed).\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n   * @return {boolean} `false` to stop event propagation.\n   * @this {KeyboardPan}\n   */\n  handleEvent(mapBrowserEvent) {\n    let stopEvent = false;\n    if (mapBrowserEvent.type == EventType.KEYDOWN) {\n      const keyEvent = /** @type {KeyboardEvent} */ (mapBrowserEvent.originalEvent);\n      const keyCode = keyEvent.keyCode;\n      if (\n        this.condition_(mapBrowserEvent) &&\n        (keyCode == KeyCode.DOWN ||\n          keyCode == KeyCode.LEFT ||\n          keyCode == KeyCode.RIGHT ||\n          keyCode == KeyCode.UP)\n      ) {\n        const map = mapBrowserEvent.map;\n        const view = map.getView();\n        const mapUnitsDelta = view.getResolution() * this.pixelDelta_;\n        let deltaX = 0,\n          deltaY = 0;\n        if (keyCode == KeyCode.DOWN) {\n          deltaY = -mapUnitsDelta;\n        } else if (keyCode == KeyCode.LEFT) {\n          deltaX = -mapUnitsDelta;\n        } else if (keyCode == KeyCode.RIGHT) {\n          deltaX = mapUnitsDelta;\n        } else {\n          deltaY = mapUnitsDelta;\n        }\n        const delta = [deltaX, deltaY];\n        rotateCoordinate(delta, view.getRotation());\n        pan(view, delta, this.duration_);\n        keyEvent.preventDefault();\n        stopEvent = true;\n      }\n    }\n    return !stopEvent;\n  }\n}\n\nexport default KeyboardPan;\n","/**\n * @module ol/interaction/KeyboardZoom\n */\nimport EventType from '../events/EventType.js';\nimport Interaction, {zoomByDelta} from './Interaction.js';\nimport {targetNotEditable} from '../events/condition.js';\n\n/**\n * @typedef {Object} Options\n * @property {number} [duration=100] Animation duration in milliseconds.\n * @property {import(\"../events/condition.js\").Condition} [condition] A function that\n * takes an {@link module:ol/MapBrowserEvent~MapBrowserEvent} and returns a\n * boolean to indicate whether that event should be handled. Default is\n * {@link module:ol/events/condition~targetNotEditable}.\n * @property {number} [delta=1] The zoom level delta on each key press.\n */\n\n/**\n * @classdesc\n * Allows the user to zoom the map using keyboard + and -.\n * Note that, although this interaction is by default included in maps,\n * the keys can only be used when browser focus is on the element to which\n * the keyboard events are attached. By default, this is the map div,\n * though you can change this with the `keyboardEventTarget` in\n * {@link module:ol/Map~Map}. `document` never loses focus but, for any other\n * element, focus will have to be on, and returned to, this element if the keys\n * are to function.\n * See also {@link module:ol/interaction/KeyboardPan~KeyboardPan}.\n * @api\n */\nclass KeyboardZoom extends Interaction {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    super();\n\n    const options = opt_options ? opt_options : {};\n\n    /**\n     * @private\n     * @type {import(\"../events/condition.js\").Condition}\n     */\n    this.condition_ = options.condition ? options.condition : targetNotEditable;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.delta_ = options.delta ? options.delta : 1;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.duration_ = options.duration !== undefined ? options.duration : 100;\n  }\n\n  /**\n   * Handles the {@link module:ol/MapBrowserEvent map browser event} if it was a\n   * `KeyEvent`, and decides whether to zoom in or out (depending on whether the\n   * key pressed was '+' or '-').\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n   * @return {boolean} `false` to stop event propagation.\n   * @this {KeyboardZoom}\n   */\n  handleEvent(mapBrowserEvent) {\n    let stopEvent = false;\n    if (\n      mapBrowserEvent.type == EventType.KEYDOWN ||\n      mapBrowserEvent.type == EventType.KEYPRESS\n    ) {\n      const keyEvent = /** @type {KeyboardEvent} */ (mapBrowserEvent.originalEvent);\n      const charCode = keyEvent.charCode;\n      if (\n        this.condition_(mapBrowserEvent) &&\n        (charCode == '+'.charCodeAt(0) || charCode == '-'.charCodeAt(0))\n      ) {\n        const map = mapBrowserEvent.map;\n        const delta =\n          charCode == '+'.charCodeAt(0) ? this.delta_ : -this.delta_;\n        const view = map.getView();\n        zoomByDelta(view, delta, undefined, this.duration_);\n        keyEvent.preventDefault();\n        stopEvent = true;\n      }\n    }\n    return !stopEvent;\n  }\n}\n\nexport default KeyboardZoom;\n","/**\n * @module ol/Kinetic\n */\n\n/**\n * @classdesc\n * Implementation of inertial deceleration for map movement.\n *\n * @api\n */\nclass Kinetic {\n  /**\n   * @param {number} decay Rate of decay (must be negative).\n   * @param {number} minVelocity Minimum velocity (pixels/millisecond).\n   * @param {number} delay Delay to consider to calculate the kinetic\n   *     initial values (milliseconds).\n   */\n  constructor(decay, minVelocity, delay) {\n    /**\n     * @private\n     * @type {number}\n     */\n    this.decay_ = decay;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.minVelocity_ = minVelocity;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.delay_ = delay;\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.points_ = [];\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.angle_ = 0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.initialVelocity_ = 0;\n  }\n\n  /**\n   * FIXME empty description for jsdoc\n   */\n  begin() {\n    this.points_.length = 0;\n    this.angle_ = 0;\n    this.initialVelocity_ = 0;\n  }\n\n  /**\n   * @param {number} x X.\n   * @param {number} y Y.\n   */\n  update(x, y) {\n    this.points_.push(x, y, Date.now());\n  }\n\n  /**\n   * @return {boolean} Whether we should do kinetic animation.\n   */\n  end() {\n    if (this.points_.length < 6) {\n      // at least 2 points are required (i.e. there must be at least 6 elements\n      // in the array)\n      return false;\n    }\n    const delay = Date.now() - this.delay_;\n    const lastIndex = this.points_.length - 3;\n    if (this.points_[lastIndex + 2] < delay) {\n      // the last tracked point is too old, which means that the user stopped\n      // panning before releasing the map\n      return false;\n    }\n\n    // get the first point which still falls into the delay time\n    let firstIndex = lastIndex - 3;\n    while (firstIndex > 0 && this.points_[firstIndex + 2] > delay) {\n      firstIndex -= 3;\n    }\n\n    const duration = this.points_[lastIndex + 2] - this.points_[firstIndex + 2];\n    // we don't want a duration of 0 (divide by zero)\n    // we also make sure the user panned for a duration of at least one frame\n    // (1/60s) to compute sane displacement values\n    if (duration < 1000 / 60) {\n      return false;\n    }\n\n    const dx = this.points_[lastIndex] - this.points_[firstIndex];\n    const dy = this.points_[lastIndex + 1] - this.points_[firstIndex + 1];\n    this.angle_ = Math.atan2(dy, dx);\n    this.initialVelocity_ = Math.sqrt(dx * dx + dy * dy) / duration;\n    return this.initialVelocity_ > this.minVelocity_;\n  }\n\n  /**\n   * @return {number} Total distance travelled (pixels).\n   */\n  getDistance() {\n    return (this.minVelocity_ - this.initialVelocity_) / this.decay_;\n  }\n\n  /**\n   * @return {number} Angle of the kinetic panning animation (radians).\n   */\n  getAngle() {\n    return this.angle_;\n  }\n}\n\nexport default Kinetic;\n","/**\n * @module ol/interaction/MouseWheelZoom\n */\nimport EventType from '../events/EventType.js';\nimport Interaction, {zoomByDelta} from './Interaction.js';\nimport {DEVICE_PIXEL_RATIO, FIREFOX} from '../has.js';\nimport {all, always, focusWithTabindex} from '../events/condition.js';\nimport {clamp} from '../math.js';\n\n/**\n * @enum {string}\n */\nexport const Mode = {\n  TRACKPAD: 'trackpad',\n  WHEEL: 'wheel',\n};\n\n/**\n * @typedef {Object} Options\n * @property {import(\"../events/condition.js\").Condition} [condition] A function that\n * takes an {@link module:ol/MapBrowserEvent~MapBrowserEvent} and returns a\n * boolean to indicate whether that event should be handled. Default is\n * {@link module:ol/events/condition~always}.\n * @property {boolean} [onFocusOnly=false] When the map's target has a `tabindex` attribute set,\n * the interaction will only handle events when the map has the focus.\n * @property {number} [maxDelta=1] Maximum mouse wheel delta.\n * @property {number} [duration=250] Animation duration in milliseconds.\n * @property {number} [timeout=80] Mouse wheel timeout duration in milliseconds.\n * @property {boolean} [useAnchor=true] Enable zooming using the mouse's\n * location as the anchor. When set to `false`, zooming in and out will zoom to\n * the center of the screen instead of zooming on the mouse's location.\n * @property {boolean} [constrainResolution=false] If true, the mouse wheel zoom\n * event will always animate to the closest zoom level after an interaction;\n * false means intermediary zoom levels are allowed.\n */\n\n/**\n * @classdesc\n * Allows the user to zoom the map by scrolling the mouse wheel.\n * @api\n */\nclass MouseWheelZoom extends Interaction {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    super(\n      /** @type {import(\"./Interaction.js\").InteractionOptions} */ (options)\n    );\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.totalDelta_ = 0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.lastDelta_ = 0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.maxDelta_ = options.maxDelta !== undefined ? options.maxDelta : 1;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.duration_ = options.duration !== undefined ? options.duration : 250;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.timeout_ = options.timeout !== undefined ? options.timeout : 80;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.useAnchor_ =\n      options.useAnchor !== undefined ? options.useAnchor : true;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.constrainResolution_ =\n      options.constrainResolution !== undefined\n        ? options.constrainResolution\n        : false;\n\n    const condition = options.condition ? options.condition : always;\n\n    /**\n     * @private\n     * @type {import(\"../events/condition.js\").Condition}\n     */\n    this.condition_ = options.onFocusOnly\n      ? all(focusWithTabindex, condition)\n      : condition;\n\n    /**\n     * @private\n     * @type {?import(\"../coordinate.js\").Coordinate}\n     */\n    this.lastAnchor_ = null;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.startTime_ = undefined;\n\n    /**\n     * @private\n     * @type {?}\n     */\n    this.timeoutId_;\n\n    /**\n     * @private\n     * @type {Mode|undefined}\n     */\n    this.mode_ = undefined;\n\n    /**\n     * Trackpad events separated by this delay will be considered separate\n     * interactions.\n     * @type {number}\n     */\n    this.trackpadEventGap_ = 400;\n\n    /**\n     * @type {?}\n     */\n    this.trackpadTimeoutId_;\n\n    /**\n     * The number of delta values per zoom level\n     * @private\n     * @type {number}\n     */\n    this.deltaPerZoom_ = 300;\n  }\n\n  /**\n   * @private\n   */\n  endInteraction_() {\n    this.trackpadTimeoutId_ = undefined;\n    const view = this.getMap().getView();\n    view.endInteraction(\n      undefined,\n      this.lastDelta_ ? (this.lastDelta_ > 0 ? 1 : -1) : 0,\n      this.lastAnchor_\n    );\n  }\n\n  /**\n   * Handles the {@link module:ol/MapBrowserEvent map browser event} (if it was a mousewheel-event) and eventually\n   * zooms the map.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Map browser event.\n   * @return {boolean} `false` to stop event propagation.\n   */\n  handleEvent(mapBrowserEvent) {\n    if (!this.condition_(mapBrowserEvent)) {\n      return true;\n    }\n    const type = mapBrowserEvent.type;\n    if (type !== EventType.WHEEL) {\n      return true;\n    }\n\n    const map = mapBrowserEvent.map;\n    const wheelEvent = /** @type {WheelEvent} */ (mapBrowserEvent.originalEvent);\n    wheelEvent.preventDefault();\n\n    if (this.useAnchor_) {\n      this.lastAnchor_ = mapBrowserEvent.coordinate;\n    }\n\n    // Delta normalisation inspired by\n    // https://github.com/mapbox/mapbox-gl-js/blob/001c7b9/js/ui/handler/scroll_zoom.js\n    let delta;\n    if (mapBrowserEvent.type == EventType.WHEEL) {\n      delta = wheelEvent.deltaY;\n      if (FIREFOX && wheelEvent.deltaMode === WheelEvent.DOM_DELTA_PIXEL) {\n        delta /= DEVICE_PIXEL_RATIO;\n      }\n      if (wheelEvent.deltaMode === WheelEvent.DOM_DELTA_LINE) {\n        delta *= 40;\n      }\n    }\n\n    if (delta === 0) {\n      return false;\n    } else {\n      this.lastDelta_ = delta;\n    }\n\n    const now = Date.now();\n\n    if (this.startTime_ === undefined) {\n      this.startTime_ = now;\n    }\n\n    if (!this.mode_ || now - this.startTime_ > this.trackpadEventGap_) {\n      this.mode_ = Math.abs(delta) < 4 ? Mode.TRACKPAD : Mode.WHEEL;\n    }\n\n    const view = map.getView();\n    if (\n      this.mode_ === Mode.TRACKPAD &&\n      !(view.getConstrainResolution() || this.constrainResolution_)\n    ) {\n      if (this.trackpadTimeoutId_) {\n        clearTimeout(this.trackpadTimeoutId_);\n      } else {\n        if (view.getAnimating()) {\n          view.cancelAnimations();\n        }\n        view.beginInteraction();\n      }\n      this.trackpadTimeoutId_ = setTimeout(\n        this.endInteraction_.bind(this),\n        this.timeout_\n      );\n      view.adjustZoom(-delta / this.deltaPerZoom_, this.lastAnchor_);\n      this.startTime_ = now;\n      return false;\n    }\n\n    this.totalDelta_ += delta;\n\n    const timeLeft = Math.max(this.timeout_ - (now - this.startTime_), 0);\n\n    clearTimeout(this.timeoutId_);\n    this.timeoutId_ = setTimeout(\n      this.handleWheelZoom_.bind(this, map),\n      timeLeft\n    );\n\n    return false;\n  }\n\n  /**\n   * @private\n   * @param {import(\"../PluggableMap.js\").default} map Map.\n   */\n  handleWheelZoom_(map) {\n    const view = map.getView();\n    if (view.getAnimating()) {\n      view.cancelAnimations();\n    }\n    let delta =\n      -clamp(\n        this.totalDelta_,\n        -this.maxDelta_ * this.deltaPerZoom_,\n        this.maxDelta_ * this.deltaPerZoom_\n      ) / this.deltaPerZoom_;\n    if (view.getConstrainResolution() || this.constrainResolution_) {\n      // view has a zoom constraint, zoom by 1\n      delta = delta ? (delta > 0 ? 1 : -1) : 0;\n    }\n    zoomByDelta(view, delta, this.lastAnchor_, this.duration_);\n\n    this.mode_ = undefined;\n    this.totalDelta_ = 0;\n    this.lastAnchor_ = null;\n    this.startTime_ = undefined;\n    this.timeoutId_ = undefined;\n  }\n\n  /**\n   * Enable or disable using the mouse's location as an anchor when zooming\n   * @param {boolean} useAnchor true to zoom to the mouse's location, false\n   * to zoom to the center of the map\n   * @api\n   */\n  setMouseAnchor(useAnchor) {\n    this.useAnchor_ = useAnchor;\n    if (!useAnchor) {\n      this.lastAnchor_ = null;\n    }\n  }\n}\n\nexport default MouseWheelZoom;\n","/**\n * @module ol/interaction/PinchRotate\n */\nimport PointerInteraction, {\n  centroid as centroidFromPointers,\n} from './Pointer.js';\nimport {FALSE} from '../functions.js';\nimport {disable} from '../rotationconstraint.js';\n\n/**\n * @typedef {Object} Options\n * @property {number} [duration=250] The duration of the animation in\n * milliseconds.\n * @property {number} [threshold=0.3] Minimal angle in radians to start a rotation.\n */\n\n/**\n * @classdesc\n * Allows the user to rotate the map by twisting with two fingers\n * on a touch screen.\n * @api\n */\nclass PinchRotate extends PointerInteraction {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    const pointerOptions = /** @type {import(\"./Pointer.js\").Options} */ (options);\n\n    if (!pointerOptions.stopDown) {\n      pointerOptions.stopDown = FALSE;\n    }\n\n    super(pointerOptions);\n\n    /**\n     * @private\n     * @type {import(\"../coordinate.js\").Coordinate}\n     */\n    this.anchor_ = null;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.lastAngle_ = undefined;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.rotating_ = false;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.rotationDelta_ = 0.0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.threshold_ = options.threshold !== undefined ? options.threshold : 0.3;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.duration_ = options.duration !== undefined ? options.duration : 250;\n  }\n\n  /**\n   * Handle pointer drag events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   */\n  handleDragEvent(mapBrowserEvent) {\n    let rotationDelta = 0.0;\n\n    const touch0 = this.targetPointers[0];\n    const touch1 = this.targetPointers[1];\n\n    // angle between touches\n    const angle = Math.atan2(\n      touch1.clientY - touch0.clientY,\n      touch1.clientX - touch0.clientX\n    );\n\n    if (this.lastAngle_ !== undefined) {\n      const delta = angle - this.lastAngle_;\n      this.rotationDelta_ += delta;\n      if (!this.rotating_ && Math.abs(this.rotationDelta_) > this.threshold_) {\n        this.rotating_ = true;\n      }\n      rotationDelta = delta;\n    }\n    this.lastAngle_ = angle;\n\n    const map = mapBrowserEvent.map;\n    const view = map.getView();\n    if (view.getConstraints().rotation === disable) {\n      return;\n    }\n\n    // rotate anchor point.\n    // FIXME: should be the intersection point between the lines:\n    //     touch0,touch1 and previousTouch0,previousTouch1\n    const viewportPosition = map.getViewport().getBoundingClientRect();\n    const centroid = centroidFromPointers(this.targetPointers);\n    centroid[0] -= viewportPosition.left;\n    centroid[1] -= viewportPosition.top;\n    this.anchor_ = map.getCoordinateFromPixelInternal(centroid);\n\n    // rotate\n    if (this.rotating_) {\n      map.render();\n      view.adjustRotationInternal(rotationDelta, this.anchor_);\n    }\n  }\n\n  /**\n   * Handle pointer up events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   */\n  handleUpEvent(mapBrowserEvent) {\n    if (this.targetPointers.length < 2) {\n      const map = mapBrowserEvent.map;\n      const view = map.getView();\n      view.endInteraction(this.duration_);\n      return false;\n    } else {\n      return true;\n    }\n  }\n\n  /**\n   * Handle pointer down events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   */\n  handleDownEvent(mapBrowserEvent) {\n    if (this.targetPointers.length >= 2) {\n      const map = mapBrowserEvent.map;\n      this.anchor_ = null;\n      this.lastAngle_ = undefined;\n      this.rotating_ = false;\n      this.rotationDelta_ = 0.0;\n      if (!this.handlingDownUpSequence) {\n        map.getView().beginInteraction();\n      }\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n\nexport default PinchRotate;\n","/**\n * @module ol/interaction/PinchZoom\n */\nimport PointerInteraction, {\n  centroid as centroidFromPointers,\n} from './Pointer.js';\nimport {FALSE} from '../functions.js';\n\n/**\n * @typedef {Object} Options\n * @property {number} [duration=400] Animation duration in milliseconds.\n */\n\n/**\n * @classdesc\n * Allows the user to zoom the map by pinching with two fingers\n * on a touch screen.\n * @api\n */\nclass PinchZoom extends PointerInteraction {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    const pointerOptions = /** @type {import(\"./Pointer.js\").Options} */ (options);\n\n    if (!pointerOptions.stopDown) {\n      pointerOptions.stopDown = FALSE;\n    }\n\n    super(pointerOptions);\n\n    /**\n     * @private\n     * @type {import(\"../coordinate.js\").Coordinate}\n     */\n    this.anchor_ = null;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.duration_ = options.duration !== undefined ? options.duration : 400;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.lastDistance_ = undefined;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.lastScaleDelta_ = 1;\n  }\n\n  /**\n   * Handle pointer drag events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   */\n  handleDragEvent(mapBrowserEvent) {\n    let scaleDelta = 1.0;\n\n    const touch0 = this.targetPointers[0];\n    const touch1 = this.targetPointers[1];\n    const dx = touch0.clientX - touch1.clientX;\n    const dy = touch0.clientY - touch1.clientY;\n\n    // distance between touches\n    const distance = Math.sqrt(dx * dx + dy * dy);\n\n    if (this.lastDistance_ !== undefined) {\n      scaleDelta = this.lastDistance_ / distance;\n    }\n    this.lastDistance_ = distance;\n\n    const map = mapBrowserEvent.map;\n    const view = map.getView();\n\n    if (scaleDelta != 1.0) {\n      this.lastScaleDelta_ = scaleDelta;\n    }\n\n    // scale anchor point.\n    const viewportPosition = map.getViewport().getBoundingClientRect();\n    const centroid = centroidFromPointers(this.targetPointers);\n    centroid[0] -= viewportPosition.left;\n    centroid[1] -= viewportPosition.top;\n    this.anchor_ = map.getCoordinateFromPixelInternal(centroid);\n\n    // scale, bypass the resolution constraint\n    map.render();\n    view.adjustResolutionInternal(scaleDelta, this.anchor_);\n  }\n\n  /**\n   * Handle pointer up events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   */\n  handleUpEvent(mapBrowserEvent) {\n    if (this.targetPointers.length < 2) {\n      const map = mapBrowserEvent.map;\n      const view = map.getView();\n      const direction = this.lastScaleDelta_ > 1 ? 1 : -1;\n      view.endInteraction(this.duration_, direction);\n      return false;\n    } else {\n      return true;\n    }\n  }\n\n  /**\n   * Handle pointer down events.\n   * @param {import(\"../MapBrowserEvent.js\").default} mapBrowserEvent Event.\n   * @return {boolean} If the event was consumed.\n   */\n  handleDownEvent(mapBrowserEvent) {\n    if (this.targetPointers.length >= 2) {\n      const map = mapBrowserEvent.map;\n      this.anchor_ = null;\n      this.lastDistance_ = undefined;\n      this.lastScaleDelta_ = 1;\n      if (!this.handlingDownUpSequence) {\n        map.getView().beginInteraction();\n      }\n      return true;\n    } else {\n      return false;\n    }\n  }\n}\n\nexport default PinchZoom;\n","/**\n * @module ol/Map\n */\nimport CompositeMapRenderer from './renderer/Composite.js';\nimport PluggableMap from './PluggableMap.js';\nimport {assign} from './obj.js';\nimport {defaults as defaultControls} from './control.js';\nimport {defaults as defaultInteractions} from './interaction.js';\n\n/**\n * @classdesc\n * The map is the core component of OpenLayers. For a map to render, a view,\n * one or more layers, and a target container are needed:\n *\n *     import Map from 'ol/Map';\n *     import View from 'ol/View';\n *     import TileLayer from 'ol/layer/Tile';\n *     import OSM from 'ol/source/OSM';\n *\n *     var map = new Map({\n *       view: new View({\n *         center: [0, 0],\n *         zoom: 1\n *       }),\n *       layers: [\n *         new TileLayer({\n *           source: new OSM()\n *         })\n *       ],\n *       target: 'map'\n *     });\n *\n * The above snippet creates a map using a {@link module:ol/layer/Tile} to\n * display {@link module:ol/source/OSM~OSM} OSM data and render it to a DOM\n * element with the id `map`.\n *\n * The constructor places a viewport container (with CSS class name\n * `ol-viewport`) in the target element (see `getViewport()`), and then two\n * further elements within the viewport: one with CSS class name\n * `ol-overlaycontainer-stopevent` for controls and some overlays, and one with\n * CSS class name `ol-overlaycontainer` for other overlays (see the `stopEvent`\n * option of {@link module:ol/Overlay~Overlay} for the difference). The map\n * itself is placed in a further element within the viewport.\n *\n * Layers are stored as a {@link module:ol/Collection~Collection} in\n * layerGroups. A top-level group is provided by the library. This is what is\n * accessed by `getLayerGroup` and `setLayerGroup`. Layers entered in the\n * options are added to this group, and `addLayer` and `removeLayer` change the\n * layer collection in the group. `getLayers` is a convenience function for\n * `getLayerGroup().getLayers()`. Note that {@link module:ol/layer/Group~Group}\n * is a subclass of {@link module:ol/layer/Base}, so layers entered in the\n * options or added with `addLayer` can be groups, which can contain further\n * groups, and so on.\n *\n * @api\n */\nclass Map extends PluggableMap {\n  /**\n   * @param {import(\"./PluggableMap.js\").MapOptions} options Map options.\n   */\n  constructor(options) {\n    options = assign({}, options);\n    if (!options.controls) {\n      options.controls = defaultControls();\n    }\n    if (!options.interactions) {\n      options.interactions = defaultInteractions({\n        onFocusOnly: true,\n      });\n    }\n\n    super(options);\n  }\n\n  createRenderer() {\n    return new CompositeMapRenderer(this);\n  }\n}\n\nexport default Map;\n","/**\n * @module ol/interaction\n */\nimport Collection from './Collection.js';\nimport DoubleClickZoom from './interaction/DoubleClickZoom.js';\nimport DragPan from './interaction/DragPan.js';\nimport DragRotate from './interaction/DragRotate.js';\nimport DragZoom from './interaction/DragZoom.js';\nimport KeyboardPan from './interaction/KeyboardPan.js';\nimport KeyboardZoom from './interaction/KeyboardZoom.js';\nimport Kinetic from './Kinetic.js';\nimport MouseWheelZoom from './interaction/MouseWheelZoom.js';\nimport PinchRotate from './interaction/PinchRotate.js';\nimport PinchZoom from './interaction/PinchZoom.js';\n\nexport {default as DoubleClickZoom} from './interaction/DoubleClickZoom.js';\nexport {default as DragAndDrop} from './interaction/DragAndDrop.js';\nexport {default as DragBox} from './interaction/DragBox.js';\nexport {default as DragPan} from './interaction/DragPan.js';\nexport {default as DragRotate} from './interaction/DragRotate.js';\nexport {default as DragRotateAndZoom} from './interaction/DragRotateAndZoom.js';\nexport {default as DragZoom} from './interaction/DragZoom.js';\nexport {default as Draw} from './interaction/Draw.js';\nexport {default as Extent} from './interaction/Extent.js';\nexport {default as Interaction} from './interaction/Interaction.js';\nexport {default as KeyboardPan} from './interaction/KeyboardPan.js';\nexport {default as KeyboardZoom} from './interaction/KeyboardZoom.js';\nexport {default as Modify} from './interaction/Modify.js';\nexport {default as MouseWheelZoom} from './interaction/MouseWheelZoom.js';\nexport {default as PinchRotate} from './interaction/PinchRotate.js';\nexport {default as PinchZoom} from './interaction/PinchZoom.js';\nexport {default as Pointer} from './interaction/Pointer.js';\nexport {default as Select} from './interaction/Select.js';\nexport {default as Snap} from './interaction/Snap.js';\nexport {default as Translate} from './interaction/Translate.js';\n\n/**\n * @typedef {Object} DefaultsOptions\n * @property {boolean} [altShiftDragRotate=true] Whether Alt-Shift-drag rotate is\n * desired.\n * @property {boolean} [onFocusOnly=false] Interact only when the map has the\n * focus. This affects the `MouseWheelZoom` and `DragPan` interactions and is\n * useful when page scroll is desired for maps that do not have the browser's\n * focus.\n * @property {boolean} [doubleClickZoom=true] Whether double click zoom is\n * desired.\n * @property {boolean} [keyboard=true] Whether keyboard interaction is desired.\n * @property {boolean} [mouseWheelZoom=true] Whether mousewheel zoom is desired.\n * @property {boolean} [shiftDragZoom=true] Whether Shift-drag zoom is desired.\n * @property {boolean} [dragPan=true] Whether drag pan is desired.\n * @property {boolean} [pinchRotate=true] Whether pinch rotate is desired.\n * @property {boolean} [pinchZoom=true] Whether pinch zoom is desired.\n * @property {number} [zoomDelta] Zoom level delta when using keyboard or double click zoom.\n * @property {number} [zoomDuration] Duration of the zoom animation in\n * milliseconds.\n */\n\n/**\n * Set of interactions included in maps by default. Specific interactions can be\n * excluded by setting the appropriate option to false in the constructor\n * options, but the order of the interactions is fixed.  If you want to specify\n * a different order for interactions, you will need to create your own\n * {@link module:ol/interaction/Interaction} instances and insert\n * them into a {@link module:ol/Collection} in the order you want\n * before creating your {@link module:ol/Map~Map} instance. Changing the order can\n * be of interest if the event propagation needs to be stopped at a point.\n * The default set of interactions, in sequence, is:\n * * {@link module:ol/interaction/DragRotate~DragRotate}\n * * {@link module:ol/interaction/DoubleClickZoom~DoubleClickZoom}\n * * {@link module:ol/interaction/DragPan~DragPan}\n * * {@link module:ol/interaction/PinchRotate~PinchRotate}\n * * {@link module:ol/interaction/PinchZoom~PinchZoom}\n * * {@link module:ol/interaction/KeyboardPan~KeyboardPan}\n * * {@link module:ol/interaction/KeyboardZoom~KeyboardZoom}\n * * {@link module:ol/interaction/MouseWheelZoom~MouseWheelZoom}\n * * {@link module:ol/interaction/DragZoom~DragZoom}\n *\n * @param {DefaultsOptions=} opt_options Defaults options.\n * @return {import(\"./Collection.js\").default<import(\"./interaction/Interaction.js\").default>}\n * A collection of interactions to be used with the {@link module:ol/Map~Map}\n * constructor's `interactions` option.\n * @api\n */\nexport function defaults(opt_options) {\n  const options = opt_options ? opt_options : {};\n\n  const interactions = new Collection();\n\n  const kinetic = new Kinetic(-0.005, 0.05, 100);\n\n  const altShiftDragRotate =\n    options.altShiftDragRotate !== undefined\n      ? options.altShiftDragRotate\n      : true;\n  if (altShiftDragRotate) {\n    interactions.push(new DragRotate());\n  }\n\n  const doubleClickZoom =\n    options.doubleClickZoom !== undefined ? options.doubleClickZoom : true;\n  if (doubleClickZoom) {\n    interactions.push(\n      new DoubleClickZoom({\n        delta: options.zoomDelta,\n        duration: options.zoomDuration,\n      })\n    );\n  }\n\n  const dragPan = options.dragPan !== undefined ? options.dragPan : true;\n  if (dragPan) {\n    interactions.push(\n      new DragPan({\n        onFocusOnly: options.onFocusOnly,\n        kinetic: kinetic,\n      })\n    );\n  }\n\n  const pinchRotate =\n    options.pinchRotate !== undefined ? options.pinchRotate : true;\n  if (pinchRotate) {\n    interactions.push(new PinchRotate());\n  }\n\n  const pinchZoom = options.pinchZoom !== undefined ? options.pinchZoom : true;\n  if (pinchZoom) {\n    interactions.push(\n      new PinchZoom({\n        duration: options.zoomDuration,\n      })\n    );\n  }\n\n  const keyboard = options.keyboard !== undefined ? options.keyboard : true;\n  if (keyboard) {\n    interactions.push(new KeyboardPan());\n    interactions.push(\n      new KeyboardZoom({\n        delta: options.zoomDelta,\n        duration: options.zoomDuration,\n      })\n    );\n  }\n\n  const mouseWheelZoom =\n    options.mouseWheelZoom !== undefined ? options.mouseWheelZoom : true;\n  if (mouseWheelZoom) {\n    interactions.push(\n      new MouseWheelZoom({\n        onFocusOnly: options.onFocusOnly,\n        duration: options.zoomDuration,\n      })\n    );\n  }\n\n  const shiftDragZoom =\n    options.shiftDragZoom !== undefined ? options.shiftDragZoom : true;\n  if (shiftDragZoom) {\n    interactions.push(\n      new DragZoom({\n        duration: options.zoomDuration,\n      })\n    );\n  }\n\n  return interactions;\n}\n","/**\n * @module ol/OverlayPositioning\n */\n\n/**\n * Overlay position: `'bottom-left'`, `'bottom-center'`,  `'bottom-right'`,\n * `'center-left'`, `'center-center'`, `'center-right'`, `'top-left'`,\n * `'top-center'`, `'top-right'`\n * @enum {string}\n */\nexport default {\n  BOTTOM_LEFT: 'bottom-left',\n  BOTTOM_CENTER: 'bottom-center',\n  BOTTOM_RIGHT: 'bottom-right',\n  CENTER_LEFT: 'center-left',\n  CENTER_CENTER: 'center-center',\n  CENTER_RIGHT: 'center-right',\n  TOP_LEFT: 'top-left',\n  TOP_CENTER: 'top-center',\n  TOP_RIGHT: 'top-right',\n};\n","/**\n * @module ol/Overlay\n */\nimport BaseObject, {getChangeEventType} from './Object.js';\nimport MapEventType from './MapEventType.js';\nimport OverlayPositioning from './OverlayPositioning.js';\nimport {CLASS_SELECTABLE} from './css.js';\nimport {containsExtent} from './extent.js';\nimport {listen, unlistenByKey} from './events.js';\nimport {outerHeight, outerWidth, removeChildren, removeNode} from './dom.js';\n\n/**\n * @typedef {Object} Options\n * @property {number|string} [id] Set the overlay id. The overlay id can be used\n * with the {@link module:ol/Map~Map#getOverlayById} method.\n * @property {HTMLElement} [element] The overlay element.\n * @property {Array<number>} [offset=[0, 0]] Offsets in pixels used when positioning\n * the overlay. The first element in the\n * array is the horizontal offset. A positive value shifts the overlay right.\n * The second element in the array is the vertical offset. A positive value\n * shifts the overlay down.\n * @property {import(\"./coordinate.js\").Coordinate} [position] The overlay position\n * in map projection.\n * @property {import(\"./OverlayPositioning.js\").default} [positioning='top-left'] Defines how\n * the overlay is actually positioned with respect to its `position` property.\n * Possible values are `'bottom-left'`, `'bottom-center'`, `'bottom-right'`,\n * `'center-left'`, `'center-center'`, `'center-right'`, `'top-left'`,\n * `'top-center'`, and `'top-right'`.\n * @property {boolean} [stopEvent=true] Whether event propagation to the map\n * viewport should be stopped. If `true` the overlay is placed in the same\n * container as that of the controls (CSS class name\n * `ol-overlaycontainer-stopevent`); if `false` it is placed in the container\n * with CSS class name specified by the `className` property.\n * @property {boolean} [insertFirst=true] Whether the overlay is inserted first\n * in the overlay container, or appended. If the overlay is placed in the same\n * container as that of the controls (see the `stopEvent` option) you will\n * probably set `insertFirst` to `true` so the overlay is displayed below the\n * controls.\n * @property {PanIntoViewOptions|boolean} [autoPan=false] Pan the map when calling\n * `setPosition`, so that the overlay is entirely visible in the current viewport?\n * If `true` (deprecated), then `autoPanAnimation` and `autoPanMargin` will be\n * used to determine the panning parameters; if an object is supplied then other\n * parameters are ignored.\n * @property {PanOptions} [autoPanAnimation] The animation options used to pan\n * the overlay into view. This animation is only used when `autoPan` is enabled.\n * A `duration` and `easing` may be provided to customize the animation.\n * Deprecated and ignored if `autoPan` is supplied as an object.\n * @property {number} [autoPanMargin=20] The margin (in pixels) between the\n * overlay and the borders of the map when autopanning. Deprecated and ignored\n * if `autoPan` is supplied as an object.\n * @property {PanIntoViewOptions} [autoPanOptions] The options to use for the\n * autoPan. This is only used when `autoPan` is enabled and has preference over\n * the individual `autoPanMargin` and `autoPanOptions`.\n * @property {string} [className='ol-overlay-container ol-selectable'] CSS class\n * name.\n */\n\n/**\n * @typedef {Object} PanOptions\n * @property {number} [duration=1000] The duration of the animation in\n * milliseconds.\n * @property {function(number):number} [easing] The easing function to use. Can\n * be one from {@link module:ol/easing} or a custom function.\n * Default is {@link module:ol/easing~inAndOut}.\n */\n\n/**\n * @typedef {Object} PanIntoViewOptions\n * @property {PanOptions} [animation={}] The animation parameters for the pan\n * @property {number} [margin=20] The margin (in pixels) between the\n * overlay and the borders of the map when panning into view.\n */\n\n/**\n * @enum {string}\n * @protected\n */\nconst Property = {\n  ELEMENT: 'element',\n  MAP: 'map',\n  OFFSET: 'offset',\n  POSITION: 'position',\n  POSITIONING: 'positioning',\n};\n\n/**\n * @classdesc\n * An element to be displayed over the map and attached to a single map\n * location.  Like {@link module:ol/control/Control~Control}, Overlays are\n * visible widgets. Unlike Controls, they are not in a fixed position on the\n * screen, but are tied to a geographical coordinate, so panning the map will\n * move an Overlay but not a Control.\n *\n * Example:\n *\n *     import Overlay from 'ol/Overlay';\n *\n *     var popup = new Overlay({\n *       element: document.getElementById('popup')\n *     });\n *     popup.setPosition(coordinate);\n *     map.addOverlay(popup);\n *\n * @api\n */\nclass Overlay extends BaseObject {\n  /**\n   * @param {Options} options Overlay options.\n   */\n  constructor(options) {\n    super();\n\n    /**\n     * @protected\n     * @type {Options}\n     */\n    this.options = options;\n\n    /**\n     * @protected\n     * @type {number|string|undefined}\n     */\n    this.id = options.id;\n\n    /**\n     * @protected\n     * @type {boolean}\n     */\n    this.insertFirst =\n      options.insertFirst !== undefined ? options.insertFirst : true;\n\n    /**\n     * @protected\n     * @type {boolean}\n     */\n    this.stopEvent = options.stopEvent !== undefined ? options.stopEvent : true;\n\n    /**\n     * @protected\n     * @type {HTMLElement}\n     */\n    this.element = document.createElement('div');\n    this.element.className =\n      options.className !== undefined\n        ? options.className\n        : 'ol-overlay-container ' + CLASS_SELECTABLE;\n    this.element.style.position = 'absolute';\n    this.element.style.pointerEvents = 'auto';\n\n    let autoPan = options.autoPan;\n    if (autoPan && 'object' !== typeof autoPan) {\n      autoPan = {\n        animation: options.autoPanAnimation,\n        margin: options.autoPanMargin,\n      };\n    }\n    /**\n     * @protected\n     * @type {PanIntoViewOptions|false}\n     */\n    this.autoPan = /** @type {PanIntoViewOptions} */ (autoPan) || false;\n\n    /**\n     * @protected\n     * @type {{transform_: string,\n     *         visible: boolean}}\n     */\n    this.rendered = {\n      transform_: '',\n      visible: true,\n    };\n\n    /**\n     * @protected\n     * @type {?import(\"./events.js\").EventsKey}\n     */\n    this.mapPostrenderListenerKey = null;\n\n    this.addEventListener(\n      getChangeEventType(Property.ELEMENT),\n      this.handleElementChanged\n    );\n    this.addEventListener(\n      getChangeEventType(Property.MAP),\n      this.handleMapChanged\n    );\n    this.addEventListener(\n      getChangeEventType(Property.OFFSET),\n      this.handleOffsetChanged\n    );\n    this.addEventListener(\n      getChangeEventType(Property.POSITION),\n      this.handlePositionChanged\n    );\n    this.addEventListener(\n      getChangeEventType(Property.POSITIONING),\n      this.handlePositioningChanged\n    );\n\n    if (options.element !== undefined) {\n      this.setElement(options.element);\n    }\n\n    this.setOffset(options.offset !== undefined ? options.offset : [0, 0]);\n\n    this.setPositioning(\n      options.positioning !== undefined\n        ? /** @type {import(\"./OverlayPositioning.js\").default} */ (options.positioning)\n        : OverlayPositioning.TOP_LEFT\n    );\n\n    if (options.position !== undefined) {\n      this.setPosition(options.position);\n    }\n  }\n\n  /**\n   * Get the DOM element of this overlay.\n   * @return {HTMLElement|undefined} The Element containing the overlay.\n   * @observable\n   * @api\n   */\n  getElement() {\n    return /** @type {HTMLElement|undefined} */ (this.get(Property.ELEMENT));\n  }\n\n  /**\n   * Get the overlay identifier which is set on constructor.\n   * @return {number|string|undefined} Id.\n   * @api\n   */\n  getId() {\n    return this.id;\n  }\n\n  /**\n   * Get the map associated with this overlay.\n   * @return {import(\"./PluggableMap.js\").default|undefined} The map that the\n   * overlay is part of.\n   * @observable\n   * @api\n   */\n  getMap() {\n    return /** @type {import(\"./PluggableMap.js\").default|undefined} */ (this.get(\n      Property.MAP\n    ));\n  }\n\n  /**\n   * Get the offset of this overlay.\n   * @return {Array<number>} The offset.\n   * @observable\n   * @api\n   */\n  getOffset() {\n    return /** @type {Array<number>} */ (this.get(Property.OFFSET));\n  }\n\n  /**\n   * Get the current position of this overlay.\n   * @return {import(\"./coordinate.js\").Coordinate|undefined} The spatial point that the overlay is\n   *     anchored at.\n   * @observable\n   * @api\n   */\n  getPosition() {\n    return /** @type {import(\"./coordinate.js\").Coordinate|undefined} */ (this.get(\n      Property.POSITION\n    ));\n  }\n\n  /**\n   * Get the current positioning of this overlay.\n   * @return {import(\"./OverlayPositioning.js\").default} How the overlay is positioned\n   *     relative to its point on the map.\n   * @observable\n   * @api\n   */\n  getPositioning() {\n    return /** @type {import(\"./OverlayPositioning.js\").default} */ (this.get(\n      Property.POSITIONING\n    ));\n  }\n\n  /**\n   * @protected\n   */\n  handleElementChanged() {\n    removeChildren(this.element);\n    const element = this.getElement();\n    if (element) {\n      this.element.appendChild(element);\n    }\n  }\n\n  /**\n   * @protected\n   */\n  handleMapChanged() {\n    if (this.mapPostrenderListenerKey) {\n      removeNode(this.element);\n      unlistenByKey(this.mapPostrenderListenerKey);\n      this.mapPostrenderListenerKey = null;\n    }\n    const map = this.getMap();\n    if (map) {\n      this.mapPostrenderListenerKey = listen(\n        map,\n        MapEventType.POSTRENDER,\n        this.render,\n        this\n      );\n      this.updatePixelPosition();\n      const container = this.stopEvent\n        ? map.getOverlayContainerStopEvent()\n        : map.getOverlayContainer();\n      if (this.insertFirst) {\n        container.insertBefore(this.element, container.childNodes[0] || null);\n      } else {\n        container.appendChild(this.element);\n      }\n      this.performAutoPan();\n    }\n  }\n\n  /**\n   * @protected\n   */\n  render() {\n    this.updatePixelPosition();\n  }\n\n  /**\n   * @protected\n   */\n  handleOffsetChanged() {\n    this.updatePixelPosition();\n  }\n\n  /**\n   * @protected\n   */\n  handlePositionChanged() {\n    this.updatePixelPosition();\n    this.performAutoPan();\n  }\n\n  /**\n   * @protected\n   */\n  handlePositioningChanged() {\n    this.updatePixelPosition();\n  }\n\n  /**\n   * Set the DOM element to be associated with this overlay.\n   * @param {HTMLElement|undefined} element The Element containing the overlay.\n   * @observable\n   * @api\n   */\n  setElement(element) {\n    this.set(Property.ELEMENT, element);\n  }\n\n  /**\n   * Set the map to be associated with this overlay.\n   * @param {import(\"./PluggableMap.js\").default|undefined} map The map that the\n   * overlay is part of.\n   * @observable\n   * @api\n   */\n  setMap(map) {\n    this.set(Property.MAP, map);\n  }\n\n  /**\n   * Set the offset for this overlay.\n   * @param {Array<number>} offset Offset.\n   * @observable\n   * @api\n   */\n  setOffset(offset) {\n    this.set(Property.OFFSET, offset);\n  }\n\n  /**\n   * Set the position for this overlay. If the position is `undefined` the\n   * overlay is hidden.\n   * @param {import(\"./coordinate.js\").Coordinate|undefined} position The spatial point that the overlay\n   *     is anchored at.\n   * @observable\n   * @api\n   */\n  setPosition(position) {\n    this.set(Property.POSITION, position);\n  }\n\n  /**\n   * Pan the map so that the overlay is entirely visisble in the current viewport\n   * (if necessary) using the configured autoPan parameters\n   * @protected\n   */\n  performAutoPan() {\n    if (this.autoPan) {\n      this.panIntoView(this.autoPan);\n    }\n  }\n\n  /**\n   * Pan the map so that the overlay is entirely visible in the current viewport\n   * (if necessary).\n   * @param {PanIntoViewOptions=} opt_panIntoViewOptions Options for the pan action\n   * @api\n   */\n  panIntoView(opt_panIntoViewOptions) {\n    const map = this.getMap();\n\n    if (!map || !map.getTargetElement() || !this.get(Property.POSITION)) {\n      return;\n    }\n\n    const mapRect = this.getRect(map.getTargetElement(), map.getSize());\n    const element = this.getElement();\n    const overlayRect = this.getRect(element, [\n      outerWidth(element),\n      outerHeight(element),\n    ]);\n\n    const panIntoViewOptions = opt_panIntoViewOptions || {};\n\n    const myMargin =\n      panIntoViewOptions.margin === undefined ? 20 : panIntoViewOptions.margin;\n    if (!containsExtent(mapRect, overlayRect)) {\n      // the overlay is not completely inside the viewport, so pan the map\n      const offsetLeft = overlayRect[0] - mapRect[0];\n      const offsetRight = mapRect[2] - overlayRect[2];\n      const offsetTop = overlayRect[1] - mapRect[1];\n      const offsetBottom = mapRect[3] - overlayRect[3];\n\n      const delta = [0, 0];\n      if (offsetLeft < 0) {\n        // move map to the left\n        delta[0] = offsetLeft - myMargin;\n      } else if (offsetRight < 0) {\n        // move map to the right\n        delta[0] = Math.abs(offsetRight) + myMargin;\n      }\n      if (offsetTop < 0) {\n        // move map up\n        delta[1] = offsetTop - myMargin;\n      } else if (offsetBottom < 0) {\n        // move map down\n        delta[1] = Math.abs(offsetBottom) + myMargin;\n      }\n\n      if (delta[0] !== 0 || delta[1] !== 0) {\n        const center = /** @type {import(\"./coordinate.js\").Coordinate} */ (map\n          .getView()\n          .getCenterInternal());\n        const centerPx = map.getPixelFromCoordinateInternal(center);\n        if (!centerPx) {\n          return;\n        }\n        const newCenterPx = [centerPx[0] + delta[0], centerPx[1] + delta[1]];\n\n        const panOptions = panIntoViewOptions.animation || {};\n        map.getView().animateInternal({\n          center: map.getCoordinateFromPixelInternal(newCenterPx),\n          duration: panOptions.duration,\n          easing: panOptions.easing,\n        });\n      }\n    }\n  }\n\n  /**\n   * Get the extent of an element relative to the document\n   * @param {HTMLElement} element The element.\n   * @param {import(\"./size.js\").Size} size The size of the element.\n   * @return {import(\"./extent.js\").Extent} The extent.\n   * @protected\n   */\n  getRect(element, size) {\n    const box = element.getBoundingClientRect();\n    const offsetX = box.left + window.pageXOffset;\n    const offsetY = box.top + window.pageYOffset;\n    return [offsetX, offsetY, offsetX + size[0], offsetY + size[1]];\n  }\n\n  /**\n   * Set the positioning for this overlay.\n   * @param {import(\"./OverlayPositioning.js\").default} positioning how the overlay is\n   *     positioned relative to its point on the map.\n   * @observable\n   * @api\n   */\n  setPositioning(positioning) {\n    this.set(Property.POSITIONING, positioning);\n  }\n\n  /**\n   * Modify the visibility of the element.\n   * @param {boolean} visible Element visibility.\n   * @protected\n   */\n  setVisible(visible) {\n    if (this.rendered.visible !== visible) {\n      this.element.style.display = visible ? '' : 'none';\n      this.rendered.visible = visible;\n    }\n  }\n\n  /**\n   * Update pixel position.\n   * @protected\n   */\n  updatePixelPosition() {\n    const map = this.getMap();\n    const position = this.getPosition();\n    if (!map || !map.isRendered() || !position) {\n      this.setVisible(false);\n      return;\n    }\n\n    const pixel = map.getPixelFromCoordinate(position);\n    const mapSize = map.getSize();\n    this.updateRenderedPosition(pixel, mapSize);\n  }\n\n  /**\n   * @param {import(\"./pixel.js\").Pixel} pixel The pixel location.\n   * @param {import(\"./size.js\").Size|undefined} mapSize The map size.\n   * @protected\n   */\n  updateRenderedPosition(pixel, mapSize) {\n    const style = this.element.style;\n    const offset = this.getOffset();\n\n    const positioning = this.getPositioning();\n\n    this.setVisible(true);\n\n    const x = Math.round(pixel[0] + offset[0]) + 'px';\n    const y = Math.round(pixel[1] + offset[1]) + 'px';\n    let posX = '0%';\n    let posY = '0%';\n    if (\n      positioning == OverlayPositioning.BOTTOM_RIGHT ||\n      positioning == OverlayPositioning.CENTER_RIGHT ||\n      positioning == OverlayPositioning.TOP_RIGHT\n    ) {\n      posX = '-100%';\n    } else if (\n      positioning == OverlayPositioning.BOTTOM_CENTER ||\n      positioning == OverlayPositioning.CENTER_CENTER ||\n      positioning == OverlayPositioning.TOP_CENTER\n    ) {\n      posX = '-50%';\n    }\n    if (\n      positioning == OverlayPositioning.BOTTOM_LEFT ||\n      positioning == OverlayPositioning.BOTTOM_CENTER ||\n      positioning == OverlayPositioning.BOTTOM_RIGHT\n    ) {\n      posY = '-100%';\n    } else if (\n      positioning == OverlayPositioning.CENTER_LEFT ||\n      positioning == OverlayPositioning.CENTER_CENTER ||\n      positioning == OverlayPositioning.CENTER_RIGHT\n    ) {\n      posY = '-50%';\n    }\n    const transform = `translate(${posX}, ${posY}) translate(${x}, ${y})`;\n    if (this.rendered.transform_ != transform) {\n      this.rendered.transform_ = transform;\n      style.transform = transform;\n      // @ts-ignore IE9\n      style.msTransform = transform;\n    }\n  }\n\n  /**\n   * returns the options this Overlay has been created with\n   * @return {Options} overlay options\n   */\n  getOptions() {\n    return this.options;\n  }\n}\n\nexport default Overlay;\n","/**\n * @module ol/layer/TileProperty\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  PRELOAD: 'preload',\n  USE_INTERIM_TILES_ON_ERROR: 'useInterimTilesOnError',\n};\n","/**\n * @module ol/layer/BaseTile\n */\nimport Layer from './Layer.js';\nimport TileProperty from './TileProperty.js';\nimport {assign} from '../obj.js';\n\n/**\n * @typedef {Object} Options\n * @property {string} [className='ol-layer'] A CSS class name to set to the layer element.\n * @property {number} [opacity=1] Opacity (0, 1).\n * @property {boolean} [visible=true] Visibility.\n * @property {import(\"../extent.js\").Extent} [extent] The bounding extent for layer rendering.  The layer will not be\n * rendered outside of this extent.\n * @property {number} [zIndex] The z-index for layer rendering.  At rendering time, the layers\n * will be ordered, first by Z-index and then by position. When `undefined`, a `zIndex` of 0 is assumed\n * for layers that are added to the map's `layers` collection, or `Infinity` when the layer's `setMap()`\n * method was used.\n * @property {number} [minResolution] The minimum resolution (inclusive) at which this layer will be\n * visible.\n * @property {number} [maxResolution] The maximum resolution (exclusive) below which this layer will\n * be visible.\n * @property {number} [minZoom] The minimum view zoom level (exclusive) above which this layer will be\n * visible.\n * @property {number} [maxZoom] The maximum view zoom level (inclusive) at which this layer will\n * be visible.\n * @property {number} [preload=0] Preload. Load low-resolution tiles up to `preload` levels. `0`\n * means no preloading.\n * @property {import(\"../source/Tile.js\").default} [source] Source for this layer.\n * @property {import(\"../PluggableMap.js\").default} [map] Sets the layer as overlay on a map. The map will not manage\n * this layer in its layers collection, and the layer will be rendered on top. This is useful for\n * temporary layers. The standard way to add a layer to a map and have it managed by the map is to\n * use {@link module:ol/Map#addLayer}.\n * @property {boolean} [useInterimTilesOnError=true] Use interim tiles on error.\n */\n\n/**\n * @classdesc\n * For layer sources that provide pre-rendered, tiled images in grids that are\n * organized by zoom levels for specific resolutions.\n * Note that any property set in the options is set as a {@link module:ol/Object~BaseObject}\n * property on the layer object; for example, setting `title: 'My Title'` in the\n * options means that `title` is observable, and has get/set accessors.\n *\n * @extends {Layer<import(\"../source/Tile.js\").default>}\n * @api\n */\nclass BaseTileLayer extends Layer {\n  /**\n   * @param {Options=} opt_options Tile layer options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    const baseOptions = assign({}, options);\n\n    delete baseOptions.preload;\n    delete baseOptions.useInterimTilesOnError;\n    super(baseOptions);\n\n    this.setPreload(options.preload !== undefined ? options.preload : 0);\n    this.setUseInterimTilesOnError(\n      options.useInterimTilesOnError !== undefined\n        ? options.useInterimTilesOnError\n        : true\n    );\n  }\n\n  /**\n   * Return the level as number to which we will preload tiles up to.\n   * @return {number} The level to preload tiles up to.\n   * @observable\n   * @api\n   */\n  getPreload() {\n    return /** @type {number} */ (this.get(TileProperty.PRELOAD));\n  }\n\n  /**\n   * Set the level as number to which we will preload tiles up to.\n   * @param {number} preload The level to preload tiles up to.\n   * @observable\n   * @api\n   */\n  setPreload(preload) {\n    this.set(TileProperty.PRELOAD, preload);\n  }\n\n  /**\n   * Whether we use interim tiles on error.\n   * @return {boolean} Use interim tiles on error.\n   * @observable\n   * @api\n   */\n  getUseInterimTilesOnError() {\n    return /** @type {boolean} */ (this.get(\n      TileProperty.USE_INTERIM_TILES_ON_ERROR\n    ));\n  }\n\n  /**\n   * Set whether we use interim tiles on error.\n   * @param {boolean} useInterimTilesOnError Use interim tiles on error.\n   * @observable\n   * @api\n   */\n  setUseInterimTilesOnError(useInterimTilesOnError) {\n    this.set(TileProperty.USE_INTERIM_TILES_ON_ERROR, useInterimTilesOnError);\n  }\n}\n\nexport default BaseTileLayer;\n","/**\n * @module ol/renderer/Layer\n */\nimport EventType from '../events/EventType.js';\nimport ImageState from '../ImageState.js';\nimport Observable from '../Observable.js';\nimport SourceState from '../source/State.js';\nimport {abstract} from '../util.js';\n\n/**\n * @template {import(\"../layer/Layer.js\").default} LayerType\n */\nclass LayerRenderer extends Observable {\n  /**\n   * @param {LayerType} layer Layer.\n   */\n  constructor(layer) {\n    super();\n\n    /** @private */\n    this.boundHandleImageChange_ = this.handleImageChange_.bind(this);\n\n    /**\n     * @protected\n     * @type {LayerType}\n     */\n    this.layer_ = layer;\n\n    /**\n     * @type {import(\"../render/canvas/ExecutorGroup\").default}\n     */\n    this.declutterExecutorGroup = null;\n  }\n\n  /**\n   * Asynchronous layer level hit detection.\n   * @param {import(\"../pixel.js\").Pixel} pixel Pixel.\n   * @return {Promise<Array<import(\"../Feature\").default>>} Promise that resolves with\n   * an array of features.\n   */\n  getFeatures(pixel) {\n    return abstract();\n  }\n\n  /**\n   * Determine whether render should be called.\n   * @abstract\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   * @return {boolean} Layer is ready to be rendered.\n   */\n  prepareFrame(frameState) {\n    return abstract();\n  }\n\n  /**\n   * Render the layer.\n   * @abstract\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {HTMLElement} target Target that may be used to render content to.\n   * @return {HTMLElement} The rendered element.\n   */\n  renderFrame(frameState, target) {\n    return abstract();\n  }\n\n  /**\n   * @param {Object<number, Object<string, import(\"../Tile.js\").default>>} tiles Lookup of loaded tiles by zoom level.\n   * @param {number} zoom Zoom level.\n   * @param {import(\"../Tile.js\").default} tile Tile.\n   * @return {boolean|void} If `false`, the tile will not be considered loaded.\n   */\n  loadedTileCallback(tiles, zoom, tile) {\n    if (!tiles[zoom]) {\n      tiles[zoom] = {};\n    }\n    tiles[zoom][tile.tileCoord.toString()] = tile;\n    return undefined;\n  }\n\n  /**\n   * Create a function that adds loaded tiles to the tile lookup.\n   * @param {import(\"../source/Tile.js\").default} source Tile source.\n   * @param {import(\"../proj/Projection.js\").default} projection Projection of the tiles.\n   * @param {Object<number, Object<string, import(\"../Tile.js\").default>>} tiles Lookup of loaded tiles by zoom level.\n   * @return {function(number, import(\"../TileRange.js\").default):boolean} A function that can be\n   *     called with a zoom level and a tile range to add loaded tiles to the lookup.\n   * @protected\n   */\n  createLoadedTileFinder(source, projection, tiles) {\n    return (\n      /**\n       * @param {number} zoom Zoom level.\n       * @param {import(\"../TileRange.js\").default} tileRange Tile range.\n       * @return {boolean} The tile range is fully loaded.\n       * @this {LayerRenderer}\n       */\n      function (zoom, tileRange) {\n        const callback = this.loadedTileCallback.bind(this, tiles, zoom);\n        return source.forEachLoadedTile(projection, zoom, tileRange, callback);\n      }.bind(this)\n    );\n  }\n  /**\n   * @abstract\n   * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {number} hitTolerance Hit tolerance in pixels.\n   * @param {import(\"./vector.js\").FeatureCallback<T>} callback Feature callback.\n   * @param {Array<import(\"./Map.js\").HitMatch<T>>} matches The hit detected matches with tolerance.\n   * @return {T|undefined} Callback result.\n   * @template T\n   */\n  forEachFeatureAtCoordinate(\n    coordinate,\n    frameState,\n    hitTolerance,\n    callback,\n    matches\n  ) {\n    return undefined;\n  }\n\n  /**\n   * @abstract\n   * @param {import(\"../pixel.js\").Pixel} pixel Pixel.\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState FrameState.\n   * @param {number} hitTolerance Hit tolerance in pixels.\n   * @return {Uint8ClampedArray|Uint8Array} The result.  If there is no data at the pixel\n   *    location, null will be returned.  If there is data, but pixel values cannot be\n   *    returned, and empty array will be returned.\n   */\n  getDataAtPixel(pixel, frameState, hitTolerance) {\n    return abstract();\n  }\n\n  /**\n   * @return {LayerType} Layer.\n   */\n  getLayer() {\n    return this.layer_;\n  }\n\n  /**\n   * Perform action necessary to get the layer rendered after new fonts have loaded\n   * @abstract\n   */\n  handleFontsChanged() {}\n\n  /**\n   * Handle changes in image state.\n   * @param {import(\"../events/Event.js\").default} event Image change event.\n   * @private\n   */\n  handleImageChange_(event) {\n    const image = /** @type {import(\"../Image.js\").default} */ (event.target);\n    if (image.getState() === ImageState.LOADED) {\n      this.renderIfReadyAndVisible();\n    }\n  }\n\n  /**\n   * Load the image if not already loaded, and register the image change\n   * listener if needed.\n   * @param {import(\"../ImageBase.js\").default} image Image.\n   * @return {boolean} `true` if the image is already loaded, `false` otherwise.\n   * @protected\n   */\n  loadImage(image) {\n    let imageState = image.getState();\n    if (imageState != ImageState.LOADED && imageState != ImageState.ERROR) {\n      image.addEventListener(EventType.CHANGE, this.boundHandleImageChange_);\n    }\n    if (imageState == ImageState.IDLE) {\n      image.load();\n      imageState = image.getState();\n    }\n    return imageState == ImageState.LOADED;\n  }\n\n  /**\n   * @protected\n   */\n  renderIfReadyAndVisible() {\n    const layer = this.getLayer();\n    if (layer.getVisible() && layer.getSourceState() == SourceState.READY) {\n      layer.changed();\n    }\n  }\n}\n\nexport default LayerRenderer;\n","/**\n * @module ol/renderer/canvas/Layer\n */\nimport LayerRenderer from '../Layer.js';\nimport RenderEvent from '../../render/Event.js';\nimport RenderEventType from '../../render/EventType.js';\nimport {\n  apply as applyTransform,\n  compose as composeTransform,\n  create as createTransform,\n} from '../../transform.js';\nimport {\n  containsCoordinate,\n  getBottomLeft,\n  getBottomRight,\n  getTopLeft,\n  getTopRight,\n} from '../../extent.js';\nimport {createCanvasContext2D} from '../../dom.js';\nimport {rotateAtOffset} from '../../render/canvas.js';\n\n/**\n * @abstract\n * @template {import(\"../../layer/Layer.js\").default} LayerType\n */\nclass CanvasLayerRenderer extends LayerRenderer {\n  /**\n   * @param {LayerType} layer Layer.\n   */\n  constructor(layer) {\n    super(layer);\n\n    /**\n     * @protected\n     * @type {HTMLElement}\n     */\n    this.container = null;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.renderedResolution;\n\n    /**\n     * A temporary transform.  The values in this transform should only be used in a\n     * function that sets the values.\n     * @protected\n     * @type {import(\"../../transform.js\").Transform}\n     */\n    this.tempTransform = createTransform();\n\n    /**\n     * The transform for rendered pixels to viewport CSS pixels.  This transform must\n     * be set when rendering a frame and may be used by other functions after rendering.\n     * @protected\n     * @type {import(\"../../transform.js\").Transform}\n     */\n    this.pixelTransform = createTransform();\n\n    /**\n     * The transform for viewport CSS pixels to rendered pixels.  This transform must\n     * be set when rendering a frame and may be used by other functions after rendering.\n     * @protected\n     * @type {import(\"../../transform.js\").Transform}\n     */\n    this.inversePixelTransform = createTransform();\n\n    /**\n     * @type {CanvasRenderingContext2D}\n     */\n    this.context = null;\n\n    /**\n     * @type {boolean}\n     */\n    this.containerReused = false;\n  }\n\n  /**\n   * Get a rendering container from an existing target, if compatible.\n   * @param {HTMLElement} target Potential render target.\n   * @param {string} transform CSS Transform.\n   * @param {number} opacity Opacity.\n   */\n  useContainer(target, transform, opacity) {\n    const layerClassName = this.getLayer().getClassName();\n    let container, context;\n    if (\n      target &&\n      target.style.opacity === '' &&\n      target.className === layerClassName\n    ) {\n      const canvas = target.firstElementChild;\n      if (canvas instanceof HTMLCanvasElement) {\n        context = canvas.getContext('2d');\n      }\n    }\n    if (\n      context &&\n      (context.canvas.width === 0 ||\n        context.canvas.style.transform === transform)\n    ) {\n      // Container of the previous layer renderer can be used.\n      this.container = target;\n      this.context = context;\n      this.containerReused = true;\n    } else if (this.containerReused) {\n      // Previously reused container cannot be used any more.\n      this.container = null;\n      this.context = null;\n      this.containerReused = false;\n    }\n    if (!this.container) {\n      container = document.createElement('div');\n      container.className = layerClassName;\n      let style = container.style;\n      style.position = 'absolute';\n      style.width = '100%';\n      style.height = '100%';\n      context = createCanvasContext2D();\n      const canvas = context.canvas;\n      container.appendChild(canvas);\n      style = canvas.style;\n      style.position = 'absolute';\n      style.left = '0';\n      style.transformOrigin = 'top left';\n      this.container = container;\n      this.context = context;\n    }\n  }\n\n  /**\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {import(\"../../extent.js\").Extent} extent Clip extent.\n   * @protected\n   */\n  clip(context, frameState, extent) {\n    const pixelRatio = frameState.pixelRatio;\n    const halfWidth = (frameState.size[0] * pixelRatio) / 2;\n    const halfHeight = (frameState.size[1] * pixelRatio) / 2;\n    const rotation = frameState.viewState.rotation;\n    const topLeft = getTopLeft(extent);\n    const topRight = getTopRight(extent);\n    const bottomRight = getBottomRight(extent);\n    const bottomLeft = getBottomLeft(extent);\n\n    applyTransform(frameState.coordinateToPixelTransform, topLeft);\n    applyTransform(frameState.coordinateToPixelTransform, topRight);\n    applyTransform(frameState.coordinateToPixelTransform, bottomRight);\n    applyTransform(frameState.coordinateToPixelTransform, bottomLeft);\n\n    context.save();\n    rotateAtOffset(context, -rotation, halfWidth, halfHeight);\n    context.beginPath();\n    context.moveTo(topLeft[0] * pixelRatio, topLeft[1] * pixelRatio);\n    context.lineTo(topRight[0] * pixelRatio, topRight[1] * pixelRatio);\n    context.lineTo(bottomRight[0] * pixelRatio, bottomRight[1] * pixelRatio);\n    context.lineTo(bottomLeft[0] * pixelRatio, bottomLeft[1] * pixelRatio);\n    context.clip();\n    rotateAtOffset(context, rotation, halfWidth, halfHeight);\n  }\n\n  /**\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {import(\"../../extent.js\").Extent} extent Clip extent.\n   * @protected\n   */\n  clipUnrotated(context, frameState, extent) {\n    const topLeft = getTopLeft(extent);\n    const topRight = getTopRight(extent);\n    const bottomRight = getBottomRight(extent);\n    const bottomLeft = getBottomLeft(extent);\n\n    applyTransform(frameState.coordinateToPixelTransform, topLeft);\n    applyTransform(frameState.coordinateToPixelTransform, topRight);\n    applyTransform(frameState.coordinateToPixelTransform, bottomRight);\n    applyTransform(frameState.coordinateToPixelTransform, bottomLeft);\n\n    const inverted = this.inversePixelTransform;\n    applyTransform(inverted, topLeft);\n    applyTransform(inverted, topRight);\n    applyTransform(inverted, bottomRight);\n    applyTransform(inverted, bottomLeft);\n\n    context.save();\n    context.beginPath();\n    context.moveTo(Math.round(topLeft[0]), Math.round(topLeft[1]));\n    context.lineTo(Math.round(topRight[0]), Math.round(topRight[1]));\n    context.lineTo(Math.round(bottomRight[0]), Math.round(bottomRight[1]));\n    context.lineTo(Math.round(bottomLeft[0]), Math.round(bottomLeft[1]));\n    context.clip();\n  }\n\n  /**\n   * @param {import(\"../../render/EventType.js\").default} type Event type.\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @private\n   */\n  dispatchRenderEvent_(type, context, frameState) {\n    const layer = this.getLayer();\n    if (layer.hasListener(type)) {\n      const event = new RenderEvent(\n        type,\n        this.inversePixelTransform,\n        frameState,\n        context\n      );\n      layer.dispatchEvent(event);\n    }\n  }\n\n  /**\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @protected\n   */\n  preRender(context, frameState) {\n    this.dispatchRenderEvent_(RenderEventType.PRERENDER, context, frameState);\n  }\n\n  /**\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @protected\n   */\n  postRender(context, frameState) {\n    this.dispatchRenderEvent_(RenderEventType.POSTRENDER, context, frameState);\n  }\n\n  /**\n   * Creates a transform for rendering to an element that will be rotated after rendering.\n   * @param {import(\"../../coordinate.js\").Coordinate} center Center.\n   * @param {number} resolution Resolution.\n   * @param {number} rotation Rotation.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {number} width Width of the rendered element (in pixels).\n   * @param {number} height Height of the rendered element (in pixels).\n   * @param {number} offsetX Offset on the x-axis in view coordinates.\n   * @protected\n   * @return {!import(\"../../transform.js\").Transform} Transform.\n   */\n  getRenderTransform(\n    center,\n    resolution,\n    rotation,\n    pixelRatio,\n    width,\n    height,\n    offsetX\n  ) {\n    const dx1 = width / 2;\n    const dy1 = height / 2;\n    const sx = pixelRatio / resolution;\n    const sy = -sx;\n    const dx2 = -center[0] + offsetX;\n    const dy2 = -center[1];\n    return composeTransform(\n      this.tempTransform,\n      dx1,\n      dy1,\n      sx,\n      sy,\n      -rotation,\n      dx2,\n      dy2\n    );\n  }\n\n  /**\n   * @param {import(\"../../pixel.js\").Pixel} pixel Pixel.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState FrameState.\n   * @param {number} hitTolerance Hit tolerance in pixels.\n   * @return {Uint8ClampedArray|Uint8Array} The result.  If there is no data at the pixel\n   *    location, null will be returned.  If there is data, but pixel values cannot be\n   *    returned, and empty array will be returned.\n   */\n  getDataAtPixel(pixel, frameState, hitTolerance) {\n    const renderPixel = applyTransform(\n      this.inversePixelTransform,\n      pixel.slice()\n    );\n    const context = this.context;\n\n    const layer = this.getLayer();\n    const layerExtent = layer.getExtent();\n    if (layerExtent) {\n      const renderCoordinate = applyTransform(\n        frameState.pixelToCoordinateTransform,\n        pixel.slice()\n      );\n\n      /** get only data inside of the layer extent */\n      if (!containsCoordinate(layerExtent, renderCoordinate)) {\n        return null;\n      }\n    }\n\n    let data;\n    try {\n      const x = Math.round(renderPixel[0]);\n      const y = Math.round(renderPixel[1]);\n      const newCanvas = document.createElement('canvas');\n      const newContext = newCanvas.getContext('2d');\n      newCanvas.width = 1;\n      newCanvas.height = 1;\n      newContext.clearRect(0, 0, 1, 1);\n      newContext.drawImage(context.canvas, x, y, 1, 1, 0, 0, 1, 1);\n      data = newContext.getImageData(0, 0, 1, 1).data;\n    } catch (err) {\n      if (err.name === 'SecurityError') {\n        // tainted canvas, we assume there is data at the given pixel (although there might not be)\n        return new Uint8Array();\n      }\n      return data;\n    }\n\n    if (data[3] === 0) {\n      return null;\n    }\n    return data;\n  }\n}\n\nexport default CanvasLayerRenderer;\n","/**\n * @module ol/TileRange\n */\n\n/**\n * A representation of a contiguous block of tiles.  A tile range is specified\n * by its min/max tile coordinates and is inclusive of coordinates.\n */\nclass TileRange {\n  /**\n   * @param {number} minX Minimum X.\n   * @param {number} maxX Maximum X.\n   * @param {number} minY Minimum Y.\n   * @param {number} maxY Maximum Y.\n   */\n  constructor(minX, maxX, minY, maxY) {\n    /**\n     * @type {number}\n     */\n    this.minX = minX;\n\n    /**\n     * @type {number}\n     */\n    this.maxX = maxX;\n\n    /**\n     * @type {number}\n     */\n    this.minY = minY;\n\n    /**\n     * @type {number}\n     */\n    this.maxY = maxY;\n  }\n\n  /**\n   * @param {import(\"./tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @return {boolean} Contains tile coordinate.\n   */\n  contains(tileCoord) {\n    return this.containsXY(tileCoord[1], tileCoord[2]);\n  }\n\n  /**\n   * @param {TileRange} tileRange Tile range.\n   * @return {boolean} Contains.\n   */\n  containsTileRange(tileRange) {\n    return (\n      this.minX <= tileRange.minX &&\n      tileRange.maxX <= this.maxX &&\n      this.minY <= tileRange.minY &&\n      tileRange.maxY <= this.maxY\n    );\n  }\n\n  /**\n   * @param {number} x Tile coordinate x.\n   * @param {number} y Tile coordinate y.\n   * @return {boolean} Contains coordinate.\n   */\n  containsXY(x, y) {\n    return this.minX <= x && x <= this.maxX && this.minY <= y && y <= this.maxY;\n  }\n\n  /**\n   * @param {TileRange} tileRange Tile range.\n   * @return {boolean} Equals.\n   */\n  equals(tileRange) {\n    return (\n      this.minX == tileRange.minX &&\n      this.minY == tileRange.minY &&\n      this.maxX == tileRange.maxX &&\n      this.maxY == tileRange.maxY\n    );\n  }\n\n  /**\n   * @param {TileRange} tileRange Tile range.\n   */\n  extend(tileRange) {\n    if (tileRange.minX < this.minX) {\n      this.minX = tileRange.minX;\n    }\n    if (tileRange.maxX > this.maxX) {\n      this.maxX = tileRange.maxX;\n    }\n    if (tileRange.minY < this.minY) {\n      this.minY = tileRange.minY;\n    }\n    if (tileRange.maxY > this.maxY) {\n      this.maxY = tileRange.maxY;\n    }\n  }\n\n  /**\n   * @return {number} Height.\n   */\n  getHeight() {\n    return this.maxY - this.minY + 1;\n  }\n\n  /**\n   * @return {import(\"./size.js\").Size} Size.\n   */\n  getSize() {\n    return [this.getWidth(), this.getHeight()];\n  }\n\n  /**\n   * @return {number} Width.\n   */\n  getWidth() {\n    return this.maxX - this.minX + 1;\n  }\n\n  /**\n   * @param {TileRange} tileRange Tile range.\n   * @return {boolean} Intersects.\n   */\n  intersects(tileRange) {\n    return (\n      this.minX <= tileRange.maxX &&\n      this.maxX >= tileRange.minX &&\n      this.minY <= tileRange.maxY &&\n      this.maxY >= tileRange.minY\n    );\n  }\n}\n\n/**\n * @param {number} minX Minimum X.\n * @param {number} maxX Maximum X.\n * @param {number} minY Minimum Y.\n * @param {number} maxY Maximum Y.\n * @param {TileRange=} tileRange TileRange.\n * @return {TileRange} Tile range.\n */\nexport function createOrUpdate(minX, maxX, minY, maxY, tileRange) {\n  if (tileRange !== undefined) {\n    tileRange.minX = minX;\n    tileRange.maxX = maxX;\n    tileRange.minY = minY;\n    tileRange.maxY = maxY;\n    return tileRange;\n  } else {\n    return new TileRange(minX, maxX, minY, maxY);\n  }\n}\n\nexport default TileRange;\n","/**\n * @module ol/renderer/canvas/TileLayer\n */\nimport CanvasLayerRenderer from './Layer.js';\nimport TileRange from '../../TileRange.js';\nimport TileState from '../../TileState.js';\nimport {\n  apply as applyTransform,\n  compose as composeTransform,\n  makeInverse,\n} from '../../transform.js';\nimport {assign} from '../../obj.js';\nimport {\n  createEmpty,\n  equals,\n  getIntersection,\n  getTopLeft,\n} from '../../extent.js';\nimport {createTransformString} from '../../render/canvas.js';\nimport {fromUserExtent} from '../../proj.js';\nimport {getUid} from '../../util.js';\nimport {numberSafeCompareFunction} from '../../array.js';\n\n/**\n * @classdesc\n * Canvas renderer for tile layers.\n * @api\n */\nclass CanvasTileLayerRenderer extends CanvasLayerRenderer {\n  /**\n   * @param {import(\"../../layer/Tile.js\").default|import(\"../../layer/VectorTile.js\").default} tileLayer Tile layer.\n   */\n  constructor(tileLayer) {\n    super(tileLayer);\n\n    /**\n     * Rendered extent has changed since the previous `renderFrame()` call\n     * @type {boolean}\n     */\n    this.extentChanged = true;\n\n    /**\n     * @private\n     * @type {?import(\"../../extent.js\").Extent}\n     */\n    this.renderedExtent_ = null;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.renderedPixelRatio;\n\n    /**\n     * @protected\n     * @type {import(\"../../proj/Projection.js\").default}\n     */\n    this.renderedProjection = null;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.renderedRevision;\n\n    /**\n     * @protected\n     * @type {!Array<import(\"../../Tile.js\").default>}\n     */\n    this.renderedTiles = [];\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.newTiles_ = false;\n\n    /**\n     * @protected\n     * @type {import(\"../../extent.js\").Extent}\n     */\n    this.tmpExtent = createEmpty();\n\n    /**\n     * @private\n     * @type {import(\"../../TileRange.js\").default}\n     */\n    this.tmpTileRange_ = new TileRange(0, 0, 0, 0);\n  }\n\n  /**\n   * @protected\n   * @param {import(\"../../Tile.js\").default} tile Tile.\n   * @return {boolean} Tile is drawable.\n   */\n  isDrawableTile(tile) {\n    const tileLayer = this.getLayer();\n    const tileState = tile.getState();\n    const useInterimTilesOnError = tileLayer.getUseInterimTilesOnError();\n    return (\n      tileState == TileState.LOADED ||\n      tileState == TileState.EMPTY ||\n      (tileState == TileState.ERROR && !useInterimTilesOnError)\n    );\n  }\n\n  /**\n   * @param {number} z Tile coordinate z.\n   * @param {number} x Tile coordinate x.\n   * @param {number} y Tile coordinate y.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @return {!import(\"../../Tile.js\").default} Tile.\n   */\n  getTile(z, x, y, frameState) {\n    const pixelRatio = frameState.pixelRatio;\n    const projection = frameState.viewState.projection;\n    const tileLayer = this.getLayer();\n    const tileSource = tileLayer.getSource();\n    let tile = tileSource.getTile(z, x, y, pixelRatio, projection);\n    if (tile.getState() == TileState.ERROR) {\n      if (!tileLayer.getUseInterimTilesOnError()) {\n        // When useInterimTilesOnError is false, we consider the error tile as loaded.\n        tile.setState(TileState.LOADED);\n      } else if (tileLayer.getPreload() > 0) {\n        // Preloaded tiles for lower resolutions might have finished loading.\n        this.newTiles_ = true;\n      }\n    }\n    if (!this.isDrawableTile(tile)) {\n      tile = tile.getInterimTile();\n    }\n    return tile;\n  }\n\n  /**\n   * @param {Object<number, Object<string, import(\"../../Tile.js\").default>>} tiles Lookup of loaded tiles by zoom level.\n   * @param {number} zoom Zoom level.\n   * @param {import(\"../../Tile.js\").default} tile Tile.\n   * @return {boolean|void} If `false`, the tile will not be considered loaded.\n   */\n  loadedTileCallback(tiles, zoom, tile) {\n    if (this.isDrawableTile(tile)) {\n      return super.loadedTileCallback(tiles, zoom, tile);\n    }\n    return false;\n  }\n\n  /**\n   * Determine whether render should be called.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @return {boolean} Layer is ready to be rendered.\n   */\n  prepareFrame(frameState) {\n    return !!this.getLayer().getSource();\n  }\n\n  /**\n   * Render the layer.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {HTMLElement} target Target that may be used to render content to.\n   * @return {HTMLElement} The rendered element.\n   */\n  renderFrame(frameState, target) {\n    const layerState = frameState.layerStatesArray[frameState.layerIndex];\n    const viewState = frameState.viewState;\n    const projection = viewState.projection;\n    const viewResolution = viewState.resolution;\n    const viewCenter = viewState.center;\n    const rotation = viewState.rotation;\n    const pixelRatio = frameState.pixelRatio;\n\n    const tileLayer = this.getLayer();\n    const tileSource = tileLayer.getSource();\n    const sourceRevision = tileSource.getRevision();\n    const tileGrid = tileSource.getTileGridForProjection(projection);\n    const z = tileGrid.getZForResolution(viewResolution, tileSource.zDirection);\n    const tileResolution = tileGrid.getResolution(z);\n\n    let extent = frameState.extent;\n    const layerExtent =\n      layerState.extent && fromUserExtent(layerState.extent, projection);\n    if (layerExtent) {\n      extent = getIntersection(\n        extent,\n        fromUserExtent(layerState.extent, projection)\n      );\n    }\n\n    const tilePixelRatio = tileSource.getTilePixelRatio(pixelRatio);\n\n    // desired dimensions of the canvas in pixels\n    let width = Math.round(frameState.size[0] * tilePixelRatio);\n    let height = Math.round(frameState.size[1] * tilePixelRatio);\n\n    if (rotation) {\n      const size = Math.round(Math.sqrt(width * width + height * height));\n      width = size;\n      height = size;\n    }\n\n    const dx = (tileResolution * width) / 2 / tilePixelRatio;\n    const dy = (tileResolution * height) / 2 / tilePixelRatio;\n    const canvasExtent = [\n      viewCenter[0] - dx,\n      viewCenter[1] - dy,\n      viewCenter[0] + dx,\n      viewCenter[1] + dy,\n    ];\n\n    const tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);\n\n    /**\n     * @type {Object<number, Object<string, import(\"../../Tile.js\").default>>}\n     */\n    const tilesToDrawByZ = {};\n    tilesToDrawByZ[z] = {};\n\n    const findLoadedTiles = this.createLoadedTileFinder(\n      tileSource,\n      projection,\n      tilesToDrawByZ\n    );\n\n    const tmpExtent = this.tmpExtent;\n    const tmpTileRange = this.tmpTileRange_;\n    this.newTiles_ = false;\n    for (let x = tileRange.minX; x <= tileRange.maxX; ++x) {\n      for (let y = tileRange.minY; y <= tileRange.maxY; ++y) {\n        const tile = this.getTile(z, x, y, frameState);\n        if (this.isDrawableTile(tile)) {\n          const uid = getUid(this);\n          if (tile.getState() == TileState.LOADED) {\n            tilesToDrawByZ[z][tile.tileCoord.toString()] = tile;\n            const inTransition = tile.inTransition(uid);\n            if (\n              !this.newTiles_ &&\n              (inTransition || this.renderedTiles.indexOf(tile) === -1)\n            ) {\n              this.newTiles_ = true;\n            }\n          }\n          if (tile.getAlpha(uid, frameState.time) === 1) {\n            // don't look for alt tiles if alpha is 1\n            continue;\n          }\n        }\n\n        const childTileRange = tileGrid.getTileCoordChildTileRange(\n          tile.tileCoord,\n          tmpTileRange,\n          tmpExtent\n        );\n\n        let covered = false;\n        if (childTileRange) {\n          covered = findLoadedTiles(z + 1, childTileRange);\n        }\n        if (!covered) {\n          tileGrid.forEachTileCoordParentTileRange(\n            tile.tileCoord,\n            findLoadedTiles,\n            tmpTileRange,\n            tmpExtent\n          );\n        }\n      }\n    }\n\n    const canvasScale = tileResolution / viewResolution;\n\n    // set forward and inverse pixel transforms\n    composeTransform(\n      this.pixelTransform,\n      frameState.size[0] / 2,\n      frameState.size[1] / 2,\n      1 / tilePixelRatio,\n      1 / tilePixelRatio,\n      rotation,\n      -width / 2,\n      -height / 2\n    );\n\n    const canvasTransform = createTransformString(this.pixelTransform);\n\n    this.useContainer(target, canvasTransform, layerState.opacity);\n    const context = this.context;\n    const canvas = context.canvas;\n\n    makeInverse(this.inversePixelTransform, this.pixelTransform);\n\n    // set scale transform for calculating tile positions on the canvas\n    composeTransform(\n      this.tempTransform,\n      width / 2,\n      height / 2,\n      canvasScale,\n      canvasScale,\n      0,\n      -width / 2,\n      -height / 2\n    );\n\n    if (canvas.width != width || canvas.height != height) {\n      canvas.width = width;\n      canvas.height = height;\n    } else if (!this.containerReused) {\n      context.clearRect(0, 0, width, height);\n    }\n\n    if (layerExtent) {\n      this.clipUnrotated(context, frameState, layerExtent);\n    }\n\n    assign(context, tileSource.getContextOptions());\n    this.preRender(context, frameState);\n\n    this.renderedTiles.length = 0;\n    /** @type {Array<number>} */\n    let zs = Object.keys(tilesToDrawByZ).map(Number);\n    zs.sort(numberSafeCompareFunction);\n\n    let clips, clipZs, currentClip;\n    if (\n      layerState.opacity === 1 &&\n      (!this.containerReused ||\n        tileSource.getOpaque(frameState.viewState.projection))\n    ) {\n      zs = zs.reverse();\n    } else {\n      clips = [];\n      clipZs = [];\n    }\n    for (let i = zs.length - 1; i >= 0; --i) {\n      const currentZ = zs[i];\n      const currentTilePixelSize = tileSource.getTilePixelSize(\n        currentZ,\n        pixelRatio,\n        projection\n      );\n      const currentResolution = tileGrid.getResolution(currentZ);\n      const currentScale = currentResolution / tileResolution;\n      const dx = currentTilePixelSize[0] * currentScale * canvasScale;\n      const dy = currentTilePixelSize[1] * currentScale * canvasScale;\n      const originTileCoord = tileGrid.getTileCoordForCoordAndZ(\n        getTopLeft(canvasExtent),\n        currentZ\n      );\n      const originTileExtent = tileGrid.getTileCoordExtent(originTileCoord);\n      const origin = applyTransform(this.tempTransform, [\n        (tilePixelRatio * (originTileExtent[0] - canvasExtent[0])) /\n          tileResolution,\n        (tilePixelRatio * (canvasExtent[3] - originTileExtent[3])) /\n          tileResolution,\n      ]);\n      const tileGutter =\n        tilePixelRatio * tileSource.getGutterForProjection(projection);\n      const tilesToDraw = tilesToDrawByZ[currentZ];\n      for (const tileCoordKey in tilesToDraw) {\n        const tile = /** @type {import(\"../../ImageTile.js\").default} */ (tilesToDraw[\n          tileCoordKey\n        ]);\n        const tileCoord = tile.tileCoord;\n\n        // Calculate integer positions and sizes so that tiles align\n        const floatX = origin[0] - (originTileCoord[1] - tileCoord[1]) * dx;\n        const nextX = Math.round(floatX + dx);\n        const floatY = origin[1] - (originTileCoord[2] - tileCoord[2]) * dy;\n        const nextY = Math.round(floatY + dy);\n        const x = Math.round(floatX);\n        const y = Math.round(floatY);\n        const w = nextX - x;\n        const h = nextY - y;\n        const transition = z === currentZ;\n\n        const inTransition =\n          transition && tile.getAlpha(getUid(this), frameState.time) !== 1;\n        if (!inTransition) {\n          if (clips) {\n            // Clip mask for regions in this tile that already filled by a higher z tile\n            context.save();\n            currentClip = [x, y, x + w, y, x + w, y + h, x, y + h];\n            for (let i = 0, ii = clips.length; i < ii; ++i) {\n              if (z !== currentZ && currentZ < clipZs[i]) {\n                const clip = clips[i];\n                context.beginPath();\n                // counter-clockwise (outer ring) for current tile\n                context.moveTo(currentClip[0], currentClip[1]);\n                context.lineTo(currentClip[2], currentClip[3]);\n                context.lineTo(currentClip[4], currentClip[5]);\n                context.lineTo(currentClip[6], currentClip[7]);\n                // clockwise (inner ring) for higher z tile\n                context.moveTo(clip[6], clip[7]);\n                context.lineTo(clip[4], clip[5]);\n                context.lineTo(clip[2], clip[3]);\n                context.lineTo(clip[0], clip[1]);\n                context.clip();\n              }\n            }\n            clips.push(currentClip);\n            clipZs.push(currentZ);\n          } else {\n            context.clearRect(x, y, w, h);\n          }\n        }\n        this.drawTileImage(\n          tile,\n          frameState,\n          x,\n          y,\n          w,\n          h,\n          tileGutter,\n          transition,\n          layerState.opacity\n        );\n        if (clips && !inTransition) {\n          context.restore();\n        }\n        this.renderedTiles.push(tile);\n        this.updateUsedTiles(frameState.usedTiles, tileSource, tile);\n      }\n    }\n\n    this.renderedRevision = sourceRevision;\n    this.renderedResolution = tileResolution;\n    this.extentChanged =\n      !this.renderedExtent_ || !equals(this.renderedExtent_, canvasExtent);\n    this.renderedExtent_ = canvasExtent;\n    this.renderedPixelRatio = pixelRatio;\n    this.renderedProjection = projection;\n\n    this.manageTilePyramid(\n      frameState,\n      tileSource,\n      tileGrid,\n      pixelRatio,\n      projection,\n      extent,\n      z,\n      tileLayer.getPreload()\n    );\n    this.scheduleExpireCache(frameState, tileSource);\n\n    this.postRender(context, frameState);\n\n    if (layerState.extent) {\n      context.restore();\n    }\n\n    if (canvasTransform !== canvas.style.transform) {\n      canvas.style.transform = canvasTransform;\n    }\n\n    return this.container;\n  }\n\n  /**\n   * @param {import(\"../../ImageTile.js\").default} tile Tile.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {number} x Left of the tile.\n   * @param {number} y Top of the tile.\n   * @param {number} w Width of the tile.\n   * @param {number} h Height of the tile.\n   * @param {number} gutter Tile gutter.\n   * @param {boolean} transition Apply an alpha transition.\n   * @param {number} opacity Opacity.\n   */\n  drawTileImage(tile, frameState, x, y, w, h, gutter, transition, opacity) {\n    const image = this.getTileImage(tile);\n    if (!image) {\n      return;\n    }\n    const uid = getUid(this);\n    const tileAlpha = transition ? tile.getAlpha(uid, frameState.time) : 1;\n    const alpha = opacity * tileAlpha;\n    const alphaChanged = alpha !== this.context.globalAlpha;\n    if (alphaChanged) {\n      this.context.save();\n      this.context.globalAlpha = alpha;\n    }\n    this.context.drawImage(\n      image,\n      gutter,\n      gutter,\n      image.width - 2 * gutter,\n      image.height - 2 * gutter,\n      x,\n      y,\n      w,\n      h\n    );\n\n    if (alphaChanged) {\n      this.context.restore();\n    }\n    if (tileAlpha !== 1) {\n      frameState.animate = true;\n    } else if (transition) {\n      tile.endTransition(uid);\n    }\n  }\n\n  /**\n   * @return {HTMLCanvasElement} Image\n   */\n  getImage() {\n    const context = this.context;\n    return context ? context.canvas : null;\n  }\n\n  /**\n   * Get the image from a tile.\n   * @param {import(\"../../ImageTile.js\").default} tile Tile.\n   * @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.\n   * @protected\n   */\n  getTileImage(tile) {\n    return tile.getImage();\n  }\n\n  /**\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {import(\"../../source/Tile.js\").default} tileSource Tile source.\n   * @protected\n   */\n  scheduleExpireCache(frameState, tileSource) {\n    if (tileSource.canExpireCache()) {\n      /**\n       * @param {import(\"../../source/Tile.js\").default} tileSource Tile source.\n       * @param {import(\"../../PluggableMap.js\").default} map Map.\n       * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n       */\n      const postRenderFunction = function (tileSource, map, frameState) {\n        const tileSourceKey = getUid(tileSource);\n        if (tileSourceKey in frameState.usedTiles) {\n          tileSource.expireCache(\n            frameState.viewState.projection,\n            frameState.usedTiles[tileSourceKey]\n          );\n        }\n      }.bind(null, tileSource);\n\n      frameState.postRenderFunctions.push(\n        /** @type {import(\"../../PluggableMap.js\").PostRenderFunction} */ (postRenderFunction)\n      );\n    }\n  }\n\n  /**\n   * @param {!Object<string, !Object<string, boolean>>} usedTiles Used tiles.\n   * @param {import(\"../../source/Tile.js\").default} tileSource Tile source.\n   * @param {import('../../Tile.js').default} tile Tile.\n   * @protected\n   */\n  updateUsedTiles(usedTiles, tileSource, tile) {\n    // FIXME should we use tilesToDrawByZ instead?\n    const tileSourceKey = getUid(tileSource);\n    if (!(tileSourceKey in usedTiles)) {\n      usedTiles[tileSourceKey] = {};\n    }\n    usedTiles[tileSourceKey][tile.getKey()] = true;\n  }\n\n  /**\n   * Manage tile pyramid.\n   * This function performs a number of functions related to the tiles at the\n   * current zoom and lower zoom levels:\n   * - registers idle tiles in frameState.wantedTiles so that they are not\n   *   discarded by the tile queue\n   * - enqueues missing tiles\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {import(\"../../source/Tile.js\").default} tileSource Tile source.\n   * @param {import(\"../../tilegrid/TileGrid.js\").default} tileGrid Tile grid.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {import(\"../../proj/Projection.js\").default} projection Projection.\n   * @param {import(\"../../extent.js\").Extent} extent Extent.\n   * @param {number} currentZ Current Z.\n   * @param {number} preload Load low resolution tiles up to 'preload' levels.\n   * @param {function(import(\"../../Tile.js\").default)=} opt_tileCallback Tile callback.\n   * @protected\n   */\n  manageTilePyramid(\n    frameState,\n    tileSource,\n    tileGrid,\n    pixelRatio,\n    projection,\n    extent,\n    currentZ,\n    preload,\n    opt_tileCallback\n  ) {\n    const tileSourceKey = getUid(tileSource);\n    if (!(tileSourceKey in frameState.wantedTiles)) {\n      frameState.wantedTiles[tileSourceKey] = {};\n    }\n    const wantedTiles = frameState.wantedTiles[tileSourceKey];\n    const tileQueue = frameState.tileQueue;\n    const minZoom = tileGrid.getMinZoom();\n    let tileCount = 0;\n    let tile, tileRange, tileResolution, x, y, z;\n    for (z = minZoom; z <= currentZ; ++z) {\n      tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z, tileRange);\n      tileResolution = tileGrid.getResolution(z);\n      for (x = tileRange.minX; x <= tileRange.maxX; ++x) {\n        for (y = tileRange.minY; y <= tileRange.maxY; ++y) {\n          if (currentZ - z <= preload) {\n            ++tileCount;\n            tile = tileSource.getTile(z, x, y, pixelRatio, projection);\n            if (tile.getState() == TileState.IDLE) {\n              wantedTiles[tile.getKey()] = true;\n              if (!tileQueue.isKeyQueued(tile.getKey())) {\n                tileQueue.enqueue([\n                  tile,\n                  tileSourceKey,\n                  tileGrid.getTileCoordCenter(tile.tileCoord),\n                  tileResolution,\n                ]);\n              }\n            }\n            if (opt_tileCallback !== undefined) {\n              opt_tileCallback(tile);\n            }\n          } else {\n            tileSource.useTile(z, x, y, projection);\n          }\n        }\n      }\n    }\n    tileSource.updateCacheSize(tileCount, projection);\n  }\n}\n\n/**\n * @function\n * @return {import(\"../../layer/Tile.js\").default|import(\"../../layer/VectorTile.js\").default}\n */\nCanvasTileLayerRenderer.prototype.getLayer;\n\nexport default CanvasTileLayerRenderer;\n","/**\n * @module ol/layer/Tile\n */\nimport BaseTileLayer from './BaseTile.js';\nimport CanvasTileLayerRenderer from '../renderer/canvas/TileLayer.js';\n\n/**\n * @classdesc\n * For layer sources that provide pre-rendered, tiled images in grids that are\n * organized by zoom levels for specific resolutions.\n * Note that any property set in the options is set as a {@link module:ol/Object~BaseObject}\n * property on the layer object; for example, setting `title: 'My Title'` in the\n * options means that `title` is observable, and has get/set accessors.\n *\n * @api\n */\nclass TileLayer extends BaseTileLayer {\n  /**\n   * @param {import(\"./BaseTile.js\").Options=} opt_options Tile layer options.\n   */\n  constructor(opt_options) {\n    super(opt_options);\n  }\n\n  /**\n   * Create a renderer for this layer.\n   * @return {import(\"../renderer/Layer.js\").default} A layer renderer.\n   * @protected\n   */\n  createRenderer() {\n    return new CanvasTileLayerRenderer(this);\n  }\n}\n\nexport default TileLayer;\n","/**\n * @module ol/source/common\n */\n\n/**\n * Default WMS version.\n * @type {string}\n */\nexport const DEFAULT_WMS_VERSION = '1.3.0';\n\n/**\n * Context options to disable image smoothing.\n * @type {Object}\n */\nexport const IMAGE_SMOOTHING_DISABLED = {\n  imageSmoothingEnabled: false,\n  msImageSmoothingEnabled: false,\n};\n","/**\n * @module ol/Tile\n */\nimport EventTarget from './events/Target.js';\nimport EventType from './events/EventType.js';\nimport TileState from './TileState.js';\nimport {abstract} from './util.js';\nimport {easeIn} from './easing.js';\n\n/**\n * A function that takes an {@link module:ol/Tile} for the tile and a\n * `{string}` for the url as arguments. The default is\n * ```js\n * source.setTileLoadFunction(function(tile, src) {\n *   tile.getImage().src = src;\n * });\n * ```\n * For more fine grained control, the load function can use fetch or XMLHttpRequest and involve\n * error handling:\n *\n * ```js\n * import TileState from 'ol/TileState';\n *\n * source.setTileLoadFunction(function(tile, src) {\n *   var xhr = new XMLHttpRequest();\n *   xhr.responseType = 'blob';\n *   xhr.addEventListener('loadend', function (evt) {\n *     var data = this.response;\n *     if (data !== undefined) {\n *       tile.getImage().src = URL.createObjectURL(data);\n *     } else {\n *       tile.setState(TileState.ERROR);\n *     }\n *   });\n *   xhr.addEventListener('error', function () {\n *     tile.setState(TileState.ERROR);\n *   });\n *   xhr.open('GET', src);\n *   xhr.send();\n * });\n * ```\n *\n * @typedef {function(Tile, string): void} LoadFunction\n * @api\n */\n\n/**\n * {@link module:ol/source/Tile~Tile} sources use a function of this type to get\n * the url that provides a tile for a given tile coordinate.\n *\n * This function takes an {@link module:ol/tilecoord~TileCoord} for the tile\n * coordinate, a `{number}` representing the pixel ratio and a\n * {@link module:ol/proj/Projection} for the projection  as arguments\n * and returns a `{string}` representing the tile URL, or undefined if no tile\n * should be requested for the passed tile coordinate.\n *\n * @typedef {function(import(\"./tilecoord.js\").TileCoord, number,\n *           import(\"./proj/Projection.js\").default): (string|undefined)} UrlFunction\n * @api\n */\n\n/**\n * @typedef {Object} Options\n * @property {number} [transition=250] A duration for tile opacity\n * transitions in milliseconds. A duration of 0 disables the opacity transition.\n * @api\n */\n\n/**\n * @classdesc\n * Base class for tiles.\n *\n * @abstract\n */\nclass Tile extends EventTarget {\n  /**\n   * @param {import(\"./tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @param {import(\"./TileState.js\").default} state State.\n   * @param {Options=} opt_options Tile options.\n   */\n  constructor(tileCoord, state, opt_options) {\n    super();\n\n    const options = opt_options ? opt_options : {};\n\n    /**\n     * @type {import(\"./tilecoord.js\").TileCoord}\n     */\n    this.tileCoord = tileCoord;\n\n    /**\n     * @protected\n     * @type {import(\"./TileState.js\").default}\n     */\n    this.state = state;\n\n    /**\n     * An \"interim\" tile for this tile. The interim tile may be used while this\n     * one is loading, for \"smooth\" transitions when changing params/dimensions\n     * on the source.\n     * @type {Tile}\n     */\n    this.interimTile = null;\n\n    /**\n     * The tile is available at the highest possible resolution. Subclasses can\n     * set this to `false` initially. Tile load listeners will not be\n     * unregistered before this is set to `true` and a `#changed()` is called.\n     * @type {boolean}\n     */\n    this.hifi = true;\n\n    /**\n     * A key assigned to the tile. This is used by the tile source to determine\n     * if this tile can effectively be used, or if a new tile should be created\n     * and this one be used as an interim tile for this new tile.\n     * @type {string}\n     */\n    this.key = '';\n\n    /**\n     * The duration for the opacity transition.\n     * @type {number}\n     */\n    this.transition_ =\n      options.transition === undefined ? 250 : options.transition;\n\n    /**\n     * Lookup of start times for rendering transitions.  If the start time is\n     * equal to -1, the transition is complete.\n     * @type {Object<string, number>}\n     */\n    this.transitionStarts_ = {};\n  }\n\n  /**\n   * @protected\n   */\n  changed() {\n    this.dispatchEvent(EventType.CHANGE);\n  }\n\n  /**\n   * Called by the tile cache when the tile is removed from the cache due to expiry\n   */\n  release() {}\n\n  /**\n   * @return {string} Key.\n   */\n  getKey() {\n    return this.key + '/' + this.tileCoord;\n  }\n\n  /**\n   * Get the interim tile most suitable for rendering using the chain of interim\n   * tiles. This corresponds to the  most recent tile that has been loaded, if no\n   * such tile exists, the original tile is returned.\n   * @return {!Tile} Best tile for rendering.\n   */\n  getInterimTile() {\n    if (!this.interimTile) {\n      //empty chain\n      return this;\n    }\n    let tile = this.interimTile;\n\n    // find the first loaded tile and return it. Since the chain is sorted in\n    // decreasing order of creation time, there is no need to search the remainder\n    // of the list (all those tiles correspond to older requests and will be\n    // cleaned up by refreshInterimChain)\n    do {\n      if (tile.getState() == TileState.LOADED) {\n        // Show tile immediately instead of fading it in after loading, because\n        // the interim tile is in place already\n        this.transition_ = 0;\n        return tile;\n      }\n      tile = tile.interimTile;\n    } while (tile);\n\n    // we can not find a better tile\n    return this;\n  }\n\n  /**\n   * Goes through the chain of interim tiles and discards sections of the chain\n   * that are no longer relevant.\n   */\n  refreshInterimChain() {\n    if (!this.interimTile) {\n      return;\n    }\n\n    let tile = this.interimTile;\n    let prev = /** @type {Tile} */ (this);\n\n    do {\n      if (tile.getState() == TileState.LOADED) {\n        //we have a loaded tile, we can discard the rest of the list\n        //we would could abort any LOADING tile request\n        //older than this tile (i.e. any LOADING tile following this entry in the chain)\n        tile.interimTile = null;\n        break;\n      } else if (tile.getState() == TileState.LOADING) {\n        //keep this LOADING tile any loaded tiles later in the chain are\n        //older than this tile, so we're still interested in the request\n        prev = tile;\n      } else if (tile.getState() == TileState.IDLE) {\n        //the head of the list is the most current tile, we don't need\n        //to start any other requests for this chain\n        prev.interimTile = tile.interimTile;\n      } else {\n        prev = tile;\n      }\n      tile = prev.interimTile;\n    } while (tile);\n  }\n\n  /**\n   * Get the tile coordinate for this tile.\n   * @return {import(\"./tilecoord.js\").TileCoord} The tile coordinate.\n   * @api\n   */\n  getTileCoord() {\n    return this.tileCoord;\n  }\n\n  /**\n   * @return {import(\"./TileState.js\").default} State.\n   */\n  getState() {\n    return this.state;\n  }\n\n  /**\n   * Sets the state of this tile. If you write your own {@link module:ol/Tile~LoadFunction tileLoadFunction} ,\n   * it is important to set the state correctly to {@link module:ol/TileState~ERROR}\n   * when the tile cannot be loaded. Otherwise the tile cannot be removed from\n   * the tile queue and will block other requests.\n   * @param {import(\"./TileState.js\").default} state State.\n   * @api\n   */\n  setState(state) {\n    if (this.state !== TileState.ERROR && this.state > state) {\n      throw new Error('Tile load sequence violation');\n    }\n    this.state = state;\n    this.changed();\n  }\n\n  /**\n   * Load the image or retry if loading previously failed.\n   * Loading is taken care of by the tile queue, and calling this method is\n   * only needed for preloading or for reloading in case of an error.\n   * @abstract\n   * @api\n   */\n  load() {\n    abstract();\n  }\n\n  /**\n   * Get the alpha value for rendering.\n   * @param {string} id An id for the renderer.\n   * @param {number} time The render frame time.\n   * @return {number} A number between 0 and 1.\n   */\n  getAlpha(id, time) {\n    if (!this.transition_) {\n      return 1;\n    }\n\n    let start = this.transitionStarts_[id];\n    if (!start) {\n      start = time;\n      this.transitionStarts_[id] = start;\n    } else if (start === -1) {\n      return 1;\n    }\n\n    const delta = time - start + 1000 / 60; // avoid rendering at 0\n    if (delta >= this.transition_) {\n      return 1;\n    }\n    return easeIn(delta / this.transition_);\n  }\n\n  /**\n   * Determine if a tile is in an alpha transition.  A tile is considered in\n   * transition if tile.getAlpha() has not yet been called or has been called\n   * and returned 1.\n   * @param {string} id An id for the renderer.\n   * @return {boolean} The tile is in transition.\n   */\n  inTransition(id) {\n    if (!this.transition_) {\n      return false;\n    }\n    return this.transitionStarts_[id] !== -1;\n  }\n\n  /**\n   * Mark a transition as complete.\n   * @param {string} id An id for the renderer.\n   */\n  endTransition(id) {\n    if (this.transition_) {\n      this.transitionStarts_[id] = -1;\n    }\n  }\n}\n\nexport default Tile;\n","/**\n * @module ol/ImageTile\n */\nimport Tile from './Tile.js';\nimport TileState from './TileState.js';\nimport {createCanvasContext2D} from './dom.js';\nimport {listenImage} from './Image.js';\n\nclass ImageTile extends Tile {\n  /**\n   * @param {import(\"./tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @param {import(\"./TileState.js\").default} state State.\n   * @param {string} src Image source URI.\n   * @param {?string} crossOrigin Cross origin.\n   * @param {import(\"./Tile.js\").LoadFunction} tileLoadFunction Tile load function.\n   * @param {import(\"./Tile.js\").Options=} opt_options Tile options.\n   */\n  constructor(\n    tileCoord,\n    state,\n    src,\n    crossOrigin,\n    tileLoadFunction,\n    opt_options\n  ) {\n    super(tileCoord, state, opt_options);\n\n    /**\n     * @private\n     * @type {?string}\n     */\n    this.crossOrigin_ = crossOrigin;\n\n    /**\n     * Image URI\n     *\n     * @private\n     * @type {string}\n     */\n    this.src_ = src;\n\n    this.key = src;\n\n    /**\n     * @private\n     * @type {HTMLImageElement|HTMLCanvasElement}\n     */\n    this.image_ = new Image();\n    if (crossOrigin !== null) {\n      this.image_.crossOrigin = crossOrigin;\n    }\n\n    /**\n     * @private\n     * @type {?function():void}\n     */\n    this.unlisten_ = null;\n\n    /**\n     * @private\n     * @type {import(\"./Tile.js\").LoadFunction}\n     */\n    this.tileLoadFunction_ = tileLoadFunction;\n  }\n\n  /**\n   * Get the HTML image element for this tile (may be a Canvas, Image, or Video).\n   * @return {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} Image.\n   * @api\n   */\n  getImage() {\n    return this.image_;\n  }\n\n  /**\n   * Tracks loading or read errors.\n   *\n   * @private\n   */\n  handleImageError_() {\n    this.state = TileState.ERROR;\n    this.unlistenImage_();\n    this.image_ = getBlankImage();\n    this.changed();\n  }\n\n  /**\n   * Tracks successful image load.\n   *\n   * @private\n   */\n  handleImageLoad_() {\n    const image = /** @type {HTMLImageElement} */ (this.image_);\n    if (image.naturalWidth && image.naturalHeight) {\n      this.state = TileState.LOADED;\n    } else {\n      this.state = TileState.EMPTY;\n    }\n    this.unlistenImage_();\n    this.changed();\n  }\n\n  /**\n   * Load not yet loaded URI.\n   * @api\n   */\n  load() {\n    if (this.state == TileState.ERROR) {\n      this.state = TileState.IDLE;\n      this.image_ = new Image();\n      if (this.crossOrigin_ !== null) {\n        this.image_.crossOrigin = this.crossOrigin_;\n      }\n    }\n    if (this.state == TileState.IDLE) {\n      this.state = TileState.LOADING;\n      this.changed();\n      this.tileLoadFunction_(this, this.src_);\n      this.unlisten_ = listenImage(\n        this.image_,\n        this.handleImageLoad_.bind(this),\n        this.handleImageError_.bind(this)\n      );\n    }\n  }\n\n  /**\n   * Discards event handlers which listen for load completion or errors.\n   *\n   * @private\n   */\n  unlistenImage_() {\n    if (this.unlisten_) {\n      this.unlisten_();\n      this.unlisten_ = null;\n    }\n  }\n}\n\n/**\n * Get a 1-pixel blank image.\n * @return {HTMLCanvasElement} Blank image.\n */\nfunction getBlankImage() {\n  const ctx = createCanvasContext2D(1, 1);\n  ctx.fillStyle = 'rgba(0,0,0,0)';\n  ctx.fillRect(0, 0, 1, 1);\n  return ctx.canvas;\n}\n\nexport default ImageTile;\n","/**\n * @module ol/reproj\n */\nimport {IMAGE_SMOOTHING_DISABLED} from './source/common.js';\nimport {assign} from './obj.js';\nimport {\n  containsCoordinate,\n  createEmpty,\n  extend,\n  forEachCorner,\n  getCenter,\n  getHeight,\n  getTopLeft,\n  getWidth,\n} from './extent.js';\nimport {createCanvasContext2D} from './dom.js';\nimport {getPointResolution, transform} from './proj.js';\nimport {solveLinearSystem} from './math.js';\n\nlet brokenDiagonalRendering_;\n\n/**\n * This draws a small triangle into a canvas by setting the triangle as the clip region\n * and then drawing a (too large) rectangle\n *\n * @param {CanvasRenderingContext2D} ctx The context in which to draw the triangle\n * @param {number} u1 The x-coordinate of the second point. The first point is 0,0.\n * @param {number} v1 The y-coordinate of the second point.\n * @param {number} u2 The x-coordinate of the third point.\n * @param {number} v2 The y-coordinate of the third point.\n */\nfunction drawTestTriangle(ctx, u1, v1, u2, v2) {\n  ctx.beginPath();\n  ctx.moveTo(0, 0);\n  ctx.lineTo(u1, v1);\n  ctx.lineTo(u2, v2);\n  ctx.closePath();\n  ctx.save();\n  ctx.clip();\n  ctx.fillRect(0, 0, Math.max(u1, u2) + 1, Math.max(v1, v2));\n  ctx.restore();\n}\n\n/**\n * Given the data from getImageData, see if the right values appear at the provided offset.\n * Returns true if either the color or transparency is off\n *\n * @param {Uint8ClampedArray} data The data returned from getImageData\n * @param {number} offset The pixel offset from the start of data.\n * @return {boolean} true if the diagonal rendering is broken\n */\nfunction verifyBrokenDiagonalRendering(data, offset) {\n  // the values ought to be close to the rgba(210, 0, 0, 0.75)\n  return (\n    Math.abs(data[offset * 4] - 210) > 2 ||\n    Math.abs(data[offset * 4 + 3] - 0.75 * 255) > 2\n  );\n}\n\n/**\n * Determines if the current browser configuration can render triangular clip regions correctly.\n * This value is cached so the function is only expensive the first time called.\n * Firefox on Windows (as of now) does not if HWA is enabled. See https://bugzilla.mozilla.org/show_bug.cgi?id=1606976\n * IE also doesn't. Chrome works, and everything seems to work on OSX and Android. This function caches the\n * result. I suppose that it is conceivably possible that a browser might flip modes while the app is\n * running, but lets hope not.\n *\n * @return {boolean} true if the Diagonal Rendering is broken.\n */\nfunction isBrokenDiagonalRendering() {\n  if (brokenDiagonalRendering_ === undefined) {\n    const ctx = document.createElement('canvas').getContext('2d');\n    ctx.globalCompositeOperation = 'lighter';\n    ctx.fillStyle = 'rgba(210, 0, 0, 0.75)';\n    drawTestTriangle(ctx, 4, 5, 4, 0);\n    drawTestTriangle(ctx, 4, 5, 0, 5);\n    const data = ctx.getImageData(0, 0, 3, 3).data;\n    brokenDiagonalRendering_ =\n      verifyBrokenDiagonalRendering(data, 0) ||\n      verifyBrokenDiagonalRendering(data, 4) ||\n      verifyBrokenDiagonalRendering(data, 8);\n  }\n\n  return brokenDiagonalRendering_;\n}\n\n/**\n * Calculates ideal resolution to use from the source in order to achieve\n * pixel mapping as close as possible to 1:1 during reprojection.\n * The resolution is calculated regardless of what resolutions\n * are actually available in the dataset (TileGrid, Image, ...).\n *\n * @param {import(\"./proj/Projection.js\").default} sourceProj Source projection.\n * @param {import(\"./proj/Projection.js\").default} targetProj Target projection.\n * @param {import(\"./coordinate.js\").Coordinate} targetCenter Target center.\n * @param {number} targetResolution Target resolution.\n * @return {number} The best resolution to use. Can be +-Infinity, NaN or 0.\n */\nexport function calculateSourceResolution(\n  sourceProj,\n  targetProj,\n  targetCenter,\n  targetResolution\n) {\n  const sourceCenter = transform(targetCenter, targetProj, sourceProj);\n\n  // calculate the ideal resolution of the source data\n  let sourceResolution = getPointResolution(\n    targetProj,\n    targetResolution,\n    targetCenter\n  );\n\n  const targetMetersPerUnit = targetProj.getMetersPerUnit();\n  if (targetMetersPerUnit !== undefined) {\n    sourceResolution *= targetMetersPerUnit;\n  }\n  const sourceMetersPerUnit = sourceProj.getMetersPerUnit();\n  if (sourceMetersPerUnit !== undefined) {\n    sourceResolution /= sourceMetersPerUnit;\n  }\n\n  // Based on the projection properties, the point resolution at the specified\n  // coordinates may be slightly different. We need to reverse-compensate this\n  // in order to achieve optimal results.\n\n  const sourceExtent = sourceProj.getExtent();\n  if (!sourceExtent || containsCoordinate(sourceExtent, sourceCenter)) {\n    const compensationFactor =\n      getPointResolution(sourceProj, sourceResolution, sourceCenter) /\n      sourceResolution;\n    if (isFinite(compensationFactor) && compensationFactor > 0) {\n      sourceResolution /= compensationFactor;\n    }\n  }\n\n  return sourceResolution;\n}\n\n/**\n * Calculates ideal resolution to use from the source in order to achieve\n * pixel mapping as close as possible to 1:1 during reprojection.\n * The resolution is calculated regardless of what resolutions\n * are actually available in the dataset (TileGrid, Image, ...).\n *\n * @param {import(\"./proj/Projection.js\").default} sourceProj Source projection.\n * @param {import(\"./proj/Projection.js\").default} targetProj Target projection.\n * @param {import(\"./extent.js\").Extent} targetExtent Target extent\n * @param {number} targetResolution Target resolution.\n * @return {number} The best resolution to use. Can be +-Infinity, NaN or 0.\n */\nexport function calculateSourceExtentResolution(\n  sourceProj,\n  targetProj,\n  targetExtent,\n  targetResolution\n) {\n  const targetCenter = getCenter(targetExtent);\n  let sourceResolution = calculateSourceResolution(\n    sourceProj,\n    targetProj,\n    targetCenter,\n    targetResolution\n  );\n\n  if (!isFinite(sourceResolution) || sourceResolution <= 0) {\n    forEachCorner(targetExtent, function (corner) {\n      sourceResolution = calculateSourceResolution(\n        sourceProj,\n        targetProj,\n        corner,\n        targetResolution\n      );\n      return isFinite(sourceResolution) && sourceResolution > 0;\n    });\n  }\n\n  return sourceResolution;\n}\n\n/**\n * Renders the source data into new canvas based on the triangulation.\n *\n * @param {number} width Width of the canvas.\n * @param {number} height Height of the canvas.\n * @param {number} pixelRatio Pixel ratio.\n * @param {number} sourceResolution Source resolution.\n * @param {import(\"./extent.js\").Extent} sourceExtent Extent of the data source.\n * @param {number} targetResolution Target resolution.\n * @param {import(\"./extent.js\").Extent} targetExtent Target extent.\n * @param {import(\"./reproj/Triangulation.js\").default} triangulation\n * Calculated triangulation.\n * @param {Array<{extent: import(\"./extent.js\").Extent,\n *                 image: (HTMLCanvasElement|HTMLImageElement|HTMLVideoElement)}>} sources\n * Array of sources.\n * @param {number} gutter Gutter of the sources.\n * @param {boolean=} opt_renderEdges Render reprojection edges.\n * @param {object=} opt_contextOptions Properties to set on the canvas context.\n * @return {HTMLCanvasElement} Canvas with reprojected data.\n */\nexport function render(\n  width,\n  height,\n  pixelRatio,\n  sourceResolution,\n  sourceExtent,\n  targetResolution,\n  targetExtent,\n  triangulation,\n  sources,\n  gutter,\n  opt_renderEdges,\n  opt_contextOptions\n) {\n  const context = createCanvasContext2D(\n    Math.round(pixelRatio * width),\n    Math.round(pixelRatio * height)\n  );\n  assign(context, opt_contextOptions);\n\n  if (sources.length === 0) {\n    return context.canvas;\n  }\n\n  context.scale(pixelRatio, pixelRatio);\n\n  function pixelRound(value) {\n    return Math.round(value * pixelRatio) / pixelRatio;\n  }\n\n  context.globalCompositeOperation = 'lighter';\n\n  const sourceDataExtent = createEmpty();\n  sources.forEach(function (src, i, arr) {\n    extend(sourceDataExtent, src.extent);\n  });\n\n  const canvasWidthInUnits = getWidth(sourceDataExtent);\n  const canvasHeightInUnits = getHeight(sourceDataExtent);\n  const stitchContext = createCanvasContext2D(\n    Math.round((pixelRatio * canvasWidthInUnits) / sourceResolution),\n    Math.round((pixelRatio * canvasHeightInUnits) / sourceResolution)\n  );\n  assign(stitchContext, opt_contextOptions);\n\n  const stitchScale = pixelRatio / sourceResolution;\n\n  sources.forEach(function (src, i, arr) {\n    const xPos = src.extent[0] - sourceDataExtent[0];\n    const yPos = -(src.extent[3] - sourceDataExtent[3]);\n    const srcWidth = getWidth(src.extent);\n    const srcHeight = getHeight(src.extent);\n\n    // This test should never fail -- but it does. Need to find a fix the upstream condition\n    if (src.image.width > 0 && src.image.height > 0) {\n      stitchContext.drawImage(\n        src.image,\n        gutter,\n        gutter,\n        src.image.width - 2 * gutter,\n        src.image.height - 2 * gutter,\n        xPos * stitchScale,\n        yPos * stitchScale,\n        srcWidth * stitchScale,\n        srcHeight * stitchScale\n      );\n    }\n  });\n\n  const targetTopLeft = getTopLeft(targetExtent);\n\n  triangulation.getTriangles().forEach(function (triangle, i, arr) {\n    /* Calculate affine transform (src -> dst)\n     * Resulting matrix can be used to transform coordinate\n     * from `sourceProjection` to destination pixels.\n     *\n     * To optimize number of context calls and increase numerical stability,\n     * we also do the following operations:\n     * trans(-topLeftExtentCorner), scale(1 / targetResolution), scale(1, -1)\n     * here before solving the linear system so [ui, vi] are pixel coordinates.\n     *\n     * Src points: xi, yi\n     * Dst points: ui, vi\n     * Affine coefficients: aij\n     *\n     * | x0 y0 1  0  0 0 |   |a00|   |u0|\n     * | x1 y1 1  0  0 0 |   |a01|   |u1|\n     * | x2 y2 1  0  0 0 | x |a02| = |u2|\n     * |  0  0 0 x0 y0 1 |   |a10|   |v0|\n     * |  0  0 0 x1 y1 1 |   |a11|   |v1|\n     * |  0  0 0 x2 y2 1 |   |a12|   |v2|\n     */\n    const source = triangle.source;\n    const target = triangle.target;\n    let x0 = source[0][0],\n      y0 = source[0][1];\n    let x1 = source[1][0],\n      y1 = source[1][1];\n    let x2 = source[2][0],\n      y2 = source[2][1];\n    // Make sure that everything is on pixel boundaries\n    const u0 = pixelRound((target[0][0] - targetTopLeft[0]) / targetResolution);\n    const v0 = pixelRound(\n      -(target[0][1] - targetTopLeft[1]) / targetResolution\n    );\n    const u1 = pixelRound((target[1][0] - targetTopLeft[0]) / targetResolution);\n    const v1 = pixelRound(\n      -(target[1][1] - targetTopLeft[1]) / targetResolution\n    );\n    const u2 = pixelRound((target[2][0] - targetTopLeft[0]) / targetResolution);\n    const v2 = pixelRound(\n      -(target[2][1] - targetTopLeft[1]) / targetResolution\n    );\n\n    // Shift all the source points to improve numerical stability\n    // of all the subsequent calculations. The [x0, y0] is used here.\n    // This is also used to simplify the linear system.\n    const sourceNumericalShiftX = x0;\n    const sourceNumericalShiftY = y0;\n    x0 = 0;\n    y0 = 0;\n    x1 -= sourceNumericalShiftX;\n    y1 -= sourceNumericalShiftY;\n    x2 -= sourceNumericalShiftX;\n    y2 -= sourceNumericalShiftY;\n\n    const augmentedMatrix = [\n      [x1, y1, 0, 0, u1 - u0],\n      [x2, y2, 0, 0, u2 - u0],\n      [0, 0, x1, y1, v1 - v0],\n      [0, 0, x2, y2, v2 - v0],\n    ];\n    const affineCoefs = solveLinearSystem(augmentedMatrix);\n    if (!affineCoefs) {\n      return;\n    }\n\n    context.save();\n    context.beginPath();\n\n    if (\n      isBrokenDiagonalRendering() ||\n      opt_contextOptions === IMAGE_SMOOTHING_DISABLED\n    ) {\n      // Make sure that all lines are horizontal or vertical\n      context.moveTo(u1, v1);\n      // This is the diagonal line. Do it in 4 steps\n      const steps = 4;\n      const ud = u0 - u1;\n      const vd = v0 - v1;\n      for (let step = 0; step < steps; step++) {\n        // Go horizontally\n        context.lineTo(\n          u1 + pixelRound(((step + 1) * ud) / steps),\n          v1 + pixelRound((step * vd) / (steps - 1))\n        );\n        // Go vertically\n        if (step != steps - 1) {\n          context.lineTo(\n            u1 + pixelRound(((step + 1) * ud) / steps),\n            v1 + pixelRound(((step + 1) * vd) / (steps - 1))\n          );\n        }\n      }\n      // We are almost at u0r, v0r\n      context.lineTo(u2, v2);\n    } else {\n      context.moveTo(u1, v1);\n      context.lineTo(u0, v0);\n      context.lineTo(u2, v2);\n    }\n\n    context.clip();\n\n    context.transform(\n      affineCoefs[0],\n      affineCoefs[2],\n      affineCoefs[1],\n      affineCoefs[3],\n      u0,\n      v0\n    );\n\n    context.translate(\n      sourceDataExtent[0] - sourceNumericalShiftX,\n      sourceDataExtent[3] - sourceNumericalShiftY\n    );\n\n    context.scale(\n      sourceResolution / pixelRatio,\n      -sourceResolution / pixelRatio\n    );\n\n    context.drawImage(stitchContext.canvas, 0, 0);\n    context.restore();\n  });\n\n  if (opt_renderEdges) {\n    context.save();\n\n    context.globalCompositeOperation = 'source-over';\n    context.strokeStyle = 'black';\n    context.lineWidth = 1;\n\n    triangulation.getTriangles().forEach(function (triangle, i, arr) {\n      const target = triangle.target;\n      const u0 = (target[0][0] - targetTopLeft[0]) / targetResolution;\n      const v0 = -(target[0][1] - targetTopLeft[1]) / targetResolution;\n      const u1 = (target[1][0] - targetTopLeft[0]) / targetResolution;\n      const v1 = -(target[1][1] - targetTopLeft[1]) / targetResolution;\n      const u2 = (target[2][0] - targetTopLeft[0]) / targetResolution;\n      const v2 = -(target[2][1] - targetTopLeft[1]) / targetResolution;\n\n      context.beginPath();\n      context.moveTo(u1, v1);\n      context.lineTo(u0, v0);\n      context.lineTo(u2, v2);\n      context.closePath();\n      context.stroke();\n    });\n\n    context.restore();\n  }\n  return context.canvas;\n}\n","/**\n * @module ol/reproj/Triangulation\n */\nimport {\n  boundingExtent,\n  createEmpty,\n  extendCoordinate,\n  getArea,\n  getBottomLeft,\n  getBottomRight,\n  getTopLeft,\n  getTopRight,\n  getWidth,\n  intersects,\n} from '../extent.js';\nimport {getTransform} from '../proj.js';\nimport {log2, modulo} from '../math.js';\n\n/**\n * Single triangle; consists of 3 source points and 3 target points.\n * @typedef {Object} Triangle\n * @property {Array<import(\"../coordinate.js\").Coordinate>} source\n * @property {Array<import(\"../coordinate.js\").Coordinate>} target\n */\n\n/**\n * Maximum number of subdivision steps during raster reprojection triangulation.\n * Prevents high memory usage and large number of proj4 calls (for certain\n * transformations and areas). At most `2*(2^this)` triangles are created for\n * each triangulated extent (tile/image).\n * @type {number}\n */\nconst MAX_SUBDIVISION = 10;\n\n/**\n * Maximum allowed size of triangle relative to world width. When transforming\n * corners of world extent between certain projections, the resulting\n * triangulation seems to have zero error and no subdivision is performed. If\n * the triangle width is more than this (relative to world width; 0-1),\n * subdivison is forced (up to `MAX_SUBDIVISION`). Default is `0.25`.\n * @type {number}\n */\nconst MAX_TRIANGLE_WIDTH = 0.25;\n\n/**\n * @classdesc\n * Class containing triangulation of the given target extent.\n * Used for determining source data and the reprojection itself.\n */\nclass Triangulation {\n  /**\n   * @param {import(\"../proj/Projection.js\").default} sourceProj Source projection.\n   * @param {import(\"../proj/Projection.js\").default} targetProj Target projection.\n   * @param {import(\"../extent.js\").Extent} targetExtent Target extent to triangulate.\n   * @param {import(\"../extent.js\").Extent} maxSourceExtent Maximal source extent that can be used.\n   * @param {number} errorThreshold Acceptable error (in source units).\n   * @param {?number} opt_destinationResolution The (optional) resolution of the destination.\n   */\n  constructor(\n    sourceProj,\n    targetProj,\n    targetExtent,\n    maxSourceExtent,\n    errorThreshold,\n    opt_destinationResolution\n  ) {\n    /**\n     * @type {import(\"../proj/Projection.js\").default}\n     * @private\n     */\n    this.sourceProj_ = sourceProj;\n\n    /**\n     * @type {import(\"../proj/Projection.js\").default}\n     * @private\n     */\n    this.targetProj_ = targetProj;\n\n    /** @type {!Object<string, import(\"../coordinate.js\").Coordinate>} */\n    let transformInvCache = {};\n    const transformInv = getTransform(this.targetProj_, this.sourceProj_);\n\n    /**\n     * @param {import(\"../coordinate.js\").Coordinate} c A coordinate.\n     * @return {import(\"../coordinate.js\").Coordinate} Transformed coordinate.\n     * @private\n     */\n    this.transformInv_ = function (c) {\n      const key = c[0] + '/' + c[1];\n      if (!transformInvCache[key]) {\n        transformInvCache[key] = transformInv(c);\n      }\n      return transformInvCache[key];\n    };\n\n    /**\n     * @type {import(\"../extent.js\").Extent}\n     * @private\n     */\n    this.maxSourceExtent_ = maxSourceExtent;\n\n    /**\n     * @type {number}\n     * @private\n     */\n    this.errorThresholdSquared_ = errorThreshold * errorThreshold;\n\n    /**\n     * @type {Array<Triangle>}\n     * @private\n     */\n    this.triangles_ = [];\n\n    /**\n     * Indicates that the triangulation crosses edge of the source projection.\n     * @type {boolean}\n     * @private\n     */\n    this.wrapsXInSource_ = false;\n\n    /**\n     * @type {boolean}\n     * @private\n     */\n    this.canWrapXInSource_ =\n      this.sourceProj_.canWrapX() &&\n      !!maxSourceExtent &&\n      !!this.sourceProj_.getExtent() &&\n      getWidth(maxSourceExtent) == getWidth(this.sourceProj_.getExtent());\n\n    /**\n     * @type {?number}\n     * @private\n     */\n    this.sourceWorldWidth_ = this.sourceProj_.getExtent()\n      ? getWidth(this.sourceProj_.getExtent())\n      : null;\n\n    /**\n     * @type {?number}\n     * @private\n     */\n    this.targetWorldWidth_ = this.targetProj_.getExtent()\n      ? getWidth(this.targetProj_.getExtent())\n      : null;\n\n    const destinationTopLeft = getTopLeft(targetExtent);\n    const destinationTopRight = getTopRight(targetExtent);\n    const destinationBottomRight = getBottomRight(targetExtent);\n    const destinationBottomLeft = getBottomLeft(targetExtent);\n    const sourceTopLeft = this.transformInv_(destinationTopLeft);\n    const sourceTopRight = this.transformInv_(destinationTopRight);\n    const sourceBottomRight = this.transformInv_(destinationBottomRight);\n    const sourceBottomLeft = this.transformInv_(destinationBottomLeft);\n\n    /*\n     * The maxSubdivision controls how many splittings of the target area can\n     * be done. The idea here is to do a linear mapping of the target areas\n     * but the actual overal reprojection (can be) extremely non-linear. The\n     * default value of MAX_SUBDIVISION was chosen based on mapping a 256x256\n     * tile size. However this function is also called to remap canvas rendered\n     * layers which can be much larger. This calculation increases the maxSubdivision\n     * value by the right factor so that each 256x256 pixel area has\n     * MAX_SUBDIVISION divisions.\n     */\n    const maxSubdivision =\n      MAX_SUBDIVISION +\n      (opt_destinationResolution\n        ? Math.max(\n            0,\n            Math.ceil(\n              log2(\n                getArea(targetExtent) /\n                  (opt_destinationResolution *\n                    opt_destinationResolution *\n                    256 *\n                    256)\n              )\n            )\n          )\n        : 0);\n\n    this.addQuad_(\n      destinationTopLeft,\n      destinationTopRight,\n      destinationBottomRight,\n      destinationBottomLeft,\n      sourceTopLeft,\n      sourceTopRight,\n      sourceBottomRight,\n      sourceBottomLeft,\n      maxSubdivision\n    );\n\n    if (this.wrapsXInSource_) {\n      let leftBound = Infinity;\n      this.triangles_.forEach(function (triangle, i, arr) {\n        leftBound = Math.min(\n          leftBound,\n          triangle.source[0][0],\n          triangle.source[1][0],\n          triangle.source[2][0]\n        );\n      });\n\n      // Shift triangles to be as close to `leftBound` as possible\n      // (if the distance is more than `worldWidth / 2` it can be closer.\n      this.triangles_.forEach(\n        function (triangle) {\n          if (\n            Math.max(\n              triangle.source[0][0],\n              triangle.source[1][0],\n              triangle.source[2][0]\n            ) -\n              leftBound >\n            this.sourceWorldWidth_ / 2\n          ) {\n            const newTriangle = [\n              [triangle.source[0][0], triangle.source[0][1]],\n              [triangle.source[1][0], triangle.source[1][1]],\n              [triangle.source[2][0], triangle.source[2][1]],\n            ];\n            if (newTriangle[0][0] - leftBound > this.sourceWorldWidth_ / 2) {\n              newTriangle[0][0] -= this.sourceWorldWidth_;\n            }\n            if (newTriangle[1][0] - leftBound > this.sourceWorldWidth_ / 2) {\n              newTriangle[1][0] -= this.sourceWorldWidth_;\n            }\n            if (newTriangle[2][0] - leftBound > this.sourceWorldWidth_ / 2) {\n              newTriangle[2][0] -= this.sourceWorldWidth_;\n            }\n\n            // Rarely (if the extent contains both the dateline and prime meridian)\n            // the shift can in turn break some triangles.\n            // Detect this here and don't shift in such cases.\n            const minX = Math.min(\n              newTriangle[0][0],\n              newTriangle[1][0],\n              newTriangle[2][0]\n            );\n            const maxX = Math.max(\n              newTriangle[0][0],\n              newTriangle[1][0],\n              newTriangle[2][0]\n            );\n            if (maxX - minX < this.sourceWorldWidth_ / 2) {\n              triangle.source = newTriangle;\n            }\n          }\n        }.bind(this)\n      );\n    }\n\n    transformInvCache = {};\n  }\n\n  /**\n   * Adds triangle to the triangulation.\n   * @param {import(\"../coordinate.js\").Coordinate} a The target a coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} b The target b coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} c The target c coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} aSrc The source a coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} bSrc The source b coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} cSrc The source c coordinate.\n   * @private\n   */\n  addTriangle_(a, b, c, aSrc, bSrc, cSrc) {\n    this.triangles_.push({\n      source: [aSrc, bSrc, cSrc],\n      target: [a, b, c],\n    });\n  }\n\n  /**\n   * Adds quad (points in clock-wise order) to the triangulation\n   * (and reprojects the vertices) if valid.\n   * Performs quad subdivision if needed to increase precision.\n   *\n   * @param {import(\"../coordinate.js\").Coordinate} a The target a coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} b The target b coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} c The target c coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} d The target d coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} aSrc The source a coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} bSrc The source b coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} cSrc The source c coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} dSrc The source d coordinate.\n   * @param {number} maxSubdivision Maximal allowed subdivision of the quad.\n   * @private\n   */\n  addQuad_(a, b, c, d, aSrc, bSrc, cSrc, dSrc, maxSubdivision) {\n    const sourceQuadExtent = boundingExtent([aSrc, bSrc, cSrc, dSrc]);\n    const sourceCoverageX = this.sourceWorldWidth_\n      ? getWidth(sourceQuadExtent) / this.sourceWorldWidth_\n      : null;\n    const sourceWorldWidth = /** @type {number} */ (this.sourceWorldWidth_);\n\n    // when the quad is wrapped in the source projection\n    // it covers most of the projection extent, but not fully\n    const wrapsX =\n      this.sourceProj_.canWrapX() &&\n      sourceCoverageX > 0.5 &&\n      sourceCoverageX < 1;\n\n    let needsSubdivision = false;\n\n    if (maxSubdivision > 0) {\n      if (this.targetProj_.isGlobal() && this.targetWorldWidth_) {\n        const targetQuadExtent = boundingExtent([a, b, c, d]);\n        const targetCoverageX =\n          getWidth(targetQuadExtent) / this.targetWorldWidth_;\n        needsSubdivision =\n          targetCoverageX > MAX_TRIANGLE_WIDTH || needsSubdivision;\n      }\n      if (!wrapsX && this.sourceProj_.isGlobal() && sourceCoverageX) {\n        needsSubdivision =\n          sourceCoverageX > MAX_TRIANGLE_WIDTH || needsSubdivision;\n      }\n    }\n\n    if (!needsSubdivision && this.maxSourceExtent_) {\n      if (\n        isFinite(sourceQuadExtent[0]) &&\n        isFinite(sourceQuadExtent[1]) &&\n        isFinite(sourceQuadExtent[2]) &&\n        isFinite(sourceQuadExtent[3])\n      ) {\n        if (!intersects(sourceQuadExtent, this.maxSourceExtent_)) {\n          // whole quad outside source projection extent -> ignore\n          return;\n        }\n      }\n    }\n\n    let isNotFinite = 0;\n\n    if (!needsSubdivision) {\n      if (\n        !isFinite(aSrc[0]) ||\n        !isFinite(aSrc[1]) ||\n        !isFinite(bSrc[0]) ||\n        !isFinite(bSrc[1]) ||\n        !isFinite(cSrc[0]) ||\n        !isFinite(cSrc[1]) ||\n        !isFinite(dSrc[0]) ||\n        !isFinite(dSrc[1])\n      ) {\n        if (maxSubdivision > 0) {\n          needsSubdivision = true;\n        } else {\n          // It might be the case that only 1 of the points is infinite. In this case\n          // we can draw a single triangle with the other three points\n          isNotFinite =\n            (!isFinite(aSrc[0]) || !isFinite(aSrc[1]) ? 8 : 0) +\n            (!isFinite(bSrc[0]) || !isFinite(bSrc[1]) ? 4 : 0) +\n            (!isFinite(cSrc[0]) || !isFinite(cSrc[1]) ? 2 : 0) +\n            (!isFinite(dSrc[0]) || !isFinite(dSrc[1]) ? 1 : 0);\n          if (\n            isNotFinite != 1 &&\n            isNotFinite != 2 &&\n            isNotFinite != 4 &&\n            isNotFinite != 8\n          ) {\n            return;\n          }\n        }\n      }\n    }\n\n    if (maxSubdivision > 0) {\n      if (!needsSubdivision) {\n        const center = [(a[0] + c[0]) / 2, (a[1] + c[1]) / 2];\n        const centerSrc = this.transformInv_(center);\n\n        let dx;\n        if (wrapsX) {\n          const centerSrcEstimX =\n            (modulo(aSrc[0], sourceWorldWidth) +\n              modulo(cSrc[0], sourceWorldWidth)) /\n            2;\n          dx = centerSrcEstimX - modulo(centerSrc[0], sourceWorldWidth);\n        } else {\n          dx = (aSrc[0] + cSrc[0]) / 2 - centerSrc[0];\n        }\n        const dy = (aSrc[1] + cSrc[1]) / 2 - centerSrc[1];\n        const centerSrcErrorSquared = dx * dx + dy * dy;\n        needsSubdivision = centerSrcErrorSquared > this.errorThresholdSquared_;\n      }\n      if (needsSubdivision) {\n        if (Math.abs(a[0] - c[0]) <= Math.abs(a[1] - c[1])) {\n          // split horizontally (top & bottom)\n          const bc = [(b[0] + c[0]) / 2, (b[1] + c[1]) / 2];\n          const bcSrc = this.transformInv_(bc);\n          const da = [(d[0] + a[0]) / 2, (d[1] + a[1]) / 2];\n          const daSrc = this.transformInv_(da);\n\n          this.addQuad_(\n            a,\n            b,\n            bc,\n            da,\n            aSrc,\n            bSrc,\n            bcSrc,\n            daSrc,\n            maxSubdivision - 1\n          );\n          this.addQuad_(\n            da,\n            bc,\n            c,\n            d,\n            daSrc,\n            bcSrc,\n            cSrc,\n            dSrc,\n            maxSubdivision - 1\n          );\n        } else {\n          // split vertically (left & right)\n          const ab = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];\n          const abSrc = this.transformInv_(ab);\n          const cd = [(c[0] + d[0]) / 2, (c[1] + d[1]) / 2];\n          const cdSrc = this.transformInv_(cd);\n\n          this.addQuad_(\n            a,\n            ab,\n            cd,\n            d,\n            aSrc,\n            abSrc,\n            cdSrc,\n            dSrc,\n            maxSubdivision - 1\n          );\n          this.addQuad_(\n            ab,\n            b,\n            c,\n            cd,\n            abSrc,\n            bSrc,\n            cSrc,\n            cdSrc,\n            maxSubdivision - 1\n          );\n        }\n        return;\n      }\n    }\n\n    if (wrapsX) {\n      if (!this.canWrapXInSource_) {\n        return;\n      }\n      this.wrapsXInSource_ = true;\n    }\n\n    // Exactly zero or one of *Src is not finite\n    // The triangles must have the diagonal line as the first side\n    // This is to allow easy code in reproj.s to make it straight for broken\n    // browsers that can't handle diagonal clipping\n    if ((isNotFinite & 0xb) == 0) {\n      this.addTriangle_(a, c, d, aSrc, cSrc, dSrc);\n    }\n    if ((isNotFinite & 0xe) == 0) {\n      this.addTriangle_(a, c, b, aSrc, cSrc, bSrc);\n    }\n    if (isNotFinite) {\n      // Try the other two triangles\n      if ((isNotFinite & 0xd) == 0) {\n        this.addTriangle_(b, d, a, bSrc, dSrc, aSrc);\n      }\n      if ((isNotFinite & 0x7) == 0) {\n        this.addTriangle_(b, d, c, bSrc, dSrc, cSrc);\n      }\n    }\n  }\n\n  /**\n   * Calculates extent of the 'source' coordinates from all the triangles.\n   *\n   * @return {import(\"../extent.js\").Extent} Calculated extent.\n   */\n  calculateSourceExtent() {\n    const extent = createEmpty();\n\n    this.triangles_.forEach(function (triangle, i, arr) {\n      const src = triangle.source;\n      extendCoordinate(extent, src[0]);\n      extendCoordinate(extent, src[1]);\n      extendCoordinate(extent, src[2]);\n    });\n\n    return extent;\n  }\n\n  /**\n   * @return {Array<Triangle>} Array of the calculated triangles.\n   */\n  getTriangles() {\n    return this.triangles_;\n  }\n}\n\nexport default Triangulation;\n","/**\n * @module ol/reproj/Tile\n */\nimport {ERROR_THRESHOLD} from './common.js';\n\nimport EventType from '../events/EventType.js';\nimport Tile from '../Tile.js';\nimport TileState from '../TileState.js';\nimport Triangulation from './Triangulation.js';\nimport {\n  calculateSourceExtentResolution,\n  render as renderReprojected,\n} from '../reproj.js';\nimport {clamp} from '../math.js';\nimport {getArea, getIntersection} from '../extent.js';\nimport {listen, unlistenByKey} from '../events.js';\n\n/**\n * @typedef {function(number, number, number, number) : import(\"../Tile.js\").default} FunctionType\n */\n\n/**\n * @classdesc\n * Class encapsulating single reprojected tile.\n * See {@link module:ol/source/TileImage~TileImage}.\n *\n */\nclass ReprojTile extends Tile {\n  /**\n   * @param {import(\"../proj/Projection.js\").default} sourceProj Source projection.\n   * @param {import(\"../tilegrid/TileGrid.js\").default} sourceTileGrid Source tile grid.\n   * @param {import(\"../proj/Projection.js\").default} targetProj Target projection.\n   * @param {import(\"../tilegrid/TileGrid.js\").default} targetTileGrid Target tile grid.\n   * @param {import(\"../tilecoord.js\").TileCoord} tileCoord Coordinate of the tile.\n   * @param {import(\"../tilecoord.js\").TileCoord} wrappedTileCoord Coordinate of the tile wrapped in X.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {number} gutter Gutter of the source tiles.\n   * @param {FunctionType} getTileFunction\n   *     Function returning source tiles (z, x, y, pixelRatio).\n   * @param {number=} opt_errorThreshold Acceptable reprojection error (in px).\n   * @param {boolean=} opt_renderEdges Render reprojection edges.\n   * @param {object=} opt_contextOptions Properties to set on the canvas context.\n   */\n  constructor(\n    sourceProj,\n    sourceTileGrid,\n    targetProj,\n    targetTileGrid,\n    tileCoord,\n    wrappedTileCoord,\n    pixelRatio,\n    gutter,\n    getTileFunction,\n    opt_errorThreshold,\n    opt_renderEdges,\n    opt_contextOptions\n  ) {\n    super(tileCoord, TileState.IDLE);\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.renderEdges_ = opt_renderEdges !== undefined ? opt_renderEdges : false;\n\n    /**\n     * @private\n     * @type {object}\n     */\n    this.contextOptions_ = opt_contextOptions;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.pixelRatio_ = pixelRatio;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.gutter_ = gutter;\n\n    /**\n     * @private\n     * @type {HTMLCanvasElement}\n     */\n    this.canvas_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../tilegrid/TileGrid.js\").default}\n     */\n    this.sourceTileGrid_ = sourceTileGrid;\n\n    /**\n     * @private\n     * @type {import(\"../tilegrid/TileGrid.js\").default}\n     */\n    this.targetTileGrid_ = targetTileGrid;\n\n    /**\n     * @private\n     * @type {import(\"../tilecoord.js\").TileCoord}\n     */\n    this.wrappedTileCoord_ = wrappedTileCoord ? wrappedTileCoord : tileCoord;\n\n    /**\n     * @private\n     * @type {!Array<import(\"../Tile.js\").default>}\n     */\n    this.sourceTiles_ = [];\n\n    /**\n     * @private\n     * @type {?Array<import(\"../events.js\").EventsKey>}\n     */\n    this.sourcesListenerKeys_ = null;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.sourceZ_ = 0;\n\n    const targetExtent = targetTileGrid.getTileCoordExtent(\n      this.wrappedTileCoord_\n    );\n    const maxTargetExtent = this.targetTileGrid_.getExtent();\n    let maxSourceExtent = this.sourceTileGrid_.getExtent();\n\n    const limitedTargetExtent = maxTargetExtent\n      ? getIntersection(targetExtent, maxTargetExtent)\n      : targetExtent;\n\n    if (getArea(limitedTargetExtent) === 0) {\n      // Tile is completely outside range -> EMPTY\n      // TODO: is it actually correct that the source even creates the tile ?\n      this.state = TileState.EMPTY;\n      return;\n    }\n\n    const sourceProjExtent = sourceProj.getExtent();\n    if (sourceProjExtent) {\n      if (!maxSourceExtent) {\n        maxSourceExtent = sourceProjExtent;\n      } else {\n        maxSourceExtent = getIntersection(maxSourceExtent, sourceProjExtent);\n      }\n    }\n\n    const targetResolution = targetTileGrid.getResolution(\n      this.wrappedTileCoord_[0]\n    );\n\n    const sourceResolution = calculateSourceExtentResolution(\n      sourceProj,\n      targetProj,\n      limitedTargetExtent,\n      targetResolution\n    );\n\n    if (!isFinite(sourceResolution) || sourceResolution <= 0) {\n      // invalid sourceResolution -> EMPTY\n      // probably edges of the projections when no extent is defined\n      this.state = TileState.EMPTY;\n      return;\n    }\n\n    const errorThresholdInPixels =\n      opt_errorThreshold !== undefined ? opt_errorThreshold : ERROR_THRESHOLD;\n\n    /**\n     * @private\n     * @type {!import(\"./Triangulation.js\").default}\n     */\n    this.triangulation_ = new Triangulation(\n      sourceProj,\n      targetProj,\n      limitedTargetExtent,\n      maxSourceExtent,\n      sourceResolution * errorThresholdInPixels,\n      targetResolution\n    );\n\n    if (this.triangulation_.getTriangles().length === 0) {\n      // no valid triangles -> EMPTY\n      this.state = TileState.EMPTY;\n      return;\n    }\n\n    this.sourceZ_ = sourceTileGrid.getZForResolution(sourceResolution);\n    let sourceExtent = this.triangulation_.calculateSourceExtent();\n\n    if (maxSourceExtent) {\n      if (sourceProj.canWrapX()) {\n        sourceExtent[1] = clamp(\n          sourceExtent[1],\n          maxSourceExtent[1],\n          maxSourceExtent[3]\n        );\n        sourceExtent[3] = clamp(\n          sourceExtent[3],\n          maxSourceExtent[1],\n          maxSourceExtent[3]\n        );\n      } else {\n        sourceExtent = getIntersection(sourceExtent, maxSourceExtent);\n      }\n    }\n\n    if (!getArea(sourceExtent)) {\n      this.state = TileState.EMPTY;\n    } else {\n      const sourceRange = sourceTileGrid.getTileRangeForExtentAndZ(\n        sourceExtent,\n        this.sourceZ_\n      );\n\n      for (let srcX = sourceRange.minX; srcX <= sourceRange.maxX; srcX++) {\n        for (let srcY = sourceRange.minY; srcY <= sourceRange.maxY; srcY++) {\n          const tile = getTileFunction(this.sourceZ_, srcX, srcY, pixelRatio);\n          if (tile) {\n            this.sourceTiles_.push(tile);\n          }\n        }\n      }\n\n      if (this.sourceTiles_.length === 0) {\n        this.state = TileState.EMPTY;\n      }\n    }\n  }\n\n  /**\n   * Get the HTML Canvas element for this tile.\n   * @return {HTMLCanvasElement} Canvas.\n   */\n  getImage() {\n    return this.canvas_;\n  }\n\n  /**\n   * @private\n   */\n  reproject_() {\n    const sources = [];\n    this.sourceTiles_.forEach(\n      function (tile, i, arr) {\n        if (tile && tile.getState() == TileState.LOADED) {\n          sources.push({\n            extent: this.sourceTileGrid_.getTileCoordExtent(tile.tileCoord),\n            image: tile.getImage(),\n          });\n        }\n      }.bind(this)\n    );\n    this.sourceTiles_.length = 0;\n\n    if (sources.length === 0) {\n      this.state = TileState.ERROR;\n    } else {\n      const z = this.wrappedTileCoord_[0];\n      const size = this.targetTileGrid_.getTileSize(z);\n      const width = typeof size === 'number' ? size : size[0];\n      const height = typeof size === 'number' ? size : size[1];\n      const targetResolution = this.targetTileGrid_.getResolution(z);\n      const sourceResolution = this.sourceTileGrid_.getResolution(\n        this.sourceZ_\n      );\n\n      const targetExtent = this.targetTileGrid_.getTileCoordExtent(\n        this.wrappedTileCoord_\n      );\n      this.canvas_ = renderReprojected(\n        width,\n        height,\n        this.pixelRatio_,\n        sourceResolution,\n        this.sourceTileGrid_.getExtent(),\n        targetResolution,\n        targetExtent,\n        this.triangulation_,\n        sources,\n        this.gutter_,\n        this.renderEdges_,\n        this.contextOptions_\n      );\n\n      this.state = TileState.LOADED;\n    }\n    this.changed();\n  }\n\n  /**\n   * Load not yet loaded URI.\n   */\n  load() {\n    if (this.state == TileState.IDLE) {\n      this.state = TileState.LOADING;\n      this.changed();\n\n      let leftToLoad = 0;\n\n      this.sourcesListenerKeys_ = [];\n      this.sourceTiles_.forEach(\n        function (tile, i, arr) {\n          const state = tile.getState();\n          if (state == TileState.IDLE || state == TileState.LOADING) {\n            leftToLoad++;\n\n            const sourceListenKey = listen(\n              tile,\n              EventType.CHANGE,\n              function (e) {\n                const state = tile.getState();\n                if (\n                  state == TileState.LOADED ||\n                  state == TileState.ERROR ||\n                  state == TileState.EMPTY\n                ) {\n                  unlistenByKey(sourceListenKey);\n                  leftToLoad--;\n                  if (leftToLoad === 0) {\n                    this.unlistenSources_();\n                    this.reproject_();\n                  }\n                }\n              },\n              this\n            );\n            this.sourcesListenerKeys_.push(sourceListenKey);\n          }\n        }.bind(this)\n      );\n\n      this.sourceTiles_.forEach(function (tile, i, arr) {\n        const state = tile.getState();\n        if (state == TileState.IDLE) {\n          tile.load();\n        }\n      });\n\n      if (leftToLoad === 0) {\n        setTimeout(this.reproject_.bind(this), 0);\n      }\n    }\n  }\n\n  /**\n   * @private\n   */\n  unlistenSources_() {\n    this.sourcesListenerKeys_.forEach(unlistenByKey);\n    this.sourcesListenerKeys_ = null;\n  }\n}\n\nexport default ReprojTile;\n","/**\n * @module ol/reproj/common\n */\n\n/**\n * Default maximum allowed threshold  (in pixels) for reprojection\n * triangulation.\n * @type {number}\n */\nexport const ERROR_THRESHOLD = 0.5;\n\n/**\n * Enable automatic reprojection of raster sources. Default is `true`.\n * TODO: decide if we want to expose this as a build flag or remove it\n * @type {boolean}\n */\nexport const ENABLE_RASTER_REPROJECTION = true;\n","/**\n * @module ol/structs/LRUCache\n */\n\nimport {assert} from '../asserts.js';\n\n/**\n * @typedef {Object} Entry\n * @property {string} key_\n * @property {Object} newer\n * @property {Object} older\n * @property {*} value_\n */\n\n/**\n * @classdesc\n * Implements a Least-Recently-Used cache where the keys do not conflict with\n * Object's properties (e.g. 'hasOwnProperty' is not allowed as a key). Expiring\n * items from the cache is the responsibility of the user.\n *\n * @fires import(\"../events/Event.js\").default\n * @template T\n */\nclass LRUCache {\n  /**\n   * @param {number=} opt_highWaterMark High water mark.\n   */\n  constructor(opt_highWaterMark) {\n    /**\n     * Desired max cache size after expireCache(). If set to 0, no cache entries\n     * will be pruned at all.\n     * @type {number}\n     */\n    this.highWaterMark =\n      opt_highWaterMark !== undefined ? opt_highWaterMark : 2048;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.count_ = 0;\n\n    /**\n     * @private\n     * @type {!Object<string, Entry>}\n     */\n    this.entries_ = {};\n\n    /**\n     * @private\n     * @type {?Entry}\n     */\n    this.oldest_ = null;\n\n    /**\n     * @private\n     * @type {?Entry}\n     */\n    this.newest_ = null;\n  }\n\n  /**\n   * @return {boolean} Can expire cache.\n   */\n  canExpireCache() {\n    return this.highWaterMark > 0 && this.getCount() > this.highWaterMark;\n  }\n\n  /**\n   * FIXME empty description for jsdoc\n   */\n  clear() {\n    this.count_ = 0;\n    this.entries_ = {};\n    this.oldest_ = null;\n    this.newest_ = null;\n  }\n\n  /**\n   * @param {string} key Key.\n   * @return {boolean} Contains key.\n   */\n  containsKey(key) {\n    return this.entries_.hasOwnProperty(key);\n  }\n\n  /**\n   * @param {function(T, string, LRUCache<T>): ?} f The function\n   *     to call for every entry from the oldest to the newer. This function takes\n   *     3 arguments (the entry value, the entry key and the LRUCache object).\n   *     The return value is ignored.\n   */\n  forEach(f) {\n    let entry = this.oldest_;\n    while (entry) {\n      f(entry.value_, entry.key_, this);\n      entry = entry.newer;\n    }\n  }\n\n  /**\n   * @param {string} key Key.\n   * @param {*=} opt_options Options (reserverd for subclasses).\n   * @return {T} Value.\n   */\n  get(key, opt_options) {\n    const entry = this.entries_[key];\n    assert(entry !== undefined, 15); // Tried to get a value for a key that does not exist in the cache\n    if (entry === this.newest_) {\n      return entry.value_;\n    } else if (entry === this.oldest_) {\n      this.oldest_ = /** @type {Entry} */ (this.oldest_.newer);\n      this.oldest_.older = null;\n    } else {\n      entry.newer.older = entry.older;\n      entry.older.newer = entry.newer;\n    }\n    entry.newer = null;\n    entry.older = this.newest_;\n    this.newest_.newer = entry;\n    this.newest_ = entry;\n    return entry.value_;\n  }\n\n  /**\n   * Remove an entry from the cache.\n   * @param {string} key The entry key.\n   * @return {T} The removed entry.\n   */\n  remove(key) {\n    const entry = this.entries_[key];\n    assert(entry !== undefined, 15); // Tried to get a value for a key that does not exist in the cache\n    if (entry === this.newest_) {\n      this.newest_ = /** @type {Entry} */ (entry.older);\n      if (this.newest_) {\n        this.newest_.newer = null;\n      }\n    } else if (entry === this.oldest_) {\n      this.oldest_ = /** @type {Entry} */ (entry.newer);\n      if (this.oldest_) {\n        this.oldest_.older = null;\n      }\n    } else {\n      entry.newer.older = entry.older;\n      entry.older.newer = entry.newer;\n    }\n    delete this.entries_[key];\n    --this.count_;\n    return entry.value_;\n  }\n\n  /**\n   * @return {number} Count.\n   */\n  getCount() {\n    return this.count_;\n  }\n\n  /**\n   * @return {Array<string>} Keys.\n   */\n  getKeys() {\n    const keys = new Array(this.count_);\n    let i = 0;\n    let entry;\n    for (entry = this.newest_; entry; entry = entry.older) {\n      keys[i++] = entry.key_;\n    }\n    return keys;\n  }\n\n  /**\n   * @return {Array<T>} Values.\n   */\n  getValues() {\n    const values = new Array(this.count_);\n    let i = 0;\n    let entry;\n    for (entry = this.newest_; entry; entry = entry.older) {\n      values[i++] = entry.value_;\n    }\n    return values;\n  }\n\n  /**\n   * @return {T} Last value.\n   */\n  peekLast() {\n    return this.oldest_.value_;\n  }\n\n  /**\n   * @return {string} Last key.\n   */\n  peekLastKey() {\n    return this.oldest_.key_;\n  }\n\n  /**\n   * Get the key of the newest item in the cache.  Throws if the cache is empty.\n   * @return {string} The newest key.\n   */\n  peekFirstKey() {\n    return this.newest_.key_;\n  }\n\n  /**\n   * @return {T} value Value.\n   */\n  pop() {\n    const entry = this.oldest_;\n    delete this.entries_[entry.key_];\n    if (entry.newer) {\n      entry.newer.older = null;\n    }\n    this.oldest_ = /** @type {Entry} */ (entry.newer);\n    if (!this.oldest_) {\n      this.newest_ = null;\n    }\n    --this.count_;\n    return entry.value_;\n  }\n\n  /**\n   * @param {string} key Key.\n   * @param {T} value Value.\n   */\n  replace(key, value) {\n    this.get(key); // update `newest_`\n    this.entries_[key].value_ = value;\n  }\n\n  /**\n   * @param {string} key Key.\n   * @param {T} value Value.\n   */\n  set(key, value) {\n    assert(!(key in this.entries_), 16); // Tried to set a value for a key that is used already\n    const entry = {\n      key_: key,\n      newer: null,\n      older: this.newest_,\n      value_: value,\n    };\n    if (!this.newest_) {\n      this.oldest_ = entry;\n    } else {\n      this.newest_.newer = entry;\n    }\n    this.newest_ = entry;\n    this.entries_[key] = entry;\n    ++this.count_;\n  }\n\n  /**\n   * Set a maximum number of entries for the cache.\n   * @param {number} size Cache size.\n   * @api\n   */\n  setSize(size) {\n    this.highWaterMark = size;\n  }\n}\n\nexport default LRUCache;\n","/**\n * @module ol/tilecoord\n */\n\n/**\n * An array of three numbers representing the location of a tile in a tile\n * grid. The order is `z` (zoom level), `x` (column), and `y` (row).\n * @typedef {Array<number>} TileCoord\n * @api\n */\n\n/**\n * @param {number} z Z.\n * @param {number} x X.\n * @param {number} y Y.\n * @param {TileCoord=} opt_tileCoord Tile coordinate.\n * @return {TileCoord} Tile coordinate.\n */\nexport function createOrUpdate(z, x, y, opt_tileCoord) {\n  if (opt_tileCoord !== undefined) {\n    opt_tileCoord[0] = z;\n    opt_tileCoord[1] = x;\n    opt_tileCoord[2] = y;\n    return opt_tileCoord;\n  } else {\n    return [z, x, y];\n  }\n}\n\n/**\n * @param {number} z Z.\n * @param {number} x X.\n * @param {number} y Y.\n * @return {string} Key.\n */\nexport function getKeyZXY(z, x, y) {\n  return z + '/' + x + '/' + y;\n}\n\n/**\n * Get the key for a tile coord.\n * @param {TileCoord} tileCoord The tile coord.\n * @return {string} Key.\n */\nexport function getKey(tileCoord) {\n  return getKeyZXY(tileCoord[0], tileCoord[1], tileCoord[2]);\n}\n\n/**\n * Get a tile coord given a key.\n * @param {string} key The tile coord key.\n * @return {TileCoord} The tile coord.\n */\nexport function fromKey(key) {\n  return key.split('/').map(Number);\n}\n\n/**\n * @param {TileCoord} tileCoord Tile coord.\n * @return {number} Hash.\n */\nexport function hash(tileCoord) {\n  return (tileCoord[1] << tileCoord[0]) + tileCoord[2];\n}\n\n/**\n * @param {TileCoord} tileCoord Tile coordinate.\n * @param {!import(\"./tilegrid/TileGrid.js\").default} tileGrid Tile grid.\n * @return {boolean} Tile coordinate is within extent and zoom level range.\n */\nexport function withinExtentAndZ(tileCoord, tileGrid) {\n  const z = tileCoord[0];\n  const x = tileCoord[1];\n  const y = tileCoord[2];\n\n  if (tileGrid.getMinZoom() > z || z > tileGrid.getMaxZoom()) {\n    return false;\n  }\n  const tileRange = tileGrid.getFullTileRange(z);\n  if (!tileRange) {\n    return true;\n  } else {\n    return tileRange.containsXY(x, y);\n  }\n}\n","/**\n * @module ol/TileCache\n */\nimport LRUCache from './structs/LRUCache.js';\nimport {fromKey, getKey} from './tilecoord.js';\n\nclass TileCache extends LRUCache {\n  /**\n   * @param {!Object<string, boolean>} usedTiles Used tiles.\n   */\n  expireCache(usedTiles) {\n    while (this.canExpireCache()) {\n      const tile = this.peekLast();\n      if (tile.getKey() in usedTiles) {\n        break;\n      } else {\n        this.pop().release();\n      }\n    }\n  }\n\n  /**\n   * Prune all tiles from the cache that don't have the same z as the newest tile.\n   */\n  pruneExceptNewestZ() {\n    if (this.getCount() === 0) {\n      return;\n    }\n    const key = this.peekFirstKey();\n    const tileCoord = fromKey(key);\n    const z = tileCoord[0];\n    this.forEach(\n      function (tile) {\n        if (tile.tileCoord[0] !== z) {\n          this.remove(getKey(tile.tileCoord));\n          tile.release();\n        }\n      }.bind(this)\n    );\n  }\n}\n\nexport default TileCache;\n","/**\n * @module ol/source/TileEventType\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  /**\n   * Triggered when a tile starts loading.\n   * @event module:ol/source/Tile.TileSourceEvent#tileloadstart\n   * @api\n   */\n  TILELOADSTART: 'tileloadstart',\n\n  /**\n   * Triggered when a tile finishes loading, either when its data is loaded,\n   * or when loading was aborted because the tile is no longer needed.\n   * @event module:ol/source/Tile.TileSourceEvent#tileloadend\n   * @api\n   */\n  TILELOADEND: 'tileloadend',\n\n  /**\n   * Triggered if tile loading results in an error.\n   * @event module:ol/source/Tile.TileSourceEvent#tileloaderror\n   * @api\n   */\n  TILELOADERROR: 'tileloaderror',\n};\n","/**\n * @module ol/source/Source\n */\nimport BaseObject from '../Object.js';\nimport SourceState from './State.js';\nimport {abstract} from '../util.js';\nimport {get as getProjection} from '../proj.js';\n\n/**\n * A function that returns a string or an array of strings representing source\n * attributions.\n *\n * @typedef {function(import(\"../PluggableMap.js\").FrameState): (string|Array<string>)} Attribution\n */\n\n/**\n * A type that can be used to provide attribution information for data sources.\n *\n * It represents either\n * * a simple string (e.g. `'© Acme Inc.'`)\n * * an array of simple strings (e.g. `['© Acme Inc.', '© Bacme Inc.']`)\n * * a function that returns a string or array of strings ({@link module:ol/source/Source~Attribution})\n *\n * @typedef {string|Array<string>|Attribution} AttributionLike\n */\n\n/**\n * @typedef {Object} Options\n * @property {AttributionLike} [attributions]\n * @property {boolean} [attributionsCollapsible=true] Attributions are collapsible.\n * @property {import(\"../proj.js\").ProjectionLike} [projection] Projection. Default is the view projection.\n * @property {import(\"./State.js\").default} [state='ready']\n * @property {boolean} [wrapX=false]\n */\n\n/**\n * @classdesc\n * Abstract base class; normally only used for creating subclasses and not\n * instantiated in apps.\n * Base class for {@link module:ol/layer/Layer~Layer} sources.\n *\n * A generic `change` event is triggered when the state of the source changes.\n * @abstract\n * @api\n */\nclass Source extends BaseObject {\n  /**\n   * @param {Options} options Source options.\n   */\n  constructor(options) {\n    super();\n\n    /**\n     * @private\n     * @type {import(\"../proj/Projection.js\").default}\n     */\n    this.projection_ = getProjection(options.projection);\n\n    /**\n     * @private\n     * @type {?Attribution}\n     */\n    this.attributions_ = adaptAttributions(options.attributions);\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.attributionsCollapsible_ =\n      options.attributionsCollapsible !== undefined\n        ? options.attributionsCollapsible\n        : true;\n\n    /**\n     * This source is currently loading data. Sources that defer loading to the\n     * map's tile queue never set this to `true`.\n     * @type {boolean}\n     */\n    this.loading = false;\n\n    /**\n     * @private\n     * @type {import(\"./State.js\").default}\n     */\n    this.state_ =\n      options.state !== undefined ? options.state : SourceState.READY;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.wrapX_ = options.wrapX !== undefined ? options.wrapX : false;\n  }\n\n  /**\n   * Get the attribution function for the source.\n   * @return {?Attribution} Attribution function.\n   */\n  getAttributions() {\n    return this.attributions_;\n  }\n\n  /**\n   * @return {boolean} Attributions are collapsible.\n   */\n  getAttributionsCollapsible() {\n    return this.attributionsCollapsible_;\n  }\n\n  /**\n   * Get the projection of the source.\n   * @return {import(\"../proj/Projection.js\").default} Projection.\n   * @api\n   */\n  getProjection() {\n    return this.projection_;\n  }\n\n  /**\n   * @abstract\n   * @return {Array<number>|undefined} Resolutions.\n   */\n  getResolutions() {\n    return abstract();\n  }\n\n  /**\n   * Get the state of the source, see {@link module:ol/source/State~State} for possible states.\n   * @return {import(\"./State.js\").default} State.\n   * @api\n   */\n  getState() {\n    return this.state_;\n  }\n\n  /**\n   * @return {boolean|undefined} Wrap X.\n   */\n  getWrapX() {\n    return this.wrapX_;\n  }\n\n  /**\n   * @return {Object|undefined} Context options.\n   */\n  getContextOptions() {\n    return undefined;\n  }\n\n  /**\n   * Refreshes the source. The source will be cleared, and data from the server will be reloaded.\n   * @api\n   */\n  refresh() {\n    this.changed();\n  }\n\n  /**\n   * Set the attributions of the source.\n   * @param {AttributionLike|undefined} attributions Attributions.\n   *     Can be passed as `string`, `Array<string>`, {@link module:ol/source/Source~Attribution},\n   *     or `undefined`.\n   * @api\n   */\n  setAttributions(attributions) {\n    this.attributions_ = adaptAttributions(attributions);\n    this.changed();\n  }\n\n  /**\n   * Set the state of the source.\n   * @param {import(\"./State.js\").default} state State.\n   */\n  setState(state) {\n    this.state_ = state;\n    this.changed();\n  }\n}\n\n/**\n * Turns the attributions option into an attributions function.\n * @param {AttributionLike|undefined} attributionLike The attribution option.\n * @return {?Attribution} An attribution function (or null).\n */\nfunction adaptAttributions(attributionLike) {\n  if (!attributionLike) {\n    return null;\n  }\n  if (Array.isArray(attributionLike)) {\n    return function (frameState) {\n      return attributionLike;\n    };\n  }\n\n  if (typeof attributionLike === 'function') {\n    return attributionLike;\n  }\n\n  return function (frameState) {\n    return [attributionLike];\n  };\n}\n\nexport default Source;\n","/**\n * @module ol/tilegrid/TileGrid\n */\nimport TileRange, {\n  createOrUpdate as createOrUpdateTileRange,\n} from '../TileRange.js';\nimport {DEFAULT_TILE_SIZE} from './common.js';\nimport {assert} from '../asserts.js';\nimport {clamp} from '../math.js';\nimport {createOrUpdate, getTopLeft} from '../extent.js';\nimport {createOrUpdate as createOrUpdateTileCoord} from '../tilecoord.js';\nimport {isSorted, linearFindNearest} from '../array.js';\nimport {toSize} from '../size.js';\n\n/**\n * @private\n * @type {import(\"../tilecoord.js\").TileCoord}\n */\nconst tmpTileCoord = [0, 0, 0];\n\n/**\n * @typedef {Object} Options\n * @property {import(\"../extent.js\").Extent} [extent] Extent for the tile grid. No tiles outside this\n * extent will be requested by {@link module:ol/source/Tile} sources. When no `origin` or\n * `origins` are configured, the `origin` will be set to the top-left corner of the extent.\n * @property {number} [minZoom=0] Minimum zoom.\n * @property {import(\"../coordinate.js\").Coordinate} [origin] The tile grid origin, i.e. where the `x`\n * and `y` axes meet (`[z, 0, 0]`). Tile coordinates increase left to right and downwards. If not\n * specified, `extent` or `origins` must be provided.\n * @property {Array<import(\"../coordinate.js\").Coordinate>} [origins] Tile grid origins, i.e. where\n * the `x` and `y` axes meet (`[z, 0, 0]`), for each zoom level. If given, the array length\n * should match the length of the `resolutions` array, i.e. each resolution can have a different\n * origin. Tile coordinates increase left to right and downwards. If not specified, `extent` or\n * `origin` must be provided.\n * @property {!Array<number>} resolutions Resolutions. The array index of each resolution needs\n * to match the zoom level. This means that even if a `minZoom` is configured, the resolutions\n * array will have a length of `maxZoom + 1`.\n * @property {Array<import(\"../size.js\").Size>} [sizes] Number of tile rows and columns\n * of the grid for each zoom level. If specified the values\n * define each zoom level's extent together with the `origin` or `origins`.\n * A grid `extent` can be configured in addition, and will further limit the extent\n * for which tile requests are made by sources. If the bottom-left corner of\n * an extent is used as `origin` or `origins`, then the `y` value must be\n * negative because OpenLayers tile coordinates use the top left as the origin.\n * @property {number|import(\"../size.js\").Size} [tileSize] Tile size.\n * Default is `[256, 256]`.\n * @property {Array<import(\"../size.js\").Size>} [tileSizes] Tile sizes. If given, the array length\n * should match the length of the `resolutions` array, i.e. each resolution can have a different\n * tile size.\n */\n\n/**\n * @classdesc\n * Base class for setting the grid pattern for sources accessing tiled-image\n * servers.\n * @api\n */\nclass TileGrid {\n  /**\n   * @param {Options} options Tile grid options.\n   */\n  constructor(options) {\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.minZoom = options.minZoom !== undefined ? options.minZoom : 0;\n\n    /**\n     * @private\n     * @type {!Array<number>}\n     */\n    this.resolutions_ = options.resolutions;\n    assert(\n      isSorted(\n        this.resolutions_,\n        function (a, b) {\n          return b - a;\n        },\n        true\n      ),\n      17\n    ); // `resolutions` must be sorted in descending order\n\n    // check if we've got a consistent zoom factor and origin\n    let zoomFactor;\n    if (!options.origins) {\n      for (let i = 0, ii = this.resolutions_.length - 1; i < ii; ++i) {\n        if (!zoomFactor) {\n          zoomFactor = this.resolutions_[i] / this.resolutions_[i + 1];\n        } else {\n          if (this.resolutions_[i] / this.resolutions_[i + 1] !== zoomFactor) {\n            zoomFactor = undefined;\n            break;\n          }\n        }\n      }\n    }\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.zoomFactor_ = zoomFactor;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.maxZoom = this.resolutions_.length - 1;\n\n    /**\n     * @private\n     * @type {import(\"../coordinate.js\").Coordinate}\n     */\n    this.origin_ = options.origin !== undefined ? options.origin : null;\n\n    /**\n     * @private\n     * @type {Array<import(\"../coordinate.js\").Coordinate>}\n     */\n    this.origins_ = null;\n    if (options.origins !== undefined) {\n      this.origins_ = options.origins;\n      assert(this.origins_.length == this.resolutions_.length, 20); // Number of `origins` and `resolutions` must be equal\n    }\n\n    const extent = options.extent;\n\n    if (extent !== undefined && !this.origin_ && !this.origins_) {\n      this.origin_ = getTopLeft(extent);\n    }\n\n    assert(\n      (!this.origin_ && this.origins_) || (this.origin_ && !this.origins_),\n      18\n    ); // Either `origin` or `origins` must be configured, never both\n\n    /**\n     * @private\n     * @type {Array<number|import(\"../size.js\").Size>}\n     */\n    this.tileSizes_ = null;\n    if (options.tileSizes !== undefined) {\n      this.tileSizes_ = options.tileSizes;\n      assert(this.tileSizes_.length == this.resolutions_.length, 19); // Number of `tileSizes` and `resolutions` must be equal\n    }\n\n    /**\n     * @private\n     * @type {number|import(\"../size.js\").Size}\n     */\n    this.tileSize_ =\n      options.tileSize !== undefined\n        ? options.tileSize\n        : !this.tileSizes_\n        ? DEFAULT_TILE_SIZE\n        : null;\n    assert(\n      (!this.tileSize_ && this.tileSizes_) ||\n        (this.tileSize_ && !this.tileSizes_),\n      22\n    ); // Either `tileSize` or `tileSizes` must be configured, never both\n\n    /**\n     * @private\n     * @type {import(\"../extent.js\").Extent}\n     */\n    this.extent_ = extent !== undefined ? extent : null;\n\n    /**\n     * @private\n     * @type {Array<import(\"../TileRange.js\").default>}\n     */\n    this.fullTileRanges_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../size.js\").Size}\n     */\n    this.tmpSize_ = [0, 0];\n\n    if (options.sizes !== undefined) {\n      this.fullTileRanges_ = options.sizes.map(function (size, z) {\n        const tileRange = new TileRange(\n          Math.min(0, size[0]),\n          Math.max(size[0] - 1, -1),\n          Math.min(0, size[1]),\n          Math.max(size[1] - 1, -1)\n        );\n        if (extent) {\n          const restrictedTileRange = this.getTileRangeForExtentAndZ(extent, z);\n          tileRange.minX = Math.max(restrictedTileRange.minX, tileRange.minX);\n          tileRange.maxX = Math.min(restrictedTileRange.maxX, tileRange.maxX);\n          tileRange.minY = Math.max(restrictedTileRange.minY, tileRange.minY);\n          tileRange.maxY = Math.min(restrictedTileRange.maxY, tileRange.maxY);\n        }\n        return tileRange;\n      }, this);\n    } else if (extent) {\n      this.calculateTileRanges_(extent);\n    }\n  }\n\n  /**\n   * Call a function with each tile coordinate for a given extent and zoom level.\n   *\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @param {number} zoom Integer zoom level.\n   * @param {function(import(\"../tilecoord.js\").TileCoord): void} callback Function called with each tile coordinate.\n   * @api\n   */\n  forEachTileCoord(extent, zoom, callback) {\n    const tileRange = this.getTileRangeForExtentAndZ(extent, zoom);\n    for (let i = tileRange.minX, ii = tileRange.maxX; i <= ii; ++i) {\n      for (let j = tileRange.minY, jj = tileRange.maxY; j <= jj; ++j) {\n        callback([zoom, i, j]);\n      }\n    }\n  }\n\n  /**\n   * @param {import(\"../tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @param {function(number, import(\"../TileRange.js\").default): boolean} callback Callback.\n   * @param {import(\"../TileRange.js\").default=} opt_tileRange Temporary import(\"../TileRange.js\").default object.\n   * @param {import(\"../extent.js\").Extent=} opt_extent Temporary import(\"../extent.js\").Extent object.\n   * @return {boolean} Callback succeeded.\n   */\n  forEachTileCoordParentTileRange(\n    tileCoord,\n    callback,\n    opt_tileRange,\n    opt_extent\n  ) {\n    let tileRange, x, y;\n    let tileCoordExtent = null;\n    let z = tileCoord[0] - 1;\n    if (this.zoomFactor_ === 2) {\n      x = tileCoord[1];\n      y = tileCoord[2];\n    } else {\n      tileCoordExtent = this.getTileCoordExtent(tileCoord, opt_extent);\n    }\n    while (z >= this.minZoom) {\n      if (this.zoomFactor_ === 2) {\n        x = Math.floor(x / 2);\n        y = Math.floor(y / 2);\n        tileRange = createOrUpdateTileRange(x, x, y, y, opt_tileRange);\n      } else {\n        tileRange = this.getTileRangeForExtentAndZ(\n          tileCoordExtent,\n          z,\n          opt_tileRange\n        );\n      }\n      if (callback(z, tileRange)) {\n        return true;\n      }\n      --z;\n    }\n    return false;\n  }\n\n  /**\n   * Get the extent for this tile grid, if it was configured.\n   * @return {import(\"../extent.js\").Extent} Extent.\n   * @api\n   */\n  getExtent() {\n    return this.extent_;\n  }\n\n  /**\n   * Get the maximum zoom level for the grid.\n   * @return {number} Max zoom.\n   * @api\n   */\n  getMaxZoom() {\n    return this.maxZoom;\n  }\n\n  /**\n   * Get the minimum zoom level for the grid.\n   * @return {number} Min zoom.\n   * @api\n   */\n  getMinZoom() {\n    return this.minZoom;\n  }\n\n  /**\n   * Get the origin for the grid at the given zoom level.\n   * @param {number} z Integer zoom level.\n   * @return {import(\"../coordinate.js\").Coordinate} Origin.\n   * @api\n   */\n  getOrigin(z) {\n    if (this.origin_) {\n      return this.origin_;\n    } else {\n      return this.origins_[z];\n    }\n  }\n\n  /**\n   * Get the resolution for the given zoom level.\n   * @param {number} z Integer zoom level.\n   * @return {number} Resolution.\n   * @api\n   */\n  getResolution(z) {\n    return this.resolutions_[z];\n  }\n\n  /**\n   * Get the list of resolutions for the tile grid.\n   * @return {Array<number>} Resolutions.\n   * @api\n   */\n  getResolutions() {\n    return this.resolutions_;\n  }\n\n  /**\n   * @param {import(\"../tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @param {import(\"../TileRange.js\").default=} opt_tileRange Temporary import(\"../TileRange.js\").default object.\n   * @param {import(\"../extent.js\").Extent=} opt_extent Temporary import(\"../extent.js\").Extent object.\n   * @return {import(\"../TileRange.js\").default} Tile range.\n   */\n  getTileCoordChildTileRange(tileCoord, opt_tileRange, opt_extent) {\n    if (tileCoord[0] < this.maxZoom) {\n      if (this.zoomFactor_ === 2) {\n        const minX = tileCoord[1] * 2;\n        const minY = tileCoord[2] * 2;\n        return createOrUpdateTileRange(\n          minX,\n          minX + 1,\n          minY,\n          minY + 1,\n          opt_tileRange\n        );\n      }\n      const tileCoordExtent = this.getTileCoordExtent(tileCoord, opt_extent);\n      return this.getTileRangeForExtentAndZ(\n        tileCoordExtent,\n        tileCoord[0] + 1,\n        opt_tileRange\n      );\n    }\n    return null;\n  }\n\n  /**\n   * Get the extent for a tile range.\n   * @param {number} z Integer zoom level.\n   * @param {import(\"../TileRange.js\").default} tileRange Tile range.\n   * @param {import(\"../extent.js\").Extent=} opt_extent Temporary import(\"../extent.js\").Extent object.\n   * @return {import(\"../extent.js\").Extent} Extent.\n   */\n  getTileRangeExtent(z, tileRange, opt_extent) {\n    const origin = this.getOrigin(z);\n    const resolution = this.getResolution(z);\n    const tileSize = toSize(this.getTileSize(z), this.tmpSize_);\n    const minX = origin[0] + tileRange.minX * tileSize[0] * resolution;\n    const maxX = origin[0] + (tileRange.maxX + 1) * tileSize[0] * resolution;\n    const minY = origin[1] + tileRange.minY * tileSize[1] * resolution;\n    const maxY = origin[1] + (tileRange.maxY + 1) * tileSize[1] * resolution;\n    return createOrUpdate(minX, minY, maxX, maxY, opt_extent);\n  }\n\n  /**\n   * Get a tile range for the given extent and integer zoom level.\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @param {number} z Integer zoom level.\n   * @param {import(\"../TileRange.js\").default=} opt_tileRange Temporary tile range object.\n   * @return {import(\"../TileRange.js\").default} Tile range.\n   */\n  getTileRangeForExtentAndZ(extent, z, opt_tileRange) {\n    const tileCoord = tmpTileCoord;\n    this.getTileCoordForXYAndZ_(extent[0], extent[3], z, false, tileCoord);\n    const minX = tileCoord[1];\n    const minY = tileCoord[2];\n    this.getTileCoordForXYAndZ_(extent[2], extent[1], z, true, tileCoord);\n    return createOrUpdateTileRange(\n      minX,\n      tileCoord[1],\n      minY,\n      tileCoord[2],\n      opt_tileRange\n    );\n  }\n\n  /**\n   * @param {import(\"../tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @return {import(\"../coordinate.js\").Coordinate} Tile center.\n   */\n  getTileCoordCenter(tileCoord) {\n    const origin = this.getOrigin(tileCoord[0]);\n    const resolution = this.getResolution(tileCoord[0]);\n    const tileSize = toSize(this.getTileSize(tileCoord[0]), this.tmpSize_);\n    return [\n      origin[0] + (tileCoord[1] + 0.5) * tileSize[0] * resolution,\n      origin[1] - (tileCoord[2] + 0.5) * tileSize[1] * resolution,\n    ];\n  }\n\n  /**\n   * Get the extent of a tile coordinate.\n   *\n   * @param {import(\"../tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @param {import(\"../extent.js\").Extent=} opt_extent Temporary extent object.\n   * @return {import(\"../extent.js\").Extent} Extent.\n   * @api\n   */\n  getTileCoordExtent(tileCoord, opt_extent) {\n    const origin = this.getOrigin(tileCoord[0]);\n    const resolution = this.getResolution(tileCoord[0]);\n    const tileSize = toSize(this.getTileSize(tileCoord[0]), this.tmpSize_);\n    const minX = origin[0] + tileCoord[1] * tileSize[0] * resolution;\n    const minY = origin[1] - (tileCoord[2] + 1) * tileSize[1] * resolution;\n    const maxX = minX + tileSize[0] * resolution;\n    const maxY = minY + tileSize[1] * resolution;\n    return createOrUpdate(minX, minY, maxX, maxY, opt_extent);\n  }\n\n  /**\n   * Get the tile coordinate for the given map coordinate and resolution.  This\n   * method considers that coordinates that intersect tile boundaries should be\n   * assigned the higher tile coordinate.\n   *\n   * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {number} resolution Resolution.\n   * @param {import(\"../tilecoord.js\").TileCoord=} opt_tileCoord Destination import(\"../tilecoord.js\").TileCoord object.\n   * @return {import(\"../tilecoord.js\").TileCoord} Tile coordinate.\n   * @api\n   */\n  getTileCoordForCoordAndResolution(coordinate, resolution, opt_tileCoord) {\n    return this.getTileCoordForXYAndResolution_(\n      coordinate[0],\n      coordinate[1],\n      resolution,\n      false,\n      opt_tileCoord\n    );\n  }\n\n  /**\n   * Note that this method should not be called for resolutions that correspond\n   * to an integer zoom level.  Instead call the `getTileCoordForXYAndZ_` method.\n   * @param {number} x X.\n   * @param {number} y Y.\n   * @param {number} resolution Resolution (for a non-integer zoom level).\n   * @param {boolean} reverseIntersectionPolicy Instead of letting edge\n   *     intersections go to the higher tile coordinate, let edge intersections\n   *     go to the lower tile coordinate.\n   * @param {import(\"../tilecoord.js\").TileCoord=} opt_tileCoord Temporary import(\"../tilecoord.js\").TileCoord object.\n   * @return {import(\"../tilecoord.js\").TileCoord} Tile coordinate.\n   * @private\n   */\n  getTileCoordForXYAndResolution_(\n    x,\n    y,\n    resolution,\n    reverseIntersectionPolicy,\n    opt_tileCoord\n  ) {\n    const z = this.getZForResolution(resolution);\n    const scale = resolution / this.getResolution(z);\n    const origin = this.getOrigin(z);\n    const tileSize = toSize(this.getTileSize(z), this.tmpSize_);\n\n    const adjustX = reverseIntersectionPolicy ? 0.5 : 0;\n    const adjustY = reverseIntersectionPolicy ? 0.5 : 0;\n    const xFromOrigin = Math.floor((x - origin[0]) / resolution + adjustX);\n    const yFromOrigin = Math.floor((origin[1] - y) / resolution + adjustY);\n    let tileCoordX = (scale * xFromOrigin) / tileSize[0];\n    let tileCoordY = (scale * yFromOrigin) / tileSize[1];\n\n    if (reverseIntersectionPolicy) {\n      tileCoordX = Math.ceil(tileCoordX) - 1;\n      tileCoordY = Math.ceil(tileCoordY) - 1;\n    } else {\n      tileCoordX = Math.floor(tileCoordX);\n      tileCoordY = Math.floor(tileCoordY);\n    }\n\n    return createOrUpdateTileCoord(z, tileCoordX, tileCoordY, opt_tileCoord);\n  }\n\n  /**\n   * Although there is repetition between this method and `getTileCoordForXYAndResolution_`,\n   * they should have separate implementations.  This method is for integer zoom\n   * levels.  The other method should only be called for resolutions corresponding\n   * to non-integer zoom levels.\n   * @param {number} x Map x coordinate.\n   * @param {number} y Map y coordinate.\n   * @param {number} z Integer zoom level.\n   * @param {boolean} reverseIntersectionPolicy Instead of letting edge\n   *     intersections go to the higher tile coordinate, let edge intersections\n   *     go to the lower tile coordinate.\n   * @param {import(\"../tilecoord.js\").TileCoord=} opt_tileCoord Temporary import(\"../tilecoord.js\").TileCoord object.\n   * @return {import(\"../tilecoord.js\").TileCoord} Tile coordinate.\n   * @private\n   */\n  getTileCoordForXYAndZ_(x, y, z, reverseIntersectionPolicy, opt_tileCoord) {\n    const origin = this.getOrigin(z);\n    const resolution = this.getResolution(z);\n    const tileSize = toSize(this.getTileSize(z), this.tmpSize_);\n\n    const adjustX = reverseIntersectionPolicy ? 0.5 : 0;\n    const adjustY = reverseIntersectionPolicy ? 0.5 : 0;\n    const xFromOrigin = Math.floor((x - origin[0]) / resolution + adjustX);\n    const yFromOrigin = Math.floor((origin[1] - y) / resolution + adjustY);\n    let tileCoordX = xFromOrigin / tileSize[0];\n    let tileCoordY = yFromOrigin / tileSize[1];\n\n    if (reverseIntersectionPolicy) {\n      tileCoordX = Math.ceil(tileCoordX) - 1;\n      tileCoordY = Math.ceil(tileCoordY) - 1;\n    } else {\n      tileCoordX = Math.floor(tileCoordX);\n      tileCoordY = Math.floor(tileCoordY);\n    }\n\n    return createOrUpdateTileCoord(z, tileCoordX, tileCoordY, opt_tileCoord);\n  }\n\n  /**\n   * Get a tile coordinate given a map coordinate and zoom level.\n   * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {number} z Zoom level.\n   * @param {import(\"../tilecoord.js\").TileCoord=} opt_tileCoord Destination import(\"../tilecoord.js\").TileCoord object.\n   * @return {import(\"../tilecoord.js\").TileCoord} Tile coordinate.\n   * @api\n   */\n  getTileCoordForCoordAndZ(coordinate, z, opt_tileCoord) {\n    return this.getTileCoordForXYAndZ_(\n      coordinate[0],\n      coordinate[1],\n      z,\n      false,\n      opt_tileCoord\n    );\n  }\n\n  /**\n   * @param {import(\"../tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @return {number} Tile resolution.\n   */\n  getTileCoordResolution(tileCoord) {\n    return this.resolutions_[tileCoord[0]];\n  }\n\n  /**\n   * Get the tile size for a zoom level. The type of the return value matches the\n   * `tileSize` or `tileSizes` that the tile grid was configured with. To always\n   * get an `import(\"../size.js\").Size`, run the result through `import(\"../size.js\").Size.toSize()`.\n   * @param {number} z Z.\n   * @return {number|import(\"../size.js\").Size} Tile size.\n   * @api\n   */\n  getTileSize(z) {\n    if (this.tileSize_) {\n      return this.tileSize_;\n    } else {\n      return this.tileSizes_[z];\n    }\n  }\n\n  /**\n   * @param {number} z Zoom level.\n   * @return {import(\"../TileRange.js\").default} Extent tile range for the specified zoom level.\n   */\n  getFullTileRange(z) {\n    if (!this.fullTileRanges_) {\n      return this.extent_\n        ? this.getTileRangeForExtentAndZ(this.extent_, z)\n        : null;\n    } else {\n      return this.fullTileRanges_[z];\n    }\n  }\n\n  /**\n   * @param {number} resolution Resolution.\n   * @param {number=} opt_direction If 0, the nearest resolution will be used.\n   *     If 1, the nearest lower resolution will be used. If -1, the nearest\n   *     higher resolution will be used. Default is 0.\n   * @return {number} Z.\n   * @api\n   */\n  getZForResolution(resolution, opt_direction) {\n    const z = linearFindNearest(\n      this.resolutions_,\n      resolution,\n      opt_direction || 0\n    );\n    return clamp(z, this.minZoom, this.maxZoom);\n  }\n\n  /**\n   * @param {!import(\"../extent.js\").Extent} extent Extent for this tile grid.\n   * @private\n   */\n  calculateTileRanges_(extent) {\n    const length = this.resolutions_.length;\n    const fullTileRanges = new Array(length);\n    for (let z = this.minZoom; z < length; ++z) {\n      fullTileRanges[z] = this.getTileRangeForExtentAndZ(extent, z);\n    }\n    this.fullTileRanges_ = fullTileRanges;\n  }\n}\n\nexport default TileGrid;\n","/**\n * @module ol/tilegrid\n */\nimport Corner from './extent/Corner.js';\nimport TileGrid from './tilegrid/TileGrid.js';\nimport Units from './proj/Units.js';\nimport {DEFAULT_MAX_ZOOM, DEFAULT_TILE_SIZE} from './tilegrid/common.js';\nimport {METERS_PER_UNIT, get as getProjection} from './proj.js';\nimport {\n  containsCoordinate,\n  createOrUpdate,\n  getCorner,\n  getHeight,\n  getWidth,\n} from './extent.js';\nimport {toSize} from './size.js';\n\n/**\n * @param {import(\"./proj/Projection.js\").default} projection Projection.\n * @return {!TileGrid} Default tile grid for the\n * passed projection.\n */\nexport function getForProjection(projection) {\n  let tileGrid = projection.getDefaultTileGrid();\n  if (!tileGrid) {\n    tileGrid = createForProjection(projection);\n    projection.setDefaultTileGrid(tileGrid);\n  }\n  return tileGrid;\n}\n\n/**\n * @param {TileGrid} tileGrid Tile grid.\n * @param {import(\"./tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n * @param {import(\"./proj/Projection.js\").default} projection Projection.\n * @return {import(\"./tilecoord.js\").TileCoord} Tile coordinate.\n */\nexport function wrapX(tileGrid, tileCoord, projection) {\n  const z = tileCoord[0];\n  const center = tileGrid.getTileCoordCenter(tileCoord);\n  const projectionExtent = extentFromProjection(projection);\n  if (!containsCoordinate(projectionExtent, center)) {\n    const worldWidth = getWidth(projectionExtent);\n    const worldsAway = Math.ceil(\n      (projectionExtent[0] - center[0]) / worldWidth\n    );\n    center[0] += worldWidth * worldsAway;\n    return tileGrid.getTileCoordForCoordAndZ(center, z);\n  } else {\n    return tileCoord;\n  }\n}\n\n/**\n * @param {import(\"./extent.js\").Extent} extent Extent.\n * @param {number=} opt_maxZoom Maximum zoom level (default is\n *     DEFAULT_MAX_ZOOM).\n * @param {number|import(\"./size.js\").Size=} opt_tileSize Tile size (default uses\n *     DEFAULT_TILE_SIZE).\n * @param {import(\"./extent/Corner.js\").default=} opt_corner Extent corner (default is `'top-left'`).\n * @return {!TileGrid} TileGrid instance.\n */\nexport function createForExtent(extent, opt_maxZoom, opt_tileSize, opt_corner) {\n  const corner = opt_corner !== undefined ? opt_corner : Corner.TOP_LEFT;\n\n  const resolutions = resolutionsFromExtent(extent, opt_maxZoom, opt_tileSize);\n\n  return new TileGrid({\n    extent: extent,\n    origin: getCorner(extent, corner),\n    resolutions: resolutions,\n    tileSize: opt_tileSize,\n  });\n}\n\n/**\n * @typedef {Object} XYZOptions\n * @property {import(\"./extent.js\").Extent} [extent] Extent for the tile grid. The origin for an XYZ tile grid is the\n * top-left corner of the extent. If `maxResolution` is not provided the zero level of the grid is defined by the resolution\n * at which one tile fits in the provided extent. If not provided, the extent of the EPSG:3857 projection is used.\n * @property {number} [maxResolution] Resolution at level zero.\n * @property {number} [maxZoom] Maximum zoom. The default is `42`. This determines the number of levels\n * in the grid set. For example, a `maxZoom` of 21 means there are 22 levels in the grid set.\n * @property {number} [minZoom=0] Minimum zoom.\n * @property {number|import(\"./size.js\").Size} [tileSize=[256, 256]] Tile size in pixels.\n */\n\n/**\n * Creates a tile grid with a standard XYZ tiling scheme.\n * @param {XYZOptions=} opt_options Tile grid options.\n * @return {!TileGrid} Tile grid instance.\n * @api\n */\nexport function createXYZ(opt_options) {\n  const xyzOptions = opt_options || {};\n\n  const extent = xyzOptions.extent || getProjection('EPSG:3857').getExtent();\n\n  const gridOptions = {\n    extent: extent,\n    minZoom: xyzOptions.minZoom,\n    tileSize: xyzOptions.tileSize,\n    resolutions: resolutionsFromExtent(\n      extent,\n      xyzOptions.maxZoom,\n      xyzOptions.tileSize,\n      xyzOptions.maxResolution\n    ),\n  };\n  return new TileGrid(gridOptions);\n}\n\n/**\n * Create a resolutions array from an extent.  A zoom factor of 2 is assumed.\n * @param {import(\"./extent.js\").Extent} extent Extent.\n * @param {number=} opt_maxZoom Maximum zoom level (default is\n *     DEFAULT_MAX_ZOOM).\n * @param {number|import(\"./size.js\").Size=} opt_tileSize Tile size (default uses\n *     DEFAULT_TILE_SIZE).\n * @param {number=} opt_maxResolution Resolution at level zero.\n * @return {!Array<number>} Resolutions array.\n */\nfunction resolutionsFromExtent(\n  extent,\n  opt_maxZoom,\n  opt_tileSize,\n  opt_maxResolution\n) {\n  const maxZoom = opt_maxZoom !== undefined ? opt_maxZoom : DEFAULT_MAX_ZOOM;\n\n  const height = getHeight(extent);\n  const width = getWidth(extent);\n\n  const tileSize = toSize(\n    opt_tileSize !== undefined ? opt_tileSize : DEFAULT_TILE_SIZE\n  );\n  const maxResolution =\n    opt_maxResolution > 0\n      ? opt_maxResolution\n      : Math.max(width / tileSize[0], height / tileSize[1]);\n\n  const length = maxZoom + 1;\n  const resolutions = new Array(length);\n  for (let z = 0; z < length; ++z) {\n    resolutions[z] = maxResolution / Math.pow(2, z);\n  }\n  return resolutions;\n}\n\n/**\n * @param {import(\"./proj.js\").ProjectionLike} projection Projection.\n * @param {number=} opt_maxZoom Maximum zoom level (default is\n *     DEFAULT_MAX_ZOOM).\n * @param {number|import(\"./size.js\").Size=} opt_tileSize Tile size (default uses\n *     DEFAULT_TILE_SIZE).\n * @param {import(\"./extent/Corner.js\").default=} opt_corner Extent corner (default is `'top-left'`).\n * @return {!TileGrid} TileGrid instance.\n */\nexport function createForProjection(\n  projection,\n  opt_maxZoom,\n  opt_tileSize,\n  opt_corner\n) {\n  const extent = extentFromProjection(projection);\n  return createForExtent(extent, opt_maxZoom, opt_tileSize, opt_corner);\n}\n\n/**\n * Generate a tile grid extent from a projection.  If the projection has an\n * extent, it is used.  If not, a global extent is assumed.\n * @param {import(\"./proj.js\").ProjectionLike} projection Projection.\n * @return {import(\"./extent.js\").Extent} Extent.\n */\nexport function extentFromProjection(projection) {\n  projection = getProjection(projection);\n  let extent = projection.getExtent();\n  if (!extent) {\n    const half =\n      (180 * METERS_PER_UNIT[Units.DEGREES]) / projection.getMetersPerUnit();\n    extent = createOrUpdate(-half, -half, half, half);\n  }\n  return extent;\n}\n","/**\n * @module ol/source/Tile\n */\nimport Event from '../events/Event.js';\nimport Source from './Source.js';\nimport TileCache from '../TileCache.js';\nimport TileState from '../TileState.js';\nimport {abstract} from '../util.js';\nimport {assert} from '../asserts.js';\nimport {equivalent} from '../proj.js';\nimport {getKeyZXY, withinExtentAndZ} from '../tilecoord.js';\nimport {\n  getForProjection as getTileGridForProjection,\n  wrapX,\n} from '../tilegrid.js';\nimport {scale as scaleSize, toSize} from '../size.js';\n\n/**\n * @typedef {Object} Options\n * @property {import(\"./Source.js\").AttributionLike} [attributions]\n * @property {boolean} [attributionsCollapsible=true] Attributions are collapsible.\n * @property {number} [cacheSize]\n * @property {boolean} [opaque=false] Whether the layer is opaque.\n * @property {number} [tilePixelRatio]\n * @property {import(\"../proj.js\").ProjectionLike} [projection]\n * @property {import(\"./State.js\").default} [state]\n * @property {import(\"../tilegrid/TileGrid.js\").default} [tileGrid]\n * @property {boolean} [wrapX=true]\n * @property {number} [transition]\n * @property {string} [key]\n * @property {number} [zDirection=0]\n */\n\n/**\n * @classdesc\n * Abstract base class; normally only used for creating subclasses and not\n * instantiated in apps.\n * Base class for sources providing images divided into a tile grid.\n * @abstract\n * @api\n */\nclass TileSource extends Source {\n  /**\n   * @param {Options} options SourceTile source options.\n   */\n  constructor(options) {\n    super({\n      attributions: options.attributions,\n      attributionsCollapsible: options.attributionsCollapsible,\n      projection: options.projection,\n      state: options.state,\n      wrapX: options.wrapX,\n    });\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.opaque_ = options.opaque !== undefined ? options.opaque : false;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.tilePixelRatio_ =\n      options.tilePixelRatio !== undefined ? options.tilePixelRatio : 1;\n\n    /**\n     * @protected\n     * @type {import(\"../tilegrid/TileGrid.js\").default}\n     */\n    this.tileGrid = options.tileGrid !== undefined ? options.tileGrid : null;\n\n    const tileSize = [256, 256];\n    const tileGrid = options.tileGrid;\n    if (tileGrid) {\n      toSize(tileGrid.getTileSize(tileGrid.getMinZoom()), tileSize);\n    }\n\n    /**\n     * @protected\n     * @type {import(\"../TileCache.js\").default}\n     */\n    this.tileCache = new TileCache(options.cacheSize || 0);\n\n    /**\n     * @protected\n     * @type {import(\"../size.js\").Size}\n     */\n    this.tmpSize = [0, 0];\n\n    /**\n     * @private\n     * @type {string}\n     */\n    this.key_ = options.key || '';\n\n    /**\n     * @protected\n     * @type {import(\"../Tile.js\").Options}\n     */\n    this.tileOptions = {transition: options.transition};\n\n    /**\n     * zDirection hint, read by the renderer. Indicates which resolution should be used\n     * by a renderer if the views resolution does not match any resolution of the tile source.\n     * If 0, the nearest resolution will be used. If 1, the nearest lower resolution\n     * will be used. If -1, the nearest higher resolution will be used.\n     * @type {number}\n     */\n    this.zDirection = options.zDirection ? options.zDirection : 0;\n  }\n\n  /**\n   * @return {boolean} Can expire cache.\n   */\n  canExpireCache() {\n    return this.tileCache.canExpireCache();\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @param {!Object<string, boolean>} usedTiles Used tiles.\n   */\n  expireCache(projection, usedTiles) {\n    const tileCache = this.getTileCacheForProjection(projection);\n    if (tileCache) {\n      tileCache.expireCache(usedTiles);\n    }\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @param {number} z Zoom level.\n   * @param {import(\"../TileRange.js\").default} tileRange Tile range.\n   * @param {function(import(\"../Tile.js\").default):(boolean|void)} callback Called with each\n   *     loaded tile.  If the callback returns `false`, the tile will not be\n   *     considered loaded.\n   * @return {boolean} The tile range is fully covered with loaded tiles.\n   */\n  forEachLoadedTile(projection, z, tileRange, callback) {\n    const tileCache = this.getTileCacheForProjection(projection);\n    if (!tileCache) {\n      return false;\n    }\n\n    let covered = true;\n    let tile, tileCoordKey, loaded;\n    for (let x = tileRange.minX; x <= tileRange.maxX; ++x) {\n      for (let y = tileRange.minY; y <= tileRange.maxY; ++y) {\n        tileCoordKey = getKeyZXY(z, x, y);\n        loaded = false;\n        if (tileCache.containsKey(tileCoordKey)) {\n          tile = /** @type {!import(\"../Tile.js\").default} */ (tileCache.get(\n            tileCoordKey\n          ));\n          loaded = tile.getState() === TileState.LOADED;\n          if (loaded) {\n            loaded = callback(tile) !== false;\n          }\n        }\n        if (!loaded) {\n          covered = false;\n        }\n      }\n    }\n    return covered;\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {number} Gutter.\n   */\n  getGutterForProjection(projection) {\n    return 0;\n  }\n\n  /**\n   * Return the key to be used for all tiles in the source.\n   * @return {string} The key for all tiles.\n   * @protected\n   */\n  getKey() {\n    return this.key_;\n  }\n\n  /**\n   * Set the value to be used as the key for all tiles in the source.\n   * @param {string} key The key for tiles.\n   * @protected\n   */\n  setKey(key) {\n    if (this.key_ !== key) {\n      this.key_ = key;\n      this.changed();\n    }\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {boolean} Opaque.\n   */\n  getOpaque(projection) {\n    return this.opaque_;\n  }\n\n  /**\n   * @return {Array<number>} Resolutions.\n   */\n  getResolutions() {\n    return this.tileGrid.getResolutions();\n  }\n\n  /**\n   * @abstract\n   * @param {number} z Tile coordinate z.\n   * @param {number} x Tile coordinate x.\n   * @param {number} y Tile coordinate y.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {!import(\"../Tile.js\").default} Tile.\n   */\n  getTile(z, x, y, pixelRatio, projection) {\n    return abstract();\n  }\n\n  /**\n   * Return the tile grid of the tile source.\n   * @return {import(\"../tilegrid/TileGrid.js\").default} Tile grid.\n   * @api\n   */\n  getTileGrid() {\n    return this.tileGrid;\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {!import(\"../tilegrid/TileGrid.js\").default} Tile grid.\n   */\n  getTileGridForProjection(projection) {\n    if (!this.tileGrid) {\n      return getTileGridForProjection(projection);\n    } else {\n      return this.tileGrid;\n    }\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {import(\"../TileCache.js\").default} Tile cache.\n   * @protected\n   */\n  getTileCacheForProjection(projection) {\n    assert(\n      equivalent(this.getProjection(), projection),\n      68 // A VectorTile source can only be rendered if it has a projection compatible with the view projection.\n    );\n    return this.tileCache;\n  }\n\n  /**\n   * Get the tile pixel ratio for this source. Subclasses may override this\n   * method, which is meant to return a supported pixel ratio that matches the\n   * provided `pixelRatio` as close as possible.\n   * @param {number} pixelRatio Pixel ratio.\n   * @return {number} Tile pixel ratio.\n   */\n  getTilePixelRatio(pixelRatio) {\n    return this.tilePixelRatio_;\n  }\n\n  /**\n   * @param {number} z Z.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {import(\"../size.js\").Size} Tile size.\n   */\n  getTilePixelSize(z, pixelRatio, projection) {\n    const tileGrid = this.getTileGridForProjection(projection);\n    const tilePixelRatio = this.getTilePixelRatio(pixelRatio);\n    const tileSize = toSize(tileGrid.getTileSize(z), this.tmpSize);\n    if (tilePixelRatio == 1) {\n      return tileSize;\n    } else {\n      return scaleSize(tileSize, tilePixelRatio, this.tmpSize);\n    }\n  }\n\n  /**\n   * Returns a tile coordinate wrapped around the x-axis. When the tile coordinate\n   * is outside the resolution and extent range of the tile grid, `null` will be\n   * returned.\n   * @param {import(\"../tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @param {import(\"../proj/Projection.js\").default=} opt_projection Projection.\n   * @return {import(\"../tilecoord.js\").TileCoord} Tile coordinate to be passed to the tileUrlFunction or\n   *     null if no tile URL should be created for the passed `tileCoord`.\n   */\n  getTileCoordForTileUrlFunction(tileCoord, opt_projection) {\n    const projection =\n      opt_projection !== undefined ? opt_projection : this.getProjection();\n    const tileGrid = this.getTileGridForProjection(projection);\n    if (this.getWrapX() && projection.isGlobal()) {\n      tileCoord = wrapX(tileGrid, tileCoord, projection);\n    }\n    return withinExtentAndZ(tileCoord, tileGrid) ? tileCoord : null;\n  }\n\n  /**\n   * Remove all cached tiles from the source. The next render cycle will fetch new tiles.\n   * @api\n   */\n  clear() {\n    this.tileCache.clear();\n  }\n\n  refresh() {\n    this.clear();\n    super.refresh();\n  }\n\n  /**\n   * Increases the cache size if needed\n   * @param {number} tileCount Minimum number of tiles needed.\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   */\n  updateCacheSize(tileCount, projection) {\n    const tileCache = this.getTileCacheForProjection(projection);\n    if (tileCount > tileCache.highWaterMark) {\n      tileCache.highWaterMark = tileCount;\n    }\n  }\n\n  /**\n   * Marks a tile coord as being used, without triggering a load.\n   * @abstract\n   * @param {number} z Tile coordinate z.\n   * @param {number} x Tile coordinate x.\n   * @param {number} y Tile coordinate y.\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   */\n  useTile(z, x, y, projection) {}\n}\n\n/**\n * @classdesc\n * Events emitted by {@link module:ol/source/Tile~TileSource} instances are instances of this\n * type.\n */\nexport class TileSourceEvent extends Event {\n  /**\n   * @param {string} type Type.\n   * @param {import(\"../Tile.js\").default} tile The tile.\n   */\n  constructor(type, tile) {\n    super(type);\n\n    /**\n     * The tile related to the event.\n     * @type {import(\"../Tile.js\").default}\n     * @api\n     */\n    this.tile = tile;\n  }\n}\n\nexport default TileSource;\n","/**\n * @module ol/tileurlfunction\n */\nimport {assert} from './asserts.js';\nimport {modulo} from './math.js';\nimport {hash as tileCoordHash} from './tilecoord.js';\n\n/**\n * @param {string} template Template.\n * @param {import(\"./tilegrid/TileGrid.js\").default} tileGrid Tile grid.\n * @return {import(\"./Tile.js\").UrlFunction} Tile URL function.\n */\nexport function createFromTemplate(template, tileGrid) {\n  const zRegEx = /\\{z\\}/g;\n  const xRegEx = /\\{x\\}/g;\n  const yRegEx = /\\{y\\}/g;\n  const dashYRegEx = /\\{-y\\}/g;\n  return (\n    /**\n     * @param {import(\"./tilecoord.js\").TileCoord} tileCoord Tile Coordinate.\n     * @param {number} pixelRatio Pixel ratio.\n     * @param {import(\"./proj/Projection.js\").default} projection Projection.\n     * @return {string|undefined} Tile URL.\n     */\n    function (tileCoord, pixelRatio, projection) {\n      if (!tileCoord) {\n        return undefined;\n      } else {\n        return template\n          .replace(zRegEx, tileCoord[0].toString())\n          .replace(xRegEx, tileCoord[1].toString())\n          .replace(yRegEx, tileCoord[2].toString())\n          .replace(dashYRegEx, function () {\n            const z = tileCoord[0];\n            const range = tileGrid.getFullTileRange(z);\n            assert(range, 55); // The {-y} placeholder requires a tile grid with extent\n            const y = range.getHeight() - tileCoord[2] - 1;\n            return y.toString();\n          });\n      }\n    }\n  );\n}\n\n/**\n * @param {Array<string>} templates Templates.\n * @param {import(\"./tilegrid/TileGrid.js\").default} tileGrid Tile grid.\n * @return {import(\"./Tile.js\").UrlFunction} Tile URL function.\n */\nexport function createFromTemplates(templates, tileGrid) {\n  const len = templates.length;\n  const tileUrlFunctions = new Array(len);\n  for (let i = 0; i < len; ++i) {\n    tileUrlFunctions[i] = createFromTemplate(templates[i], tileGrid);\n  }\n  return createFromTileUrlFunctions(tileUrlFunctions);\n}\n\n/**\n * @param {Array<import(\"./Tile.js\").UrlFunction>} tileUrlFunctions Tile URL Functions.\n * @return {import(\"./Tile.js\").UrlFunction} Tile URL function.\n */\nexport function createFromTileUrlFunctions(tileUrlFunctions) {\n  if (tileUrlFunctions.length === 1) {\n    return tileUrlFunctions[0];\n  }\n  return (\n    /**\n     * @param {import(\"./tilecoord.js\").TileCoord} tileCoord Tile Coordinate.\n     * @param {number} pixelRatio Pixel ratio.\n     * @param {import(\"./proj/Projection.js\").default} projection Projection.\n     * @return {string|undefined} Tile URL.\n     */\n    function (tileCoord, pixelRatio, projection) {\n      if (!tileCoord) {\n        return undefined;\n      } else {\n        const h = tileCoordHash(tileCoord);\n        const index = modulo(h, tileUrlFunctions.length);\n        return tileUrlFunctions[index](tileCoord, pixelRatio, projection);\n      }\n    }\n  );\n}\n\n/**\n * @param {import(\"./tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n * @param {number} pixelRatio Pixel ratio.\n * @param {import(\"./proj/Projection.js\").default} projection Projection.\n * @return {string|undefined} Tile URL.\n */\nexport function nullTileUrlFunction(tileCoord, pixelRatio, projection) {\n  return undefined;\n}\n\n/**\n * @param {string} url URL.\n * @return {Array<string>} Array of urls.\n */\nexport function expandUrl(url) {\n  const urls = [];\n  let match = /\\{([a-z])-([a-z])\\}/.exec(url);\n  if (match) {\n    // char range\n    const startCharCode = match[1].charCodeAt(0);\n    const stopCharCode = match[2].charCodeAt(0);\n    let charCode;\n    for (charCode = startCharCode; charCode <= stopCharCode; ++charCode) {\n      urls.push(url.replace(match[0], String.fromCharCode(charCode)));\n    }\n    return urls;\n  }\n  match = /\\{(\\d+)-(\\d+)\\}/.exec(url);\n  if (match) {\n    // number range\n    const stop = parseInt(match[2], 10);\n    for (let i = parseInt(match[1], 10); i <= stop; i++) {\n      urls.push(url.replace(match[0], i.toString()));\n    }\n    return urls;\n  }\n  urls.push(url);\n  return urls;\n}\n","/**\n * @module ol/source/UrlTile\n */\nimport TileEventType from './TileEventType.js';\nimport TileSource, {TileSourceEvent} from './Tile.js';\nimport TileState from '../TileState.js';\nimport {createFromTemplates, expandUrl} from '../tileurlfunction.js';\nimport {getKeyZXY} from '../tilecoord.js';\nimport {getUid} from '../util.js';\n\n/**\n * @typedef {Object} Options\n * @property {import(\"./Source.js\").AttributionLike} [attributions]\n * @property {boolean} [attributionsCollapsible=true] Attributions are collapsible.\n * @property {number} [cacheSize]\n * @property {boolean} [opaque=false] Whether the layer is opaque.\n * @property {import(\"../proj.js\").ProjectionLike} [projection]\n * @property {import(\"./State.js\").default} [state]\n * @property {import(\"../tilegrid/TileGrid.js\").default} [tileGrid]\n * @property {import(\"../Tile.js\").LoadFunction} tileLoadFunction\n * @property {number} [tilePixelRatio]\n * @property {import(\"../Tile.js\").UrlFunction} [tileUrlFunction]\n * @property {string} [url]\n * @property {Array<string>} [urls]\n * @property {boolean} [wrapX=true]\n * @property {number} [transition]\n * @property {string} [key]\n * @property {number} [zDirection=0]\n */\n\n/**\n * @classdesc\n * Base class for sources providing tiles divided into a tile grid over http.\n *\n * @fires import(\"./Tile.js\").TileSourceEvent\n */\nclass UrlTile extends TileSource {\n  /**\n   * @param {Options} options Image tile options.\n   */\n  constructor(options) {\n    super({\n      attributions: options.attributions,\n      cacheSize: options.cacheSize,\n      opaque: options.opaque,\n      projection: options.projection,\n      state: options.state,\n      tileGrid: options.tileGrid,\n      tilePixelRatio: options.tilePixelRatio,\n      wrapX: options.wrapX,\n      transition: options.transition,\n      key: options.key,\n      attributionsCollapsible: options.attributionsCollapsible,\n      zDirection: options.zDirection,\n    });\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.generateTileUrlFunction_ =\n      this.tileUrlFunction === UrlTile.prototype.tileUrlFunction;\n\n    /**\n     * @protected\n     * @type {import(\"../Tile.js\").LoadFunction}\n     */\n    this.tileLoadFunction = options.tileLoadFunction;\n\n    if (options.tileUrlFunction) {\n      this.tileUrlFunction = options.tileUrlFunction;\n    }\n\n    /**\n     * @protected\n     * @type {!Array<string>|null}\n     */\n    this.urls = null;\n\n    if (options.urls) {\n      this.setUrls(options.urls);\n    } else if (options.url) {\n      this.setUrl(options.url);\n    }\n\n    /**\n     * @private\n     * @type {!Object<string, boolean>}\n     */\n    this.tileLoadingKeys_ = {};\n  }\n\n  /**\n   * Return the tile load function of the source.\n   * @return {import(\"../Tile.js\").LoadFunction} TileLoadFunction\n   * @api\n   */\n  getTileLoadFunction() {\n    return this.tileLoadFunction;\n  }\n\n  /**\n   * Return the tile URL function of the source.\n   * @return {import(\"../Tile.js\").UrlFunction} TileUrlFunction\n   * @api\n   */\n  getTileUrlFunction() {\n    return Object.getPrototypeOf(this).tileUrlFunction === this.tileUrlFunction\n      ? this.tileUrlFunction.bind(this)\n      : this.tileUrlFunction;\n  }\n\n  /**\n   * Return the URLs used for this source.\n   * When a tileUrlFunction is used instead of url or urls,\n   * null will be returned.\n   * @return {!Array<string>|null} URLs.\n   * @api\n   */\n  getUrls() {\n    return this.urls;\n  }\n\n  /**\n   * Handle tile change events.\n   * @param {import(\"../events/Event.js\").default} event Event.\n   * @protected\n   */\n  handleTileChange(event) {\n    const tile = /** @type {import(\"../Tile.js\").default} */ (event.target);\n    const uid = getUid(tile);\n    const tileState = tile.getState();\n    let type;\n    if (tileState == TileState.LOADING) {\n      this.tileLoadingKeys_[uid] = true;\n      type = TileEventType.TILELOADSTART;\n    } else if (uid in this.tileLoadingKeys_) {\n      delete this.tileLoadingKeys_[uid];\n      type =\n        tileState == TileState.ERROR\n          ? TileEventType.TILELOADERROR\n          : tileState == TileState.LOADED\n          ? TileEventType.TILELOADEND\n          : undefined;\n    }\n    if (type != undefined) {\n      this.dispatchEvent(new TileSourceEvent(type, tile));\n    }\n  }\n\n  /**\n   * Set the tile load function of the source.\n   * @param {import(\"../Tile.js\").LoadFunction} tileLoadFunction Tile load function.\n   * @api\n   */\n  setTileLoadFunction(tileLoadFunction) {\n    this.tileCache.clear();\n    this.tileLoadFunction = tileLoadFunction;\n    this.changed();\n  }\n\n  /**\n   * Set the tile URL function of the source.\n   * @param {import(\"../Tile.js\").UrlFunction} tileUrlFunction Tile URL function.\n   * @param {string=} key Optional new tile key for the source.\n   * @api\n   */\n  setTileUrlFunction(tileUrlFunction, key) {\n    this.tileUrlFunction = tileUrlFunction;\n    this.tileCache.pruneExceptNewestZ();\n    if (typeof key !== 'undefined') {\n      this.setKey(key);\n    } else {\n      this.changed();\n    }\n  }\n\n  /**\n   * Set the URL to use for requests.\n   * @param {string} url URL.\n   * @api\n   */\n  setUrl(url) {\n    const urls = expandUrl(url);\n    this.urls = urls;\n    this.setUrls(urls);\n  }\n\n  /**\n   * Set the URLs to use for requests.\n   * @param {Array<string>} urls URLs.\n   * @api\n   */\n  setUrls(urls) {\n    this.urls = urls;\n    const key = urls.join('\\n');\n    if (this.generateTileUrlFunction_) {\n      this.setTileUrlFunction(createFromTemplates(urls, this.tileGrid), key);\n    } else {\n      this.setKey(key);\n    }\n  }\n\n  /**\n   * @param {import(\"../tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {string|undefined} Tile URL.\n   */\n  tileUrlFunction(tileCoord, pixelRatio, projection) {\n    return undefined;\n  }\n\n  /**\n   * Marks a tile coord as being used, without triggering a load.\n   * @param {number} z Tile coordinate z.\n   * @param {number} x Tile coordinate x.\n   * @param {number} y Tile coordinate y.\n   */\n  useTile(z, x, y) {\n    const tileCoordKey = getKeyZXY(z, x, y);\n    if (this.tileCache.containsKey(tileCoordKey)) {\n      this.tileCache.get(tileCoordKey);\n    }\n  }\n}\n\nexport default UrlTile;\n","/**\n * @module ol/source/TileImage\n */\nimport EventType from '../events/EventType.js';\nimport ImageTile from '../ImageTile.js';\nimport ReprojTile from '../reproj/Tile.js';\nimport TileCache from '../TileCache.js';\nimport TileState from '../TileState.js';\nimport UrlTile from './UrlTile.js';\nimport {ENABLE_RASTER_REPROJECTION} from '../reproj/common.js';\nimport {IMAGE_SMOOTHING_DISABLED} from './common.js';\nimport {equivalent, get as getProjection} from '../proj.js';\nimport {getKey, getKeyZXY} from '../tilecoord.js';\nimport {getForProjection as getTileGridForProjection} from '../tilegrid.js';\nimport {getUid} from '../util.js';\n\n/**\n * @typedef {Object} Options\n * @property {import(\"./Source.js\").AttributionLike} [attributions] Attributions.\n * @property {boolean} [attributionsCollapsible=true] Attributions are collapsible.\n * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.\n * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that\n * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.\n * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.\n * @property {boolean} [imageSmoothing=true] Enable image smoothing.\n * @property {boolean} [opaque=false] Whether the layer is opaque.\n * @property {import(\"../proj.js\").ProjectionLike} [projection] Projection. Default is the view projection.\n * @property {number} [reprojectionErrorThreshold=0.5] Maximum allowed reprojection error (in pixels).\n * Higher values can increase reprojection performance, but decrease precision.\n * @property {import(\"./State.js\").default} [state] Source state.\n * @property {typeof import(\"../ImageTile.js\").default} [tileClass] Class used to instantiate image tiles.\n * Default is {@link module:ol/ImageTile~ImageTile}.\n * @property {import(\"../tilegrid/TileGrid.js\").default} [tileGrid] Tile grid.\n * @property {import(\"../Tile.js\").LoadFunction} [tileLoadFunction] Optional function to load a tile given a URL. The default is\n * ```js\n * function(imageTile, src) {\n *   imageTile.getImage().src = src;\n * };\n * ```\n * @property {number} [tilePixelRatio=1] The pixel ratio used by the tile service. For example, if the tile\n * service advertizes 256px by 256px tiles but actually sends 512px\n * by 512px images (for retina/hidpi devices) then `tilePixelRatio`\n * should be set to `2`.\n * @property {import(\"../Tile.js\").UrlFunction} [tileUrlFunction] Optional function to get tile URL given a tile coordinate and the projection.\n * @property {string} [url] URL template. Must include `{x}`, `{y}` or `{-y}`, and `{z}` placeholders.\n * A `{?-?}` template pattern, for example `subdomain{a-f}.domain.com`, may be\n * used instead of defining each one separately in the `urls` option.\n * @property {Array<string>} [urls] An array of URL templates.\n * @property {boolean} [wrapX] Whether to wrap the world horizontally. The default, is to\n * request out-of-bounds tiles from the server. When set to `false`, only one\n * world will be rendered. When set to `true`, tiles will be requested for one\n * world only, but they will be wrapped horizontally to render multiple worlds.\n * @property {number} [transition] Duration of the opacity transition for rendering.\n * To disable the opacity transition, pass `transition: 0`.\n * @property {string} [key] Optional tile key for proper cache fetching\n * @property {number} [zDirection=0] Indicate which resolution should be used\n * by a renderer if the view resolution does not match any resolution of the tile source.\n * If 0, the nearest resolution will be used. If 1, the nearest lower resolution\n * will be used. If -1, the nearest higher resolution will be used.\n */\n\n/**\n * @classdesc\n * Base class for sources providing images divided into a tile grid.\n *\n * @fires import(\"./Tile.js\").TileSourceEvent\n * @api\n */\nclass TileImage extends UrlTile {\n  /**\n   * @param {!Options} options Image tile options.\n   */\n  constructor(options) {\n    super({\n      attributions: options.attributions,\n      cacheSize: options.cacheSize,\n      opaque: options.opaque,\n      projection: options.projection,\n      state: options.state,\n      tileGrid: options.tileGrid,\n      tileLoadFunction: options.tileLoadFunction\n        ? options.tileLoadFunction\n        : defaultTileLoadFunction,\n      tilePixelRatio: options.tilePixelRatio,\n      tileUrlFunction: options.tileUrlFunction,\n      url: options.url,\n      urls: options.urls,\n      wrapX: options.wrapX,\n      transition: options.transition,\n      key: options.key,\n      attributionsCollapsible: options.attributionsCollapsible,\n      zDirection: options.zDirection,\n    });\n\n    /**\n     * @protected\n     * @type {?string}\n     */\n    this.crossOrigin =\n      options.crossOrigin !== undefined ? options.crossOrigin : null;\n\n    /**\n     * @protected\n     * @type {typeof ImageTile}\n     */\n    this.tileClass =\n      options.tileClass !== undefined ? options.tileClass : ImageTile;\n\n    /**\n     * @protected\n     * @type {!Object<string, TileCache>}\n     */\n    this.tileCacheForProjection = {};\n\n    /**\n     * @protected\n     * @type {!Object<string, import(\"../tilegrid/TileGrid.js\").default>}\n     */\n    this.tileGridForProjection = {};\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.reprojectionErrorThreshold_ = options.reprojectionErrorThreshold;\n\n    /**\n     * @private\n     * @type {object|undefined}\n     */\n    this.contextOptions_ =\n      options.imageSmoothing === false ? IMAGE_SMOOTHING_DISABLED : undefined;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.renderReprojectionEdges_ = false;\n  }\n\n  /**\n   * @return {boolean} Can expire cache.\n   */\n  canExpireCache() {\n    if (!ENABLE_RASTER_REPROJECTION) {\n      return super.canExpireCache();\n    }\n    if (this.tileCache.canExpireCache()) {\n      return true;\n    } else {\n      for (const key in this.tileCacheForProjection) {\n        if (this.tileCacheForProjection[key].canExpireCache()) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @param {!Object<string, boolean>} usedTiles Used tiles.\n   */\n  expireCache(projection, usedTiles) {\n    if (!ENABLE_RASTER_REPROJECTION) {\n      super.expireCache(projection, usedTiles);\n      return;\n    }\n    const usedTileCache = this.getTileCacheForProjection(projection);\n\n    this.tileCache.expireCache(\n      this.tileCache == usedTileCache ? usedTiles : {}\n    );\n    for (const id in this.tileCacheForProjection) {\n      const tileCache = this.tileCacheForProjection[id];\n      tileCache.expireCache(tileCache == usedTileCache ? usedTiles : {});\n    }\n  }\n\n  /**\n   * @return {Object|undefined} Context options.\n   */\n  getContextOptions() {\n    return this.contextOptions_;\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {number} Gutter.\n   */\n  getGutterForProjection(projection) {\n    if (\n      ENABLE_RASTER_REPROJECTION &&\n      this.getProjection() &&\n      projection &&\n      !equivalent(this.getProjection(), projection)\n    ) {\n      return 0;\n    } else {\n      return this.getGutter();\n    }\n  }\n\n  /**\n   * @return {number} Gutter.\n   */\n  getGutter() {\n    return 0;\n  }\n\n  /**\n   * Return the key to be used for all tiles in the source.\n   * @return {string} The key for all tiles.\n   * @protected\n   */\n  getKey() {\n    return (\n      super.getKey() +\n      (this.contextOptions_ ? '\\n' + JSON.stringify(this.contextOptions_) : '')\n    );\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {boolean} Opaque.\n   */\n  getOpaque(projection) {\n    if (\n      ENABLE_RASTER_REPROJECTION &&\n      this.getProjection() &&\n      projection &&\n      !equivalent(this.getProjection(), projection)\n    ) {\n      return false;\n    } else {\n      return super.getOpaque(projection);\n    }\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {!import(\"../tilegrid/TileGrid.js\").default} Tile grid.\n   */\n  getTileGridForProjection(projection) {\n    if (!ENABLE_RASTER_REPROJECTION) {\n      return super.getTileGridForProjection(projection);\n    }\n    const thisProj = this.getProjection();\n    if (this.tileGrid && (!thisProj || equivalent(thisProj, projection))) {\n      return this.tileGrid;\n    } else {\n      const projKey = getUid(projection);\n      if (!(projKey in this.tileGridForProjection)) {\n        this.tileGridForProjection[projKey] = getTileGridForProjection(\n          projection\n        );\n      }\n      return this.tileGridForProjection[projKey];\n    }\n  }\n\n  /**\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {import(\"../TileCache.js\").default} Tile cache.\n   */\n  getTileCacheForProjection(projection) {\n    if (!ENABLE_RASTER_REPROJECTION) {\n      return super.getTileCacheForProjection(projection);\n    }\n    const thisProj = this.getProjection();\n    if (!thisProj || equivalent(thisProj, projection)) {\n      return this.tileCache;\n    } else {\n      const projKey = getUid(projection);\n      if (!(projKey in this.tileCacheForProjection)) {\n        this.tileCacheForProjection[projKey] = new TileCache(\n          this.tileCache.highWaterMark\n        );\n      }\n      return this.tileCacheForProjection[projKey];\n    }\n  }\n\n  /**\n   * @param {number} z Tile coordinate z.\n   * @param {number} x Tile coordinate x.\n   * @param {number} y Tile coordinate y.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @param {string} key The key set on the tile.\n   * @return {!import(\"../Tile.js\").default} Tile.\n   * @private\n   */\n  createTile_(z, x, y, pixelRatio, projection, key) {\n    const tileCoord = [z, x, y];\n    const urlTileCoord = this.getTileCoordForTileUrlFunction(\n      tileCoord,\n      projection\n    );\n    const tileUrl = urlTileCoord\n      ? this.tileUrlFunction(urlTileCoord, pixelRatio, projection)\n      : undefined;\n    const tile = new this.tileClass(\n      tileCoord,\n      tileUrl !== undefined ? TileState.IDLE : TileState.EMPTY,\n      tileUrl !== undefined ? tileUrl : '',\n      this.crossOrigin,\n      this.tileLoadFunction,\n      this.tileOptions\n    );\n    tile.key = key;\n    tile.addEventListener(EventType.CHANGE, this.handleTileChange.bind(this));\n    return tile;\n  }\n\n  /**\n   * @param {number} z Tile coordinate z.\n   * @param {number} x Tile coordinate x.\n   * @param {number} y Tile coordinate y.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {!import(\"../Tile.js\").default} Tile.\n   */\n  getTile(z, x, y, pixelRatio, projection) {\n    const sourceProjection = this.getProjection();\n    if (\n      !ENABLE_RASTER_REPROJECTION ||\n      !sourceProjection ||\n      !projection ||\n      equivalent(sourceProjection, projection)\n    ) {\n      return this.getTileInternal(\n        z,\n        x,\n        y,\n        pixelRatio,\n        sourceProjection || projection\n      );\n    } else {\n      const cache = this.getTileCacheForProjection(projection);\n      const tileCoord = [z, x, y];\n      let tile;\n      const tileCoordKey = getKey(tileCoord);\n      if (cache.containsKey(tileCoordKey)) {\n        tile = cache.get(tileCoordKey);\n      }\n      const key = this.getKey();\n      if (tile && tile.key == key) {\n        return tile;\n      } else {\n        const sourceTileGrid = this.getTileGridForProjection(sourceProjection);\n        const targetTileGrid = this.getTileGridForProjection(projection);\n        const wrappedTileCoord = this.getTileCoordForTileUrlFunction(\n          tileCoord,\n          projection\n        );\n        const newTile = new ReprojTile(\n          sourceProjection,\n          sourceTileGrid,\n          projection,\n          targetTileGrid,\n          tileCoord,\n          wrappedTileCoord,\n          this.getTilePixelRatio(pixelRatio),\n          this.getGutter(),\n          function (z, x, y, pixelRatio) {\n            return this.getTileInternal(z, x, y, pixelRatio, sourceProjection);\n          }.bind(this),\n          this.reprojectionErrorThreshold_,\n          this.renderReprojectionEdges_,\n          this.contextOptions_\n        );\n        newTile.key = key;\n\n        if (tile) {\n          newTile.interimTile = tile;\n          newTile.refreshInterimChain();\n          cache.replace(tileCoordKey, newTile);\n        } else {\n          cache.set(tileCoordKey, newTile);\n        }\n        return newTile;\n      }\n    }\n  }\n\n  /**\n   * @param {number} z Tile coordinate z.\n   * @param {number} x Tile coordinate x.\n   * @param {number} y Tile coordinate y.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {!import(\"../proj/Projection.js\").default} projection Projection.\n   * @return {!import(\"../Tile.js\").default} Tile.\n   * @protected\n   */\n  getTileInternal(z, x, y, pixelRatio, projection) {\n    let tile = null;\n    const tileCoordKey = getKeyZXY(z, x, y);\n    const key = this.getKey();\n    if (!this.tileCache.containsKey(tileCoordKey)) {\n      tile = this.createTile_(z, x, y, pixelRatio, projection, key);\n      this.tileCache.set(tileCoordKey, tile);\n    } else {\n      tile = this.tileCache.get(tileCoordKey);\n      if (tile.key != key) {\n        // The source's params changed. If the tile has an interim tile and if we\n        // can use it then we use it. Otherwise we create a new tile.  In both\n        // cases we attempt to assign an interim tile to the new tile.\n        const interimTile = tile;\n        tile = this.createTile_(z, x, y, pixelRatio, projection, key);\n\n        //make the new tile the head of the list,\n        if (interimTile.getState() == TileState.IDLE) {\n          //the old tile hasn't begun loading yet, and is now outdated, so we can simply discard it\n          tile.interimTile = interimTile.interimTile;\n        } else {\n          tile.interimTile = interimTile;\n        }\n        tile.refreshInterimChain();\n        this.tileCache.replace(tileCoordKey, tile);\n      }\n    }\n    return tile;\n  }\n\n  /**\n   * Sets whether to render reprojection edges or not (usually for debugging).\n   * @param {boolean} render Render the edges.\n   * @api\n   */\n  setRenderReprojectionEdges(render) {\n    if (\n      !ENABLE_RASTER_REPROJECTION ||\n      this.renderReprojectionEdges_ == render\n    ) {\n      return;\n    }\n    this.renderReprojectionEdges_ = render;\n    for (const id in this.tileCacheForProjection) {\n      this.tileCacheForProjection[id].clear();\n    }\n    this.changed();\n  }\n\n  /**\n   * Sets the tile grid to use when reprojecting the tiles to the given\n   * projection instead of the default tile grid for the projection.\n   *\n   * This can be useful when the default tile grid cannot be created\n   * (e.g. projection has no extent defined) or\n   * for optimization reasons (custom tile size, resolutions, ...).\n   *\n   * @param {import(\"../proj.js\").ProjectionLike} projection Projection.\n   * @param {import(\"../tilegrid/TileGrid.js\").default} tilegrid Tile grid to use for the projection.\n   * @api\n   */\n  setTileGridForProjection(projection, tilegrid) {\n    if (ENABLE_RASTER_REPROJECTION) {\n      const proj = getProjection(projection);\n      if (proj) {\n        const projKey = getUid(proj);\n        if (!(projKey in this.tileGridForProjection)) {\n          this.tileGridForProjection[projKey] = tilegrid;\n        }\n      }\n    }\n  }\n}\n\n/**\n * @param {ImageTile} imageTile Image tile.\n * @param {string} src Source.\n */\nfunction defaultTileLoadFunction(imageTile, src) {\n  /** @type {HTMLImageElement|HTMLVideoElement} */ (imageTile.getImage()).src = src;\n}\n\nexport default TileImage;\n","/**\n * @module ol/source/WMSServerType\n */\n\n/**\n * Available server types: `'carmentaserver'`, `'geoserver'`, `'mapserver'`,\n *     `'qgis'`. These are servers that have vendor parameters beyond the WMS\n *     specification that OpenLayers can make use of.\n * @enum {string}\n */\nexport default {\n  /**\n   * HiDPI support for [Carmenta Server](https://www.carmenta.com/en/products/carmenta-server)\n   * @api\n   */\n  CARMENTA_SERVER: 'carmentaserver',\n  /**\n   * HiDPI support for [GeoServer](https://geoserver.org/)\n   * @api\n   */\n  GEOSERVER: 'geoserver',\n  /**\n   * HiDPI support for [MapServer](https://mapserver.org/)\n   * @api\n   */\n  MAPSERVER: 'mapserver',\n  /**\n   * HiDPI support for [QGIS](https://qgis.org/)\n   * @api\n   */\n  QGIS: 'qgis',\n};\n","/**\n * @module ol/uri\n */\n\n/**\n * Appends query parameters to a URI.\n *\n * @param {string} uri The original URI, which may already have query data.\n * @param {!Object} params An object where keys are URI-encoded parameter keys,\n *     and the values are arbitrary types or arrays.\n * @return {string} The new URI.\n */\nexport function appendParams(uri, params) {\n  const keyParams = [];\n  // Skip any null or undefined parameter values\n  Object.keys(params).forEach(function (k) {\n    if (params[k] !== null && params[k] !== undefined) {\n      keyParams.push(k + '=' + encodeURIComponent(params[k]));\n    }\n  });\n  const qs = keyParams.join('&');\n  // remove any trailing ? or &\n  uri = uri.replace(/[?&]$/, '');\n  // append ? or & depending on whether uri has existing parameters\n  uri = uri.indexOf('?') === -1 ? uri + '?' : uri + '&';\n  return uri + qs;\n}\n","/**\n * @module ol/source/TileWMS\n */\n\nimport {DEFAULT_WMS_VERSION} from './common.js';\n\nimport TileImage from './TileImage.js';\nimport WMSServerType from './WMSServerType.js';\nimport {appendParams} from '../uri.js';\nimport {assert} from '../asserts.js';\nimport {assign} from '../obj.js';\nimport {buffer, createEmpty} from '../extent.js';\nimport {buffer as bufferSize, scale as scaleSize, toSize} from '../size.js';\nimport {calculateSourceResolution} from '../reproj.js';\nimport {compareVersions} from '../string.js';\nimport {get as getProjection, transform, transformExtent} from '../proj.js';\nimport {modulo} from '../math.js';\nimport {hash as tileCoordHash} from '../tilecoord.js';\n\n/**\n * @typedef {Object} Options\n * @property {import(\"./Source.js\").AttributionLike} [attributions] Attributions.\n * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.\n * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that\n * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.\n * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.\n * @property {boolean} [imageSmoothing=true] Enable image smoothing.\n * @property {Object<string,*>} params WMS request parameters.\n * At least a `LAYERS` param is required. `STYLES` is\n * `''` by default. `VERSION` is `1.3.0` by default. `WIDTH`, `HEIGHT`, `BBOX`\n * and `CRS` (`SRS` for WMS version < 1.3.0) will be set dynamically.\n * @property {number} [gutter=0]\n * The size in pixels of the gutter around image tiles to ignore. By setting\n * this property to a non-zero value, images will be requested that are wider\n * and taller than the tile size by a value of `2 x gutter`.\n * Using a non-zero value allows artifacts of rendering at tile edges to be\n * ignored. If you control the WMS service it is recommended to address\n * \"artifacts at tile edges\" issues by properly configuring the WMS service. For\n * example, MapServer has a `tile_map_edge_buffer` configuration parameter for\n * this. See http://mapserver.org/output/tile_mode.html.\n * @property {boolean} [hidpi=true] Use the `ol/Map#pixelRatio` value when requesting\n * the image from the remote server.\n * @property {import(\"../proj.js\").ProjectionLike} [projection] Projection. Default is the view projection.\n * @property {number} [reprojectionErrorThreshold=0.5] Maximum allowed reprojection error (in pixels).\n * Higher values can increase reprojection performance, but decrease precision.\n * @property {typeof import(\"../ImageTile.js\").default} [tileClass] Class used to instantiate image tiles.\n * Default is {@link module:ol/ImageTile~ImageTile}.\n * @property {import(\"../tilegrid/TileGrid.js\").default} [tileGrid] Tile grid. Base this on the resolutions,\n * tilesize and extent supported by the server.\n * If this is not defined, a default grid will be used: if there is a projection\n * extent, the grid will be based on that; if not, a grid based on a global\n * extent with origin at 0,0 will be used..\n * @property {import(\"./WMSServerType.js\").default|string} [serverType]\n * The type of the remote WMS server. Currently only used when `hidpi` is\n * `true`.\n * @property {import(\"../Tile.js\").LoadFunction} [tileLoadFunction] Optional function to load a tile given a URL. The default is\n * ```js\n * function(imageTile, src) {\n *   imageTile.getImage().src = src;\n * };\n * ```\n * @property {string} [url] WMS service URL.\n * @property {Array<string>} [urls] WMS service urls.\n * Use this instead of `url` when the WMS supports multiple urls for GetMap requests.\n * @property {boolean} [wrapX=true] Whether to wrap the world horizontally.\n * When set to `false`, only one world\n * will be rendered. When `true`, tiles will be requested for one world only,\n * but they will be wrapped horizontally to render multiple worlds.\n * @property {number} [transition] Duration of the opacity transition for rendering.\n * To disable the opacity transition, pass `transition: 0`.\n */\n\n/**\n * @classdesc\n * Layer source for tile data from WMS servers.\n * @api\n */\nclass TileWMS extends TileImage {\n  /**\n   * @param {Options=} [opt_options] Tile WMS options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : /** @type {Options} */ ({});\n\n    const params = options.params || {};\n\n    const transparent = 'TRANSPARENT' in params ? params['TRANSPARENT'] : true;\n\n    super({\n      attributions: options.attributions,\n      cacheSize: options.cacheSize,\n      crossOrigin: options.crossOrigin,\n      imageSmoothing: options.imageSmoothing,\n      opaque: !transparent,\n      projection: options.projection,\n      reprojectionErrorThreshold: options.reprojectionErrorThreshold,\n      tileClass: options.tileClass,\n      tileGrid: options.tileGrid,\n      tileLoadFunction: options.tileLoadFunction,\n      url: options.url,\n      urls: options.urls,\n      wrapX: options.wrapX !== undefined ? options.wrapX : true,\n      transition: options.transition,\n    });\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.gutter_ = options.gutter !== undefined ? options.gutter : 0;\n\n    /**\n     * @private\n     * @type {!Object}\n     */\n    this.params_ = params;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.v13_ = true;\n\n    /**\n     * @private\n     * @type {import(\"./WMSServerType.js\").default|undefined}\n     */\n    this.serverType_ = /** @type {import(\"./WMSServerType.js\").default|undefined} */ (options.serverType);\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.hidpi_ = options.hidpi !== undefined ? options.hidpi : true;\n\n    /**\n     * @private\n     * @type {import(\"../extent.js\").Extent}\n     */\n    this.tmpExtent_ = createEmpty();\n\n    this.updateV13_();\n    this.setKey(this.getKeyForParams_());\n  }\n\n  /**\n   * Return the GetFeatureInfo URL for the passed coordinate, resolution, and\n   * projection. Return `undefined` if the GetFeatureInfo URL cannot be\n   * constructed.\n   * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {number} resolution Resolution.\n   * @param {import(\"../proj.js\").ProjectionLike} projection Projection.\n   * @param {!Object} params GetFeatureInfo params. `INFO_FORMAT` at least should\n   *     be provided. If `QUERY_LAYERS` is not provided then the layers specified\n   *     in the `LAYERS` parameter will be used. `VERSION` should not be\n   *     specified here.\n   * @return {string|undefined} GetFeatureInfo URL.\n   * @api\n   */\n  getFeatureInfoUrl(coordinate, resolution, projection, params) {\n    const projectionObj = getProjection(projection);\n    const sourceProjectionObj = this.getProjection();\n\n    let tileGrid = this.getTileGrid();\n    if (!tileGrid) {\n      tileGrid = this.getTileGridForProjection(projectionObj);\n    }\n\n    const z = tileGrid.getZForResolution(resolution, this.zDirection);\n    const tileCoord = tileGrid.getTileCoordForCoordAndZ(coordinate, z);\n\n    if (tileGrid.getResolutions().length <= tileCoord[0]) {\n      return undefined;\n    }\n\n    let tileResolution = tileGrid.getResolution(tileCoord[0]);\n    let tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent_);\n    let tileSize = toSize(tileGrid.getTileSize(tileCoord[0]), this.tmpSize);\n\n    const gutter = this.gutter_;\n    if (gutter !== 0) {\n      tileSize = bufferSize(tileSize, gutter, this.tmpSize);\n      tileExtent = buffer(tileExtent, tileResolution * gutter, tileExtent);\n    }\n\n    if (sourceProjectionObj && sourceProjectionObj !== projectionObj) {\n      tileResolution = calculateSourceResolution(\n        sourceProjectionObj,\n        projectionObj,\n        coordinate,\n        tileResolution\n      );\n      tileExtent = transformExtent(\n        tileExtent,\n        projectionObj,\n        sourceProjectionObj\n      );\n      coordinate = transform(coordinate, projectionObj, sourceProjectionObj);\n    }\n\n    const baseParams = {\n      'SERVICE': 'WMS',\n      'VERSION': DEFAULT_WMS_VERSION,\n      'REQUEST': 'GetFeatureInfo',\n      'FORMAT': 'image/png',\n      'TRANSPARENT': true,\n      'QUERY_LAYERS': this.params_['LAYERS'],\n    };\n    assign(baseParams, this.params_, params);\n\n    const x = Math.floor((coordinate[0] - tileExtent[0]) / tileResolution);\n    const y = Math.floor((tileExtent[3] - coordinate[1]) / tileResolution);\n\n    baseParams[this.v13_ ? 'I' : 'X'] = x;\n    baseParams[this.v13_ ? 'J' : 'Y'] = y;\n\n    return this.getRequestUrl_(\n      tileCoord,\n      tileSize,\n      tileExtent,\n      1,\n      sourceProjectionObj || projectionObj,\n      baseParams\n    );\n  }\n\n  /**\n   * Return the GetLegendGraphic URL, optionally optimized for the passed\n   * resolution and possibly including any passed specific parameters. Returns\n   * `undefined` if the GetLegendGraphic URL cannot be constructed.\n   *\n   * @param {number} [resolution] Resolution. If set to undefined, `SCALE`\n   *     will not be calculated and included in URL.\n   * @param {Object} [params] GetLegendGraphic params. If `LAYER` is set, the\n   *     request is generated for this wms layer, else it will try to use the\n   *     configured wms layer. Default `FORMAT` is `image/png`.\n   *     `VERSION` should not be specified here.\n   * @return {string|undefined} GetLegendGraphic URL.\n   * @api\n   */\n  getLegendUrl(resolution, params) {\n    if (this.urls[0] === undefined) {\n      return undefined;\n    }\n\n    const baseParams = {\n      'SERVICE': 'WMS',\n      'VERSION': DEFAULT_WMS_VERSION,\n      'REQUEST': 'GetLegendGraphic',\n      'FORMAT': 'image/png',\n    };\n\n    if (params === undefined || params['LAYER'] === undefined) {\n      const layers = this.params_.LAYERS;\n      const isSingleLayer = !Array.isArray(layers) || layers.length === 1;\n      if (!isSingleLayer) {\n        return undefined;\n      }\n      baseParams['LAYER'] = layers;\n    }\n\n    if (resolution !== undefined) {\n      const mpu = this.getProjection()\n        ? this.getProjection().getMetersPerUnit()\n        : 1;\n      const pixelSize = 0.00028;\n      baseParams['SCALE'] = (resolution * mpu) / pixelSize;\n    }\n\n    assign(baseParams, params);\n\n    return appendParams(/** @type {string} */ (this.urls[0]), baseParams);\n  }\n\n  /**\n   * @return {number} Gutter.\n   */\n  getGutter() {\n    return this.gutter_;\n  }\n\n  /**\n   * Get the user-provided params, i.e. those passed to the constructor through\n   * the \"params\" option, and possibly updated using the updateParams method.\n   * @return {Object} Params.\n   * @api\n   */\n  getParams() {\n    return this.params_;\n  }\n\n  /**\n   * @param {import(\"../tilecoord.js\").TileCoord} tileCoord Tile coordinate.\n   * @param {import(\"../size.js\").Size} tileSize Tile size.\n   * @param {import(\"../extent.js\").Extent} tileExtent Tile extent.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   * @param {Object} params Params.\n   * @return {string|undefined} Request URL.\n   * @private\n   */\n  getRequestUrl_(\n    tileCoord,\n    tileSize,\n    tileExtent,\n    pixelRatio,\n    projection,\n    params\n  ) {\n    const urls = this.urls;\n    if (!urls) {\n      return undefined;\n    }\n\n    params['WIDTH'] = tileSize[0];\n    params['HEIGHT'] = tileSize[1];\n\n    params[this.v13_ ? 'CRS' : 'SRS'] = projection.getCode();\n\n    if (!('STYLES' in this.params_)) {\n      params['STYLES'] = '';\n    }\n\n    if (pixelRatio != 1) {\n      switch (this.serverType_) {\n        case WMSServerType.GEOSERVER:\n          const dpi = (90 * pixelRatio + 0.5) | 0;\n          if ('FORMAT_OPTIONS' in params) {\n            params['FORMAT_OPTIONS'] += ';dpi:' + dpi;\n          } else {\n            params['FORMAT_OPTIONS'] = 'dpi:' + dpi;\n          }\n          break;\n        case WMSServerType.MAPSERVER:\n          params['MAP_RESOLUTION'] = 90 * pixelRatio;\n          break;\n        case WMSServerType.CARMENTA_SERVER:\n        case WMSServerType.QGIS:\n          params['DPI'] = 90 * pixelRatio;\n          break;\n        default:\n          assert(false, 52); // Unknown `serverType` configured\n          break;\n      }\n    }\n\n    const axisOrientation = projection.getAxisOrientation();\n    const bbox = tileExtent;\n    if (this.v13_ && axisOrientation.substr(0, 2) == 'ne') {\n      let tmp;\n      tmp = tileExtent[0];\n      bbox[0] = tileExtent[1];\n      bbox[1] = tmp;\n      tmp = tileExtent[2];\n      bbox[2] = tileExtent[3];\n      bbox[3] = tmp;\n    }\n    params['BBOX'] = bbox.join(',');\n\n    let url;\n    if (urls.length == 1) {\n      url = urls[0];\n    } else {\n      const index = modulo(tileCoordHash(tileCoord), urls.length);\n      url = urls[index];\n    }\n    return appendParams(url, params);\n  }\n\n  /**\n   * Get the tile pixel ratio for this source.\n   * @param {number} pixelRatio Pixel ratio.\n   * @return {number} Tile pixel ratio.\n   */\n  getTilePixelRatio(pixelRatio) {\n    return !this.hidpi_ || this.serverType_ === undefined ? 1 : pixelRatio;\n  }\n\n  /**\n   * @private\n   * @return {string} The key for the current params.\n   */\n  getKeyForParams_() {\n    let i = 0;\n    const res = [];\n    for (const key in this.params_) {\n      res[i++] = key + '-' + this.params_[key];\n    }\n    return res.join('/');\n  }\n\n  /**\n   * Update the user-provided params.\n   * @param {Object} params Params.\n   * @api\n   */\n  updateParams(params) {\n    assign(this.params_, params);\n    this.updateV13_();\n    this.setKey(this.getKeyForParams_());\n  }\n\n  /**\n   * @private\n   */\n  updateV13_() {\n    const version = this.params_['VERSION'] || DEFAULT_WMS_VERSION;\n    this.v13_ = compareVersions(version, '1.3') >= 0;\n  }\n\n  /**\n   * @param {import(\"../tilecoord.js\").TileCoord} tileCoord The tile coordinate\n   * @param {number} pixelRatio The pixel ratio\n   * @param {import(\"../proj/Projection.js\").default} projection The projection\n   * @return {string|undefined} The tile URL\n   * @override\n   */\n  tileUrlFunction(tileCoord, pixelRatio, projection) {\n    let tileGrid = this.getTileGrid();\n    if (!tileGrid) {\n      tileGrid = this.getTileGridForProjection(projection);\n    }\n\n    if (tileGrid.getResolutions().length <= tileCoord[0]) {\n      return undefined;\n    }\n\n    if (pixelRatio != 1 && (!this.hidpi_ || this.serverType_ === undefined)) {\n      pixelRatio = 1;\n    }\n\n    const tileResolution = tileGrid.getResolution(tileCoord[0]);\n    let tileExtent = tileGrid.getTileCoordExtent(tileCoord, this.tmpExtent_);\n    let tileSize = toSize(tileGrid.getTileSize(tileCoord[0]), this.tmpSize);\n\n    const gutter = this.gutter_;\n    if (gutter !== 0) {\n      tileSize = bufferSize(tileSize, gutter, this.tmpSize);\n      tileExtent = buffer(tileExtent, tileResolution * gutter, tileExtent);\n    }\n\n    if (pixelRatio != 1) {\n      tileSize = scaleSize(tileSize, pixelRatio, this.tmpSize);\n    }\n\n    const baseParams = {\n      'SERVICE': 'WMS',\n      'VERSION': DEFAULT_WMS_VERSION,\n      'REQUEST': 'GetMap',\n      'FORMAT': 'image/png',\n      'TRANSPARENT': true,\n    };\n    assign(baseParams, this.params_);\n\n    return this.getRequestUrl_(\n      tileCoord,\n      tileSize,\n      tileExtent,\n      pixelRatio,\n      projection,\n      baseParams\n    );\n  }\n}\n\nexport default TileWMS;\n","/**\n * @module ol/string\n */\n\n/**\n * @param {number} number Number to be formatted\n * @param {number} width The desired width\n * @param {number=} opt_precision Precision of the output string (i.e. number of decimal places)\n * @returns {string} Formatted string\n */\nexport function padNumber(number, width, opt_precision) {\n  const numberString =\n    opt_precision !== undefined ? number.toFixed(opt_precision) : '' + number;\n  let decimal = numberString.indexOf('.');\n  decimal = decimal === -1 ? numberString.length : decimal;\n  return decimal > width\n    ? numberString\n    : new Array(1 + width - decimal).join('0') + numberString;\n}\n\n/**\n * Adapted from https://github.com/omichelsen/compare-versions/blob/master/index.js\n * @param {string|number} v1 First version\n * @param {string|number} v2 Second version\n * @returns {number} Value\n */\nexport function compareVersions(v1, v2) {\n  const s1 = ('' + v1).split('.');\n  const s2 = ('' + v2).split('.');\n\n  for (let i = 0; i < Math.max(s1.length, s2.length); i++) {\n    const n1 = parseInt(s1[i] || '0', 10);\n    const n2 = parseInt(s2[i] || '0', 10);\n\n    if (n1 > n2) {\n      return 1;\n    }\n    if (n2 > n1) {\n      return -1;\n    }\n  }\n\n  return 0;\n}\n","!function(t,i){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=i():\"function\"==typeof define&&define.amd?define(i):(t=t||self).RBush=i()}(this,function(){\"use strict\";function t(t,r,e,a,h){!function t(n,r,e,a,h){for(;a>e;){if(a-e>600){var o=a-e+1,s=r-e+1,l=Math.log(o),f=.5*Math.exp(2*l/3),u=.5*Math.sqrt(l*f*(o-f)/o)*(s-o/2<0?-1:1),m=Math.max(e,Math.floor(r-s*f/o+u)),c=Math.min(a,Math.floor(r+(o-s)*f/o+u));t(n,r,m,c,h)}var p=n[r],d=e,x=a;for(i(n,e,r),h(n[a],p)>0&&i(n,e,a);d<x;){for(i(n,d,x),d++,x--;h(n[d],p)<0;)d++;for(;h(n[x],p)>0;)x--}0===h(n[e],p)?i(n,e,x):i(n,++x,a),x<=r&&(e=x+1),r<=x&&(a=x-1)}}(t,r,e||0,a||t.length-1,h||n)}function i(t,i,n){var r=t[i];t[i]=t[n],t[n]=r}function n(t,i){return t<i?-1:t>i?1:0}var r=function(t){void 0===t&&(t=9),this._maxEntries=Math.max(4,t),this._minEntries=Math.max(2,Math.ceil(.4*this._maxEntries)),this.clear()};function e(t,i,n){if(!n)return i.indexOf(t);for(var r=0;r<i.length;r++)if(n(t,i[r]))return r;return-1}function a(t,i){h(t,0,t.children.length,i,t)}function h(t,i,n,r,e){e||(e=p(null)),e.minX=1/0,e.minY=1/0,e.maxX=-1/0,e.maxY=-1/0;for(var a=i;a<n;a++){var h=t.children[a];o(e,t.leaf?r(h):h)}return e}function o(t,i){return t.minX=Math.min(t.minX,i.minX),t.minY=Math.min(t.minY,i.minY),t.maxX=Math.max(t.maxX,i.maxX),t.maxY=Math.max(t.maxY,i.maxY),t}function s(t,i){return t.minX-i.minX}function l(t,i){return t.minY-i.minY}function f(t){return(t.maxX-t.minX)*(t.maxY-t.minY)}function u(t){return t.maxX-t.minX+(t.maxY-t.minY)}function m(t,i){return t.minX<=i.minX&&t.minY<=i.minY&&i.maxX<=t.maxX&&i.maxY<=t.maxY}function c(t,i){return i.minX<=t.maxX&&i.minY<=t.maxY&&i.maxX>=t.minX&&i.maxY>=t.minY}function p(t){return{children:t,height:1,leaf:!0,minX:1/0,minY:1/0,maxX:-1/0,maxY:-1/0}}function d(i,n,r,e,a){for(var h=[n,r];h.length;)if(!((r=h.pop())-(n=h.pop())<=e)){var o=n+Math.ceil((r-n)/e/2)*e;t(i,o,n,r,a),h.push(n,o,o,r)}}return r.prototype.all=function(){return this._all(this.data,[])},r.prototype.search=function(t){var i=this.data,n=[];if(!c(t,i))return n;for(var r=this.toBBox,e=[];i;){for(var a=0;a<i.children.length;a++){var h=i.children[a],o=i.leaf?r(h):h;c(t,o)&&(i.leaf?n.push(h):m(t,o)?this._all(h,n):e.push(h))}i=e.pop()}return n},r.prototype.collides=function(t){var i=this.data;if(!c(t,i))return!1;for(var n=[];i;){for(var r=0;r<i.children.length;r++){var e=i.children[r],a=i.leaf?this.toBBox(e):e;if(c(t,a)){if(i.leaf||m(t,a))return!0;n.push(e)}}i=n.pop()}return!1},r.prototype.load=function(t){if(!t||!t.length)return this;if(t.length<this._minEntries){for(var i=0;i<t.length;i++)this.insert(t[i]);return this}var n=this._build(t.slice(),0,t.length-1,0);if(this.data.children.length)if(this.data.height===n.height)this._splitRoot(this.data,n);else{if(this.data.height<n.height){var r=this.data;this.data=n,n=r}this._insert(n,this.data.height-n.height-1,!0)}else this.data=n;return this},r.prototype.insert=function(t){return t&&this._insert(t,this.data.height-1),this},r.prototype.clear=function(){return this.data=p([]),this},r.prototype.remove=function(t,i){if(!t)return this;for(var n,r,a,h=this.data,o=this.toBBox(t),s=[],l=[];h||s.length;){if(h||(h=s.pop(),r=s[s.length-1],n=l.pop(),a=!0),h.leaf){var f=e(t,h.children,i);if(-1!==f)return h.children.splice(f,1),s.push(h),this._condense(s),this}a||h.leaf||!m(h,o)?r?(n++,h=r.children[n],a=!1):h=null:(s.push(h),l.push(n),n=0,r=h,h=h.children[0])}return this},r.prototype.toBBox=function(t){return t},r.prototype.compareMinX=function(t,i){return t.minX-i.minX},r.prototype.compareMinY=function(t,i){return t.minY-i.minY},r.prototype.toJSON=function(){return this.data},r.prototype.fromJSON=function(t){return this.data=t,this},r.prototype._all=function(t,i){for(var n=[];t;)t.leaf?i.push.apply(i,t.children):n.push.apply(n,t.children),t=n.pop();return i},r.prototype._build=function(t,i,n,r){var e,h=n-i+1,o=this._maxEntries;if(h<=o)return a(e=p(t.slice(i,n+1)),this.toBBox),e;r||(r=Math.ceil(Math.log(h)/Math.log(o)),o=Math.ceil(h/Math.pow(o,r-1))),(e=p([])).leaf=!1,e.height=r;var s=Math.ceil(h/o),l=s*Math.ceil(Math.sqrt(o));d(t,i,n,l,this.compareMinX);for(var f=i;f<=n;f+=l){var u=Math.min(f+l-1,n);d(t,f,u,s,this.compareMinY);for(var m=f;m<=u;m+=s){var c=Math.min(m+s-1,u);e.children.push(this._build(t,m,c,r-1))}}return a(e,this.toBBox),e},r.prototype._chooseSubtree=function(t,i,n,r){for(;r.push(i),!i.leaf&&r.length-1!==n;){for(var e=1/0,a=1/0,h=void 0,o=0;o<i.children.length;o++){var s=i.children[o],l=f(s),u=(m=t,c=s,(Math.max(c.maxX,m.maxX)-Math.min(c.minX,m.minX))*(Math.max(c.maxY,m.maxY)-Math.min(c.minY,m.minY))-l);u<a?(a=u,e=l<e?l:e,h=s):u===a&&l<e&&(e=l,h=s)}i=h||i.children[0]}var m,c;return i},r.prototype._insert=function(t,i,n){var r=n?t:this.toBBox(t),e=[],a=this._chooseSubtree(r,this.data,i,e);for(a.children.push(t),o(a,r);i>=0&&e[i].children.length>this._maxEntries;)this._split(e,i),i--;this._adjustParentBBoxes(r,e,i)},r.prototype._split=function(t,i){var n=t[i],r=n.children.length,e=this._minEntries;this._chooseSplitAxis(n,e,r);var h=this._chooseSplitIndex(n,e,r),o=p(n.children.splice(h,n.children.length-h));o.height=n.height,o.leaf=n.leaf,a(n,this.toBBox),a(o,this.toBBox),i?t[i-1].children.push(o):this._splitRoot(n,o)},r.prototype._splitRoot=function(t,i){this.data=p([t,i]),this.data.height=t.height+1,this.data.leaf=!1,a(this.data,this.toBBox)},r.prototype._chooseSplitIndex=function(t,i,n){for(var r,e,a,o,s,l,u,m=1/0,c=1/0,p=i;p<=n-i;p++){var d=h(t,0,p,this.toBBox),x=h(t,p,n,this.toBBox),v=(e=d,a=x,o=void 0,s=void 0,l=void 0,u=void 0,o=Math.max(e.minX,a.minX),s=Math.max(e.minY,a.minY),l=Math.min(e.maxX,a.maxX),u=Math.min(e.maxY,a.maxY),Math.max(0,l-o)*Math.max(0,u-s)),M=f(d)+f(x);v<m?(m=v,r=p,c=M<c?M:c):v===m&&M<c&&(c=M,r=p)}return r||n-i},r.prototype._chooseSplitAxis=function(t,i,n){var r=t.leaf?this.compareMinX:s,e=t.leaf?this.compareMinY:l;this._allDistMargin(t,i,n,r)<this._allDistMargin(t,i,n,e)&&t.children.sort(r)},r.prototype._allDistMargin=function(t,i,n,r){t.children.sort(r);for(var e=this.toBBox,a=h(t,0,i,e),s=h(t,n-i,n,e),l=u(a)+u(s),f=i;f<n-i;f++){var m=t.children[f];o(a,t.leaf?e(m):m),l+=u(a)}for(var c=n-i-1;c>=i;c--){var p=t.children[c];o(s,t.leaf?e(p):p),l+=u(s)}return l},r.prototype._adjustParentBBoxes=function(t,i,n){for(var r=n;r>=0;r--)o(i[r],t)},r.prototype._condense=function(t){for(var i=t.length-1,n=void 0;i>=0;i--)0===t[i].children.length?i>0?(n=t[i-1].children).splice(n.indexOf(t[i]),1):this.clear():a(t[i],this.toBBox)},r});\n","/**\n * @module ol/layer/BaseVector\n */\nimport Layer from './Layer.js';\nimport RBush from 'rbush';\nimport {assign} from '../obj.js';\nimport {\n  createDefaultStyle,\n  toFunction as toStyleFunction,\n} from '../style/Style.js';\n\n/**\n * @typedef {Object} Options\n * @property {string} [className='ol-layer'] A CSS class name to set to the layer element.\n * @property {number} [opacity=1] Opacity (0, 1).\n * @property {boolean} [visible=true] Visibility.\n * @property {import(\"../extent.js\").Extent} [extent] The bounding extent for layer rendering.  The layer will not be\n * rendered outside of this extent.\n * @property {number} [zIndex] The z-index for layer rendering.  At rendering time, the layers\n * will be ordered, first by Z-index and then by position. When `undefined`, a `zIndex` of 0 is assumed\n * for layers that are added to the map's `layers` collection, or `Infinity` when the layer's `setMap()`\n * method was used.\n * @property {number} [minResolution] The minimum resolution (inclusive) at which this layer will be\n * visible.\n * @property {number} [maxResolution] The maximum resolution (exclusive) below which this layer will\n * be visible.\n * @property {number} [minZoom] The minimum view zoom level (exclusive) above which this layer will be\n * visible.\n * @property {number} [maxZoom] The maximum view zoom level (inclusive) at which this layer will\n * be visible.\n * @property {import(\"../render.js\").OrderFunction} [renderOrder] Render order. Function to be used when sorting\n * features before rendering. By default features are drawn in the order that they are created. Use\n * `null` to avoid the sort, but get an undefined draw order.\n * @property {number} [renderBuffer=100] The buffer in pixels around the viewport extent used by the\n * renderer when getting features from the vector source for the rendering or hit-detection.\n * Recommended value: the size of the largest symbol, line width or label.\n * @property {import(\"../source/Vector.js\").default} [source] Source.\n * @property {import(\"../PluggableMap.js\").default} [map] Sets the layer as overlay on a map. The map will not manage\n * this layer in its layers collection, and the layer will be rendered on top. This is useful for\n * temporary layers. The standard way to add a layer to a map and have it managed by the map is to\n * use {@link module:ol/Map#addLayer}.\n * @property {boolean} [declutter=false] Declutter images and text. Decluttering is applied to all\n * image and text styles of all Vector and VectorTile layers that have set this to `true`. The priority\n * is defined by the z-index of the layer, the `zIndex` of the style and the render order of features.\n * Higher z-index means higher priority. Within the same z-index, a feature rendered before another has\n * higher priority.\n * @property {import(\"../style/Style.js\").StyleLike|null} [style] Layer style. When set to `null`, only\n * features that have their own style will be rendered. See {@link module:ol/style} for default style\n * which will be used if this is not set.\n * @property {boolean} [updateWhileAnimating=false] When set to `true`, feature batches will\n * be recreated during animations. This means that no vectors will be shown clipped, but the\n * setting will have a performance impact for large amounts of vector data. When set to `false`,\n * batches will be recreated when no animation is active.\n * @property {boolean} [updateWhileInteracting=false] When set to `true`, feature batches will\n * be recreated during interactions. See also `updateWhileAnimating`.\n */\n\n/**\n * @enum {string}\n * @private\n */\nconst Property = {\n  RENDER_ORDER: 'renderOrder',\n};\n\n/**\n * @classdesc\n * Vector data that is rendered client-side.\n * Note that any property set in the options is set as a {@link module:ol/Object~BaseObject}\n * property on the layer object; for example, setting `title: 'My Title'` in the\n * options means that `title` is observable, and has get/set accessors.\n *\n * @template {import(\"../source/Vector.js\").default|import(\"../source/VectorTile.js\").default} VectorSourceType\n * @extends {Layer<VectorSourceType>}\n * @api\n */\nclass BaseVectorLayer extends Layer {\n  /**\n   * @param {Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    const options = opt_options ? opt_options : {};\n\n    const baseOptions = assign({}, options);\n\n    delete baseOptions.style;\n    delete baseOptions.renderBuffer;\n    delete baseOptions.updateWhileAnimating;\n    delete baseOptions.updateWhileInteracting;\n    super(baseOptions);\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.declutter_ =\n      options.declutter !== undefined ? options.declutter : false;\n\n    /**\n     * @type {number}\n     * @private\n     */\n    this.renderBuffer_ =\n      options.renderBuffer !== undefined ? options.renderBuffer : 100;\n\n    /**\n     * User provided style.\n     * @type {import(\"../style/Style.js\").StyleLike}\n     * @private\n     */\n    this.style_ = null;\n\n    /**\n     * Style function for use within the library.\n     * @type {import(\"../style/Style.js\").StyleFunction|undefined}\n     * @private\n     */\n    this.styleFunction_ = undefined;\n\n    this.setStyle(options.style);\n\n    /**\n     * @type {boolean}\n     * @private\n     */\n    this.updateWhileAnimating_ =\n      options.updateWhileAnimating !== undefined\n        ? options.updateWhileAnimating\n        : false;\n\n    /**\n     * @type {boolean}\n     * @private\n     */\n    this.updateWhileInteracting_ =\n      options.updateWhileInteracting !== undefined\n        ? options.updateWhileInteracting\n        : false;\n  }\n\n  /**\n   * @return {boolean} Declutter.\n   */\n  getDeclutter() {\n    return this.declutter_;\n  }\n\n  /**\n   * Get the topmost feature that intersects the given pixel on the viewport. Returns a promise\n   * that resolves with an array of features. The array will either contain the topmost feature\n   * when a hit was detected, or it will be empty.\n   *\n   * The hit detection algorithm used for this method is optimized for performance, but is less\n   * accurate than the one used in {@link import(\"../PluggableMap.js\").default#getFeaturesAtPixel}: Text\n   * is not considered, and icons are only represented by their bounding box instead of the exact\n   * image.\n   *\n   * @param {import(\"../pixel.js\").Pixel} pixel Pixel.\n   * @return {Promise<Array<import(\"../Feature\").default>>} Promise that resolves with an array of features.\n   * @api\n   */\n  getFeatures(pixel) {\n    return super.getFeatures(pixel);\n  }\n\n  /**\n   * @return {number|undefined} Render buffer.\n   */\n  getRenderBuffer() {\n    return this.renderBuffer_;\n  }\n\n  /**\n   * @return {function(import(\"../Feature.js\").default, import(\"../Feature.js\").default): number|null|undefined} Render\n   *     order.\n   */\n  getRenderOrder() {\n    return /** @type {import(\"../render.js\").OrderFunction|null|undefined} */ (this.get(\n      Property.RENDER_ORDER\n    ));\n  }\n\n  /**\n   * Get the style for features.  This returns whatever was passed to the `style`\n   * option at construction or to the `setStyle` method.\n   * @return {import(\"../style/Style.js\").StyleLike|null|undefined} Layer style.\n   * @api\n   */\n  getStyle() {\n    return this.style_;\n  }\n\n  /**\n   * Get the style function.\n   * @return {import(\"../style/Style.js\").StyleFunction|undefined} Layer style function.\n   * @api\n   */\n  getStyleFunction() {\n    return this.styleFunction_;\n  }\n\n  /**\n   * @return {boolean} Whether the rendered layer should be updated while\n   *     animating.\n   */\n  getUpdateWhileAnimating() {\n    return this.updateWhileAnimating_;\n  }\n\n  /**\n   * @return {boolean} Whether the rendered layer should be updated while\n   *     interacting.\n   */\n  getUpdateWhileInteracting() {\n    return this.updateWhileInteracting_;\n  }\n\n  /**\n   * Render declutter items for this layer\n   * @param {import(\"../PluggableMap.js\").FrameState} frameState Frame state.\n   */\n  renderDeclutter(frameState) {\n    if (!frameState.declutterTree) {\n      frameState.declutterTree = new RBush(9);\n    }\n    /** @type {*} */ (this.getRenderer()).renderDeclutter(frameState);\n  }\n\n  /**\n   * @param {import(\"../render.js\").OrderFunction|null|undefined} renderOrder\n   *     Render order.\n   */\n  setRenderOrder(renderOrder) {\n    this.set(Property.RENDER_ORDER, renderOrder);\n  }\n\n  /**\n   * Set the style for features.  This can be a single style object, an array\n   * of styles, or a function that takes a feature and resolution and returns\n   * an array of styles. If set to `null`, the layer has no style (a `null` style),\n   * so only features that have their own styles will be rendered in the layer. Call\n   * `setStyle()` without arguments to reset to the default style. See\n   * {@link module:ol/style} for information on the default style.\n   * @param {(import(\"../style/Style.js\").StyleLike|null)=} opt_style Layer style.\n   * @api\n   */\n  setStyle(opt_style) {\n    this.style_ = opt_style !== undefined ? opt_style : createDefaultStyle;\n    this.styleFunction_ =\n      opt_style === null ? undefined : toStyleFunction(this.style_);\n    this.changed();\n  }\n}\n\nexport default BaseVectorLayer;\n","/**\n * @module ol/render/canvas/Instruction\n */\n\n/**\n * @enum {number}\n */\nconst Instruction = {\n  BEGIN_GEOMETRY: 0,\n  BEGIN_PATH: 1,\n  CIRCLE: 2,\n  CLOSE_PATH: 3,\n  CUSTOM: 4,\n  DRAW_CHARS: 5,\n  DRAW_IMAGE: 6,\n  END_GEOMETRY: 7,\n  FILL: 8,\n  MOVE_TO_LINE_TO: 9,\n  SET_FILL_STYLE: 10,\n  SET_STROKE_STYLE: 11,\n  STROKE: 12,\n};\n\n/**\n * @type {Array<Instruction>}\n */\nexport const fillInstruction = [Instruction.FILL];\n\n/**\n * @type {Array<Instruction>}\n */\nexport const strokeInstruction = [Instruction.STROKE];\n\n/**\n * @type {Array<Instruction>}\n */\nexport const beginPathInstruction = [Instruction.BEGIN_PATH];\n\n/**\n * @type {Array<Instruction>}\n */\nexport const closePathInstruction = [Instruction.CLOSE_PATH];\n\nexport default Instruction;\n","/**\n * @module ol/render/VectorContext\n */\n\n/**\n * @classdesc\n * Context for drawing geometries.  A vector context is available on render\n * events and does not need to be constructed directly.\n * @api\n */\nclass VectorContext {\n  /**\n   * Render a geometry with a custom renderer.\n   *\n   * @param {import(\"../geom/SimpleGeometry.js\").default} geometry Geometry.\n   * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n   * @param {Function} renderer Renderer.\n   */\n  drawCustom(geometry, feature, renderer) {}\n\n  /**\n   * Render a geometry.\n   *\n   * @param {import(\"../geom/Geometry.js\").default} geometry The geometry to render.\n   */\n  drawGeometry(geometry) {}\n\n  /**\n   * Set the rendering style.\n   *\n   * @param {import(\"../style/Style.js\").default} style The rendering style.\n   */\n  setStyle(style) {}\n\n  /**\n   * @param {import(\"../geom/Circle.js\").default} circleGeometry Circle geometry.\n   * @param {import(\"../Feature.js\").default} feature Feature.\n   */\n  drawCircle(circleGeometry, feature) {}\n\n  /**\n   * @param {import(\"../Feature.js\").default} feature Feature.\n   * @param {import(\"../style/Style.js\").default} style Style.\n   */\n  drawFeature(feature, style) {}\n\n  /**\n   * @param {import(\"../geom/GeometryCollection.js\").default} geometryCollectionGeometry Geometry collection.\n   * @param {import(\"../Feature.js\").default} feature Feature.\n   */\n  drawGeometryCollection(geometryCollectionGeometry, feature) {}\n\n  /**\n   * @param {import(\"../geom/LineString.js\").default|import(\"./Feature.js\").default} lineStringGeometry Line string geometry.\n   * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawLineString(lineStringGeometry, feature) {}\n\n  /**\n   * @param {import(\"../geom/MultiLineString.js\").default|import(\"./Feature.js\").default} multiLineStringGeometry MultiLineString geometry.\n   * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawMultiLineString(multiLineStringGeometry, feature) {}\n\n  /**\n   * @param {import(\"../geom/MultiPoint.js\").default|import(\"./Feature.js\").default} multiPointGeometry MultiPoint geometry.\n   * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawMultiPoint(multiPointGeometry, feature) {}\n\n  /**\n   * @param {import(\"../geom/MultiPolygon.js\").default} multiPolygonGeometry MultiPolygon geometry.\n   * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawMultiPolygon(multiPolygonGeometry, feature) {}\n\n  /**\n   * @param {import(\"../geom/Point.js\").default|import(\"./Feature.js\").default} pointGeometry Point geometry.\n   * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawPoint(pointGeometry, feature) {}\n\n  /**\n   * @param {import(\"../geom/Polygon.js\").default|import(\"./Feature.js\").default} polygonGeometry Polygon geometry.\n   * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawPolygon(polygonGeometry, feature) {}\n\n  /**\n   * @param {import(\"../geom/SimpleGeometry.js\").default|import(\"./Feature.js\").default} geometry Geometry.\n   * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawText(geometry, feature) {}\n\n  /**\n   * @param {import(\"../style/Fill.js\").default} fillStyle Fill style.\n   * @param {import(\"../style/Stroke.js\").default} strokeStyle Stroke style.\n   */\n  setFillStrokeStyle(fillStyle, strokeStyle) {}\n\n  /**\n   * @param {import(\"../style/Image.js\").default} imageStyle Image style.\n   * @param {import(\"../render/canvas.js\").DeclutterImageWithText=} opt_declutterImageWithText Shared data for combined decluttering with a text style.\n   */\n  setImageStyle(imageStyle, opt_declutterImageWithText) {}\n\n  /**\n   * @param {import(\"../style/Text.js\").default} textStyle Text style.\n   * @param {import(\"../render/canvas.js\").DeclutterImageWithText=} opt_declutterImageWithText Shared data for combined decluttering with an image style.\n   */\n  setTextStyle(textStyle, opt_declutterImageWithText) {}\n}\n\nexport default VectorContext;\n","/**\n * @module ol/render/canvas/Builder\n */\nimport CanvasInstruction from './Instruction.js';\nimport GeometryType from '../../geom/GeometryType.js';\nimport Relationship from '../../extent/Relationship.js';\nimport VectorContext from '../VectorContext.js';\nimport {asColorLike} from '../../colorlike.js';\nimport {\n  buffer,\n  clone,\n  containsCoordinate,\n  coordinateRelationship,\n} from '../../extent.js';\nimport {\n  defaultFillStyle,\n  defaultLineCap,\n  defaultLineDash,\n  defaultLineDashOffset,\n  defaultLineJoin,\n  defaultLineWidth,\n  defaultMiterLimit,\n  defaultStrokeStyle,\n} from '../canvas.js';\nimport {equals, reverseSubArray} from '../../array.js';\nimport {\n  inflateCoordinates,\n  inflateCoordinatesArray,\n  inflateMultiCoordinatesArray,\n} from '../../geom/flat/inflate.js';\n\nclass CanvasBuilder extends VectorContext {\n  /**\n   * @param {number} tolerance Tolerance.\n   * @param {import(\"../../extent.js\").Extent} maxExtent Maximum extent.\n   * @param {number} resolution Resolution.\n   * @param {number} pixelRatio Pixel ratio.\n   */\n  constructor(tolerance, maxExtent, resolution, pixelRatio) {\n    super();\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.tolerance = tolerance;\n\n    /**\n     * @protected\n     * @const\n     * @type {import(\"../../extent.js\").Extent}\n     */\n    this.maxExtent = maxExtent;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.pixelRatio = pixelRatio;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.maxLineWidth = 0;\n\n    /**\n     * @protected\n     * @const\n     * @type {number}\n     */\n    this.resolution = resolution;\n\n    /**\n     * @private\n     * @type {Array<*>}\n     */\n    this.beginGeometryInstruction1_ = null;\n\n    /**\n     * @private\n     * @type {Array<*>}\n     */\n    this.beginGeometryInstruction2_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../../extent.js\").Extent}\n     */\n    this.bufferedMaxExtent_ = null;\n\n    /**\n     * @protected\n     * @type {Array<*>}\n     */\n    this.instructions = [];\n\n    /**\n     * @protected\n     * @type {Array<number>}\n     */\n    this.coordinates = [];\n\n    /**\n     * @private\n     * @type {import(\"../../coordinate.js\").Coordinate}\n     */\n    this.tmpCoordinate_ = [];\n\n    /**\n     * @protected\n     * @type {Array<*>}\n     */\n    this.hitDetectionInstructions = [];\n\n    /**\n     * @protected\n     * @type {import(\"../canvas.js\").FillStrokeState}\n     */\n    this.state = /** @type {import(\"../canvas.js\").FillStrokeState} */ ({});\n  }\n\n  /**\n   * @protected\n   * @param {Array<number>} dashArray Dash array.\n   * @return {Array<number>} Dash array with pixel ratio applied\n   */\n  applyPixelRatio(dashArray) {\n    const pixelRatio = this.pixelRatio;\n    return pixelRatio == 1\n      ? dashArray\n      : dashArray.map(function (dash) {\n          return dash * pixelRatio;\n        });\n  }\n\n  /**\n   * @param {Array<number>} flatCoordinates Flat coordinates.\n   * @param {number} stride Stride.\n   * @protected\n   * @return {number} My end\n   */\n  appendFlatPointCoordinates(flatCoordinates, stride) {\n    const extent = this.getBufferedMaxExtent();\n    const tmpCoord = this.tmpCoordinate_;\n    const coordinates = this.coordinates;\n    let myEnd = coordinates.length;\n    for (let i = 0, ii = flatCoordinates.length; i < ii; i += stride) {\n      tmpCoord[0] = flatCoordinates[i];\n      tmpCoord[1] = flatCoordinates[i + 1];\n      if (containsCoordinate(extent, tmpCoord)) {\n        coordinates[myEnd++] = tmpCoord[0];\n        coordinates[myEnd++] = tmpCoord[1];\n      }\n    }\n    return myEnd;\n  }\n\n  /**\n   * @param {Array<number>} flatCoordinates Flat coordinates.\n   * @param {number} offset Offset.\n   * @param {number} end End.\n   * @param {number} stride Stride.\n   * @param {boolean} closed Last input coordinate equals first.\n   * @param {boolean} skipFirst Skip first coordinate.\n   * @protected\n   * @return {number} My end.\n   */\n  appendFlatLineCoordinates(\n    flatCoordinates,\n    offset,\n    end,\n    stride,\n    closed,\n    skipFirst\n  ) {\n    const coordinates = this.coordinates;\n    let myEnd = coordinates.length;\n    const extent = this.getBufferedMaxExtent();\n    if (skipFirst) {\n      offset += stride;\n    }\n    let lastXCoord = flatCoordinates[offset];\n    let lastYCoord = flatCoordinates[offset + 1];\n    const nextCoord = this.tmpCoordinate_;\n    let skipped = true;\n\n    let i, lastRel, nextRel;\n    for (i = offset + stride; i < end; i += stride) {\n      nextCoord[0] = flatCoordinates[i];\n      nextCoord[1] = flatCoordinates[i + 1];\n      nextRel = coordinateRelationship(extent, nextCoord);\n      if (nextRel !== lastRel) {\n        if (skipped) {\n          coordinates[myEnd++] = lastXCoord;\n          coordinates[myEnd++] = lastYCoord;\n          skipped = false;\n        }\n        coordinates[myEnd++] = nextCoord[0];\n        coordinates[myEnd++] = nextCoord[1];\n      } else if (nextRel === Relationship.INTERSECTING) {\n        coordinates[myEnd++] = nextCoord[0];\n        coordinates[myEnd++] = nextCoord[1];\n        skipped = false;\n      } else {\n        skipped = true;\n      }\n      lastXCoord = nextCoord[0];\n      lastYCoord = nextCoord[1];\n      lastRel = nextRel;\n    }\n\n    // Last coordinate equals first or only one point to append:\n    if ((closed && skipped) || i === offset + stride) {\n      coordinates[myEnd++] = lastXCoord;\n      coordinates[myEnd++] = lastYCoord;\n    }\n    return myEnd;\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 {Array<number>} builderEnds Builder ends.\n   * @return {number} Offset.\n   */\n  drawCustomCoordinates_(flatCoordinates, offset, ends, stride, builderEnds) {\n    for (let i = 0, ii = ends.length; i < ii; ++i) {\n      const end = ends[i];\n      const builderEnd = this.appendFlatLineCoordinates(\n        flatCoordinates,\n        offset,\n        end,\n        stride,\n        false,\n        false\n      );\n      builderEnds.push(builderEnd);\n      offset = end;\n    }\n    return offset;\n  }\n\n  /**\n   * @param {import(\"../../geom/SimpleGeometry.js\").default} geometry Geometry.\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   * @param {Function} renderer Renderer.\n   */\n  drawCustom(geometry, feature, renderer) {\n    this.beginGeometry(geometry, feature);\n    const type = geometry.getType();\n    const stride = geometry.getStride();\n    const builderBegin = this.coordinates.length;\n    let flatCoordinates, builderEnd, builderEnds, builderEndss;\n    let offset;\n    if (type == GeometryType.MULTI_POLYGON) {\n      flatCoordinates = /** @type {import(\"../../geom/MultiPolygon.js\").default} */ (geometry).getOrientedFlatCoordinates();\n      builderEndss = [];\n      const endss = /** @type {import(\"../../geom/MultiPolygon.js\").default} */ (geometry).getEndss();\n      offset = 0;\n      for (let i = 0, ii = endss.length; i < ii; ++i) {\n        const myEnds = [];\n        offset = this.drawCustomCoordinates_(\n          flatCoordinates,\n          offset,\n          endss[i],\n          stride,\n          myEnds\n        );\n        builderEndss.push(myEnds);\n      }\n      this.instructions.push([\n        CanvasInstruction.CUSTOM,\n        builderBegin,\n        builderEndss,\n        geometry,\n        renderer,\n        inflateMultiCoordinatesArray,\n      ]);\n    } else if (\n      type == GeometryType.POLYGON ||\n      type == GeometryType.MULTI_LINE_STRING\n    ) {\n      builderEnds = [];\n      flatCoordinates =\n        type == GeometryType.POLYGON\n          ? /** @type {import(\"../../geom/Polygon.js\").default} */ (geometry).getOrientedFlatCoordinates()\n          : geometry.getFlatCoordinates();\n      offset = this.drawCustomCoordinates_(\n        flatCoordinates,\n        0,\n        /** @type {import(\"../../geom/Polygon.js\").default|import(\"../../geom/MultiLineString.js\").default} */ (geometry).getEnds(),\n        stride,\n        builderEnds\n      );\n      this.instructions.push([\n        CanvasInstruction.CUSTOM,\n        builderBegin,\n        builderEnds,\n        geometry,\n        renderer,\n        inflateCoordinatesArray,\n      ]);\n    } else if (\n      type == GeometryType.LINE_STRING ||\n      type == GeometryType.CIRCLE\n    ) {\n      flatCoordinates = geometry.getFlatCoordinates();\n      builderEnd = this.appendFlatLineCoordinates(\n        flatCoordinates,\n        0,\n        flatCoordinates.length,\n        stride,\n        false,\n        false\n      );\n      this.instructions.push([\n        CanvasInstruction.CUSTOM,\n        builderBegin,\n        builderEnd,\n        geometry,\n        renderer,\n        inflateCoordinates,\n      ]);\n    } else if (type == GeometryType.MULTI_POINT) {\n      flatCoordinates = geometry.getFlatCoordinates();\n      builderEnd = this.appendFlatPointCoordinates(flatCoordinates, stride);\n      if (builderEnd > builderBegin) {\n        this.instructions.push([\n          CanvasInstruction.CUSTOM,\n          builderBegin,\n          builderEnd,\n          geometry,\n          renderer,\n          inflateCoordinates,\n        ]);\n      }\n    } else if (type == GeometryType.POINT) {\n      flatCoordinates = geometry.getFlatCoordinates();\n      this.coordinates.push(flatCoordinates[0], flatCoordinates[1]);\n      builderEnd = this.coordinates.length;\n      this.instructions.push([\n        CanvasInstruction.CUSTOM,\n        builderBegin,\n        builderEnd,\n        geometry,\n        renderer,\n      ]);\n    }\n    this.endGeometry(feature);\n  }\n\n  /**\n   * @protected\n   * @param {import(\"../../geom/Geometry\").default|import(\"../Feature.js\").default} geometry The geometry.\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   */\n  beginGeometry(geometry, feature) {\n    this.beginGeometryInstruction1_ = [\n      CanvasInstruction.BEGIN_GEOMETRY,\n      feature,\n      0,\n      geometry,\n    ];\n    this.instructions.push(this.beginGeometryInstruction1_);\n    this.beginGeometryInstruction2_ = [\n      CanvasInstruction.BEGIN_GEOMETRY,\n      feature,\n      0,\n      geometry,\n    ];\n    this.hitDetectionInstructions.push(this.beginGeometryInstruction2_);\n  }\n\n  /**\n   * @return {import(\"../canvas.js\").SerializableInstructions} the serializable instructions.\n   */\n  finish() {\n    return {\n      instructions: this.instructions,\n      hitDetectionInstructions: this.hitDetectionInstructions,\n      coordinates: this.coordinates,\n    };\n  }\n\n  /**\n   * Reverse the hit detection instructions.\n   */\n  reverseHitDetectionInstructions() {\n    const hitDetectionInstructions = this.hitDetectionInstructions;\n    // step 1 - reverse array\n    hitDetectionInstructions.reverse();\n    // step 2 - reverse instructions within geometry blocks\n    let i;\n    const n = hitDetectionInstructions.length;\n    let instruction;\n    let type;\n    let begin = -1;\n    for (i = 0; i < n; ++i) {\n      instruction = hitDetectionInstructions[i];\n      type = /** @type {import(\"./Instruction.js\").default} */ (instruction[0]);\n      if (type == CanvasInstruction.END_GEOMETRY) {\n        begin = i;\n      } else if (type == CanvasInstruction.BEGIN_GEOMETRY) {\n        instruction[2] = i;\n        reverseSubArray(this.hitDetectionInstructions, begin, i);\n        begin = -1;\n      }\n    }\n  }\n\n  /**\n   * @param {import(\"../../style/Fill.js\").default} fillStyle Fill style.\n   * @param {import(\"../../style/Stroke.js\").default} strokeStyle Stroke style.\n   */\n  setFillStrokeStyle(fillStyle, strokeStyle) {\n    const state = this.state;\n    if (fillStyle) {\n      const fillStyleColor = fillStyle.getColor();\n      state.fillStyle = asColorLike(\n        fillStyleColor ? fillStyleColor : defaultFillStyle\n      );\n    } else {\n      state.fillStyle = undefined;\n    }\n    if (strokeStyle) {\n      const strokeStyleColor = strokeStyle.getColor();\n      state.strokeStyle = asColorLike(\n        strokeStyleColor ? strokeStyleColor : defaultStrokeStyle\n      );\n      const strokeStyleLineCap = strokeStyle.getLineCap();\n      state.lineCap =\n        strokeStyleLineCap !== undefined ? strokeStyleLineCap : defaultLineCap;\n      const strokeStyleLineDash = strokeStyle.getLineDash();\n      state.lineDash = strokeStyleLineDash\n        ? strokeStyleLineDash.slice()\n        : defaultLineDash;\n      const strokeStyleLineDashOffset = strokeStyle.getLineDashOffset();\n      state.lineDashOffset = strokeStyleLineDashOffset\n        ? strokeStyleLineDashOffset\n        : defaultLineDashOffset;\n      const strokeStyleLineJoin = strokeStyle.getLineJoin();\n      state.lineJoin =\n        strokeStyleLineJoin !== undefined\n          ? strokeStyleLineJoin\n          : defaultLineJoin;\n      const strokeStyleWidth = strokeStyle.getWidth();\n      state.lineWidth =\n        strokeStyleWidth !== undefined ? strokeStyleWidth : defaultLineWidth;\n      const strokeStyleMiterLimit = strokeStyle.getMiterLimit();\n      state.miterLimit =\n        strokeStyleMiterLimit !== undefined\n          ? strokeStyleMiterLimit\n          : defaultMiterLimit;\n\n      if (state.lineWidth > this.maxLineWidth) {\n        this.maxLineWidth = state.lineWidth;\n        // invalidate the buffered max extent cache\n        this.bufferedMaxExtent_ = null;\n      }\n    } else {\n      state.strokeStyle = undefined;\n      state.lineCap = undefined;\n      state.lineDash = null;\n      state.lineDashOffset = undefined;\n      state.lineJoin = undefined;\n      state.lineWidth = undefined;\n      state.miterLimit = undefined;\n    }\n  }\n\n  /**\n   * @param {import(\"../canvas.js\").FillStrokeState} state State.\n   * @return {Array<*>} Fill instruction.\n   */\n  createFill(state) {\n    const fillStyle = state.fillStyle;\n    /** @type {Array<*>} */\n    const fillInstruction = [CanvasInstruction.SET_FILL_STYLE, fillStyle];\n    if (typeof fillStyle !== 'string') {\n      // Fill is a pattern or gradient - align it!\n      fillInstruction.push(true);\n    }\n    return fillInstruction;\n  }\n\n  /**\n   * @param {import(\"../canvas.js\").FillStrokeState} state State.\n   */\n  applyStroke(state) {\n    this.instructions.push(this.createStroke(state));\n  }\n\n  /**\n   * @param {import(\"../canvas.js\").FillStrokeState} state State.\n   * @return {Array<*>} Stroke instruction.\n   */\n  createStroke(state) {\n    return [\n      CanvasInstruction.SET_STROKE_STYLE,\n      state.strokeStyle,\n      state.lineWidth * this.pixelRatio,\n      state.lineCap,\n      state.lineJoin,\n      state.miterLimit,\n      this.applyPixelRatio(state.lineDash),\n      state.lineDashOffset * this.pixelRatio,\n    ];\n  }\n\n  /**\n   * @param {import(\"../canvas.js\").FillStrokeState} state State.\n   * @param {function(this:CanvasBuilder, import(\"../canvas.js\").FillStrokeState):Array<*>} createFill Create fill.\n   */\n  updateFillStyle(state, createFill) {\n    const fillStyle = state.fillStyle;\n    if (typeof fillStyle !== 'string' || state.currentFillStyle != fillStyle) {\n      if (fillStyle !== undefined) {\n        this.instructions.push(createFill.call(this, state));\n      }\n      state.currentFillStyle = fillStyle;\n    }\n  }\n\n  /**\n   * @param {import(\"../canvas.js\").FillStrokeState} state State.\n   * @param {function(this:CanvasBuilder, import(\"../canvas.js\").FillStrokeState): void} applyStroke Apply stroke.\n   */\n  updateStrokeStyle(state, applyStroke) {\n    const strokeStyle = state.strokeStyle;\n    const lineCap = state.lineCap;\n    const lineDash = state.lineDash;\n    const lineDashOffset = state.lineDashOffset;\n    const lineJoin = state.lineJoin;\n    const lineWidth = state.lineWidth;\n    const miterLimit = state.miterLimit;\n    if (\n      state.currentStrokeStyle != strokeStyle ||\n      state.currentLineCap != lineCap ||\n      (lineDash != state.currentLineDash &&\n        !equals(state.currentLineDash, lineDash)) ||\n      state.currentLineDashOffset != lineDashOffset ||\n      state.currentLineJoin != lineJoin ||\n      state.currentLineWidth != lineWidth ||\n      state.currentMiterLimit != miterLimit\n    ) {\n      if (strokeStyle !== undefined) {\n        applyStroke.call(this, state);\n      }\n      state.currentStrokeStyle = strokeStyle;\n      state.currentLineCap = lineCap;\n      state.currentLineDash = lineDash;\n      state.currentLineDashOffset = lineDashOffset;\n      state.currentLineJoin = lineJoin;\n      state.currentLineWidth = lineWidth;\n      state.currentMiterLimit = miterLimit;\n    }\n  }\n\n  /**\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   */\n  endGeometry(feature) {\n    this.beginGeometryInstruction1_[2] = this.instructions.length;\n    this.beginGeometryInstruction1_ = null;\n    this.beginGeometryInstruction2_[2] = this.hitDetectionInstructions.length;\n    this.beginGeometryInstruction2_ = null;\n    const endGeometryInstruction = [CanvasInstruction.END_GEOMETRY, feature];\n    this.instructions.push(endGeometryInstruction);\n    this.hitDetectionInstructions.push(endGeometryInstruction);\n  }\n\n  /**\n   * Get the buffered rendering extent.  Rendering will be clipped to the extent\n   * provided to the constructor.  To account for symbolizers that may intersect\n   * this extent, we calculate a buffered extent (e.g. based on stroke width).\n   * @return {import(\"../../extent.js\").Extent} The buffered rendering extent.\n   * @protected\n   */\n  getBufferedMaxExtent() {\n    if (!this.bufferedMaxExtent_) {\n      this.bufferedMaxExtent_ = clone(this.maxExtent);\n      if (this.maxLineWidth > 0) {\n        const width = (this.resolution * (this.maxLineWidth + 1)) / 2;\n        buffer(this.bufferedMaxExtent_, width, this.bufferedMaxExtent_);\n      }\n    }\n    return this.bufferedMaxExtent_;\n  }\n}\n\nexport default CanvasBuilder;\n","/**\n * @module ol/render/canvas/ImageBuilder\n */\nimport CanvasBuilder from './Builder.js';\nimport CanvasInstruction from './Instruction.js';\n\nclass CanvasImageBuilder extends CanvasBuilder {\n  /**\n   * @param {number} tolerance Tolerance.\n   * @param {import(\"../../extent.js\").Extent} maxExtent Maximum extent.\n   * @param {number} resolution Resolution.\n   * @param {number} pixelRatio Pixel ratio.\n   */\n  constructor(tolerance, maxExtent, resolution, pixelRatio) {\n    super(tolerance, maxExtent, resolution, pixelRatio);\n\n    /**\n     * @private\n     * @type {HTMLCanvasElement|HTMLVideoElement|HTMLImageElement}\n     */\n    this.hitDetectionImage_ = null;\n\n    /**\n     * @private\n     * @type {HTMLCanvasElement|HTMLVideoElement|HTMLImageElement}\n     */\n    this.image_ = null;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.imagePixelRatio_ = undefined;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.anchorX_ = undefined;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.anchorY_ = undefined;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.height_ = undefined;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.opacity_ = undefined;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.originX_ = undefined;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.originY_ = undefined;\n\n    /**\n     * @private\n     * @type {boolean|undefined}\n     */\n    this.rotateWithView_ = undefined;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.rotation_ = undefined;\n\n    /**\n     * @private\n     * @type {import(\"../../size.js\").Size|undefined}\n     */\n    this.scale_ = undefined;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.width_ = undefined;\n\n    /**\n     * Data shared with a text builder for combined decluttering.\n     * @private\n     * @type {import(\"../canvas.js\").DeclutterImageWithText}\n     */\n    this.declutterImageWithText_ = undefined;\n  }\n\n  /**\n   * @param {import(\"../../geom/Point.js\").default|import(\"../Feature.js\").default} pointGeometry Point geometry.\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawPoint(pointGeometry, feature) {\n    if (!this.image_) {\n      return;\n    }\n    this.beginGeometry(pointGeometry, feature);\n    const flatCoordinates = pointGeometry.getFlatCoordinates();\n    const stride = pointGeometry.getStride();\n    const myBegin = this.coordinates.length;\n    const myEnd = this.appendFlatPointCoordinates(flatCoordinates, stride);\n    this.instructions.push([\n      CanvasInstruction.DRAW_IMAGE,\n      myBegin,\n      myEnd,\n      this.image_,\n      // Remaining arguments to DRAW_IMAGE are in alphabetical order\n      this.anchorX_ * this.imagePixelRatio_,\n      this.anchorY_ * this.imagePixelRatio_,\n      Math.ceil(this.height_ * this.imagePixelRatio_),\n      this.opacity_,\n      this.originX_,\n      this.originY_,\n      this.rotateWithView_,\n      this.rotation_,\n      [\n        (this.scale_[0] * this.pixelRatio) / this.imagePixelRatio_,\n        (this.scale_[1] * this.pixelRatio) / this.imagePixelRatio_,\n      ],\n      Math.ceil(this.width_ * this.imagePixelRatio_),\n      this.declutterImageWithText_,\n    ]);\n    this.hitDetectionInstructions.push([\n      CanvasInstruction.DRAW_IMAGE,\n      myBegin,\n      myEnd,\n      this.hitDetectionImage_,\n      // Remaining arguments to DRAW_IMAGE are in alphabetical order\n      this.anchorX_,\n      this.anchorY_,\n      this.height_,\n      this.opacity_,\n      this.originX_,\n      this.originY_,\n      this.rotateWithView_,\n      this.rotation_,\n      this.scale_,\n      this.width_,\n      this.declutterImageWithText_,\n    ]);\n    this.endGeometry(feature);\n  }\n\n  /**\n   * @param {import(\"../../geom/MultiPoint.js\").default|import(\"../Feature.js\").default} multiPointGeometry MultiPoint geometry.\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawMultiPoint(multiPointGeometry, feature) {\n    if (!this.image_) {\n      return;\n    }\n    this.beginGeometry(multiPointGeometry, feature);\n    const flatCoordinates = multiPointGeometry.getFlatCoordinates();\n    const stride = multiPointGeometry.getStride();\n    const myBegin = this.coordinates.length;\n    const myEnd = this.appendFlatPointCoordinates(flatCoordinates, stride);\n    this.instructions.push([\n      CanvasInstruction.DRAW_IMAGE,\n      myBegin,\n      myEnd,\n      this.image_,\n      // Remaining arguments to DRAW_IMAGE are in alphabetical order\n      this.anchorX_ * this.imagePixelRatio_,\n      this.anchorY_ * this.imagePixelRatio_,\n      Math.ceil(this.height_ * this.imagePixelRatio_),\n      this.opacity_,\n      this.originX_,\n      this.originY_,\n      this.rotateWithView_,\n      this.rotation_,\n      [\n        (this.scale_[0] * this.pixelRatio) / this.imagePixelRatio_,\n        (this.scale_[1] * this.pixelRatio) / this.imagePixelRatio_,\n      ],\n      Math.ceil(this.width_ * this.imagePixelRatio_),\n      this.declutterImageWithText_,\n    ]);\n    this.hitDetectionInstructions.push([\n      CanvasInstruction.DRAW_IMAGE,\n      myBegin,\n      myEnd,\n      this.hitDetectionImage_,\n      // Remaining arguments to DRAW_IMAGE are in alphabetical order\n      this.anchorX_,\n      this.anchorY_,\n      this.height_,\n      this.opacity_,\n      this.originX_,\n      this.originY_,\n      this.rotateWithView_,\n      this.rotation_,\n      this.scale_,\n      this.width_,\n      this.declutterImageWithText_,\n    ]);\n    this.endGeometry(feature);\n  }\n\n  /**\n   * @return {import(\"../canvas.js\").SerializableInstructions} the serializable instructions.\n   */\n  finish() {\n    this.reverseHitDetectionInstructions();\n    // FIXME this doesn't really protect us against further calls to draw*Geometry\n    this.anchorX_ = undefined;\n    this.anchorY_ = undefined;\n    this.hitDetectionImage_ = null;\n    this.image_ = null;\n    this.imagePixelRatio_ = undefined;\n    this.height_ = undefined;\n    this.scale_ = undefined;\n    this.opacity_ = undefined;\n    this.originX_ = undefined;\n    this.originY_ = undefined;\n    this.rotateWithView_ = undefined;\n    this.rotation_ = undefined;\n    this.width_ = undefined;\n    return super.finish();\n  }\n\n  /**\n   * @param {import(\"../../style/Image.js\").default} imageStyle Image style.\n   * @param {Object=} opt_sharedData Shared data.\n   */\n  setImageStyle(imageStyle, opt_sharedData) {\n    const anchor = imageStyle.getAnchor();\n    const size = imageStyle.getSize();\n    const hitDetectionImage = imageStyle.getHitDetectionImage();\n    const image = imageStyle.getImage(this.pixelRatio);\n    const origin = imageStyle.getOrigin();\n    this.imagePixelRatio_ = imageStyle.getPixelRatio(this.pixelRatio);\n    this.anchorX_ = anchor[0];\n    this.anchorY_ = anchor[1];\n    this.hitDetectionImage_ = hitDetectionImage;\n    this.image_ = image;\n    this.height_ = size[1];\n    this.opacity_ = imageStyle.getOpacity();\n    this.originX_ = origin[0];\n    this.originY_ = origin[1];\n    this.rotateWithView_ = imageStyle.getRotateWithView();\n    this.rotation_ = imageStyle.getRotation();\n    this.scale_ = imageStyle.getScaleArray();\n    this.width_ = size[0];\n    this.declutterImageWithText_ = opt_sharedData;\n  }\n}\n\nexport default CanvasImageBuilder;\n","/**\n * @module ol/render/canvas/LineStringBuilder\n */\nimport CanvasBuilder from './Builder.js';\nimport CanvasInstruction, {\n  beginPathInstruction,\n  strokeInstruction,\n} from './Instruction.js';\n\nclass CanvasLineStringBuilder extends CanvasBuilder {\n  /**\n   * @param {number} tolerance Tolerance.\n   * @param {import(\"../../extent.js\").Extent} maxExtent Maximum extent.\n   * @param {number} resolution Resolution.\n   * @param {number} pixelRatio Pixel ratio.\n   */\n  constructor(tolerance, maxExtent, resolution, pixelRatio) {\n    super(tolerance, maxExtent, resolution, pixelRatio);\n  }\n\n  /**\n   * @param {Array<number>} flatCoordinates Flat coordinates.\n   * @param {number} offset Offset.\n   * @param {number} end End.\n   * @param {number} stride Stride.\n   * @private\n   * @return {number} end.\n   */\n  drawFlatCoordinates_(flatCoordinates, offset, end, stride) {\n    const myBegin = this.coordinates.length;\n    const myEnd = this.appendFlatLineCoordinates(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      false,\n      false\n    );\n    const moveToLineToInstruction = [\n      CanvasInstruction.MOVE_TO_LINE_TO,\n      myBegin,\n      myEnd,\n    ];\n    this.instructions.push(moveToLineToInstruction);\n    this.hitDetectionInstructions.push(moveToLineToInstruction);\n    return end;\n  }\n\n  /**\n   * @param {import(\"../../geom/LineString.js\").default|import(\"../Feature.js\").default} lineStringGeometry Line string geometry.\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawLineString(lineStringGeometry, feature) {\n    const state = this.state;\n    const strokeStyle = state.strokeStyle;\n    const lineWidth = state.lineWidth;\n    if (strokeStyle === undefined || lineWidth === undefined) {\n      return;\n    }\n    this.updateStrokeStyle(state, this.applyStroke);\n    this.beginGeometry(lineStringGeometry, feature);\n    this.hitDetectionInstructions.push(\n      [\n        CanvasInstruction.SET_STROKE_STYLE,\n        state.strokeStyle,\n        state.lineWidth,\n        state.lineCap,\n        state.lineJoin,\n        state.miterLimit,\n        state.lineDash,\n        state.lineDashOffset,\n      ],\n      beginPathInstruction\n    );\n    const flatCoordinates = lineStringGeometry.getFlatCoordinates();\n    const stride = lineStringGeometry.getStride();\n    this.drawFlatCoordinates_(\n      flatCoordinates,\n      0,\n      flatCoordinates.length,\n      stride\n    );\n    this.hitDetectionInstructions.push(strokeInstruction);\n    this.endGeometry(feature);\n  }\n\n  /**\n   * @param {import(\"../../geom/MultiLineString.js\").default|import(\"../Feature.js\").default} multiLineStringGeometry MultiLineString geometry.\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawMultiLineString(multiLineStringGeometry, feature) {\n    const state = this.state;\n    const strokeStyle = state.strokeStyle;\n    const lineWidth = state.lineWidth;\n    if (strokeStyle === undefined || lineWidth === undefined) {\n      return;\n    }\n    this.updateStrokeStyle(state, this.applyStroke);\n    this.beginGeometry(multiLineStringGeometry, feature);\n    this.hitDetectionInstructions.push(\n      [\n        CanvasInstruction.SET_STROKE_STYLE,\n        state.strokeStyle,\n        state.lineWidth,\n        state.lineCap,\n        state.lineJoin,\n        state.miterLimit,\n        state.lineDash,\n        state.lineDashOffset,\n      ],\n      beginPathInstruction\n    );\n    const ends = multiLineStringGeometry.getEnds();\n    const flatCoordinates = multiLineStringGeometry.getFlatCoordinates();\n    const stride = multiLineStringGeometry.getStride();\n    let offset = 0;\n    for (let i = 0, ii = ends.length; i < ii; ++i) {\n      offset = this.drawFlatCoordinates_(\n        flatCoordinates,\n        offset,\n        /** @type {number} */ (ends[i]),\n        stride\n      );\n    }\n    this.hitDetectionInstructions.push(strokeInstruction);\n    this.endGeometry(feature);\n  }\n\n  /**\n   * @return {import(\"../canvas.js\").SerializableInstructions} the serializable instructions.\n   */\n  finish() {\n    const state = this.state;\n    if (\n      state.lastStroke != undefined &&\n      state.lastStroke != this.coordinates.length\n    ) {\n      this.instructions.push(strokeInstruction);\n    }\n    this.reverseHitDetectionInstructions();\n    this.state = null;\n    return super.finish();\n  }\n\n  /**\n   * @param {import(\"../canvas.js\").FillStrokeState} state State.\n   */\n  applyStroke(state) {\n    if (\n      state.lastStroke != undefined &&\n      state.lastStroke != this.coordinates.length\n    ) {\n      this.instructions.push(strokeInstruction);\n      state.lastStroke = this.coordinates.length;\n    }\n    state.lastStroke = 0;\n    super.applyStroke(state);\n    this.instructions.push(beginPathInstruction);\n  }\n}\n\nexport default CanvasLineStringBuilder;\n","/**\n * @module ol/render/canvas/PolygonBuilder\n */\nimport CanvasBuilder from './Builder.js';\nimport CanvasInstruction, {\n  beginPathInstruction,\n  closePathInstruction,\n  fillInstruction,\n  strokeInstruction,\n} from './Instruction.js';\nimport {defaultFillStyle} from '../canvas.js';\nimport {snap} from '../../geom/flat/simplify.js';\n\nclass CanvasPolygonBuilder extends CanvasBuilder {\n  /**\n   * @param {number} tolerance Tolerance.\n   * @param {import(\"../../extent.js\").Extent} maxExtent Maximum extent.\n   * @param {number} resolution Resolution.\n   * @param {number} pixelRatio Pixel ratio.\n   */\n  constructor(tolerance, maxExtent, resolution, pixelRatio) {\n    super(tolerance, maxExtent, resolution, pixelRatio);\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   * @private\n   * @return {number} End.\n   */\n  drawFlatCoordinatess_(flatCoordinates, offset, ends, stride) {\n    const state = this.state;\n    const fill = state.fillStyle !== undefined;\n    const stroke = state.strokeStyle !== undefined;\n    const numEnds = ends.length;\n    this.instructions.push(beginPathInstruction);\n    this.hitDetectionInstructions.push(beginPathInstruction);\n    for (let i = 0; i < numEnds; ++i) {\n      const end = ends[i];\n      const myBegin = this.coordinates.length;\n      const myEnd = this.appendFlatLineCoordinates(\n        flatCoordinates,\n        offset,\n        end,\n        stride,\n        true,\n        !stroke\n      );\n      const moveToLineToInstruction = [\n        CanvasInstruction.MOVE_TO_LINE_TO,\n        myBegin,\n        myEnd,\n      ];\n      this.instructions.push(moveToLineToInstruction);\n      this.hitDetectionInstructions.push(moveToLineToInstruction);\n      if (stroke) {\n        // Performance optimization: only call closePath() when we have a stroke.\n        // Otherwise the ring is closed already (see appendFlatLineCoordinates above).\n        this.instructions.push(closePathInstruction);\n        this.hitDetectionInstructions.push(closePathInstruction);\n      }\n      offset = end;\n    }\n    if (fill) {\n      this.instructions.push(fillInstruction);\n      this.hitDetectionInstructions.push(fillInstruction);\n    }\n    if (stroke) {\n      this.instructions.push(strokeInstruction);\n      this.hitDetectionInstructions.push(strokeInstruction);\n    }\n    return offset;\n  }\n\n  /**\n   * @param {import(\"../../geom/Circle.js\").default} circleGeometry Circle geometry.\n   * @param {import(\"../../Feature.js\").default} feature Feature.\n   */\n  drawCircle(circleGeometry, feature) {\n    const state = this.state;\n    const fillStyle = state.fillStyle;\n    const strokeStyle = state.strokeStyle;\n    if (fillStyle === undefined && strokeStyle === undefined) {\n      return;\n    }\n    this.setFillStrokeStyles_();\n    this.beginGeometry(circleGeometry, feature);\n    if (state.fillStyle !== undefined) {\n      this.hitDetectionInstructions.push([\n        CanvasInstruction.SET_FILL_STYLE,\n        defaultFillStyle,\n      ]);\n    }\n    if (state.strokeStyle !== undefined) {\n      this.hitDetectionInstructions.push([\n        CanvasInstruction.SET_STROKE_STYLE,\n        state.strokeStyle,\n        state.lineWidth,\n        state.lineCap,\n        state.lineJoin,\n        state.miterLimit,\n        state.lineDash,\n        state.lineDashOffset,\n      ]);\n    }\n    const flatCoordinates = circleGeometry.getFlatCoordinates();\n    const stride = circleGeometry.getStride();\n    const myBegin = this.coordinates.length;\n    this.appendFlatLineCoordinates(\n      flatCoordinates,\n      0,\n      flatCoordinates.length,\n      stride,\n      false,\n      false\n    );\n    const circleInstruction = [CanvasInstruction.CIRCLE, myBegin];\n    this.instructions.push(beginPathInstruction, circleInstruction);\n    this.hitDetectionInstructions.push(beginPathInstruction, circleInstruction);\n    if (state.fillStyle !== undefined) {\n      this.instructions.push(fillInstruction);\n      this.hitDetectionInstructions.push(fillInstruction);\n    }\n    if (state.strokeStyle !== undefined) {\n      this.instructions.push(strokeInstruction);\n      this.hitDetectionInstructions.push(strokeInstruction);\n    }\n    this.endGeometry(feature);\n  }\n\n  /**\n   * @param {import(\"../../geom/Polygon.js\").default|import(\"../Feature.js\").default} polygonGeometry Polygon geometry.\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawPolygon(polygonGeometry, feature) {\n    const state = this.state;\n    const fillStyle = state.fillStyle;\n    const strokeStyle = state.strokeStyle;\n    if (fillStyle === undefined && strokeStyle === undefined) {\n      return;\n    }\n    this.setFillStrokeStyles_();\n    this.beginGeometry(polygonGeometry, feature);\n    if (state.fillStyle !== undefined) {\n      this.hitDetectionInstructions.push([\n        CanvasInstruction.SET_FILL_STYLE,\n        defaultFillStyle,\n      ]);\n    }\n    if (state.strokeStyle !== undefined) {\n      this.hitDetectionInstructions.push([\n        CanvasInstruction.SET_STROKE_STYLE,\n        state.strokeStyle,\n        state.lineWidth,\n        state.lineCap,\n        state.lineJoin,\n        state.miterLimit,\n        state.lineDash,\n        state.lineDashOffset,\n      ]);\n    }\n    const ends = polygonGeometry.getEnds();\n    const flatCoordinates = polygonGeometry.getOrientedFlatCoordinates();\n    const stride = polygonGeometry.getStride();\n    this.drawFlatCoordinatess_(\n      flatCoordinates,\n      0,\n      /** @type {Array<number>} */ (ends),\n      stride\n    );\n    this.endGeometry(feature);\n  }\n\n  /**\n   * @param {import(\"../../geom/MultiPolygon.js\").default} multiPolygonGeometry MultiPolygon geometry.\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawMultiPolygon(multiPolygonGeometry, feature) {\n    const state = this.state;\n    const fillStyle = state.fillStyle;\n    const strokeStyle = state.strokeStyle;\n    if (fillStyle === undefined && strokeStyle === undefined) {\n      return;\n    }\n    this.setFillStrokeStyles_();\n    this.beginGeometry(multiPolygonGeometry, feature);\n    if (state.fillStyle !== undefined) {\n      this.hitDetectionInstructions.push([\n        CanvasInstruction.SET_FILL_STYLE,\n        defaultFillStyle,\n      ]);\n    }\n    if (state.strokeStyle !== undefined) {\n      this.hitDetectionInstructions.push([\n        CanvasInstruction.SET_STROKE_STYLE,\n        state.strokeStyle,\n        state.lineWidth,\n        state.lineCap,\n        state.lineJoin,\n        state.miterLimit,\n        state.lineDash,\n        state.lineDashOffset,\n      ]);\n    }\n    const endss = multiPolygonGeometry.getEndss();\n    const flatCoordinates = multiPolygonGeometry.getOrientedFlatCoordinates();\n    const stride = multiPolygonGeometry.getStride();\n    let offset = 0;\n    for (let i = 0, ii = endss.length; i < ii; ++i) {\n      offset = this.drawFlatCoordinatess_(\n        flatCoordinates,\n        offset,\n        endss[i],\n        stride\n      );\n    }\n    this.endGeometry(feature);\n  }\n\n  /**\n   * @return {import(\"../canvas.js\").SerializableInstructions} the serializable instructions.\n   */\n  finish() {\n    this.reverseHitDetectionInstructions();\n    this.state = null;\n    // We want to preserve topology when drawing polygons.  Polygons are\n    // simplified using quantization and point elimination. However, we might\n    // have received a mix of quantized and non-quantized geometries, so ensure\n    // that all are quantized by quantizing all coordinates in the batch.\n    const tolerance = this.tolerance;\n    if (tolerance !== 0) {\n      const coordinates = this.coordinates;\n      for (let i = 0, ii = coordinates.length; i < ii; ++i) {\n        coordinates[i] = snap(coordinates[i], tolerance);\n      }\n    }\n    return super.finish();\n  }\n\n  /**\n   * @private\n   */\n  setFillStrokeStyles_() {\n    const state = this.state;\n    const fillStyle = state.fillStyle;\n    if (fillStyle !== undefined) {\n      this.updateFillStyle(state, this.createFill);\n    }\n    if (state.strokeStyle !== undefined) {\n      this.updateStrokeStyle(state, this.applyStroke);\n    }\n  }\n}\n\nexport default CanvasPolygonBuilder;\n","/**\n * @module ol/style/TextPlacement\n */\n\n/**\n * Text placement. One of `'point'`, `'line'`. Default is `'point'`. Note that\n * `'line'` requires the underlying geometry to be a {@link module:ol/geom/LineString~LineString},\n * {@link module:ol/geom/Polygon~Polygon}, {@link module:ol/geom/MultiLineString~MultiLineString} or\n * {@link module:ol/geom/MultiPolygon~MultiPolygon}.\n * @enum {string}\n */\nexport default {\n  POINT: 'point',\n  LINE: 'line',\n};\n","/**\n * @module ol/geom/flat/straightchunk\n */\n\n/**\n * @param {number} maxAngle Maximum acceptable angle delta between segments.\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @return {Array<number>} Start and end of the first suitable chunk of the\n * given `flatCoordinates`.\n */\nexport function matchingChunk(maxAngle, flatCoordinates, offset, end, stride) {\n  let chunkStart = offset;\n  let chunkEnd = offset;\n  let chunkM = 0;\n  let m = 0;\n  let start = offset;\n  let acos, i, m12, m23, x1, y1, x12, y12, x23, y23;\n  for (i = offset; i < end; i += stride) {\n    const x2 = flatCoordinates[i];\n    const y2 = flatCoordinates[i + 1];\n    if (x1 !== undefined) {\n      x23 = x2 - x1;\n      y23 = y2 - y1;\n      m23 = Math.sqrt(x23 * x23 + y23 * y23);\n      if (x12 !== undefined) {\n        m += m12;\n        acos = Math.acos((x12 * x23 + y12 * y23) / (m12 * m23));\n        if (acos > maxAngle) {\n          if (m > chunkM) {\n            chunkM = m;\n            chunkStart = start;\n            chunkEnd = i;\n          }\n          m = 0;\n          start = i - stride;\n        }\n      }\n      m12 = m23;\n      x12 = x23;\n      y12 = y23;\n    }\n    x1 = x2;\n    y1 = y2;\n  }\n  m += m23;\n  return m > chunkM ? [start, i] : [chunkStart, chunkEnd];\n}\n","/**\n * @module ol/render/canvas/TextBuilder\n */\nimport CanvasBuilder from './Builder.js';\nimport CanvasInstruction from './Instruction.js';\nimport GeometryType from '../../geom/GeometryType.js';\nimport TextPlacement from '../../style/TextPlacement.js';\nimport {asColorLike} from '../../colorlike.js';\nimport {\n  defaultFillStyle,\n  defaultFont,\n  defaultLineCap,\n  defaultLineDash,\n  defaultLineDashOffset,\n  defaultLineJoin,\n  defaultLineWidth,\n  defaultMiterLimit,\n  defaultPadding,\n  defaultStrokeStyle,\n  defaultTextAlign,\n  defaultTextBaseline,\n  registerFont,\n} from '../canvas.js';\nimport {getUid} from '../../util.js';\nimport {intersects} from '../../extent.js';\nimport {matchingChunk} from '../../geom/flat/straightchunk.js';\n/**\n * @const\n * @enum {number}\n */\nexport const TEXT_ALIGN = {\n  'left': 0,\n  'end': 0,\n  'center': 0.5,\n  'right': 1,\n  'start': 1,\n  'top': 0,\n  'middle': 0.5,\n  'hanging': 0.2,\n  'alphabetic': 0.8,\n  'ideographic': 0.8,\n  'bottom': 1,\n};\n\nclass CanvasTextBuilder extends CanvasBuilder {\n  /**\n   * @param {number} tolerance Tolerance.\n   * @param {import(\"../../extent.js\").Extent} maxExtent Maximum extent.\n   * @param {number} resolution Resolution.\n   * @param {number} pixelRatio Pixel ratio.\n   */\n  constructor(tolerance, maxExtent, resolution, pixelRatio) {\n    super(tolerance, maxExtent, resolution, pixelRatio);\n\n    /**\n     * @private\n     * @type {Array<HTMLCanvasElement>}\n     */\n    this.labels_ = null;\n\n    /**\n     * @private\n     * @type {string}\n     */\n    this.text_ = '';\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.textOffsetX_ = 0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.textOffsetY_ = 0;\n\n    /**\n     * @private\n     * @type {boolean|undefined}\n     */\n    this.textRotateWithView_ = undefined;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.textRotation_ = 0;\n\n    /**\n     * @private\n     * @type {?import(\"../canvas.js\").FillState}\n     */\n    this.textFillState_ = null;\n\n    /**\n     * @type {!Object<string, import(\"../canvas.js\").FillState>}\n     */\n    this.fillStates = {};\n\n    /**\n     * @private\n     * @type {?import(\"../canvas.js\").StrokeState}\n     */\n    this.textStrokeState_ = null;\n\n    /**\n     * @type {!Object<string, import(\"../canvas.js\").StrokeState>}\n     */\n    this.strokeStates = {};\n\n    /**\n     * @private\n     * @type {import(\"../canvas.js\").TextState}\n     */\n    this.textState_ = /** @type {import(\"../canvas.js\").TextState} */ ({});\n\n    /**\n     * @type {!Object<string, import(\"../canvas.js\").TextState>}\n     */\n    this.textStates = {};\n\n    /**\n     * @private\n     * @type {string}\n     */\n    this.textKey_ = '';\n\n    /**\n     * @private\n     * @type {string}\n     */\n    this.fillKey_ = '';\n\n    /**\n     * @private\n     * @type {string}\n     */\n    this.strokeKey_ = '';\n\n    /**\n     * Data shared with an image builder for combined decluttering.\n     * @private\n     * @type {import(\"../canvas.js\").DeclutterImageWithText}\n     */\n    this.declutterImageWithText_ = undefined;\n  }\n\n  /**\n   * @return {import(\"../canvas.js\").SerializableInstructions} the serializable instructions.\n   */\n  finish() {\n    const instructions = super.finish();\n    instructions.textStates = this.textStates;\n    instructions.fillStates = this.fillStates;\n    instructions.strokeStates = this.strokeStates;\n    return instructions;\n  }\n\n  /**\n   * @param {import(\"../../geom/SimpleGeometry.js\").default|import(\"../Feature.js\").default} geometry Geometry.\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   */\n  drawText(geometry, feature) {\n    const fillState = this.textFillState_;\n    const strokeState = this.textStrokeState_;\n    const textState = this.textState_;\n    if (this.text_ === '' || !textState || (!fillState && !strokeState)) {\n      return;\n    }\n\n    const coordinates = this.coordinates;\n    let begin = coordinates.length;\n\n    const geometryType = geometry.getType();\n    let flatCoordinates = null;\n    let stride = geometry.getStride();\n\n    if (\n      textState.placement === TextPlacement.LINE &&\n      (geometryType == GeometryType.LINE_STRING ||\n        geometryType == GeometryType.MULTI_LINE_STRING ||\n        geometryType == GeometryType.POLYGON ||\n        geometryType == GeometryType.MULTI_POLYGON)\n    ) {\n      if (!intersects(this.getBufferedMaxExtent(), geometry.getExtent())) {\n        return;\n      }\n      let ends;\n      flatCoordinates = geometry.getFlatCoordinates();\n      if (geometryType == GeometryType.LINE_STRING) {\n        ends = [flatCoordinates.length];\n      } else if (geometryType == GeometryType.MULTI_LINE_STRING) {\n        ends = /** @type {import(\"../../geom/MultiLineString.js\").default} */ (geometry).getEnds();\n      } else if (geometryType == GeometryType.POLYGON) {\n        ends = /** @type {import(\"../../geom/Polygon.js\").default} */ (geometry)\n          .getEnds()\n          .slice(0, 1);\n      } else if (geometryType == GeometryType.MULTI_POLYGON) {\n        const endss = /** @type {import(\"../../geom/MultiPolygon.js\").default} */ (geometry).getEndss();\n        ends = [];\n        for (let i = 0, ii = endss.length; i < ii; ++i) {\n          ends.push(endss[i][0]);\n        }\n      }\n      this.beginGeometry(geometry, feature);\n      const textAlign = textState.textAlign;\n      let flatOffset = 0;\n      let flatEnd;\n      for (let o = 0, oo = ends.length; o < oo; ++o) {\n        if (textAlign == undefined) {\n          const range = matchingChunk(\n            textState.maxAngle,\n            flatCoordinates,\n            flatOffset,\n            ends[o],\n            stride\n          );\n          flatOffset = range[0];\n          flatEnd = range[1];\n        } else {\n          flatEnd = ends[o];\n        }\n        for (let i = flatOffset; i < flatEnd; i += stride) {\n          coordinates.push(flatCoordinates[i], flatCoordinates[i + 1]);\n        }\n        const end = coordinates.length;\n        flatOffset = ends[o];\n        this.drawChars_(begin, end);\n        begin = end;\n      }\n      this.endGeometry(feature);\n    } else {\n      const geometryWidths = textState.overflow ? null : [];\n      switch (geometryType) {\n        case GeometryType.POINT:\n        case GeometryType.MULTI_POINT:\n          flatCoordinates = /** @type {import(\"../../geom/MultiPoint.js\").default} */ (geometry).getFlatCoordinates();\n          break;\n        case GeometryType.LINE_STRING:\n          flatCoordinates = /** @type {import(\"../../geom/LineString.js\").default} */ (geometry).getFlatMidpoint();\n          break;\n        case GeometryType.CIRCLE:\n          flatCoordinates = /** @type {import(\"../../geom/Circle.js\").default} */ (geometry).getCenter();\n          break;\n        case GeometryType.MULTI_LINE_STRING:\n          flatCoordinates = /** @type {import(\"../../geom/MultiLineString.js\").default} */ (geometry).getFlatMidpoints();\n          stride = 2;\n          break;\n        case GeometryType.POLYGON:\n          flatCoordinates = /** @type {import(\"../../geom/Polygon.js\").default} */ (geometry).getFlatInteriorPoint();\n          if (!textState.overflow) {\n            geometryWidths.push(flatCoordinates[2] / this.resolution);\n          }\n          stride = 3;\n          break;\n        case GeometryType.MULTI_POLYGON:\n          const interiorPoints = /** @type {import(\"../../geom/MultiPolygon.js\").default} */ (geometry).getFlatInteriorPoints();\n          flatCoordinates = [];\n          for (let i = 0, ii = interiorPoints.length; i < ii; i += 3) {\n            if (!textState.overflow) {\n              geometryWidths.push(interiorPoints[i + 2] / this.resolution);\n            }\n            flatCoordinates.push(interiorPoints[i], interiorPoints[i + 1]);\n          }\n          if (flatCoordinates.length === 0) {\n            return;\n          }\n          stride = 2;\n          break;\n        default:\n      }\n      const end = this.appendFlatPointCoordinates(flatCoordinates, stride);\n      if (end === begin) {\n        return;\n      }\n\n      this.saveTextStates_();\n\n      if (textState.backgroundFill || textState.backgroundStroke) {\n        this.setFillStrokeStyle(\n          textState.backgroundFill,\n          textState.backgroundStroke\n        );\n        if (textState.backgroundFill) {\n          this.updateFillStyle(this.state, this.createFill);\n          this.hitDetectionInstructions.push(this.createFill(this.state));\n        }\n        if (textState.backgroundStroke) {\n          this.updateStrokeStyle(this.state, this.applyStroke);\n          this.hitDetectionInstructions.push(this.createStroke(this.state));\n        }\n      }\n\n      this.beginGeometry(geometry, feature);\n\n      // adjust padding for negative scale\n      let padding = textState.padding;\n      if (\n        padding != defaultPadding &&\n        (textState.scale[0] < 0 || textState.scale[1] < 0)\n      ) {\n        let p0 = textState.padding[0];\n        let p1 = textState.padding[1];\n        let p2 = textState.padding[2];\n        let p3 = textState.padding[3];\n        if (textState.scale[0] < 0) {\n          p1 = -p1;\n          p3 = -p3;\n        }\n        if (textState.scale[1] < 0) {\n          p0 = -p0;\n          p2 = -p2;\n        }\n        padding = [p0, p1, p2, p3];\n      }\n\n      // The image is unknown at this stage so we pass null; it will be computed at render time.\n      // For clarity, we pass NaN for offsetX, offsetY, width and height, which will be computed at\n      // render time.\n      const pixelRatio = this.pixelRatio;\n      this.instructions.push([\n        CanvasInstruction.DRAW_IMAGE,\n        begin,\n        end,\n        null,\n        NaN,\n        NaN,\n        NaN,\n        1,\n        0,\n        0,\n        this.textRotateWithView_,\n        this.textRotation_,\n        [1, 1],\n        NaN,\n        this.declutterImageWithText_,\n        padding == defaultPadding\n          ? defaultPadding\n          : padding.map(function (p) {\n              return p * pixelRatio;\n            }),\n        !!textState.backgroundFill,\n        !!textState.backgroundStroke,\n        this.text_,\n        this.textKey_,\n        this.strokeKey_,\n        this.fillKey_,\n        this.textOffsetX_,\n        this.textOffsetY_,\n        geometryWidths,\n      ]);\n      const scale = 1 / pixelRatio;\n      this.hitDetectionInstructions.push([\n        CanvasInstruction.DRAW_IMAGE,\n        begin,\n        end,\n        null,\n        NaN,\n        NaN,\n        NaN,\n        1,\n        0,\n        0,\n        this.textRotateWithView_,\n        this.textRotation_,\n        [scale, scale],\n        NaN,\n        this.declutterImageWithText_,\n        padding,\n        !!textState.backgroundFill,\n        !!textState.backgroundStroke,\n        this.text_,\n        this.textKey_,\n        this.strokeKey_,\n        this.fillKey_,\n        this.textOffsetX_,\n        this.textOffsetY_,\n        geometryWidths,\n      ]);\n\n      this.endGeometry(feature);\n    }\n  }\n\n  /**\n   * @private\n   */\n  saveTextStates_() {\n    const strokeState = this.textStrokeState_;\n    const textState = this.textState_;\n    const fillState = this.textFillState_;\n\n    const strokeKey = this.strokeKey_;\n    if (strokeState) {\n      if (!(strokeKey in this.strokeStates)) {\n        this.strokeStates[strokeKey] = {\n          strokeStyle: strokeState.strokeStyle,\n          lineCap: strokeState.lineCap,\n          lineDashOffset: strokeState.lineDashOffset,\n          lineWidth: strokeState.lineWidth,\n          lineJoin: strokeState.lineJoin,\n          miterLimit: strokeState.miterLimit,\n          lineDash: strokeState.lineDash,\n        };\n      }\n    }\n    const textKey = this.textKey_;\n    if (!(textKey in this.textStates)) {\n      this.textStates[textKey] = {\n        font: textState.font,\n        textAlign: textState.textAlign || defaultTextAlign,\n        textBaseline: textState.textBaseline || defaultTextBaseline,\n        scale: textState.scale,\n      };\n    }\n    const fillKey = this.fillKey_;\n    if (fillState) {\n      if (!(fillKey in this.fillStates)) {\n        this.fillStates[fillKey] = {\n          fillStyle: fillState.fillStyle,\n        };\n      }\n    }\n  }\n\n  /**\n   * @private\n   * @param {number} begin Begin.\n   * @param {number} end End.\n   */\n  drawChars_(begin, end) {\n    const strokeState = this.textStrokeState_;\n    const textState = this.textState_;\n\n    const strokeKey = this.strokeKey_;\n    const textKey = this.textKey_;\n    const fillKey = this.fillKey_;\n    this.saveTextStates_();\n\n    const pixelRatio = this.pixelRatio;\n    const baseline = TEXT_ALIGN[textState.textBaseline];\n\n    const offsetY = this.textOffsetY_ * pixelRatio;\n    const text = this.text_;\n    const strokeWidth = strokeState\n      ? (strokeState.lineWidth * Math.abs(textState.scale[0])) / 2\n      : 0;\n\n    this.instructions.push([\n      CanvasInstruction.DRAW_CHARS,\n      begin,\n      end,\n      baseline,\n      textState.overflow,\n      fillKey,\n      textState.maxAngle,\n      pixelRatio,\n      offsetY,\n      strokeKey,\n      strokeWidth * pixelRatio,\n      text,\n      textKey,\n      1,\n    ]);\n    this.hitDetectionInstructions.push([\n      CanvasInstruction.DRAW_CHARS,\n      begin,\n      end,\n      baseline,\n      textState.overflow,\n      fillKey,\n      textState.maxAngle,\n      1,\n      offsetY,\n      strokeKey,\n      strokeWidth,\n      text,\n      textKey,\n      1 / pixelRatio,\n    ]);\n  }\n\n  /**\n   * @param {import(\"../../style/Text.js\").default} textStyle Text style.\n   * @param {Object=} opt_sharedData Shared data.\n   */\n  setTextStyle(textStyle, opt_sharedData) {\n    let textState, fillState, strokeState;\n    if (!textStyle) {\n      this.text_ = '';\n    } else {\n      const textFillStyle = textStyle.getFill();\n      if (!textFillStyle) {\n        fillState = null;\n        this.textFillState_ = fillState;\n      } else {\n        fillState = this.textFillState_;\n        if (!fillState) {\n          fillState = /** @type {import(\"../canvas.js\").FillState} */ ({});\n          this.textFillState_ = fillState;\n        }\n        fillState.fillStyle = asColorLike(\n          textFillStyle.getColor() || defaultFillStyle\n        );\n      }\n\n      const textStrokeStyle = textStyle.getStroke();\n      if (!textStrokeStyle) {\n        strokeState = null;\n        this.textStrokeState_ = strokeState;\n      } else {\n        strokeState = this.textStrokeState_;\n        if (!strokeState) {\n          strokeState = /** @type {import(\"../canvas.js\").StrokeState} */ ({});\n          this.textStrokeState_ = strokeState;\n        }\n        const lineDash = textStrokeStyle.getLineDash();\n        const lineDashOffset = textStrokeStyle.getLineDashOffset();\n        const lineWidth = textStrokeStyle.getWidth();\n        const miterLimit = textStrokeStyle.getMiterLimit();\n        strokeState.lineCap = textStrokeStyle.getLineCap() || defaultLineCap;\n        strokeState.lineDash = lineDash ? lineDash.slice() : defaultLineDash;\n        strokeState.lineDashOffset =\n          lineDashOffset === undefined ? defaultLineDashOffset : lineDashOffset;\n        strokeState.lineJoin = textStrokeStyle.getLineJoin() || defaultLineJoin;\n        strokeState.lineWidth =\n          lineWidth === undefined ? defaultLineWidth : lineWidth;\n        strokeState.miterLimit =\n          miterLimit === undefined ? defaultMiterLimit : miterLimit;\n        strokeState.strokeStyle = asColorLike(\n          textStrokeStyle.getColor() || defaultStrokeStyle\n        );\n      }\n\n      textState = this.textState_;\n      const font = textStyle.getFont() || defaultFont;\n      registerFont(font);\n      const textScale = textStyle.getScaleArray();\n      textState.overflow = textStyle.getOverflow();\n      textState.font = font;\n      textState.maxAngle = textStyle.getMaxAngle();\n      textState.placement = textStyle.getPlacement();\n      textState.textAlign = textStyle.getTextAlign();\n      textState.textBaseline =\n        textStyle.getTextBaseline() || defaultTextBaseline;\n      textState.backgroundFill = textStyle.getBackgroundFill();\n      textState.backgroundStroke = textStyle.getBackgroundStroke();\n      textState.padding = textStyle.getPadding() || defaultPadding;\n      textState.scale = textScale === undefined ? [1, 1] : textScale;\n\n      const textOffsetX = textStyle.getOffsetX();\n      const textOffsetY = textStyle.getOffsetY();\n      const textRotateWithView = textStyle.getRotateWithView();\n      const textRotation = textStyle.getRotation();\n      this.text_ = textStyle.getText() || '';\n      this.textOffsetX_ = textOffsetX === undefined ? 0 : textOffsetX;\n      this.textOffsetY_ = textOffsetY === undefined ? 0 : textOffsetY;\n      this.textRotateWithView_ =\n        textRotateWithView === undefined ? false : textRotateWithView;\n      this.textRotation_ = textRotation === undefined ? 0 : textRotation;\n\n      this.strokeKey_ = strokeState\n        ? (typeof strokeState.strokeStyle == 'string'\n            ? strokeState.strokeStyle\n            : getUid(strokeState.strokeStyle)) +\n          strokeState.lineCap +\n          strokeState.lineDashOffset +\n          '|' +\n          strokeState.lineWidth +\n          strokeState.lineJoin +\n          strokeState.miterLimit +\n          '[' +\n          strokeState.lineDash.join() +\n          ']'\n        : '';\n      this.textKey_ =\n        textState.font +\n        textState.scale +\n        (textState.textAlign || '?') +\n        (textState.textBaseline || '?');\n      this.fillKey_ = fillState\n        ? typeof fillState.fillStyle == 'string'\n          ? fillState.fillStyle\n          : '|' + getUid(fillState.fillStyle)\n        : '';\n    }\n    this.declutterImageWithText_ = opt_sharedData;\n  }\n}\n\nexport default CanvasTextBuilder;\n","/**\n * @module ol/render/canvas/BuilderGroup\n */\n\nimport Builder from './Builder.js';\nimport ImageBuilder from './ImageBuilder.js';\nimport LineStringBuilder from './LineStringBuilder.js';\nimport PolygonBuilder from './PolygonBuilder.js';\nimport TextBuilder from './TextBuilder.js';\n\n/**\n * @type {Object<import(\"./BuilderType\").default, typeof Builder>}\n */\nconst BATCH_CONSTRUCTORS = {\n  'Circle': PolygonBuilder,\n  'Default': Builder,\n  'Image': ImageBuilder,\n  'LineString': LineStringBuilder,\n  'Polygon': PolygonBuilder,\n  'Text': TextBuilder,\n};\n\nclass BuilderGroup {\n  /**\n   * @param {number} tolerance Tolerance.\n   * @param {import(\"../../extent.js\").Extent} maxExtent Max extent.\n   * @param {number} resolution Resolution.\n   * @param {number} pixelRatio Pixel ratio.\n   */\n  constructor(tolerance, maxExtent, resolution, pixelRatio) {\n    /**\n     * @private\n     * @type {number}\n     */\n    this.tolerance_ = tolerance;\n\n    /**\n     * @private\n     * @type {import(\"../../extent.js\").Extent}\n     */\n    this.maxExtent_ = maxExtent;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.pixelRatio_ = pixelRatio;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.resolution_ = resolution;\n\n    /**\n     * @private\n     * @type {!Object<string, !Object<import(\"./BuilderType\").default, Builder>>}\n     */\n    this.buildersByZIndex_ = {};\n  }\n\n  /**\n   * @return {!Object<string, !Object<import(\"./BuilderType\").default, import(\"./Builder.js\").SerializableInstructions>>} The serializable instructions\n   */\n  finish() {\n    const builderInstructions = {};\n    for (const zKey in this.buildersByZIndex_) {\n      builderInstructions[zKey] = builderInstructions[zKey] || {};\n      const builders = this.buildersByZIndex_[zKey];\n      for (const builderKey in builders) {\n        const builderInstruction = builders[builderKey].finish();\n        builderInstructions[zKey][builderKey] = builderInstruction;\n      }\n    }\n    return builderInstructions;\n  }\n\n  /**\n   * @param {number|undefined} zIndex Z index.\n   * @param {import(\"./BuilderType.js\").default} builderType Replay type.\n   * @return {import(\"../VectorContext.js\").default} Replay.\n   */\n  getBuilder(zIndex, builderType) {\n    const zIndexKey = zIndex !== undefined ? zIndex.toString() : '0';\n    let replays = this.buildersByZIndex_[zIndexKey];\n    if (replays === undefined) {\n      replays = {};\n      this.buildersByZIndex_[zIndexKey] = replays;\n    }\n    let replay = replays[builderType];\n    if (replay === undefined) {\n      const Constructor = BATCH_CONSTRUCTORS[builderType];\n      replay = new Constructor(\n        this.tolerance_,\n        this.maxExtent_,\n        this.resolution_,\n        this.pixelRatio_\n      );\n      replays[builderType] = replay;\n    }\n    return replay;\n  }\n}\n\nexport default BuilderGroup;\n","/**\n * @module ol/render/canvas/BuilderType\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  CIRCLE: 'Circle',\n  DEFAULT: 'Default',\n  IMAGE: 'Image',\n  LINE_STRING: 'LineString',\n  POLYGON: 'Polygon',\n  TEXT: 'Text',\n};\n","/**\n * @module ol/geom/flat/textpath\n */\nimport {lerp} from '../../math.js';\nimport {rotate} from './transform.js';\n\n/**\n * @param {Array<number>} flatCoordinates Path to put text on.\n * @param {number} offset Start offset of the `flatCoordinates`.\n * @param {number} end End offset of the `flatCoordinates`.\n * @param {number} stride Stride.\n * @param {string} text Text to place on the path.\n * @param {number} startM m along the path where the text starts.\n * @param {number} maxAngle Max angle between adjacent chars in radians.\n * @param {number} scale The product of the text scale and the device pixel ratio.\n * @param {function(string, string, Object<string, number>):number} measureAndCacheTextWidth Measure and cache text width.\n * @param {string} font The font.\n * @param {Object<string, number>} cache A cache of measured widths.\n * @param {number} rotation Rotation to apply to the flatCoordinates to determine whether text needs to be reversed.\n * @return {Array<Array<*>>} The result array (or null if `maxAngle` was\n * exceeded). Entries of the array are x, y, anchorX, angle, chunk.\n */\nexport function drawTextOnPath(\n  flatCoordinates,\n  offset,\n  end,\n  stride,\n  text,\n  startM,\n  maxAngle,\n  scale,\n  measureAndCacheTextWidth,\n  font,\n  cache,\n  rotation\n) {\n  let x2 = flatCoordinates[offset];\n  let y2 = flatCoordinates[offset + 1];\n  let x1 = 0;\n  let y1 = 0;\n  let segmentLength = 0;\n  let segmentM = 0;\n\n  function advance() {\n    x1 = x2;\n    y1 = y2;\n    offset += stride;\n    x2 = flatCoordinates[offset];\n    y2 = flatCoordinates[offset + 1];\n    segmentM += segmentLength;\n    segmentLength = Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));\n  }\n  do {\n    advance();\n  } while (offset < end - stride && segmentM + segmentLength < startM);\n\n  let interpolate = (startM - segmentM) / segmentLength;\n  const beginX = lerp(x1, x2, interpolate);\n  const beginY = lerp(y1, y2, interpolate);\n\n  const startOffset = offset - stride;\n  const startLength = segmentM;\n  const endM = startM + scale * measureAndCacheTextWidth(font, text, cache);\n  while (offset < end - stride && segmentM + segmentLength < endM) {\n    advance();\n  }\n  interpolate = (endM - segmentM) / segmentLength;\n  const endX = lerp(x1, x2, interpolate);\n  const endY = lerp(y1, y2, interpolate);\n\n  // Keep text upright\n  let reverse;\n  if (rotation) {\n    const flat = [beginX, beginY, endX, endY];\n    rotate(flat, 0, 4, 2, rotation, flat, flat);\n    reverse = flat[0] > flat[2];\n  } else {\n    reverse = beginX > endX;\n  }\n\n  const PI = Math.PI;\n  const result = [];\n  const singleSegment = startOffset + stride === offset;\n\n  offset = startOffset;\n  segmentLength = 0;\n  segmentM = startLength;\n  x2 = flatCoordinates[offset];\n  y2 = flatCoordinates[offset + 1];\n\n  // All on the same segment\n  if (singleSegment) {\n    advance();\n\n    let previousAngle = Math.atan2(y2 - y1, x2 - x1);\n    if (reverse) {\n      previousAngle += previousAngle > 0 ? -PI : PI;\n    }\n    const x = (endX + beginX) / 2;\n    const y = (endY + beginY) / 2;\n    result[0] = [x, y, (endM - startM) / 2, previousAngle, text];\n    return result;\n  }\n\n  let previousAngle;\n  for (let i = 0, ii = text.length; i < ii; ) {\n    advance();\n    let angle = Math.atan2(y2 - y1, x2 - x1);\n    if (reverse) {\n      angle += angle > 0 ? -PI : PI;\n    }\n    if (previousAngle !== undefined) {\n      let delta = angle - previousAngle;\n      delta += delta > PI ? -2 * PI : delta < -PI ? 2 * PI : 0;\n      if (Math.abs(delta) > maxAngle) {\n        return null;\n      }\n    }\n    previousAngle = angle;\n\n    const iStart = i;\n    let charLength = 0;\n    for (; i < ii; ++i) {\n      const index = reverse ? ii - i - 1 : i;\n      const len = scale * measureAndCacheTextWidth(font, text[index], cache);\n      if (\n        offset + stride < end &&\n        segmentM + segmentLength < startM + charLength + len / 2\n      ) {\n        break;\n      }\n      charLength += len;\n    }\n    if (i === iStart) {\n      continue;\n    }\n    const chars = reverse\n      ? text.substring(ii - iStart, ii - i)\n      : text.substring(iStart, i);\n    interpolate = (startM + charLength / 2 - segmentM) / segmentLength;\n    const x = lerp(x1, x2, interpolate);\n    const y = lerp(y1, y2, interpolate);\n    result.push([x, y, charLength / 2, angle, chars]);\n    startM += charLength;\n  }\n  return result;\n}\n","/**\n * @module ol/geom/flat/length\n */\n\n/**\n * @param {Array<number>} flatCoordinates Flat coordinates.\n * @param {number} offset Offset.\n * @param {number} end End.\n * @param {number} stride Stride.\n * @return {number} Length.\n */\nexport function lineStringLength(flatCoordinates, offset, end, stride) {\n  let x1 = flatCoordinates[offset];\n  let y1 = flatCoordinates[offset + 1];\n  let length = 0;\n  for (let i = offset + stride; i < end; i += stride) {\n    const x2 = flatCoordinates[i];\n    const 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/**\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  let perimeter = lineStringLength(flatCoordinates, offset, end, stride);\n  const dx = flatCoordinates[end - stride] - flatCoordinates[offset];\n  const dy = flatCoordinates[end - stride + 1] - flatCoordinates[offset + 1];\n  perimeter += Math.sqrt(dx * dx + dy * dy);\n  return perimeter;\n}\n","/**\n * @module ol/render/canvas/Executor\n */\nimport CanvasInstruction from './Instruction.js';\nimport {TEXT_ALIGN} from './TextBuilder.js';\nimport {WORKER_OFFSCREEN_CANVAS} from '../../has.js';\nimport {\n  apply as applyTransform,\n  compose as composeTransform,\n  create as createTransform,\n  setFromArray as transformSetFromArray,\n} from '../../transform.js';\nimport {createEmpty, createOrUpdate, intersects} from '../../extent.js';\nimport {\n  defaultPadding,\n  defaultTextBaseline,\n  drawImageOrLabel,\n} from '../canvas.js';\nimport {\n  defaultTextAlign,\n  measureAndCacheTextWidth,\n  measureTextHeight,\n  measureTextWidths,\n} from '../canvas.js';\nimport {drawTextOnPath} from '../../geom/flat/textpath.js';\nimport {equals} from '../../array.js';\nimport {lineStringLength} from '../../geom/flat/length.js';\nimport {transform2D} from '../../geom/flat/transform.js';\n\n/**\n * @typedef {Object} BBox\n * @property {number} minX\n * @property {number} minY\n * @property {number} maxX\n * @property {number} maxY\n * @property {*} value\n */\n\n/**\n * @typedef {Object} ImageOrLabelDimensions\n * @property {number} drawImageX\n * @property {number} drawImageY\n * @property {number} drawImageW\n * @property {number} drawImageH\n * @property {number} originX\n * @property {number} originY\n * @property {Array<number>} scale\n * @property {BBox} declutterBox\n * @property {import(\"../../transform.js\").Transform} canvasTransform\n */\n\n/**\n * @typedef {{0: CanvasRenderingContext2D, 1: number, 2: import(\"../canvas.js\").Label|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement, 3: ImageOrLabelDimensions, 4: number, 5: Array<*>, 6: Array<*>}} ReplayImageOrLabelArgs\n */\n\n/**\n * @template T\n * @typedef {function(import(\"../../Feature.js\").FeatureLike, import(\"../../geom/SimpleGeometry.js\").default): T} FeatureCallback\n */\n\n/**\n * @type {import(\"../../extent.js\").Extent}\n */\nconst tmpExtent = createEmpty();\n\n/** @type {import(\"../../coordinate.js\").Coordinate} */\nconst p1 = [];\n/** @type {import(\"../../coordinate.js\").Coordinate} */\nconst p2 = [];\n/** @type {import(\"../../coordinate.js\").Coordinate} */\nconst p3 = [];\n/** @type {import(\"../../coordinate.js\").Coordinate} */\nconst p4 = [];\n\n/**\n * @param {ReplayImageOrLabelArgs} replayImageOrLabelArgs Arguments to replayImageOrLabel\n * @return {BBox} Declutter bbox.\n */\nfunction getDeclutterBox(replayImageOrLabelArgs) {\n  return replayImageOrLabelArgs[3].declutterBox;\n}\n\nconst rtlRegEx = new RegExp(\n  /* eslint-disable prettier/prettier */\n  '[' +\n    String.fromCharCode(0x00591) + '-' + String.fromCharCode(0x008ff) +\n    String.fromCharCode(0x0fb1d) + '-' + String.fromCharCode(0x0fdff) +\n    String.fromCharCode(0x0fe70) + '-' + String.fromCharCode(0x0fefc) +\n    String.fromCharCode(0x10800) + '-' + String.fromCharCode(0x10fff) +\n    String.fromCharCode(0x1e800) + '-' + String.fromCharCode(0x1efff) +\n  ']'\n  /* eslint-enable prettier/prettier */\n);\n\n/**\n * @param {string} text Text.\n * @param {string} align Alignment.\n * @return {number} Text alignment.\n */\nfunction horizontalTextAlign(text, align) {\n  if ((align === 'start' || align === 'end') && !rtlRegEx.test(text)) {\n    align = align === 'start' ? 'left' : 'right';\n  }\n  return TEXT_ALIGN[align];\n}\n\nclass Executor {\n  /**\n   * @param {number} resolution Resolution.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {boolean} overlaps The replay can have overlapping geometries.\n   * @param {import(\"../canvas.js\").SerializableInstructions} instructions The serializable instructions\n   * @param {import(\"../../size.js\").Size} renderBuffer Render buffer (width/height) in pixels.\n   */\n  constructor(resolution, pixelRatio, overlaps, instructions, renderBuffer) {\n    /**\n     * @protected\n     * @type {boolean}\n     */\n    this.overlaps = overlaps;\n\n    /**\n     * @protected\n     * @type {number}\n     */\n    this.pixelRatio = pixelRatio;\n\n    /**\n     * @protected\n     * @const\n     * @type {number}\n     */\n    this.resolution = resolution;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.alignFill_;\n\n    /**\n     * @protected\n     * @type {Array<*>}\n     */\n    this.instructions = instructions.instructions;\n\n    /**\n     * @protected\n     * @type {Array<number>}\n     */\n    this.coordinates = instructions.coordinates;\n\n    /**\n     * @private\n     * @type {!Object<number,import(\"../../coordinate.js\").Coordinate|Array<import(\"../../coordinate.js\").Coordinate>|Array<Array<import(\"../../coordinate.js\").Coordinate>>>}\n     */\n    this.coordinateCache_ = {};\n\n    /**\n     * @private\n     * @type {import(\"../../size.js\").Size}\n     */\n    this.renderBuffer_ = renderBuffer;\n\n    /**\n     * @private\n     * @type {!import(\"../../transform.js\").Transform}\n     */\n    this.renderedTransform_ = createTransform();\n\n    /**\n     * @protected\n     * @type {Array<*>}\n     */\n    this.hitDetectionInstructions = instructions.hitDetectionInstructions;\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.pixelCoordinates_ = null;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.viewRotation_ = 0;\n\n    /**\n     * @type {!Object<string, import(\"../canvas.js\").FillState>}\n     */\n    this.fillStates = instructions.fillStates || {};\n\n    /**\n     * @type {!Object<string, import(\"../canvas.js\").StrokeState>}\n     */\n    this.strokeStates = instructions.strokeStates || {};\n\n    /**\n     * @type {!Object<string, import(\"../canvas.js\").TextState>}\n     */\n    this.textStates = instructions.textStates || {};\n\n    /**\n     * @private\n     * @type {Object<string, Object<string, number>>}\n     */\n    this.widths_ = {};\n\n    /**\n     * @private\n     * @type {Object<string, import(\"../canvas.js\").Label>}\n     */\n    this.labels_ = {};\n  }\n\n  /**\n   * @param {string} text Text.\n   * @param {string} textKey Text style key.\n   * @param {string} fillKey Fill style key.\n   * @param {string} strokeKey Stroke style key.\n   * @return {import(\"../canvas.js\").Label} Label.\n   */\n  createLabel(text, textKey, fillKey, strokeKey) {\n    const key = text + textKey + fillKey + strokeKey;\n    if (this.labels_[key]) {\n      return this.labels_[key];\n    }\n    const strokeState = strokeKey ? this.strokeStates[strokeKey] : null;\n    const fillState = fillKey ? this.fillStates[fillKey] : null;\n    const textState = this.textStates[textKey];\n    const pixelRatio = this.pixelRatio;\n    const scale = [\n      textState.scale[0] * pixelRatio,\n      textState.scale[1] * pixelRatio,\n    ];\n    const align = horizontalTextAlign(\n      text,\n      textState.textAlign || defaultTextAlign\n    );\n    const strokeWidth =\n      strokeKey && strokeState.lineWidth ? strokeState.lineWidth : 0;\n\n    const lines = text.split('\\n');\n    const numLines = lines.length;\n    const widths = [];\n    const width = measureTextWidths(textState.font, lines, widths);\n    const lineHeight = measureTextHeight(textState.font);\n    const height = lineHeight * numLines;\n    const renderWidth = width + strokeWidth;\n    const contextInstructions = [];\n    // make canvas 2 pixels wider to account for italic text width measurement errors\n    const w = (renderWidth + 2) * scale[0];\n    const h = (height + strokeWidth) * scale[1];\n    /** @type {import(\"../canvas.js\").Label} */\n    const label = {\n      width: w < 0 ? Math.floor(w) : Math.ceil(w),\n      height: h < 0 ? Math.floor(h) : Math.ceil(h),\n      contextInstructions: contextInstructions,\n    };\n    if (scale[0] != 1 || scale[1] != 1) {\n      contextInstructions.push('scale', scale);\n    }\n    contextInstructions.push('font', textState.font);\n    if (strokeKey) {\n      contextInstructions.push('strokeStyle', strokeState.strokeStyle);\n      contextInstructions.push('lineWidth', strokeWidth);\n      contextInstructions.push('lineCap', strokeState.lineCap);\n      contextInstructions.push('lineJoin', strokeState.lineJoin);\n      contextInstructions.push('miterLimit', strokeState.miterLimit);\n      // eslint-disable-next-line\n      const Context = WORKER_OFFSCREEN_CANVAS ? OffscreenCanvasRenderingContext2D : CanvasRenderingContext2D;\n      if (Context.prototype.setLineDash) {\n        contextInstructions.push('setLineDash', [strokeState.lineDash]);\n        contextInstructions.push('lineDashOffset', strokeState.lineDashOffset);\n      }\n    }\n    if (fillKey) {\n      contextInstructions.push('fillStyle', fillState.fillStyle);\n    }\n    contextInstructions.push('textBaseline', 'middle');\n    contextInstructions.push('textAlign', 'center');\n    const leftRight = 0.5 - align;\n    const x = align * renderWidth + leftRight * strokeWidth;\n    let i;\n    if (strokeKey) {\n      for (i = 0; i < numLines; ++i) {\n        contextInstructions.push('strokeText', [\n          lines[i],\n          x + leftRight * widths[i],\n          0.5 * (strokeWidth + lineHeight) + i * lineHeight,\n        ]);\n      }\n    }\n    if (fillKey) {\n      for (i = 0; i < numLines; ++i) {\n        contextInstructions.push('fillText', [\n          lines[i],\n          x + leftRight * widths[i],\n          0.5 * (strokeWidth + lineHeight) + i * lineHeight,\n        ]);\n      }\n    }\n    this.labels_[key] = label;\n    return label;\n  }\n\n  /**\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {import(\"../../coordinate.js\").Coordinate} p1 1st point of the background box.\n   * @param {import(\"../../coordinate.js\").Coordinate} p2 2nd point of the background box.\n   * @param {import(\"../../coordinate.js\").Coordinate} p3 3rd point of the background box.\n   * @param {import(\"../../coordinate.js\").Coordinate} p4 4th point of the background box.\n   * @param {Array<*>} fillInstruction Fill instruction.\n   * @param {Array<*>} strokeInstruction Stroke instruction.\n   */\n  replayTextBackground_(\n    context,\n    p1,\n    p2,\n    p3,\n    p4,\n    fillInstruction,\n    strokeInstruction\n  ) {\n    context.beginPath();\n    context.moveTo.apply(context, p1);\n    context.lineTo.apply(context, p2);\n    context.lineTo.apply(context, p3);\n    context.lineTo.apply(context, p4);\n    context.lineTo.apply(context, p1);\n    if (fillInstruction) {\n      this.alignFill_ = /** @type {boolean} */ (fillInstruction[2]);\n      this.fill_(context);\n    }\n    if (strokeInstruction) {\n      this.setStrokeStyle_(\n        context,\n        /** @type {Array<*>} */ (strokeInstruction)\n      );\n      context.stroke();\n    }\n  }\n\n  /**\n   * @private\n   * @param {number} sheetWidth Width of the sprite sheet.\n   * @param {number} sheetHeight Height of the sprite sheet.\n   * @param {number} centerX X.\n   * @param {number} centerY Y.\n   * @param {number} width Width.\n   * @param {number} height Height.\n   * @param {number} anchorX Anchor X.\n   * @param {number} anchorY Anchor Y.\n   * @param {number} originX Origin X.\n   * @param {number} originY Origin Y.\n   * @param {number} rotation Rotation.\n   * @param {import(\"../../size.js\").Size} scale Scale.\n   * @param {boolean} snapToPixel Snap to pixel.\n   * @param {Array<number>} padding Padding.\n   * @param {boolean} fillStroke Background fill or stroke.\n   * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n   * @return {ImageOrLabelDimensions} Dimensions for positioning and decluttering the image or label.\n   */\n  calculateImageOrLabelDimensions_(\n    sheetWidth,\n    sheetHeight,\n    centerX,\n    centerY,\n    width,\n    height,\n    anchorX,\n    anchorY,\n    originX,\n    originY,\n    rotation,\n    scale,\n    snapToPixel,\n    padding,\n    fillStroke,\n    feature\n  ) {\n    anchorX *= scale[0];\n    anchorY *= scale[1];\n    let x = centerX - anchorX;\n    let y = centerY - anchorY;\n\n    const w = width + originX > sheetWidth ? sheetWidth - originX : width;\n    const h = height + originY > sheetHeight ? sheetHeight - originY : height;\n    const boxW = padding[3] + w * scale[0] + padding[1];\n    const boxH = padding[0] + h * scale[1] + padding[2];\n    const boxX = x - padding[3];\n    const boxY = y - padding[0];\n\n    if (fillStroke || rotation !== 0) {\n      p1[0] = boxX;\n      p4[0] = boxX;\n      p1[1] = boxY;\n      p2[1] = boxY;\n      p2[0] = boxX + boxW;\n      p3[0] = p2[0];\n      p3[1] = boxY + boxH;\n      p4[1] = p3[1];\n    }\n\n    let transform;\n    if (rotation !== 0) {\n      transform = composeTransform(\n        createTransform(),\n        centerX,\n        centerY,\n        1,\n        1,\n        rotation,\n        -centerX,\n        -centerY\n      );\n\n      applyTransform(transform, p1);\n      applyTransform(transform, p2);\n      applyTransform(transform, p3);\n      applyTransform(transform, p4);\n      createOrUpdate(\n        Math.min(p1[0], p2[0], p3[0], p4[0]),\n        Math.min(p1[1], p2[1], p3[1], p4[1]),\n        Math.max(p1[0], p2[0], p3[0], p4[0]),\n        Math.max(p1[1], p2[1], p3[1], p4[1]),\n        tmpExtent\n      );\n    } else {\n      createOrUpdate(\n        Math.min(boxX, boxX + boxW),\n        Math.min(boxY, boxY + boxH),\n        Math.max(boxX, boxX + boxW),\n        Math.max(boxY, boxY + boxH),\n        tmpExtent\n      );\n    }\n    if (snapToPixel) {\n      x = Math.round(x);\n      y = Math.round(y);\n    }\n    return {\n      drawImageX: x,\n      drawImageY: y,\n      drawImageW: w,\n      drawImageH: h,\n      originX: originX,\n      originY: originY,\n      declutterBox: {\n        minX: tmpExtent[0],\n        minY: tmpExtent[1],\n        maxX: tmpExtent[2],\n        maxY: tmpExtent[3],\n        value: feature,\n      },\n      canvasTransform: transform,\n      scale: scale,\n    };\n  }\n\n  /**\n   * @private\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {number} contextScale Scale of the context.\n   * @param {import(\"../canvas.js\").Label|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement} imageOrLabel Image.\n   * @param {ImageOrLabelDimensions} dimensions Dimensions.\n   * @param {number} opacity Opacity.\n   * @param {Array<*>} fillInstruction Fill instruction.\n   * @param {Array<*>} strokeInstruction Stroke instruction.\n   * @return {boolean} The image or label was rendered.\n   */\n  replayImageOrLabel_(\n    context,\n    contextScale,\n    imageOrLabel,\n    dimensions,\n    opacity,\n    fillInstruction,\n    strokeInstruction\n  ) {\n    const fillStroke = !!(fillInstruction || strokeInstruction);\n\n    const box = dimensions.declutterBox;\n    const canvas = context.canvas;\n    const strokePadding = strokeInstruction\n      ? (strokeInstruction[2] * dimensions.scale[0]) / 2\n      : 0;\n    const intersects =\n      box.minX - strokePadding <= canvas.width / contextScale &&\n      box.maxX + strokePadding >= 0 &&\n      box.minY - strokePadding <= canvas.height / contextScale &&\n      box.maxY + strokePadding >= 0;\n\n    if (intersects) {\n      if (fillStroke) {\n        this.replayTextBackground_(\n          context,\n          p1,\n          p2,\n          p3,\n          p4,\n          /** @type {Array<*>} */ (fillInstruction),\n          /** @type {Array<*>} */ (strokeInstruction)\n        );\n      }\n      drawImageOrLabel(\n        context,\n        dimensions.canvasTransform,\n        opacity,\n        imageOrLabel,\n        dimensions.originX,\n        dimensions.originY,\n        dimensions.drawImageW,\n        dimensions.drawImageH,\n        dimensions.drawImageX,\n        dimensions.drawImageY,\n        dimensions.scale\n      );\n    }\n    return true;\n  }\n\n  /**\n   * @private\n   * @param {CanvasRenderingContext2D} context Context.\n   */\n  fill_(context) {\n    if (this.alignFill_) {\n      const origin = applyTransform(this.renderedTransform_, [0, 0]);\n      const repeatSize = 512 * this.pixelRatio;\n      context.save();\n      context.translate(origin[0] % repeatSize, origin[1] % repeatSize);\n      context.rotate(this.viewRotation_);\n    }\n    context.fill();\n    if (this.alignFill_) {\n      context.restore();\n    }\n  }\n\n  /**\n   * @private\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {Array<*>} instruction Instruction.\n   */\n  setStrokeStyle_(context, instruction) {\n    context[\n      'strokeStyle'\n    ] = /** @type {import(\"../../colorlike.js\").ColorLike} */ (instruction[1]);\n    context.lineWidth = /** @type {number} */ (instruction[2]);\n    context.lineCap = /** @type {CanvasLineCap} */ (instruction[3]);\n    context.lineJoin = /** @type {CanvasLineJoin} */ (instruction[4]);\n    context.miterLimit = /** @type {number} */ (instruction[5]);\n    if (context.setLineDash) {\n      context.lineDashOffset = /** @type {number} */ (instruction[7]);\n      context.setLineDash(/** @type {Array<number>} */ (instruction[6]));\n    }\n  }\n\n  /**\n   * @private\n   * @param {string} text The text to draw.\n   * @param {string} textKey The key of the text state.\n   * @param {string} strokeKey The key for the stroke state.\n   * @param {string} fillKey The key for the fill state.\n   * @return {{label: import(\"../canvas.js\").Label, anchorX: number, anchorY: number}} The text image and its anchor.\n   */\n  drawLabelWithPointPlacement_(text, textKey, strokeKey, fillKey) {\n    const textState = this.textStates[textKey];\n\n    const label = this.createLabel(text, textKey, fillKey, strokeKey);\n\n    const strokeState = this.strokeStates[strokeKey];\n    const pixelRatio = this.pixelRatio;\n    const align = horizontalTextAlign(\n      text,\n      textState.textAlign || defaultTextAlign\n    );\n    const baseline = TEXT_ALIGN[textState.textBaseline || defaultTextBaseline];\n    const strokeWidth =\n      strokeState && strokeState.lineWidth ? strokeState.lineWidth : 0;\n\n    // Remove the 2 pixels we added in createLabel() for the anchor\n    const width = label.width / pixelRatio - 2 * textState.scale[0];\n    const anchorX = align * width + 2 * (0.5 - align) * strokeWidth;\n    const anchorY =\n      (baseline * label.height) / pixelRatio +\n      2 * (0.5 - baseline) * strokeWidth;\n\n    return {\n      label: label,\n      anchorX: anchorX,\n      anchorY: anchorY,\n    };\n  }\n\n  /**\n   * @private\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {number} contextScale Scale of the context.\n   * @param {import(\"../../transform.js\").Transform} transform Transform.\n   * @param {Array<*>} instructions Instructions array.\n   * @param {boolean} snapToPixel Snap point symbols and text to integer pixels.\n   * @param {FeatureCallback<T>=} opt_featureCallback Feature callback.\n   * @param {import(\"../../extent.js\").Extent=} opt_hitExtent Only check\n   *     features that intersect this extent.\n   * @param {import(\"rbush\").default=} opt_declutterTree Declutter tree.\n   * @return {T|undefined} Callback result.\n   * @template T\n   */\n  execute_(\n    context,\n    contextScale,\n    transform,\n    instructions,\n    snapToPixel,\n    opt_featureCallback,\n    opt_hitExtent,\n    opt_declutterTree\n  ) {\n    /** @type {Array<number>} */\n    let pixelCoordinates;\n    if (this.pixelCoordinates_ && equals(transform, this.renderedTransform_)) {\n      pixelCoordinates = this.pixelCoordinates_;\n    } else {\n      if (!this.pixelCoordinates_) {\n        this.pixelCoordinates_ = [];\n      }\n      pixelCoordinates = transform2D(\n        this.coordinates,\n        0,\n        this.coordinates.length,\n        2,\n        transform,\n        this.pixelCoordinates_\n      );\n      transformSetFromArray(this.renderedTransform_, transform);\n    }\n    let i = 0; // instruction index\n    const ii = instructions.length; // end of instructions\n    let d = 0; // data index\n    let dd; // end of per-instruction data\n    let anchorX,\n      anchorY,\n      prevX,\n      prevY,\n      roundX,\n      roundY,\n      image,\n      text,\n      textKey,\n      strokeKey,\n      fillKey;\n    let pendingFill = 0;\n    let pendingStroke = 0;\n    let lastFillInstruction = null;\n    let lastStrokeInstruction = null;\n    const coordinateCache = this.coordinateCache_;\n    const viewRotation = this.viewRotation_;\n    const viewRotationFromTransform =\n      Math.round(Math.atan2(-transform[1], transform[0]) * 1e12) / 1e12;\n\n    const state = /** @type {import(\"../../render.js\").State} */ ({\n      context: context,\n      pixelRatio: this.pixelRatio,\n      resolution: this.resolution,\n      rotation: viewRotation,\n    });\n\n    // When the batch size gets too big, performance decreases. 200 is a good\n    // balance between batch size and number of fill/stroke instructions.\n    const batchSize =\n      this.instructions != instructions || this.overlaps ? 0 : 200;\n    let /** @type {import(\"../../Feature.js\").FeatureLike} */ feature;\n    let x, y, currentGeometry;\n    while (i < ii) {\n      const instruction = instructions[i];\n      const type = /** @type {import(\"./Instruction.js\").default} */ (instruction[0]);\n      switch (type) {\n        case CanvasInstruction.BEGIN_GEOMETRY:\n          feature = /** @type {import(\"../../Feature.js\").FeatureLike} */ (instruction[1]);\n          currentGeometry = instruction[3];\n          if (!feature.getGeometry()) {\n            i = /** @type {number} */ (instruction[2]);\n          } else if (\n            opt_hitExtent !== undefined &&\n            !intersects(opt_hitExtent, currentGeometry.getExtent())\n          ) {\n            i = /** @type {number} */ (instruction[2]) + 1;\n          } else {\n            ++i;\n          }\n          break;\n        case CanvasInstruction.BEGIN_PATH:\n          if (pendingFill > batchSize) {\n            this.fill_(context);\n            pendingFill = 0;\n          }\n          if (pendingStroke > batchSize) {\n            context.stroke();\n            pendingStroke = 0;\n          }\n          if (!pendingFill && !pendingStroke) {\n            context.beginPath();\n            prevX = NaN;\n            prevY = NaN;\n          }\n          ++i;\n          break;\n        case CanvasInstruction.CIRCLE:\n          d = /** @type {number} */ (instruction[1]);\n          const x1 = pixelCoordinates[d];\n          const y1 = pixelCoordinates[d + 1];\n          const x2 = pixelCoordinates[d + 2];\n          const y2 = pixelCoordinates[d + 3];\n          const dx = x2 - x1;\n          const dy = y2 - y1;\n          const r = Math.sqrt(dx * dx + dy * dy);\n          context.moveTo(x1 + r, y1);\n          context.arc(x1, y1, r, 0, 2 * Math.PI, true);\n          ++i;\n          break;\n        case CanvasInstruction.CLOSE_PATH:\n          context.closePath();\n          ++i;\n          break;\n        case CanvasInstruction.CUSTOM:\n          d = /** @type {number} */ (instruction[1]);\n          dd = instruction[2];\n          const geometry = /** @type {import(\"../../geom/SimpleGeometry.js\").default} */ (instruction[3]);\n          const renderer = instruction[4];\n          const fn = instruction.length == 6 ? instruction[5] : undefined;\n          state.geometry = geometry;\n          state.feature = feature;\n          if (!(i in coordinateCache)) {\n            coordinateCache[i] = [];\n          }\n          const coords = coordinateCache[i];\n          if (fn) {\n            fn(pixelCoordinates, d, dd, 2, coords);\n          } else {\n            coords[0] = pixelCoordinates[d];\n            coords[1] = pixelCoordinates[d + 1];\n            coords.length = 2;\n          }\n          renderer(coords, state);\n          ++i;\n          break;\n        case CanvasInstruction.DRAW_IMAGE:\n          d = /** @type {number} */ (instruction[1]);\n          dd = /** @type {number} */ (instruction[2]);\n          image = /** @type {HTMLCanvasElement|HTMLVideoElement|HTMLImageElement} */ (instruction[3]);\n\n          // Remaining arguments in DRAW_IMAGE are in alphabetical order\n          anchorX = /** @type {number} */ (instruction[4]);\n          anchorY = /** @type {number} */ (instruction[5]);\n          let height = /** @type {number} */ (instruction[6]);\n          const opacity = /** @type {number} */ (instruction[7]);\n          const originX = /** @type {number} */ (instruction[8]);\n          const originY = /** @type {number} */ (instruction[9]);\n          const rotateWithView = /** @type {boolean} */ (instruction[10]);\n          let rotation = /** @type {number} */ (instruction[11]);\n          const scale = /** @type {import(\"../../size.js\").Size} */ (instruction[12]);\n          let width = /** @type {number} */ (instruction[13]);\n          const declutterImageWithText = /** @type {import(\"../canvas.js\").DeclutterImageWithText} */ (instruction[14]);\n\n          if (!image && instruction.length >= 19) {\n            // create label images\n            text = /** @type {string} */ (instruction[18]);\n            textKey = /** @type {string} */ (instruction[19]);\n            strokeKey = /** @type {string} */ (instruction[20]);\n            fillKey = /** @type {string} */ (instruction[21]);\n            const labelWithAnchor = this.drawLabelWithPointPlacement_(\n              text,\n              textKey,\n              strokeKey,\n              fillKey\n            );\n            image = labelWithAnchor.label;\n            instruction[3] = image;\n            const textOffsetX = /** @type {number} */ (instruction[22]);\n            anchorX = (labelWithAnchor.anchorX - textOffsetX) * this.pixelRatio;\n            instruction[4] = anchorX;\n            const textOffsetY = /** @type {number} */ (instruction[23]);\n            anchorY = (labelWithAnchor.anchorY - textOffsetY) * this.pixelRatio;\n            instruction[5] = anchorY;\n            height = image.height;\n            instruction[6] = height;\n            width = image.width;\n            instruction[13] = width;\n          }\n\n          let geometryWidths;\n          if (instruction.length > 24) {\n            geometryWidths = /** @type {number} */ (instruction[24]);\n          }\n\n          let padding, backgroundFill, backgroundStroke;\n          if (instruction.length > 16) {\n            padding = /** @type {Array<number>} */ (instruction[15]);\n            backgroundFill = /** @type {boolean} */ (instruction[16]);\n            backgroundStroke = /** @type {boolean} */ (instruction[17]);\n          } else {\n            padding = defaultPadding;\n            backgroundFill = false;\n            backgroundStroke = false;\n          }\n\n          if (rotateWithView && viewRotationFromTransform) {\n            // Canvas is expected to be rotated to reverse view rotation.\n            rotation += viewRotation;\n          } else if (!rotateWithView && !viewRotationFromTransform) {\n            // Canvas is not rotated, images need to be rotated back to be north-up.\n            rotation -= viewRotation;\n          }\n          let widthIndex = 0;\n          for (; d < dd; d += 2) {\n            if (\n              geometryWidths &&\n              geometryWidths[widthIndex++] < width / this.pixelRatio\n            ) {\n              continue;\n            }\n            const dimensions = this.calculateImageOrLabelDimensions_(\n              image.width,\n              image.height,\n              pixelCoordinates[d],\n              pixelCoordinates[d + 1],\n              width,\n              height,\n              anchorX,\n              anchorY,\n              originX,\n              originY,\n              rotation,\n              scale,\n              snapToPixel,\n              padding,\n              backgroundFill || backgroundStroke,\n              feature\n            );\n            /** @type {ReplayImageOrLabelArgs} */\n            const args = [\n              context,\n              contextScale,\n              image,\n              dimensions,\n              opacity,\n              backgroundFill\n                ? /** @type {Array<*>} */ (lastFillInstruction)\n                : null,\n              backgroundStroke\n                ? /** @type {Array<*>} */ (lastStrokeInstruction)\n                : null,\n            ];\n            let imageArgs;\n            let imageDeclutterBox;\n            if (opt_declutterTree && declutterImageWithText) {\n              if (!declutterImageWithText[d]) {\n                // We now have the image for an image+text combination.\n                declutterImageWithText[d] = args;\n                // Don't render anything for now, wait for the text.\n                continue;\n              }\n              imageArgs = declutterImageWithText[d];\n              delete declutterImageWithText[d];\n              imageDeclutterBox = getDeclutterBox(imageArgs);\n              if (opt_declutterTree.collides(imageDeclutterBox)) {\n                continue;\n              }\n            }\n            if (\n              opt_declutterTree &&\n              opt_declutterTree.collides(dimensions.declutterBox)\n            ) {\n              continue;\n            }\n            if (imageArgs) {\n              // We now have image and text for an image+text combination.\n              if (opt_declutterTree) {\n                opt_declutterTree.insert(imageDeclutterBox);\n              }\n              // Render the image before we render the text.\n              this.replayImageOrLabel_.apply(this, imageArgs);\n            }\n            if (opt_declutterTree) {\n              opt_declutterTree.insert(dimensions.declutterBox);\n            }\n            this.replayImageOrLabel_.apply(this, args);\n          }\n          ++i;\n          break;\n        case CanvasInstruction.DRAW_CHARS:\n          const begin = /** @type {number} */ (instruction[1]);\n          const end = /** @type {number} */ (instruction[2]);\n          const baseline = /** @type {number} */ (instruction[3]);\n          const overflow = /** @type {number} */ (instruction[4]);\n          fillKey = /** @type {string} */ (instruction[5]);\n          const maxAngle = /** @type {number} */ (instruction[6]);\n          const measurePixelRatio = /** @type {number} */ (instruction[7]);\n          const offsetY = /** @type {number} */ (instruction[8]);\n          strokeKey = /** @type {string} */ (instruction[9]);\n          const strokeWidth = /** @type {number} */ (instruction[10]);\n          text = /** @type {string} */ (instruction[11]);\n          textKey = /** @type {string} */ (instruction[12]);\n          const pixelRatioScale = [\n            /** @type {number} */ (instruction[13]),\n            /** @type {number} */ (instruction[13]),\n          ];\n\n          const textState = this.textStates[textKey];\n          const font = textState.font;\n          const textScale = [\n            textState.scale[0] * measurePixelRatio,\n            textState.scale[1] * measurePixelRatio,\n          ];\n\n          let cachedWidths;\n          if (font in this.widths_) {\n            cachedWidths = this.widths_[font];\n          } else {\n            cachedWidths = {};\n            this.widths_[font] = cachedWidths;\n          }\n\n          const pathLength = lineStringLength(pixelCoordinates, begin, end, 2);\n          const textLength =\n            Math.abs(textScale[0]) *\n            measureAndCacheTextWidth(font, text, cachedWidths);\n          if (overflow || textLength <= pathLength) {\n            const textAlign = this.textStates[textKey].textAlign;\n            const startM = (pathLength - textLength) * TEXT_ALIGN[textAlign];\n            const parts = drawTextOnPath(\n              pixelCoordinates,\n              begin,\n              end,\n              2,\n              text,\n              startM,\n              maxAngle,\n              Math.abs(textScale[0]),\n              measureAndCacheTextWidth,\n              font,\n              cachedWidths,\n              viewRotationFromTransform ? 0 : this.viewRotation_\n            );\n            drawChars: if (parts) {\n              /** @type {Array<ReplayImageOrLabelArgs>} */\n              const replayImageOrLabelArgs = [];\n              let c, cc, chars, label, part;\n              if (strokeKey) {\n                for (c = 0, cc = parts.length; c < cc; ++c) {\n                  part = parts[c]; // x, y, anchorX, rotation, chunk\n                  chars = /** @type {string} */ (part[4]);\n                  label = this.createLabel(chars, textKey, '', strokeKey);\n                  anchorX =\n                    /** @type {number} */ (part[2]) +\n                    (textScale[0] < 0 ? -strokeWidth : strokeWidth);\n                  anchorY =\n                    baseline * label.height +\n                    ((0.5 - baseline) * 2 * strokeWidth * textScale[1]) /\n                      textScale[0] -\n                    offsetY;\n                  const dimensions = this.calculateImageOrLabelDimensions_(\n                    label.width,\n                    label.height,\n                    part[0],\n                    part[1],\n                    label.width,\n                    label.height,\n                    anchorX,\n                    anchorY,\n                    0,\n                    0,\n                    part[3],\n                    pixelRatioScale,\n                    false,\n                    defaultPadding,\n                    false,\n                    feature\n                  );\n                  if (\n                    opt_declutterTree &&\n                    opt_declutterTree.collides(dimensions.declutterBox)\n                  ) {\n                    break drawChars;\n                  }\n                  replayImageOrLabelArgs.push([\n                    context,\n                    contextScale,\n                    label,\n                    dimensions,\n                    1,\n                    null,\n                    null,\n                  ]);\n                }\n              }\n              if (fillKey) {\n                for (c = 0, cc = parts.length; c < cc; ++c) {\n                  part = parts[c]; // x, y, anchorX, rotation, chunk\n                  chars = /** @type {string} */ (part[4]);\n                  label = this.createLabel(chars, textKey, fillKey, '');\n                  anchorX = /** @type {number} */ (part[2]);\n                  anchorY = baseline * label.height - offsetY;\n                  const dimensions = this.calculateImageOrLabelDimensions_(\n                    label.width,\n                    label.height,\n                    part[0],\n                    part[1],\n                    label.width,\n                    label.height,\n                    anchorX,\n                    anchorY,\n                    0,\n                    0,\n                    part[3],\n                    pixelRatioScale,\n                    false,\n                    defaultPadding,\n                    false,\n                    feature\n                  );\n                  if (\n                    opt_declutterTree &&\n                    opt_declutterTree.collides(dimensions.declutterBox)\n                  ) {\n                    break drawChars;\n                  }\n                  replayImageOrLabelArgs.push([\n                    context,\n                    contextScale,\n                    label,\n                    dimensions,\n                    1,\n                    null,\n                    null,\n                  ]);\n                }\n              }\n              if (opt_declutterTree) {\n                opt_declutterTree.load(\n                  replayImageOrLabelArgs.map(getDeclutterBox)\n                );\n              }\n              for (let i = 0, ii = replayImageOrLabelArgs.length; i < ii; ++i) {\n                this.replayImageOrLabel_.apply(this, replayImageOrLabelArgs[i]);\n              }\n            }\n          }\n          ++i;\n          break;\n        case CanvasInstruction.END_GEOMETRY:\n          if (opt_featureCallback !== undefined) {\n            feature = /** @type {import(\"../../Feature.js\").FeatureLike} */ (instruction[1]);\n            const result = opt_featureCallback(feature, currentGeometry);\n            if (result) {\n              return result;\n            }\n          }\n          ++i;\n          break;\n        case CanvasInstruction.FILL:\n          if (batchSize) {\n            pendingFill++;\n          } else {\n            this.fill_(context);\n          }\n          ++i;\n          break;\n        case CanvasInstruction.MOVE_TO_LINE_TO:\n          d = /** @type {number} */ (instruction[1]);\n          dd = /** @type {number} */ (instruction[2]);\n          x = pixelCoordinates[d];\n          y = pixelCoordinates[d + 1];\n          roundX = (x + 0.5) | 0;\n          roundY = (y + 0.5) | 0;\n          if (roundX !== prevX || roundY !== prevY) {\n            context.moveTo(x, y);\n            prevX = roundX;\n            prevY = roundY;\n          }\n          for (d += 2; d < dd; d += 2) {\n            x = pixelCoordinates[d];\n            y = pixelCoordinates[d + 1];\n            roundX = (x + 0.5) | 0;\n            roundY = (y + 0.5) | 0;\n            if (d == dd - 2 || roundX !== prevX || roundY !== prevY) {\n              context.lineTo(x, y);\n              prevX = roundX;\n              prevY = roundY;\n            }\n          }\n          ++i;\n          break;\n        case CanvasInstruction.SET_FILL_STYLE:\n          lastFillInstruction = instruction;\n          this.alignFill_ = instruction[2];\n\n          if (pendingFill) {\n            this.fill_(context);\n            pendingFill = 0;\n            if (pendingStroke) {\n              context.stroke();\n              pendingStroke = 0;\n            }\n          }\n\n          context.fillStyle = /** @type {import(\"../../colorlike.js\").ColorLike} */ (instruction[1]);\n          ++i;\n          break;\n        case CanvasInstruction.SET_STROKE_STYLE:\n          lastStrokeInstruction = instruction;\n          if (pendingStroke) {\n            context.stroke();\n            pendingStroke = 0;\n          }\n          this.setStrokeStyle_(context, /** @type {Array<*>} */ (instruction));\n          ++i;\n          break;\n        case CanvasInstruction.STROKE:\n          if (batchSize) {\n            pendingStroke++;\n          } else {\n            context.stroke();\n          }\n          ++i;\n          break;\n        default:\n          ++i; // consume the instruction anyway, to avoid an infinite loop\n          break;\n      }\n    }\n    if (pendingFill) {\n      this.fill_(context);\n    }\n    if (pendingStroke) {\n      context.stroke();\n    }\n    return undefined;\n  }\n\n  /**\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {number} contextScale Scale of the context.\n   * @param {import(\"../../transform.js\").Transform} transform Transform.\n   * @param {number} viewRotation View rotation.\n   * @param {boolean} snapToPixel Snap point symbols and text to integer pixels.\n   * @param {import(\"rbush\").default=} opt_declutterTree Declutter tree.\n   */\n  execute(\n    context,\n    contextScale,\n    transform,\n    viewRotation,\n    snapToPixel,\n    opt_declutterTree\n  ) {\n    this.viewRotation_ = viewRotation;\n    this.execute_(\n      context,\n      contextScale,\n      transform,\n      this.instructions,\n      snapToPixel,\n      undefined,\n      undefined,\n      opt_declutterTree\n    );\n  }\n\n  /**\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {import(\"../../transform.js\").Transform} transform Transform.\n   * @param {number} viewRotation View rotation.\n   * @param {FeatureCallback<T>=} opt_featureCallback Feature callback.\n   * @param {import(\"../../extent.js\").Extent=} opt_hitExtent Only check\n   *     features that intersect this extent.\n   * @return {T|undefined} Callback result.\n   * @template T\n   */\n  executeHitDetection(\n    context,\n    transform,\n    viewRotation,\n    opt_featureCallback,\n    opt_hitExtent\n  ) {\n    this.viewRotation_ = viewRotation;\n    return this.execute_(\n      context,\n      1,\n      transform,\n      this.hitDetectionInstructions,\n      true,\n      opt_featureCallback,\n      opt_hitExtent\n    );\n  }\n}\n\nexport default Executor;\n","/**\n * @module ol/render/canvas/ExecutorGroup\n */\n\nimport BuilderType from './BuilderType.js';\nimport Executor from './Executor.js';\nimport {buffer, createEmpty, extendCoordinate} from '../../extent.js';\nimport {\n  compose as composeTransform,\n  create as createTransform,\n} from '../../transform.js';\nimport {createCanvasContext2D} from '../../dom.js';\nimport {isEmpty} from '../../obj.js';\nimport {numberSafeCompareFunction} from '../../array.js';\nimport {transform2D} from '../../geom/flat/transform.js';\n\n/**\n * @const\n * @type {Array<import(\"./BuilderType.js\").default>}\n */\nconst ORDER = [\n  BuilderType.POLYGON,\n  BuilderType.CIRCLE,\n  BuilderType.LINE_STRING,\n  BuilderType.IMAGE,\n  BuilderType.TEXT,\n  BuilderType.DEFAULT,\n];\n\nclass ExecutorGroup {\n  /**\n   * @param {import(\"../../extent.js\").Extent} maxExtent Max extent for clipping. When a\n   * `maxExtent` was set on the Buillder for this executor group, the same `maxExtent`\n   * should be set here, unless the target context does not exceet that extent (which\n   * can be the case when rendering to tiles).\n   * @param {number} resolution Resolution.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {boolean} overlaps The executor group can have overlapping geometries.\n   * @param {!Object<string, !Object<import(\"./BuilderType.js\").default, import(\"../canvas.js\").SerializableInstructions>>} allInstructions\n   * The serializable instructions.\n   * @param {number=} opt_renderBuffer Optional rendering buffer.\n   */\n  constructor(\n    maxExtent,\n    resolution,\n    pixelRatio,\n    overlaps,\n    allInstructions,\n    opt_renderBuffer\n  ) {\n    /**\n     * @private\n     * @type {import(\"../../extent.js\").Extent}\n     */\n    this.maxExtent_ = maxExtent;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.overlaps_ = overlaps;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.pixelRatio_ = pixelRatio;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.resolution_ = resolution;\n\n    /**\n     * @private\n     * @type {number|undefined}\n     */\n    this.renderBuffer_ = opt_renderBuffer;\n\n    /**\n     * @private\n     * @type {!Object<string, !Object<import(\"./BuilderType.js\").default, import(\"./Executor\").default>>}\n     */\n    this.executorsByZIndex_ = {};\n\n    /**\n     * @private\n     * @type {CanvasRenderingContext2D}\n     */\n    this.hitDetectionContext_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../../transform.js\").Transform}\n     */\n    this.hitDetectionTransform_ = createTransform();\n\n    this.createExecutors_(allInstructions);\n  }\n\n  /**\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {import(\"../../transform.js\").Transform} transform Transform.\n   */\n  clip(context, transform) {\n    const flatClipCoords = this.getClipCoords(transform);\n    context.beginPath();\n    context.moveTo(flatClipCoords[0], flatClipCoords[1]);\n    context.lineTo(flatClipCoords[2], flatClipCoords[3]);\n    context.lineTo(flatClipCoords[4], flatClipCoords[5]);\n    context.lineTo(flatClipCoords[6], flatClipCoords[7]);\n    context.clip();\n  }\n\n  /**\n   * Create executors and populate them using the provided instructions.\n   * @private\n   * @param {!Object<string, !Object<import(\"./BuilderType.js\").default, import(\"../canvas.js\").SerializableInstructions>>} allInstructions The serializable instructions\n   */\n  createExecutors_(allInstructions) {\n    for (const zIndex in allInstructions) {\n      let executors = this.executorsByZIndex_[zIndex];\n      if (executors === undefined) {\n        executors = {};\n        this.executorsByZIndex_[zIndex] = executors;\n      }\n      const instructionByZindex = allInstructions[zIndex];\n      const renderBuffer = [this.renderBuffer_ || 0, this.renderBuffer_ || 0];\n      for (const builderType in instructionByZindex) {\n        const instructions = instructionByZindex[builderType];\n        executors[builderType] = new Executor(\n          this.resolution_,\n          this.pixelRatio_,\n          this.overlaps_,\n          instructions,\n          renderBuffer\n        );\n      }\n    }\n  }\n\n  /**\n   * @param {Array<import(\"./BuilderType.js\").default>} executors Executors.\n   * @return {boolean} Has executors of the provided types.\n   */\n  hasExecutors(executors) {\n    for (const zIndex in this.executorsByZIndex_) {\n      const candidates = this.executorsByZIndex_[zIndex];\n      for (let i = 0, ii = executors.length; i < ii; ++i) {\n        if (executors[i] in candidates) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  /**\n   * @param {import(\"../../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {number} resolution Resolution.\n   * @param {number} rotation Rotation.\n   * @param {number} hitTolerance Hit tolerance in pixels.\n   * @param {function(import(\"../../Feature.js\").FeatureLike, import(\"../../geom/SimpleGeometry.js\").default, number): T} callback Feature callback.\n   * @param {Array<import(\"../../Feature.js\").FeatureLike>} declutteredFeatures Decluttered features.\n   * @return {T|undefined} Callback result.\n   * @template T\n   */\n  forEachFeatureAtCoordinate(\n    coordinate,\n    resolution,\n    rotation,\n    hitTolerance,\n    callback,\n    declutteredFeatures\n  ) {\n    hitTolerance = Math.round(hitTolerance);\n    const contextSize = hitTolerance * 2 + 1;\n    const transform = composeTransform(\n      this.hitDetectionTransform_,\n      hitTolerance + 0.5,\n      hitTolerance + 0.5,\n      1 / resolution,\n      -1 / resolution,\n      -rotation,\n      -coordinate[0],\n      -coordinate[1]\n    );\n\n    const newContext = !this.hitDetectionContext_;\n    if (newContext) {\n      this.hitDetectionContext_ = createCanvasContext2D(\n        contextSize,\n        contextSize\n      );\n    }\n    const context = this.hitDetectionContext_;\n\n    if (\n      context.canvas.width !== contextSize ||\n      context.canvas.height !== contextSize\n    ) {\n      context.canvas.width = contextSize;\n      context.canvas.height = contextSize;\n    } else if (!newContext) {\n      context.clearRect(0, 0, contextSize, contextSize);\n    }\n\n    /**\n     * @type {import(\"../../extent.js\").Extent}\n     */\n    let hitExtent;\n    if (this.renderBuffer_ !== undefined) {\n      hitExtent = createEmpty();\n      extendCoordinate(hitExtent, coordinate);\n      buffer(\n        hitExtent,\n        resolution * (this.renderBuffer_ + hitTolerance),\n        hitExtent\n      );\n    }\n\n    const indexes = getPixelIndexArray(hitTolerance);\n\n    let builderType;\n\n    /**\n     * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n     * @param {import(\"../../geom/SimpleGeometry.js\").default} geometry Geometry.\n     * @return {T|undefined} Callback result.\n     */\n    function featureCallback(feature, geometry) {\n      const imageData = context.getImageData(0, 0, contextSize, contextSize)\n        .data;\n      for (let i = 0, ii = indexes.length; i < ii; i++) {\n        if (imageData[indexes[i]] > 0) {\n          if (\n            !declutteredFeatures ||\n            (builderType !== BuilderType.IMAGE &&\n              builderType !== BuilderType.TEXT) ||\n            declutteredFeatures.indexOf(feature) !== -1\n          ) {\n            const idx = (indexes[i] - 3) / 4;\n            const x = hitTolerance - (idx % contextSize);\n            const y = hitTolerance - ((idx / contextSize) | 0);\n            const result = callback(feature, geometry, x * x + y * y);\n            if (result) {\n              return result;\n            }\n          }\n          context.clearRect(0, 0, contextSize, contextSize);\n          break;\n        }\n      }\n      return undefined;\n    }\n\n    /** @type {Array<number>} */\n    const zs = Object.keys(this.executorsByZIndex_).map(Number);\n    zs.sort(numberSafeCompareFunction);\n\n    let i, j, executors, executor, result;\n    for (i = zs.length - 1; i >= 0; --i) {\n      const zIndexKey = zs[i].toString();\n      executors = this.executorsByZIndex_[zIndexKey];\n      for (j = ORDER.length - 1; j >= 0; --j) {\n        builderType = ORDER[j];\n        executor = executors[builderType];\n        if (executor !== undefined) {\n          result = executor.executeHitDetection(\n            context,\n            transform,\n            rotation,\n            featureCallback,\n            hitExtent\n          );\n          if (result) {\n            return result;\n          }\n        }\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * @param {import(\"../../transform.js\").Transform} transform Transform.\n   * @return {Array<number>} Clip coordinates.\n   */\n  getClipCoords(transform) {\n    const maxExtent = this.maxExtent_;\n    if (!maxExtent) {\n      return null;\n    }\n    const minX = maxExtent[0];\n    const minY = maxExtent[1];\n    const maxX = maxExtent[2];\n    const maxY = maxExtent[3];\n    const flatClipCoords = [minX, minY, minX, maxY, maxX, maxY, maxX, minY];\n    transform2D(flatClipCoords, 0, 8, 2, transform, flatClipCoords);\n    return flatClipCoords;\n  }\n\n  /**\n   * @return {boolean} Is empty.\n   */\n  isEmpty() {\n    return isEmpty(this.executorsByZIndex_);\n  }\n\n  /**\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {number} contextScale Scale of the context.\n   * @param {import(\"../../transform.js\").Transform} transform Transform.\n   * @param {number} viewRotation View rotation.\n   * @param {boolean} snapToPixel Snap point symbols and test to integer pixel.\n   * @param {Array<import(\"./BuilderType.js\").default>=} opt_builderTypes Ordered replay types to replay.\n   *     Default is {@link module:ol/render/replay~ORDER}\n   * @param {import(\"rbush\").default=} opt_declutterTree Declutter tree.\n   */\n  execute(\n    context,\n    contextScale,\n    transform,\n    viewRotation,\n    snapToPixel,\n    opt_builderTypes,\n    opt_declutterTree\n  ) {\n    /** @type {Array<number>} */\n    const zs = Object.keys(this.executorsByZIndex_).map(Number);\n    zs.sort(numberSafeCompareFunction);\n\n    // setup clipping so that the parts of over-simplified geometries are not\n    // visible outside the current extent when panning\n    if (this.maxExtent_) {\n      context.save();\n      this.clip(context, transform);\n    }\n\n    const builderTypes = opt_builderTypes ? opt_builderTypes : ORDER;\n    let i, ii, j, jj, replays, replay;\n    if (opt_declutterTree) {\n      zs.reverse();\n    }\n    for (i = 0, ii = zs.length; i < ii; ++i) {\n      const zIndexKey = zs[i].toString();\n      replays = this.executorsByZIndex_[zIndexKey];\n      for (j = 0, jj = builderTypes.length; j < jj; ++j) {\n        const builderType = builderTypes[j];\n        replay = replays[builderType];\n        if (replay !== undefined) {\n          replay.execute(\n            context,\n            contextScale,\n            transform,\n            viewRotation,\n            snapToPixel,\n            opt_declutterTree\n          );\n        }\n      }\n    }\n\n    if (this.maxExtent_) {\n      context.restore();\n    }\n  }\n}\n\n/**\n * This cache is used to store arrays of indexes for calculated pixel circles\n * to increase performance.\n * It is a static property to allow each Replaygroup to access it.\n * @type {Object<number, Array<number>>}\n */\nconst circlePixelIndexArrayCache = {};\n\n/**\n * This methods creates an array with indexes of all pixels within a circle,\n * ordered by how close they are to the center.\n * A cache is used to increase performance.\n * @param {number} radius Radius.\n * @returns {Array<number>} An array with indexes within a circle.\n */\nexport function getPixelIndexArray(radius) {\n  if (circlePixelIndexArrayCache[radius] !== undefined) {\n    return circlePixelIndexArrayCache[radius];\n  }\n\n  const size = radius * 2 + 1;\n  const maxDistanceSq = radius * radius;\n  const distances = new Array(maxDistanceSq + 1);\n  for (let i = 0; i <= radius; ++i) {\n    for (let j = 0; j <= radius; ++j) {\n      const distanceSq = i * i + j * j;\n      if (distanceSq > maxDistanceSq) {\n        break;\n      }\n      let distance = distances[distanceSq];\n      if (!distance) {\n        distance = [];\n        distances[distanceSq] = distance;\n      }\n      distance.push(((radius + i) * size + (radius + j)) * 4 + 3);\n      if (i > 0) {\n        distance.push(((radius - i) * size + (radius + j)) * 4 + 3);\n      }\n      if (j > 0) {\n        distance.push(((radius + i) * size + (radius - j)) * 4 + 3);\n        if (i > 0) {\n          distance.push(((radius - i) * size + (radius - j)) * 4 + 3);\n        }\n      }\n    }\n  }\n\n  const pixelIndex = [];\n  for (let i = 0, ii = distances.length; i < ii; ++i) {\n    if (distances[i]) {\n      pixelIndex.push(...distances[i]);\n    }\n  }\n\n  circlePixelIndexArrayCache[radius] = pixelIndex;\n  return pixelIndex;\n}\n\nexport default ExecutorGroup;\n","/**\n * @module ol/render/canvas/Immediate\n */\n// FIXME test, especially polygons with holes and multipolygons\n// FIXME need to handle large thick features (where pixel size matters)\n// FIXME add offset and end to ol/geom/flat/transform~transform2D?\n\nimport GeometryType from '../../geom/GeometryType.js';\nimport VectorContext from '../VectorContext.js';\nimport {asColorLike} from '../../colorlike.js';\nimport {\n  compose as composeTransform,\n  create as createTransform,\n} from '../../transform.js';\nimport {\n  defaultFillStyle,\n  defaultFont,\n  defaultLineCap,\n  defaultLineDash,\n  defaultLineDashOffset,\n  defaultLineJoin,\n  defaultLineWidth,\n  defaultMiterLimit,\n  defaultStrokeStyle,\n  defaultTextAlign,\n  defaultTextBaseline,\n} from '../canvas.js';\nimport {equals} from '../../array.js';\nimport {intersects} from '../../extent.js';\nimport {transform2D} from '../../geom/flat/transform.js';\nimport {transformGeom2D} from '../../geom/SimpleGeometry.js';\n\n/**\n * @classdesc\n * A concrete subclass of {@link module:ol/render/VectorContext} that implements\n * direct rendering of features and geometries to an HTML5 Canvas context.\n * Instances of this class are created internally by the library and\n * provided to application code as vectorContext member of the\n * {@link module:ol/render/Event~RenderEvent} object associated with postcompose, precompose and\n * render events emitted by layers and maps.\n */\nclass CanvasImmediateRenderer extends VectorContext {\n  /**\n   * @param {CanvasRenderingContext2D} context Context.\n   * @param {number} pixelRatio Pixel ratio.\n   * @param {import(\"../../extent.js\").Extent} extent Extent.\n   * @param {import(\"../../transform.js\").Transform} transform Transform.\n   * @param {number} viewRotation View rotation.\n   * @param {number=} opt_squaredTolerance Optional squared tolerance for simplification.\n   * @param {import(\"../../proj.js\").TransformFunction=} opt_userTransform Transform from user to view projection.\n   */\n  constructor(\n    context,\n    pixelRatio,\n    extent,\n    transform,\n    viewRotation,\n    opt_squaredTolerance,\n    opt_userTransform\n  ) {\n    super();\n\n    /**\n     * @private\n     * @type {CanvasRenderingContext2D}\n     */\n    this.context_ = context;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.pixelRatio_ = pixelRatio;\n\n    /**\n     * @private\n     * @type {import(\"../../extent.js\").Extent}\n     */\n    this.extent_ = extent;\n\n    /**\n     * @private\n     * @type {import(\"../../transform.js\").Transform}\n     */\n    this.transform_ = transform;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.viewRotation_ = viewRotation;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.squaredTolerance_ = opt_squaredTolerance;\n\n    /**\n     * @private\n     * @type {import(\"../../proj.js\").TransformFunction}\n     */\n    this.userTransform_ = opt_userTransform;\n\n    /**\n     * @private\n     * @type {?import(\"../canvas.js\").FillState}\n     */\n    this.contextFillState_ = null;\n\n    /**\n     * @private\n     * @type {?import(\"../canvas.js\").StrokeState}\n     */\n    this.contextStrokeState_ = null;\n\n    /**\n     * @private\n     * @type {?import(\"../canvas.js\").TextState}\n     */\n    this.contextTextState_ = null;\n\n    /**\n     * @private\n     * @type {?import(\"../canvas.js\").FillState}\n     */\n    this.fillState_ = null;\n\n    /**\n     * @private\n     * @type {?import(\"../canvas.js\").StrokeState}\n     */\n    this.strokeState_ = null;\n\n    /**\n     * @private\n     * @type {HTMLCanvasElement|HTMLVideoElement|HTMLImageElement}\n     */\n    this.image_ = null;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.imageAnchorX_ = 0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.imageAnchorY_ = 0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.imageHeight_ = 0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.imageOpacity_ = 0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.imageOriginX_ = 0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.imageOriginY_ = 0;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.imageRotateWithView_ = false;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.imageRotation_ = 0;\n\n    /**\n     * @private\n     * @type {import(\"../../size.js\").Size}\n     */\n    this.imageScale_ = [0, 0];\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.imageWidth_ = 0;\n\n    /**\n     * @private\n     * @type {string}\n     */\n    this.text_ = '';\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.textOffsetX_ = 0;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.textOffsetY_ = 0;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.textRotateWithView_ = false;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.textRotation_ = 0;\n\n    /**\n     * @private\n     * @type {import(\"../../size.js\").Size}\n     */\n    this.textScale_ = [0, 0];\n\n    /**\n     * @private\n     * @type {?import(\"../canvas.js\").FillState}\n     */\n    this.textFillState_ = null;\n\n    /**\n     * @private\n     * @type {?import(\"../canvas.js\").StrokeState}\n     */\n    this.textStrokeState_ = null;\n\n    /**\n     * @private\n     * @type {?import(\"../canvas.js\").TextState}\n     */\n    this.textState_ = null;\n\n    /**\n     * @private\n     * @type {Array<number>}\n     */\n    this.pixelCoordinates_ = [];\n\n    /**\n     * @private\n     * @type {import(\"../../transform.js\").Transform}\n     */\n    this.tmpLocalTransform_ = createTransform();\n  }\n\n  /**\n   * @param {Array<number>} flatCoordinates Flat coordinates.\n   * @param {number} offset Offset.\n   * @param {number} end End.\n   * @param {number} stride Stride.\n   * @private\n   */\n  drawImages_(flatCoordinates, offset, end, stride) {\n    if (!this.image_) {\n      return;\n    }\n    const pixelCoordinates = transform2D(\n      flatCoordinates,\n      offset,\n      end,\n      2,\n      this.transform_,\n      this.pixelCoordinates_\n    );\n    const context = this.context_;\n    const localTransform = this.tmpLocalTransform_;\n    const alpha = context.globalAlpha;\n    if (this.imageOpacity_ != 1) {\n      context.globalAlpha = alpha * this.imageOpacity_;\n    }\n    let rotation = this.imageRotation_;\n    if (this.imageRotateWithView_) {\n      rotation += this.viewRotation_;\n    }\n    for (let i = 0, ii = pixelCoordinates.length; i < ii; i += 2) {\n      const x = pixelCoordinates[i] - this.imageAnchorX_;\n      const y = pixelCoordinates[i + 1] - this.imageAnchorY_;\n      if (\n        rotation !== 0 ||\n        this.imageScale_[0] != 1 ||\n        this.imageScale_[1] != 1\n      ) {\n        const centerX = x + this.imageAnchorX_;\n        const centerY = y + this.imageAnchorY_;\n        composeTransform(\n          localTransform,\n          centerX,\n          centerY,\n          1,\n          1,\n          rotation,\n          -centerX,\n          -centerY\n        );\n        context.setTransform.apply(context, localTransform);\n        context.translate(centerX, centerY);\n        context.scale(this.imageScale_[0], this.imageScale_[1]);\n        context.drawImage(\n          this.image_,\n          this.imageOriginX_,\n          this.imageOriginY_,\n          this.imageWidth_,\n          this.imageHeight_,\n          -this.imageAnchorX_,\n          -this.imageAnchorY_,\n          this.imageWidth_,\n          this.imageHeight_\n        );\n        context.setTransform(1, 0, 0, 1, 0, 0);\n      } else {\n        context.drawImage(\n          this.image_,\n          this.imageOriginX_,\n          this.imageOriginY_,\n          this.imageWidth_,\n          this.imageHeight_,\n          x,\n          y,\n          this.imageWidth_,\n          this.imageHeight_\n        );\n      }\n    }\n    if (this.imageOpacity_ != 1) {\n      context.globalAlpha = alpha;\n    }\n  }\n\n  /**\n   * @param {Array<number>} flatCoordinates Flat coordinates.\n   * @param {number} offset Offset.\n   * @param {number} end End.\n   * @param {number} stride Stride.\n   * @private\n   */\n  drawText_(flatCoordinates, offset, end, stride) {\n    if (!this.textState_ || this.text_ === '') {\n      return;\n    }\n    if (this.textFillState_) {\n      this.setContextFillState_(this.textFillState_);\n    }\n    if (this.textStrokeState_) {\n      this.setContextStrokeState_(this.textStrokeState_);\n    }\n    this.setContextTextState_(this.textState_);\n    const pixelCoordinates = transform2D(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      this.transform_,\n      this.pixelCoordinates_\n    );\n    const context = this.context_;\n    let rotation = this.textRotation_;\n    if (this.textRotateWithView_) {\n      rotation += this.viewRotation_;\n    }\n    for (; offset < end; offset += stride) {\n      const x = pixelCoordinates[offset] + this.textOffsetX_;\n      const y = pixelCoordinates[offset + 1] + this.textOffsetY_;\n      if (\n        rotation !== 0 ||\n        this.textScale_[0] != 1 ||\n        this.textScale_[1] != 1\n      ) {\n        const localTransform = composeTransform(\n          this.tmpLocalTransform_,\n          x,\n          y,\n          1,\n          1,\n          rotation,\n          -x,\n          -y\n        );\n        context.setTransform.apply(context, localTransform);\n        context.translate(x, y);\n        context.scale(this.textScale_[0], this.textScale_[1]);\n        if (this.textStrokeState_) {\n          context.strokeText(this.text_, 0, 0);\n        }\n        if (this.textFillState_) {\n          context.fillText(this.text_, 0, 0);\n        }\n        context.setTransform(1, 0, 0, 1, 0, 0);\n      } else {\n        if (this.textStrokeState_) {\n          context.strokeText(this.text_, x, y);\n        }\n        if (this.textFillState_) {\n          context.fillText(this.text_, x, y);\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {Array<number>} flatCoordinates Flat coordinates.\n   * @param {number} offset Offset.\n   * @param {number} end End.\n   * @param {number} stride Stride.\n   * @param {boolean} close Close.\n   * @private\n   * @return {number} end End.\n   */\n  moveToLineTo_(flatCoordinates, offset, end, stride, close) {\n    const context = this.context_;\n    const pixelCoordinates = transform2D(\n      flatCoordinates,\n      offset,\n      end,\n      stride,\n      this.transform_,\n      this.pixelCoordinates_\n    );\n    context.moveTo(pixelCoordinates[0], pixelCoordinates[1]);\n    let length = pixelCoordinates.length;\n    if (close) {\n      length -= 2;\n    }\n    for (let i = 2; i < length; i += 2) {\n      context.lineTo(pixelCoordinates[i], pixelCoordinates[i + 1]);\n    }\n    if (close) {\n      context.closePath();\n    }\n    return end;\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   * @private\n   * @return {number} End.\n   */\n  drawRings_(flatCoordinates, offset, ends, stride) {\n    for (let i = 0, ii = ends.length; i < ii; ++i) {\n      offset = this.moveToLineTo_(\n        flatCoordinates,\n        offset,\n        ends[i],\n        stride,\n        true\n      );\n    }\n    return offset;\n  }\n\n  /**\n   * Render a circle geometry into the canvas.  Rendering is immediate and uses\n   * the current fill and stroke styles.\n   *\n   * @param {import(\"../../geom/Circle.js\").default} geometry Circle geometry.\n   * @api\n   */\n  drawCircle(geometry) {\n    if (!intersects(this.extent_, geometry.getExtent())) {\n      return;\n    }\n    if (this.fillState_ || this.strokeState_) {\n      if (this.fillState_) {\n        this.setContextFillState_(this.fillState_);\n      }\n      if (this.strokeState_) {\n        this.setContextStrokeState_(this.strokeState_);\n      }\n      const pixelCoordinates = transformGeom2D(\n        geometry,\n        this.transform_,\n        this.pixelCoordinates_\n      );\n      const dx = pixelCoordinates[2] - pixelCoordinates[0];\n      const dy = pixelCoordinates[3] - pixelCoordinates[1];\n      const radius = Math.sqrt(dx * dx + dy * dy);\n      const context = this.context_;\n      context.beginPath();\n      context.arc(\n        pixelCoordinates[0],\n        pixelCoordinates[1],\n        radius,\n        0,\n        2 * Math.PI\n      );\n      if (this.fillState_) {\n        context.fill();\n      }\n      if (this.strokeState_) {\n        context.stroke();\n      }\n    }\n    if (this.text_ !== '') {\n      this.drawText_(geometry.getCenter(), 0, 2, 2);\n    }\n  }\n\n  /**\n   * Set the rendering style.  Note that since this is an immediate rendering API,\n   * any `zIndex` on the provided style will be ignored.\n   *\n   * @param {import(\"../../style/Style.js\").default} style The rendering style.\n   * @api\n   */\n  setStyle(style) {\n    this.setFillStrokeStyle(style.getFill(), style.getStroke());\n    this.setImageStyle(style.getImage());\n    this.setTextStyle(style.getText());\n  }\n\n  /**\n   * @param {import(\"../../transform.js\").Transform} transform Transform.\n   */\n  setTransform(transform) {\n    this.transform_ = transform;\n  }\n\n  /**\n   * Render a geometry into the canvas.  Call\n   * {@link module:ol/render/canvas/Immediate#setStyle} first to set the rendering style.\n   *\n   * @param {import(\"../../geom/Geometry.js\").default|import(\"../Feature.js\").default} geometry The geometry to render.\n   * @api\n   */\n  drawGeometry(geometry) {\n    const type = geometry.getType();\n    switch (type) {\n      case GeometryType.POINT:\n        this.drawPoint(\n          /** @type {import(\"../../geom/Point.js\").default} */ (geometry)\n        );\n        break;\n      case GeometryType.LINE_STRING:\n        this.drawLineString(\n          /** @type {import(\"../../geom/LineString.js\").default} */ (geometry)\n        );\n        break;\n      case GeometryType.POLYGON:\n        this.drawPolygon(\n          /** @type {import(\"../../geom/Polygon.js\").default} */ (geometry)\n        );\n        break;\n      case GeometryType.MULTI_POINT:\n        this.drawMultiPoint(\n          /** @type {import(\"../../geom/MultiPoint.js\").default} */ (geometry)\n        );\n        break;\n      case GeometryType.MULTI_LINE_STRING:\n        this.drawMultiLineString(\n          /** @type {import(\"../../geom/MultiLineString.js\").default} */ (geometry)\n        );\n        break;\n      case GeometryType.MULTI_POLYGON:\n        this.drawMultiPolygon(\n          /** @type {import(\"../../geom/MultiPolygon.js\").default} */ (geometry)\n        );\n        break;\n      case GeometryType.GEOMETRY_COLLECTION:\n        this.drawGeometryCollection(\n          /** @type {import(\"../../geom/GeometryCollection.js\").default} */ (geometry)\n        );\n        break;\n      case GeometryType.CIRCLE:\n        this.drawCircle(\n          /** @type {import(\"../../geom/Circle.js\").default} */ (geometry)\n        );\n        break;\n      default:\n    }\n  }\n\n  /**\n   * Render a feature into the canvas.  Note that any `zIndex` on the provided\n   * style will be ignored - features are rendered immediately in the order that\n   * this method is called.  If you need `zIndex` support, you should be using an\n   * {@link module:ol/layer/Vector~VectorLayer} instead.\n   *\n   * @param {import(\"../../Feature.js\").default} feature Feature.\n   * @param {import(\"../../style/Style.js\").default} style Style.\n   * @api\n   */\n  drawFeature(feature, style) {\n    const geometry = style.getGeometryFunction()(feature);\n    if (!geometry || !intersects(this.extent_, geometry.getExtent())) {\n      return;\n    }\n    this.setStyle(style);\n    this.drawGeometry(geometry);\n  }\n\n  /**\n   * Render a GeometryCollection to the canvas.  Rendering is immediate and\n   * uses the current styles appropriate for each geometry in the collection.\n   *\n   * @param {import(\"../../geom/GeometryCollection.js\").default} geometry Geometry collection.\n   */\n  drawGeometryCollection(geometry) {\n    const geometries = geometry.getGeometriesArray();\n    for (let i = 0, ii = geometries.length; i < ii; ++i) {\n      this.drawGeometry(geometries[i]);\n    }\n  }\n\n  /**\n   * Render a Point geometry into the canvas.  Rendering is immediate and uses\n   * the current style.\n   *\n   * @param {import(\"../../geom/Point.js\").default|import(\"../Feature.js\").default} geometry Point geometry.\n   */\n  drawPoint(geometry) {\n    if (this.squaredTolerance_) {\n      geometry = /** @type {import(\"../../geom/Point.js\").default} */ (geometry.simplifyTransformed(\n        this.squaredTolerance_,\n        this.userTransform_\n      ));\n    }\n    const flatCoordinates = geometry.getFlatCoordinates();\n    const stride = geometry.getStride();\n    if (this.image_) {\n      this.drawImages_(flatCoordinates, 0, flatCoordinates.length, stride);\n    }\n    if (this.text_ !== '') {\n      this.drawText_(flatCoordinates, 0, flatCoordinates.length, stride);\n    }\n  }\n\n  /**\n   * Render a MultiPoint geometry  into the canvas.  Rendering is immediate and\n   * uses the current style.\n   *\n   * @param {import(\"../../geom/MultiPoint.js\").default|import(\"../Feature.js\").default} geometry MultiPoint geometry.\n   */\n  drawMultiPoint(geometry) {\n    if (this.squaredTolerance_) {\n      geometry = /** @type {import(\"../../geom/MultiPoint.js\").default} */ (geometry.simplifyTransformed(\n        this.squaredTolerance_,\n        this.userTransform_\n      ));\n    }\n    const flatCoordinates = geometry.getFlatCoordinates();\n    const stride = geometry.getStride();\n    if (this.image_) {\n      this.drawImages_(flatCoordinates, 0, flatCoordinates.length, stride);\n    }\n    if (this.text_ !== '') {\n      this.drawText_(flatCoordinates, 0, flatCoordinates.length, stride);\n    }\n  }\n\n  /**\n   * Render a LineString into the canvas.  Rendering is immediate and uses\n   * the current style.\n   *\n   * @param {import(\"../../geom/LineString.js\").default|import(\"../Feature.js\").default} geometry LineString geometry.\n   */\n  drawLineString(geometry) {\n    if (this.squaredTolerance_) {\n      geometry = /** @type {import(\"../../geom/LineString.js\").default} */ (geometry.simplifyTransformed(\n        this.squaredTolerance_,\n        this.userTransform_\n      ));\n    }\n    if (!intersects(this.extent_, geometry.getExtent())) {\n      return;\n    }\n    if (this.strokeState_) {\n      this.setContextStrokeState_(this.strokeState_);\n      const context = this.context_;\n      const flatCoordinates = geometry.getFlatCoordinates();\n      context.beginPath();\n      this.moveToLineTo_(\n        flatCoordinates,\n        0,\n        flatCoordinates.length,\n        geometry.getStride(),\n        false\n      );\n      context.stroke();\n    }\n    if (this.text_ !== '') {\n      const flatMidpoint = geometry.getFlatMidpoint();\n      this.drawText_(flatMidpoint, 0, 2, 2);\n    }\n  }\n\n  /**\n   * Render a MultiLineString geometry into the canvas.  Rendering is immediate\n   * and uses the current style.\n   *\n   * @param {import(\"../../geom/MultiLineString.js\").default|import(\"../Feature.js\").default} geometry MultiLineString geometry.\n   */\n  drawMultiLineString(geometry) {\n    if (this.squaredTolerance_) {\n      geometry = /** @type {import(\"../../geom/MultiLineString.js\").default} */ (geometry.simplifyTransformed(\n        this.squaredTolerance_,\n        this.userTransform_\n      ));\n    }\n    const geometryExtent = geometry.getExtent();\n    if (!intersects(this.extent_, geometryExtent)) {\n      return;\n    }\n    if (this.strokeState_) {\n      this.setContextStrokeState_(this.strokeState_);\n      const context = this.context_;\n      const flatCoordinates = geometry.getFlatCoordinates();\n      let offset = 0;\n      const ends = /** @type {Array<number>} */ (geometry.getEnds());\n      const stride = geometry.getStride();\n      context.beginPath();\n      for (let i = 0, ii = ends.length; i < ii; ++i) {\n        offset = this.moveToLineTo_(\n          flatCoordinates,\n          offset,\n          ends[i],\n          stride,\n          false\n        );\n      }\n      context.stroke();\n    }\n    if (this.text_ !== '') {\n      const flatMidpoints = geometry.getFlatMidpoints();\n      this.drawText_(flatMidpoints, 0, flatMidpoints.length, 2);\n    }\n  }\n\n  /**\n   * Render a Polygon geometry into the canvas.  Rendering is immediate and uses\n   * the current style.\n   *\n   * @param {import(\"../../geom/Polygon.js\").default|import(\"../Feature.js\").default} geometry Polygon geometry.\n   */\n  drawPolygon(geometry) {\n    if (this.squaredTolerance_) {\n      geometry = /** @type {import(\"../../geom/Polygon.js\").default} */ (geometry.simplifyTransformed(\n        this.squaredTolerance_,\n        this.userTransform_\n      ));\n    }\n    if (!intersects(this.extent_, geometry.getExtent())) {\n      return;\n    }\n    if (this.strokeState_ || this.fillState_) {\n      if (this.fillState_) {\n        this.setContextFillState_(this.fillState_);\n      }\n      if (this.strokeState_) {\n        this.setContextStrokeState_(this.strokeState_);\n      }\n      const context = this.context_;\n      context.beginPath();\n      this.drawRings_(\n        geometry.getOrientedFlatCoordinates(),\n        0,\n        /** @type {Array<number>} */ (geometry.getEnds()),\n        geometry.getStride()\n      );\n      if (this.fillState_) {\n        context.fill();\n      }\n      if (this.strokeState_) {\n        context.stroke();\n      }\n    }\n    if (this.text_ !== '') {\n      const flatInteriorPoint = geometry.getFlatInteriorPoint();\n      this.drawText_(flatInteriorPoint, 0, 2, 2);\n    }\n  }\n\n  /**\n   * Render MultiPolygon geometry into the canvas.  Rendering is immediate and\n   * uses the current style.\n   * @param {import(\"../../geom/MultiPolygon.js\").default} geometry MultiPolygon geometry.\n   */\n  drawMultiPolygon(geometry) {\n    if (this.squaredTolerance_) {\n      geometry = /** @type {import(\"../../geom/MultiPolygon.js\").default} */ (geometry.simplifyTransformed(\n        this.squaredTolerance_,\n        this.userTransform_\n      ));\n    }\n    if (!intersects(this.extent_, geometry.getExtent())) {\n      return;\n    }\n    if (this.strokeState_ || this.fillState_) {\n      if (this.fillState_) {\n        this.setContextFillState_(this.fillState_);\n      }\n      if (this.strokeState_) {\n        this.setContextStrokeState_(this.strokeState_);\n      }\n      const context = this.context_;\n      const flatCoordinates = geometry.getOrientedFlatCoordinates();\n      let offset = 0;\n      const endss = geometry.getEndss();\n      const stride = geometry.getStride();\n      context.beginPath();\n      for (let i = 0, ii = endss.length; i < ii; ++i) {\n        const ends = endss[i];\n        offset = this.drawRings_(flatCoordinates, offset, ends, stride);\n      }\n      if (this.fillState_) {\n        context.fill();\n      }\n      if (this.strokeState_) {\n        context.stroke();\n      }\n    }\n    if (this.text_ !== '') {\n      const flatInteriorPoints = geometry.getFlatInteriorPoints();\n      this.drawText_(flatInteriorPoints, 0, flatInteriorPoints.length, 2);\n    }\n  }\n\n  /**\n   * @param {import(\"../canvas.js\").FillState} fillState Fill state.\n   * @private\n   */\n  setContextFillState_(fillState) {\n    const context = this.context_;\n    const contextFillState = this.contextFillState_;\n    if (!contextFillState) {\n      context.fillStyle = fillState.fillStyle;\n      this.contextFillState_ = {\n        fillStyle: fillState.fillStyle,\n      };\n    } else {\n      if (contextFillState.fillStyle != fillState.fillStyle) {\n        contextFillState.fillStyle = fillState.fillStyle;\n        context.fillStyle = fillState.fillStyle;\n      }\n    }\n  }\n\n  /**\n   * @param {import(\"../canvas.js\").StrokeState} strokeState Stroke state.\n   * @private\n   */\n  setContextStrokeState_(strokeState) {\n    const context = this.context_;\n    const contextStrokeState = this.contextStrokeState_;\n    if (!contextStrokeState) {\n      context.lineCap = strokeState.lineCap;\n      if (context.setLineDash) {\n        context.setLineDash(strokeState.lineDash);\n        context.lineDashOffset = strokeState.lineDashOffset;\n      }\n      context.lineJoin = strokeState.lineJoin;\n      context.lineWidth = strokeState.lineWidth;\n      context.miterLimit = strokeState.miterLimit;\n      context.strokeStyle = strokeState.strokeStyle;\n      this.contextStrokeState_ = {\n        lineCap: strokeState.lineCap,\n        lineDash: strokeState.lineDash,\n        lineDashOffset: strokeState.lineDashOffset,\n        lineJoin: strokeState.lineJoin,\n        lineWidth: strokeState.lineWidth,\n        miterLimit: strokeState.miterLimit,\n        strokeStyle: strokeState.strokeStyle,\n      };\n    } else {\n      if (contextStrokeState.lineCap != strokeState.lineCap) {\n        contextStrokeState.lineCap = strokeState.lineCap;\n        context.lineCap = strokeState.lineCap;\n      }\n      if (context.setLineDash) {\n        if (!equals(contextStrokeState.lineDash, strokeState.lineDash)) {\n          context.setLineDash(\n            (contextStrokeState.lineDash = strokeState.lineDash)\n          );\n        }\n        if (contextStrokeState.lineDashOffset != strokeState.lineDashOffset) {\n          contextStrokeState.lineDashOffset = strokeState.lineDashOffset;\n          context.lineDashOffset = strokeState.lineDashOffset;\n        }\n      }\n      if (contextStrokeState.lineJoin != strokeState.lineJoin) {\n        contextStrokeState.lineJoin = strokeState.lineJoin;\n        context.lineJoin = strokeState.lineJoin;\n      }\n      if (contextStrokeState.lineWidth != strokeState.lineWidth) {\n        contextStrokeState.lineWidth = strokeState.lineWidth;\n        context.lineWidth = strokeState.lineWidth;\n      }\n      if (contextStrokeState.miterLimit != strokeState.miterLimit) {\n        contextStrokeState.miterLimit = strokeState.miterLimit;\n        context.miterLimit = strokeState.miterLimit;\n      }\n      if (contextStrokeState.strokeStyle != strokeState.strokeStyle) {\n        contextStrokeState.strokeStyle = strokeState.strokeStyle;\n        context.strokeStyle = strokeState.strokeStyle;\n      }\n    }\n  }\n\n  /**\n   * @param {import(\"../canvas.js\").TextState} textState Text state.\n   * @private\n   */\n  setContextTextState_(textState) {\n    const context = this.context_;\n    const contextTextState = this.contextTextState_;\n    const textAlign = textState.textAlign\n      ? textState.textAlign\n      : defaultTextAlign;\n    if (!contextTextState) {\n      context.font = textState.font;\n      context.textAlign = /** @type {CanvasTextAlign} */ (textAlign);\n      context.textBaseline = /** @type {CanvasTextBaseline} */ (textState.textBaseline);\n      this.contextTextState_ = {\n        font: textState.font,\n        textAlign: textAlign,\n        textBaseline: textState.textBaseline,\n      };\n    } else {\n      if (contextTextState.font != textState.font) {\n        contextTextState.font = textState.font;\n        context.font = textState.font;\n      }\n      if (contextTextState.textAlign != textAlign) {\n        contextTextState.textAlign = /** @type {CanvasTextAlign} */ (textAlign);\n        context.textAlign = /** @type {CanvasTextAlign} */ (textAlign);\n      }\n      if (contextTextState.textBaseline != textState.textBaseline) {\n        contextTextState.textBaseline = /** @type {CanvasTextBaseline} */ (textState.textBaseline);\n        context.textBaseline = /** @type {CanvasTextBaseline} */ (textState.textBaseline);\n      }\n    }\n  }\n\n  /**\n   * Set the fill and stroke style for subsequent draw operations.  To clear\n   * either fill or stroke styles, pass null for the appropriate parameter.\n   *\n   * @param {import(\"../../style/Fill.js\").default} fillStyle Fill style.\n   * @param {import(\"../../style/Stroke.js\").default} strokeStyle Stroke style.\n   */\n  setFillStrokeStyle(fillStyle, strokeStyle) {\n    if (!fillStyle) {\n      this.fillState_ = null;\n    } else {\n      const fillStyleColor = fillStyle.getColor();\n      this.fillState_ = {\n        fillStyle: asColorLike(\n          fillStyleColor ? fillStyleColor : defaultFillStyle\n        ),\n      };\n    }\n    if (!strokeStyle) {\n      this.strokeState_ = null;\n    } else {\n      const strokeStyleColor = strokeStyle.getColor();\n      const strokeStyleLineCap = strokeStyle.getLineCap();\n      const strokeStyleLineDash = strokeStyle.getLineDash();\n      const strokeStyleLineDashOffset = strokeStyle.getLineDashOffset();\n      const strokeStyleLineJoin = strokeStyle.getLineJoin();\n      const strokeStyleWidth = strokeStyle.getWidth();\n      const strokeStyleMiterLimit = strokeStyle.getMiterLimit();\n      this.strokeState_ = {\n        lineCap:\n          strokeStyleLineCap !== undefined\n            ? strokeStyleLineCap\n            : defaultLineCap,\n        lineDash: strokeStyleLineDash ? strokeStyleLineDash : defaultLineDash,\n        lineDashOffset: strokeStyleLineDashOffset\n          ? strokeStyleLineDashOffset\n          : defaultLineDashOffset,\n        lineJoin:\n          strokeStyleLineJoin !== undefined\n            ? strokeStyleLineJoin\n            : defaultLineJoin,\n        lineWidth:\n          this.pixelRatio_ *\n          (strokeStyleWidth !== undefined\n            ? strokeStyleWidth\n            : defaultLineWidth),\n        miterLimit:\n          strokeStyleMiterLimit !== undefined\n            ? strokeStyleMiterLimit\n            : defaultMiterLimit,\n        strokeStyle: asColorLike(\n          strokeStyleColor ? strokeStyleColor : defaultStrokeStyle\n        ),\n      };\n    }\n  }\n\n  /**\n   * Set the image style for subsequent draw operations.  Pass null to remove\n   * the image style.\n   *\n   * @param {import(\"../../style/Image.js\").default} imageStyle Image style.\n   */\n  setImageStyle(imageStyle) {\n    if (!imageStyle) {\n      this.image_ = null;\n    } else {\n      const imageSize = imageStyle.getSize();\n      if (!imageSize) {\n        this.image_ = null;\n      } else {\n        const imageAnchor = imageStyle.getAnchor();\n        // FIXME pixel ratio\n        const imageImage = imageStyle.getImage(1);\n        const imageOrigin = imageStyle.getOrigin();\n        const imageScale = imageStyle.getScaleArray();\n        this.imageAnchorX_ = imageAnchor[0];\n        this.imageAnchorY_ = imageAnchor[1];\n        this.imageHeight_ = imageSize[1];\n        this.image_ = imageImage;\n        this.imageOpacity_ = imageStyle.getOpacity();\n        this.imageOriginX_ = imageOrigin[0];\n        this.imageOriginY_ = imageOrigin[1];\n        this.imageRotateWithView_ = imageStyle.getRotateWithView();\n        this.imageRotation_ = imageStyle.getRotation();\n        this.imageScale_ = [\n          this.pixelRatio_ * imageScale[0],\n          this.pixelRatio_ * imageScale[1],\n        ];\n        this.imageWidth_ = imageSize[0];\n      }\n    }\n  }\n\n  /**\n   * Set the text style for subsequent draw operations.  Pass null to\n   * remove the text style.\n   *\n   * @param {import(\"../../style/Text.js\").default} textStyle Text style.\n   */\n  setTextStyle(textStyle) {\n    if (!textStyle) {\n      this.text_ = '';\n    } else {\n      const textFillStyle = textStyle.getFill();\n      if (!textFillStyle) {\n        this.textFillState_ = null;\n      } else {\n        const textFillStyleColor = textFillStyle.getColor();\n        this.textFillState_ = {\n          fillStyle: asColorLike(\n            textFillStyleColor ? textFillStyleColor : defaultFillStyle\n          ),\n        };\n      }\n      const textStrokeStyle = textStyle.getStroke();\n      if (!textStrokeStyle) {\n        this.textStrokeState_ = null;\n      } else {\n        const textStrokeStyleColor = textStrokeStyle.getColor();\n        const textStrokeStyleLineCap = textStrokeStyle.getLineCap();\n        const textStrokeStyleLineDash = textStrokeStyle.getLineDash();\n        const textStrokeStyleLineDashOffset = textStrokeStyle.getLineDashOffset();\n        const textStrokeStyleLineJoin = textStrokeStyle.getLineJoin();\n        const textStrokeStyleWidth = textStrokeStyle.getWidth();\n        const textStrokeStyleMiterLimit = textStrokeStyle.getMiterLimit();\n        this.textStrokeState_ = {\n          lineCap:\n            textStrokeStyleLineCap !== undefined\n              ? textStrokeStyleLineCap\n              : defaultLineCap,\n          lineDash: textStrokeStyleLineDash\n            ? textStrokeStyleLineDash\n            : defaultLineDash,\n          lineDashOffset: textStrokeStyleLineDashOffset\n            ? textStrokeStyleLineDashOffset\n            : defaultLineDashOffset,\n          lineJoin:\n            textStrokeStyleLineJoin !== undefined\n              ? textStrokeStyleLineJoin\n              : defaultLineJoin,\n          lineWidth:\n            textStrokeStyleWidth !== undefined\n              ? textStrokeStyleWidth\n              : defaultLineWidth,\n          miterLimit:\n            textStrokeStyleMiterLimit !== undefined\n              ? textStrokeStyleMiterLimit\n              : defaultMiterLimit,\n          strokeStyle: asColorLike(\n            textStrokeStyleColor ? textStrokeStyleColor : defaultStrokeStyle\n          ),\n        };\n      }\n      const textFont = textStyle.getFont();\n      const textOffsetX = textStyle.getOffsetX();\n      const textOffsetY = textStyle.getOffsetY();\n      const textRotateWithView = textStyle.getRotateWithView();\n      const textRotation = textStyle.getRotation();\n      const textScale = textStyle.getScaleArray();\n      const textText = textStyle.getText();\n      const textTextAlign = textStyle.getTextAlign();\n      const textTextBaseline = textStyle.getTextBaseline();\n      this.textState_ = {\n        font: textFont !== undefined ? textFont : defaultFont,\n        textAlign:\n          textTextAlign !== undefined ? textTextAlign : defaultTextAlign,\n        textBaseline:\n          textTextBaseline !== undefined\n            ? textTextBaseline\n            : defaultTextBaseline,\n      };\n      this.text_ = textText !== undefined ? textText : '';\n      this.textOffsetX_ =\n        textOffsetX !== undefined ? this.pixelRatio_ * textOffsetX : 0;\n      this.textOffsetY_ =\n        textOffsetY !== undefined ? this.pixelRatio_ * textOffsetY : 0;\n      this.textRotateWithView_ =\n        textRotateWithView !== undefined ? textRotateWithView : false;\n      this.textRotation_ = textRotation !== undefined ? textRotation : 0;\n      this.textScale_ = [\n        this.pixelRatio_ * textScale[0],\n        this.pixelRatio_ * textScale[1],\n      ];\n    }\n  }\n}\n\nexport default CanvasImmediateRenderer;\n","/**\n * @module ol/renderer/vector\n */\nimport BuilderType from '../render/canvas/BuilderType.js';\nimport GeometryType from '../geom/GeometryType.js';\nimport ImageState from '../ImageState.js';\nimport {getUid} from '../util.js';\n\n/**\n * Feature callback. The callback will be called with three arguments. The first\n * argument is one {@link module:ol/Feature feature} or {@link module:ol/render/Feature render feature}\n * at the pixel, the second is the {@link module:ol/layer/Layer layer} of the feature and will be null for\n * unmanaged layers. The third is the {@link module:ol/geom/SimpleGeometry} of the feature. For features\n * with a GeometryCollection geometry, it will be the first detected geometry from the collection.\n * @template T\n * @typedef {function(import(\"../Feature.js\").FeatureLike, import(\"../layer/Layer.js\").default, import(\"../geom/SimpleGeometry.js\").default): T} FeatureCallback\n */\n\n/**\n * Tolerance for geometry simplification in device pixels.\n * @type {number}\n */\nconst SIMPLIFY_TOLERANCE = 0.5;\n\n/**\n * @const\n * @type {Object<import(\"../geom/GeometryType.js\").default,\n *                function(import(\"../render/canvas/BuilderGroup.js\").default, import(\"../geom/Geometry.js\").default,\n *                         import(\"../style/Style.js\").default, Object): void>}\n */\nconst GEOMETRY_RENDERERS = {\n  'Point': renderPointGeometry,\n  'LineString': renderLineStringGeometry,\n  'Polygon': renderPolygonGeometry,\n  'MultiPoint': renderMultiPointGeometry,\n  'MultiLineString': renderMultiLineStringGeometry,\n  'MultiPolygon': renderMultiPolygonGeometry,\n  'GeometryCollection': renderGeometryCollectionGeometry,\n  'Circle': renderCircleGeometry,\n};\n\n/**\n * @param {import(\"../Feature.js\").FeatureLike} feature1 Feature 1.\n * @param {import(\"../Feature.js\").FeatureLike} feature2 Feature 2.\n * @return {number} Order.\n */\nexport function defaultOrder(feature1, feature2) {\n  return parseInt(getUid(feature1), 10) - parseInt(getUid(feature2), 10);\n}\n\n/**\n * @param {number} resolution Resolution.\n * @param {number} pixelRatio Pixel ratio.\n * @return {number} Squared pixel tolerance.\n */\nexport function getSquaredTolerance(resolution, pixelRatio) {\n  const tolerance = getTolerance(resolution, pixelRatio);\n  return tolerance * tolerance;\n}\n\n/**\n * @param {number} resolution Resolution.\n * @param {number} pixelRatio Pixel ratio.\n * @return {number} Pixel tolerance.\n */\nexport function getTolerance(resolution, pixelRatio) {\n  return (SIMPLIFY_TOLERANCE * resolution) / pixelRatio;\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} builderGroup Builder group.\n * @param {import(\"../geom/Circle.js\").default} geometry Geometry.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {import(\"../Feature.js\").default} feature Feature.\n * @param {import(\"../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n */\nfunction renderCircleGeometry(\n  builderGroup,\n  geometry,\n  style,\n  feature,\n  opt_declutterBuilderGroup\n) {\n  const fillStyle = style.getFill();\n  const strokeStyle = style.getStroke();\n  if (fillStyle || strokeStyle) {\n    const circleReplay = builderGroup.getBuilder(\n      style.getZIndex(),\n      BuilderType.CIRCLE\n    );\n    circleReplay.setFillStrokeStyle(fillStyle, strokeStyle);\n    circleReplay.drawCircle(geometry, feature);\n  }\n  const textStyle = style.getText();\n  if (textStyle && textStyle.getText()) {\n    const textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(\n      style.getZIndex(),\n      BuilderType.TEXT\n    );\n    textReplay.setTextStyle(textStyle);\n    textReplay.drawText(geometry, feature);\n  }\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} replayGroup Replay group.\n * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {number} squaredTolerance Squared tolerance.\n * @param {function(import(\"../events/Event.js\").default): void} listener Listener function.\n * @param {import(\"../proj.js\").TransformFunction} [opt_transform] Transform from user to view projection.\n * @param {import(\"../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n * @return {boolean} `true` if style is loading.\n */\nexport function renderFeature(\n  replayGroup,\n  feature,\n  style,\n  squaredTolerance,\n  listener,\n  opt_transform,\n  opt_declutterBuilderGroup\n) {\n  let loading = false;\n  const imageStyle = style.getImage();\n  if (imageStyle) {\n    let imageState = imageStyle.getImageState();\n    if (imageState == ImageState.LOADED || imageState == ImageState.ERROR) {\n      imageStyle.unlistenImageChange(listener);\n    } else {\n      if (imageState == ImageState.IDLE) {\n        imageStyle.load();\n      }\n      imageState = imageStyle.getImageState();\n      imageStyle.listenImageChange(listener);\n      loading = true;\n    }\n  }\n  renderFeatureInternal(\n    replayGroup,\n    feature,\n    style,\n    squaredTolerance,\n    opt_transform,\n    opt_declutterBuilderGroup\n  );\n\n  return loading;\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} replayGroup Replay group.\n * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {number} squaredTolerance Squared tolerance.\n * @param {import(\"../proj.js\").TransformFunction} [opt_transform] Optional transform function.\n * @param {import(\"../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n */\nfunction renderFeatureInternal(\n  replayGroup,\n  feature,\n  style,\n  squaredTolerance,\n  opt_transform,\n  opt_declutterBuilderGroup\n) {\n  const geometry = style.getGeometryFunction()(feature);\n  if (!geometry) {\n    return;\n  }\n  const simplifiedGeometry = geometry.simplifyTransformed(\n    squaredTolerance,\n    opt_transform\n  );\n  const renderer = style.getRenderer();\n  if (renderer) {\n    renderGeometry(replayGroup, simplifiedGeometry, style, feature);\n  } else {\n    const geometryRenderer = GEOMETRY_RENDERERS[simplifiedGeometry.getType()];\n    geometryRenderer(\n      replayGroup,\n      simplifiedGeometry,\n      style,\n      feature,\n      opt_declutterBuilderGroup\n    );\n  }\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} replayGroup Replay group.\n * @param {import(\"../geom/Geometry.js\").default|import(\"../render/Feature.js\").default} geometry Geometry.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n */\nfunction renderGeometry(replayGroup, geometry, style, feature) {\n  if (geometry.getType() == GeometryType.GEOMETRY_COLLECTION) {\n    const geometries = /** @type {import(\"../geom/GeometryCollection.js\").default} */ (geometry).getGeometries();\n    for (let i = 0, ii = geometries.length; i < ii; ++i) {\n      renderGeometry(replayGroup, geometries[i], style, feature);\n    }\n    return;\n  }\n  const replay = replayGroup.getBuilder(style.getZIndex(), BuilderType.DEFAULT);\n  replay.drawCustom(\n    /** @type {import(\"../geom/SimpleGeometry.js\").default} */ (geometry),\n    feature,\n    style.getRenderer()\n  );\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} replayGroup Replay group.\n * @param {import(\"../geom/GeometryCollection.js\").default} geometry Geometry.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {import(\"../Feature.js\").default} feature Feature.\n * @param {import(\"../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n */\nfunction renderGeometryCollectionGeometry(\n  replayGroup,\n  geometry,\n  style,\n  feature,\n  opt_declutterBuilderGroup\n) {\n  const geometries = geometry.getGeometriesArray();\n  let i, ii;\n  for (i = 0, ii = geometries.length; i < ii; ++i) {\n    const geometryRenderer = GEOMETRY_RENDERERS[geometries[i].getType()];\n    geometryRenderer(\n      replayGroup,\n      geometries[i],\n      style,\n      feature,\n      opt_declutterBuilderGroup\n    );\n  }\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} builderGroup Replay group.\n * @param {import(\"../geom/LineString.js\").default|import(\"../render/Feature.js\").default} geometry Geometry.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n * @param {import(\"../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n */\nfunction renderLineStringGeometry(\n  builderGroup,\n  geometry,\n  style,\n  feature,\n  opt_declutterBuilderGroup\n) {\n  const strokeStyle = style.getStroke();\n  if (strokeStyle) {\n    const lineStringReplay = builderGroup.getBuilder(\n      style.getZIndex(),\n      BuilderType.LINE_STRING\n    );\n    lineStringReplay.setFillStrokeStyle(null, strokeStyle);\n    lineStringReplay.drawLineString(geometry, feature);\n  }\n  const textStyle = style.getText();\n  if (textStyle && textStyle.getText()) {\n    const textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(\n      style.getZIndex(),\n      BuilderType.TEXT\n    );\n    textReplay.setTextStyle(textStyle);\n    textReplay.drawText(geometry, feature);\n  }\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} builderGroup Replay group.\n * @param {import(\"../geom/MultiLineString.js\").default|import(\"../render/Feature.js\").default} geometry Geometry.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n * @param {import(\"../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n */\nfunction renderMultiLineStringGeometry(\n  builderGroup,\n  geometry,\n  style,\n  feature,\n  opt_declutterBuilderGroup\n) {\n  const strokeStyle = style.getStroke();\n  if (strokeStyle) {\n    const lineStringReplay = builderGroup.getBuilder(\n      style.getZIndex(),\n      BuilderType.LINE_STRING\n    );\n    lineStringReplay.setFillStrokeStyle(null, strokeStyle);\n    lineStringReplay.drawMultiLineString(geometry, feature);\n  }\n  const textStyle = style.getText();\n  if (textStyle && textStyle.getText()) {\n    const textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(\n      style.getZIndex(),\n      BuilderType.TEXT\n    );\n    textReplay.setTextStyle(textStyle);\n    textReplay.drawText(geometry, feature);\n  }\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} builderGroup Replay group.\n * @param {import(\"../geom/MultiPolygon.js\").default} geometry Geometry.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {import(\"../Feature.js\").default} feature Feature.\n * @param {import(\"../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n */\nfunction renderMultiPolygonGeometry(\n  builderGroup,\n  geometry,\n  style,\n  feature,\n  opt_declutterBuilderGroup\n) {\n  const fillStyle = style.getFill();\n  const strokeStyle = style.getStroke();\n  if (strokeStyle || fillStyle) {\n    const polygonReplay = builderGroup.getBuilder(\n      style.getZIndex(),\n      BuilderType.POLYGON\n    );\n    polygonReplay.setFillStrokeStyle(fillStyle, strokeStyle);\n    polygonReplay.drawMultiPolygon(geometry, feature);\n  }\n  const textStyle = style.getText();\n  if (textStyle && textStyle.getText()) {\n    const textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(\n      style.getZIndex(),\n      BuilderType.TEXT\n    );\n    textReplay.setTextStyle(textStyle);\n    textReplay.drawText(geometry, feature);\n  }\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} builderGroup Replay group.\n * @param {import(\"../geom/Point.js\").default|import(\"../render/Feature.js\").default} geometry Geometry.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n * @param {import(\"../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n */\nfunction renderPointGeometry(\n  builderGroup,\n  geometry,\n  style,\n  feature,\n  opt_declutterBuilderGroup\n) {\n  const imageStyle = style.getImage();\n  const textStyle = style.getText();\n  /** @type {import(\"../render/canvas.js\").DeclutterImageWithText} */\n  let declutterImageWithText;\n  if (opt_declutterBuilderGroup) {\n    builderGroup = opt_declutterBuilderGroup;\n    declutterImageWithText =\n      imageStyle && textStyle && textStyle.getText() ? {} : undefined;\n  }\n  if (imageStyle) {\n    if (imageStyle.getImageState() != ImageState.LOADED) {\n      return;\n    }\n    const imageReplay = builderGroup.getBuilder(\n      style.getZIndex(),\n      BuilderType.IMAGE\n    );\n    imageReplay.setImageStyle(imageStyle, declutterImageWithText);\n    imageReplay.drawPoint(geometry, feature);\n  }\n  if (textStyle && textStyle.getText()) {\n    const textReplay = builderGroup.getBuilder(\n      style.getZIndex(),\n      BuilderType.TEXT\n    );\n    textReplay.setTextStyle(textStyle, declutterImageWithText);\n    textReplay.drawText(geometry, feature);\n  }\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} builderGroup Replay group.\n * @param {import(\"../geom/MultiPoint.js\").default|import(\"../render/Feature.js\").default} geometry Geometry.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n * @param {import(\"../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n */\nfunction renderMultiPointGeometry(\n  builderGroup,\n  geometry,\n  style,\n  feature,\n  opt_declutterBuilderGroup\n) {\n  const imageStyle = style.getImage();\n  const textStyle = style.getText();\n  /** @type {import(\"../render/canvas.js\").DeclutterImageWithText} */\n  let declutterImageWithText;\n  if (opt_declutterBuilderGroup) {\n    builderGroup = opt_declutterBuilderGroup;\n    declutterImageWithText =\n      imageStyle && textStyle && textStyle.getText() ? {} : undefined;\n  }\n  if (imageStyle) {\n    if (imageStyle.getImageState() != ImageState.LOADED) {\n      return;\n    }\n    const imageReplay = builderGroup.getBuilder(\n      style.getZIndex(),\n      BuilderType.IMAGE\n    );\n    imageReplay.setImageStyle(imageStyle, declutterImageWithText);\n    imageReplay.drawMultiPoint(geometry, feature);\n  }\n  if (textStyle && textStyle.getText()) {\n    const textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(\n      style.getZIndex(),\n      BuilderType.TEXT\n    );\n    textReplay.setTextStyle(textStyle, declutterImageWithText);\n    textReplay.drawText(geometry, feature);\n  }\n}\n\n/**\n * @param {import(\"../render/canvas/BuilderGroup.js\").default} builderGroup Replay group.\n * @param {import(\"../geom/Polygon.js\").default|import(\"../render/Feature.js\").default} geometry Geometry.\n * @param {import(\"../style/Style.js\").default} style Style.\n * @param {import(\"../Feature.js\").FeatureLike} feature Feature.\n * @param {import(\"../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n */\nfunction renderPolygonGeometry(\n  builderGroup,\n  geometry,\n  style,\n  feature,\n  opt_declutterBuilderGroup\n) {\n  const fillStyle = style.getFill();\n  const strokeStyle = style.getStroke();\n  if (fillStyle || strokeStyle) {\n    const polygonReplay = builderGroup.getBuilder(\n      style.getZIndex(),\n      BuilderType.POLYGON\n    );\n    polygonReplay.setFillStrokeStyle(fillStyle, strokeStyle);\n    polygonReplay.drawPolygon(geometry, feature);\n  }\n  const textStyle = style.getText();\n  if (textStyle && textStyle.getText()) {\n    const textReplay = (opt_declutterBuilderGroup || builderGroup).getBuilder(\n      style.getZIndex(),\n      BuilderType.TEXT\n    );\n    textReplay.setTextStyle(textStyle);\n    textReplay.drawText(geometry, feature);\n  }\n}\n","/**\n * @module ol/renderer/canvas/VectorLayer\n */\nimport CanvasBuilderGroup from '../../render/canvas/BuilderGroup.js';\nimport CanvasLayerRenderer from './Layer.js';\nimport ExecutorGroup from '../../render/canvas/ExecutorGroup.js';\nimport ViewHint from '../../ViewHint.js';\nimport {\n  apply,\n  makeInverse,\n  makeScale,\n  toString as transformToString,\n} from '../../transform.js';\nimport {\n  buffer,\n  containsExtent,\n  createEmpty,\n  getWidth,\n  intersects as intersectsExtent,\n  wrapX as wrapExtentX,\n} from '../../extent.js';\nimport {\n  createHitDetectionImageData,\n  hitDetect,\n} from '../../render/canvas/hitdetect.js';\nimport {\n  defaultOrder as defaultRenderOrder,\n  getTolerance as getRenderTolerance,\n  getSquaredTolerance as getSquaredRenderTolerance,\n  renderFeature,\n} from '../vector.js';\nimport {\n  fromUserExtent,\n  getTransformFromProjections,\n  getUserProjection,\n  toUserExtent,\n} from '../../proj.js';\nimport {getUid} from '../../util.js';\nimport {wrapX as wrapCoordinateX} from '../../coordinate.js';\n\n/**\n * @classdesc\n * Canvas renderer for vector layers.\n * @api\n */\nclass CanvasVectorLayerRenderer extends CanvasLayerRenderer {\n  /**\n   * @param {import(\"../../layer/Vector.js\").default} vectorLayer Vector layer.\n   */\n  constructor(vectorLayer) {\n    super(vectorLayer);\n\n    /** @private */\n    this.boundHandleStyleImageChange_ = this.handleStyleImageChange_.bind(this);\n\n    /**\n     * @type {boolean}\n     */\n    this.animatingOrInteracting_;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.dirty_ = false;\n\n    /**\n     * @type {ImageData}\n     */\n    this.hitDetectionImageData_ = null;\n\n    /**\n     * @type {Array<import(\"../../Feature.js\").default>}\n     */\n    this.renderedFeatures_ = null;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.renderedRevision_ = -1;\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.renderedResolution_ = NaN;\n\n    /**\n     * @private\n     * @type {import(\"../../extent.js\").Extent}\n     */\n    this.renderedExtent_ = createEmpty();\n\n    /**\n     * @private\n     * @type {number}\n     */\n    this.renderedRotation_;\n\n    /**\n     * @private\n     * @type {import(\"../../coordinate\").Coordinate}\n     */\n    this.renderedCenter_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../../proj/Projection\").default}\n     */\n    this.renderedProjection_ = null;\n\n    /**\n     * @private\n     * @type {function(import(\"../../Feature.js\").default, import(\"../../Feature.js\").default): number|null}\n     */\n    this.renderedRenderOrder_ = null;\n\n    /**\n     * @private\n     * @type {import(\"../../render/canvas/ExecutorGroup\").default}\n     */\n    this.replayGroup_ = null;\n\n    /**\n     * A new replay group had to be created by `prepareFrame()`\n     * @type {boolean}\n     */\n    this.replayGroupChanged = true;\n\n    /**\n     * @type {import(\"../../render/canvas/ExecutorGroup\").default}\n     */\n    this.declutterExecutorGroup = null;\n\n    /**\n     * Clipping to be performed by `renderFrame()`\n     * @type {boolean}\n     */\n    this.clipping = true;\n  }\n\n  /**\n   * Get a rendering container from an existing target, if compatible.\n   * @param {HTMLElement} target Potential render target.\n   * @param {string} transform CSS Transform.\n   * @param {number} opacity Opacity.\n   */\n  useContainer(target, transform, opacity) {\n    if (opacity < 1) {\n      target = null;\n    }\n    super.useContainer(target, transform, opacity);\n  }\n\n  /**\n   * @param {ExecutorGroup} executorGroup Executor group.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {import(\"rbush\").default=} opt_declutterTree Declutter tree.\n   */\n  renderWorlds(executorGroup, frameState, opt_declutterTree) {\n    const extent = frameState.extent;\n    const viewState = frameState.viewState;\n    const center = viewState.center;\n    const resolution = viewState.resolution;\n    const projection = viewState.projection;\n    const rotation = viewState.rotation;\n    const projectionExtent = projection.getExtent();\n    const vectorSource = this.getLayer().getSource();\n    const pixelRatio = frameState.pixelRatio;\n    const viewHints = frameState.viewHints;\n    const snapToPixel = !(\n      viewHints[ViewHint.ANIMATING] || viewHints[ViewHint.INTERACTING]\n    );\n    const context = this.context;\n    const width = Math.round(frameState.size[0] * pixelRatio);\n    const height = Math.round(frameState.size[1] * pixelRatio);\n\n    const multiWorld = vectorSource.getWrapX() && projection.canWrapX();\n    const worldWidth = multiWorld ? getWidth(projectionExtent) : null;\n    const endWorld = multiWorld\n      ? Math.ceil((extent[2] - projectionExtent[2]) / worldWidth) + 1\n      : 1;\n    let world = multiWorld\n      ? Math.floor((extent[0] - projectionExtent[0]) / worldWidth)\n      : 0;\n    do {\n      const transform = this.getRenderTransform(\n        center,\n        resolution,\n        rotation,\n        pixelRatio,\n        width,\n        height,\n        world * worldWidth\n      );\n      executorGroup.execute(\n        context,\n        1,\n        transform,\n        rotation,\n        snapToPixel,\n        undefined,\n        opt_declutterTree\n      );\n    } while (++world < endWorld);\n  }\n\n  /**\n   * Render declutter items for this layer\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   */\n  renderDeclutter(frameState) {\n    if (this.declutterExecutorGroup) {\n      this.renderWorlds(\n        this.declutterExecutorGroup,\n        frameState,\n        frameState.declutterTree\n      );\n    }\n  }\n\n  /**\n   * Render the layer.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {HTMLElement} target Target that may be used to render content to.\n   * @return {HTMLElement} The rendered element.\n   */\n  renderFrame(frameState, target) {\n    const pixelRatio = frameState.pixelRatio;\n    const layerState = frameState.layerStatesArray[frameState.layerIndex];\n\n    // set forward and inverse pixel transforms\n    makeScale(this.pixelTransform, 1 / pixelRatio, 1 / pixelRatio);\n    makeInverse(this.inversePixelTransform, this.pixelTransform);\n\n    const canvasTransform = transformToString(this.pixelTransform);\n\n    this.useContainer(target, canvasTransform, layerState.opacity);\n    const context = this.context;\n    const canvas = context.canvas;\n\n    const replayGroup = this.replayGroup_;\n    const declutterExecutorGroup = this.declutterExecutorGroup;\n    if (\n      (!replayGroup || replayGroup.isEmpty()) &&\n      (!declutterExecutorGroup || declutterExecutorGroup.isEmpty())\n    ) {\n      if (!this.containerReused && canvas.width > 0) {\n        canvas.width = 0;\n      }\n      return this.container;\n    }\n\n    // resize and clear\n    const width = Math.round(frameState.size[0] * pixelRatio);\n    const height = Math.round(frameState.size[1] * pixelRatio);\n    if (canvas.width != width || canvas.height != height) {\n      canvas.width = width;\n      canvas.height = height;\n      if (canvas.style.transform !== canvasTransform) {\n        canvas.style.transform = canvasTransform;\n      }\n    } else if (!this.containerReused) {\n      context.clearRect(0, 0, width, height);\n    }\n\n    this.preRender(context, frameState);\n\n    const viewState = frameState.viewState;\n    const projection = viewState.projection;\n\n    // clipped rendering if layer extent is set\n    let clipped = false;\n    if (layerState.extent && this.clipping) {\n      const layerExtent = fromUserExtent(layerState.extent, projection);\n      clipped =\n        !containsExtent(layerExtent, frameState.extent) &&\n        intersectsExtent(layerExtent, frameState.extent);\n      if (clipped) {\n        this.clipUnrotated(context, frameState, layerExtent);\n      }\n    }\n\n    this.renderWorlds(replayGroup, frameState);\n\n    if (clipped) {\n      context.restore();\n    }\n\n    this.postRender(context, frameState);\n\n    const opacity = layerState.opacity;\n    const container = this.container;\n    if (opacity !== parseFloat(container.style.opacity)) {\n      container.style.opacity = opacity === 1 ? '' : String(opacity);\n    }\n\n    if (this.renderedRotation_ !== viewState.rotation) {\n      this.renderedRotation_ = viewState.rotation;\n      this.hitDetectionImageData_ = null;\n    }\n    return this.container;\n  }\n\n  /**\n   * Asynchronous layer level hit detection.\n   * @param {import(\"../../pixel.js\").Pixel} pixel Pixel.\n   * @return {Promise<Array<import(\"../../Feature\").default>>} Promise that resolves with an array of features.\n   */\n  getFeatures(pixel) {\n    return new Promise(\n      /**\n       * @param {function(Array<import(\"../../Feature\").default|import(\"../../render/Feature\").default>): void} resolve Resolver function.\n       * @this {CanvasVectorLayerRenderer}\n       */\n      function (resolve) {\n        if (!this.hitDetectionImageData_ && !this.animatingOrInteracting_) {\n          const size = [this.context.canvas.width, this.context.canvas.height];\n          apply(this.pixelTransform, size);\n          const center = this.renderedCenter_;\n          const resolution = this.renderedResolution_;\n          const rotation = this.renderedRotation_;\n          const projection = this.renderedProjection_;\n          const extent = this.renderedExtent_;\n          const layer = this.getLayer();\n          const transforms = [];\n          const width = size[0] / 2;\n          const height = size[1] / 2;\n          transforms.push(\n            this.getRenderTransform(\n              center,\n              resolution,\n              rotation,\n              0.5,\n              width,\n              height,\n              0\n            ).slice()\n          );\n          const source = layer.getSource();\n          const projectionExtent = projection.getExtent();\n          if (\n            source.getWrapX() &&\n            projection.canWrapX() &&\n            !containsExtent(projectionExtent, extent)\n          ) {\n            let startX = extent[0];\n            const worldWidth = getWidth(projectionExtent);\n            let world = 0;\n            let offsetX;\n            while (startX < projectionExtent[0]) {\n              --world;\n              offsetX = worldWidth * world;\n              transforms.push(\n                this.getRenderTransform(\n                  center,\n                  resolution,\n                  rotation,\n                  0.5,\n                  width,\n                  height,\n                  offsetX\n                ).slice()\n              );\n              startX += worldWidth;\n            }\n            world = 0;\n            startX = extent[2];\n            while (startX > projectionExtent[2]) {\n              ++world;\n              offsetX = worldWidth * world;\n              transforms.push(\n                this.getRenderTransform(\n                  center,\n                  resolution,\n                  rotation,\n                  0.5,\n                  width,\n                  height,\n                  offsetX\n                ).slice()\n              );\n              startX -= worldWidth;\n            }\n          }\n\n          this.hitDetectionImageData_ = createHitDetectionImageData(\n            size,\n            transforms,\n            this.renderedFeatures_,\n            layer.getStyleFunction(),\n            extent,\n            resolution,\n            rotation\n          );\n        }\n        resolve(\n          hitDetect(pixel, this.renderedFeatures_, this.hitDetectionImageData_)\n        );\n      }.bind(this)\n    );\n  }\n\n  /**\n   * @param {import(\"../../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @param {number} hitTolerance Hit tolerance in pixels.\n   * @param {import(\"../vector.js\").FeatureCallback<T>} callback Feature callback.\n   * @param {Array<import(\"../Map.js\").HitMatch<T>>} matches The hit detected matches with tolerance.\n   * @return {T|undefined} Callback result.\n   * @template T\n   */\n  forEachFeatureAtCoordinate(\n    coordinate,\n    frameState,\n    hitTolerance,\n    callback,\n    matches\n  ) {\n    if (!this.replayGroup_) {\n      return undefined;\n    }\n    const resolution = frameState.viewState.resolution;\n    const rotation = frameState.viewState.rotation;\n    const layer = this.getLayer();\n\n    /** @type {!Object<string, import(\"../Map.js\").HitMatch<T>|true>} */\n    const features = {};\n\n    /**\n     * @param {import(\"../../Feature.js\").FeatureLike} feature Feature.\n     * @param {import(\"../../geom/SimpleGeometry.js\").default} geometry Geometry.\n     * @param {number} distanceSq The squared distance to the click position\n     * @return {T|undefined} Callback result.\n     */\n    const featureCallback = function (feature, geometry, distanceSq) {\n      const key = getUid(feature);\n      const match = features[key];\n      if (!match) {\n        if (distanceSq === 0) {\n          features[key] = true;\n          return callback(feature, layer, geometry);\n        }\n        matches.push(\n          (features[key] = {\n            feature: feature,\n            layer: layer,\n            geometry: geometry,\n            distanceSq: distanceSq,\n            callback: callback,\n          })\n        );\n      } else if (match !== true && distanceSq < match.distanceSq) {\n        if (distanceSq === 0) {\n          features[key] = true;\n          matches.splice(matches.lastIndexOf(match), 1);\n          return callback(feature, layer, geometry);\n        }\n        match.geometry = geometry;\n        match.distanceSq = distanceSq;\n      }\n      return undefined;\n    };\n\n    let result;\n    const executorGroups = [this.replayGroup_];\n    if (this.declutterExecutorGroup) {\n      executorGroups.push(this.declutterExecutorGroup);\n    }\n    executorGroups.some((executorGroup) => {\n      return (result = executorGroup.forEachFeatureAtCoordinate(\n        coordinate,\n        resolution,\n        rotation,\n        hitTolerance,\n        featureCallback,\n        executorGroup === this.declutterExecutorGroup\n          ? frameState.declutterTree.all().map((item) => item.value)\n          : null\n      ));\n    });\n\n    return result;\n  }\n\n  /**\n   * Perform action necessary to get the layer rendered after new fonts have loaded\n   */\n  handleFontsChanged() {\n    const layer = this.getLayer();\n    if (layer.getVisible() && this.replayGroup_) {\n      layer.changed();\n    }\n  }\n\n  /**\n   * Handle changes in image style state.\n   * @param {import(\"../../events/Event.js\").default} event Image style change event.\n   * @private\n   */\n  handleStyleImageChange_(event) {\n    this.renderIfReadyAndVisible();\n  }\n\n  /**\n   * Determine whether render should be called.\n   * @param {import(\"../../PluggableMap.js\").FrameState} frameState Frame state.\n   * @return {boolean} Layer is ready to be rendered.\n   */\n  prepareFrame(frameState) {\n    const vectorLayer = this.getLayer();\n    const vectorSource = vectorLayer.getSource();\n    if (!vectorSource) {\n      return false;\n    }\n\n    const animating = frameState.viewHints[ViewHint.ANIMATING];\n    const interacting = frameState.viewHints[ViewHint.INTERACTING];\n    const updateWhileAnimating = vectorLayer.getUpdateWhileAnimating();\n    const updateWhileInteracting = vectorLayer.getUpdateWhileInteracting();\n\n    if (\n      (!this.dirty_ && !updateWhileAnimating && animating) ||\n      (!updateWhileInteracting && interacting)\n    ) {\n      this.animatingOrInteracting_ = true;\n      return true;\n    }\n    this.animatingOrInteracting_ = false;\n\n    const frameStateExtent = frameState.extent;\n    const viewState = frameState.viewState;\n    const projection = viewState.projection;\n    const resolution = viewState.resolution;\n    const pixelRatio = frameState.pixelRatio;\n    const vectorLayerRevision = vectorLayer.getRevision();\n    const vectorLayerRenderBuffer = vectorLayer.getRenderBuffer();\n    let vectorLayerRenderOrder = vectorLayer.getRenderOrder();\n\n    if (vectorLayerRenderOrder === undefined) {\n      vectorLayerRenderOrder = defaultRenderOrder;\n    }\n\n    const center = viewState.center.slice();\n    const extent = buffer(\n      frameStateExtent,\n      vectorLayerRenderBuffer * resolution\n    );\n    const loadExtents = [extent.slice()];\n    const projectionExtent = projection.getExtent();\n\n    if (\n      vectorSource.getWrapX() &&\n      projection.canWrapX() &&\n      !containsExtent(projectionExtent, frameState.extent)\n    ) {\n      // For the replay group, we need an extent that intersects the real world\n      // (-180° to +180°). To support geometries in a coordinate range from -540°\n      // to +540°, we add at least 1 world width on each side of the projection\n      // extent. If the viewport is wider than the world, we need to add half of\n      // the viewport width to make sure we cover the whole viewport.\n      const worldWidth = getWidth(projectionExtent);\n      const gutter = Math.max(getWidth(extent) / 2, worldWidth);\n      extent[0] = projectionExtent[0] - gutter;\n      extent[2] = projectionExtent[2] + gutter;\n      wrapCoordinateX(center, projection);\n      const loadExtent = wrapExtentX(loadExtents[0], projection);\n      // If the extent crosses the date line, we load data for both edges of the worlds\n      if (\n        loadExtent[0] < projectionExtent[0] &&\n        loadExtent[2] < projectionExtent[2]\n      ) {\n        loadExtents.push([\n          loadExtent[0] + worldWidth,\n          loadExtent[1],\n          loadExtent[2] + worldWidth,\n          loadExtent[3],\n        ]);\n      } else if (\n        loadExtent[0] > projectionExtent[0] &&\n        loadExtent[2] > projectionExtent[2]\n      ) {\n        loadExtents.push([\n          loadExtent[0] - worldWidth,\n          loadExtent[1],\n          loadExtent[2] - worldWidth,\n          loadExtent[3],\n        ]);\n      }\n    }\n\n    if (\n      !this.dirty_ &&\n      this.renderedResolution_ == resolution &&\n      this.renderedRevision_ == vectorLayerRevision &&\n      this.renderedRenderOrder_ == vectorLayerRenderOrder &&\n      containsExtent(this.renderedExtent_, extent)\n    ) {\n      this.replayGroupChanged = false;\n      return true;\n    }\n\n    this.replayGroup_ = null;\n\n    this.dirty_ = false;\n\n    const replayGroup = new CanvasBuilderGroup(\n      getRenderTolerance(resolution, pixelRatio),\n      extent,\n      resolution,\n      pixelRatio\n    );\n\n    let declutterBuilderGroup;\n    if (this.getLayer().getDeclutter()) {\n      declutterBuilderGroup = new CanvasBuilderGroup(\n        getRenderTolerance(resolution, pixelRatio),\n        extent,\n        resolution,\n        pixelRatio\n      );\n    }\n\n    const userProjection = getUserProjection();\n    let userTransform;\n    if (userProjection) {\n      for (let i = 0, ii = loadExtents.length; i < ii; ++i) {\n        vectorSource.loadFeatures(\n          toUserExtent(loadExtents[i], projection),\n          resolution,\n          userProjection\n        );\n      }\n      userTransform = getTransformFromProjections(userProjection, projection);\n    } else {\n      for (let i = 0, ii = loadExtents.length; i < ii; ++i) {\n        vectorSource.loadFeatures(loadExtents[i], resolution, projection);\n      }\n    }\n\n    const squaredTolerance = getSquaredRenderTolerance(resolution, pixelRatio);\n\n    const render =\n      /**\n       * @param {import(\"../../Feature.js\").default} feature Feature.\n       * @this {CanvasVectorLayerRenderer}\n       */\n      function (feature) {\n        let styles;\n        const styleFunction =\n          feature.getStyleFunction() || vectorLayer.getStyleFunction();\n        if (styleFunction) {\n          styles = styleFunction(feature, resolution);\n        }\n        if (styles) {\n          const dirty = this.renderFeature(\n            feature,\n            squaredTolerance,\n            styles,\n            replayGroup,\n            userTransform,\n            declutterBuilderGroup\n          );\n          this.dirty_ = this.dirty_ || dirty;\n        }\n      }.bind(this);\n\n    const userExtent = toUserExtent(extent, projection);\n    /** @type {Array<import(\"../../Feature.js\").default>} */\n    const features = vectorSource.getFeaturesInExtent(userExtent);\n    if (vectorLayerRenderOrder) {\n      features.sort(vectorLayerRenderOrder);\n    }\n    for (let i = 0, ii = features.length; i < ii; ++i) {\n      render(features[i]);\n    }\n    this.renderedFeatures_ = features;\n\n    const replayGroupInstructions = replayGroup.finish();\n    const executorGroup = new ExecutorGroup(\n      extent,\n      resolution,\n      pixelRatio,\n      vectorSource.getOverlaps(),\n      replayGroupInstructions,\n      vectorLayer.getRenderBuffer()\n    );\n\n    if (declutterBuilderGroup) {\n      this.declutterExecutorGroup = new ExecutorGroup(\n        extent,\n        resolution,\n        pixelRatio,\n        vectorSource.getOverlaps(),\n        declutterBuilderGroup.finish(),\n        vectorLayer.getRenderBuffer()\n      );\n    }\n\n    this.renderedResolution_ = resolution;\n    this.renderedRevision_ = vectorLayerRevision;\n    this.renderedRenderOrder_ = vectorLayerRenderOrder;\n    this.renderedExtent_ = extent;\n    this.renderedCenter_ = center;\n    this.renderedProjection_ = projection;\n    this.replayGroup_ = executorGroup;\n    this.hitDetectionImageData_ = null;\n\n    this.replayGroupChanged = true;\n    return true;\n  }\n\n  /**\n   * @param {import(\"../../Feature.js\").default} feature Feature.\n   * @param {number} squaredTolerance Squared render tolerance.\n   * @param {import(\"../../style/Style.js\").default|Array<import(\"../../style/Style.js\").default>} styles The style or array of styles.\n   * @param {import(\"../../render/canvas/BuilderGroup.js\").default} builderGroup Builder group.\n   * @param {import(\"../../proj.js\").TransformFunction=} opt_transform Transform from user to view projection.\n   * @param {import(\"../../render/canvas/BuilderGroup.js\").default=} opt_declutterBuilderGroup Builder for decluttering.\n   * @return {boolean} `true` if an image is loading.\n   */\n  renderFeature(\n    feature,\n    squaredTolerance,\n    styles,\n    builderGroup,\n    opt_transform,\n    opt_declutterBuilderGroup\n  ) {\n    if (!styles) {\n      return false;\n    }\n    let loading = false;\n    if (Array.isArray(styles)) {\n      for (let i = 0, ii = styles.length; i < ii; ++i) {\n        loading =\n          renderFeature(\n            builderGroup,\n            feature,\n            styles[i],\n            squaredTolerance,\n            this.boundHandleStyleImageChange_,\n            opt_transform,\n            opt_declutterBuilderGroup\n          ) || loading;\n      }\n    } else {\n      loading = renderFeature(\n        builderGroup,\n        feature,\n        styles,\n        squaredTolerance,\n        this.boundHandleStyleImageChange_,\n        opt_transform,\n        opt_declutterBuilderGroup\n      );\n    }\n    return loading;\n  }\n}\n\nexport default CanvasVectorLayerRenderer;\n","/**\n * @module ol/render/canvas/hitdetect\n */\n\nimport CanvasImmediateRenderer from './Immediate.js';\nimport GeometryType from '../../geom/GeometryType.js';\nimport IconAnchorUnits from '../../style/IconAnchorUnits.js';\nimport {Icon} from '../../style.js';\nimport {createCanvasContext2D} from '../../dom.js';\nimport {intersects} from '../../extent.js';\nimport {numberSafeCompareFunction} from '../../array.js';\n\n/**\n * @param {import(\"../../size.js\").Size} size Canvas size in css pixels.\n * @param {Array<import(\"../../transform.js\").Transform>} transforms Transforms\n * for rendering features to all worlds of the viewport, from coordinates to css\n * pixels.\n * @param {Array<import(\"../../Feature.js\").FeatureLike>} features\n * Features to consider for hit detection.\n * @param {import(\"../../style/Style.js\").StyleFunction|undefined} styleFunction\n * Layer style function.\n * @param {import(\"../../extent.js\").Extent} extent Extent.\n * @param {number} resolution Resolution.\n * @param {number} rotation Rotation.\n * @return {ImageData} Hit detection image data.\n */\nexport function createHitDetectionImageData(\n  size,\n  transforms,\n  features,\n  styleFunction,\n  extent,\n  resolution,\n  rotation\n) {\n  const width = size[0] / 2;\n  const height = size[1] / 2;\n  const context = createCanvasContext2D(width, height);\n  context.imageSmoothingEnabled = false;\n  const canvas = context.canvas;\n  const renderer = new CanvasImmediateRenderer(\n    context,\n    0.5,\n    extent,\n    null,\n    rotation\n  );\n  const featureCount = features.length;\n  // Stretch hit detection index to use the whole available color range\n  const indexFactor = Math.floor((256 * 256 * 256 - 1) / featureCount);\n  const featuresByZIndex = {};\n  for (let i = 1; i <= featureCount; ++i) {\n    const feature = features[i - 1];\n    const featureStyleFunction = feature.getStyleFunction() || styleFunction;\n    if (!styleFunction) {\n      continue;\n    }\n    let styles = featureStyleFunction(feature, resolution);\n    if (!styles) {\n      continue;\n    }\n    if (!Array.isArray(styles)) {\n      styles = [styles];\n    }\n    const index = i * indexFactor;\n    const color = '#' + ('000000' + index.toString(16)).slice(-6);\n    for (let j = 0, jj = styles.length; j < jj; ++j) {\n      const originalStyle = styles[j];\n      const style = originalStyle.clone();\n      const fill = style.getFill();\n      if (fill) {\n        fill.setColor(color);\n      }\n      const stroke = style.getStroke();\n      if (stroke) {\n        stroke.setColor(color);\n      }\n      style.setText(undefined);\n      const image = originalStyle.getImage();\n      if (image) {\n        const imgSize = image.getImageSize();\n        if (!imgSize) {\n          continue;\n        }\n\n        const canvas = document.createElement('canvas');\n        canvas.width = imgSize[0];\n        canvas.height = imgSize[1];\n        const imgContext = canvas.getContext('2d', {alpha: false});\n        imgContext.fillStyle = color;\n        const img = imgContext.canvas;\n        imgContext.fillRect(0, 0, img.width, img.height);\n        const width = imgSize ? imgSize[0] : img.width;\n        const height = imgSize ? imgSize[1] : img.height;\n        const iconContext = createCanvasContext2D(width, height);\n        iconContext.drawImage(img, 0, 0);\n        style.setImage(\n          new Icon({\n            img: img,\n            imgSize: imgSize,\n            anchor: image.getAnchor(),\n            anchorXUnits: IconAnchorUnits.PIXELS,\n            anchorYUnits: IconAnchorUnits.PIXELS,\n            offset: image.getOrigin(),\n            size: image.getSize(),\n            opacity: image.getOpacity(),\n            scale: image.getScale(),\n            rotation: image.getRotation(),\n            rotateWithView: image.getRotateWithView(),\n          })\n        );\n      }\n      const zIndex = Number(style.getZIndex());\n      let byGeometryType = featuresByZIndex[zIndex];\n      if (!byGeometryType) {\n        byGeometryType = {};\n        featuresByZIndex[zIndex] = byGeometryType;\n        byGeometryType[GeometryType.POLYGON] = [];\n        byGeometryType[GeometryType.CIRCLE] = [];\n        byGeometryType[GeometryType.LINE_STRING] = [];\n        byGeometryType[GeometryType.POINT] = [];\n      }\n      const geometry = style.getGeometryFunction()(feature);\n      if (geometry && intersects(extent, geometry.getExtent())) {\n        byGeometryType[geometry.getType().replace('Multi', '')].push(\n          geometry,\n          style\n        );\n      }\n    }\n  }\n\n  const zIndexKeys = Object.keys(featuresByZIndex)\n    .map(Number)\n    .sort(numberSafeCompareFunction);\n  for (let i = 0, ii = zIndexKeys.length; i < ii; ++i) {\n    const byGeometryType = featuresByZIndex[zIndexKeys[i]];\n    for (const type in byGeometryType) {\n      const geomAndStyle = byGeometryType[type];\n      for (let j = 0, jj = geomAndStyle.length; j < jj; j += 2) {\n        renderer.setStyle(geomAndStyle[j + 1]);\n        for (let k = 0, kk = transforms.length; k < kk; ++k) {\n          renderer.setTransform(transforms[k]);\n          renderer.drawGeometry(geomAndStyle[j]);\n        }\n      }\n    }\n  }\n  return context.getImageData(0, 0, canvas.width, canvas.height);\n}\n\n/**\n * @param {import(\"../../pixel\").Pixel} pixel Pixel coordinate on the hit\n * detection canvas in css pixels.\n * @param {Array<import(\"../../Feature\").FeatureLike>} features Features. Has to\n * match the `features` array that was passed to `createHitDetectionImageData()`.\n * @param {ImageData} imageData Hit detection image data generated by\n * `createHitDetectionImageData()`.\n * @return {Array<import(\"../../Feature\").FeatureLike>} features Features.\n */\nexport function hitDetect(pixel, features, imageData) {\n  const resultFeatures = [];\n  if (imageData) {\n    const index =\n      (Math.round(pixel[0] / 2) + Math.round(pixel[1] / 2) * imageData.width) *\n      4;\n    const r = imageData.data[index];\n    const g = imageData.data[index + 1];\n    const b = imageData.data[index + 2];\n    const i = b + 256 * (g + 256 * r);\n    const indexFactor = Math.floor((256 * 256 * 256 - 1) / features.length);\n    if (i && i % indexFactor === 0) {\n      resultFeatures.push(features[i / indexFactor - 1]);\n    }\n  }\n  return resultFeatures;\n}\n","/**\n * @module ol/layer/Vector\n */\nimport BaseVectorLayer from './BaseVector.js';\nimport CanvasVectorLayerRenderer from '../renderer/canvas/VectorLayer.js';\n\n/**\n * @classdesc\n * Vector data that is rendered client-side.\n * Note that any property set in the options is set as a {@link module:ol/Object~BaseObject}\n * property on the layer object; for example, setting `title: 'My Title'` in the\n * options means that `title` is observable, and has get/set accessors.\n *\n * @extends {BaseVectorLayer<import(\"../source/Vector.js\").default>}\n * @api\n */\nclass VectorLayer extends BaseVectorLayer {\n  /**\n   * @param {import(\"./BaseVector.js\").Options=} opt_options Options.\n   */\n  constructor(opt_options) {\n    super(opt_options);\n  }\n\n  /**\n   * Create a renderer for this layer.\n   * @return {import(\"../renderer/Layer.js\").default} A layer renderer.\n   */\n  createRenderer() {\n    return new CanvasVectorLayerRenderer(this);\n  }\n}\n\nexport default VectorLayer;\n","/**\n * @module ol/structs/RBush\n */\nimport RBush_ from 'rbush';\nimport {createOrUpdate, equals} from '../extent.js';\nimport {getUid} from '../util.js';\nimport {isEmpty} from '../obj.js';\n\n/**\n * @typedef {Object} Entry\n * @property {number} minX\n * @property {number} minY\n * @property {number} maxX\n * @property {number} maxY\n * @property {Object} [value]\n */\n\n/**\n * @classdesc\n * Wrapper around the RBush by Vladimir Agafonkin.\n * See https://github.com/mourner/rbush.\n *\n * @template T\n */\nclass RBush {\n  /**\n   * @param {number=} opt_maxEntries Max entries.\n   */\n  constructor(opt_maxEntries) {\n    /**\n     * @private\n     */\n    this.rbush_ = new RBush_(opt_maxEntries);\n\n    /**\n     * A mapping between the objects added to this rbush wrapper\n     * and the objects that are actually added to the internal rbush.\n     * @private\n     * @type {Object<string, Entry>}\n     */\n    this.items_ = {};\n  }\n\n  /**\n   * Insert a value into the RBush.\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @param {T} value Value.\n   */\n  insert(extent, value) {\n    /** @type {Entry} */\n    const item = {\n      minX: extent[0],\n      minY: extent[1],\n      maxX: extent[2],\n      maxY: extent[3],\n      value: value,\n    };\n\n    this.rbush_.insert(item);\n    this.items_[getUid(value)] = item;\n  }\n\n  /**\n   * Bulk-insert values into the RBush.\n   * @param {Array<import(\"../extent.js\").Extent>} extents Extents.\n   * @param {Array<T>} values Values.\n   */\n  load(extents, values) {\n    const items = new Array(values.length);\n    for (let i = 0, l = values.length; i < l; i++) {\n      const extent = extents[i];\n      const value = values[i];\n\n      /** @type {Entry} */\n      const item = {\n        minX: extent[0],\n        minY: extent[1],\n        maxX: extent[2],\n        maxY: extent[3],\n        value: value,\n      };\n      items[i] = item;\n      this.items_[getUid(value)] = item;\n    }\n    this.rbush_.load(items);\n  }\n\n  /**\n   * Remove a value from the RBush.\n   * @param {T} value Value.\n   * @return {boolean} Removed.\n   */\n  remove(value) {\n    const uid = getUid(value);\n\n    // get the object in which the value was wrapped when adding to the\n    // internal rbush. then use that object to do the removal.\n    const item = this.items_[uid];\n    delete this.items_[uid];\n    return this.rbush_.remove(item) !== null;\n  }\n\n  /**\n   * Update the extent of a value in the RBush.\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @param {T} value Value.\n   */\n  update(extent, value) {\n    const item = this.items_[getUid(value)];\n    const bbox = [item.minX, item.minY, item.maxX, item.maxY];\n    if (!equals(bbox, extent)) {\n      this.remove(value);\n      this.insert(extent, value);\n    }\n  }\n\n  /**\n   * Return all values in the RBush.\n   * @return {Array<T>} All.\n   */\n  getAll() {\n    const items = this.rbush_.all();\n    return items.map(function (item) {\n      return item.value;\n    });\n  }\n\n  /**\n   * Return all values in the given extent.\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @return {Array<T>} All in extent.\n   */\n  getInExtent(extent) {\n    /** @type {Entry} */\n    const bbox = {\n      minX: extent[0],\n      minY: extent[1],\n      maxX: extent[2],\n      maxY: extent[3],\n    };\n    const items = this.rbush_.search(bbox);\n    return items.map(function (item) {\n      return item.value;\n    });\n  }\n\n  /**\n   * Calls a callback function with each value in the tree.\n   * If the callback returns a truthy value, this value is returned without\n   * checking the rest of the tree.\n   * @param {function(T): *} callback Callback.\n   * @return {*} Callback return value.\n   */\n  forEach(callback) {\n    return this.forEach_(this.getAll(), callback);\n  }\n\n  /**\n   * Calls a callback function with each value in the provided extent.\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @param {function(T): *} callback Callback.\n   * @return {*} Callback return value.\n   */\n  forEachInExtent(extent, callback) {\n    return this.forEach_(this.getInExtent(extent), callback);\n  }\n\n  /**\n   * @param {Array<T>} values Values.\n   * @param {function(T): *} callback Callback.\n   * @private\n   * @return {*} Callback return value.\n   */\n  forEach_(values, callback) {\n    let result;\n    for (let i = 0, l = values.length; i < l; i++) {\n      result = callback(values[i]);\n      if (result) {\n        return result;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * @return {boolean} Is empty.\n   */\n  isEmpty() {\n    return isEmpty(this.items_);\n  }\n\n  /**\n   * Remove all values from the RBush.\n   */\n  clear() {\n    this.rbush_.clear();\n    this.items_ = {};\n  }\n\n  /**\n   * @param {import(\"../extent.js\").Extent=} opt_extent Extent.\n   * @return {import(\"../extent.js\").Extent} Extent.\n   */\n  getExtent(opt_extent) {\n    const data = this.rbush_.toJSON();\n    return createOrUpdate(\n      data.minX,\n      data.minY,\n      data.maxX,\n      data.maxY,\n      opt_extent\n    );\n  }\n\n  /**\n   * @param {RBush} rbush R-Tree.\n   */\n  concat(rbush) {\n    this.rbush_.load(rbush.rbush_.all());\n    for (const i in rbush.items_) {\n      this.items_[i] = rbush.items_[i];\n    }\n  }\n}\n\nexport default RBush;\n","/**\n * @module ol/source/VectorEventType\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  /**\n   * Triggered when a feature is added to the source.\n   * @event module:ol/source/Vector.VectorSourceEvent#addfeature\n   * @api\n   */\n  ADDFEATURE: 'addfeature',\n\n  /**\n   * Triggered when a feature is updated.\n   * @event module:ol/source/Vector.VectorSourceEvent#changefeature\n   * @api\n   */\n  CHANGEFEATURE: 'changefeature',\n\n  /**\n   * Triggered when the clear method is called on the source.\n   * @event module:ol/source/Vector.VectorSourceEvent#clear\n   * @api\n   */\n  CLEAR: 'clear',\n\n  /**\n   * Triggered when a feature is removed from the source.\n   * See {@link module:ol/source/Vector#clear source.clear()} for exceptions.\n   * @event module:ol/source/Vector.VectorSourceEvent#removefeature\n   * @api\n   */\n  REMOVEFEATURE: 'removefeature',\n\n  /**\n   * Triggered when features starts loading.\n   * @event module:ol/source/Vector.VectorSourceEvent#featuresloadstart\n   * @api\n   */\n  FEATURESLOADSTART: 'featuresloadstart',\n\n  /**\n   * Triggered when features finishes loading.\n   * @event module:ol/source/Vector.VectorSourceEvent#featuresloadend\n   * @api\n   */\n  FEATURESLOADEND: 'featuresloadend',\n\n  /**\n   * Triggered if feature loading results in an error.\n   * @event module:ol/source/Vector.VectorSourceEvent#featuresloaderror\n   * @api\n   */\n  FEATURESLOADERROR: 'featuresloaderror',\n};\n","/**\n * @module ol/loadingstrategy\n */\n\n/**\n * Strategy function for loading all features with a single request.\n * @param {import(\"./extent.js\").Extent} extent Extent.\n * @param {number} resolution Resolution.\n * @return {Array<import(\"./extent.js\").Extent>} Extents.\n * @api\n */\nexport function all(extent, resolution) {\n  return [[-Infinity, -Infinity, Infinity, Infinity]];\n}\n\n/**\n * Strategy function for loading features based on the view's extent and\n * resolution.\n * @param {import(\"./extent.js\").Extent} extent Extent.\n * @param {number} resolution Resolution.\n * @return {Array<import(\"./extent.js\").Extent>} Extents.\n * @api\n */\nexport function bbox(extent, resolution) {\n  return [extent];\n}\n\n/**\n * Creates a strategy function for loading features based on a tile grid.\n * @param {import(\"./tilegrid/TileGrid.js\").default} tileGrid Tile grid.\n * @return {function(import(\"./extent.js\").Extent, number): Array<import(\"./extent.js\").Extent>} Loading strategy.\n * @api\n */\nexport function tile(tileGrid) {\n  return (\n    /**\n     * @param {import(\"./extent.js\").Extent} extent Extent.\n     * @param {number} resolution Resolution.\n     * @return {Array<import(\"./extent.js\").Extent>} Extents.\n     */\n    function (extent, resolution) {\n      const z = tileGrid.getZForResolution(resolution);\n      const tileRange = tileGrid.getTileRangeForExtentAndZ(extent, z);\n      /** @type {Array<import(\"./extent.js\").Extent>} */\n      const extents = [];\n      /** @type {import(\"./tilecoord.js\").TileCoord} */\n      const tileCoord = [z, 0, 0];\n      for (\n        tileCoord[1] = tileRange.minX;\n        tileCoord[1] <= tileRange.maxX;\n        ++tileCoord[1]\n      ) {\n        for (\n          tileCoord[2] = tileRange.minY;\n          tileCoord[2] <= tileRange.maxY;\n          ++tileCoord[2]\n        ) {\n          extents.push(tileGrid.getTileCoordExtent(tileCoord));\n        }\n      }\n      return extents;\n    }\n  );\n}\n","/**\n * @module ol/format/FormatType\n */\n\n/**\n * @enum {string}\n */\nexport default {\n  ARRAY_BUFFER: 'arraybuffer',\n  JSON: 'json',\n  TEXT: 'text',\n  XML: 'xml',\n};\n","/**\n * @module ol/featureloader\n */\nimport FormatType from './format/FormatType.js';\nimport {VOID} from './functions.js';\n\n/**\n *\n * @type {boolean}\n * @private\n */\nlet withCredentials = false;\n\n/**\n * {@link module:ol/source/Vector} sources use a function of this type to\n * load features.\n *\n * This function takes an {@link module:ol/extent~Extent} representing the area to be loaded,\n * a `{number}` representing the resolution (map units per pixel), an\n * {@link module:ol/proj/Projection} for the projection and success and failure callbacks as\n * arguments. `this` within the function is bound to the\n * {@link module:ol/source/Vector} it's called from.\n *\n * The function is responsible for loading the features and adding them to the\n * source.\n * @typedef {function(this:(import(\"./source/Vector\").default|import(\"./VectorTile.js\").default),\n *           import(\"./extent.js\").Extent,\n *           number,\n *           import(\"./proj/Projection.js\").default,\n *           function(Array<import(\"./Feature.js\").default>): void=,\n *           function(): void=): void} FeatureLoader\n * @api\n */\n\n/**\n * {@link module:ol/source/Vector} sources use a function of this type to\n * get the url to load features from.\n *\n * This function takes an {@link module:ol/extent~Extent} representing the area\n * to be loaded, a `{number}` representing the resolution (map units per pixel)\n * and an {@link module:ol/proj/Projection} for the projection  as\n * arguments and returns a `{string}` representing the URL.\n * @typedef {function(import(\"./extent.js\").Extent, number, import(\"./proj/Projection.js\").default): string} FeatureUrlFunction\n * @api\n */\n\n/**\n * @param {string|FeatureUrlFunction} url Feature URL service.\n * @param {import(\"./format/Feature.js\").default} format Feature format.\n * @param {import(\"./extent.js\").Extent} extent Extent.\n * @param {number} resolution Resolution.\n * @param {import(\"./proj/Projection.js\").default} projection Projection.\n * @param {function(Array<import(\"./Feature.js\").default>, import(\"./proj/Projection.js\").default): void} success Success\n *      Function called with the loaded features and optionally with the data projection.\n * @param {function(): void} failure Failure\n *      Function called when loading failed.\n */\nexport function loadFeaturesXhr(\n  url,\n  format,\n  extent,\n  resolution,\n  projection,\n  success,\n  failure\n) {\n  const xhr = new XMLHttpRequest();\n  xhr.open(\n    'GET',\n    typeof url === 'function' ? url(extent, resolution, projection) : url,\n    true\n  );\n  if (format.getType() == FormatType.ARRAY_BUFFER) {\n    xhr.responseType = 'arraybuffer';\n  }\n  xhr.withCredentials = withCredentials;\n  /**\n   * @param {Event} event Event.\n   * @private\n   */\n  xhr.onload = function (event) {\n    // status will be 0 for file:// urls\n    if (!xhr.status || (xhr.status >= 200 && xhr.status < 300)) {\n      const type = format.getType();\n      /** @type {Document|Node|Object|string|undefined} */\n      let source;\n      if (type == FormatType.JSON || type == FormatType.TEXT) {\n        source = xhr.responseText;\n      } else if (type == FormatType.XML) {\n        source = xhr.responseXML;\n        if (!source) {\n          source = new DOMParser().parseFromString(\n            xhr.responseText,\n            'application/xml'\n          );\n        }\n      } else if (type == FormatType.ARRAY_BUFFER) {\n        source = /** @type {ArrayBuffer} */ (xhr.response);\n      }\n      if (source) {\n        success(\n          /** @type {Array<import(\"./Feature.js\").default>} */\n          (format.readFeatures(source, {\n            extent: extent,\n            featureProjection: projection,\n          })),\n          format.readProjection(source)\n        );\n      } else {\n        failure();\n      }\n    } else {\n      failure();\n    }\n  };\n  /**\n   * @private\n   */\n  xhr.onerror = failure;\n  xhr.send();\n}\n\n/**\n * Create an XHR feature loader for a `url` and `format`. The feature loader\n * loads features (with XHR), parses the features, and adds them to the\n * vector source.\n * @param {string|FeatureUrlFunction} url Feature URL service.\n * @param {import(\"./format/Feature.js\").default} format Feature format.\n * @return {FeatureLoader} The feature loader.\n * @api\n */\nexport function xhr(url, format) {\n  /**\n   * @param {import(\"./extent.js\").Extent} extent Extent.\n   * @param {number} resolution Resolution.\n   * @param {import(\"./proj/Projection.js\").default} projection Projection.\n   * @param {function(): void=} success Success\n   *      Function called when loading succeeded.\n   * @param {function(): void=} failure Failure\n   *      Function called when loading failed.\n   * @this {import(\"./source/Vector\").default}\n   */\n  return function (extent, resolution, projection, success, failure) {\n    const source = /** @type {import(\"./source/Vector\").default} */ (this);\n    loadFeaturesXhr(\n      url,\n      format,\n      extent,\n      resolution,\n      projection,\n      /**\n       * @param {Array<import(\"./Feature.js\").default>} features The loaded features.\n       * @param {import(\"./proj/Projection.js\").default} dataProjection Data\n       * projection.\n       */\n      function (features, dataProjection) {\n        if (success !== undefined) {\n          success(features);\n        }\n        source.addFeatures(features);\n      },\n      /* FIXME handle error */ failure ? failure : VOID\n    );\n  };\n}\n\n/**\n * Setter for the withCredentials configuration for the XHR.\n *\n * @param {boolean} xhrWithCredentials The value of withCredentials to set.\n * Compare https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/\n * @api\n */\nexport function setWithCredentials(xhrWithCredentials) {\n  withCredentials = xhrWithCredentials;\n}\n","/**\n * @module ol/source/Vector\n */\n\nimport Collection from '../Collection.js';\nimport CollectionEventType from '../CollectionEventType.js';\nimport Event from '../events/Event.js';\nimport EventType from '../events/EventType.js';\nimport ObjectEventType from '../ObjectEventType.js';\nimport RBush from '../structs/RBush.js';\nimport Source from './Source.js';\nimport SourceState from './State.js';\nimport VectorEventType from './VectorEventType.js';\nimport {TRUE, VOID} from '../functions.js';\nimport {all as allStrategy} from '../loadingstrategy.js';\nimport {assert} from '../asserts.js';\nimport {containsExtent, equals} from '../extent.js';\nimport {extend} from '../array.js';\nimport {getUid} from '../util.js';\nimport {getValues, isEmpty} from '../obj.js';\nimport {listen, unlistenByKey} from '../events.js';\nimport {xhr} from '../featureloader.js';\n\n/**\n * A function that takes an {@link module:ol/extent~Extent} and a resolution as arguments, and\n * returns an array of {@link module:ol/extent~Extent} with the extents to load. Usually this\n * is one of the standard {@link module:ol/loadingstrategy} strategies.\n *\n * @typedef {function(import(\"../extent.js\").Extent, number): Array<import(\"../extent.js\").Extent>} LoadingStrategy\n * @api\n */\n\n/**\n * @classdesc\n * Events emitted by {@link module:ol/source/Vector} instances are instances of this\n * type.\n * @template {import(\"../geom/Geometry.js\").default} Geometry\n */\nexport class VectorSourceEvent extends Event {\n  /**\n   * @param {string} type Type.\n   * @param {import(\"../Feature.js\").default<Geometry>=} opt_feature Feature.\n   * @param {Array<import(\"../Feature.js\").default<Geometry>>=} opt_features Features.\n   */\n  constructor(type, opt_feature, opt_features) {\n    super(type);\n\n    /**\n     * The added or removed feature for the `ADDFEATURE` and `REMOVEFEATURE` events, `undefined` otherwise.\n     * @type {import(\"../Feature.js\").default<Geometry>|undefined}\n     * @api\n     */\n    this.feature = opt_feature;\n\n    /**\n     * The loaded features for the `FEATURESLOADED` event, `undefined` otherwise.\n     * @type {Array<import(\"../Feature.js\").default<Geometry>>|undefined}\n     * @api\n     */\n    this.features = opt_features;\n  }\n}\n\n/**\n * @typedef {Object} Options\n * @property {import(\"./Source.js\").AttributionLike} [attributions] Attributions.\n * @property {Array<import(\"../Feature.js\").default>|Collection<import(\"../Feature.js\").default>} [features]\n * Features. If provided as {@link module:ol/Collection}, the features in the source\n * and the collection will stay in sync.\n * @property {import(\"../format/Feature.js\").default} [format] The feature format used by the XHR\n * feature loader when `url` is set. Required if `url` is set, otherwise ignored.\n * @property {import(\"../featureloader.js\").FeatureLoader} [loader]\n * The loader function used to load features, from a remote source for example.\n * If this is not set and `url` is set, the source will create and use an XHR\n * feature loader.\n *\n * Example:\n *\n * ```js\n * import {Vector} from 'ol/source';\n * import {GeoJSON} from 'ol/format';\n * import {bbox} from 'ol/loadingstrategy';\n *\n * var vectorSource = new Vector({\n *   format: new GeoJSON(),\n *   loader: function(extent, resolution, projection) {\n *      var proj = projection.getCode();\n *      var url = 'https://ahocevar.com/geoserver/wfs?service=WFS&' +\n *          'version=1.1.0&request=GetFeature&typename=osm:water_areas&' +\n *          'outputFormat=application/json&srsname=' + proj + '&' +\n *          'bbox=' + extent.join(',') + ',' + proj;\n *      var xhr = new XMLHttpRequest();\n *      xhr.open('GET', url);\n *      var onError = function() {\n *        vectorSource.removeLoadedExtent(extent);\n *      }\n *      xhr.onerror = onError;\n *      xhr.onload = function() {\n *        if (xhr.status == 200) {\n *          vectorSource.addFeatures(\n *              vectorSource.getFormat().readFeatures(xhr.responseText));\n *        } else {\n *          onError();\n *        }\n *      }\n *      xhr.send();\n *    },\n *    strategy: bbox\n *  });\n * ```\n * @property {boolean} [overlaps=true] This source may have overlapping geometries.\n * Setting this to `false` (e.g. for sources with polygons that represent administrative\n * boundaries or TopoJSON sources) allows the renderer to optimise fill and\n * stroke operations.\n * @property {LoadingStrategy} [strategy] The loading strategy to use.\n * By default an {@link module:ol/loadingstrategy~all}\n * strategy is used, a one-off strategy which loads all features at once.\n * @property {string|import(\"../featureloader.js\").FeatureUrlFunction} [url]\n * Setting this option instructs the source to load features using an XHR loader\n * (see {@link module:ol/featureloader~xhr}). Use a `string` and an\n * {@link module:ol/loadingstrategy~all} for a one-off download of all features from\n * the given URL. Use a {@link module:ol/featureloader~FeatureUrlFunction} to generate the url with\n * other loading strategies.\n * Requires `format` to be set as well.\n * When default XHR feature loader is provided, the features will\n * be transformed from the data projection to the view projection\n * during parsing. If your remote data source does not advertise its projection\n * properly, this transformation will be incorrect. For some formats, the\n * default projection (usually EPSG:4326) can be overridden by setting the\n * dataProjection constructor option on the format.\n * Note that if a source contains non-feature data, such as a GeoJSON geometry\n * or a KML NetworkLink, these will be ignored. Use a custom loader to load these.\n * @property {boolean} [useSpatialIndex=true]\n * By default, an RTree is used as spatial index. When features are removed and\n * added frequently, and the total number of features is low, setting this to\n * `false` may improve performance.\n *\n * Note that\n * {@link module:ol/source/Vector~VectorSource#getFeaturesInExtent},\n * {@link module:ol/source/Vector~VectorSource#getClosestFeatureToCoordinate} and\n * {@link module:ol/source/Vector~VectorSource#getExtent} cannot be used when `useSpatialIndex` is\n * set to `false`, and {@link module:ol/source/Vector~VectorSource#forEachFeatureInExtent} will loop\n * through all features.\n *\n * When set to `false`, the features will be maintained in an\n * {@link module:ol/Collection}, which can be retrieved through\n * {@link module:ol/source/Vector~VectorSource#getFeaturesCollection}.\n * @property {boolean} [wrapX=true] Wrap the world horizontally. For vector editing across the\n * -180° and 180° meridians to work properly, this should be set to `false`. The\n * resulting geometry coordinates will then exceed the world bounds.\n */\n\n/**\n * @classdesc\n * Provides a source of features for vector layers. Vector features provided\n * by this source are suitable for editing. See {@link module:ol/source/VectorTile~VectorTile} for\n * vector data that is optimized for rendering.\n *\n * @fires VectorSourceEvent\n * @api\n * @template {import(\"../geom/Geometry.js\").default} Geometry\n */\nclass VectorSource extends Source {\n  /**\n   * @param {Options=} opt_options Vector source options.\n   */\n  constructor(opt_options) {\n    const options = opt_options || {};\n\n    super({\n      attributions: options.attributions,\n      projection: undefined,\n      state: SourceState.READY,\n      wrapX: options.wrapX !== undefined ? options.wrapX : true,\n    });\n\n    /**\n     * @private\n     * @type {import(\"../featureloader.js\").FeatureLoader}\n     */\n    this.loader_ = VOID;\n\n    /**\n     * @private\n     * @type {import(\"../format/Feature.js\").default|undefined}\n     */\n    this.format_ = options.format;\n\n    /**\n     * @private\n     * @type {boolean}\n     */\n    this.overlaps_ = options.overlaps === undefined ? true : options.overlaps;\n\n    /**\n     * @private\n     * @type {string|import(\"../featureloader.js\").FeatureUrlFunction|undefined}\n     */\n    this.url_ = options.url;\n\n    if (options.loader !== undefined) {\n      this.loader_ = options.loader;\n    } else if (this.url_ !== undefined) {\n      assert(this.format_, 7); // `format` must be set when `url` is set\n      // create a XHR feature loader for \"url\" and \"format\"\n      this.loader_ = xhr(\n        this.url_,\n        /** @type {import(\"../format/Feature.js\").default} */ (this.format_)\n      );\n    }\n\n    /**\n     * @private\n     * @type {LoadingStrategy}\n     */\n    this.strategy_ =\n      options.strategy !== undefined ? options.strategy : allStrategy;\n\n    const useSpatialIndex =\n      options.useSpatialIndex !== undefined ? options.useSpatialIndex : true;\n\n    /**\n     * @private\n     * @type {RBush<import(\"../Feature.js\").default<Geometry>>}\n     */\n    this.featuresRtree_ = useSpatialIndex ? new RBush() : null;\n\n    /**\n     * @private\n     * @type {RBush<{extent: import(\"../extent.js\").Extent}>}\n     */\n    this.loadedExtentsRtree_ = new RBush();\n\n    /**\n     * @private\n     * @type {!Object<string, import(\"../Feature.js\").default<Geometry>>}\n     */\n    this.nullGeometryFeatures_ = {};\n\n    /**\n     * A lookup of features by id (the return from feature.getId()).\n     * @private\n     * @type {!Object<string, import(\"../Feature.js\").default<Geometry>>}\n     */\n    this.idIndex_ = {};\n\n    /**\n     * A lookup of features by uid (using getUid(feature)).\n     * @private\n     * @type {!Object<string, import(\"../Feature.js\").default<Geometry>>}\n     */\n    this.uidIndex_ = {};\n\n    /**\n     * @private\n     * @type {Object<string, Array<import(\"../events.js\").EventsKey>>}\n     */\n    this.featureChangeKeys_ = {};\n\n    /**\n     * @private\n     * @type {Collection<import(\"../Feature.js\").default<Geometry>>}\n     */\n    this.featuresCollection_ = null;\n\n    let collection, features;\n    if (Array.isArray(options.features)) {\n      features = options.features;\n    } else if (options.features) {\n      collection = options.features;\n      features = collection.getArray();\n    }\n    if (!useSpatialIndex && collection === undefined) {\n      collection = new Collection(features);\n    }\n    if (features !== undefined) {\n      this.addFeaturesInternal(features);\n    }\n    if (collection !== undefined) {\n      this.bindFeaturesCollection_(collection);\n    }\n  }\n\n  /**\n   * Add a single feature to the source.  If you want to add a batch of features\n   * at once, call {@link module:ol/source/Vector~VectorSource#addFeatures #addFeatures()}\n   * instead. A feature will not be added to the source if feature with\n   * the same id is already there. The reason for this behavior is to avoid\n   * feature duplication when using bbox or tile loading strategies.\n   * Note: this also applies if an {@link module:ol/Collection} is used for features,\n   * meaning that if a feature with a duplicate id is added in the collection, it will\n   * be removed from it right away.\n   * @param {import(\"../Feature.js\").default<Geometry>} feature Feature to add.\n   * @api\n   */\n  addFeature(feature) {\n    this.addFeatureInternal(feature);\n    this.changed();\n  }\n\n  /**\n   * Add a feature without firing a `change` event.\n   * @param {import(\"../Feature.js\").default<Geometry>} feature Feature.\n   * @protected\n   */\n  addFeatureInternal(feature) {\n    const featureKey = getUid(feature);\n\n    if (!this.addToIndex_(featureKey, feature)) {\n      if (this.featuresCollection_) {\n        this.featuresCollection_.remove(feature);\n      }\n      return;\n    }\n\n    this.setupChangeEvents_(featureKey, feature);\n\n    const geometry = feature.getGeometry();\n    if (geometry) {\n      const extent = geometry.getExtent();\n      if (this.featuresRtree_) {\n        this.featuresRtree_.insert(extent, feature);\n      }\n    } else {\n      this.nullGeometryFeatures_[featureKey] = feature;\n    }\n\n    this.dispatchEvent(\n      new VectorSourceEvent(VectorEventType.ADDFEATURE, feature)\n    );\n  }\n\n  /**\n   * @param {string} featureKey Unique identifier for the feature.\n   * @param {import(\"../Feature.js\").default<Geometry>} feature The feature.\n   * @private\n   */\n  setupChangeEvents_(featureKey, feature) {\n    this.featureChangeKeys_[featureKey] = [\n      listen(feature, EventType.CHANGE, this.handleFeatureChange_, this),\n      listen(\n        feature,\n        ObjectEventType.PROPERTYCHANGE,\n        this.handleFeatureChange_,\n        this\n      ),\n    ];\n  }\n\n  /**\n   * @param {string} featureKey Unique identifier for the feature.\n   * @param {import(\"../Feature.js\").default<Geometry>} feature The feature.\n   * @return {boolean} The feature is \"valid\", in the sense that it is also a\n   *     candidate for insertion into the Rtree.\n   * @private\n   */\n  addToIndex_(featureKey, feature) {\n    let valid = true;\n    const id = feature.getId();\n    if (id !== undefined) {\n      if (!(id.toString() in this.idIndex_)) {\n        this.idIndex_[id.toString()] = feature;\n      } else {\n        valid = false;\n      }\n    }\n    if (valid) {\n      assert(!(featureKey in this.uidIndex_), 30); // The passed `feature` was already added to the source\n      this.uidIndex_[featureKey] = feature;\n    }\n    return valid;\n  }\n\n  /**\n   * Add a batch of features to the source.\n   * @param {Array<import(\"../Feature.js\").default<Geometry>>} features Features to add.\n   * @api\n   */\n  addFeatures(features) {\n    this.addFeaturesInternal(features);\n    this.changed();\n  }\n\n  /**\n   * Add features without firing a `change` event.\n   * @param {Array<import(\"../Feature.js\").default<Geometry>>} features Features.\n   * @protected\n   */\n  addFeaturesInternal(features) {\n    const extents = [];\n    const newFeatures = [];\n    const geometryFeatures = [];\n\n    for (let i = 0, length = features.length; i < length; i++) {\n      const feature = features[i];\n      const featureKey = getUid(feature);\n      if (this.addToIndex_(featureKey, feature)) {\n        newFeatures.push(feature);\n      }\n    }\n\n    for (let i = 0, length = newFeatures.length; i < length; i++) {\n      const feature = newFeatures[i];\n      const featureKey = getUid(feature);\n      this.setupChangeEvents_(featureKey, feature);\n\n      const geometry = feature.getGeometry();\n      if (geometry) {\n        const extent = geometry.getExtent();\n        extents.push(extent);\n        geometryFeatures.push(feature);\n      } else {\n        this.nullGeometryFeatures_[featureKey] = feature;\n      }\n    }\n    if (this.featuresRtree_) {\n      this.featuresRtree_.load(extents, geometryFeatures);\n    }\n\n    for (let i = 0, length = newFeatures.length; i < length; i++) {\n      this.dispatchEvent(\n        new VectorSourceEvent(VectorEventType.ADDFEATURE, newFeatures[i])\n      );\n    }\n  }\n\n  /**\n   * @param {!Collection<import(\"../Feature.js\").default<Geometry>>} collection Collection.\n   * @private\n   */\n  bindFeaturesCollection_(collection) {\n    let modifyingCollection = false;\n    this.addEventListener(\n      VectorEventType.ADDFEATURE,\n      /**\n       * @param {VectorSourceEvent<Geometry>} evt The vector source event\n       */\n      function (evt) {\n        if (!modifyingCollection) {\n          modifyingCollection = true;\n          collection.push(evt.feature);\n          modifyingCollection = false;\n        }\n      }\n    );\n    this.addEventListener(\n      VectorEventType.REMOVEFEATURE,\n      /**\n       * @param {VectorSourceEvent<Geometry>} evt The vector source event\n       */\n      function (evt) {\n        if (!modifyingCollection) {\n          modifyingCollection = true;\n          collection.remove(evt.feature);\n          modifyingCollection = false;\n        }\n      }\n    );\n    collection.addEventListener(\n      CollectionEventType.ADD,\n      /**\n       * @param {import(\"../Collection.js\").CollectionEvent} evt The collection event\n       */\n      function (evt) {\n        if (!modifyingCollection) {\n          modifyingCollection = true;\n          this.addFeature(\n            /** @type {import(\"../Feature.js\").default<Geometry>} */ (evt.element)\n          );\n          modifyingCollection = false;\n        }\n      }.bind(this)\n    );\n    collection.addEventListener(\n      CollectionEventType.REMOVE,\n      /**\n       * @param {import(\"../Collection.js\").CollectionEvent} evt The collection event\n       */\n      function (evt) {\n        if (!modifyingCollection) {\n          modifyingCollection = true;\n          this.removeFeature(\n            /** @type {import(\"../Feature.js\").default<Geometry>} */ (evt.element)\n          );\n          modifyingCollection = false;\n        }\n      }.bind(this)\n    );\n    this.featuresCollection_ = collection;\n  }\n\n  /**\n   * Remove all features from the source.\n   * @param {boolean=} opt_fast Skip dispatching of {@link module:ol/source/Vector.VectorSourceEvent#removefeature} events.\n   * @api\n   */\n  clear(opt_fast) {\n    if (opt_fast) {\n      for (const featureId in this.featureChangeKeys_) {\n        const keys = this.featureChangeKeys_[featureId];\n        keys.forEach(unlistenByKey);\n      }\n      if (!this.featuresCollection_) {\n        this.featureChangeKeys_ = {};\n        this.idIndex_ = {};\n        this.uidIndex_ = {};\n      }\n    } else {\n      if (this.featuresRtree_) {\n        this.featuresRtree_.forEach(this.removeFeatureInternal.bind(this));\n        for (const id in this.nullGeometryFeatures_) {\n          this.removeFeatureInternal(this.nullGeometryFeatures_[id]);\n        }\n      }\n    }\n    if (this.featuresCollection_) {\n      this.featuresCollection_.clear();\n    }\n\n    if (this.featuresRtree_) {\n      this.featuresRtree_.clear();\n    }\n    this.nullGeometryFeatures_ = {};\n\n    const clearEvent = new VectorSourceEvent(VectorEventType.CLEAR);\n    this.dispatchEvent(clearEvent);\n    this.changed();\n  }\n\n  /**\n   * Iterate through all features on the source, calling the provided callback\n   * with each one.  If the callback returns any \"truthy\" value, iteration will\n   * stop and the function will return the same value.\n   * Note: this function only iterate through the feature that have a defined geometry.\n   *\n   * @param {function(import(\"../Feature.js\").default<Geometry>): T} callback Called with each feature\n   *     on the source.  Return a truthy value to stop iteration.\n   * @return {T|undefined} The return value from the last call to the callback.\n   * @template T\n   * @api\n   */\n  forEachFeature(callback) {\n    if (this.featuresRtree_) {\n      return this.featuresRtree_.forEach(callback);\n    } else if (this.featuresCollection_) {\n      this.featuresCollection_.forEach(callback);\n    }\n  }\n\n  /**\n   * Iterate through all features whose geometries contain the provided\n   * coordinate, calling the callback with each feature.  If the callback returns\n   * a \"truthy\" value, iteration will stop and the function will return the same\n   * value.\n   *\n   * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {function(import(\"../Feature.js\").default<Geometry>): T} callback Called with each feature\n   *     whose goemetry contains the provided coordinate.\n   * @return {T|undefined} The return value from the last call to the callback.\n   * @template T\n   */\n  forEachFeatureAtCoordinateDirect(coordinate, callback) {\n    const extent = [coordinate[0], coordinate[1], coordinate[0], coordinate[1]];\n    return this.forEachFeatureInExtent(extent, function (feature) {\n      const geometry = feature.getGeometry();\n      if (geometry.intersectsCoordinate(coordinate)) {\n        return callback(feature);\n      } else {\n        return undefined;\n      }\n    });\n  }\n\n  /**\n   * Iterate through all features whose bounding box intersects the provided\n   * extent (note that the feature's geometry may not intersect the extent),\n   * calling the callback with each feature.  If the callback returns a \"truthy\"\n   * value, iteration will stop and the function will return the same value.\n   *\n   * If you are interested in features whose geometry intersects an extent, call\n   * the {@link module:ol/source/Vector~VectorSource#forEachFeatureIntersectingExtent #forEachFeatureIntersectingExtent()} method instead.\n   *\n   * When `useSpatialIndex` is set to false, this method will loop through all\n   * features, equivalent to {@link module:ol/source/Vector~VectorSource#forEachFeature #forEachFeature()}.\n   *\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @param {function(import(\"../Feature.js\").default<Geometry>): T} callback Called with each feature\n   *     whose bounding box intersects the provided extent.\n   * @return {T|undefined} The return value from the last call to the callback.\n   * @template T\n   * @api\n   */\n  forEachFeatureInExtent(extent, callback) {\n    if (this.featuresRtree_) {\n      return this.featuresRtree_.forEachInExtent(extent, callback);\n    } else if (this.featuresCollection_) {\n      this.featuresCollection_.forEach(callback);\n    }\n  }\n\n  /**\n   * Iterate through all features whose geometry intersects the provided extent,\n   * calling the callback with each feature.  If the callback returns a \"truthy\"\n   * value, iteration will stop and the function will return the same value.\n   *\n   * If you only want to test for bounding box intersection, call the\n   * {@link module:ol/source/Vector~VectorSource#forEachFeatureInExtent #forEachFeatureInExtent()} method instead.\n   *\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @param {function(import(\"../Feature.js\").default<Geometry>): T} callback Called with each feature\n   *     whose geometry intersects the provided extent.\n   * @return {T|undefined} The return value from the last call to the callback.\n   * @template T\n   * @api\n   */\n  forEachFeatureIntersectingExtent(extent, callback) {\n    return this.forEachFeatureInExtent(\n      extent,\n      /**\n       * @param {import(\"../Feature.js\").default<Geometry>} feature Feature.\n       * @return {T|undefined} The return value from the last call to the callback.\n       */\n      function (feature) {\n        const geometry = feature.getGeometry();\n        if (geometry.intersectsExtent(extent)) {\n          const result = callback(feature);\n          if (result) {\n            return result;\n          }\n        }\n      }\n    );\n  }\n\n  /**\n   * Get the features collection associated with this source. Will be `null`\n   * unless the source was configured with `useSpatialIndex` set to `false`, or\n   * with an {@link module:ol/Collection} as `features`.\n   * @return {Collection<import(\"../Feature.js\").default<Geometry>>} The collection of features.\n   * @api\n   */\n  getFeaturesCollection() {\n    return this.featuresCollection_;\n  }\n\n  /**\n   * Get all features on the source in random order.\n   * @return {Array<import(\"../Feature.js\").default<Geometry>>} Features.\n   * @api\n   */\n  getFeatures() {\n    let features;\n    if (this.featuresCollection_) {\n      features = this.featuresCollection_.getArray();\n    } else if (this.featuresRtree_) {\n      features = this.featuresRtree_.getAll();\n      if (!isEmpty(this.nullGeometryFeatures_)) {\n        extend(features, getValues(this.nullGeometryFeatures_));\n      }\n    }\n    return /** @type {Array<import(\"../Feature.js\").default<Geometry>>} */ (features);\n  }\n\n  /**\n   * Get all features whose geometry intersects the provided coordinate.\n   * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @return {Array<import(\"../Feature.js\").default<Geometry>>} Features.\n   * @api\n   */\n  getFeaturesAtCoordinate(coordinate) {\n    const features = [];\n    this.forEachFeatureAtCoordinateDirect(coordinate, function (feature) {\n      features.push(feature);\n    });\n    return features;\n  }\n\n  /**\n   * Get all features whose bounding box intersects the provided extent.  Note that this returns an array of\n   * all features intersecting the given extent in random order (so it may include\n   * features whose geometries do not intersect the extent).\n   *\n   * When `useSpatialIndex` is set to false, this method will return all\n   * features.\n   *\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @return {Array<import(\"../Feature.js\").default<Geometry>>} Features.\n   * @api\n   */\n  getFeaturesInExtent(extent) {\n    if (this.featuresRtree_) {\n      return this.featuresRtree_.getInExtent(extent);\n    } else if (this.featuresCollection_) {\n      return this.featuresCollection_.getArray();\n    } else {\n      return [];\n    }\n  }\n\n  /**\n   * Get the closest feature to the provided coordinate.\n   *\n   * This method is not available when the source is configured with\n   * `useSpatialIndex` set to `false`.\n   * @param {import(\"../coordinate.js\").Coordinate} coordinate Coordinate.\n   * @param {function(import(\"../Feature.js\").default<Geometry>):boolean=} opt_filter Feature filter function.\n   *     The filter function will receive one argument, the {@link module:ol/Feature feature}\n   *     and it should return a boolean value. By default, no filtering is made.\n   * @return {import(\"../Feature.js\").default<Geometry>} Closest feature.\n   * @api\n   */\n  getClosestFeatureToCoordinate(coordinate, opt_filter) {\n    // Find the closest feature using branch and bound.  We start searching an\n    // infinite extent, and find the distance from the first feature found.  This\n    // becomes the closest feature.  We then compute a smaller extent which any\n    // closer feature must intersect.  We continue searching with this smaller\n    // extent, trying to find a closer feature.  Every time we find a closer\n    // feature, we update the extent being searched so that any even closer\n    // feature must intersect it.  We continue until we run out of features.\n    const x = coordinate[0];\n    const y = coordinate[1];\n    let closestFeature = null;\n    const closestPoint = [NaN, NaN];\n    let minSquaredDistance = Infinity;\n    const extent = [-Infinity, -Infinity, Infinity, Infinity];\n    const filter = opt_filter ? opt_filter : TRUE;\n    this.featuresRtree_.forEachInExtent(\n      extent,\n      /**\n       * @param {import(\"../Feature.js\").default<Geometry>} feature Feature.\n       */\n      function (feature) {\n        if (filter(feature)) {\n          const geometry = feature.getGeometry();\n          const previousMinSquaredDistance = minSquaredDistance;\n          minSquaredDistance = geometry.closestPointXY(\n            x,\n            y,\n            closestPoint,\n            minSquaredDistance\n          );\n          if (minSquaredDistance < previousMinSquaredDistance) {\n            closestFeature = feature;\n            // This is sneaky.  Reduce the extent that it is currently being\n            // searched while the R-Tree traversal using this same extent object\n            // is still in progress.  This is safe because the new extent is\n            // strictly contained by the old extent.\n            const minDistance = Math.sqrt(minSquaredDistance);\n            extent[0] = x - minDistance;\n            extent[1] = y - minDistance;\n            extent[2] = x + minDistance;\n            extent[3] = y + minDistance;\n          }\n        }\n      }\n    );\n    return closestFeature;\n  }\n\n  /**\n   * Get the extent of the features currently in the source.\n   *\n   * This method is not available when the source is configured with\n   * `useSpatialIndex` set to `false`.\n   * @param {import(\"../extent.js\").Extent=} opt_extent Destination extent. If provided, no new extent\n   *     will be created. Instead, that extent's coordinates will be overwritten.\n   * @return {import(\"../extent.js\").Extent} Extent.\n   * @api\n   */\n  getExtent(opt_extent) {\n    return this.featuresRtree_.getExtent(opt_extent);\n  }\n\n  /**\n   * Get a feature by its identifier (the value returned by feature.getId()).\n   * Note that the index treats string and numeric identifiers as the same.  So\n   * `source.getFeatureById(2)` will return a feature with id `'2'` or `2`.\n   *\n   * @param {string|number} id Feature identifier.\n   * @return {import(\"../Feature.js\").default<Geometry>} The feature (or `null` if not found).\n   * @api\n   */\n  getFeatureById(id) {\n    const feature = this.idIndex_[id.toString()];\n    return feature !== undefined ? feature : null;\n  }\n\n  /**\n   * Get a feature by its internal unique identifier (using `getUid`).\n   *\n   * @param {string} uid Feature identifier.\n   * @return {import(\"../Feature.js\").default<Geometry>} The feature (or `null` if not found).\n   */\n  getFeatureByUid(uid) {\n    const feature = this.uidIndex_[uid];\n    return feature !== undefined ? feature : null;\n  }\n\n  /**\n   * Get the format associated with this source.\n   *\n   * @return {import(\"../format/Feature.js\").default|undefined} The feature format.\n   * @api\n   */\n  getFormat() {\n    return this.format_;\n  }\n\n  /**\n   * @return {boolean} The source can have overlapping geometries.\n   */\n  getOverlaps() {\n    return this.overlaps_;\n  }\n\n  /**\n   * Get the url associated with this source.\n   *\n   * @return {string|import(\"../featureloader.js\").FeatureUrlFunction|undefined} The url.\n   * @api\n   */\n  getUrl() {\n    return this.url_;\n  }\n\n  /**\n   * @param {Event} event Event.\n   * @private\n   */\n  handleFeatureChange_(event) {\n    const feature = /** @type {import(\"../Feature.js\").default<Geometry>} */ (event.target);\n    const featureKey = getUid(feature);\n    const geometry = feature.getGeometry();\n    if (!geometry) {\n      if (!(featureKey in this.nullGeometryFeatures_)) {\n        if (this.featuresRtree_) {\n          this.featuresRtree_.remove(feature);\n        }\n        this.nullGeometryFeatures_[featureKey] = feature;\n      }\n    } else {\n      const extent = geometry.getExtent();\n      if (featureKey in this.nullGeometryFeatures_) {\n        delete this.nullGeometryFeatures_[featureKey];\n        if (this.featuresRtree_) {\n          this.featuresRtree_.insert(extent, feature);\n        }\n      } else {\n        if (this.featuresRtree_) {\n          this.featuresRtree_.update(extent, feature);\n        }\n      }\n    }\n    const id = feature.getId();\n    if (id !== undefined) {\n      const sid = id.toString();\n      if (this.idIndex_[sid] !== feature) {\n        this.removeFromIdIndex_(feature);\n        this.idIndex_[sid] = feature;\n      }\n    } else {\n      this.removeFromIdIndex_(feature);\n      this.uidIndex_[featureKey] = feature;\n    }\n    this.changed();\n    this.dispatchEvent(\n      new VectorSourceEvent(VectorEventType.CHANGEFEATURE, feature)\n    );\n  }\n\n  /**\n   * Returns true if the feature is contained within the source.\n   * @param {import(\"../Feature.js\").default<Geometry>} feature Feature.\n   * @return {boolean} Has feature.\n   * @api\n   */\n  hasFeature(feature) {\n    const id = feature.getId();\n    if (id !== undefined) {\n      return id in this.idIndex_;\n    } else {\n      return getUid(feature) in this.uidIndex_;\n    }\n  }\n\n  /**\n   * @return {boolean} Is empty.\n   */\n  isEmpty() {\n    return this.featuresRtree_.isEmpty() && isEmpty(this.nullGeometryFeatures_);\n  }\n\n  /**\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @param {number} resolution Resolution.\n   * @param {import(\"../proj/Projection.js\").default} projection Projection.\n   */\n  loadFeatures(extent, resolution, projection) {\n    const loadedExtentsRtree = this.loadedExtentsRtree_;\n    const extentsToLoad = this.strategy_(extent, resolution);\n    this.loading = false;\n    for (let i = 0, ii = extentsToLoad.length; i < ii; ++i) {\n      const extentToLoad = extentsToLoad[i];\n      const alreadyLoaded = loadedExtentsRtree.forEachInExtent(\n        extentToLoad,\n        /**\n         * @param {{extent: import(\"../extent.js\").Extent}} object Object.\n         * @return {boolean} Contains.\n         */\n        function (object) {\n          return containsExtent(object.extent, extentToLoad);\n        }\n      );\n      if (!alreadyLoaded) {\n        this.dispatchEvent(\n          new VectorSourceEvent(VectorEventType.FEATURESLOADSTART)\n        );\n        this.loader_.call(\n          this,\n          extentToLoad,\n          resolution,\n          projection,\n          function (features) {\n            this.dispatchEvent(\n              new VectorSourceEvent(\n                VectorEventType.FEATURESLOADEND,\n                undefined,\n                features\n              )\n            );\n          }.bind(this),\n          function () {\n            this.dispatchEvent(\n              new VectorSourceEvent(VectorEventType.FEATURESLOADERROR)\n            );\n          }.bind(this)\n        );\n        loadedExtentsRtree.insert(extentToLoad, {extent: extentToLoad.slice()});\n        this.loading = this.loader_ !== VOID;\n      }\n    }\n  }\n\n  refresh() {\n    this.clear(true);\n    this.loadedExtentsRtree_.clear();\n    super.refresh();\n  }\n\n  /**\n   * Remove an extent from the list of loaded extents.\n   * @param {import(\"../extent.js\").Extent} extent Extent.\n   * @api\n   */\n  removeLoadedExtent(extent) {\n    const loadedExtentsRtree = this.loadedExtentsRtree_;\n    let obj;\n    loadedExtentsRtree.forEachInExtent(extent, function (object) {\n      if (equals(object.extent, extent)) {\n        obj = object;\n        return true;\n      }\n    });\n    if (obj) {\n      loadedExtentsRtree.remove(obj);\n    }\n  }\n\n  /**\n   * Remove a single feature from the source.  If you want to remove all features\n   * at once, use the {@link module:ol/source/Vector~VectorSource#clear #clear()} method\n   * instead.\n   * @param {import(\"../Feature.js\").default<Geometry>} feature Feature to remove.\n   * @api\n   */\n  removeFeature(feature) {\n    const featureKey = getUid(feature);\n    if (featureKey in this.nullGeometryFeatures_) {\n      delete this.nullGeometryFeatures_[featureKey];\n    } else {\n      if (this.featuresRtree_) {\n        this.featuresRtree_.remove(feature);\n      }\n    }\n    this.removeFeatureInternal(feature);\n    this.changed();\n  }\n\n  /**\n   * Remove feature without firing a `change` event.\n   * @param {import(\"../Feature.js\").default<Geometry>} feature Feature.\n   * @protected\n   */\n  removeFeatureInternal(feature) {\n    const featureKey = getUid(feature);\n    this.featureChangeKeys_[featureKey].forEach(unlistenByKey);\n    delete this.featureChangeKeys_[featureKey];\n    const id = feature.getId();\n    if (id !== undefined) {\n      delete this.idIndex_[id.toString()];\n    }\n    delete this.uidIndex_[featureKey];\n    this.dispatchEvent(\n      new VectorSourceEvent(VectorEventType.REMOVEFEATURE, feature)\n    );\n  }\n\n  /**\n   * Remove a feature from the id index.  Called internally when the feature id\n   * may have changed.\n   * @param {import(\"../Feature.js\").default<Geometry>} feature The feature.\n   * @return {boolean} Removed the feature from the index.\n   * @private\n   */\n  removeFromIdIndex_(feature) {\n    let removed = false;\n    for (const id in this.idIndex_) {\n      if (this.idIndex_[id] === feature) {\n        delete this.idIndex_[id];\n        removed = true;\n        break;\n      }\n    }\n    return removed;\n  }\n\n  /**\n   * Set the new loader of the source. The next render cycle will use the\n   * new loader.\n   * @param {import(\"../featureloader.js\").FeatureLoader} loader The loader to set.\n   * @api\n   */\n  setLoader(loader) {\n    this.loader_ = loader;\n  }\n\n  /**\n   * Points the source to a new url. The next render cycle will use the new url.\n   * @param {string|import(\"../featureloader.js\").FeatureUrlFunction} url Url.\n   * @api\n   */\n  setUrl(url) {\n    assert(this.format_, 7); // `format` must be set when `url` is set\n    this.setLoader(xhr(url, this.format_));\n  }\n}\n\nexport default VectorSource;\n","/**\n * @module ol/source/XYZ\n */\n\nimport TileImage from './TileImage.js';\nimport {createXYZ, extentFromProjection} from '../tilegrid.js';\n\n/**\n * @typedef {Object} Options\n * @property {import(\"./Source.js\").AttributionLike} [attributions] Attributions.\n * @property {boolean} [attributionsCollapsible=true] Attributions are collapsible.\n * @property {number} [cacheSize] Initial tile cache size. Will auto-grow to hold at least the number of tiles in the viewport.\n * @property {null|string} [crossOrigin] The `crossOrigin` attribute for loaded images.  Note that\n * you must provide a `crossOrigin` value if you want to access pixel data with the Canvas renderer.\n * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.\n * @property {boolean} [imageSmoothing=true] Enable image smoothing.\n * @property {boolean} [opaque=false] Whether the layer is opaque.\n * @property {import(\"../proj.js\").ProjectionLike} [projection='EPSG:3857'] Projection.\n * @property {number} [reprojectionErrorThreshold=0.5] Maximum allowed reprojection error (in pixels).\n * Higher values can increase reprojection performance, but decrease precision.\n * @property {number} [maxZoom=42] Optional max zoom level. Not used if `tileGrid` is provided.\n * @property {number} [minZoom=0] Optional min zoom level. Not used if `tileGrid` is provided.\n * @property {number} [maxResolution] Optional tile grid resolution at level zero. Not used if `tileGrid` is provided.\n * @property {import(\"../tilegrid/TileGrid.js\").default} [tileGrid] Tile grid.\n * @property {import(\"../Tile.js\").LoadFunction} [tileLoadFunction] Optional function to load a tile given a URL. The default is\n * ```js\n * function(imageTile, src) {\n *   imageTile.getImage().src = src;\n * };\n * ```\n * @property {number} [tilePixelRatio=1] The pixel ratio used by the tile service.\n * For example, if the tile service advertizes 256px by 256px tiles but actually sends 512px\n * by 512px images (for retina/hidpi devices) then `tilePixelRatio`\n * should be set to `2`.\n * @property {number|import(\"../size.js\").Size} [tileSize=[256, 256]] The tile size used by the tile service.\n * Not used if `tileGrid` is provided.\n * @property {import(\"../Tile.js\").UrlFunction} [tileUrlFunction] Optional function to get\n * tile URL given a tile coordinate and the projection.\n * Required if `url` or `urls` are not provided.\n * @property {string} [url] URL template. Must include `{x}`, `{y}` or `{-y}`,\n * and `{z}` placeholders. A `{?-?}` template pattern, for example `subdomain{a-f}.domain.com`,\n * may be used instead of defining each one separately in the `urls` option.\n * @property {Array<string>} [urls] An array of URL templates.\n * @property {boolean} [wrapX=true] Whether to wrap the world horizontally.\n * @property {number} [transition=250] Duration of the opacity transition for rendering.\n * To disable the opacity transition, pass `transition: 0`.\n * @property {number} [zDirection=0] Indicate which resolution should be used\n * by a renderer if the view resolution does not match any resolution of the tile source.\n * If 0, the nearest resolution will be used. If 1, the nearest lower resolution\n * will be used. If -1, the nearest higher resolution will be used.\n */\n\n/**\n * @classdesc\n * Layer source for tile data with URLs in a set XYZ format that are\n * defined in a URL template. By default, this follows the widely-used\n * Google grid where `x` 0 and `y` 0 are in the top left. Grids like\n * TMS where `x` 0 and `y` 0 are in the bottom left can be used by\n * using the `{-y}` placeholder in the URL template, so long as the\n * source does not have a custom tile grid. In this case\n * a `tileUrlFunction` can be used, such as:\n * ```js\n *  tileUrlFunction: function(coordinate) {\n *    return 'http://mapserver.com/' + coordinate[0] + '/' +\n *      coordinate[1] + '/' + (-coordinate[2] - 1) + '.png';\n *  }\n * ```\n * @api\n */\nclass XYZ extends TileImage {\n  /**\n   * @param {Options=} opt_options XYZ options.\n   */\n  constructor(opt_options) {\n    const options = opt_options || {};\n    const projection =\n      options.projection !== undefined ? options.projection : 'EPSG:3857';\n\n    const tileGrid =\n      options.tileGrid !== undefined\n        ? options.tileGrid\n        : createXYZ({\n            extent: extentFromProjection(projection),\n            maxResolution: options.maxResolution,\n            maxZoom: options.maxZoom,\n            minZoom: options.minZoom,\n            tileSize: options.tileSize,\n          });\n\n    super({\n      attributions: options.attributions,\n      cacheSize: options.cacheSize,\n      crossOrigin: options.crossOrigin,\n      imageSmoothing: options.imageSmoothing,\n      opaque: options.opaque,\n      projection: projection,\n      reprojectionErrorThreshold: options.reprojectionErrorThreshold,\n      tileGrid: tileGrid,\n      tileLoadFunction: options.tileLoadFunction,\n      tilePixelRatio: options.tilePixelRatio,\n      tileUrlFunction: options.tileUrlFunction,\n      url: options.url,\n      urls: options.urls,\n      wrapX: options.wrapX !== undefined ? options.wrapX : true,\n      transition: options.transition,\n      attributionsCollapsible: options.attributionsCollapsible,\n      zDirection: options.zDirection,\n    });\n  }\n}\n\nexport default XYZ;\n","import Control from 'ol/control/Control';\r\nimport { Control, defaults as defaultControls } from 'ol/control';\r\nimport Feature from 'ol/Feature';\r\nimport { fromLonLat } from 'ol/proj';\r\nimport { Group , Tile as TileLayer } from 'ol/layer';\r\n//import ImageWMS from 'ol/source/ImageWMS';\r\nimport { Image as ImageLayer, Tile as TileLayer } from 'ol/layer';\r\nimport Icon from 'ol/style/Icon';\r\nimport { Icon, Style } from 'ol/style';\r\nimport Map from 'ol/Map';\r\nimport 'ol/ol.css';\r\n//import OSM from 'ol/source/OSM';\r\nimport Overlay from 'ol/Overlay';\r\nimport Point from 'ol/geom/Point';\r\nimport Point from 'ol/geom/Point';\r\n//import Polyline from 'ol/format/Polyline';\r\nimport { Circle, Fill, Style } from 'ol/style';\r\nimport { ScaleLine, defaults as defaultControls } from 'ol/control';\r\nimport TileLayer from 'ol/layer/Tile';\r\nimport TileWMS from 'ol/source/TileWMS';\r\n//import TileJSON from 'ol/source/TileJSON';\r\nimport VectorLayer from 'ol/layer/Vector';\r\nimport LayerGroup from 'ol/layer/Group';\r\nimport View from 'ol/View';\r\nimport VectorSource from 'ol/source/Vector';\r\nimport XYZ from 'ol/source/XYZ';\r\n//import Zoom from 'ol/control/Zoom';\r\n//import Extent from 'ol/extent';\r\n//import { makeInverse } from 'ol/transform';\r\n//const place = [-4.503088, 54.225411];\r\n//const point = new Point(fromLonLat(place));\r\n\r\n\r\n//===================================================================================================================================================================\r\n// takes a location such as afile.txt  and changes to https://maps.im/afile.txt   (any http://localhost:1234 becomes http://localhost)\r\n//===================================================================================================================================================================\r\nfunction URLToFinal(urlloc) {\r\n    ToRet = window.location.origin + '/' + urlloc;\r\n    ToRet = ToRet.replace('localhost:1234', 'localhost');     // debugging move from localhost:1234 to just localhost for serving our files\r\n    return ToRet;\r\n}\r\n//===================================================================================================================================================================\r\n// http to https\r\nif (window.location.origin.replace('localhost', '').length == window.location.origin.length)   // not running localhost\r\n{\r\n    if (location.protocol !== 'https:') {\r\n        location.replace(`https:${location.href.substring(location.protocol.length)}`);\r\n    }\r\n}\r\n//===================================================================================================================================================================\r\n// Detect if is mobile\r\nvar ScaleMarkers = 0.6;\r\nvar PopoverWidth = 372;\r\nvar PopoverHeight = 208;\r\nif (/Android|webOS|iPhone|iPad|Mac|Macintosh|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) { // mobile\r\n    ScaleMarkers = 1;\r\n    $(\"head\").append('<style>.popover { width: 600px; }</style>');\r\n    PopoverWidth = 572;\r\n    PopoverHeight = 319;\r\n} else {\r\n    $(\"head\").append('<style>.popover { width: 400px; }</style>');\r\n}\r\n//===================================================================================================================================================================\r\n/*function rotate_image() {\r\n    var newMapLayer;\r\n\r\n    if ($(this).is(':checked'))\r\n        newMapLayer = 'https://tile.openstreetmap.org/{z}/{x}/{y}.png';\r\n    else\r\n        newMapLayer = 'https://mt0.google.com/vt/lyrs=s&hl=en&x={x}&y={y}&z={z}';\r\n\r\n    if (newMapLayer != mapLayer) {\r\n        map.addLayer(newMapLayer);\r\n        map.removeLayer(mapLayer);\r\n        mapLayer = newMapLayer;\r\n    }\r\n}\r\n*/\r\n/*$('#testButton').click(function () {\r\n    console.log('click');\r\n    map.getView().setZoom(map.getView().getZoom() + 1);\r\n});\r\nvar graphic = new Image(\r\n    'Document Page',\r\n    \"http://www.hdwallpapersinn.com/wp-content/uploads/2013/03/landscape_7.jpg\",\r\n    new Bounds(-250, -100, 250, 100),\r\n    new Size(250, 100)\r\n);*/\r\n//map.addLayers([graphic]);\r\n/*var layersOSM = new Group({\r\n    layers: [\r\n        new TileLayer({\r\n            source: new OSM()\r\n        })\r\n    ]\r\n});\r\nvar layersMQ = new Group({\r\n    layers: [\r\n        new TileLayer({\r\n            source: new MapQuest({ layer: 'osm' })\r\n        })\r\n    ]\r\n});\r\nfunction setMapType(newType) {\r\n    if (newType == 'OSM') {\r\n        map.setLayerGroup(layersOSM);\r\n    } else if (newType == 'MAPQUEST_OSM') {\r\n        map.setLayerGroup(layersMQ);\r\n    }\r\n}\r\n*/\r\n//===================================================================================================================================================================\r\n//sets position to URL coordinates\r\nconst IOM = fromLonLat([-4.543088, 54.225411]);\r\nlet zoom = 11;\r\n//const BottomLeft = fromLonLat([-5.112288, 54.021665]);\r\n//const TopRight = fromLonLat([-4.106921, 54.482645]);\r\n//let boundingExtent = Extent.boundingExtent([BottomLeft, TopRight]);\r\nvar CurrentWindowLocation = '';\r\nif (window.location.hash !== '') {\r\n    // try to restore center, zoom-level and rotation from the URL\r\n    const hash = window.location.hash.replace('#map=', '');\r\n    const parts = hash.split('/');\r\n    if (parts.length === 3) {\r\n        zoom = parseFloat(parts[0]);\r\n        center = [parseFloat(parts[1]), parseFloat(parts[2])];\r\n        //alert(center);\r\n    }\r\n}\r\nwindow.addEventListener('popstate', function (event) {\r\n    // Log the state data to the console\r\n    console.log(event.state);\r\n    if (window.location.hash !== '' && window.location.hash !==CurrentWindowLocation) {\r\n        // try to restore center, zoom-level and rotation from the URL\r\n        const hash = window.location.hash.replace('#map=', '');\r\n        const parts = hash.split('/');\r\n        if (parts.length === 3) {\r\n            zoom = parseFloat(parts[0]);\r\n            center = [parseFloat(parts[1]), parseFloat(parts[2])];\r\n            view = map.getView();\r\n            view.setCenter(center);\r\n            view.setZoom(zoom);\r\n            map.render();\r\n        }\r\n    }\r\n});\r\n\r\n\r\n//=====================================================================================================================================================================================\r\n//Overlay Layer selector POPUP\r\nvar CustomButton;\r\nclass RotateNorthControl extends Control {\r\n    /**\r\n     * @param {Object} [opt_options] Control options.\r\n     */\r\n    constructor(opt_options) {\r\n        const options = opt_options || {};\r\n\r\n        CustomButton = document.createElement('button');\r\n        CustomButton.innerHTML = 'N';\r\n\r\n        const element = document.createElement('div');\r\n        element.className = 'rotate-north ol-unselectable ol-control';\r\n\r\n//       element.innerHTML += \"<p class=\\\"pop-target\\\"><a href= \\\"#\\\" title=\\\"\\\" data-toggle=\\\"popover\\\" data-content=\\\"You world\\\" data-original-title=\\\"Wisdom Quotes\\\"></a></p>\";\r\n        \r\n        element.appendChild(CustomButton);\r\n\r\n        super({\r\n            element: element,\r\n            target: options.target,\r\n        });\r\n\r\n        CustomButton.addEventListener('click', this.handleRotateNorth.bind(this), false);\r\n    }\r\n    handleRotateNorth(event) {\r\n\r\n//popupOverlaySelector.setElement = CustomButton;\r\n\r\n      //  $(\".pop-target a\").popover('show');\r\n//            const coordinate = feature.getGeometry().getCoordinates();\r\n//            popupOverlaySelector.setPosition(coordinate);\r\n            $(elementOverlaySelector).popover({\r\n                container: elementOverlaySelector.parentElement,\r\n                html: true,\r\n                sanitize: false,\r\n                content: 'HI',\r\n                placement: 'top',\r\n            });\r\n            $(elementOverlaySelector).popover('show');\r\n    }\r\n}\r\n\r\n\r\n\r\n//===================================================================================================================================================================\r\n//MAP\r\nvar bingLayer = new TileLayer({\r\n    name: 'Test_bing',\r\n    source: new XYZ({\r\n        url: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',\r\n    })\r\n})\r\nconst map = new Map({\r\n    controls: defaultControls().extend([\r\n        new ScaleLine({\r\n            units: 'metric',\r\n        \r\n        }),\r\n        new RotateNorthControl()\r\n    ]),\r\n    target: 'map',\r\n    layers: [\r\n        new TileLayer({\r\n            source: new XYZ({\r\n                url: 'https://mt0.google.com/vt/lyrs=s&hl=en&x={x}&y={y}&z={z}',\r\n\r\n                      attributions:\r\n                    '� <a href=\" https://www.google.com/maps/' +\r\n                    '\">Google</a>',                 \r\n            })\r\n        }),\r\n    ],\r\n    view: new View({\r\n        center: IOM,\r\n        zoom: zoom,\r\n        enableRotation: false,\r\n        extent:[- 572513.341856, 7161017.966314, -416327.095083, 7276950.728974]\r\n //       extent: boundingExtent\r\n    })\r\n});\r\n\r\n\r\n//===================================================================================================================================================================\r\n// Load our layers\r\nfunction AddOurLayers(urlloc) {\r\n    // read text from URL location\r\n    var request = new XMLHttpRequest();\r\n    request.open('GET', URLToFinal(urlloc), true);\r\n    request.send(null);\r\n    request.onreadystatechange = function () {\r\n        if (request.readyState === 4 && request.status === 200) {\r\n            var type = request.getResponseHeader('Content-Type');\r\n            if (type.indexOf(\"text\") !== 1) {\r\n                var Response = request.responseText;\r\n                var MapsToAdd = Response.split(\"\\r\\n\");\r\n                for (var i = 1; i < MapsToAdd.length; i++) {\r\n                    if (i == 1) {\r\n                        var ALayer = new TileLayer({\r\n                            source: new TileWMS({\r\n                                url: MapsToAdd[0],\r\n                                params: { 'LAYERS': MapsToAdd[i], 'TILED': true },\r\n                                serverType: 'geoserver',\r\n                                transition: 0,\r\n                                attributions:\r\n                                    '� <a href=\"https://www.dronesurvey.im/' +\r\n                                    '\">DroneSurvey.im</a>',\r\n                            }),\r\n                            zIndex: 1\r\n                        });\r\n                        map.addLayer(ALayer);\r\n                    } else {\r\n                        var ALayer = new TileLayer({\r\n                            source: new TileWMS({\r\n                                url: MapsToAdd[0],\r\n                                params: { 'LAYERS': MapsToAdd[i], 'TILED': true },\r\n                                serverType: 'geoserver',\r\n                                transition: 0,\r\n                            }),\r\n                        });\r\n                        map.addLayer(ALayer);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\nAddOurLayers('!iommaps.txt');\r\n\r\n\r\n\r\n$('input[class=set]').click(function () {\r\n    alert(\"Change some parameters\");\r\n    var group = map.getLayerGroup();\r\n    var layers = group.getLayers();\r\n    var element = layers.item(0);\r\n    var name = element.get('name');\r\n    alert(name);\r\n    if (name != \"Test_bing\") {\r\n        map.removeLayer(TileLayer);\r\n        map.addLayer(bingLayer);\r\n    } else {\r\n        map.removeLayer(bingLayer);\r\n        map.addLayer(TileLayer);\r\n    }\r\n});\r\n\r\n\r\n\r\n\r\n//var popup2 = new Overlay.Popup();\r\n//map.addOverlay(popup2);\r\n\r\n\r\n//===================================================================================================================================================================\r\n//MARKERS\r\nclass MarkerOnMap {\r\n    constructor(ShowName, InfoLine, InternalFolder, ShowAtZoomLevel, Latitude, Longitude) {\r\n        this.ShowName = ShowName;\r\n        this.InfoLine = InfoLine;\r\n        this.InternalFolder = InternalFolder;       // has to be unique\r\n        this.ShowAtZoomLevel = ShowAtZoomLevel;\r\n        this.Latitude = Latitude;           // NS\r\n        this.Longitude = Longitude;         // EW\r\n        this.IsShowing = false;\r\n    }\r\n}\r\nlet MarkersOnMap = [];\r\nvar MarkersGrp = new LayerGroup({\r\n    title: 'Markers',\r\n    layers: []\r\n});\r\nmap.addLayer(MarkersGrp); //this add a new layergroup\r\nfunction ProcessMarkersToMap() {\r\n    var Zoom = map.getView().getZoom();\r\n    var ReGenAllLayer = false;\r\n    for (iMarker = 0; iMarker < MarkersOnMap.length; iMarker++) {\r\n        if (MarkersOnMap[iMarker].ShowAtZoomLevel > Zoom) {\r\n            if (MarkersOnMap[iMarker].IsShowing == true)\r\n                ReGenAllLayer = true;\r\n        } else {\r\n            if (MarkersOnMap[iMarker].IsShowing == false)\r\n                ReGenAllLayer = true;\r\n        }\r\n    }\r\n    if (ReGenAllLayer == true) {\r\n        MarkersGrp.getLayers().clear();\r\n        for (iMarker = 0; iMarker < MarkersOnMap.length; iMarker++) {\r\n            MarkersOnMap[iMarker].IsShowing = false;\r\n            if (MarkersOnMap[iMarker].ShowAtZoomLevel > Zoom)\r\n                continue;\r\n            MarkersOnMap[iMarker].IsShowing = true;\r\n            var marker = new Feature({\r\n                title: 'IOMMarker-' + iMarker,\r\n                geometry: new Point(\r\n                    fromLonLat([MarkersOnMap[iMarker].Longitude, MarkersOnMap[iMarker].Latitude])\r\n                ),\r\n            });\r\n            var markerVectorLayer = new VectorLayer({\r\n                title: iMarker,\r\n                source: new VectorSource({\r\n                    features: [marker]\r\n                }),\r\n                style: new Style({\r\n                    image: new Icon({\r\n                        src: URLToFinal('3dmodels/' + MarkersOnMap[iMarker].InternalFolder + '/3dmarker.png'),\r\n                        size: [92, 92],\r\n                        scale: ScaleMarkers,\r\n                        anchor: [0.5, 1.0]\r\n                    })\r\n                }),\r\n                zIndex: 2\r\n            });\r\n            MarkersGrp.getLayers().push(markerVectorLayer);\r\n        }\r\n    }\r\n}\r\nfunction AddOurMarkers(urlloc) {\r\n    // read text from URL location\r\n    var request = new XMLHttpRequest();\r\n    request.open('GET', URLToFinal(urlloc), true);\r\n    request.send(null);\r\n    request.onreadystatechange = function () {\r\n        if (request.readyState === 4 && request.status === 200) {\r\n            var type = request.getResponseHeader('Content-Type');\r\n            if (type.indexOf(\"text\") !== 1) {\r\n                var Response = request.responseText;\r\n                var MarkersToAdd = Response.split(\"\\r\\n\");\r\n                const ElementsInMarkerstxt = 6;\r\n                for (var i = 0; i < MarkersToAdd.length / ElementsInMarkerstxt; i++) {        // 5 elements in each marker\r\n                    var ShowName = MarkersToAdd[0 + (i * ElementsInMarkerstxt)];\r\n                    var InfoLine = MarkersToAdd[1 + (i * ElementsInMarkerstxt)];\r\n                    var InternalFolder = MarkersToAdd[2 + (i * ElementsInMarkerstxt)];\r\n                    var ShowAtZoomLevel = MarkersToAdd[3 + (i * ElementsInMarkerstxt)];\r\n                    var Latitude = MarkersToAdd[4 + (i * ElementsInMarkerstxt)];\r\n                    var Longitude = MarkersToAdd[5 + (i * ElementsInMarkerstxt)];\r\n                    if (ShowName != '') {\r\n                        MarkersOnMap.push(new MarkerOnMap(ShowName, InfoLine, InternalFolder, ShowAtZoomLevel, Latitude, Longitude));\r\n                    }\r\n                }\r\n                ProcessMarkersToMap();\r\n            }\r\n        }\r\n    }\r\n}\r\nAddOurMarkers('!iommapmarkers.txt');\r\n//var markersVisable = false;\r\nvar currZoom = 0;\r\n//const ShowMarkersZoom = 12;\r\n//===================================================================================================================================================================\r\n//\r\nmap.on('moveend', function (e) {\r\n    var view = map.getView();\r\n    var newZoom = view.getZoom();\r\n    if (currZoom != newZoom)\r\n    {\r\n        ProcessMarkersToMap();\r\n        currZoom = newZoom;\r\n    }\r\n    //this is bound to the map, so:\r\n    const center = view.getCenter();\r\n    CurrentWindowLocation =\r\n        '#map=' +\r\n        view.getZoom().toFixed(2) +\r\n        '/' +\r\n        center[0].toFixed(2) +\r\n        '/' +\r\n        center[1].toFixed(2);\r\n    window.location.hash = CurrentWindowLocation;\r\n});\r\n//===================================================================================================================================================================\r\n//Marker POPUP\r\nconst elementMarker = document.getElementById('popup');\r\nconst popupMarker = new Overlay({\r\n    element: elementMarker,\r\n    positioning: 'bottom-center',\r\n    stopEvent: true,\r\n    offset: [0, -10],\r\n});\r\nmap.addOverlay(popupMarker);\r\n\r\nmap.on('click', function (event) {\r\n    $(elementMarker).popover('dispose');\r\n //   console.info(map.getView().getCoordinates());\r\n    const feature = map.getFeaturesAtPixel(event.pixel)[0];\r\n    if (feature) {\r\n        var Title = feature.get('title');\r\n        var iMarker = Title.replace('IOMMarker-', '');\r\n        var view = map.getView();\r\n//console.info(Title);\r\n        if (iMarker.length < Title.length) {\r\n            const coordinate = feature.getGeometry().getCoordinates();\r\n            var LinkURL = URLToFinal('3dmodels/' + MarkersOnMap[iMarker].InternalFolder + '/');\r\n            popupMarker.setPosition(coordinate);\r\n            $(elementMarker).popover({\r\n                container: elementMarker.parentElement,\r\n                html: true,\r\n                sanitize: false,\r\n                content: '<table><tr><td style=\"vertical-align:top\"><a class=\"link\" href=\"' + LinkURL + '\"><img width=\"' + PopoverWidth + 'px\" height=\"'+ PopoverHeight +'px\" src=\"' + URLToFinal('3dmodels/' + MarkersOnMap[iMarker].InternalFolder + '/popupimg.jpg') + '\"></a></td>' +\r\n                    '<tr><td style=\"vertical-align:top\"><a class=\"programtitle link\" href=\"' + LinkURL + '\">' + MarkersOnMap[iMarker].ShowName + '</a></td></tr>' +\r\n                    '<tr><td class=\"main\">' + MarkersOnMap[iMarker].InfoLine + \"</td></tr>\" +\r\n                    '<tr><td style=\"vertical-align:top\"><div style=\"text-align:right;\"><a class=\"link\" href=\"' + LinkURL + '\"><img height=\"75px\" src=\"' + URLToFinal('images/info.png') + '\"></a><a class=\"link\" href=\"' + LinkURL + '\"><img height=\"75px\" src=\"' + URLToFinal('images/viewin3d.png') + '\"></a></div></td></tr>' +\r\n                    '</table>',\r\n                placement: 'top',\r\n            });\r\n            $(elementMarker).popover('show');\r\n        }\r\n    } else {\r\n        $(elementMarker).popover('dispose');\r\n    }\r\n});\r\n//CURSOR CHANGE\r\nmap.on('pointermove', function (event) {\r\n    if (map.hasFeatureAtPixel(event.pixel)) {\r\n        map.getViewport().style.cursor = 'pointer';\r\n    } else {\r\n        map.getViewport().style.cursor = 'inherit';\r\n    }\r\n});\r\nmap.on('movestart', function () {\r\n    $(elementMarker).popover('dispose');\r\n});\r\n\r\n\r\n\r\n\r\n\r\n\r\n//https://viglino.github.io/ol-ext/examples/control/map.switcher.image.html"],"names":["$003acff01e79c0a73122c747343d2e59$export$9099ad97b570f7c","BaseEvent","type","this","propagationStopped","target","prototype","preventDefault","stopPropagation","$bfcfd5d9960b75cc9cb78b58301ad8a4$export$9099ad97b570f7c","$f7bbc97715b7cef936b659025f276afb$export$9099ad97b570f7c","Disposable","disposed","dispose","disposeInternal","$7c21d7646a0313abf7b847efa68bfceb$export$8eda8fbd1364c8a1","a","b","$7c21d7646a0313abf7b847efa68bfceb$export$45934da9231b7323","arr","direction","n","length","i","$7c21d7646a0313abf7b847efa68bfceb$export$1f4f991ce94838ce","begin","end","tmp","$7c21d7646a0313abf7b847efa68bfceb$export$46e35401bc090c62","data","extension","Array","isArray","$7c21d7646a0313abf7b847efa68bfceb$export$bcc761834e33d339","arr1","arr2","len1","$8ff7925ef9afa7e69604ab9620edac22$export$ad8dd69aa6772cd0","$8ff7925ef9afa7e69604ab9620edac22$export$5c50afa32081505e","$8ff7925ef9afa7e69604ab9620edac22$export$3850addf0fb4e6a7","$e1ac967f910869e98e549bfd20a1853c$export$f3c88f5a058bec38","Object","assign","var_sources","TypeError","output","ii","arguments","source","key","hasOwnProperty","$e1ac967f910869e98e549bfd20a1853c$export$97fff7491bd246bd","object","property","$e1ac967f910869e98e549bfd20a1853c$export$207c30846165e93a","values","push","$e1ac967f910869e98e549bfd20a1853c$export$988399e568471db1","$99fe3f3343ef18166bd431edc467d890$export$9099ad97b570f7c","_super","Target","opt_target","_this","call","eventTarget_","pendingRemovals_","dispatching_","listeners_","$99fe3f3343ef18166bd431edc467d890$var$__extends","addEventListener","listener","listeners","listenersForType","indexOf","dispatchEvent","event","evt","propagate","dispatching","pendingRemovals","handleEvent","pr","removeEventListener","getListeners","undefined","hasListener","opt_type","keys","index","splice","$c81aa09fb137106970dbc142b1e89ec3$export$9099ad97b570f7c","$7961378a294a4943979a10a4df4a3fcf$export$ff95bcce2965a200","opt_this","opt_once","bind","originalListener_1","apply","eventsKey","$7961378a294a4943979a10a4df4a3fcf$export$d2df825b2d8bc2ba","$7961378a294a4943979a10a4df4a3fcf$export$6dee5fd4fdf600ff","$02e80757fefec0a9636ae28d17c9fab2$export$21f63b82add5980c","$02e80757fefec0a9636ae28d17c9fab2$export$9099ad97b570f7c","Observable","revision_","$02e80757fefec0a9636ae28d17c9fab2$var$__extends","changed","getRevision","on","len","once","ol_key","un","$99fe3f3343ef18166bd431edc467d890$exports","default","$cd365e7aabd14aaf6df378f6a61e84d7$export$18e1b4ff5b3c2297","Error","$cd365e7aabd14aaf6df378f6a61e84d7$var$uidCounter_","$cd365e7aabd14aaf6df378f6a61e84d7$export$604e9536b9e0488a","obj","ol_uid","String","$cd365e7aabd14aaf6df378f6a61e84d7$export$f2eb173e8f6e4130","$a41f90da440d5a4a421775ee47a2c536$export$b902cfd711fa7f06","ObjectEvent","oldValue","$a41f90da440d5a4a421775ee47a2c536$var$__extends","$a41f90da440d5a4a421775ee47a2c536$var$BaseObject","BaseObject","opt_values","values_","setProperties","get","value","getKeys","getProperties","hasProperties","notify","eventType","$a41f90da440d5a4a421775ee47a2c536$export$b958104f5d8e9527","set","opt_silent","applyProperties","unset","$02e80757fefec0a9636ae28d17c9fab2$exports","$a41f90da440d5a4a421775ee47a2c536$var$changeEventTypeCache","$a41f90da440d5a4a421775ee47a2c536$export$9099ad97b570f7c","$841b38a534c9217d8aceb4320d3d91b5$export$9099ad97b570f7c","$2016f251f21b02e27a5ca36c37510540$var$ua","navigator","userAgent","toLowerCase","$2016f251f21b02e27a5ca36c37510540$export$543c908bf17a24fb","$2016f251f21b02e27a5ca36c37510540$export$bccc8605349feea7","$2016f251f21b02e27a5ca36c37510540$export$f16ffc71033a7aaa","$2016f251f21b02e27a5ca36c37510540$export$1940d5d2b4cf824d","devicePixelRatio","$2016f251f21b02e27a5ca36c37510540$export$b011c43406458fa9","WorkerGlobalScope","OffscreenCanvas","self","$2016f251f21b02e27a5ca36c37510540$export$9544418e5c6fedfe","Image","decode","$2016f251f21b02e27a5ca36c37510540$export$700ce540937d8c69","passive","options","defineProperty","window","error","$8b566ca8fd3b2d9c184057ba73cbf345$export$fe55455cced7aebb","opt_width","opt_height","opt_canvasPool","canvas","shift","document","createElement","width","height","getContext","$8b566ca8fd3b2d9c184057ba73cbf345$export$954ce77093b0d494","element","offsetWidth","style","getComputedStyle","parseInt","marginLeft","marginRight","$8b566ca8fd3b2d9c184057ba73cbf345$export$a3ec1d24165186f9","offsetHeight","marginTop","marginBottom","$8b566ca8fd3b2d9c184057ba73cbf345$export$495cfc7e7a2968e6","newNode","oldNode","parent","parentNode","replaceChild","$8b566ca8fd3b2d9c184057ba73cbf345$export$47503d53c08beb29","node","removeChild","$8b566ca8fd3b2d9c184057ba73cbf345$export$f0994cfd84ab1152","lastChild","$8316c877d328ebfc4f4b917229eec057$export$9099ad97b570f7c","Control","pointerEvents","target_","map_","listenerKeys","render","setTarget","$8316c877d328ebfc4f4b917229eec057$var$__extends","getMap","setMap","map","getOverlayContainerStopEvent","appendChild","mapEvent","getElementById","$a41f90da440d5a4a421775ee47a2c536$exports","$7ef0aa4943b3f1208e19af1336a3f8f6$export$4b206f1dd0085e9f","$7ef0aa4943b3f1208e19af1336a3f8f6$export$2fbf9d496fb0d5a8","$7ef0aa4943b3f1208e19af1336a3f8f6$export$6cfb92f3ca39d412","$7ef0aa4943b3f1208e19af1336a3f8f6$export$a6463a3b3793c500","$7ef0aa4943b3f1208e19af1336a3f8f6$var$fontRegEx","RegExp","join","$7ef0aa4943b3f1208e19af1336a3f8f6$var$fontRegExMatchIndex","$7ef0aa4943b3f1208e19af1336a3f8f6$export$b705256ab57c20ca","fontSpec","match","lineHeight","size","weight","variant","families","family","split","$6e657bb9f80dab756c945a825e2a2cee$export$9099ad97b570f7c","$fd652548d0f540d94aaff6aa830746d2$export$9099ad97b570f7c","AssertionError","code","message","name","$fd652548d0f540d94aaff6aa830746d2$var$__extends","$2ce41f61858dd350a0b2670bdab4e597$export$b8795f4f643ce74f","assertion","errorCode","$fd652548d0f540d94aaff6aa830746d2$exports","$916dab65013919ad0345478f9a9f4e0f$export$4b8705656de00c72","min","max","Math","$916dab65013919ad0345478f9a9f4e0f$export$4a376e0f60d976ee","cosh","x","y","exp","$916dab65013919ad0345478f9a9f4e0f$export$e08236045caaa3e1","log2","log","LOG2E","$916dab65013919ad0345478f9a9f4e0f$export$fd0b1e5ac4df516c","x1","y1","x2","y2","dx","dy","t","$916dab65013919ad0345478f9a9f4e0f$export$8b6706701cd75ea9","$916dab65013919ad0345478f9a9f4e0f$export$11468133b1231643","angleInRadians","PI","$916dab65013919ad0345478f9a9f4e0f$export$4fc80c88d72f096","angleInDegrees","$916dab65013919ad0345478f9a9f4e0f$export$3334706ffb3dccb1","r","$916dab65013919ad0345478f9a9f4e0f$export$45ca8e7f50ccf2e0","$3a8294651627eb74246351f5b596cf68$export$9099ad97b570f7c","BaseLayer","properties","opacity","visible","zIndex","maxResolution","Infinity","minResolution","minZoom","maxZoom","className_","className","state_","$3a8294651627eb74246351f5b596cf68$var$__extends","getClassName","getLayerState","opt_managed","state","layer","managed","getZIndex","round","getOpacity","sourceState","getSourceState","getVisible","extent","getExtent","getMaxResolution","getMinResolution","getMinZoom","getMaxZoom","getLayersArray","opt_array","getLayerStatesArray","opt_states","setExtent","setMaxResolution","setMinResolution","setMaxZoom","setMinZoom","setOpacity","setVisible","setZIndex","zindex","$939d3f0e5ddda81ef3d6b6e4c37a0795$export$9099ad97b570f7c","$88faaf1879d30d470a1b447dd4b5a77a$export$9099ad97b570f7c","$1935b85c22cfc539ea58e141ab0b37d6$export$16970faadcd3f29b","layerState","viewState","resolution","zoom","$1935b85c22cfc539ea58e141ab0b37d6$export$9099ad97b570f7c","Layer","baseOptions","mapPrecomposeKey_","mapRenderKey_","sourceChangeKey_","renderer_","getChangeEventType","handleSourcePropertyChange_","setSource","$1935b85c22cfc539ea58e141ab0b37d6$var$__extends","array","states","getSource","getState","handleSourceChange_","getFeatures","pixel","frameState","layerRenderer","getRenderer","prepareFrame","renderFrame","layerStatesArray","some","arrayLayerState","createRenderer","hasRenderer","$3a8294651627eb74246351f5b596cf68$exports","$194d017bd833b991c2c712fa2ff5b0e5$export$9099ad97b570f7c","Attribution","opt_options","ulElement_","collapsed_","collapsed","userCollapsed_","overrideCollapsible_","collapsible","collapsible_","tipLabel","expandClassName","collapseLabel","collapseClassName","collapseLabel_","textContent","label","label_","activeLabel","button","setAttribute","title","handleClick_","cssClasses","renderedAttributions_","renderedVisible_","$194d017bd833b991c2c712fa2ff5b0e5$var$__extends","collectSourceAttributions_","lookup","visibleAttributions","$1935b85c22cfc539ea58e141ab0b37d6$exports","inView","attributionGetter","getAttributions","attributions","getAttributionsCollapsible","j","jj","setCollapsible","updateElement_","display","innerHTML","handleToggle_","classList","toggle","getCollapsible","setCollapsed","getCollapsed","$8316c877d328ebfc4f4b917229eec057$exports","$994e322493abe750f187f7e3835dca5c$export$9099ad97b570f7c","$e6a59fbd122f687b33c2f382a3c7634b$var$Property","$e6a59fbd122f687b33c2f382a3c7634b$export$cf29312ab18b402e","CollectionEvent","opt_element","opt_index","$e6a59fbd122f687b33c2f382a3c7634b$var$__extends","$e6a59fbd122f687b33c2f382a3c7634b$export$9099ad97b570f7c","Collection","unique_","unique","array_","assertUnique_","updateLength_","clear","getLength","pop","extend","forEach","f","getArray","item","insertAt","elem","removeAt","remove","prev","setAt","opt_except","$8717569d70d85bd7f28c8c1b2c37daee$export$9fbc3b1d6b2da9ec","pow","$8717569d70d85bd7f28c8c1b2c37daee$export$673b9849e2bc032c","$8717569d70d85bd7f28c8c1b2c37daee$export$1b5c1277e30d397d","$8717569d70d85bd7f28c8c1b2c37daee$export$5523e35ab8ae283a","$aef56543978371a8090d728a4f107ac0$export$9099ad97b570f7c","Rotate","compassClassName","add","callResetNorth_","resetNorth","duration_","duration","autoHide_","autoHide","rotation_","$aef56543978371a8090d728a4f107ac0$var$__extends","resetNorth_","view","getView","rotation","getRotation","animate","easing","setRotation","transform","contains","$9812beea87bdcda9027d52b89085c87c$export$9099ad97b570f7c","Zoom","delta","zoomInClassName","zoomOutClassName","zoomInLabel","zoomOutLabel","zoomInTipLabel","zoomOutTipLabel","inElement","createTextNode","outElement","$9812beea87bdcda9027d52b89085c87c$var$__extends","zoomByDelta_","currentZoom","getZoom","newZoom","getConstrainedZoom","getAnimating","cancelAnimations","setZoom","$df0b68b08946bf3d8de6eeca4fba3a5f$var$Units","DEGREES","FEET","METERS","PIXELS","TILE_PIXELS","USFEET","$df0b68b08946bf3d8de6eeca4fba3a5f$export$af68584dedf5e52c","$df0b68b08946bf3d8de6eeca4fba3a5f$export$9099ad97b570f7c","$1514cc7c23ad291d61b727f0ef5e4246$export$9099ad97b570f7c","Projection","code_","units_","units","extent_","worldExtent_","worldExtent","axisOrientation_","axisOrientation","global_","global","canWrapX_","getPointResolutionFunc_","getPointResolution","defaultTileGrid_","metersPerUnit_","metersPerUnit","canWrapX","getCode","getUnits","getMetersPerUnit","getWorldExtent","getAxisOrientation","isGlobal","setGlobal","getDefaultTileGrid","setDefaultTileGrid","tileGrid","setWorldExtent","setGetPointResolution","func","getPointResolutionFunc","$7d5079714e2786ec6bee07910f0d8a86$export$8c5f77743cd0e8b7","$7d5079714e2786ec6bee07910f0d8a86$export$bb1f4f75177e5528","$7d5079714e2786ec6bee07910f0d8a86$export$6fd015d56b8406c9","$7d5079714e2786ec6bee07910f0d8a86$export$64afaa717a0c4932","$7d5079714e2786ec6bee07910f0d8a86$export$2126dea64bc40b7b","tan","$7d5079714e2786ec6bee07910f0d8a86$var$EPSG3857Projection","EPSG3857Projection","point","$7d5079714e2786ec6bee07910f0d8a86$var$__extends","$7d5079714e2786ec6bee07910f0d8a86$export$850c9b527a5298aa","$7d5079714e2786ec6bee07910f0d8a86$export$128bedc7a8a0ae2c","input","opt_output","opt_dimension","dimension","slice","$7d5079714e2786ec6bee07910f0d8a86$export$f361696640082386","atan","$655738a66489cc3574c072262645bff6$export$6fd015d56b8406c9","$655738a66489cc3574c072262645bff6$export$af68584dedf5e52c","$655738a66489cc3574c072262645bff6$var$EPSG4326Projection","EPSG4326Projection","opt_axisOrientation","$655738a66489cc3574c072262645bff6$var$__extends","$655738a66489cc3574c072262645bff6$export$850c9b527a5298aa","$0ba2913765cbb83278246e730dbcdcdf$var$cache","$6cb154572a1cc3d19ea74b1e9a3a7861$var$transforms","$6cb154572a1cc3d19ea74b1e9a3a7861$export$568ed88074851180","destination","transformFn","sourceCode","destinationCode","$8fe041eefe2f7aaeb97e4d98623d5d5e$export$9099ad97b570f7c","$8913dbc1b585601bf0ecb482246c0b4c$export$9099ad97b570f7c","$8ebfb36ef5532881c5652b708da2c120$export$a7ecbd362d65c1fe","coordinates","$8ebfb36ef5532881c5652b708da2c120$export$dbb3d72606cdc11","$8ebfb36ef5532881c5652b708da2c120$export$2852acc8f8b94686","$8ebfb36ef5532881c5652b708da2c120$export$14e1765886db335a","opt_extent","$8ebfb36ef5532881c5652b708da2c120$export$d6a0542127b96c83","$8ebfb36ef5532881c5652b708da2c120$export$c7d6a927f416dd39","$8ebfb36ef5532881c5652b708da2c120$export$c422a9fcb5f1ee5c","coordinate","$8ebfb36ef5532881c5652b708da2c120$export$cc70e7e516e4370f","$8ebfb36ef5532881c5652b708da2c120$export$4f55e2d709659e7b","extent1","extent2","$8ebfb36ef5532881c5652b708da2c120$export$9bdde4fe01cd4b6b","minX","minY","maxX","maxY","relationship","$8ebfb36ef5532881c5652b708da2c120$export$ea8082d0226d35a5","$8ebfb36ef5532881c5652b708da2c120$export$80741250c74fd4fa","$8ebfb36ef5532881c5652b708da2c120$export$bcc761834e33d339","$8ebfb36ef5532881c5652b708da2c120$export$bfc2e43ae5c3c00c","$8ebfb36ef5532881c5652b708da2c120$export$4b116deb3079b147","flatCoordinates","offset","stride","$8ebfb36ef5532881c5652b708da2c120$export$8696fee511ea7c7a","$8ebfb36ef5532881c5652b708da2c120$export$c26f7b9c5adc34b4","callback","val","$8ebfb36ef5532881c5652b708da2c120$export$3932426cd8118930","$8ebfb36ef5532881c5652b708da2c120$export$4e2fc25ce97f3583","$8ebfb36ef5532881c5652b708da2c120$export$35aedeaeee8be6cd","$8ebfb36ef5532881c5652b708da2c120$export$5100f0815ea32995","$8ebfb36ef5532881c5652b708da2c120$export$ab4e37d31d15614d","area","$8ebfb36ef5532881c5652b708da2c120$export$988399e568471db1","$8ebfb36ef5532881c5652b708da2c120$export$3dc3550566517965","$8ebfb36ef5532881c5652b708da2c120$export$e178c8044d3d0a05","$8ebfb36ef5532881c5652b708da2c120$export$339e303bf205caae","$8ebfb36ef5532881c5652b708da2c120$export$38622892ed79bdc7","corner","$8ebfb36ef5532881c5652b708da2c120$export$3212225221d5bc14","center","cosRotation","cos","sinRotation","sin","xCos","xSin","yCos","ySin","x0","x3","y0","y3","$8ebfb36ef5532881c5652b708da2c120$export$c491031eb9adcc3a","intersection","$8ebfb36ef5532881c5652b708da2c120$export$c3bd2c3b798b0350","$8ebfb36ef5532881c5652b708da2c120$export$76e02248c0889c3e","opt_stops","xs","ys","l","$8ebfb36ef5532881c5652b708da2c120$var$_boundingExtentXYs","$29d4509fdec4b1b2fe8c71c42629ef39$export$9099ad97b570f7c","$525020a649871896a05d6fe288616b91$export$761de677acb0d085","$525020a649871896a05d6fe288616b91$export$aec7b6756585c081","c1","c2","opt_radius","radius","lat1","lat2","deltaLatBy2","deltaLonBy2","atan2","sqrt","$525020a649871896a05d6fe288616b91$export$80a87d59b6e09730","distance","bearing","lon1","dByR","lat","asin","$29884e9b826cd25109649ab0c360e769$export$bcc761834e33d339","coordinate1","coordinate2","equals","$29884e9b826cd25109649ab0c360e769$export$d40e2456b1281660","angle","cosAngle","sinAngle","$29884e9b826cd25109649ab0c360e769$export$5a0d9577a24f3c5b","projection","worldWidth","worldsAway","$29884e9b826cd25109649ab0c360e769$export$c8ebaff90a21375a","opt_sourceExtentWidth","projectionExtent","sourceExtentWidth","floor","$524e9c84a4c58bd58490804da4c772c6$export$3fbbaef54e2e9d28","$524e9c84a4c58bd58490804da4c772c6$export$678028d364072132","$524e9c84a4c58bd58490804da4c772c6$export$6308908a0016f099","$0ba2913765cbb83278246e730dbcdcdf$export$568ed88074851180","$524e9c84a4c58bd58490804da4c772c6$export$7eb84799c931fe91","projectionLike","replace","$524e9c84a4c58bd58490804da4c772c6$export$75cdc5d556e3d9b2","opt_units","pointResolution","getter","toEPSG4326_1","$524e9c84a4c58bd58490804da4c772c6$export$747af4f49bde2f53","vertices","$524e9c84a4c58bd58490804da4c772c6$export$a42db349809b0c24","projections","$524e9c84a4c58bd58490804da4c772c6$export$fd4cd3535c7ea97f","$524e9c84a4c58bd58490804da4c772c6$export$f704437a72056fb8","defaultCode","$524e9c84a4c58bd58490804da4c772c6$export$13550698a4b6771e","opt_projection","$524e9c84a4c58bd58490804da4c772c6$export$4b169b49e1a4823b","$524e9c84a4c58bd58490804da4c772c6$export$c7a9310bdeddab53","projection1","projection2","equalUnits","sourceProjection","destinationProjection","transformFunc","$6cb154572a1cc3d19ea74b1e9a3a7861$export$7eb84799c931fe91","$524e9c84a4c58bd58490804da4c772c6$export$9336879ef6599bf5","$524e9c84a4c58bd58490804da4c772c6$export$f2a2f51d8aa8d6b0","projections2","forwardTransform","inverseTransform","$524e9c84a4c58bd58490804da4c772c6$var$userProjection","$524e9c84a4c58bd58490804da4c772c6$export$352fd07bdd93dc1e","$524e9c84a4c58bd58490804da4c772c6$export$4a182a4d53d7595c","$524e9c84a4c58bd58490804da4c772c6$export$b5d00774755783fc","destProjection","$524e9c84a4c58bd58490804da4c772c6$export$a7d473ff80a6a3b","$524e9c84a4c58bd58490804da4c772c6$export$f87215506b474b9e","$7d5079714e2786ec6bee07910f0d8a86$exports","PROJECTIONS","$655738a66489cc3574c072262645bff6$exports","fromEPSG4326","toEPSG4326","$f41607ead8a4acc607ffb32c05f65f86$var$UNITS_PROP","$f41607ead8a4acc607ffb32c05f65f86$export$9d6d462c9b8add1e","IMPERIAL","NAUTICAL","METRIC","US","$f41607ead8a4acc607ffb32c05f65f86$var$LEADING_DIGITS","$f41607ead8a4acc607ffb32c05f65f86$var$DEFAULT_DPI","$f41607ead8a4acc607ffb32c05f65f86$export$9099ad97b570f7c","ScaleLine","bar","innerElement_","viewState_","minWidth_","minWidth","renderedWidth_","renderedHTML_","handleUnitsChanged_","setUnits","scaleBar_","scaleBarSteps_","steps","scaleBarText_","text","dpi_","dpi","$f41607ead8a4acc607ffb32c05f65f86$var$__extends","setDpi","pointResolutionUnits","nominalCount","suffix","metersPerDegree","count","decimalCount","html","decimal","isNaN","createScaleBar","toFixed","scale","mapScale","getScaleForResolution","toLocaleString","scaleSteps","stepWidth","backgroundColor","createMarker","createStepText","position","isLast","lengthString","mpu","parseFloat","toString","$c10299a05f898a09c43f788b5b6dfdbd$export$b403fbac94228e09","controls","$e6a59fbd122f687b33c2f382a3c7634b$exports","$9812beea87bdcda9027d52b89085c87c$exports","zoomOptions","rotate","$aef56543978371a8090d728a4f107ac0$exports","rotateOptions","attribution","$194d017bd833b991c2c712fa2ff5b0e5$exports","attributionOptions","$fe05caf5f991aea82bd67c9bebabc467$export$7cf753b6a6534915","styles_1","$fe05caf5f991aea82bd67c9bebabc467$export$9099ad97b570f7c","Feature","opt_geometryOrProperties","id_","geometryName_","style_","styleFunction_","geometryChangeKey_","handleGeometryChanged_","getSimplifiedGeometry","geometry","setGeometry","$fe05caf5f991aea82bd67c9bebabc467$var$__extends","clone","setGeometryName","getGeometryName","getGeometry","getStyle","setStyle","getId","getStyleFunction","handleGeometryChange_","opt_style","setId","id","$250247a34cdb6d9c26d2c6d3640e511f$export$9099ad97b570f7c","$c921d54e03c98d7c23acffcfb75264d3$export$9099ad97b570f7c","$ddbf871807cbdb80f3672c8008047cee$export$9099ad97b570f7c","$8556eff40cf4f1624cd78ff7ea054c5b$export$14e1765886db335a","num","opt_size","$8556eff40cf4f1624cd78ff7ea054c5b$export$8f869025bba9609b","ratio","$8556eff40cf4f1624cd78ff7ea054c5b$export$48d31d2725e4d98b","$96f7f946d494434256fc7391bfca3d81$export$9099ad97b570f7c","ImageStyle","opacity_","rotateWithView_","rotateWithView","scale_","scaleArray_","displacement_","displacement","getScale","getRotateWithView","getDisplacement","getScaleArray","getAnchor","getImage","pixelRatio","getHitDetectionImage","getPixelRatio","getImageState","getImageSize","getHitDetectionImageSize","getOrigin","getSize","setRotateWithView","setScale","listenImageChange","load","unlistenImageChange","$ddc7f5de3664aab559d1c545c366e59d$var$HEX_COLOR_RE_","$ddc7f5de3664aab559d1c545c366e59d$var$NAMED_COLOR_RE_","$ddc7f5de3664aab559d1c545c366e59d$export$9fe004474d6f7f65","color","$ddc7f5de3664aab559d1c545c366e59d$export$47bee913e0e80eb4","$ddc7f5de3664aab559d1c545c366e59d$var$fromNamed","el","body","rgb","cache","cacheSize","$ddc7f5de3664aab559d1c545c366e59d$export$21528ce64591bf2","s","g","exec","d","hasAlpha","substr","$ddc7f5de3664aab559d1c545c366e59d$export$2e33abec8aecd572","Number","$ddc7f5de3664aab559d1c545c366e59d$var$fromStringInternal_","$ddc7f5de3664aab559d1c545c366e59d$export$7266a24c0caa2a8","$80553d92e1fbcb82d752b6de833f9cf3$var$IconImageCache","IconImageCache","cache_","cacheSize_","maxCacheSize_","canExpireCache","expire","iconImage","src","crossOrigin","$80553d92e1fbcb82d752b6de833f9cf3$var$getKey","setSize","maxCacheSize","$80553d92e1fbcb82d752b6de833f9cf3$export$601b9e2be44c7cb2","$e65a38a3837120ad833711b5930f5912$export$9099ad97b570f7c","ImageBase","pixelRatio_","$e65a38a3837120ad833711b5930f5912$var$__extends","getResolution","$2fc4e1887f4ffa14e16ea647fd21482c$export$469eb8ba3f45955e","image","loadHandler","errorHandler","img","promise","listening_1","then","catch","ImageWrapper","imageLoadFunction","src_","image_","unlisten_","imageLoadFunction_","$2fc4e1887f4ffa14e16ea647fd21482c$var$__extends","handleImageError_","unlistenImage_","handleImageLoad_","setImage","$e65a38a3837120ad833711b5930f5912$exports","$92a5ba3fab046f40ee35c464c4cf79b4$var$taintedTestContext","$92a5ba3fab046f40ee35c464c4cf79b4$var$IconImage","IconImage","imageState","hitDetectionImage_","canvas_","color_","imageState_","size_","tainted_","$92a5ba3fab046f40ee35c464c4cf79b4$var$__extends","isTainted_","drawImage","getImageData","e","dispatchChangeEvent_","replaceColor_","context","fillRect","getSrc","$2fc4e1887f4ffa14e16ea647fd21482c$exports","listenImage","ceil","ctx","globalCompositeOperation","fillStyle","imgData","putImageData","$92a5ba3fab046f40ee35c464c4cf79b4$export$7eb84799c931fe91","$4de6336f82b6fd9bc7cf688bb41b8b96$export$9099ad97b570f7c","Icon","anchor_","anchor","normalizedAnchor_","anchorOrigin_","anchorOrigin","anchorXUnits_","anchorXUnits","anchorYUnits_","anchorYUnits","crossOrigin_","imgSize","iconImage_","$92a5ba3fab046f40ee35c464c4cf79b4$exports","offset_","offsetOrigin_","offsetOrigin","origin_","$4de6336f82b6fd9bc7cf688bb41b8b96$var$__extends","setAnchor","getColor","iconImageSize","$7eb24b24c1bb92b5f48477cc7ed0ef45$export$55029509b82b2e2b","$af95442a94d1862a138c401177ef0c4b$export$77f8d2fc923b14e3","c","$af95442a94d1862a138c401177ef0c4b$export$6af9bbf310c9e4bf","$af95442a94d1862a138c401177ef0c4b$export$452ae967caf14641","dx1","dy1","sx","sy","dx2","dy2","$af95442a94d1862a138c401177ef0c4b$export$6e6aac0f60e83c70","mat","det","$af95442a94d1862a138c401177ef0c4b$export$47bee913e0e80eb4","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$18c07a12203603b5","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$55c06ab37ead2f5d","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$ffc0c15ee0fd31b3","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$6ad0413f8fea3c71","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$4f3c27e569bdb39e","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$b679e5c5d4b15cf5","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$d721e051424a5865","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$6f57224ec3df03c9","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$70c5a077e5d6beb9","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$907cf5cff4a8acb1","console","warn","$d79b9b8aceb2a0d1337b4e6f69d78e46$var$measureFont","div","$d79b9b8aceb2a0d1337b4e6f69d78e46$var$measureContext","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$384c0f09c94ed6cc","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$6491effd8671e9f6","interval","referenceWidth","referenceFonts","isAvailable","fontStyle","fontWeight","fontFamily","available","referenceFont","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$85ae5018a2fb98b4","check","done","fonts","font","clearInterval","setInterval","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$a2bf16790cd8f004","metrics","$d79b9b8aceb2a0d1337b4e6f69d78e46$var$measureText","actualBoundingBoxAscent","actualBoundingBoxDescent","margin","padding","left","measureText","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$4b2ca35321179b27","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$c02f953f8e44cc0a","offsetX","offsetY","translate","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$3004e0c7927eb2d1","labelOrImage","originX","originY","w","h","save","globalAlpha","setTransform","contextInstructions","$d79b9b8aceb2a0d1337b4e6f69d78e46$var$executeLabelInstructions","restore","$d79b9b8aceb2a0d1337b4e6f69d78e46$var$createTransformStringCanvas","$9395bcf7fa5c622dff9d678b4abf4bba$export$9099ad97b570f7c","RegularShape","hitDetectionCanvas_","fill_","fill","points_","points","radius_","radius1","radius2_","radius2","angle_","stroke_","stroke","imageSize_","hitDetectionImageSize_","$9395bcf7fa5c622dff9d678b4abf4bba$var$__extends","getFill","getPoints","getRadius","getRadius2","getAngle","getStroke","renderOptions","createRenderOptions","createHitDetectionCanvas_","draw_","strokeStyle","lineCap","lineJoin","miterLimit","lineDash","lineDashOffset","strokeWidth","getWidth","getLineDash","getLineDashOffset","getLineJoin","getLineCap","getMiterLimit","imageSize","angle0","radiusC","beginPath","arc","lineTo","lineWidth","setLineDash","closePath","drawHitDetectionCanvas_","$19d3c8bef588e205c4ab8014047de833$export$9099ad97b570f7c","CircleStyle","$19d3c8bef588e205c4ab8014047de833$var$__extends","setRadius","$9395bcf7fa5c622dff9d678b4abf4bba$exports","$e1f9f7b0a69ff9a9f4c2bbbdfef410b1$export$9099ad97b570f7c","Fill","setColor","$4c58aec149e538982cbf4e874e866484$export$9099ad97b570f7c","Stroke","lineCap_","lineDash_","lineDashOffset_","lineJoin_","miterLimit_","width_","setLineCap","setLineDashOffset","setLineJoin","setMiterLimit","setWidth","$b550892c9c7d6707a4415bf7976deb12$var$Style","Style","geometry_","geometryFunction_","$b550892c9c7d6707a4415bf7976deb12$var$defaultGeometryFunction","renderer","text_","zIndex_","getText","setRenderer","getGeometryFunction","setFill","setStroke","setText","feature","$b550892c9c7d6707a4415bf7976deb12$var$defaultStyles","$b550892c9c7d6707a4415bf7976deb12$export$33d0043adf82cc14","$19d3c8bef588e205c4ab8014047de833$exports","$b550892c9c7d6707a4415bf7976deb12$export$9099ad97b570f7c","$52488a0195cf0e38344877f5a3896831$var$expireIconCache","$52488a0195cf0e38344877f5a3896831$export$9099ad97b570f7c","MapRenderer","$52488a0195cf0e38344877f5a3896831$var$__extends","dispatchRenderEvent","calculateMatrices2D","coordinateToPixelTransform","pixelToCoordinateTransform","forEachFeatureAtCoordinate","hitTolerance","checkWrapped","thisArg","layerFilter","thisArg2","result","translatedCoordinate","offsets","layerStates","numLayers","matches","tmpCoord","getWrapX","callback_1","order","m","i1","distanceSq","sort","forEachLayerAtPixel","hasFeatureAtCoordinate","scheduleExpireIconCache","postRenderFunctions","$1a95b8d63eeb9d5cd5e2742791ea7ab2$export$9099ad97b570f7c","RenderEvent","opt_inversePixelTransform","opt_frameState","opt_context","inversePixelTransform","$1a95b8d63eeb9d5cd5e2742791ea7ab2$var$__extends","$2ae21f590be041e7827bf48426c0766a$export$9099ad97b570f7c","CompositeMapRenderer","fontChangeListenerKey_","redrawText","element_","container","getViewport","insertBefore","firstChild","children_","$2ae21f590be041e7827bf48426c0766a$var$__extends","event_1","$1a95b8d63eeb9d5cd5e2742791ea7ab2$exports","declutterLayers","previousElement","layerIndex","renderDeclutter","children","oldChildren","childNodes","oldChild","newChild","$8b566ca8fd3b2d9c184057ba73cbf345$export$439ebc2b0f0ec9f4","getDataAtPixel","$52488a0195cf0e38344877f5a3896831$exports","$d66bdf9af75d90254b022f9a4b768a43$var$Property","$d66bdf9af75d90254b022f9a4b768a43$export$9099ad97b570f7c","LayerGroup","layers","layersListenerKeys_","listenerKeys_","handleLayersChanged_","setLayers","$d66bdf9af75d90254b022f9a4b768a43$var$__extends","handleLayerChange_","getLayers","handleLayersAdd_","handleLayersRemove_","layersArray","collectionEvent","pos","ownLayerState","$f8e1a00fe597e09d283a3697649a8ad5$export$9099ad97b570f7c","MapEvent","$f8e1a00fe597e09d283a3697649a8ad5$var$__extends","$5185059e8a82c1ae03c4e1ba7159b318$export$9099ad97b570f7c","MapBrowserEvent","originalEvent","opt_dragging","pixel_","coordinate_","dragging","$5185059e8a82c1ae03c4e1ba7159b318$var$__extends","getEventPixel","getCoordinateFromPixel","$f8e1a00fe597e09d283a3697649a8ad5$exports","$7aa259efacd921e7e7d327d1aea40a76$export$9099ad97b570f7c","SINGLECLICK","CLICK","DBLCLICK","POINTERDRAG","POINTERMOVE","POINTERDOWN","POINTERUP","POINTEROVER","POINTEROUT","POINTERENTER","POINTERLEAVE","POINTERCANCEL","$abba75ad998e5558d931e97019b1ab4c$export$9099ad97b570f7c","$75ed2fc91ec6cb8478583ef358a9dd4d$export$9099ad97b570f7c","MapBrowserEventHandler","moveTolerance","clickTimeoutId_","emulateClicks_","dragging_","dragListenerKeys_","moveTolerance_","down_","activePointers_","trackedTouches_","pointerdownListenerKey_","handlePointerDown_","originalPointerMoveEvent_","relayedListenerKey_","relayEvent_","boundHandleTouchMove_","handleTouchMove_","$75ed2fc91ec6cb8478583ef358a9dd4d$var$__extends","emulateClick_","pointerEvent","newEvent","$5185059e8a82c1ae03c4e1ba7159b318$exports","clearTimeout","setTimeout","newEvent1","updateActivePointers_","pointerId","handlePointerUp_","isMouseActionButton_","doc","getOwnerDocument","handlePointerMove_","getRootNode","isMoving_","defaultPrevented","abs","clientX","clientY","$71b981cc74aab5981a718ea8e06b800b$export$9099ad97b570f7c","$eeb9190850355aed8fc5d92349a26bc6$export$55b8074a560bbdf4","$eeb9190850355aed8fc5d92349a26bc6$export$9099ad97b570f7c","PriorityQueue","priorityFunction","keyFunction","priorityFunction_","keyFunction_","elements_","priorities_","queuedElements_","dequeue","elements","priorities","siftUp_","elementKey","enqueue","priority","siftDown_","getCount","getLeftChildIndex_","getRightChildIndex_","getParentIndex_","heapify_","isEmpty","isKeyQueued","isQueued","startIndex","lIndex","rIndex","smallerChildIndex","parentIndex","reprioritize","$070765ef09fbcd82a0016eb3aec41934$export$9099ad97b570f7c","$6bfe069e85349c527971d875462feeac$export$9099ad97b570f7c","TileQueue","tilePriorityFunction","tileChangeCallback","getKey","boundHandleTileChange_","handleTileChange","tileChangeCallback_","tilesLoading_","tilesLoadingKeys_","$6bfe069e85349c527971d875462feeac$var$__extends","added","getTilesLoading","tile","hifi","tileKey","loadMoreTiles","maxTotalLoading","maxNewLoads","newLoads","$6bfe069e85349c527971d875462feeac$export$f7de9366327711a7","tileSourceKey","tileCenter","tileResolution","wantedTiles","deltaX","deltaY","$69bda6b48e87f8072533951cf5cd4b41$export$9099ad97b570f7c","$6fef8cd20559fa789cc7c5f681ed5561$export$9099ad97b570f7c","$61ba71c2b15c8b7e6577526180db0da5$export$33d0cf822839cfa8","onlyCenter","smooth","opt_isMoving","opt_centerShift","viewWidth","viewHeight","shiftX","shiftY","$61ba71c2b15c8b7e6577526180db0da5$export$eaafe0fae18e32b1","$75cf935c4655e9fc21b1ade56ed27175$var$getViewportClampedResolution","maxExtent","viewportSize","showFullExtent","xResolution","yResolution","$75cf935c4655e9fc21b1ade56ed27175$var$getSmoothClampedResolution","$75cf935c4655e9fc21b1ade56ed27175$export$56cba9b4a749f219","opt_smooth","opt_maxExtent","opt_showFullExtent","cappedMaxRes","$4c6a822b604dbfa9a10722399f7335d0$export$e97ec87d2336bd4e","$4c6a822b604dbfa9a10722399f7335d0$export$eaafe0fae18e32b1","$01b4ee2590431d23f431f1e9785f436f$export$9099ad97b570f7c","$3f4f29b0a4be88d8241f933ff6121a33$export$92106241c01aa541","opt_dest","dest","$3f4f29b0a4be88d8241f933ff6121a33$export$d40e2456b1281660","anchorX","anchorY","k","$a17c336463d573a615343832f6e09aa8$var$tmpTransform","$a17c336463d573a615343832f6e09aa8$export$9099ad97b570f7c","Geometry","fn","lastResult","lastArgs","lastThis","called","extentRevision_","simplifiedGeometryMaxMinSquaredTolerance","simplifiedGeometryRevision","simplifyTransformedInternal","revision","squaredTolerance","opt_transform","applyTransform","nextArgs","$a17c336463d573a615343832f6e09aa8$var$__extends","simplifyTransformed","closestPointXY","closestPoint","minSquaredDistance","containsXY","coord","getClosestPoint","opt_closestPoint","NaN","intersectsCoordinate","computeExtent","$8ebfb36ef5532881c5652b708da2c120$export$d1e01ccfd06bf8ee","opt_sy","opt_anchor","simplify","tolerance","getType","intersectsExtent","sourceProj","inCoordinates","outCoordinates","pixelExtent","projectedExtent","$57ce72c0539154dec2abdc81ffcff6df$export$2a65008b73824080","layout","$57ce72c0539154dec2abdc81ffcff6df$export$36912b83e488cd77","simpleGeometry","getFlatCoordinates","getStride","$57ce72c0539154dec2abdc81ffcff6df$export$9099ad97b570f7c","SimpleGeometry","$57ce72c0539154dec2abdc81ffcff6df$var$__extends","getCoordinates","getFirstCoordinate","getLastCoordinate","getLayout","simplifiedGeometry","getSimplifiedGeometryInternal","setFlatCoordinates","setCoordinates","opt_layout","setLayout","nesting","$57ce72c0539154dec2abdc81ffcff6df$var$getLayoutForStride","$3f4f29b0a4be88d8241f933ff6121a33$export$8f869025bba9609b","$3f4f29b0a4be88d8241f933ff6121a33$export$41b0d7466cde8385","$a17c336463d573a615343832f6e09aa8$exports","$020a0553c73896bfe8e0cfb3e7ff136b$var$assignClosest","offset1","offset2","$020a0553c73896bfe8e0cfb3e7ff136b$export$acf7548d1f0e8581","squaredDelta","$020a0553c73896bfe8e0cfb3e7ff136b$export$ba38095f6bb45df2","ends","$020a0553c73896bfe8e0cfb3e7ff136b$export$cc4caddc4c9b8b6f","maxDelta","isRing","opt_tmpPoint","squaredDistance","tmpPoint","$020a0553c73896bfe8e0cfb3e7ff136b$export$3dd3914e22f9012e","$e477329667689b6619ea04e4a51dbccc$export$e175f505890ac90f","$e477329667689b6619ea04e4a51dbccc$export$ab1a51db55485752","coordinatess","opt_ends","$a357f0a07bdcadd773e93ca791a42f7b$export$a5f6a1911260c251","simplifiedFlatCoordinates","simplifiedOffset","markers","stack","last","first","maxSquaredDistance","squaredDistance_1","$a357f0a07bdcadd773e93ca791a42f7b$export$383ea8a1f2974dfb","$a357f0a07bdcadd773e93ca791a42f7b$export$e29de4fdb2175738","$a357f0a07bdcadd773e93ca791a42f7b$export$1df19a1eb5514c2f","simplifiedEnds","$c39683e7fcea5e9dae135d728d60cf52$export$92f32d891164b0ac","opt_coordinates","$c39683e7fcea5e9dae135d728d60cf52$export$d82a8a3167f968d","opt_coordinatess","$c39683e7fcea5e9dae135d728d60cf52$export$db289937da1f5213","endss","opt_coordinatesss","coordinatesss","$7641779008ab07f3e708dabdbbb046eb$export$9bf2059fd656d5e9","twiceArea","$7641779008ab07f3e708dabdbbb046eb$export$99cb92d00fd73c87","$cf0a72c7dbf1c3cfa9edf65c24bc230b$export$9099ad97b570f7c","LinearRing","maxDelta_","maxDeltaRevision_","$cf0a72c7dbf1c3cfa9edf65c24bc230b$var$__extends","getArea","$57ce72c0539154dec2abdc81ffcff6df$exports","$acd1b863667085614d305475fd6c1d27$export$9099ad97b570f7c","Point","$acd1b863667085614d305475fd6c1d27$var$__extends","$e477329667689b6619ea04e4a51dbccc$export$a53e62528b652807","$7311a6a51d57e65f0d3a69bd7a380356$export$f7b55b637f92fd7","$7311a6a51d57e65f0d3a69bd7a380356$export$e2ed757909b25f63","wn","$7311a6a51d57e65f0d3a69bd7a380356$export$51e46a3625992b91","$67787df47ebd352536b767ba5aa6ea83$export$45b4e4437984917d","flatCenters","flatCentersOffset","intersections","rr","pointX","maxSegmentLength","segmentLength","$32ab876027ca0904f46063bee68b73aa$export$26f047a5bfac4b1a","coordinatesExtent","ret","point1","point2","$419a691625de72e89acadcc033e1165f$export$40f3d9558cf6e846","start","intersects","startRel","endRel","startX","startY","endX","endY","slope","$8ebfb36ef5532881c5652b708da2c120$export$525a75abb91115e3","$32ab876027ca0904f46063bee68b73aa$export$717c2c7c46a5bf3d","$32ab876027ca0904f46063bee68b73aa$export$f14bd9270666b480","$221ffa684d4ba252080508824e602b78$export$c77fe031a1447f2e","$52f5ef13e882c7db8132623a2b51ee49$export$add61ad31d0a68b4","edge","$52f5ef13e882c7db8132623a2b51ee49$export$586adaf930d9fdb6","opt_right","right","isClockwise","$52f5ef13e882c7db8132623a2b51ee49$export$325e57738fd8b321","$bffbcd35af658c4477627697774de1c2$var$Polygon","Polygon","ends_","flatInteriorPointRevision_","flatInteriorPoint_","orientedRevision_","orientedFlatCoordinates_","$bffbcd35af658c4477627697774de1c2$var$__extends","appendLinearRing","linearRing","polygon","getOrientedFlatCoordinates","getEnds","getFlatInteriorPoint","flatCenter","getInteriorPoint","$acd1b863667085614d305475fd6c1d27$exports","getLinearRingCount","getLinearRing","$cf0a72c7dbf1c3cfa9edf65c24bc230b$exports","getLinearRings","linearRings","$bffbcd35af658c4477627697774de1c2$export$9099ad97b570f7c","$bffbcd35af658c4477627697774de1c2$export$bbb8e839e9c5bda9","opt_n","opt_sphereRadius","$bffbcd35af658c4477627697774de1c2$export$b50d271c6e9656cd","$bffbcd35af658c4477627697774de1c2$export$186fa890234c5366","circle","opt_sides","opt_angle","sides","getCenter","arrayLength","$bffbcd35af658c4477627697774de1c2$export$5d1798f0e1df079","startAngle","$19fadbefe1b7e34cc76223b5c3e441cc$var$animationCallback","returnValue","$19fadbefe1b7e34cc76223b5c3e441cc$export$535fae5a159fbda4","smoothExtentConstraint","constrainOnlyCenter","multiWorld","$19fadbefe1b7e34cc76223b5c3e441cc$export$8b6914b45b83f21f","resolutionConstraint","zoomFactor","smoothResolutionConstraint","projExtent","resolutions","constrainResolution","capped","z","$75cf935c4655e9fc21b1ade56ed27175$export$d1041fa75d07f305","defaultMaxResolution","defaultMinResolution","defaultMaxZoom","power","opt_minResolution","minZoomLevel","cappedZoomLevel","zoomLevel","$75cf935c4655e9fc21b1ade56ed27175$export$7690ad4e930f454b","constraint","$19fadbefe1b7e34cc76223b5c3e441cc$export$9665b691bc2d5ca0","theta","opt_tolerance","enableRotation","constrainRotation","$19fadbefe1b7e34cc76223b5c3e441cc$export$5d87c27d7d9f380e","animation","sourceCenter","targetCenter","sourceResolution","targetResolution","sourceRotation","targetRotation","$19fadbefe1b7e34cc76223b5c3e441cc$var$calculateCenterOn","rotX","rotY","$19fadbefe1b7e34cc76223b5c3e441cc$export$9099ad97b570f7c","View","hints_","animations_","updateAnimationKey_","projection_","viewportSize_","targetCenter_","targetResolution_","targetRotation_","cancelAnchor_","applyOptions_","$19fadbefe1b7e34cc76223b5c3e441cc$var$__extends","resolutionConstraintInfo","maxResolution_","minResolution_","zoomFactor_","resolutions_","minZoom_","centerConstraint","rotationConstraint","constraints_","setCenterInternal","setResolution","options_","getUpdatedOptions_","newOptions","getCenterInternal","var_args","isDef","resolveConstraints","args","getProjection","animateInternal","animationCount","Date","now","series","complete","getResolutionForZoom","setHint","updateAnimations_","getInteracting","cancelAnimationFrame","more","seriesComplete","elapsed","fraction","progress","getViewportSize_","constrainedResolution","calculateCenterZoom","applyTargetState_","constrainedRotation","calculateCenterRotate","filter","Boolean","requestAnimationFrame","currentCenter","currentResolution","opt_rotation","setViewportSize","getConstraints","getConstrainResolution","getHints","opt_hints","calculateExtent","calculateExtentInternal","getZoomForResolution","setConstrainResolution","enabled","getResolutions","getResolutionForExtent","getResolutionForExtentInternal","getResolutionForValueFunction","opt_power","getConstrainedResolution","getValueForResolutionFunction","logPower","getViewportSizeMinusPadding_","reducedSize","nearest","baseLevel","fit","geometryOrExtent","$bffbcd35af658c4477627697774de1c2$exports","fromExtent","userProjection","fitInternal","coords","minRotX","minRotY","maxRotX","maxRotY","centerRotX","centerRotY","centerX","centerY","getConstrainedCenter","centerOn","centerOnInternal","calculateCenterShift","centerShift","shiftedCenter","adjustCenter","deltaCoordinates","setCenter","adjustCenterInternal","adjustResolution","adjustResolutionInternal","isMoving","newResolution","adjustZoom","adjustRotation","adjustRotationInternal","newRotation","hint","opt_doNotCancelAnims","opt_forceMoving","newCenter","opt_duration","opt_resolutionDirection","beginInteraction","endInteraction","endInteractionInternal","opt_targetResolution","targetZoom","opt_direction","targetRes","$b198bbb8a7fca092de94dd3a772c1343$export$9099ad97b570f7c","PluggableMap","optionsInternal","keyboardEventTarget","interactions","overlays","layerGroup","$d66bdf9af75d90254b022f9a4b768a43$exports","$19fadbefe1b7e34cc76223b5c3e441cc$exports","$b198bbb8a7fca092de94dd3a772c1343$var$createOptionsInternal","boundHandleBrowserEvent_","handleBrowserEvent","maxTilesLoading_","maxTilesLoading","postRenderTimeoutHandle_","animationDelayKey_","animationDelay_","renderFrame_","coordinateToPixelTransform_","pixelToCoordinateTransform_","frameIndex_","frameState_","previousExtent_","viewPropertyListenerKey_","viewChangeListenerKey_","layerGroupPropertyListenerKeys_","viewport_","overflow","overlayContainer_","overlayContainerStopEvent_","mapBrowserEventHandler_","keyboardEventTarget_","keyHandlerKeys_","overlays_","overlayIdIndex_","handleResize_","postRenderFunctions_","tileQueue_","$6bfe069e85349c527971d875462feeac$exports","getTilePriority","handleTileChange_","handleLayerGroupChanged_","handleViewChanged_","handleSizeChanged_","handleTargetChanged_","control","interaction","addOverlayInternal_","$b198bbb8a7fca092de94dd3a772c1343$var$__extends","addControl","getControls","addInteraction","getInteractions","addLayer","getLayerGroup","addOverlay","overlay","getOverlays","forEachFeatureAtPixel","getCoordinateFromPixelInternal","getFeaturesAtPixel","features","hasFeatureAtPixel","getEventCoordinate","getEventCoordinateInternal","viewportPosition","getBoundingClientRect","eventPosition","changedTouches","top","getTarget","getTargetElement","getOverlayById","getLoading","loading","getPixelFromCoordinate","viewCoordinate","getPixelFromCoordinateInternal","getOverlayContainer","ownerDocument","browserEvent","mapBrowserEvent","handleMapBrowserEvent","rootNode","elementFromPoint","documentElement","interactionsArray","getActive","handlePostRender","tileQueue","hints","viewHints","lowOnFrameBudget","time","targetElement","$75ed2fc91ec6cb8478583ef358a9dd4d$exports","updateSize","handleViewPropertyChanged_","updateViewportSize_","isRendered","renderSync","handleFontsChanged","removeControl","removeInteraction","removeLayer","removeOverlay","previousFrameState","$8556eff40cf4f1624cd78ff7ea054c5b$export$c563c2b7121f8771","declutterTree","usedTiles","setLayerGroup","setView","computedStyle","$c147d956996cb96e879ea56bdc9c5d5d$export$9099ad97b570f7c","$1ad0cf5090e3852174414bfc8cc27b9e$export$63568b31cb17dd4d","$1ad0cf5090e3852174414bfc8cc27b9e$export$d2c07614bfd6a817","$1ad0cf5090e3852174414bfc8cc27b9e$export$9099ad97b570f7c","Interaction","setActive","$1ad0cf5090e3852174414bfc8cc27b9e$var$__extends","active","$4eeedd039b7e6d5b8277b175715f9541$export$9099ad97b570f7c","DoubleClickZoom","delta_","$4eeedd039b7e6d5b8277b175715f9541$var$__extends","stopEvent","shiftKey","$1ad0cf5090e3852174414bfc8cc27b9e$exports","zoomByDelta","$0714aed143b912743afff175db44c1dc$export$e61edea4dfe4ed9b","$0714aed143b912743afff175db44c1dc$export$9099ad97b570f7c","PointerInteraction","handleDownEvent","handleDragEvent","handleMoveEvent","handleUpEvent","stopDown","handlingDownUpSequence","trackedPointers_","targetPointers","$0714aed143b912743afff175db44c1dc$var$__extends","getPointerCount","updateTrackedPointers_","handledUp","handled","$0714aed143b912743afff175db44c1dc$var$isPointerDraggingEvent","$054715504eaffdc825d0a6ada99ec596$export$8dbdea330bbd6b3c","conditions","pass","$054715504eaffdc825d0a6ada99ec596$export$7576515282e06e7a","altKey","metaKey","ctrlKey","$054715504eaffdc825d0a6ada99ec596$export$584a07df7b145c47","hasAttribute","activeElement","$054715504eaffdc825d0a6ada99ec596$export$363947888fb85da6","$054715504eaffdc825d0a6ada99ec596$export$a8612972eacfc116","$054715504eaffdc825d0a6ada99ec596$export$9f5e19851eeaf2c1","$054715504eaffdc825d0a6ada99ec596$export$1734dfcac3c09b2f","$054715504eaffdc825d0a6ada99ec596$export$59c8376875f673f8","$054715504eaffdc825d0a6ada99ec596$export$5bbcce8021828272","tagName","$054715504eaffdc825d0a6ada99ec596$export$d31d3f3aa38542a8","pointerType","$054715504eaffdc825d0a6ada99ec596$export$45cd27c0322d6513","isPrimary","$959ec1b544453a9fa4f0e9221c3bb0b0$export$9099ad97b570f7c","DragPan","kinetic_","kinetic","lastCentroid","lastPointersCount_","panning_","condition","condition_","onFocusOnly","noKinetic_","$959ec1b544453a9fa4f0e9221c3bb0b0$var$__extends","centroid","$0714aed143b912743afff175db44c1dc$exports","update","getDistance","centerpx","$719e5208cd50905e41bacbcae2219883$export$9099ad97b570f7c","DragRotate","lastAngle_","$719e5208cd50905e41bacbcae2219883$var$__extends","$d0055a036577a61fd8306330947568c7$export$9099ad97b570f7c","RenderBox","startPixel_","endPixel_","$d0055a036577a61fd8306330947568c7$var$__extends","render_","startPixel","endPixel","px","setPixels","createOrUpdateGeometry","$275b26378704892d776581791f32dc0e$var$DragBoxEventType","$275b26378704892d776581791f32dc0e$export$4d9b552836937ca2","DragBoxEvent","$275b26378704892d776581791f32dc0e$var$__extends","$275b26378704892d776581791f32dc0e$export$9099ad97b570f7c","DragBox","box_","$d0055a036577a61fd8306330947568c7$exports","minArea_","minArea","onBoxEnd","boxEndCondition_","boxEndCondition","defaultBoxEndCondition","completeBox","$b5cd6c68e27395a36aa4c8d3c5395250$export$9099ad97b570f7c","DragZoom","out_","out","$b5cd6c68e27395a36aa4c8d3c5395250$var$__extends","mapExtent","boxPixelExtent","$8ebfb36ef5532881c5652b708da2c120$export$9f54817615211741","$275b26378704892d776581791f32dc0e$exports","$8d5ac6bc9707ee873610cb367c0dab7f$export$9099ad97b570f7c","$bcd9d2d6fd38b8643ae7b7b6fd22a911$export$9099ad97b570f7c","KeyboardPan","defaultCondition_","pixelDelta_","pixelDelta","$bcd9d2d6fd38b8643ae7b7b6fd22a911$var$__extends","keyEvent","keyCode","mapUnitsDelta","pan","$55ea853e77e2fe25fa1a8793cb31a3bf$export$9099ad97b570f7c","KeyboardZoom","$55ea853e77e2fe25fa1a8793cb31a3bf$var$__extends","charCode","charCodeAt","$4f2c4d65e25c75c4fbc5129660f72747$export$9099ad97b570f7c","Kinetic","decay","minVelocity","delay","decay_","minVelocity_","delay_","initialVelocity_","lastIndex","firstIndex","$f7a99b9e7b1a72242a3eb408b28d3563$export$9658e13a40f6ce34","TRACKPAD","WHEEL","$f7a99b9e7b1a72242a3eb408b28d3563$export$9099ad97b570f7c","MouseWheelZoom","totalDelta_","lastDelta_","timeout_","timeout","useAnchor_","useAnchor","constrainResolution_","lastAnchor_","startTime_","timeoutId_","mode_","trackpadEventGap_","trackpadTimeoutId_","deltaPerZoom_","$f7a99b9e7b1a72242a3eb408b28d3563$var$__extends","endInteraction_","wheelEvent","deltaMode","WheelEvent","DOM_DELTA_PIXEL","DOM_DELTA_LINE","timeLeft","handleWheelZoom_","setMouseAnchor","$74b3a0ab43d5d3c47ed1a15cedc99f6a$export$9099ad97b570f7c","PinchRotate","pointerOptions","rotating_","rotationDelta_","threshold_","threshold","$74b3a0ab43d5d3c47ed1a15cedc99f6a$var$__extends","rotationDelta","touch0","touch1","$601b81cfcc535d77832cc96f04e942a1$export$9099ad97b570f7c","PinchZoom","lastDistance_","lastScaleDelta_","$601b81cfcc535d77832cc96f04e942a1$var$__extends","scaleDelta","$976448907138da16f7612e32ecc55ac7$export$9099ad97b570f7c","Map1","altShiftDragRotate","$719e5208cd50905e41bacbcae2219883$exports","doubleClickZoom","$4eeedd039b7e6d5b8277b175715f9541$exports","zoomDelta","zoomDuration","dragPan","$959ec1b544453a9fa4f0e9221c3bb0b0$exports","pinchRotate","$74b3a0ab43d5d3c47ed1a15cedc99f6a$exports","pinchZoom","$601b81cfcc535d77832cc96f04e942a1$exports","keyboard","$bcd9d2d6fd38b8643ae7b7b6fd22a911$exports","$55ea853e77e2fe25fa1a8793cb31a3bf$exports","mouseWheelZoom","$f7a99b9e7b1a72242a3eb408b28d3563$exports","shiftDragZoom","$b5cd6c68e27395a36aa4c8d3c5395250$exports","$ad51cb5d42c2f2a2874b19907e742966$export$b403fbac94228e09","$976448907138da16f7612e32ecc55ac7$var$__extends","$2ae21f590be041e7827bf48426c0766a$exports","$b198bbb8a7fca092de94dd3a772c1343$exports","$528cb875889b595e5e9ea3d22048d8af$export$9099ad97b570f7c","$e57902a7301793e401678bb29ec1b554$var$Property","$e57902a7301793e401678bb29ec1b554$export$9099ad97b570f7c","Overlay","insertFirst","autoPan","autoPanAnimation","autoPanMargin","rendered","transform_","mapPostrenderListenerKey","handleElementChanged","handleMapChanged","handleOffsetChanged","handlePositionChanged","handlePositioningChanged","setElement","setOffset","setPositioning","positioning","setPosition","$e57902a7301793e401678bb29ec1b554$var$__extends","getElement","getOffset","getPosition","getPositioning","updatePixelPosition","performAutoPan","panIntoView","opt_panIntoViewOptions","mapRect","getRect","overlayRect","panIntoViewOptions","myMargin","offsetLeft","offsetRight","offsetTop","offsetBottom","centerPx","newCenterPx","panOptions","box","pageXOffset","pageYOffset","mapSize","updateRenderedPosition","posX","posY","msTransform","getOptions","$013ee184ddda363412ada1e10e95871e$export$9099ad97b570f7c","$ab70eb0a0a56b112261264db1ea7acab$export$9099ad97b570f7c","BaseTileLayer","preload","useInterimTilesOnError","setPreload","setUseInterimTilesOnError","$ab70eb0a0a56b112261264db1ea7acab$var$__extends","getPreload","getUseInterimTilesOnError","$ae15ed96a99c1303ea67938747c94fca$export$9099ad97b570f7c","LayerRenderer","boundHandleImageChange_","handleImageChange_","layer_","declutterExecutorGroup","$ae15ed96a99c1303ea67938747c94fca$var$__extends","loadedTileCallback","tiles","tileCoord","createLoadedTileFinder","tileRange","forEachLoadedTile","getLayer","renderIfReadyAndVisible","loadImage","$ac230d10056414a40eb774bd091234f1$export$9099ad97b570f7c","CanvasLayerRenderer","renderedResolution","tempTransform","pixelTransform","containerReused","$ac230d10056414a40eb774bd091234f1$var$__extends","useContainer","layerClassName","firstElementChild","HTMLCanvasElement","transformOrigin","clip","halfWidth","halfHeight","topLeft","topRight","bottomRight","bottomLeft","moveTo","clipUnrotated","inverted","dispatchRenderEvent_","preRender","postRender","getRenderTransform","renderPixel","layerExtent","newCanvas","newContext","clearRect","err","Uint8Array","$ae15ed96a99c1303ea67938747c94fca$exports","$6a958d3d10a45fbc13d601def6cb4731$var$TileRange","TileRange","containsTileRange","getHeight","$6a958d3d10a45fbc13d601def6cb4731$export$ea8082d0226d35a5","$6a958d3d10a45fbc13d601def6cb4731$export$9099ad97b570f7c","$21101e8f6691f861098a74ca233ba3e1$var$CanvasTileLayerRenderer","CanvasTileLayerRenderer","tileLayer","extentChanged","renderedExtent_","renderedPixelRatio","renderedProjection","renderedRevision","renderedTiles","newTiles_","tmpExtent","tmpTileRange_","$21101e8f6691f861098a74ca233ba3e1$var$__extends","isDrawableTile","tileState","getTile","setState","getInterimTile","viewResolution","viewCenter","tileSource","sourceRevision","getTileGridForProjection","getZForResolution","zDirection","tilePixelRatio","getTilePixelRatio","canvasExtent","getTileRangeForExtentAndZ","tilesToDrawByZ","findLoadedTiles","tmpTileRange","uid","inTransition","getAlpha","childTileRange","getTileCoordChildTileRange","covered","forEachTileCoordParentTileRange","canvasScale","canvasTransform","getContextOptions","clips","clipZs","currentClip","zs","getOpaque","reverse","currentZ","currentTilePixelSize","getTilePixelSize","currentScale","dx_1","dy_1","originTileCoord","getTileCoordForCoordAndZ","originTileExtent","getTileCoordExtent","origin_1","tileGutter","getGutterForProjection","tilesToDraw","tileCoordKey","floatX","nextX","floatY","nextY","transition","i_1","drawTileImage","updateUsedTiles","manageTilePyramid","scheduleExpireCache","gutter","getTileImage","tileAlpha","alpha","alphaChanged","endTransition","postRenderFunction","tileSource1","frameState1","expireCache","opt_tileCallback","tileCount","getTileCoordCenter","useTile","updateCacheSize","$ac230d10056414a40eb774bd091234f1$exports","$21101e8f6691f861098a74ca233ba3e1$export$9099ad97b570f7c","$7f639b92eb9591e7aded56644548f656$export$9099ad97b570f7c","TileLayer","$7f639b92eb9591e7aded56644548f656$var$__extends","$21101e8f6691f861098a74ca233ba3e1$exports","$ab70eb0a0a56b112261264db1ea7acab$exports","$dffde8f1acde674bc74a24601c2788a7$export$28342ec567be40be","$dffde8f1acde674bc74a24601c2788a7$export$5f986e3acaff8610","imageSmoothingEnabled","msImageSmoothingEnabled","$6ea2e09c0ee686e4fcf344e90f929221$export$9099ad97b570f7c","Tile","interimTile","transition_","transitionStarts_","$6ea2e09c0ee686e4fcf344e90f929221$var$__extends","release","refreshInterimChain","getTileCoord","$69031f3b45b1bb2d223c45e6bbe47b36$export$9099ad97b570f7c","ImageTile","tileLoadFunction","tileLoadFunction_","$69031f3b45b1bb2d223c45e6bbe47b36$var$__extends","naturalWidth","naturalHeight","$6ea2e09c0ee686e4fcf344e90f929221$exports","$7e4c33869bbc09ad771e58efcd7791e2$var$brokenDiagonalRendering_","$3a0ea260bd0161734cb5e603b9086c9d$export$9099ad97b570f7c","Triangulation","targetProj","targetExtent","maxSourceExtent","errorThreshold","opt_destinationResolution","sourceProj_","targetProj_","transformInvCache","transformInv","transformInv_","maxSourceExtent_","errorThresholdSquared_","triangles_","wrapsXInSource_","canWrapXInSource_","sourceWorldWidth_","targetWorldWidth_","destinationTopLeft","destinationTopRight","destinationBottomRight","destinationBottomLeft","sourceTopLeft","sourceTopRight","sourceBottomRight","sourceBottomLeft","maxSubdivision","addQuad_","leftBound_1","triangle","newTriangle","addTriangle_","aSrc","bSrc","cSrc","dSrc","sourceQuadExtent","sourceCoverageX","sourceWorldWidth","wrapsX","needsSubdivision","isFinite","isNotFinite","centerSrc","bc","bcSrc","da","daSrc","ab","abSrc","cd","cdSrc","calculateSourceExtent","getTriangles","$7e4c33869bbc09ad771e58efcd7791e2$var$drawTestTriangle","u1","v1","u2","v2","$7e4c33869bbc09ad771e58efcd7791e2$var$verifyBrokenDiagonalRendering","$7e4c33869bbc09ad771e58efcd7791e2$export$fbbff54b3c32db8d","targetMetersPerUnit","sourceMetersPerUnit","sourceExtent","compensationFactor","$7e4c33869bbc09ad771e58efcd7791e2$export$792a797b69be0d58","triangulation","sources","opt_renderEdges","opt_contextOptions","pixelRound","sourceDataExtent","canvasWidthInUnits","canvasHeightInUnits","stitchContext","stitchScale","xPos","yPos","srcWidth","srcHeight","targetTopLeft","u0","v0","sourceNumericalShiftX","sourceNumericalShiftY","affineCoefs","maxRow","maxEl","absValue","coef","$916dab65013919ad0345478f9a9f4e0f$export$27dc5719ceda6735","$7e4c33869bbc09ad771e58efcd7791e2$var$isBrokenDiagonalRendering","ud","vd","step","$97e37be8733b1927a1ed959b854a8d18$export$9099ad97b570f7c","ReprojTile","sourceTileGrid","targetTileGrid","wrappedTileCoord","getTileFunction","opt_errorThreshold","renderEdges_","contextOptions_","gutter_","sourceTileGrid_","targetTileGrid_","wrappedTileCoord_","sourceTiles_","sourcesListenerKeys_","sourceZ_","maxTargetExtent","limitedTargetExtent","sourceProjExtent","$7e4c33869bbc09ad771e58efcd7791e2$export$ed73ddd0371d87e2","errorThresholdInPixels","triangulation_","sourceRange","srcX","srcY","$97e37be8733b1927a1ed959b854a8d18$var$__extends","reproject_","getTileSize","leftToLoad_1","sourceListenKey_1","state1","unlistenSources_","$101ae72fedfe330e8897d118e958a8b6$export$9099ad97b570f7c","LRUCache","opt_highWaterMark","highWaterMark","count_","entries_","oldest_","newest_","containsKey","entry","value_","key_","newer","older","getValues","peekLast","peekLastKey","peekFirstKey","$c98d704946f2a3a0e1335bd43bccb465$export$ea8082d0226d35a5","opt_tileCoord","$c98d704946f2a3a0e1335bd43bccb465$export$1039fb0288fd71e3","$c98d704946f2a3a0e1335bd43bccb465$export$a0f0ccbe5bbc0789","$c98d704946f2a3a0e1335bd43bccb465$export$4639c7f2947f4458","$8328c42c04c9adada69111ec662476d9$export$9099ad97b570f7c","TileCache","$8328c42c04c9adada69111ec662476d9$var$__extends","pruneExceptNewestZ","$c98d704946f2a3a0e1335bd43bccb465$export$5208a752d34424e5","$6fb7cf65abcfc8d879372ec2dca0d0b8$export$9099ad97b570f7c","$6a9611a0560ac769e67fadc6cfef9a2c$var$adaptAttributions","attributionLike","$6a9611a0560ac769e67fadc6cfef9a2c$export$9099ad97b570f7c","Source","attributions_","attributionsCollapsible_","attributionsCollapsible","wrapX_","wrapX","$6a9611a0560ac769e67fadc6cfef9a2c$var$__extends","refresh","setAttributions","$0f9feaa19e1db86e91525f400c1bbfa1$var$tmpTileCoord","$0f9feaa19e1db86e91525f400c1bbfa1$export$9099ad97b570f7c","TileGrid","opt_strict","compare","every","currentVal","res","origins","origin","origins_","tileSizes_","tileSizes","tileSize_","tileSize","fullTileRanges_","tmpSize_","sizes","restrictedTileRange","calculateTileRanges_","forEachTileCoord","opt_tileRange","tileCoordExtent","getTileRangeExtent","getTileCoordForXYAndZ_","getTileCoordForCoordAndResolution","getTileCoordForXYAndResolution_","reverseIntersectionPolicy","adjustX","adjustY","xFromOrigin","yFromOrigin","tileCoordX","tileCoordY","getTileCoordResolution","getFullTileRange","fullTileRanges","$0b7f50deff6bfc90c8b239d5ceca7010$export$115502f69f929231","opt_maxZoom","opt_tileSize","opt_corner","$0b7f50deff6bfc90c8b239d5ceca7010$var$resolutionsFromExtent","$0b7f50deff6bfc90c8b239d5ceca7010$export$57c49ef1657592d4","$0b7f50deff6bfc90c8b239d5ceca7010$export$9666e825b22d806d","$0b7f50deff6bfc90c8b239d5ceca7010$export$6dfef52f91d4f582","opt_maxResolution","half","$cde35ab3df9629f8ffd26ea2f187b41e$var$TileSource","TileSource","opaque_","opaque","tilePixelRatio_","tileCache","$8328c42c04c9adada69111ec662476d9$exports","tmpSize","tileOptions","$cde35ab3df9629f8ffd26ea2f187b41e$var$__extends","getTileCacheForProjection","loaded","setKey","getTileGrid","getTileCoordForTileUrlFunction","$0b7f50deff6bfc90c8b239d5ceca7010$export$5a0d9577a24f3c5b","$c98d704946f2a3a0e1335bd43bccb465$export$b46b80619528d4e5","$6a9611a0560ac769e67fadc6cfef9a2c$exports","$cde35ab3df9629f8ffd26ea2f187b41e$export$8434c8db61edbf9d","TileSourceEvent","$cde35ab3df9629f8ffd26ea2f187b41e$export$9099ad97b570f7c","$f3b33fdefe65058178a4b532c7b3f14b$export$ee162149bf998c0f","template","zRegEx","xRegEx","yRegEx","dashYRegEx","range","$f3b33fdefe65058178a4b532c7b3f14b$export$2d2faeb2e9d58b93","templates","tileUrlFunctions","$f3b33fdefe65058178a4b532c7b3f14b$export$c6a04e0c49b28953","$671acdd0ca89710db49a7e8e41335e8e$export$9099ad97b570f7c","UrlTile","generateTileUrlFunction_","tileUrlFunction","urls","setUrls","url","setUrl","tileLoadingKeys_","$671acdd0ca89710db49a7e8e41335e8e$var$__extends","getTileLoadFunction","getTileUrlFunction","getPrototypeOf","getUrls","$cde35ab3df9629f8ffd26ea2f187b41e$exports","setTileLoadFunction","setTileUrlFunction","startCharCode","stopCharCode","fromCharCode","stop_1","$f3b33fdefe65058178a4b532c7b3f14b$export$47abe479fba0e55d","$f1c529d0542d6a8d6fa77a64fa516101$var$defaultTileLoadFunction","imageTile","$f1c529d0542d6a8d6fa77a64fa516101$export$9099ad97b570f7c","TileImage","tileClass","$69031f3b45b1bb2d223c45e6bbe47b36$exports","tileCacheForProjection","tileGridForProjection","reprojectionErrorThreshold_","reprojectionErrorThreshold","imageSmoothing","renderReprojectionEdges_","$f1c529d0542d6a8d6fa77a64fa516101$var$__extends","usedTileCache","getGutter","JSON","stringify","thisProj","projKey","createTile_","urlTileCoord","tileUrl","newTile","$97e37be8733b1927a1ed959b854a8d18$exports","z1","pixelRatio1","getTileInternal","setRenderReprojectionEdges","setTileGridForProjection","tilegrid","proj","$671acdd0ca89710db49a7e8e41335e8e$exports","$918982e6323673f67eda8326df5fb61a$export$9099ad97b570f7c","$c965b52f2e69fc1d4b0c393ef9deb65b$export$8626442242d77803","uri","params","keyParams","encodeURIComponent","qs","$00e77240b5127dee51e8cd811345686e$export$9099ad97b570f7c","TileWMS","transparent","params_","v13_","serverType_","serverType","hidpi_","hidpi","tmpExtent_","updateV13_","getKeyForParams_","$00e77240b5127dee51e8cd811345686e$var$__extends","getFeatureInfoUrl","projectionObj","sourceProjectionObj","tileExtent","baseParams","getRequestUrl_","getLegendUrl","LAYERS","getParams","bbox","updateParams","version","s1","s2","n1","n2","$9d44b4ae0ee335a0d47ee14b2c70e04c$export$906129c39da8a5c1","$f1c529d0542d6a8d6fa77a64fa516101$exports","$a51010926fccd7fa7fa549e12811b655$exports","t1","t2","r1","e1","a1","h1","o","u","p","_maxEntries","_minEntries","leaf","m2","h2","o1","all","_all","search","toBBox","o2","collides","a2","insert","_build","_splitRoot","r2","_insert","i2","r3","a3","h3","o3","l1","f1","_condense","compareMinX","compareMinY","toJSON","fromJSON","e2","f2","m1","_chooseSubtree","m3","c3","e3","a4","_split","_adjustParentBBoxes","_chooseSplitAxis","h4","_chooseSplitIndex","o4","l2","u3","p1","d1","v","M","_allDistMargin","define","amd","RBush","$ceed79ad4f0d8f0ebaf810c3cca30983$var$Property","$ceed79ad4f0d8f0ebaf810c3cca30983$export$9099ad97b570f7c","BaseVectorLayer","renderBuffer","updateWhileAnimating","updateWhileInteracting","declutter_","declutter","renderBuffer_","updateWhileAnimating_","updateWhileInteracting_","$ceed79ad4f0d8f0ebaf810c3cca30983$var$__extends","getDeclutter","getRenderBuffer","getRenderOrder","getUpdateWhileAnimating","getUpdateWhileInteracting","$parcel$interopDefault","setRenderOrder","renderOrder","styleFunction","$b550892c9c7d6707a4415bf7976deb12$export$4aaa4bacaec09e94","$75febe525c6e0d71892cea5e044a142c$var$Instruction","BEGIN_GEOMETRY","BEGIN_PATH","CIRCLE","CLOSE_PATH","CUSTOM","DRAW_CHARS","DRAW_IMAGE","END_GEOMETRY","FILL","MOVE_TO_LINE_TO","SET_FILL_STYLE","SET_STROKE_STYLE","STROKE","$75febe525c6e0d71892cea5e044a142c$export$c649c04369bd3370","$75febe525c6e0d71892cea5e044a142c$export$2513c58bc344fc5c","$75febe525c6e0d71892cea5e044a142c$export$84e3c67fd41b07f5","$75febe525c6e0d71892cea5e044a142c$export$6cd4b1e0c0e7240c","$75febe525c6e0d71892cea5e044a142c$export$9099ad97b570f7c","$98c4b84222a5e84ec508cd638c4e0b8c$export$9099ad97b570f7c","VectorContext","drawCustom","drawGeometry","drawCircle","circleGeometry","drawFeature","drawGeometryCollection","geometryCollectionGeometry","drawLineString","lineStringGeometry","drawMultiLineString","multiLineStringGeometry","drawMultiPoint","multiPointGeometry","drawMultiPolygon","multiPolygonGeometry","drawPoint","pointGeometry","drawPolygon","polygonGeometry","drawText","setFillStrokeStyle","setImageStyle","imageStyle","opt_declutterImageWithText","setTextStyle","textStyle","$ca67e4c506ae561bc3174e981b55d257$export$9099ad97b570f7c","CanvasBuilder","maxLineWidth","beginGeometryInstruction1_","beginGeometryInstruction2_","bufferedMaxExtent_","instructions","tmpCoordinate_","hitDetectionInstructions","$ca67e4c506ae561bc3174e981b55d257$var$__extends","applyPixelRatio","dashArray","dash","appendFlatPointCoordinates","getBufferedMaxExtent","myEnd","appendFlatLineCoordinates","closed","skipFirst","lastRel","nextRel","lastXCoord","lastYCoord","nextCoord","skipped","drawCustomCoordinates_","builderEnds","builderEnd","beginGeometry","builderEndss","builderBegin","getEndss","myEnds","endGeometry","finish","reverseHitDetectionInstructions","instruction","fillStyleColor","strokeStyleColor","strokeStyleLineCap","strokeStyleLineDash","strokeStyleLineDashOffset","strokeStyleLineJoin","strokeStyleWidth","strokeStyleMiterLimit","createFill","fillInstruction","applyStroke","createStroke","updateFillStyle","currentFillStyle","updateStrokeStyle","currentStrokeStyle","currentLineCap","currentLineDash","currentLineDashOffset","currentLineJoin","currentLineWidth","currentMiterLimit","endGeometryInstruction","$072d5e6cee1f9ae87cd55eb588566cc6$export$9099ad97b570f7c","CanvasImageBuilder","imagePixelRatio_","anchorX_","anchorY_","height_","originX_","originY_","declutterImageWithText_","$072d5e6cee1f9ae87cd55eb588566cc6$var$__extends","myBegin","opt_sharedData","hitDetectionImage","$ca67e4c506ae561bc3174e981b55d257$exports","$28ceeb2640c662153e0cc1bb27e7eea9$export$9099ad97b570f7c","CanvasLineStringBuilder","$28ceeb2640c662153e0cc1bb27e7eea9$var$__extends","drawFlatCoordinates_","moveToLineToInstruction","lastStroke","$f5fec2e7653cdbd2c7958b8312f0d7d6$export$9099ad97b570f7c","CanvasPolygonBuilder","$f5fec2e7653cdbd2c7958b8312f0d7d6$var$__extends","drawFlatCoordinatess_","numEnds","setFillStrokeStyles_","circleInstruction","$efe444a788e44e26b0fd0d03352a7cb8$export$9099ad97b570f7c","$f19e98a3c9584b88eb9c26a752a19276$export$e8c34bbbade92a3a","maxAngle","m12","m23","x12","y12","x23","y23","chunkStart","chunkEnd","chunkM","acos","$7e7051822986fcb02ea0e43ac0707b32$export$3964e67694391753","$7e7051822986fcb02ea0e43ac0707b32$export$9099ad97b570f7c","CanvasTextBuilder","labels_","textOffsetX_","textOffsetY_","textRotateWithView_","textRotation_","textFillState_","fillStates","textStrokeState_","strokeStates","textState_","textStates","textKey_","fillKey_","strokeKey_","$7e7051822986fcb02ea0e43ac0707b32$var$__extends","fillState","strokeState","textState","geometryType","placement","geometryWidths","getFlatMidpoint","getFlatMidpoints","interiorPoints","getFlatInteriorPoints","saveTextStates_","backgroundFill","backgroundStroke","p0","p2","p3","pixelRatio_1","textAlign","flatOffset","flatEnd","oo","drawChars_","strokeKey","textKey","textBaseline","fillKey","baseline","textFillStyle","textStrokeStyle","getFont","textScale","getOverflow","getMaxAngle","getPlacement","getTextAlign","getTextBaseline","getBackgroundFill","getBackgroundStroke","getPadding","textOffsetX","getOffsetX","textOffsetY","getOffsetY","textRotateWithView","textRotation","$4f54cdaa0352e7689a6e30aa9d8207ec$var$BATCH_CONSTRUCTORS","$f5fec2e7653cdbd2c7958b8312f0d7d6$exports","$072d5e6cee1f9ae87cd55eb588566cc6$exports","$28ceeb2640c662153e0cc1bb27e7eea9$exports","$7e7051822986fcb02ea0e43ac0707b32$exports","$4f54cdaa0352e7689a6e30aa9d8207ec$export$9099ad97b570f7c","BuilderGroup","tolerance_","maxExtent_","resolution_","buildersByZIndex_","builderInstructions","zKey","builders","builderKey","builderInstruction","getBuilder","builderType","zIndexKey","replays","replay","Constructor","$2a2c9e207ab3a32ae55e264c8b11e252$export$9099ad97b570f7c","$56c23dc34f9f14c7874ab5d8b63c5fb3$export$1829060502283fb8","startM","measureAndCacheTextWidth","segmentM","advance","interpolate","beginX","beginY","startOffset","startLength","endM","flat","previousAngle","singleSegment","previousAngle_1","iStart","charLength","chars","substring","$c028848ec55b72b61f5eaf0ec6396be2$export$7326ac1b36a49776","$6cf1557e9efeeb4d32c6b7acaeb9c268$var$tmpExtent","$6cf1557e9efeeb4d32c6b7acaeb9c268$var$p1","$6cf1557e9efeeb4d32c6b7acaeb9c268$var$p2","$6cf1557e9efeeb4d32c6b7acaeb9c268$var$p3","$6cf1557e9efeeb4d32c6b7acaeb9c268$var$p4","$6cf1557e9efeeb4d32c6b7acaeb9c268$var$getDeclutterBox","replayImageOrLabelArgs","declutterBox","$6cf1557e9efeeb4d32c6b7acaeb9c268$var$rtlRegEx","$6cf1557e9efeeb4d32c6b7acaeb9c268$var$horizontalTextAlign","align","test","TEXT_ALIGN","$6cf1557e9efeeb4d32c6b7acaeb9c268$export$9099ad97b570f7c","Executor","overlaps","alignFill_","coordinateCache_","renderedTransform_","pixelCoordinates_","viewRotation_","widths_","createLabel","lines","numLines","widths","currentWidth","$d79b9b8aceb2a0d1337b4e6f69d78e46$export$ba197a5e917e3183","renderWidth","OffscreenCanvasRenderingContext2D","CanvasRenderingContext2D","leftRight","replayTextBackground_","p4","strokeInstruction","setStrokeStyle_","calculateImageOrLabelDimensions_","sheetWidth","sheetHeight","snapToPixel","fillStroke","boxW","boxH","boxX","boxY","drawImageX","drawImageY","drawImageW","drawImageH","replayImageOrLabel_","contextScale","imageOrLabel","dimensions","strokePadding","repeatSize","drawLabelWithPointPlacement_","execute_","opt_featureCallback","opt_hitExtent","opt_declutterTree","pixelCoordinates","transform1","transform2","dd","prevX","prevY","roundX","roundY","currentGeometry","pendingFill","pendingStroke","lastFillInstruction","lastStrokeInstruction","coordinateCache","viewRotation","viewRotationFromTransform","batchSize","declutterImageWithText","labelWithAnchor","widthIndex","imageArgs","imageDeclutterBox","measurePixelRatio","pixelRatioScale","cachedWidths","pathLength","textLength","parts","drawChars","cc","part","ii_1","execute","executeHitDetection","$c6e46405591acfe99e5a94d22fbe8573$var$ORDER","$c6e46405591acfe99e5a94d22fbe8573$var$ExecutorGroup","ExecutorGroup","allInstructions","opt_renderBuffer","overlaps_","executorsByZIndex_","hitDetectionContext_","hitDetectionTransform_","createExecutors_","flatClipCoords","getClipCoords","executors","instructionByZindex","hasExecutors","candidates","declutteredFeatures","contextSize","hitExtent","indexes","$c6e46405591acfe99e5a94d22fbe8573$var$circlePixelIndexArrayCache","maxDistanceSq","distances","pixelIndex","$c6e46405591acfe99e5a94d22fbe8573$export$f610334c339a4991","featureCallback","imageData","idx","result_1","executor","opt_builderTypes","builderTypes","$c6e46405591acfe99e5a94d22fbe8573$export$9099ad97b570f7c","$9f8df4495769241e9ec70201b90e0eaa$export$9099ad97b570f7c","CanvasImmediateRenderer","opt_squaredTolerance","opt_userTransform","context_","squaredTolerance_","userTransform_","contextFillState_","contextStrokeState_","contextTextState_","fillState_","strokeState_","imageAnchorX_","imageAnchorY_","imageHeight_","imageOpacity_","imageOriginX_","imageOriginY_","imageRotateWithView_","imageRotation_","imageScale_","imageWidth_","textScale_","tmpLocalTransform_","$9f8df4495769241e9ec70201b90e0eaa$var$__extends","drawImages_","localTransform","drawText_","setContextFillState_","setContextStrokeState_","setContextTextState_","strokeText","fillText","moveToLineTo_","close","drawRings_","transformGeom2D","geometries","getGeometriesArray","flatMidpoint","geometryExtent","flatMidpoints","flatInteriorPoint","flatInteriorPoints","contextFillState","contextStrokeState","contextTextState","imageAnchor","imageImage","imageOrigin","imageScale","textFillStyleColor","textStrokeStyleColor","textStrokeStyleLineCap","textStrokeStyleLineDash","textStrokeStyleLineDashOffset","textStrokeStyleLineJoin","textStrokeStyleWidth","textStrokeStyleMiterLimit","textFont","textText","textTextAlign","textTextBaseline","$4480b5f4b6f69a5829dd2449dbe6a6c8$var$GEOMETRY_RENDERERS","builderGroup","opt_declutterBuilderGroup","imageReplay","textReplay","lineStringReplay","polygonReplay","replayGroup","geometryRenderer","circleReplay","$4480b5f4b6f69a5829dd2449dbe6a6c8$export$65a5cfeed6fd0c33","feature1","feature2","$4480b5f4b6f69a5829dd2449dbe6a6c8$export$f0ea347488340e3d","$4480b5f4b6f69a5829dd2449dbe6a6c8$export$522dfd100dd96ba1","$4480b5f4b6f69a5829dd2449dbe6a6c8$var$renderGeometry","$4480b5f4b6f69a5829dd2449dbe6a6c8$var$renderFeatureInternal","getGeometries","$c2243072b6513ba407326b2a30b1374a$export$9099ad97b570f7c","CanvasVectorLayerRenderer","vectorLayer","boundHandleStyleImageChange_","handleStyleImageChange_","animatingOrInteracting_","dirty_","hitDetectionImageData_","renderedFeatures_","renderedRevision_","renderedResolution_","renderedRotation_","renderedCenter_","renderedProjection_","renderedRenderOrder_","replayGroup_","replayGroupChanged","clipping","$c2243072b6513ba407326b2a30b1374a$var$__extends","renderWorlds","executorGroup","vectorSource","endWorld","world","$af95442a94d1862a138c401177ef0c4b$export$e7468c0ae08395df","clipped","Promise","resolve","transforms","$9f8df4495769241e9ec70201b90e0eaa$exports","featureCount","indexFactor","featuresByZIndex","featureStyleFunction","styles","originalStyle","canvas_1","imgContext","$4de6336f82b6fd9bc7cf688bb41b8b96$exports","byGeometryType","zIndexKeys","geomAndStyle","kk","$9f8fd0aab32ac5c353b56f527e1d00a9$export$9fd146a6491490e3","resultFeatures","$9f8fd0aab32ac5c353b56f527e1d00a9$export$57fd269e987b81b8","lastIndexOf","executorGroups","animating","interacting","frameStateExtent","vectorLayerRevision","vectorLayerRenderBuffer","vectorLayerRenderOrder","loadExtents","loadExtent","$8ebfb36ef5532881c5652b708da2c120$export$5a0d9577a24f3c5b","declutterBuilderGroup","userTransform","loadFeatures","$4480b5f4b6f69a5829dd2449dbe6a6c8$export$f3b3f9822f340683","dirty","renderFeature","userExtent","getFeaturesInExtent","replayGroupInstructions","getOverlaps","$2f5ed0ce65ecb2bfe439d05296b3d36a$export$9099ad97b570f7c","VectorLayer","$2f5ed0ce65ecb2bfe439d05296b3d36a$var$__extends","$c2243072b6513ba407326b2a30b1374a$exports","$ceed79ad4f0d8f0ebaf810c3cca30983$exports","$e311f93de68f58225dfc37d89d1dcffc$export$9099ad97b570f7c","opt_maxEntries","rbush_","items_","extents","items","getAll","getInExtent","forEach_","forEachInExtent","concat","rbush","$4b7d9e079415657c49d05e16783d2ed4$export$9099ad97b570f7c","$26b846260444bc742bddf88d96721338$export$8dbdea330bbd6b3c","$e1f6506982452a68a8aaa230bb78068a$export$9099ad97b570f7c","$2ef5772bb5b0926a9ba82fc2a88f3163$var$withCredentials","$2ef5772bb5b0926a9ba82fc2a88f3163$export$52988233cf090939","format","success","failure","xhr","XMLHttpRequest","open","responseType","withCredentials","onload","status","responseText","responseXML","DOMParser","parseFromString","response","readFeatures","featureProjection","readProjection","onerror","send","$2ef5772bb5b0926a9ba82fc2a88f3163$export$4355fa6d12274ca5","dataProjection","addFeatures","$76e99b295c09c7c5e340e251e89879b1$export$e3e368afaf9a4fc7","VectorSourceEvent","opt_feature","opt_features","$76e99b295c09c7c5e340e251e89879b1$var$__extends","$76e99b295c09c7c5e340e251e89879b1$export$9099ad97b570f7c","VectorSource","loader_","format_","url_","loader","strategy_","strategy","collection","useSpatialIndex","featuresRtree_","loadedExtentsRtree_","nullGeometryFeatures_","idIndex_","uidIndex_","featureChangeKeys_","featuresCollection_","addFeaturesInternal","bindFeaturesCollection_","addFeature","addFeatureInternal","featureKey","addToIndex_","setupChangeEvents_","handleFeatureChange_","valid","newFeatures","geometryFeatures","length_1","length_2","length_3","modifyingCollection","removeFeature","opt_fast","featureId","removeFeatureInternal","clearEvent","forEachFeature","forEachFeatureAtCoordinateDirect","forEachFeatureInExtent","forEachFeatureIntersectingExtent","getFeaturesCollection","getFeaturesAtCoordinate","getClosestFeatureToCoordinate","opt_filter","closestFeature","previousMinSquaredDistance","minDistance","getFeatureById","getFeatureByUid","getFormat","getUrl","sid","removeFromIdIndex_","hasFeature","loadedExtentsRtree","extentsToLoad","extentToLoad","this_1","removeLoadedExtent","removed","setLoader","$fd3ab3577c0c67d5f04f77f7494fe563$export$9099ad97b570f7c","XYZ","xyzOptions","gridOptions","$0b7f50deff6bfc90c8b239d5ceca7010$export$5731532c605ee56","$fd3ab3577c0c67d5f04f77f7494fe563$var$__extends","$fa8fdebac07669d2ee57fbf926837b94$var$URLToFinal","urlloc","ToRet","location","protocol","href","$fa8fdebac07669d2ee57fbf926837b94$var$ScaleMarkers","$fa8fdebac07669d2ee57fbf926837b94$var$PopoverWidth","$fa8fdebac07669d2ee57fbf926837b94$var$PopoverHeight","$","append","$fa8fdebac07669d2ee57fbf926837b94$var$IOM","hash","$fa8fdebac07669d2ee57fbf926837b94$var$CurrentWindowLocation","$fa8fdebac07669d2ee57fbf926837b94$var$map","$fa8fdebac07669d2ee57fbf926837b94$var$zoom","$7f639b92eb9591e7aded56644548f656$exports","$976448907138da16f7612e32ecc55ac7$exports","[object Object]","$fa8fdebac07669d2ee57fbf926837b94$var$CustomButton","super","handleRotateNorth","elementOverlaySelector","popover","parentElement","sanitize","content","request","onreadystatechange","readyState","getResponseHeader","MapsToAdd","TILED","ALayer","click","$fa8fdebac07669d2ee57fbf926837b94$var$bingLayer","InfoLine","InternalFolder","ShowAtZoomLevel","Latitude","Longitude","ShowName","iMarker","$fa8fdebac07669d2ee57fbf926837b94$var$MarkersOnMap","IsShowing","ReGenAllLayer","$fe05caf5f991aea82bd67c9bebabc467$exports","$2f5ed0ce65ecb2bfe439d05296b3d36a$exports","$76e99b295c09c7c5e340e251e89879b1$exports","$fa8fdebac07669d2ee57fbf926837b94$var$MarkersGrp","markerVectorLayer","MarkersToAdd","ElementsInMarkerstxt","ShowName1","InfoLine1","InternalFolder1","ShowAtZoomLevel1","Latitude1","Longitude1","$fa8fdebac07669d2ee57fbf926837b94$var$MarkerOnMap","$fa8fdebac07669d2ee57fbf926837b94$var$currZoom","$fa8fdebac07669d2ee57fbf926837b94$var$ProcessMarkersToMap"],"version":3,"file":"index.b030226e.js.map"}