{"version":3,"file":"olcesium.js","mappings":"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","sources":["webpack://olcs_unused_var/webpack/bootstrap","webpack://olcs_unused_var/webpack/runtime/compat get default export","webpack://olcs_unused_var/webpack/runtime/define property getters","webpack://olcs_unused_var/webpack/runtime/hasOwnProperty shorthand","webpack://olcs_unused_var/webpack/runtime/make namespace object","webpack://olcs_unused_var/external var \"ol.geom.Point\"","webpack://olcs_unused_var/./src/olcs/util.ts","webpack://olcs_unused_var/external var \"ol.easing\"","webpack://olcs_unused_var/external var \"ol.layer.Tile\"","webpack://olcs_unused_var/external var \"ol.layer.Image\"","webpack://olcs_unused_var/external var \"ol.proj\"","webpack://olcs_unused_var/external var \"ol.source.ImageStatic\"","webpack://olcs_unused_var/external var \"ol.source.ImageWMS\"","webpack://olcs_unused_var/external var \"ol.source.TileImage\"","webpack://olcs_unused_var/external var \"ol.source.TileWMS\"","webpack://olcs_unused_var/external var \"ol.source.VectorTile\"","webpack://olcs_unused_var/external var \"ol.source.Image\"","webpack://olcs_unused_var/external var \"ol.source\"","webpack://olcs_unused_var/./src/olcs/core/OLImageryProvider.ts","webpack://olcs_unused_var/external var \"ol.format.MVT\"","webpack://olcs_unused_var/external var \"ol.style.Style\"","webpack://olcs_unused_var/external var \"ol.style.Stroke\"","webpack://olcs_unused_var/external var \"ol.render\"","webpack://olcs_unused_var/external var \"ol.util\"","webpack://olcs_unused_var/external var \"ol.structs.LRUCache\"","webpack://olcs_unused_var/external var \"ol.tilegrid\"","webpack://olcs_unused_var/external var \"ol.tileurlfunction\"","webpack://olcs_unused_var/external var \"ol.render.Feature\"","webpack://olcs_unused_var/./src/olcs/MVTImageryProvider.ts","webpack://olcs_unused_var/external var \"ol.layer.VectorTile\"","webpack://olcs_unused_var/external var \"ol.extent\"","webpack://olcs_unused_var/./src/olcs/core.ts","webpack://olcs_unused_var/./src/olcs/AutoRenderLoop.ts","webpack://olcs_unused_var/external var \"ol.Observable\"","webpack://olcs_unused_var/./src/olcs/math.ts","webpack://olcs_unused_var/./src/olcs/Camera.ts","webpack://olcs_unused_var/external var \"ol.layer.Group\"","webpack://olcs_unused_var/./src/olcs/AbstractSynchronizer.ts","webpack://olcs_unused_var/external var \"ol.layer.BaseVector\"","webpack://olcs_unused_var/./src/olcs/RasterSynchronizer.ts","webpack://olcs_unused_var/external var \"ol.source.Vector\"","webpack://olcs_unused_var/external var \"ol.layer.Layer\"","webpack://olcs_unused_var/external var \"ol.source.Cluster\"","webpack://olcs_unused_var/external var \"ol.layer.Vector\"","webpack://olcs_unused_var/external var \"ol.style.Icon\"","webpack://olcs_unused_var/external var \"ol.geom.Polygon\"","webpack://olcs_unused_var/external var \"ol.geom.SimpleGeometry\"","webpack://olcs_unused_var/./src/olcs/core/VectorLayerCounterpart.ts","webpack://olcs_unused_var/external var \"ol.geom\"","webpack://olcs_unused_var/./src/olcs/FeatureConverter.ts","webpack://olcs_unused_var/./src/olcs/VectorSynchronizer.ts","webpack://olcs_unused_var/external var \"ol.Overlay\"","webpack://olcs_unused_var/./src/olcs/SynchronizedOverlay.ts","webpack://olcs_unused_var/./src/olcs/OverlaySynchronizer.ts","webpack://olcs_unused_var/./src/olcs/OLCesium.ts","webpack://olcs_unused_var/./src/olcs/print/computeRectangle.ts","webpack://olcs_unused_var/./src/olcs/print/drawCesiumMask.ts","webpack://olcs_unused_var/./src/olcs/print/takeCesiumScreenshot.ts","webpack://olcs_unused_var/./src/olcs/contrib/LazyLoader.ts","webpack://olcs_unused_var/./src/olcs/contrib/Manager.ts","webpack://olcs_unused_var/./src/olcs.ts"],"sourcesContent":["// The require scope\nvar __webpack_require__ = {};\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","const __WEBPACK_NAMESPACE_OBJECT__ = ol.geom.Point;","import type {Projection} from 'ol/proj';\nimport type {Source} from 'ol/source';\n\nlet _imageRenderingPixelatedSupported: boolean = undefined;\nlet _imageRenderingValue: string = undefined;\n\n\n/**\n * https://caniuse.com/mdn-css_properties_image-rendering_pixelated\n * @return whether the browser supports\n */\nexport function supportsImageRenderingPixelated(): boolean {\n  if (_imageRenderingPixelatedSupported === undefined) {\n    const canvas = document.createElement('canvas');\n    canvas.setAttribute('style', 'image-rendering: -moz-crisp-edges; image-rendering: crisp-edges; image-rendering: pixelated;');\n    // canvas.style.imageRendering will be undefined, null or an\n    // empty string on unsupported browsers.\n    const imageRenderingValue = canvas.style.imageRendering;\n    _imageRenderingPixelatedSupported = !!imageRenderingValue;\n    if (_imageRenderingPixelatedSupported) {\n      _imageRenderingValue = imageRenderingValue;\n    }\n  }\n  return _imageRenderingPixelatedSupported;\n}\n\n\n/**\n * The value supported by thie browser for the CSS property \"image-rendering\"\n * @return {string}\n */\nexport function imageRenderingValue() {\n  supportsImageRenderingPixelated();\n  return _imageRenderingValue || '';\n}\n\n/**\n * Return the projection of the source that Cesium should use.\n *\n * @param source Source.\n * @return The projection of the source.\n */\nexport function getSourceProjection(source: Source): Projection {\n  return source.get('olcs.projection') as Projection || source.getProjection();\n}\n\n\n/**\n * Counter for getUid.\n * @type {number}\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. Similar to OL getUid.\n *\n * @param obj The object to get the unique ID for.\n * @return The unique ID for the object.\n */\nexport function getUid(obj: any): number {\n  return obj.olcs_uid || (obj.olcs_uid = ++uidCounter_);\n}\n\nexport function waitReady<Type>(object: Type): Promise<Type> {\n  const o = object as any;\n  const p = o.readyPromise;\n  if (p) {\n    return p;\n  }\n  if (o.ready !== undefined) {\n    if (o.ready) {\n      return Promise.resolve(object);\n    }\n    return new Promise((resolve, _) => {\n      // FIXME: this is crazy\n      // alternative: intercept _ready = true\n      // altnerative: pass a timeout\n      const stopper = setInterval(() => {\n        if (o.ready) {\n          clearInterval(stopper);\n          resolve(object);\n        }\n      }, 20);\n    });\n  }\n  return Promise.reject('Not a readyable object');\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = ol.easing;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.layer.Tile;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.layer.Image;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.proj;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.source.ImageStatic;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.source.ImageWMS;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.source.TileImage;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.source.TileWMS;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.source.VectorTile;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.source.Image;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.source;","import {getSourceProjection} from '../util';\nimport {Tile as TileSource, type TileImage} from 'ol/source.js';\nimport {attributionsFunctionToCredits} from '../core';\nimport type {Map} from 'ol';\nimport type {Projection} from 'ol/proj.js';\nimport type {Credit, Event, ImageryLayerFeatureInfo, ImageryProvider, ImageryTypes, Proxy, Rectangle, Request, TileDiscardPolicy, TilingScheme} from 'cesium';\n\n\nexport function createEmptyCanvas(): HTMLCanvasElement {\n  const canvas = document.createElement('canvas');\n  canvas.width = 1;\n  canvas.height = 1;\n  return canvas;\n}\n\nconst olUseNewCoordinates = (function() {\n  const tileSource = new TileSource({\n    projection: 'EPSG:3857',\n    wrapX: true\n  });\n  const tileCoord = tileSource.getTileCoordForTileUrlFunction([6, -31, 22]);\n  return tileCoord && tileCoord[1] === 33 && tileCoord[2] === 22;\n  // See b/test/spec/ol/source/tile.test.js\n  // of e9a30c5cb7e3721d9370025fbe5472c322847b35 in OpenLayers repository\n})();\n\n\nexport default class OLImageryProvider implements ImageryProvider /* should not extend Cesium.ImageryProvider */ {\n  private source_: TileImage;\n  private projection_: Projection | undefined;\n  private fallbackProj_: Projection | undefined;\n  private map_: Map;\n  private shouldRequestNextLevel: boolean;\n  private emptyCanvas_: HTMLCanvasElement = createEmptyCanvas();\n  private emptyCanvasPromise_: Promise<HTMLCanvasElement> = Promise.resolve(this.emptyCanvas_);\n  private tilingScheme_: TilingScheme;\n  private ready_: boolean;\n  private rectangle_: Rectangle;\n\n  /**\n * When <code>true</code>, this model is ready to render, i.e., the external binary, image,\n * and shader files were downloaded and the WebGL resources were created.\n */\n  get ready(): boolean {\n    return this.ready_;\n  }\n\n  /**\n * Gets the rectangle, in radians, of the imagery provided by the instance.\n */\n  get rectangle() {\n    return this.rectangle_;\n  }\n\n  /**\n   * Gets the tiling scheme used by the provider.\n   */\n  get tilingScheme(): TilingScheme {\n    return this.tilingScheme_;\n  }\n\n  /**\n   * Gets an event that is raised when the imagery provider encounters an asynchronous error.  By subscribing\n   * to the event, you will be notified of the error and can potentially recover from it.  Event listeners\n   * are passed an instance of {@link Cesium.TileProviderError}.\n   */\n  readonly errorEvent: Event = new Cesium.Event();\n\n  /**\n   * Gets the credit to display when this imagery provider is active.  Typically this is used to credit\n   * the source of the imagery.\n   */\n  readonly credit: Credit;\n\n  /**\n   * Gets the proxy used by this provider.\n   */\n  readonly proxy: Proxy;\n\n  get _ready(): boolean {\n    return this.ready_;\n  }\n\n  /**\n   * Gets the width of each tile, in pixels.\n   */\n  get tileWidth(): number {\n    const tileGrid = this.source_.getTileGrid();\n    if (tileGrid) {\n      const tileSizeAtZoom0 = tileGrid.getTileSize(0);\n      if (Array.isArray(tileSizeAtZoom0)) {\n        return tileSizeAtZoom0[0];\n      } else {\n        return tileSizeAtZoom0; // same width and height\n      }\n    }\n    return 256;\n  }\n\n  /**\n   * Gets the height of each tile, in pixels.\n   */\n  get tileHeight(): number {\n    const tileGrid = this.source_.getTileGrid();\n    if (tileGrid) {\n      const tileSizeAtZoom0 = tileGrid.getTileSize(0);\n      if (Array.isArray(tileSizeAtZoom0)) {\n        return tileSizeAtZoom0[1];\n      } else {\n        return tileSizeAtZoom0; // same width and height\n      }\n    }\n    return 256;\n  }\n\n  /**\n   * Gets the maximum level-of-detail that can be requested.\n   */\n  get maximumLevel(): number {\n    const tileGrid = this.source_.getTileGrid();\n    if (tileGrid) {\n      return tileGrid.getMaxZoom();\n    } else {\n      return 18; // some arbitrary value\n    }\n  }\n\n  // FIXME: to implement, we could check the number of tiles at minzoom (for this rectangle) and return 0 if too big\n  /**\n   * Gets the minimum level-of-detail that can be requested.  Generally,\n   * a minimum level should only be used when the rectangle of the imagery is small\n   * enough that the number of tiles at the minimum level is small.  An imagery\n   * provider with more than a few tiles at the minimum level will lead to\n   * rendering problems.\n   */\n  get minimumLevel() {\n    // WARNING: Do not use the minimum level (at least until the extent is\n    // properly set). Cesium assumes the minimumLevel to contain only\n    // a few tiles and tries to load them all at once -- this can\n    // freeze and/or crash the browser !\n    return 0;\n    //var tg = this.source_.getTileGrid();\n    //return tg ? tg.getMinZoom() : 0;\n  }\n\n  /**\n   * Gets the tile discard policy.  If not undefined, the discard policy is responsible\n   * for filtering out \"missing\" tiles via its shouldDiscardImage function.  If this function\n   * returns undefined, no tiles are filtered.\n   */\n  get tileDiscardPolicy(): TileDiscardPolicy {\n    return undefined;\n  }\n\n  // FIXME: this might be exposed\n  /**\n   * Gets a value indicating whether or not the images provided by this imagery provider\n   * include an alpha channel.  If this property is false, an alpha channel, if present, will\n   * be ignored.  If this property is true, any images without an alpha channel will be treated\n   * as if their alpha is 1.0 everywhere.  When this property is false, memory usage\n   * and texture upload time are reduced.\n   */\n  get hasAlphaChannel() {\n    return true;\n  }\n\n  // FIXME: this could be implemented by proxying to OL\n  /**\n   * Asynchronously determines what features, if any, are located at a given longitude and latitude within\n   * a tile.\n   * This function is optional, so it may not exist on all ImageryProviders.\n   * @param x - The tile X coordinate.\n   * @param y - The tile Y coordinate.\n   * @param level - The tile level.\n   * @param longitude - The longitude at which to pick features.\n   * @param latitude - The latitude at which to pick features.\n   * @return A promise for the picked features that will resolve when the asynchronous\n   *                   picking completes.  The resolved value is an array of {@link ImageryLayerFeatureInfo}\n   *                   instances.  The array may be empty if no features are found at the given location.\n   *                   It may also be undefined if picking is not supported.\n   */\n  pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined {\n    return undefined;\n  }\n\n  /**\n   * Special class derived from Cesium.ImageryProvider\n   * that is connected to the given ol.source.TileImage.\n   * @param olMap OL map\n   * @param source Tile image source\n   * @param [opt_fallbackProj] Projection to assume if source has no projection\n   */\n  constructor(olMap: Map, source: TileImage, opt_fallbackProj: Projection) {\n    this.source_ = source;\n\n    this.projection_ = null;\n\n    this.ready_ = false;\n\n    this.fallbackProj_ = opt_fallbackProj || null;\n\n    // cesium v107+ don't wait for ready anymore so we put somehing here while it loads\n    this.tilingScheme_ = new Cesium.WebMercatorTilingScheme();\n\n    this.rectangle_ = null;\n\n    this.map_ = olMap;\n\n    this.shouldRequestNextLevel = false;\n\n    const proxy = this.source_.get('olcs.proxy');\n    if (proxy) {\n      if (typeof proxy === 'function') {\n        // Duck typing a proxy\n        this.proxy = {\n          'getURL': proxy\n        } as Proxy;\n      } else if (typeof proxy === 'string') {\n        this.proxy = new Cesium.DefaultProxy(proxy);\n      }\n    }\n\n    this.source_.on('change', (e) => {\n      this.handleSourceChanged_();\n    });\n    this.handleSourceChanged_();\n  }\n\n  /**\n   * Checks if the underlying source is ready and cached required data.\n   */\n  private handleSourceChanged_() {\n    if (!this.ready_ && this.source_.getState() == 'ready') {\n      this.projection_ = getSourceProjection(this.source_) || this.fallbackProj_;\n      const options = {numberOfLevelZeroTilesX: 1, numberOfLevelZeroTilesY: 1};\n\n      if (this.source_.tileGrid !== null) {\n        // Get the number of tiles at level 0 if it is defined\n        this.source_.tileGrid.forEachTileCoord(this.projection_.getExtent(), 0, ([zoom, xIndex, yIndex]) => {\n          options.numberOfLevelZeroTilesX = xIndex + 1;\n          options.numberOfLevelZeroTilesY = yIndex + 1;\n        });\n      }\n\n      if (this.projection_.getCode() === 'EPSG:4326') {\n        // Cesium zoom level 0 is OpenLayers zoom level 1 for layer in EPSG:4326 with a single tile on level 0\n        this.shouldRequestNextLevel = options.numberOfLevelZeroTilesX === 1 && options.numberOfLevelZeroTilesY === 1;\n        this.tilingScheme_ = new Cesium.GeographicTilingScheme(options);\n      } else if (this.projection_.getCode() === 'EPSG:3857') {\n        this.shouldRequestNextLevel = false;\n        this.tilingScheme_ = new Cesium.WebMercatorTilingScheme(options);\n      } else {\n        return;\n      }\n      this.rectangle_ = this.tilingScheme_.rectangle;\n\n      this.ready_ = true;\n    }\n  }\n\n  /**\n   * Generates the proper attributions for a given position and zoom\n   * level.\n   * @implements\n   */\n  getTileCredits(x: number, y: number, level: number): Credit[] {\n    const attributionsFunction = this.source_.getAttributions();\n    if (!attributionsFunction) {\n      return [];\n    }\n    const extent = this.map_.getView().calculateExtent(this.map_.getSize());\n    const center = this.map_.getView().getCenter();\n    const zoom = this.shouldRequestNextLevel ? level + 1 : level;\n    return attributionsFunctionToCredits(attributionsFunction, zoom, center, extent);\n  }\n\n  /**\n   * @implements\n   */\n  requestImage(x: number, y: number, level: number, request?: Request): Promise<ImageryTypes> | undefined {\n    const tileUrlFunction = this.source_.getTileUrlFunction();\n    if (tileUrlFunction && this.projection_) {\n      const z_ = this.shouldRequestNextLevel ? level + 1 : level;\n\n      let y_ = y;\n      if (!olUseNewCoordinates) {\n        // LEGACY\n        // OpenLayers version 3 to 5 tile coordinates increase from bottom to top\n        y_ = -y - 1;\n      }\n      let url = tileUrlFunction.call(this.source_, [z_, x, y_], 1, this.projection_);\n      if (this.proxy) {\n        url = this.proxy.getURL(url);\n      }\n      if (url) {\n        // It is probably safe to cast here\n        return Cesium.ImageryProvider.loadImage(this, url) as Promise<ImageryTypes>;\n      }\n      return this.emptyCanvasPromise_;\n    } else {\n      // return empty canvas to stop Cesium from retrying later\n      return this.emptyCanvasPromise_;\n    }\n  }\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = ol.format.MVT;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.style.Style;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.style.Stroke;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.render;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.util;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.structs.LRUCache;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.tilegrid;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.tileurlfunction;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.render.Feature;","import MVT from 'ol/format/MVT.js';\nimport Style, {type StyleFunction} from 'ol/style/Style.js';\nimport Stroke from 'ol/style/Stroke.js';\nimport {toContext} from 'ol/render.js';\nimport {get as getProjection} from 'ol/proj.js';\nimport {VERSION as OL_VERSION} from 'ol/util.js';\nimport LRUCache from 'ol/structs/LRUCache.js';\nimport {getForProjection as getTilegridForProjection} from 'ol/tilegrid.js';\nimport {createFromTemplates as createTileUrlFunctions} from 'ol/tileurlfunction.js';\nimport type {Credit, Event, ImageryLayerFeatureInfo, ImageryProvider, ImageryTypes, Proxy, Rectangle, Request, TileDiscardPolicy, TilingScheme} from 'cesium';\nimport type {UrlFunction} from 'ol/Tile.js';\nimport RenderFeature from 'ol/render/Feature.js';\nimport {createEmptyCanvas} from './core/OLImageryProvider';\n\n\nexport interface MVTOptions {\n  urls: string[],\n  rectangle: Rectangle,\n  credit: Credit,\n  styleFunction: StyleFunction,\n  cacheSize?: number,\n  featureCache?: LRUCache<Promise<RenderFeature[]>>\n  minimumLevel: number\n}\n\nconst format = new MVT({\n  featureClass: RenderFeature\n});\n\nconst styles = [new Style({\n  stroke: new Stroke({\n    color: 'blue',\n    width: 2\n  })\n})];\n\n\nexport default class MVTImageryProvider implements ImageryProvider {\n  private urls: string[];\n  private emptyCanvas_: HTMLCanvasElement = createEmptyCanvas();\n  private emptyCanvasPromise_: Promise<HTMLCanvasElement> = Promise.resolve(this.emptyCanvas_);\n  private tilingScheme_ = new Cesium.WebMercatorTilingScheme;\n  private ready_ = true;\n  private rectangle_: Rectangle;\n  private tileRectangle_: Rectangle;\n  readonly tileWidth = 256;\n  readonly tileHeight = 256;\n  readonly maximumLevel = 20;\n  private minimumLevel_ = 0;\n  get minimumLevel(): number {\n    return this.minimumLevel_;\n  }\n  private featureCache: LRUCache<Promise<RenderFeature[]>>;\n  private tileCache: LRUCache<Promise<HTMLCanvasElement>>;\n  private tileFunction_: UrlFunction;\n  private styleFunction_: StyleFunction;\n  private projection_ = getProjection('EPSG:3857');\n\n  /**\n * When <code>true</code>, this model is ready to render, i.e., the external binary, image,\n * and shader files were downloaded and the WebGL resources were created.\n */\n  get ready(): boolean {\n    return this.ready_;\n  }\n\n  /**\n * Gets the rectangle, in radians, of the imagery provided by the instance.\n */\n  get rectangle() {\n    return this.rectangle_;\n  }\n\n  /**\n   * Gets the tiling scheme used by the provider.\n   */\n  get tilingScheme(): TilingScheme {\n    return this.tilingScheme_;\n  }\n\n  /**\n   * Gets an event that is raised when the imagery provider encounters an asynchronous error.  By subscribing\n   * to the event, you will be notified of the error and can potentially recover from it.  Event listeners\n   * are passed an instance of {@link Cesium.TileProviderError}.\n   */\n  readonly errorEvent: Event = new Cesium.Event();\n\n  /**\n   * Gets the credit to display when this imagery provider is active.  Typically this is used to credit\n   * the source of the imagery.\n   */\n  readonly credit: Credit;\n\n  getTileCredits(x: number, y: number, level: number): Credit[] {\n    return [];\n  }\n\n  /**\n   * Gets the proxy used by this provider.\n   */\n  readonly proxy: Proxy;\n\n  get _ready(): boolean {\n    return this.ready_;\n  }\n\n  /**\n   * Gets the tile discard policy.  If not undefined, the discard policy is responsible\n   * for filtering out \"missing\" tiles via its shouldDiscardImage function.  If this function\n   * returns undefined, no tiles are filtered.\n   */\n  get tileDiscardPolicy(): TileDiscardPolicy {\n    return undefined;\n  }\n\n  // FIXME: this might be exposed\n  /**\n   * Gets a value indicating whether or not the images provided by this imagery provider\n   * include an alpha channel.  If this property is false, an alpha channel, if present, will\n   * be ignored.  If this property is true, any images without an alpha channel will be treated\n   * as if their alpha is 1.0 everywhere.  When this property is false, memory usage\n   * and texture upload time are reduced.\n   */\n  get hasAlphaChannel() {\n    return true;\n  }\n\n  // FIXME: this could be implemented by proxying to OL\n  /**\n   * Asynchronously determines what features, if any, are located at a given longitude and latitude within\n   * a tile.\n   * This function is optional, so it may not exist on all ImageryProviders.\n   * @param x - The tile X coordinate.\n   * @param y - The tile Y coordinate.\n   * @param level - The tile level.\n   * @param longitude - The longitude at which to pick features.\n   * @param latitude - The latitude at which to pick features.\n   * @return A promise for the picked features that will resolve when the asynchronous\n   *                   picking completes.  The resolved value is an array of {@link ImageryLayerFeatureInfo}\n   *                   instances.  The array may be empty if no features are found at the given location.\n   *                   It may also be undefined if picking is not supported.\n   */\n  pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined {\n    return undefined;\n  }\n\n  constructor(options: MVTOptions) {\n    this.urls = options.urls;\n    this.rectangle_ = options.rectangle || this.tilingScheme.rectangle;\n    this.credit = options.credit;\n    this.styleFunction_ = options.styleFunction || (() => styles);\n    this.tileRectangle_ = new Cesium.Rectangle();\n    // to avoid too frequent cache grooming we allow x2 capacity\n    const cacheSize = options.cacheSize !== undefined ? options.cacheSize : 50;\n    this.tileCache = new LRUCache(cacheSize);\n    this.featureCache = options.featureCache || new LRUCache(cacheSize);\n    this.minimumLevel_ = options.minimumLevel || 0;\n    const tileGrid = getTilegridForProjection(this.projection_);\n    this.tileFunction_ = createTileUrlFunctions(this.urls, tileGrid);\n  }\n\n  private getTileFeatures(z: number, x: number, y: number): Promise<RenderFeature[]> {\n    const cacheKey = this.getCacheKey_(z, x, y);\n    let promise;\n    if (this.featureCache.containsKey(cacheKey)) {\n      promise = this.featureCache.get(cacheKey);\n    }\n    if (!promise) {\n      const url = this.getUrl_(z, x, y);\n      promise = fetch(url)\n          .then(r => (r.ok ? r : Promise.reject(r)))\n          .then(r => r.arrayBuffer())\n          .then(buffer => this.readFeaturesFromBuffer(buffer));\n      this.featureCache.set(cacheKey, promise);\n      if (this.featureCache.getCount() > 2 * this.featureCache.highWaterMark) {\n        while (this.featureCache.canExpireCache()) {\n          this.featureCache.pop();\n        }\n      }\n    }\n    return promise;\n  }\n\n  readFeaturesFromBuffer(buffer: ArrayBuffer): RenderFeature[] {\n    let options;\n    if (OL_VERSION <= '6.4.4') {\n      // See https://github.com/openlayers/openlayers/pull/11540\n      options = {\n        extent: [0, 0, 4096, 4096],\n        dataProjection: this.projection_,\n        featureProjection: this.projection_\n      };\n    }\n    const features = format.readFeatures(buffer, options) as RenderFeature[];\n    const scaleFactor = this.tileWidth / 4096;\n    features.forEach((f) => {\n      const flatCoordinates = f.getFlatCoordinates();\n      let flip = false;\n      for (let i = 0; i < flatCoordinates.length; ++i) {\n        flatCoordinates[i] *= scaleFactor;\n        if (flip) {\n          // FIXME: why do we need this now?\n          flatCoordinates[i] = this.tileWidth - flatCoordinates[i];\n        }\n        if (OL_VERSION <= '6.4.4') {\n          // LEGACY\n          flip = !flip;\n        }\n      }\n    });\n\n    return features;\n  }\n\n  private getUrl_(z: number, x: number, y: number): string {\n    // FIXME: probably we should not pass 1 as pixelRatio\n    const url = this.tileFunction_([z, x, y], 1, this.projection_);\n    return url;\n  }\n\n  private getCacheKey_(z: number, x: number, y: number) {\n    return `${z}_${x}_${y}`;\n  }\n\n  requestImage(x: number, y: number, z: number, request?: Request): Promise<ImageryTypes> | undefined {\n    if (z < this.minimumLevel_) {\n      return this.emptyCanvasPromise_;\n    }\n\n    try {\n      const cacheKey = this.getCacheKey_(z, x, y);\n      let promise;\n      if (this.tileCache.containsKey(cacheKey)) {\n        promise = this.tileCache.get(cacheKey);\n      }\n      if (!promise) {\n        promise = this.getTileFeatures(z, x, y)\n            .then((features) => {\n            // FIXME: here we suppose the 2D projection is in meters\n              this.tilingScheme.tileXYToNativeRectangle(x, y, z, this.tileRectangle_);\n              const resolution = (this.tileRectangle_.east - this.tileRectangle_.west) / this.tileWidth;\n              return this.rasterizeFeatures(features, this.styleFunction_, resolution);\n            });\n        this.tileCache.set(cacheKey, promise);\n        if (this.tileCache.getCount() > 2 * this.tileCache.highWaterMark) {\n          while (this.tileCache.canExpireCache()) {\n            this.tileCache.pop();\n          }\n        }\n      }\n      return promise;\n    } catch (e) {\n      console.trace(e);\n      // FIXME: open PR on Cesium to fix incorrect typing\n      // @ts-ignore\n      this.errorEvent.raiseEvent('could not render pbf to tile', e);\n    }\n  }\n\n  rasterizeFeatures(features: RenderFeature[], styleFunction: StyleFunction, resolution: number): HTMLCanvasElement {\n    const canvas = document.createElement('canvas');\n    const vectorContext = toContext(canvas.getContext('2d'), {size: [this.tileWidth, this.tileHeight]});\n    features.forEach((f) => {\n      const styles = styleFunction(f, resolution);\n      if (styles) {\n        if (Array.isArray(styles)) {\n          styles.forEach((style) => {\n            vectorContext.setStyle(style);\n            vectorContext.drawGeometry(f);\n          });\n        } else {\n          vectorContext.setStyle(styles);\n          vectorContext.drawGeometry(f);\n        }\n      }\n    });\n    return canvas;\n  }\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = ol.layer.VectorTile;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.extent;","import {linear as linearEasing} from 'ol/easing.js';\nimport olLayerTile from 'ol/layer/Tile.js';\nimport olLayerImage from 'ol/layer/Image.js';\nimport {get as getProjection, type ProjectionLike, transformExtent} from 'ol/proj.js';\nimport olSourceImageStatic from 'ol/source/ImageStatic.js';\nimport olSourceImageWMS from 'ol/source/ImageWMS.js';\nimport olSourceTileImage from 'ol/source/TileImage.js';\nimport olSourceTileWMS from 'ol/source/TileWMS.js';\nimport olSourceVectorTile from 'ol/source/VectorTile.js';\nimport {defaultImageLoadFunction} from 'ol/source/Image.js';\nimport olcsCoreOLImageryProvider from './core/OLImageryProvider';\nimport {getSourceProjection} from './util';\nimport MVTImageryProvider from './MVTImageryProvider';\nimport VectorTileLayer from 'ol/layer/VectorTile.js';\nimport {type Extent, getCenter as getExtentCenter} from 'ol/extent.js';\nimport type BaseLayer from 'ol/layer/Base.js';\nimport type LayerGroup from 'ol/layer/Group.js';\nimport type {\n  BoundingSphere,\n  Camera,\n  Cartesian2,\n  Cartesian3,\n  Cartographic,\n  Color, ImageMaterialProperty,\n  ImageryLayer,\n  Matrix4,\n  Ray,\n  Rectangle,\n  Scene,\n  SingleTileImageryProvider\n} from 'cesium';\nimport type Geometry from 'ol/geom/Geometry.js';\nimport type {Coordinate} from 'ol/coordinate.js';\nimport type Source from 'ol/source/Source.js';\n// eslint-disable-next-line no-duplicate-imports\nimport type {Attribution} from 'ol/source/Source.js';\n\nimport type Map from 'ol/Map.js';\nimport type Projection from 'ol/proj/Projection.js';\nimport type {Color as OLColor} from 'ol/color.js';\nimport type View from 'ol/View.js';\n\ntype CesiumUrlDefinition = {\n    url: string,\n    subdomains: string\n}\n\n\n/**\n * Options for rotate around axis core function.\n */\ntype RotateAroundAxisOption = {\n  duration?: number,\n  easing?: (value: number) => number,\n  callback: () => void\n}\n\n\nexport type LayerWithParents = {\n  layer: BaseLayer,\n  parents: LayerGroup[] | BaseLayer[]\n}\n\n\n/**\n * Compute the pixel width and height of a point in meters using the\n * camera frustum.\n */\nexport function computePixelSizeAtCoordinate(scene: Scene, target: Cartesian3): Cartesian2 {\n  const camera = scene.camera;\n  const canvas = scene.canvas;\n  const frustum = camera.frustum;\n  const distance = Cesium.Cartesian3.magnitude(Cesium.Cartesian3.subtract(\n      camera.position, target, new Cesium.Cartesian3()));\n  // @ts-ignore TS2341\n  return frustum.getPixelDimensions(canvas.clientWidth, canvas.clientHeight, distance, scene.pixelRatio, new Cesium.Cartesian2());\n}\n\n\n/**\n * Compute bounding box around a target point.\n * @param {!Cesium.Scene} scene\n * @param {!Cesium.Cartesian3} target\n * @param {number} amount Half the side of the box, in pixels.\n * @return {Array<Cesium.Cartographic>} bottom left and top right\n * coordinates of the box\n */\nexport function computeBoundingBoxAtTarget(scene: Scene, target: Cartesian3, amount: number): Cartographic[] {\n  const pixelSize = computePixelSizeAtCoordinate(scene, target);\n  const transform = Cesium.Transforms.eastNorthUpToFixedFrame(target);\n\n  const bottomLeft = Cesium.Matrix4.multiplyByPoint(\n      transform,\n      new Cesium.Cartesian3(-pixelSize.x * amount, -pixelSize.y * amount, 0),\n      new Cesium.Cartesian3());\n\n  const topRight = Cesium.Matrix4.multiplyByPoint(\n      transform,\n      new Cesium.Cartesian3(pixelSize.x * amount, pixelSize.y * amount, 0),\n      new Cesium.Cartesian3());\n\n  return Cesium.Ellipsoid.WGS84.cartesianArrayToCartographicArray(\n      [bottomLeft, topRight]);\n}\n\nexport function applyHeightOffsetToGeometry(geometry: Geometry, height: number) {\n  geometry.applyTransform((input, output, stride) => {\n    console.assert(input === output);\n    if (stride !== undefined && stride >= 3) {\n      for (let i = 0; i < output.length; i += stride) {\n        output[i + 2] = output[i + 2] + height;\n      }\n    }\n    return output;\n  });\n}\n\nexport function createMatrixAtCoordinates(\n    coordinates: Coordinate,\n    rotation = 0,\n    translation = Cesium.Cartesian3.ZERO,\n    scale = new Cesium.Cartesian3(1, 1, 1)\n): Matrix4 {\n  const position = ol4326CoordinateToCesiumCartesian(coordinates);\n  const rawMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(position);\n  const quaternion = Cesium.Quaternion.fromAxisAngle(Cesium.Cartesian3.UNIT_Z, -rotation);\n  const rotationMatrix = Cesium.Matrix4.fromTranslationQuaternionRotationScale(translation, quaternion, scale);\n  return Cesium.Matrix4.multiply(rawMatrix, rotationMatrix, new Cesium.Matrix4());\n}\n\nexport function rotateAroundAxis(camera: Camera, angle: number, axis: Cartesian3, transform: Matrix4,\n    opt_options?: RotateAroundAxisOption) {\n  const clamp = Cesium.Math.clamp;\n  const defaultValue = Cesium.defaultValue;\n\n  const options: RotateAroundAxisOption = opt_options;\n  const duration = defaultValue(options?.duration, 500); // ms\n  const easing = defaultValue(options?.easing, linearEasing);\n  const callback = options?.callback;\n\n  let lastProgress = 0;\n  const oldTransform = new Cesium.Matrix4();\n\n  const start = Date.now();\n  const step = function() {\n    const timestamp = Date.now();\n    const timeDifference = timestamp - start;\n    const progress = easing(clamp(timeDifference / duration, 0, 1));\n    console.assert(progress >= lastProgress);\n\n    camera.transform.clone(oldTransform);\n    const stepAngle = (progress - lastProgress) * angle;\n    lastProgress = progress;\n    camera.lookAtTransform(transform);\n    camera.rotate(axis, stepAngle);\n    camera.lookAtTransform(oldTransform);\n\n    if (progress < 1) {\n      window.requestAnimationFrame(step);\n    } else {\n      if (callback) {\n        callback();\n      }\n    }\n  };\n  window.requestAnimationFrame(step);\n}\n\nexport function setHeadingUsingBottomCenter(\n    scene: Scene,\n    heading: number,\n    bottomCenter: Cartesian3,\n    options?: RotateAroundAxisOption\n) {\n  const camera = scene.camera;\n  // Compute the camera position to zenith quaternion\n  const angleToZenith = computeAngleToZenith(scene, bottomCenter);\n  const axis = camera.right;\n  const quaternion = Cesium.Quaternion.fromAxisAngle(axis, angleToZenith);\n  const rotation = Cesium.Matrix3.fromQuaternion(quaternion);\n\n  // Get the zenith point from the rotation of the position vector\n  const vector = new Cesium.Cartesian3();\n  Cesium.Cartesian3.subtract(camera.position, bottomCenter, vector);\n  const zenith = new Cesium.Cartesian3();\n  Cesium.Matrix3.multiplyByVector(rotation, vector, zenith);\n  Cesium.Cartesian3.add(zenith, bottomCenter, zenith);\n\n  // Actually rotate around the zenith normal\n  const transform = Cesium.Matrix4.fromTranslation(zenith);\n  rotateAroundAxis(camera, heading, zenith, transform, options);\n}\n\n\n/**\n * Get the 3D position of the given pixel of the canvas.\n */\nexport function pickOnTerrainOrEllipsoid(scene: Scene, pixel: Cartesian2): Cartesian3 {\n  const ray = scene.camera.getPickRay(pixel);\n  const target = scene.globe.pick(ray, scene);\n  return target || scene.camera.pickEllipsoid(pixel);\n}\n\n\n/**\n * Get the 3D position of the point at the bottom-center of the screen.\n */\nexport function pickBottomPoint(scene: Scene): Cartesian3 | undefined {\n  const canvas = scene.canvas;\n  const bottom = new Cesium.Cartesian2(\n      canvas.clientWidth / 2, canvas.clientHeight);\n  return pickOnTerrainOrEllipsoid(scene, bottom);\n}\n\n\n/**\n * Get the 3D position of the point at the center of the screen.\n */\nexport function pickCenterPoint(scene: Scene): Cartesian3 | undefined {\n  const canvas = scene.canvas;\n  const center = new Cesium.Cartesian2(\n      canvas.clientWidth / 2,\n      canvas.clientHeight / 2);\n  return pickOnTerrainOrEllipsoid(scene, center);\n}\n\n\n/**\n * Compute the signed tilt angle on globe, between the opposite of the\n * camera direction and the target normal. Return undefined if there is no\n */\nexport function computeSignedTiltAngleOnGlobe(scene: Scene): number | undefined {\n  const camera = scene.camera;\n  const ray = new Cesium.Ray(camera.position, camera.direction);\n  let target = scene.globe.pick(ray, scene);\n\n  if (!target) {\n    // no tiles in the area were loaded?\n    const ellipsoid = Cesium.Ellipsoid.WGS84;\n    const obj = Cesium.IntersectionTests.rayEllipsoid(ray, ellipsoid);\n    if (obj) {\n      target = Cesium.Ray.getPoint(ray, obj.start);\n    }\n  }\n\n  if (!target) {\n    return undefined;\n  }\n\n  const normal = new Cesium.Cartesian3();\n  Cesium.Ellipsoid.WGS84.geocentricSurfaceNormal(target, normal);\n\n  const angleBetween = signedAngleBetween;\n  const angle = angleBetween(camera.direction, normal, camera.right) - Math.PI;\n  return Cesium.Math.convertLongitudeRange(angle);\n}\n\n\n/**\n * Compute the ray from the camera to the bottom-center of the screen.\n */\nexport function bottomFovRay(scene: Scene): Ray {\n  const camera = scene.camera;\n  // @ts-ignore TS2341\n  const fovy2 = camera.frustum.fovy / 2;\n  const direction = camera.direction;\n  const rotation = Cesium.Quaternion.fromAxisAngle(camera.right, fovy2);\n  const matrix = Cesium.Matrix3.fromQuaternion(rotation);\n  const vector = new Cesium.Cartesian3();\n  Cesium.Matrix3.multiplyByVector(matrix, direction, vector);\n  return new Cesium.Ray(camera.position, vector);\n}\n\n\n/**\n * Compute the angle between two Cartesian3.\n */\nexport function signedAngleBetween(first: Cartesian3, second: Cartesian3, normal: Cartesian3): number {\n  // We are using the dot for the angle.\n  // Then the cross and the dot for the sign.\n  const a = new Cesium.Cartesian3();\n  const b = new Cesium.Cartesian3();\n  const c = new Cesium.Cartesian3();\n  Cesium.Cartesian3.normalize(first, a);\n  Cesium.Cartesian3.normalize(second, b);\n  Cesium.Cartesian3.cross(a, b, c);\n\n  const cosine = Cesium.Cartesian3.dot(a, b);\n  const sine = Cesium.Cartesian3.magnitude(c);\n\n  // Sign of the vector product and the orientation normal\n  const sign = Cesium.Cartesian3.dot(normal, c);\n  const angle = Math.atan2(sine, cosine);\n  return sign >= 0 ? angle : -angle;\n}\n\n\n/**\n * Compute the rotation angle around a given point, needed to reach the\n * zenith position.\n * At a zenith position, the camera direction is going througth the earth\n * center and the frustrum bottom ray is going through the chosen pivot\n * point.\n * The bottom-center of the screen is a good candidate for the pivot point.\n */\nexport function computeAngleToZenith(scene: Scene, pivot: Cartesian3): number {\n  // This angle is the sum of the angles 'fy' and 'a', which are defined\n  // using the pivot point and its surface normal.\n  //        Zenith |    camera\n  //           \\   |   /\n  //            \\fy|  /\n  //             \\ |a/\n  //              \\|/pivot\n  const camera = scene.camera;\n  // @ts-ignore TS2341\n  const fy = camera.frustum.fovy / 2;\n  const ray = bottomFovRay(scene);\n  const direction = Cesium.Cartesian3.clone(ray.direction);\n  Cesium.Cartesian3.negate(direction, direction);\n\n  const normal = new Cesium.Cartesian3();\n  Cesium.Ellipsoid.WGS84.geocentricSurfaceNormal(pivot, normal);\n\n  const left = new Cesium.Cartesian3();\n  Cesium.Cartesian3.negate(camera.right, left);\n\n  const a = signedAngleBetween(normal, direction, left);\n  return a + fy;\n}\n\n\n/**\n * Convert an OpenLayers extent to a Cesium rectangle.\n * @param {ol.Extent} extent Extent.\n * @param {ol.ProjectionLike} projection Extent projection.\n * @return {Cesium.Rectangle} The corresponding Cesium rectangle.\n */\nexport function extentToRectangle(extent: Extent, projection: ProjectionLike) {\n  if (extent && projection) {\n    const ext = transformExtent(extent, projection, 'EPSG:4326');\n    return Cesium.Rectangle.fromDegrees(ext[0], ext[1], ext[2], ext[3]);\n  } else {\n    return null;\n  }\n}\n\nexport function sourceToImageryProvider(\n    olMap: Map,\n    source: Source,\n    viewProj: Projection,\n    olLayer: BaseLayer\n): olcsCoreOLImageryProvider | MVTImageryProvider | SingleTileImageryProvider {\n  const skip = source.get('olcs_skip');\n  if (skip) {\n    return null;\n  }\n  let provider = null;\n  // Convert ImageWMS to TileWMS\n  if (source instanceof olSourceImageWMS && source.getUrl() &&\n  source.getImageLoadFunction() === defaultImageLoadFunction) {\n    const sourceProps = {\n      'olcs.proxy': source.get('olcs.proxy'),\n      'olcs.extent': source.get('olcs.extent'),\n      'olcs.projection': source.get('olcs.projection'),\n      'olcs.imagesource': source\n    };\n    source = new olSourceTileWMS({\n      url: source.getUrl(),\n      attributions: source.getAttributions(),\n      projection: source.getProjection(),\n      params: source.getParams()\n    });\n    source.setProperties(sourceProps);\n  }\n\n  if (source instanceof olSourceTileImage) {\n    let projection = getSourceProjection(source);\n\n    if (!projection) {\n    // if not explicit, assume the same projection as view\n      projection = viewProj;\n    }\n\n    if (isCesiumProjection(projection)) {\n      provider = new olcsCoreOLImageryProvider(olMap, source, viewProj);\n    }\n    // Projection not supported by Cesium\n    else {\n      return null;\n    }\n  } else if (source instanceof olSourceImageStatic) {\n    let projection = getSourceProjection(source);\n    if (!projection) {\n      projection = viewProj;\n    }\n    if (isCesiumProjection(projection)) {\n      const rectangle: Rectangle = Cesium.Rectangle.fromDegrees(\n          source.getImageExtent()[0],\n          source.getImageExtent()[1],\n          source.getImageExtent()[2],\n          source.getImageExtent()[3],\n          new Cesium.Rectangle()\n      );\n      provider = new Cesium.SingleTileImageryProvider({\n        url: source.getUrl(),\n        rectangle\n      });\n    }\n    // Projection not supported by Cesium\n    else {\n      return null;\n    }\n  } else if (source instanceof olSourceVectorTile && olLayer instanceof VectorTileLayer) {\n    let projection = getSourceProjection(source);\n\n    if (!projection) {\n      projection = viewProj;\n    }\n    if (skip === false) {\n    // MVT is experimental, it should be whitelisted to be synchronized\n      const fromCode = projection.getCode().split(':')[1];\n      // @ts-ignore TS2341\n      const urls = source.urls.map(u => u.replace(fromCode, '3857'));\n      const extent = olLayer.getExtent();\n      const rectangle = extentToRectangle(extent, projection);\n      const minimumLevel = source.get('olcs_minimumLevel');\n      const attributionsFunction = source.getAttributions();\n      const styleFunction = olLayer.getStyleFunction();\n      let credit;\n      if (extent && attributionsFunction) {\n        const center = getExtentCenter(extent);\n        credit = attributionsFunctionToCredits(attributionsFunction, 0, center, extent)[0];\n      }\n\n      provider = new MVTImageryProvider({\n        credit,\n        rectangle,\n        minimumLevel,\n        styleFunction,\n        urls\n      });\n      return provider;\n    }\n    return null; // FIXME: it is disabled by default right now\n  } else {\n    // sources other than TileImage|Imageexport function are currently not supported\n    return null;\n  }\n  return provider;\n}\n\n/**\n * Creates Cesium.ImageryLayer best corresponding to the given ol.layer.Layer.\n * Only supports raster layers and export function images\n */\nexport function tileLayerToImageryLayer(olMap: Map, olLayer: BaseLayer, viewProj: Projection): ImageryLayer | null {\n\n  if (!(olLayer instanceof olLayerTile) && !(olLayer instanceof olLayerImage) &&\n  !(olLayer instanceof VectorTileLayer)) {\n    return null;\n  }\n\n  const source = olLayer.getSource();\n  if (!source) {\n    return null;\n  }\n  let provider = source.get('olcs_provider');\n  if (!provider) {\n    provider = sourceToImageryProvider(olMap, source, viewProj, olLayer);\n  }\n  if (!provider) {\n    return null;\n  }\n\n  const layerOptions: {rectangle?: Rectangle} = {};\n\n  const forcedExtent = (olLayer.get('olcs.extent'));\n  const ext = forcedExtent || olLayer.getExtent();\n  if (ext) {\n    layerOptions.rectangle = extentToRectangle(ext, viewProj);\n  }\n\n  const cesiumLayer = new Cesium.ImageryLayer(provider, layerOptions);\n  return cesiumLayer;\n}\n\n\n/**\n * Synchronizes the layer rendering properties (opacity, visible)\n * to the given Cesium ImageryLayer.\n */\nexport function updateCesiumLayerProperties(olLayerWithParents: LayerWithParents, csLayer: ImageryLayer) {\n  let opacity = 1;\n  let visible = true;\n  [olLayerWithParents.layer].concat(olLayerWithParents.parents).forEach((olLayer) => {\n    const layerOpacity = olLayer.getOpacity();\n    if (layerOpacity !== undefined) {\n      opacity *= layerOpacity;\n    }\n    const layerVisible = olLayer.getVisible();\n    if (layerVisible !== undefined) {\n      visible = visible && layerVisible;\n    }\n  });\n  csLayer.alpha = opacity;\n  csLayer.show = visible;\n}\n\n\n/**\n * Convert a 2D or 3D OpenLayers coordinate to Cesium.\n */\nexport function ol4326CoordinateToCesiumCartesian(coordinate: Coordinate): Cartesian3 {\n  const coo = coordinate;\n  return coo.length > 2 ?\n    Cesium.Cartesian3.fromDegrees(coo[0], coo[1], coo[2]) :\n    Cesium.Cartesian3.fromDegrees(coo[0], coo[1]);\n}\n\n\n/**\n * Convert an array of 2D or 3D OpenLayers coordinates to Cesium.\n */\nexport function ol4326CoordinateArrayToCsCartesians(coordinates: Coordinate[]): Cartesian3[] {\n  console.assert(coordinates !== null);\n  const toCartesian = ol4326CoordinateToCesiumCartesian;\n  const cartesians = [];\n  for (let i = 0; i < coordinates.length; ++i) {\n    cartesians.push(toCartesian(coordinates[i]));\n  }\n  return cartesians;\n}\n\n\n/**\n * Reproject an OpenLayers geometry to EPSG:4326 if needed.\n * The geometry will be cloned only when original projection is not EPSG:4326\n * and the properties will be shallow copied.\n */\nexport function olGeometryCloneTo4326<T extends Geometry>(geometry: T, projection: ProjectionLike): T {\n  console.assert(projection);\n\n  const proj4326 = getProjection('EPSG:4326');\n  const proj = getProjection(projection);\n  if (proj.getCode() !== proj4326.getCode()) {\n    const properties = geometry.getProperties();\n    geometry = geometry.clone() as T;\n    geometry.transform(proj, proj4326);\n    geometry.setProperties(properties);\n  }\n  return geometry;\n}\n\n\n/**\n * Convert an OpenLayers color to Cesium.\n */\nexport function convertColorToCesium(olColor: OLColor | CanvasGradient | CanvasPattern | string): Color | ImageMaterialProperty {\n  olColor = olColor || 'black';\n  if (Array.isArray(olColor)) {\n    return new Cesium.Color(\n        Cesium.Color.byteToFloat(olColor[0]),\n        Cesium.Color.byteToFloat(olColor[1]),\n        Cesium.Color.byteToFloat(olColor[2]),\n        olColor[3]\n    );\n  } else if (typeof olColor == 'string') {\n    return Cesium.Color.fromCssColorString(olColor);\n  } else if (olColor instanceof CanvasPattern || olColor instanceof CanvasGradient) {\n    // Render the CanvasPattern/CanvasGradient into a canvas that will be sent to Cesium as material\n    const canvas = document.createElement('canvas');\n    const ctx = canvas.getContext('2d');\n    canvas.width = canvas.height = 256;\n    ctx.fillStyle = olColor;\n    ctx.fillRect(0, 0, canvas.width, canvas.height);\n    return new Cesium.ImageMaterialProperty({\n      image: canvas\n    });\n  }\n  console.assert(false, 'impossible');\n}\n\n\n/**\n * Convert an OpenLayers url to Cesium.\n */\nexport function convertUrlToCesium(url: string): CesiumUrlDefinition {\n  let subdomains = '';\n  const re = /\\{(\\d|[a-z])-(\\d|[a-z])\\}/;\n  const match = re.exec(url);\n  if (match) {\n    url = url.replace(re, '{s}');\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      subdomains += String.fromCharCode(charCode);\n    }\n  }\n  return {\n    url,\n    subdomains\n  };\n}\n\n\n/**\n * Animate the return to a top-down view from the zenith.\n * The camera is rotated to orient to the North.\n */\nexport function resetToNorthZenith(map: Map, scene: Scene): Promise<undefined> {\n  return new Promise((resolve, reject) => {\n    const camera = scene.camera;\n    const pivot = pickBottomPoint(scene);\n    if (!pivot) {\n      reject('Could not get bottom pivot');\n      return;\n    }\n\n    const currentHeading = map.getView().getRotation();\n    if (currentHeading === undefined) {\n      reject('The view is not initialized');\n      return;\n    }\n    const angle = computeAngleToZenith(scene, pivot);\n\n    // Point to North\n    setHeadingUsingBottomCenter(scene, currentHeading, pivot);\n\n    // Go to zenith\n    const transform = Cesium.Matrix4.fromTranslation(pivot);\n    const axis = camera.right;\n    const options: RotateAroundAxisOption = {\n      callback: () => {\n        const view = map.getView();\n        normalizeView(view);\n        resolve(undefined);\n      }\n    };\n    rotateAroundAxis(camera, -angle, axis, transform, options);\n  });\n}\n\n\n/**\n * @param {!Cesium.Scene} scene\n * @param {number} angle in radian\n * @return {Promise<undefined>}\n * @api\n */\nexport function rotateAroundBottomCenter(scene: Scene, angle: number): Promise<undefined> {\n  return new Promise((resolve, reject) => {\n    const camera = scene.camera;\n    const pivot = pickBottomPoint(scene);\n    if (!pivot) {\n      reject('could not get bottom pivot');\n      return;\n    }\n\n    const options: RotateAroundAxisOption = {callback: () => resolve(undefined)};\n    const transform = Cesium.Matrix4.fromTranslation(pivot);\n    const axis = camera.right;\n    rotateAroundAxis(camera, -angle, axis, transform, options);\n  });\n}\n\n\n/**\n * Set the OpenLayers view to a specific rotation and\n * the nearest resolution.\n */\nexport function normalizeView(view: View, angle = 0) {\n  const resolution = view.getResolution();\n  view.setRotation(angle);\n\n  // @ts-ignore TS2341\n  if (view.constrainResolution) {\n    // @ts-ignore TS2341\n    view.setResolution(view.constrainResolution(resolution));\n  } else {\n    view.setResolution(view.getConstrainedResolution(resolution));\n  }\n}\n\n/**\n * Check if the given projection is managed by Cesium (WGS84 or Mercator Spheric)\n */\nexport function isCesiumProjection(projection: Projection): boolean {\n  const is3857 = projection.getCode() === 'EPSG:3857';\n  const is4326 = projection.getCode() === 'EPSG:4326';\n  return is3857 || is4326;\n}\n\nexport function attributionsFunctionToCredits(\n    attributionsFunction: Attribution | null,\n    zoom: number,\n    center: Coordinate,\n    extent: Extent\n) {\n\n  if (!attributionsFunction) {\n    return [];\n  }\n  let attributions = attributionsFunction({\n    viewState: {zoom, center, projection: undefined, resolution: undefined, rotation: undefined},\n    extent,\n  });\n  if (!Array.isArray(attributions)) {\n    attributions = [attributions];\n  }\n\n  return attributions.map(html => new Cesium.Credit(html, true));\n}\n\n/**\n * calculate the distance between camera and centerpoint based on the resolution and latitude value\n */\nexport function calcDistanceForResolution(\n    resolution: number,\n    latitude: number,\n    scene: Scene,\n    projection: Projection\n): number {\n  const canvas = scene.canvas;\n  const camera = scene.camera;\n  // @ts-ignore TS2341\n  const fovy = camera.frustum.fovy; // vertical field of view\n  console.assert(!isNaN(fovy));\n  const metersPerUnit = projection.getMetersPerUnit();\n\n  // number of \"map units\" visible in 2D (vertically)\n  const visibleMapUnits = resolution * canvas.clientHeight;\n\n  // The metersPerUnit does not take latitude into account, but it should\n  // be lower with increasing latitude -- we have to compensate.\n  // In 3D it is not possible to maintain the resolution at more than one point,\n  // so it only makes sense to use the latitude of the \"target\" point.\n  const relativeCircumference = Math.cos(Math.abs(latitude));\n\n  // how many meters should be visible in 3D\n  const visibleMeters = visibleMapUnits * metersPerUnit * relativeCircumference;\n\n  // distance required to view the calculated length in meters\n  //\n  //  fovy/2\n  //    |\\\n  //  x | \\\n  //    |--\\\n  // visibleMeters/2\n  const requiredDistance = (visibleMeters / 2) / Math.tan(fovy / 2);\n\n  // NOTE: This calculation is not absolutely precise, because metersPerUnit\n  // is a great simplification. It does not take ellipsoid/terrain into account.\n\n  return requiredDistance;\n}\n\n/**\n * calculate the resolution based on a distance(camera to position) and latitude value\n */\nexport function calcResolutionForDistance(distance: number, latitude: number, scene: Scene, projection: Projection): number {\n  // See the reverse calculation (calcDistanceForResolution) for details\n  const canvas = scene.canvas;\n  const camera = scene.camera;\n  // @ts-ignore TS2341\n  const fovy = camera.frustum.fovy; // vertical field of view\n  console.assert(!isNaN(fovy));\n  const metersPerUnit = projection.getMetersPerUnit();\n\n  const visibleMeters = 2 * distance * Math.tan(fovy / 2);\n  const relativeCircumference = Math.cos(Math.abs(latitude));\n  const visibleMapUnits = visibleMeters / metersPerUnit / relativeCircumference;\n  const resolution = visibleMapUnits / canvas.clientHeight;\n\n  return resolution;\n}\n\n/**\n * Constrain the camera so that it stays close to the bounding sphere of the map extent.\n * Near the ground the allowed distance is shorter.\n */\nexport function limitCameraToBoundingSphere(camera: Camera, boundingSphere: BoundingSphere, ratio: (height: number) => number): () => void {\n  let blockLimiter = false;\n  return function() {\n    if (!blockLimiter) {\n      const position = camera.position;\n      const carto = Cesium.Cartographic.fromCartesian(position);\n      if (Cesium.Cartesian3.distance(boundingSphere.center, position) > boundingSphere.radius * ratio(carto.height)) {\n        // @ts-ignore TS2339: FIXME, there is no flying property in Camera\n        const currentlyFlying = camera.flying;\n        if (currentlyFlying === true) {\n          // There is a flying property and its value is true\n          return;\n        } else {\n          blockLimiter = true;\n          const unblockLimiter = () => (blockLimiter = false);\n          camera.flyToBoundingSphere(boundingSphere, {\n            complete: unblockLimiter,\n            cancel: unblockLimiter,\n          });\n        }\n      }\n    }\n  };\n}\n","import type {Scene} from 'cesium';\nimport type OLCesium from './OLCesium';\n\n/**\n * By default Cesium (used to?) renders as often as possible.\n * This is a waste of resources (CPU/GPU/battery).\n * An alternative mechanism in Cesium is on-demand rendering.\n * This class makes use of this alternative method and add some additionnal render points.\n */\nexport default class AutoRenderLoop {\n  ol3d: OLCesium;\n  private scene_: Scene;\n  private canvas_: HTMLCanvasElement;\n  private _boundNotifyRepaintRequired: typeof this.notifyRepaintRequired;\n  private repaintEventNames_ = [\n    'mousemove', 'mousedown', 'mouseup',\n    'touchstart', 'touchend', 'touchmove',\n    'pointerdown', 'pointerup', 'pointermove',\n    'wheel'\n  ] as const;\n\n  /**\n   * @param ol3d\n   */\n  constructor(ol3d: OLCesium) {\n    this.ol3d = ol3d;\n    this.scene_ = ol3d.getCesiumScene();\n    this.canvas_ = this.scene_.canvas;\n    this._boundNotifyRepaintRequired = this.notifyRepaintRequired.bind(this);\n    this.enable();\n  }\n\n  /**\n   * Enable.\n   */\n  enable() {\n    this.scene_.requestRenderMode = true;\n    this.scene_.maximumRenderTimeChange = 1000;\n    for (const repaintKey of this.repaintEventNames_) {\n      this.canvas_.addEventListener(repaintKey, this._boundNotifyRepaintRequired, false);\n    }\n\n    window.addEventListener('resize', this._boundNotifyRepaintRequired, false);\n\n    // Listen for changes on the layer group\n    this.ol3d.getOlMap().getLayerGroup().on('change', this._boundNotifyRepaintRequired);\n  }\n\n  /**\n   * Disable.\n   */\n  disable() {\n    for (const repaintKey of this.repaintEventNames_) {\n      this.canvas_.removeEventListener(repaintKey, this._boundNotifyRepaintRequired, false);\n    }\n\n    window.removeEventListener('resize', this._boundNotifyRepaintRequired, false);\n\n    this.ol3d.getOlMap().getLayerGroup().un('change', this._boundNotifyRepaintRequired);\n    this.scene_.requestRenderMode = false;\n  }\n\n  /**\n   * Restart render loop.\n   * Force a restart of the render loop.\n   */\n  restartRenderLoop() {\n    this.notifyRepaintRequired();\n  }\n\n  notifyRepaintRequired() {\n    this.scene_.requestRender();\n  }\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = ol.Observable;","/**\n * Converts radians to to degrees.\n *\n * @param angleInRadians Angle in radians.\n * @return Angle in degrees.\n */\nexport function toDegrees(angleInRadians: number): number {\n  return angleInRadians * 180 / Math.PI;\n}\n\n\n/**\n * Converts degrees to radians.\n *\n * @param angleInDegrees Angle in degrees.\n * @return Angle in radians.\n */\nexport function toRadians(angleInDegrees: number): number {\n  return angleInDegrees * Math.PI / 180;\n}\n","import {unByKey as olObservableUnByKey} from 'ol/Observable.js';\nimport {toRadians, toDegrees} from './math';\nimport {getTransform} from 'ol/proj.js';\nimport {pickCenterPoint, calcDistanceForResolution, calcResolutionForDistance} from './core';\nimport type {Map, View} from 'ol';\nimport type {Scene, Camera as CesiumCamera, Matrix4, HeadingPitchRollValues} from 'cesium';\nimport type {EventsKey} from 'ol/events.js';\n\n/**\n * @param input Input coordinate array.\n * @param opt_output Output array of coordinate values.\n * @param opt_dimension Dimension.\n * @return Input coordinate array (same array as input).\n */\nexport function identityProjection(input: number[], opt_output?: number[], opt_dimension?: number): number[] {\n  const dim = opt_dimension || input.length;\n  if (opt_output) {\n    for (let i = 0; i < dim; ++i) {\n      opt_output[i] = input[i];\n    }\n  }\n  return input;\n}\n\nexport default class Camera {\n  private scene_: Scene;\n  private cam_: CesiumCamera;\n  private map_: Map;\n  private view_: View;\n\n  private viewListenKey_: EventsKey = null;\n\n  private toLonLat_ = identityProjection;\n  private fromLonLat_ = identityProjection;\n\n  /**\n   * 0 -- topdown, PI/2 -- the horizon\n   */\n  private tilt_: number = 0;\n  private distance_ = 0;\n  private lastCameraViewMatrix_: Matrix4 = null;\n\n  /**\n   * This is used to discard change events on view caused by updateView method.\n   */\n  private viewUpdateInProgress_ = false;\n\n  /**\n   * This object takes care of additional 3d-specific properties of the view and\n   * ensures proper synchronization with the underlying raw Cesium.Camera object.\n   */\n  constructor(scene: Scene, map: Map) {\n    this.scene_ = scene;\n    this.cam_ = scene.camera;\n    this.map_ = map;\n    this.map_.on('change:view', (e) => {\n      this.setView_(this.map_.getView());\n    });\n    this.setView_(this.map_.getView());\n  }\n\n  destroy() {\n    olObservableUnByKey(this.viewListenKey_);\n    this.viewListenKey_ = null;\n  }\n\n  /**\n   * @param {?ol.View} view New view to use.\n   * @private\n   */\n  setView_(view: View | undefined) {\n    if (this.view_) {\n      olObservableUnByKey(this.viewListenKey_);\n      this.viewListenKey_ = null;\n    }\n\n    this.view_ = view;\n    if (view) {\n      const toLonLat = getTransform(view.getProjection(), 'EPSG:4326');\n      const fromLonLat = getTransform('EPSG:4326', view.getProjection());\n      console.assert(toLonLat && fromLonLat);\n\n      this.toLonLat_ = toLonLat;\n      this.fromLonLat_ = fromLonLat;\n\n      this.viewListenKey_ = view.on('propertychange', e => this.handleViewChangedEvent_());\n\n      this.readFromView();\n    } else {\n      this.toLonLat_ = identityProjection;\n      this.fromLonLat_ = identityProjection;\n    }\n  }\n\n  private handleViewChangedEvent_() {\n    if (!this.viewUpdateInProgress_) {\n      this.readFromView();\n    }\n  }\n\n  /**\n   * @deprecated\n   * @param heading In radians.\n   */\n  setHeading(heading: number) {\n    if (!this.view_) {\n      return;\n    }\n\n    this.view_.setRotation(heading);\n  }\n\n  /**\n   * @deprecated\n   * @return Heading in radians.\n   */\n  getHeading(): number|undefined {\n    if (!this.view_) {\n      return undefined;\n    }\n    const rotation = this.view_.getRotation();\n    return rotation || 0;\n  }\n\n  /**\n   * @param tilt In radians.\n   */\n  setTilt(tilt: number) {\n    this.tilt_ = tilt;\n    this.updateCamera_();\n  }\n\n  /**\n   * @return Tilt in radians.\n   */\n  getTilt(): number {\n    return this.tilt_;\n  }\n\n  /**\n   * @param distance In meters.\n   */\n  setDistance(distance: number) {\n    this.distance_ = distance;\n    this.updateCamera_();\n    this.updateView();\n  }\n\n  /**\n   * @return Distance in meters.\n   */\n  getDistance(): number {\n    return this.distance_;\n  }\n\n  /**\n   * @deprecated\n   * Shortcut for ol.View.setCenter().\n   * @param center Same projection as the ol.View.\n   */\n  setCenter(center: number[]) {\n    if (!this.view_) {\n      return;\n    }\n    this.view_.setCenter(center);\n  }\n\n  /**\n   * @deprecated\n   * Shortcut for ol.View.getCenter().\n   * @return {ol.Coordinate|undefined} Same projection as the ol.View.\n   * @api\n   */\n  getCenter() {\n    if (!this.view_) {\n      return undefined;\n    }\n    return this.view_.getCenter();\n  }\n\n  /**\n   * Sets the position of the camera.\n   * @param position Same projection as the ol.View.\n   */\n  setPosition(position: number[]) {\n    if (!this.toLonLat_) {\n      return;\n    }\n    const ll = this.toLonLat_(position);\n    console.assert(ll);\n\n    const carto = new Cesium.Cartographic(\n        toRadians(ll[0]),\n        toRadians(ll[1]),\n        this.getAltitude());\n\n    this.cam_.setView({\n      destination: Cesium.Ellipsoid.WGS84.cartographicToCartesian(carto)\n    });\n    this.updateView();\n  }\n\n  /**\n   * Calculates position under the camera.\n   * @return Coordinates in same projection as the ol.View.\n   * @api\n   */\n  getPosition(): number[] | undefined {\n    if (!this.fromLonLat_) {\n      return undefined;\n    }\n    const carto = Cesium.Ellipsoid.WGS84.cartesianToCartographic(this.cam_.position);\n\n    const pos = this.fromLonLat_([\n      toDegrees(carto.longitude),\n      toDegrees(carto.latitude)\n    ]);\n    console.assert(pos);\n    return pos;\n  }\n\n  /**\n   * @param altitude In meters.\n   */\n  setAltitude(altitude: number) {\n    const carto = Cesium.Ellipsoid.WGS84.cartesianToCartographic(\n        this.cam_.position);\n    carto.height = altitude;\n    this.cam_.position = Cesium.Ellipsoid.WGS84.cartographicToCartesian(carto);\n\n    this.updateView();\n  }\n\n  /**\n   * @return Altitude in meters.\n   */\n  getAltitude(): number {\n    const carto = Cesium.Ellipsoid.WGS84.cartesianToCartographic(\n        this.cam_.position);\n\n    return carto.height;\n  }\n\n  /**\n   * Updates the state of the underlying Cesium.Camera\n   * according to the current values of the properties.\n   */\n  private updateCamera_() {\n    if (!this.view_ || !this.toLonLat_) {\n      return;\n    }\n    const center = this.view_.getCenter();\n    if (!center) {\n      return;\n    }\n    const ll = this.toLonLat_(center);\n    console.assert(ll);\n\n    const carto = new Cesium.Cartographic(toRadians(ll[0]),\n        toRadians(ll[1]));\n    if (this.scene_.globe) {\n      const height = this.scene_.globe.getHeight(carto);\n      carto.height = height || 0;\n    }\n\n    const destination = Cesium.Ellipsoid.WGS84.cartographicToCartesian(carto);\n\n    const orientation: HeadingPitchRollValues = {\n      pitch: this.tilt_ - Cesium.Math.PI_OVER_TWO,\n      heading: -this.view_.getRotation(),\n      roll: undefined\n    };\n    this.cam_.setView({\n      destination,\n      orientation\n    });\n\n    this.cam_.moveBackward(this.distance_);\n\n    this.checkCameraChange(true);\n  }\n\n  /**\n   * Calculates the values of the properties from the current ol.View state.\n   */\n  readFromView() {\n    if (!this.view_ || !this.toLonLat_) {\n      return;\n    }\n    const center = this.view_.getCenter();\n    if (center === undefined || center === null) {\n      return;\n    }\n    const ll = this.toLonLat_(center);\n    console.assert(ll);\n\n    const resolution = this.view_.getResolution();\n    this.distance_ = this.calcDistanceForResolution(\n        resolution || 0, toRadians(ll[1]));\n\n    this.updateCamera_();\n  }\n\n  /**\n   * Calculates the values of the properties from the current Cesium.Camera state.\n   * Modifies the center, resolution and rotation properties of the view.\n   */\n  updateView() {\n    if (!this.view_ || !this.fromLonLat_) {\n      return;\n    }\n    this.viewUpdateInProgress_ = true;\n\n    // target & distance\n    const ellipsoid = Cesium.Ellipsoid.WGS84;\n    const scene = this.scene_;\n    const target = pickCenterPoint(scene);\n\n    let bestTarget = target;\n    if (!bestTarget) {\n      //TODO: how to handle this properly ?\n      const globe = scene.globe;\n      const carto = this.cam_.positionCartographic.clone();\n      const height = globe.getHeight(carto);\n      carto.height = height || 0;\n      bestTarget = Cesium.Ellipsoid.WGS84.cartographicToCartesian(carto);\n    }\n    this.distance_ = Cesium.Cartesian3.distance(bestTarget, this.cam_.position);\n    const bestTargetCartographic = ellipsoid.cartesianToCartographic(bestTarget);\n    this.view_.setCenter(this.fromLonLat_([\n      toDegrees(bestTargetCartographic.longitude),\n      toDegrees(bestTargetCartographic.latitude)]));\n\n    // resolution\n    this.view_.setResolution(\n        this.calcResolutionForDistance(this.distance_,\n            bestTargetCartographic ? bestTargetCartographic.latitude : 0));\n\n\n    /*\n     * Since we are positioning the target, the values of heading and tilt\n     * need to be calculated _at the target_.\n     */\n    if (target) {\n      const pos = this.cam_.position;\n\n      // normal to the ellipsoid at the target\n      const targetNormal = new Cesium.Cartesian3();\n      ellipsoid.geocentricSurfaceNormal(target, targetNormal);\n\n      // vector from the target to the camera\n      const targetToCamera = new Cesium.Cartesian3();\n      Cesium.Cartesian3.subtract(pos, target, targetToCamera);\n      Cesium.Cartesian3.normalize(targetToCamera, targetToCamera);\n\n\n      // HEADING\n      const up = this.cam_.up;\n      const right = this.cam_.right;\n      const normal = new Cesium.Cartesian3(-target.y, target.x, 0); // what is it?\n      const heading = Cesium.Cartesian3.angleBetween(right, normal);\n      const cross = Cesium.Cartesian3.cross(target, up, new Cesium.Cartesian3());\n      const orientation = cross.z;\n\n      this.view_.setRotation((orientation < 0 ? heading : -heading));\n\n      // TILT\n      const tiltAngle = Math.acos(\n          Cesium.Cartesian3.dot(targetNormal, targetToCamera));\n      this.tilt_ = isNaN(tiltAngle) ? 0 : tiltAngle;\n    } else {\n      // fallback when there is no target\n      this.view_.setRotation(this.cam_.heading);\n      this.tilt_ = -this.cam_.pitch + Math.PI / 2;\n    }\n\n    this.viewUpdateInProgress_ = false;\n  }\n\n  /**\n   * Check if the underlying camera state has changed and ensure synchronization.\n   * @param opt_dontSync Do not synchronize the view.\n   */\n  checkCameraChange(opt_dontSync?: boolean) {\n    const old = this.lastCameraViewMatrix_;\n    const current = this.cam_.viewMatrix;\n\n    if (!old || !Cesium.Matrix4.equalsEpsilon(old, current, 1e-7)) {\n      this.lastCameraViewMatrix_ = current.clone();\n      if (opt_dontSync !== true) {\n        this.updateView();\n      }\n    }\n  }\n\n  /**\n   * calculate the distance between camera and centerpoint based on the resolution and latitude value\n   * @param resolution Number of map units per pixel.\n   * @param latitude Latitude in radians.\n   * @return The calculated distance.\n   */\n  calcDistanceForResolution(resolution: number, latitude: number): number {\n    return calcDistanceForResolution(resolution, latitude, this.scene_, this.view_.getProjection());\n  }\n\n  /**\n   * calculate the resolution based on a distance(camera to position) and latitude value\n   * @param distance\n   * @param latitude\n   * @return} The calculated resolution.\n   */\n  calcResolutionForDistance(distance: number, latitude: number): number {\n    return calcResolutionForDistance(distance, latitude, this.scene_, this.view_.getProjection());\n  }\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = ol.layer.Group;","import {unByKey as olObservableUnByKey} from 'ol/Observable.js';\nimport LayerGroup from 'ol/layer/Group.js';\nimport {getUid} from './util';\nimport type Map from 'ol/Map.js';\nimport type {Scene, ImageryLayer} from 'cesium';\nimport type View from 'ol/View.js';\nimport type Collection from 'ol/Collection.js';\nimport type BaseLayer from 'ol/layer/Base.js';\nimport type {EventsKey} from 'ol/events.js';\nimport type {LayerWithParents} from './core';\nimport type VectorLayerCounterpart from './core/VectorLayerCounterpart';\n\n\nexport default abstract class AbstractSynchronizer<T extends ImageryLayer | VectorLayerCounterpart> {\n  protected map: Map;\n  protected view: View;\n  protected scene: Scene;\n  protected olLayers: Collection<BaseLayer>;\n  mapLayerGroup: LayerGroup;\n  /**\n   * Map of OpenLayers layer ids (from getUid) to the Cesium ImageryLayers.\n   * Null value means, that we are unable to create equivalent layers.\n   */\n  protected layerMap: Record<string, Array<T>> = {};\n  /**\n   * Map of listen keys for OpenLayers layer layers ids (from getUid).\n   */\n  protected olLayerListenKeys: Record<string, Array<EventsKey>> = {};\n  /**\n   * Map of listen keys for OpenLayers layer groups ids (from getUid).\n   */\n  private olGroupListenKeys_: Record<string, Array<EventsKey>> = {};\n\n  protected constructor(map: Map, scene: Scene) {\n    this.map = map;\n    this.view = map.getView();\n    this.scene = scene;\n    this.olLayers = map.getLayerGroup().getLayers();\n    this.mapLayerGroup = map.getLayerGroup();\n  }\n\n  /**\n   * Destroy all and perform complete synchronization of the layers.\n   */\n  synchronize() {\n    this.destroyAll();\n    this.addLayers_(this.mapLayerGroup);\n  }\n\n  /**\n   * Order counterparts using the same algorithm as the Openlayers renderer:\n   * z-index then original sequence order.\n   */\n  protected orderLayers() {\n    // Ordering logics is handled in subclasses.\n  }\n\n  /**\n   * Add a layer hierarchy.\n   */\n  private addLayers_(root: BaseLayer) {\n    const fifo: LayerWithParents[] = [{\n      layer: root,\n      parents: []\n    }];\n    while (fifo.length > 0) {\n      const olLayerWithParents = fifo.splice(0, 1)[0];\n      const olLayer = olLayerWithParents.layer;\n      const olLayerId = getUid(olLayer).toString();\n      this.olLayerListenKeys[olLayerId] = [];\n      console.assert(!this.layerMap[olLayerId]);\n\n      let cesiumObjects = null;\n      if (olLayer instanceof LayerGroup) {\n        this.listenForGroupChanges_(olLayer);\n        if (olLayer !== this.mapLayerGroup) {\n          cesiumObjects = this.createSingleLayerCounterparts(olLayerWithParents);\n        }\n        if (!cesiumObjects) {\n          olLayer.getLayers().forEach((l) => {\n            if (l) {\n              const newOlLayerWithParents: LayerWithParents = {\n                layer: l,\n                parents: olLayer === this.mapLayerGroup ?\n                  [] :\n                  [olLayerWithParents.layer].concat(olLayerWithParents.parents)\n              };\n              fifo.push(newOlLayerWithParents);\n            }\n          });\n        }\n      } else {\n        cesiumObjects = this.createSingleLayerCounterparts(olLayerWithParents);\n        if (!cesiumObjects) {\n          // keep an eye on the layers that once failed to be added (might work when the layer is updated)\n          // for example when a source is set after the layer is added to the map\n          const layerId = olLayerId;\n          const layerWithParents = olLayerWithParents;\n          const onLayerChange = () => {\n            const cesiumObjs = this.createSingleLayerCounterparts(layerWithParents);\n            if (cesiumObjs) {\n              // unsubscribe event listener\n              layerWithParents.layer.un('change', onLayerChange);\n              this.addCesiumObjects_(cesiumObjs, layerId, layerWithParents.layer);\n              this.orderLayers();\n            }\n          };\n          this.olLayerListenKeys[olLayerId].push(layerWithParents.layer.on('change', onLayerChange));\n        }\n      }\n      // add Cesium layers\n      if (cesiumObjects) {\n        this.addCesiumObjects_(cesiumObjects, olLayerId, olLayer);\n      }\n    }\n\n    this.orderLayers();\n  }\n\n  /**\n   * Add Cesium objects.\n   */\n  private addCesiumObjects_(cesiumObjects: Array<T>, layerId: string, layer: BaseLayer) {\n    this.layerMap[layerId] = cesiumObjects;\n    this.olLayerListenKeys[layerId].push(layer.on('change:zIndex', () => this.orderLayers()));\n    cesiumObjects.forEach((cesiumObject) => {\n      this.addCesiumObject(cesiumObject);\n    });\n  }\n\n  /**\n   * Remove and destroy a single layer.\n   * @param {ol.layer.Layer} layer\n   * @return {boolean} counterpart destroyed\n   */\n  private removeAndDestroySingleLayer_(layer: BaseLayer): boolean {\n    const uid = getUid(layer).toString();\n    const counterparts = this.layerMap[uid];\n    if (!!counterparts) {\n      counterparts.forEach((counterpart) => {\n        this.removeSingleCesiumObject(counterpart, false);\n        this.destroyCesiumObject(counterpart);\n      });\n      this.olLayerListenKeys[uid].forEach(olObservableUnByKey);\n      delete this.olLayerListenKeys[uid];\n    }\n    delete this.layerMap[uid];\n    return !!counterparts;\n  }\n\n  /**\n   * Unlisten a single layer group.\n   */\n  private unlistenSingleGroup_(group: LayerGroup) {\n    if (group === this.mapLayerGroup) {\n      return;\n    }\n    const uid = getUid(group).toString();\n    const keys = this.olGroupListenKeys_[uid];\n    keys.forEach((key) => {\n      olObservableUnByKey(key);\n    });\n    delete this.olGroupListenKeys_[uid];\n    delete this.layerMap[uid];\n  }\n\n  /**\n   * Remove layer hierarchy.\n   */\n  private removeLayer_(root: BaseLayer) {\n    if (!!root) {\n      const fifo = [root];\n      while (fifo.length > 0) {\n        const olLayer = fifo.splice(0, 1)[0];\n        const done = this.removeAndDestroySingleLayer_(olLayer);\n        if (olLayer instanceof LayerGroup) {\n          this.unlistenSingleGroup_(olLayer);\n          if (!done) {\n            // No counterpart for the group itself so removing\n            // each of the child layers.\n            olLayer.getLayers().forEach((l) => {\n              fifo.push(l);\n            });\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Register listeners for single layer group change.\n   */\n  private listenForGroupChanges_(group: LayerGroup) {\n    const uuid = getUid(group).toString();\n\n    console.assert(this.olGroupListenKeys_[uuid] === undefined);\n\n    const listenKeyArray: EventsKey[] = [];\n    this.olGroupListenKeys_[uuid] = listenKeyArray;\n\n    // only the keys that need to be relistened when collection changes\n    let contentKeys: EventsKey[] = [];\n    const listenAddRemove = (function() {\n      const collection = group.getLayers();\n      if (collection) {\n        contentKeys = [\n          collection.on('add', (event) => {\n            this.addLayers_(event.element);\n          }),\n          collection.on('remove', (event) => {\n            this.removeLayer_(event.element);\n          })\n        ];\n        listenKeyArray.push(...contentKeys);\n      }\n    }).bind(this);\n\n    listenAddRemove();\n\n    listenKeyArray.push(group.on('change:layers', (e) => {\n      contentKeys.forEach((el) => {\n        const i = listenKeyArray.indexOf(el);\n        if (i >= 0) {\n          listenKeyArray.splice(i, 1);\n        }\n        olObservableUnByKey(el);\n      });\n      listenAddRemove();\n    }));\n  }\n\n  /**\n   * Destroys all the created Cesium objects.\n   */\n  public destroyAll() {\n    this.removeAllCesiumObjects(true); // destroy\n    let objKey;\n    for (objKey in this.olGroupListenKeys_) {\n      const keys = this.olGroupListenKeys_[objKey];\n      keys.forEach(olObservableUnByKey);\n    }\n    for (objKey in this.olLayerListenKeys) {\n      this.olLayerListenKeys[objKey].forEach(olObservableUnByKey);\n    }\n    this.olGroupListenKeys_ = {};\n    this.olLayerListenKeys = {};\n    this.layerMap = {};\n  }\n\n  /**\n   * Adds a single Cesium object to the collection.\n   */\n  protected abstract addCesiumObject(object: T): void;\n\n  protected abstract destroyCesiumObject(object: T): void;\n\n  /**\n   * Remove single Cesium object from the collection.\n   */\n  protected abstract removeSingleCesiumObject(object: T, destroy: boolean): void;\n\n  protected abstract removeAllCesiumObjects(destroy: boolean): void;\n\n  protected abstract createSingleLayerCounterparts(olLayerWithParents: LayerWithParents): Array<T>;\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = ol.layer.BaseVector;","import type Map from 'ol/Map.js';\nimport {getUid} from './util';\nimport olcsAbstractSynchronizer from './AbstractSynchronizer';\nimport {type LayerWithParents, tileLayerToImageryLayer, updateCesiumLayerProperties} from './core';\nimport type {Scene, ImageryLayer, ImageryLayerCollection} from 'cesium';\nimport type BaseLayer from 'ol/layer/Base.js';\nimport type Projection from 'ol/proj/Projection.js';\nimport BaseVectorLayer from 'ol/layer/BaseVector.js';\nimport LayerGroup from 'ol/layer/Group.js';\n\nexport default class RasterSynchronizer extends olcsAbstractSynchronizer<ImageryLayer> {\n  private cesiumLayers_: ImageryLayerCollection;\n  private ourLayers_: ImageryLayerCollection;\n  /**\n   * This object takes care of one-directional synchronization of\n   * Openlayers raster layers to the given Cesium globe.\n   */\n  constructor(map: Map, scene: Scene) {\n    super(map, scene);\n\n    this.cesiumLayers_ = scene.imageryLayers;\n    this.ourLayers_ = new Cesium.ImageryLayerCollection();\n  }\n\n  addCesiumObject(object: ImageryLayer): void {\n    this.cesiumLayers_.add(object);\n    this.ourLayers_.add(object);\n  }\n\n  destroyCesiumObject(object: ImageryLayer): void {\n    object.destroy();\n  }\n\n  removeSingleCesiumObject(object: ImageryLayer, destroy: boolean): void {\n    this.cesiumLayers_.remove(object, destroy);\n    this.ourLayers_.remove(object, false);\n  }\n\n  removeAllCesiumObjects(destroy: boolean): void {\n    for (let i = 0; i < this.ourLayers_.length; ++i) {\n      this.cesiumLayers_.remove(this.ourLayers_.get(i), destroy);\n    }\n    this.ourLayers_.removeAll(false);\n  }\n\n  /**\n   * Creates an array of Cesium.ImageryLayer.\n   * May be overriden by child classes to implement custom behavior.\n   * The default implementation handles tiled imageries in EPSG:4326 or\n   * EPSG:3859.\n   */\n  protected convertLayerToCesiumImageries(olLayer: BaseLayer, viewProj: Projection): ImageryLayer[] {\n    const result = tileLayerToImageryLayer(this.map, olLayer, viewProj);\n    return result ? [result] : null;\n  }\n\n  createSingleLayerCounterparts(olLayerWithParents: LayerWithParents): ImageryLayer[] {\n    const olLayer = olLayerWithParents.layer;\n    const uid = getUid(olLayer).toString();\n    const viewProj = this.view.getProjection();\n    console.assert(viewProj);\n    const cesiumObjects = this.convertLayerToCesiumImageries(olLayer, viewProj);\n    if (cesiumObjects) {\n      const listenKeyArray = [];\n      [olLayerWithParents.layer].concat(olLayerWithParents.parents).forEach((olLayerItem) => {\n        listenKeyArray.push(olLayerItem.on(['change:opacity', 'change:visible'], () => {\n          // the compiler does not seem to be able to infer this\n          console.assert(cesiumObjects);\n          for (let i = 0; i < cesiumObjects.length; ++i) {\n            updateCesiumLayerProperties(olLayerWithParents, cesiumObjects[i]);\n          }\n        }));\n      });\n\n      if (olLayer instanceof BaseVectorLayer) {\n        let previousStyleFunction = olLayer.getStyleFunction();\n        // there is no convenient way to detect a style function change in OL\n        listenKeyArray.push(olLayer.on('change', () => {\n          const currentStyleFunction = olLayer.getStyleFunction();\n          if (previousStyleFunction === currentStyleFunction) {\n            return;\n          }\n          previousStyleFunction = currentStyleFunction;\n          for (let i = 0; i < cesiumObjects.length; ++i) {\n            const csObj = cesiumObjects[i];\n            // clear cache and set new style\n            // @ts-ignore TS2341\n            if (csObj._imageryCache) {\n              // @ts-ignore TS2341\n              csObj._imageryCache = {};\n            }\n\n            const ip = csObj.imageryProvider;\n            if (ip) {\n              // @ts-ignore TS2341\n              ip.tileCache?.clear();\n              // @ts-ignore TS2341\n              ip.styleFunction_ = currentStyleFunction;\n            }\n          }\n          this.scene.requestRender();\n        }));\n      }\n\n      for (let i = 0; i < cesiumObjects.length; ++i) {\n        updateCesiumLayerProperties(olLayerWithParents, cesiumObjects[i]);\n      }\n\n      // there is no way to modify Cesium layer extent,\n      // we have to recreate when OpenLayers layer extent changes:\n      listenKeyArray.push(olLayer.on('change:extent', (e) => {\n        for (let i = 0; i < cesiumObjects.length; ++i) {\n          this.cesiumLayers_.remove(cesiumObjects[i], true); // destroy\n          this.ourLayers_.remove(cesiumObjects[i], false);\n        }\n        delete this.layerMap[getUid(olLayer)]; // invalidate the map entry\n        this.synchronize();\n      }));\n\n      listenKeyArray.push(olLayer.on('change', (e) => {\n        // when the source changes, re-add the layer to force update\n        for (let i = 0; i < cesiumObjects.length; ++i) {\n          const position = this.cesiumLayers_.indexOf(cesiumObjects[i]);\n          if (position >= 0) {\n            this.cesiumLayers_.remove(cesiumObjects[i], false);\n            this.cesiumLayers_.add(cesiumObjects[i], position);\n          }\n        }\n      }));\n\n      this.olLayerListenKeys[uid].push(...listenKeyArray);\n    }\n\n    return Array.isArray(cesiumObjects) ? cesiumObjects : null;\n  }\n\n  /**\n   * Order counterparts using the same algorithm as the Openlayers renderer:\n   * z-index then original sequence order.\n   * @override\n   * @protected\n   */\n  orderLayers() {\n    const layers = [];\n    const zIndices: Record<number, number> = {};\n    const queue: Array<BaseLayer | LayerGroup> = [this.mapLayerGroup];\n\n    while (queue.length > 0) {\n      const olLayer = queue.splice(0, 1)[0];\n      layers.push(olLayer);\n      zIndices[getUid(olLayer)] = olLayer.getZIndex() || 0;\n\n      if (olLayer instanceof LayerGroup) {\n        const sublayers = olLayer.getLayers();\n        if (sublayers) {\n          // Prepend queue with sublayers in order\n          queue.unshift(...sublayers.getArray());\n        }\n      }\n    }\n\n    // We assume sort is stable (which has been in the spec since a long time already).\n    // See https://caniuse.com/mdn-javascript_builtins_array_sort_stable\n    layers.sort((layer1, layer2) =>\n      zIndices[getUid(layer1)] - zIndices[getUid(layer2)]\n    );\n\n    layers.forEach((olLayer) => {\n      const olLayerId = getUid(olLayer).toString();\n      const cesiumObjects = this.layerMap[olLayerId];\n      if (cesiumObjects) {\n        cesiumObjects.forEach((cesiumObject) => { this.raiseToTop(cesiumObject); });\n      }\n    });\n  }\n\n  raiseToTop(counterpart: ImageryLayer) {\n    this.cesiumLayers_.raiseToTop(counterpart);\n  }\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = ol.source.Vector;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.layer.Layer;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.source.Cluster;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.layer.Vector;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.style.Icon;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.geom.Polygon;","const __WEBPACK_NAMESPACE_OBJECT__ = ol.geom.SimpleGeometry;","import {unByKey as olObservableUnByKey} from 'ol/Observable.js';\nimport type Projection from 'ol/proj/Projection.js';\nimport type {Billboard, BillboardCollection, Primitive, PrimitiveCollection, Scene} from 'cesium';\nimport type {EventsKey} from 'ol/events.js';\n\n\n/**\n * Context for feature conversion.\n */\nexport type OlFeatureToCesiumContext = {\n  projection: Projection | string,\n  billboards: BillboardCollection,\n  featureToCesiumMap: Record<number, Array<Primitive | Billboard>>,\n  primitives: PrimitiveCollection\n};\n\n\nexport default class VectorLayerCounterpart {\n  olListenKeys: EventsKey[] = [];\n  context: OlFeatureToCesiumContext;\n  private rootCollection_: PrimitiveCollection;\n  /**\n  * Result of the conversion of an OpenLayers layer to Cesium.\n  */\n  constructor(layerProjection: Projection | string, scene: Scene) {\n    const billboards = new Cesium.BillboardCollection({scene});\n    const primitives = new Cesium.PrimitiveCollection();\n    this.rootCollection_ = new Cesium.PrimitiveCollection();\n    this.context = {\n      projection: layerProjection,\n      billboards,\n      featureToCesiumMap: {},\n      primitives\n    };\n\n    this.rootCollection_.add(billboards);\n    this.rootCollection_.add(primitives);\n  }\n\n  /**\n  * Unlisten.\n  */\n  destroy() {\n    this.olListenKeys.forEach(olObservableUnByKey);\n    this.olListenKeys.length = 0;\n  }\n\n  getRootPrimitive(): PrimitiveCollection {\n    return this.rootCollection_;\n  }\n}\n\n\nexport type PrimitiveCollectionCounterpart = PrimitiveCollection & {counterpart: VectorLayerCounterpart};\n","const __WEBPACK_NAMESPACE_OBJECT__ = ol.geom;","import OLStyleIcon from 'ol/style/Icon.js';\nimport VectorSource, {type VectorSourceEvent} from 'ol/source/Vector.js';\nimport OLClusterSource from 'ol/source/Cluster.js';\nimport {circular as olCreateCircularPolygon} from 'ol/geom/Polygon.js';\nimport {boundingExtent, getCenter} from 'ol/extent.js';\nimport olGeomSimpleGeometry from 'ol/geom/SimpleGeometry.js';\nimport {convertColorToCesium, olGeometryCloneTo4326, ol4326CoordinateToCesiumCartesian, ol4326CoordinateArrayToCsCartesians} from './core';\nimport VectorLayerCounterpart, {type OlFeatureToCesiumContext} from './core/VectorLayerCounterpart';\nimport {getUid, waitReady} from './util';\nimport type {CircleGeometry, CircleOutlineGeometry, Primitive, Billboard, Label, Matrix4, Scene, Geometry as CSGeometry, Color as CSColor, GroundPrimitive, PrimitiveCollection, ImageMaterialProperty, BillboardCollection, Cartesian3, GroundPolylinePrimitive, PolygonHierarchy, HeightReference, Model, LabelCollection, Material} from 'cesium';\nimport type VectorLayer from 'ol/layer/Vector.js';\nimport type ImageLayer from 'ol/layer/Image.js';\nimport type {Feature, View} from 'ol';\nimport type Text from 'ol/style/Text.js';\nimport {type default as Style, type StyleFunction} from 'ol/style/Style.js';\nimport type {ColorLike as OLColorLike} from 'ol/colorlike.js';\nimport type {Color as OLColor} from 'ol/color.js';\nimport type {ProjectionLike} from 'ol/proj.js';\nimport {Geometry as OLGeometry, type MultiLineString, type MultiPolygon, type MultiPoint, type GeometryCollection, type Circle, type LineString, type Point, type Polygon} from 'ol/geom.js';\nimport type ImageStyle from 'ol/style/Image.js';\n\n\ntype ModelFromGltfOptions = Parameters<typeof Model.fromGltfAsync>[0];\n\ntype PrimitiveLayer = VectorLayer<any> | ImageLayer<any>;\n\ndeclare module 'cesium' {\n  // eslint-disable-next-line no-unused-vars\n  interface Primitive {\n    olLayer: PrimitiveLayer;\n    olFeature: Feature;\n  }\n  // eslint-disable-next-line no-unused-vars\n  interface GroundPolylinePrimitive {\n    olLayer: PrimitiveLayer;\n    olFeature: Feature;\n    _primitive: Primitive; // Missing from types published by Cesium\n  }\n  // eslint-disable-next-line no-unused-vars\n  interface GroundPrimitive {\n    olLayer: PrimitiveLayer;\n    olFeature: Feature;\n  }\n  // eslint-disable-next-line no-unused-vars\n  interface Label {\n    olLayer: PrimitiveLayer;\n    olFeature: Feature;\n  }\n  // eslint-disable-next-line no-unused-vars\n  interface Billboard {\n    olLayer: PrimitiveLayer;\n    olFeature: Feature;\n  }\n}\n\ninterface ModelStyle {\n  debugModelMatrix?: Matrix4;\n  cesiumOptions: ModelFromGltfOptions;\n}\n\ninterface MaterialAppearanceOptions {\n  flat: boolean;\n  renderState: {\n    depthTest: {\n      enabled: boolean;\n    },\n    lineWidth?: number;\n  }\n}\n\nexport default class FeatureConverter {\n\n  /**\n   * Bind once to have a unique function for using as a listener\n   */\n  private boundOnRemoveOrClearFeatureListener_ = this.onRemoveOrClearFeature_.bind(this);\n\n  private defaultBillboardEyeOffset_ = new Cesium.Cartesian3(0, 0, 10);\n\n  /**\n   * Concrete base class for converting from OpenLayers3 vectors to Cesium\n   * primitives.\n   * Extending this class is possible provided that the extending class and\n   * the library are compiled together by the closure compiler.\n   * @param scene Cesium scene.\n   * @api\n   */\n  constructor(protected scene: Scene) {\n    this.scene = scene;\n  }\n\n  /**\n   * @param evt\n   */\n  private onRemoveOrClearFeature_(evt: VectorSourceEvent) {\n    const source = evt.target;\n    console.assert(source instanceof VectorSource);\n\n    const cancellers = source['olcs_cancellers'];\n    if (cancellers) {\n      const feature = evt.feature;\n      if (feature) {\n        // remove\n        const id = getUid(feature);\n        const canceller = cancellers[id];\n        if (canceller) {\n          canceller();\n          delete cancellers[id];\n        }\n      } else {\n        // clear\n        for (const key in cancellers) {\n          if (cancellers.hasOwnProperty(key)) {\n            cancellers[key]();\n          }\n        }\n        source['olcs_cancellers'] = {};\n      }\n    }\n  }\n\n  /**\n   * @param layer\n   * @param feature OpenLayers feature.\n   * @param primitive\n   */\n  protected setReferenceForPicking(layer: PrimitiveLayer, feature: Feature, primitive: GroundPolylinePrimitive | GroundPrimitive | Primitive| Label|Billboard) {\n    primitive.olLayer = layer;\n    primitive.olFeature = feature;\n  }\n\n  /**\n   * Basics primitive creation using a color attribute.\n   * Note that Cesium has 'interior' and outline geometries.\n   * @param layer\n   * @param feature OpenLayers feature.\n   * @param olGeometry OpenLayers geometry.\n   * @param geometry\n   * @param color\n   * @param opt_lineWidth\n   * @return primitive\n   */\n  protected createColoredPrimitive(layer: PrimitiveLayer, feature: Feature, olGeometry: OLGeometry, geometry: CSGeometry | CircleGeometry, color: CSColor| ImageMaterialProperty, opt_lineWidth?: number): Primitive | GroundPrimitive {\n    const createInstance = function(geometry: CSGeometry | CircleGeometry, color: CSColor | ImageMaterialProperty) {\n      const instance = new Cesium.GeometryInstance({\n        geometry\n      });\n      if (color && !(color instanceof Cesium.ImageMaterialProperty)) {\n        instance.attributes = {\n          color: Cesium.ColorGeometryInstanceAttribute.fromColor(color)\n        };\n      }\n      return instance;\n    };\n\n    const options: MaterialAppearanceOptions = {\n      flat: true, // work with all geometries\n      renderState: {\n        depthTest: {\n          enabled: true\n        }\n      }\n    };\n\n    if (opt_lineWidth !== undefined) {\n      options.renderState.lineWidth = opt_lineWidth;\n    }\n\n    const instances = createInstance(geometry, color);\n\n    const heightReference = this.getHeightReference(layer, feature, olGeometry);\n\n    let primitive: GroundPrimitive | Primitive;\n\n    if (heightReference === Cesium.HeightReference.CLAMP_TO_GROUND) {\n      if (!('createShadowVolume' in instances.geometry.constructor)) {\n        // This is not a ground geometry\n        return null;\n      }\n      primitive = new Cesium.GroundPrimitive({\n        geometryInstances: instances\n      });\n    } else {\n      primitive = new Cesium.Primitive({\n        geometryInstances: instances\n      });\n    }\n\n    if (color instanceof Cesium.ImageMaterialProperty) {\n      // FIXME: we created stylings which are not time related\n      // What should we pass here?\n      // @ts-ignore\n      const dataUri = color.image.getValue().toDataURL();\n\n      primitive.appearance = new Cesium.MaterialAppearance({\n        flat: true,\n        renderState: {\n          depthTest: {\n            enabled: true,\n          }\n        },\n        material: new Cesium.Material({\n          fabric: {\n            type: 'Image',\n            uniforms: {\n              image: dataUri\n            }\n          }\n        })\n      });\n    } else {\n      primitive.appearance = new Cesium.MaterialAppearance({\n        ...options,\n        material: new Cesium.Material({\n          translucent: color.alpha !== 1,\n          fabric: {\n            type: 'Color',\n            uniforms: {\n              color,\n            }\n          }\n        })\n      });\n      if (primitive instanceof Cesium.Primitive && (feature.get('olcs_shadows') || layer.get('olcs_shadows'))) {\n        primitive.shadows = 1;\n      }\n    }\n    this.setReferenceForPicking(layer, feature, primitive);\n    return primitive;\n  }\n\n  /**\n   * Return the fill or stroke color from a plain ol style.\n   * @param style\n   * @param outline\n   * @return {!CSColor}\n   */\n  protected extractColorFromOlStyle(style: Style | Text, outline: boolean) {\n    const fillColor = style.getFill() ? style.getFill().getColor() : null;\n    const strokeColor = style.getStroke() ? style.getStroke().getColor() : null;\n\n    let olColor: OLColorLike | OLColor = 'black';\n    if (strokeColor && outline) {\n      olColor = strokeColor;\n    } else if (fillColor) {\n      olColor = fillColor;\n    }\n\n    return convertColorToCesium(olColor);\n  }\n\n  /**\n   * Return the width of stroke from a plain ol style.\n   * @param style\n   * @return {number}\n   */\n  protected extractLineWidthFromOlStyle(style: Style | Text) {\n    // Handling of line width WebGL limitations is handled by Cesium.\n    const width = style.getStroke() ? style.getStroke().getWidth() : undefined;\n    return width !== undefined ? width : 1;\n  }\n\n  /**\n   * Create a primitive collection out of two Cesium geometries.\n   * Only the OpenLayers style colors will be used.\n   */\n  protected wrapFillAndOutlineGeometries(layer: PrimitiveLayer, feature: Feature, olGeometry: OLGeometry, fillGeometry: CSGeometry | CircleGeometry, outlineGeometry: CSGeometry | CircleOutlineGeometry, olStyle: Style): PrimitiveCollection {\n    const fillColor = this.extractColorFromOlStyle(olStyle, false);\n    const outlineColor = this.extractColorFromOlStyle(olStyle, true);\n\n    const primitives = new Cesium.PrimitiveCollection();\n    if (olStyle.getFill()) {\n      const p1 = this.createColoredPrimitive(layer, feature, olGeometry,\n          fillGeometry, fillColor);\n      console.assert(!!p1);\n      primitives.add(p1);\n    }\n\n    if (olStyle.getStroke() && outlineGeometry) {\n      const width = this.extractLineWidthFromOlStyle(olStyle);\n      const p2 = this.createColoredPrimitive(layer, feature, olGeometry,\n          outlineGeometry, outlineColor, width);\n      if (p2) {\n        // Some outline geometries are not supported by Cesium in clamp to ground\n        // mode. These primitives are skipped.\n        primitives.add(p2);\n      }\n    }\n\n    return primitives;\n  }\n\n  // Geometry converters\n\n  // FIXME: would make more sense to only accept primitive collection.\n  /**\n   * Create a Cesium primitive if style has a text component.\n   * Eventually return a PrimitiveCollection including current primitive.\n   */\n  protected addTextStyle(layer: PrimitiveLayer, feature: Feature, geometry: OLGeometry, style: Style, primitive: Primitive | PrimitiveCollection | GroundPolylinePrimitive): PrimitiveCollection {\n    let primitives;\n    if (!(primitive instanceof Cesium.PrimitiveCollection)) {\n      primitives = new Cesium.PrimitiveCollection();\n      primitives.add(primitive);\n    } else {\n      primitives = primitive;\n    }\n\n    if (!style.getText()) {\n      return primitives;\n    }\n\n    const text = /** @type {!ol.style.Text} */ (style.getText());\n    const label = this.olGeometry4326TextPartToCesium(layer, feature, geometry,\n        text);\n    if (label) {\n      primitives.add(label);\n    }\n    return primitives;\n  }\n\n  /**\n   * Add a billboard to a Cesium.BillboardCollection.\n   * Overriding this wrapper allows manipulating the billboard options.\n   * @param billboards\n   * @param bbOptions\n   * @param layer\n   * @param feature OpenLayers feature.\n   * @param geometry\n   * @param style\n   * @return newly created billboard\n   * @api\n   */\n  csAddBillboard(billboards: BillboardCollection, bbOptions: Parameters<BillboardCollection['add']>[0], layer: PrimitiveLayer, feature: Feature, geometry: OLGeometry, style: Style): Billboard {\n    if (!bbOptions.eyeOffset) {\n      bbOptions.eyeOffset = this.defaultBillboardEyeOffset_;\n    }\n    const bb = billboards.add(bbOptions);\n    this.setReferenceForPicking(layer, feature, bb);\n    return bb;\n  }\n\n  /**\n   * Convert an OpenLayers circle geometry to Cesium.\n   * @api\n   */\n  olCircleGeometryToCesium(layer: PrimitiveLayer, feature: Feature, olGeometry: Circle, projection: ProjectionLike, olStyle: Style): PrimitiveCollection {\n\n    olGeometry = olGeometryCloneTo4326(olGeometry, projection);\n    console.assert(olGeometry.getType() == 'Circle');\n\n    // ol.Coordinate\n    const olCenter = olGeometry.getCenter();\n    const height = olCenter.length == 3 ? olCenter[2] : 0.0;\n    const olPoint = olCenter.slice();\n    olPoint[0] += olGeometry.getRadius();\n\n    // Cesium\n    const center: Cartesian3 = ol4326CoordinateToCesiumCartesian(olCenter);\n    const point: Cartesian3 = ol4326CoordinateToCesiumCartesian(olPoint);\n\n    // Accurate computation of straight distance\n    const radius = Cesium.Cartesian3.distance(center, point);\n\n    const fillGeometry = new Cesium.CircleGeometry({\n      center,\n      radius,\n      height\n    });\n\n    let outlinePrimitive: Primitive | GroundPrimitive | GroundPolylinePrimitive;\n    let outlineGeometry;\n    if (this.getHeightReference(layer, feature, olGeometry) === Cesium.HeightReference.CLAMP_TO_GROUND) {\n      const width = this.extractLineWidthFromOlStyle(olStyle);\n      if (width) {\n        const circlePolygon = olCreateCircularPolygon(olGeometry.getCenter(), radius);\n        const positions = ol4326CoordinateArrayToCsCartesians(circlePolygon.getLinearRing(0).getCoordinates());\n        const op = outlinePrimitive = new Cesium.GroundPolylinePrimitive({\n          geometryInstances: new Cesium.GeometryInstance({\n            geometry: new Cesium.GroundPolylineGeometry({positions, width}),\n          }),\n          appearance: new Cesium.PolylineMaterialAppearance({\n            material: this.olStyleToCesium(feature, olStyle, true),\n          }),\n          classificationType: Cesium.ClassificationType.TERRAIN,\n        });\n        waitReady(outlinePrimitive).then(() => {\n          this.setReferenceForPicking(layer, feature, op._primitive);\n        });\n      }\n    } else {\n      outlineGeometry = new Cesium.CircleOutlineGeometry({\n        center,\n        radius,\n        extrudedHeight: height,\n        height\n      });\n    }\n\n    const primitives = this.wrapFillAndOutlineGeometries(\n        layer, feature, olGeometry, fillGeometry, outlineGeometry, olStyle);\n\n    if (outlinePrimitive) {\n      primitives.add(outlinePrimitive);\n    }\n    return this.addTextStyle(layer, feature, olGeometry, olStyle, primitives);\n  }\n\n\n  /**\n   * Convert an OpenLayers line string geometry to Cesium.\n   * @api\n   */\n  olLineStringGeometryToCesium(layer: PrimitiveLayer, feature: Feature, olGeometry: LineString, projection: ProjectionLike, olStyle: Style): PrimitiveCollection {\n\n    olGeometry = olGeometryCloneTo4326(olGeometry, projection);\n    console.assert(olGeometry.getType() == 'LineString');\n\n    const positions = ol4326CoordinateArrayToCsCartesians(olGeometry.getCoordinates());\n    const width = this.extractLineWidthFromOlStyle(olStyle);\n\n    let outlinePrimitive: Primitive | GroundPolylinePrimitive;\n    const heightReference = this.getHeightReference(layer, feature, olGeometry);\n\n    const appearance = new Cesium.PolylineMaterialAppearance({\n      material: this.olStyleToCesium(feature, olStyle, true)\n    });\n    if (heightReference === Cesium.HeightReference.CLAMP_TO_GROUND) {\n      const geometry = new Cesium.GroundPolylineGeometry({\n        positions,\n        width,\n      });\n      const op = outlinePrimitive = new Cesium.GroundPolylinePrimitive({\n        appearance,\n        geometryInstances: new Cesium.GeometryInstance({\n          geometry\n        })\n      });\n      waitReady(outlinePrimitive).then(() => {\n        this.setReferenceForPicking(layer, feature, op._primitive);\n      });\n    } else {\n      const geometry = new Cesium.PolylineGeometry({\n        positions,\n        width,\n        vertexFormat: appearance.vertexFormat\n      });\n      outlinePrimitive = new Cesium.Primitive({\n        appearance,\n        geometryInstances: new Cesium.GeometryInstance({\n          geometry\n        }),\n      });\n    }\n\n    this.setReferenceForPicking(layer, feature, outlinePrimitive);\n\n    return this.addTextStyle(layer, feature, olGeometry, olStyle, outlinePrimitive);\n  }\n\n  /**\n   * Convert an OpenLayers polygon geometry to Cesium.\n   * @api\n   */\n  olPolygonGeometryToCesium(layer: PrimitiveLayer, feature: Feature, olGeometry: Polygon, projection: ProjectionLike, olStyle: Style): PrimitiveCollection {\n\n    olGeometry = olGeometryCloneTo4326(olGeometry, projection);\n    console.assert(olGeometry.getType() == 'Polygon');\n\n    const heightReference = this.getHeightReference(layer, feature, olGeometry);\n\n    let fillGeometry, outlineGeometry;\n    let outlinePrimitive: GroundPolylinePrimitive;\n    if ((olGeometry.getCoordinates()[0].length == 5) &&\n        (feature.get('olcs.polygon_kind') === 'rectangle')) {\n      // Create a rectangle according to the longitude and latitude curves\n      const coordinates = olGeometry.getCoordinates()[0];\n      // Extract the West, South, East, North coordinates\n      const extent = boundingExtent(coordinates);\n      const rectangle = Cesium.Rectangle.fromDegrees(extent[0], extent[1],\n          extent[2], extent[3]);\n\n      // Extract the average height of the vertices\n      let maxHeight = 0.0;\n      if (coordinates[0].length == 3) {\n        for (let c = 0; c < coordinates.length; c++) {\n          maxHeight = Math.max(maxHeight, coordinates[c][2]);\n        }\n      }\n\n      const featureExtrudedHeight = feature.get('olcs_extruded_height');\n\n      // Render the cartographic rectangle\n      fillGeometry = new Cesium.RectangleGeometry({\n        ellipsoid: Cesium.Ellipsoid.WGS84,\n        rectangle,\n        height: maxHeight,\n        extrudedHeight: featureExtrudedHeight,\n      });\n\n      outlineGeometry = new Cesium.RectangleOutlineGeometry({\n        ellipsoid: Cesium.Ellipsoid.WGS84,\n        rectangle,\n        height: maxHeight,\n        extrudedHeight: featureExtrudedHeight,\n      });\n    } else {\n      const rings = olGeometry.getLinearRings();\n      const hierarchy: PolygonHierarchy = {\n        positions: [],\n        holes: [],\n      };\n      const polygonHierarchy: PolygonHierarchy = hierarchy;\n      console.assert(rings.length > 0);\n\n      for (let i = 0; i < rings.length; ++i) {\n        const olPos = rings[i].getCoordinates();\n        const positions = ol4326CoordinateArrayToCsCartesians(olPos);\n        console.assert(positions && positions.length > 0);\n        if (i === 0) {\n          hierarchy.positions = positions;\n        } else {\n          hierarchy.holes.push({\n            positions,\n            holes: [],\n          });\n        }\n      }\n\n      const featureExtrudedHeight = feature.get('olcs_extruded_height');\n\n      fillGeometry = new Cesium.PolygonGeometry({\n        polygonHierarchy,\n        perPositionHeight: true,\n        extrudedHeight: featureExtrudedHeight,\n      });\n\n      // Since Cesium doesn't yet support Polygon outlines on terrain yet (coming soon...?)\n      // we don't create an outline geometry if clamped, but instead do the polyline method\n      // for each ring. Most of this code should be removeable when Cesium adds\n      // support for Polygon outlines on terrain.\n      if (heightReference === Cesium.HeightReference.CLAMP_TO_GROUND) {\n        const width = this.extractLineWidthFromOlStyle(olStyle);\n        if (width > 0) {\n          const positions: Cartesian3[][] = [hierarchy.positions];\n          if (hierarchy.holes) {\n            for (let i = 0; i < hierarchy.holes.length; ++i) {\n              positions.push(hierarchy.holes[i].positions);\n            }\n          }\n          const appearance = new Cesium.PolylineMaterialAppearance({\n            material: this.olStyleToCesium(feature, olStyle, true)\n          });\n          const geometryInstances = [];\n          for (const linePositions of positions) {\n            const polylineGeometry = new Cesium.GroundPolylineGeometry({positions: linePositions, width});\n            geometryInstances.push(new Cesium.GeometryInstance({\n              geometry: polylineGeometry\n            }));\n          }\n          outlinePrimitive = new Cesium.GroundPolylinePrimitive({\n            appearance,\n            geometryInstances\n          });\n          waitReady(outlinePrimitive).then(() => {\n            this.setReferenceForPicking(layer, feature, outlinePrimitive._primitive);\n          });\n        }\n      } else {\n        // Actually do the normal polygon thing. This should end the removable\n        // section of code described above.\n        outlineGeometry = new Cesium.PolygonOutlineGeometry({\n          polygonHierarchy: hierarchy,\n          perPositionHeight: true,\n          extrudedHeight: featureExtrudedHeight,\n        });\n      }\n    }\n\n    const primitives = this.wrapFillAndOutlineGeometries(\n        layer, feature, olGeometry, fillGeometry, outlineGeometry, olStyle);\n\n    if (outlinePrimitive) {\n      primitives.add(outlinePrimitive);\n    }\n\n    return this.addTextStyle(layer, feature, olGeometry, olStyle, primitives);\n  }\n\n  /**\n   * @api\n   */\n  getHeightReference(layer: PrimitiveLayer, feature: Feature, geometry: OLGeometry): HeightReference {\n\n    // Read from the geometry\n    let altitudeMode = geometry.get('altitudeMode');\n\n    // Or from the feature\n    if (altitudeMode === undefined) {\n      altitudeMode = feature.get('altitudeMode');\n    }\n\n    // Or from the layer\n    if (altitudeMode === undefined) {\n      altitudeMode = layer.get('altitudeMode');\n    }\n\n    let heightReference = Cesium.HeightReference.NONE;\n    if (altitudeMode === 'clampToGround') {\n      heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;\n    } else if (altitudeMode === 'relativeToGround') {\n      heightReference = Cesium.HeightReference.RELATIVE_TO_GROUND;\n    }\n\n    return heightReference;\n  }\n\n  /**\n   * Convert a point geometry to a Cesium BillboardCollection.\n   * @param {ol.layer.Vector|ol.layer.Image} layer\n   * @param {!ol.Feature} feature OpenLayers feature..\n   * @param {!ol.geom.Point} olGeometry OpenLayers point geometry.\n   * @param {!ol.ProjectionLike} projection\n   * @param {!ol.style.Style} style\n   * @param {!ol.style.Image} imageStyle\n   * @param {!Cesium.BillboardCollection} billboards\n   * @param {function(!Cesium.Billboard)=} opt_newBillboardCallback Called when the new billboard is added.\n   * @api\n   */\n  createBillboardFromImage(\n      layer: PrimitiveLayer,\n      feature: Feature,\n      olGeometry: Point,\n      projection: ProjectionLike,\n      style: Style,\n      imageStyle: ImageStyle,\n      billboards: BillboardCollection,\n      opt_newBillboardCallback: (bb: Billboard) => void,\n  ) {\n    if (imageStyle instanceof OLStyleIcon) {\n      // make sure the image is scheduled for load\n      imageStyle.load();\n    }\n\n    const image = imageStyle.getImage(1); // get normal density\n    const isImageLoaded = function(image: HTMLImageElement) {\n      return image.src != '' &&\n          image.naturalHeight != 0 &&\n          image.naturalWidth != 0 &&\n          image.complete;\n    };\n    const reallyCreateBillboard = (function() {\n      if (!image) {\n        return;\n      }\n      if (!(image instanceof HTMLCanvasElement ||\n          image instanceof Image ||\n          image instanceof HTMLImageElement)) {\n        return;\n      }\n      const center = olGeometry.getCoordinates();\n      const position = ol4326CoordinateToCesiumCartesian(center);\n      let color;\n      const opacity = imageStyle.getOpacity();\n      if (opacity !== undefined) {\n        color = new Cesium.Color(1.0, 1.0, 1.0, opacity);\n      }\n\n      const scale = imageStyle.getScale();\n      const heightReference = this.getHeightReference(layer, feature, olGeometry);\n\n      const bbOptions: Parameters<BillboardCollection['add']>[0] = {\n        image,\n        color,\n        scale,\n        heightReference,\n        position\n      };\n\n      // merge in cesium options from openlayers feature\n      Object.assign(bbOptions, feature.get('cesiumOptions'));\n\n      if (imageStyle instanceof OLStyleIcon) {\n        const anchor = imageStyle.getAnchor();\n        if (anchor) {\n          const xScale = (Array.isArray(scale) ? scale[0] : scale);\n          const yScale = (Array.isArray(scale) ? scale[1] : scale);\n          bbOptions.pixelOffset = new Cesium.Cartesian2(\n              (image.width / 2 - anchor[0]) * xScale,\n              (image.height / 2 - anchor[1]) * yScale\n          );\n        }\n      }\n\n      const bb = this.csAddBillboard(billboards, bbOptions, layer, feature, olGeometry, style);\n      if (opt_newBillboardCallback) {\n        opt_newBillboardCallback(bb);\n      }\n    }).bind(this);\n\n    if (image instanceof Image && !isImageLoaded(image)) {\n      // Cesium requires the image to be loaded\n      let cancelled = false;\n      const source = layer.getSource();\n      const canceller = function() {\n        cancelled = true;\n      };\n      source.on(['removefeature', 'clear'],\n          this.boundOnRemoveOrClearFeatureListener_);\n      let cancellers = source['olcs_cancellers'];\n      if (!cancellers) {\n        cancellers = source['olcs_cancellers'] = {};\n      }\n\n      const fuid = getUid(feature);\n      if (cancellers[fuid]) {\n        // When the feature change quickly, a canceller may still be present so\n        // we cancel it here to prevent creation of a billboard.\n        cancellers[fuid]();\n      }\n      cancellers[fuid] = canceller;\n\n      const listener = function() {\n        image.removeEventListener('load', listener);\n        if (!billboards.isDestroyed() && !cancelled) {\n          // Create billboard if the feature is still displayed on the map.\n          reallyCreateBillboard();\n        }\n      };\n\n      image.addEventListener('load', listener);\n    } else {\n      reallyCreateBillboard();\n    }\n  }\n\n  /**\n   * Convert a point geometry to a Cesium BillboardCollection.\n   * @param layer\n   * @param feature OpenLayers feature..\n   * @param olGeometry OpenLayers point geometry.\n   * @param projection\n   * @param style\n   * @param billboards\n   * @param opt_newBillboardCallback Called when the new billboard is added.\n   * @return primitives\n   * @api\n   */\n  olPointGeometryToCesium(\n      layer: PrimitiveLayer,\n      feature: Feature,\n      olGeometry: Point,\n      projection: ProjectionLike,\n      style: Style,\n      billboards: BillboardCollection,\n      opt_newBillboardCallback?: (bb: Billboard) => void\n  ): PrimitiveCollection {\n    console.assert(olGeometry.getType() == 'Point');\n    olGeometry = olGeometryCloneTo4326(olGeometry, projection);\n\n    let modelPrimitive: PrimitiveCollection = null;\n    const imageStyle = style.getImage();\n    if (imageStyle) {\n      const olcsModelFunction: () => ModelStyle = olGeometry.get('olcs_model') || feature.get('olcs_model');\n      if (olcsModelFunction) {\n        modelPrimitive = new Cesium.PrimitiveCollection();\n        const olcsModel = olcsModelFunction();\n        const options: ModelFromGltfOptions = Object.assign({}, {scene: this.scene}, olcsModel.cesiumOptions);\n        if ('fromGltf' in Cesium.Model) {\n          // pre Cesium v107\n          // @ts-ignore\n          const model = Cesium.Model.fromGltf(options);\n          modelPrimitive.add(model);\n        } else {\n          Cesium.Model.fromGltfAsync(options).then((model) => {\n            modelPrimitive.add(model);\n          });\n        }\n\n        if (olcsModel.debugModelMatrix) {\n          modelPrimitive.add(new Cesium.DebugModelMatrixPrimitive({\n            modelMatrix: olcsModel.debugModelMatrix\n          }));\n        }\n      } else {\n        this.createBillboardFromImage(layer, feature, olGeometry, projection, style, imageStyle, billboards, opt_newBillboardCallback);\n      }\n    }\n\n    if (style.getText()) {\n      return this.addTextStyle(layer, feature, olGeometry, style, modelPrimitive || new Cesium.Primitive());\n    } else {\n      return modelPrimitive;\n    }\n  }\n\n  /**\n   * Convert an OpenLayers multi-something geometry to Cesium.\n   * @param {ol.layer.Vector|ol.layer.Image} layer\n   * @param {!ol.Feature} feature OpenLayers feature..\n   * @param {!ol.geom.Geometry} geometry OpenLayers geometry.\n   * @param {!ol.ProjectionLike} projection\n   * @param {!ol.style.Style} olStyle\n   * @param {!Cesium.BillboardCollection} billboards\n   * @param {function(!Cesium.Billboard)=} opt_newBillboardCallback Called when\n   * the new billboard is added.\n   * @return {Cesium.Primitive} primitives\n   * @api\n   */\n  olMultiGeometryToCesium(\n      layer: PrimitiveLayer,\n      feature: Feature,\n      geometry: OLGeometry,\n      projection: ProjectionLike,\n      olStyle: Style,\n      billboards: BillboardCollection,\n      opt_newBillboardCallback: (bb: Billboard) => void\n  ) {\n    // Do not reproject to 4326 now because it will be done later.\n\n    switch (geometry.getType()) {\n      case 'MultiPoint': {\n        const points = (geometry as MultiPoint).getPoints();\n        if (olStyle.getText()) {\n          const primitives = new Cesium.PrimitiveCollection();\n          points.forEach((geom) => {\n            console.assert(geom);\n            const result = this.olPointGeometryToCesium(layer, feature, geom,\n                projection, olStyle, billboards, opt_newBillboardCallback);\n            if (result) {\n              primitives.add(result);\n            }\n          });\n          return primitives;\n        } else {\n          points.forEach((geom) => {\n            console.assert(geom);\n            this.olPointGeometryToCesium(layer, feature, geom, projection,\n                olStyle, billboards, opt_newBillboardCallback);\n          });\n          return null;\n        }\n      }\n      case 'MultiLineString': {\n        const lineStrings = (geometry as MultiLineString).getLineStrings();\n        // FIXME: would be better to combine all child geometries in one primitive\n        // instead we create n primitives for simplicity.\n        const primitives = new Cesium.PrimitiveCollection();\n        lineStrings.forEach((geom) => {\n          const p = this.olLineStringGeometryToCesium(layer, feature, geom, projection, olStyle);\n          primitives.add(p);\n        });\n        return primitives;\n      }\n      case 'MultiPolygon': {\n        const polygons = (geometry as MultiPolygon).getPolygons();\n        // FIXME: would be better to combine all child geometries in one primitive\n        // instead we create n primitives for simplicity.\n        const primitives = new Cesium.PrimitiveCollection();\n        polygons.forEach((geom) => {\n          const p = this.olPolygonGeometryToCesium(layer, feature, geom, projection, olStyle);\n          primitives.add(p);\n        });\n        return primitives;\n      }\n      default:\n        console.assert(false, `Unhandled multi geometry type${geometry.getType()}`);\n    }\n  }\n\n  /**\n   * Convert an OpenLayers text style to Cesium.\n   * @api\n   */\n  olGeometry4326TextPartToCesium(layer: PrimitiveLayer, feature: Feature, geometry: OLGeometry, style: Text): LabelCollection {\n    const text = style.getText();\n    if (!text) {\n      return null;\n    }\n\n    const labels = new Cesium.LabelCollection({scene: this.scene});\n    // TODO: export and use the text draw position from OpenLayers .\n    // See src/ol/render/vector.js\n    const extentCenter = getCenter(geometry.getExtent());\n    if (geometry instanceof olGeomSimpleGeometry) {\n      const first = geometry.getFirstCoordinate();\n      extentCenter[2] = first.length == 3 ? first[2] : 0.0;\n    }\n    const options: Parameters<LabelCollection['add']>[0] = {};\n\n    options.position = ol4326CoordinateToCesiumCartesian(extentCenter);\n\n    options.text = text;\n\n    options.heightReference = this.getHeightReference(layer, feature, geometry);\n\n    const offsetX = style.getOffsetX();\n    const offsetY = style.getOffsetY();\n    if (offsetX != 0 || offsetY != 0) {\n      const offset = new Cesium.Cartesian2(offsetX, offsetY);\n      options.pixelOffset = offset;\n    }\n\n    options.font = style.getFont() || '10px sans-serif'; // OpenLayers default\n\n    let labelStyle = undefined;\n    if (style.getFill()) {\n      options.fillColor = this.extractColorFromOlStyle(style, false);\n      labelStyle = Cesium.LabelStyle.FILL;\n    }\n    if (style.getStroke()) {\n      options.outlineWidth = this.extractLineWidthFromOlStyle(style);\n      options.outlineColor = this.extractColorFromOlStyle(style, true);\n      labelStyle = Cesium.LabelStyle.OUTLINE;\n    }\n    if (style.getFill() && style.getStroke()) {\n      labelStyle = Cesium.LabelStyle.FILL_AND_OUTLINE;\n    }\n    options.style = labelStyle;\n\n    let horizontalOrigin;\n    switch (style.getTextAlign()) {\n      case 'left':\n        horizontalOrigin = Cesium.HorizontalOrigin.LEFT;\n        break;\n      case 'right':\n        horizontalOrigin = Cesium.HorizontalOrigin.RIGHT;\n        break;\n      case 'center':\n      default:\n        horizontalOrigin = Cesium.HorizontalOrigin.CENTER;\n    }\n    options.horizontalOrigin = horizontalOrigin;\n\n    if (style.getTextBaseline()) {\n      let verticalOrigin;\n      switch (style.getTextBaseline()) {\n        case 'top':\n          verticalOrigin = Cesium.VerticalOrigin.TOP;\n          break;\n        case 'middle':\n          verticalOrigin = Cesium.VerticalOrigin.CENTER;\n          break;\n        case 'bottom':\n          verticalOrigin = Cesium.VerticalOrigin.BOTTOM;\n          break;\n        case 'alphabetic':\n          verticalOrigin = Cesium.VerticalOrigin.TOP;\n          break;\n        case 'hanging':\n          verticalOrigin = Cesium.VerticalOrigin.BOTTOM;\n          break;\n        default:\n          console.assert(false, `unhandled baseline ${style.getTextBaseline()}`);\n      }\n      options.verticalOrigin = verticalOrigin;\n    }\n\n\n    const l = labels.add(options);\n    this.setReferenceForPicking(layer, feature, l);\n    return labels;\n  }\n\n  /**\n   * Convert an OpenLayers style to a Cesium Material.\n   * @api\n   */\n  olStyleToCesium(feature: Feature, style: Style, outline: boolean): Material {\n    const fill = style.getFill();\n    const stroke = style.getStroke();\n    if ((outline && !stroke) || (!outline && !fill)) {\n      return null; // FIXME use a default style? Developer error?\n    }\n\n    const olColor = outline ? stroke.getColor() : fill.getColor();\n    const color = convertColorToCesium(olColor);\n\n    if (outline && stroke.getLineDash()) {\n      return Cesium.Material.fromType('Stripe', {\n        horizontal: false,\n        repeat: 500, // TODO how to calculate this?\n        evenColor: color,\n        oddColor: new Cesium.Color(0, 0, 0, 0) // transparent\n      });\n    } else {\n      return Cesium.Material.fromType('Color', {\n        color\n      });\n    }\n\n  }\n\n  /**\n   * Compute OpenLayers plain style.\n   * Evaluates style function, blend arrays, get default style.\n   * @api\n   */\n  computePlainStyle(layer: PrimitiveLayer, feature: Feature, fallbackStyleFunction: StyleFunction, resolution: number): Style[] {\n    /**\n     * @type {ol.FeatureStyleFunction|undefined}\n     */\n    const featureStyleFunction = feature.getStyleFunction();\n\n    /**\n     * @type {ol.style.Style|Array.<ol.style.Style>}\n     */\n    let style = null;\n\n    if (featureStyleFunction) {\n      style = featureStyleFunction(feature, resolution);\n    }\n\n    if (!style && fallbackStyleFunction) {\n      style = fallbackStyleFunction(feature, resolution);\n    }\n\n    if (!style) {\n      // The feature must not be displayed\n      return null;\n    }\n\n    // FIXME combine materials as in cesium-materials-pack?\n    // then this function must return a custom material\n    // More simply, could blend the colors like described in\n    // http://en.wikipedia.org/wiki/Alpha_compositing\n    return Array.isArray(style) ? style : [style];\n  }\n\n  /**\n   */\n  protected getGeometryFromFeature(feature: Feature, style: Style, opt_geom?: OLGeometry): OLGeometry | undefined {\n    if (opt_geom) {\n      return opt_geom;\n    }\n\n    const geom3d: OLGeometry = feature.get('olcs.3d_geometry');\n    if (geom3d && geom3d instanceof OLGeometry) {\n      return geom3d;\n    }\n\n    if (style) {\n      const geomFuncRes = style.getGeometryFunction()(feature);\n      if (geomFuncRes instanceof OLGeometry) {\n        return geomFuncRes;\n      }\n    }\n\n    return feature.getGeometry();\n  }\n\n  /**\n   * Convert one OpenLayers feature up to a collection of Cesium primitives.\n   * @api\n   */\n  olFeatureToCesium(layer: PrimitiveLayer, feature: Feature, style: Style, context: OlFeatureToCesiumContext, opt_geom?: OLGeometry): PrimitiveCollection {\n    const geom: OLGeometry = this.getGeometryFromFeature(feature, style, opt_geom);\n\n    if (!geom) {\n      // OpenLayers features may not have a geometry\n      // See http://geojson.org/geojson-spec.html#feature-objects\n      return null;\n    }\n\n    const proj = context.projection;\n    const newBillboardAddedCallback = function(bb: Billboard) {\n      const featureBb = context.featureToCesiumMap[getUid(feature)];\n      if (featureBb instanceof Array) {\n        featureBb.push(bb);\n      }\n      else {\n        context.featureToCesiumMap[getUid(feature)] = [bb];\n      }\n    };\n\n    switch (geom.getType()) {\n      case 'GeometryCollection':\n        const primitives = new Cesium.PrimitiveCollection();\n        (geom as GeometryCollection).getGeometriesArray().forEach((geom) => {\n          if (geom) {\n            const prims = this.olFeatureToCesium(layer, feature, style, context,\n                geom);\n            if (prims) {\n              primitives.add(prims);\n            }\n          }\n        });\n        return primitives;\n      case 'Point':\n        const bbs = context.billboards;\n        const result = this.olPointGeometryToCesium(layer, feature, geom as Point, proj,\n            style, bbs, newBillboardAddedCallback);\n        if (!result) {\n          // no wrapping primitive\n          return null;\n        } else {\n          return result;\n        }\n      case 'Circle':\n        return this.olCircleGeometryToCesium(layer, feature, geom as Circle, proj,\n            style);\n      case 'LineString':\n        return this.olLineStringGeometryToCesium(layer, feature, geom as LineString, proj,\n            style);\n      case 'Polygon':\n        return this.olPolygonGeometryToCesium(layer, feature, geom as Polygon, proj,\n            style);\n      case 'MultiPoint':\n        return this.olMultiGeometryToCesium(layer, feature, geom as MultiPoint, proj,\n            style, context.billboards, newBillboardAddedCallback) || null;\n      case 'MultiLineString':\n        return this.olMultiGeometryToCesium(layer, feature, geom as MultiLineString, proj,\n            style, context.billboards, newBillboardAddedCallback) || null;\n      case 'MultiPolygon':\n        return this.olMultiGeometryToCesium(layer, feature, geom as MultiPolygon, proj,\n            style, context.billboards, newBillboardAddedCallback) || null;\n      case 'LinearRing':\n        throw new Error('LinearRing should only be part of polygon.');\n      default:\n        throw new Error(`Ol geom type not handled : ${geom.getType()}`);\n    }\n  }\n\n  /**\n   * Convert an OpenLayers vector layer to Cesium primitive collection.\n   * For each feature, the associated primitive will be stored in\n   * `featurePrimitiveMap`.\n   * @api\n   */\n  olVectorLayerToCesium(olLayer: VectorLayer<VectorSource>, olView: View, featurePrimitiveMap: Record<number, PrimitiveCollection>): VectorLayerCounterpart {\n    const proj = olView.getProjection();\n    const resolution = olView.getResolution();\n\n    if (resolution === undefined || !proj) {\n      console.assert(false, 'View not ready');\n      // an assertion is not enough for closure to assume resolution and proj\n      // are defined\n      throw new Error('View not ready');\n    }\n\n    let source = olLayer.getSource();\n    if (source instanceof OLClusterSource) {\n      source = source.getSource();\n    }\n\n    console.assert(source instanceof VectorSource);\n    const features = source.getFeatures();\n    const counterpart = new VectorLayerCounterpart(proj, this.scene);\n    const context = counterpart.context;\n    for (let i = 0; i < features.length; ++i) {\n      const feature = features[i];\n      if (!feature) {\n        continue;\n      }\n      const layerStyle: StyleFunction | undefined = olLayer.getStyleFunction();\n      const styles = this.computePlainStyle(olLayer, feature, layerStyle,\n          resolution);\n      if (!styles || !styles.length) {\n        // only 'render' features with a style\n        continue;\n      }\n\n      let primitives: PrimitiveCollection = null;\n      for (let i = 0; i < styles.length; i++) {\n        const prims = this.olFeatureToCesium(olLayer, feature, styles[i], context);\n        if (prims) {\n          if (!primitives) {\n            primitives = prims;\n          } else if (prims) {\n            let i = 0, prim;\n            while ((prim = prims.get(i))) {\n              primitives.add(prim);\n              i++;\n            }\n          }\n        }\n      }\n      if (!primitives) {\n        continue;\n      }\n      featurePrimitiveMap[getUid(feature)] = primitives;\n      counterpart.getRootPrimitive().add(primitives);\n    }\n\n    return counterpart;\n  }\n\n  /**\n   * Convert an OpenLayers feature to Cesium primitive collection.\n   * @api\n   */\n  convert(layer: VectorLayer<VectorSource>, view: View, feature: Feature, context: OlFeatureToCesiumContext): PrimitiveCollection {\n    const proj = view.getProjection();\n    const resolution = view.getResolution();\n\n    if (resolution == undefined || !proj) {\n      return null;\n    }\n\n    /**\n     * @type {ol.StyleFunction|undefined}\n     */\n    const layerStyle = layer.getStyleFunction();\n\n    const styles = this.computePlainStyle(layer, feature, layerStyle, resolution);\n\n    if (!styles || !styles.length) {\n      // only 'render' features with a style\n      return null;\n    }\n\n    context.projection = proj;\n\n    /**\n     * @type {Cesium.Primitive|null}\n     */\n    let primitives = null;\n    for (let i = 0; i < styles.length; i++) {\n      const prims = this.olFeatureToCesium(layer, feature, styles[i], context);\n      if (!primitives) {\n        primitives = prims;\n      } else if (prims) {\n        let i = 0, prim;\n        while ((prim = prims.get(i))) {\n          primitives.add(prim);\n          i++;\n        }\n      }\n    }\n    return primitives;\n  }\n}\n","import olSourceVector, {type VectorSourceEvent} from 'ol/source/Vector.js';\nimport olLayerLayer from 'ol/layer/Layer.js';\nimport olSourceCluster from 'ol/source/Cluster.js';\nimport {getUid} from './util';\nimport olLayerVector from 'ol/layer/Vector.js';\nimport olLayerVectorTile from 'ol/layer/VectorTile.js';\nimport olcsAbstractSynchronizer from './AbstractSynchronizer';\nimport olcsFeatureConverter from './FeatureConverter';\nimport type VectorLayerCounterpart from './core/VectorLayerCounterpart';\n// eslint-disable-next-line no-duplicate-imports\nimport {\n  type OlFeatureToCesiumContext,\n  type PrimitiveCollectionCounterpart\n} from './core/VectorLayerCounterpart';\nimport type Map from 'ol/Map.js';\nimport {type LayerWithParents} from './core';\nimport type Feature from 'ol/Feature.js';\nimport type BaseLayer from 'ol/layer/Base.js';\nimport type {PrimitiveCollection, Scene} from 'cesium';\n\nexport default class VectorSynchronizer extends olcsAbstractSynchronizer<VectorLayerCounterpart> {\n  protected converter: olcsFeatureConverter;\n  private csAllPrimitives_: PrimitiveCollection;\n  /**\n   * Unidirectionally synchronize OpenLayers vector layers to Cesium.\n   */\n  constructor(map: Map, scene: Scene, opt_converter?: olcsFeatureConverter) {\n    super(map, scene);\n\n    this.converter = opt_converter || new olcsFeatureConverter(scene);\n    this.csAllPrimitives_ = new Cesium.PrimitiveCollection();\n    scene.primitives.add(this.csAllPrimitives_);\n    this.csAllPrimitives_.destroyPrimitives = false;\n  }\n\n  addCesiumObject(counterpart: VectorLayerCounterpart) {\n    console.assert(counterpart);\n    const collection = <PrimitiveCollectionCounterpart>counterpart.getRootPrimitive();\n    collection.counterpart = counterpart;\n    this.csAllPrimitives_.add(counterpart.getRootPrimitive());\n  }\n\n  destroyCesiumObject(object: VectorLayerCounterpart) {\n    object.getRootPrimitive().destroy();\n  }\n\n  removeSingleCesiumObject(object: VectorLayerCounterpart, destroy: boolean) {\n    object.destroy();\n    this.csAllPrimitives_.destroyPrimitives = destroy;\n    this.csAllPrimitives_.remove(object.getRootPrimitive());\n    this.csAllPrimitives_.destroyPrimitives = false;\n  }\n\n  removeAllCesiumObjects(destroy: boolean) {\n    this.csAllPrimitives_.destroyPrimitives = destroy;\n    if (destroy) {\n      for (let i = 0; i < this.csAllPrimitives_.length; ++i) {\n        this.csAllPrimitives_.get(i)['counterpart'].destroy();\n      }\n    }\n    this.csAllPrimitives_.removeAll();\n    this.csAllPrimitives_.destroyPrimitives = false;\n  }\n\n  /**\n   * Synchronizes the layer visibility properties\n   * to the given Cesium Primitive.\n   */\n  updateLayerVisibility(olLayerWithParents: LayerWithParents, csPrimitive: PrimitiveCollection) {\n    let visible = true;\n    [olLayerWithParents.layer].concat(olLayerWithParents.parents).forEach((olLayer) => {\n      const layerVisible = olLayer.getVisible();\n      if (layerVisible !== undefined) {\n        visible = visible && layerVisible;\n      } else {\n        visible = false;\n      }\n    });\n    csPrimitive.show = visible;\n  }\n\n  createSingleLayerCounterparts(olLayerWithParents: LayerWithParents): VectorLayerCounterpart[] {\n    const olLayer: BaseLayer = olLayerWithParents.layer;\n    if (!(olLayer instanceof olLayerVector) || olLayer instanceof olLayerVectorTile) {\n      return null;\n    }\n    console.assert(olLayer instanceof olLayerLayer);\n\n    let source = olLayer.getSource();\n    if (source instanceof olSourceCluster) {\n      source = source.getSource();\n    }\n\n    if (!source) {\n      return null;\n    }\n\n    console.assert(source instanceof olSourceVector);\n    console.assert(this.view);\n\n    const view = this.view;\n    const featurePrimitiveMap: Record<number, PrimitiveCollection> = {};\n    const counterpart: VectorLayerCounterpart = this.converter.olVectorLayerToCesium(olLayer, view, featurePrimitiveMap);\n    const csPrimitives = counterpart.getRootPrimitive();\n    const olListenKeys = counterpart.olListenKeys;\n\n    [olLayerWithParents.layer].concat(olLayerWithParents.parents).forEach((olLayerItem) => {\n      olListenKeys.push(olLayerItem.on('change:visible', () => {\n        this.updateLayerVisibility(olLayerWithParents, csPrimitives);\n      }));\n    });\n    this.updateLayerVisibility(olLayerWithParents, csPrimitives);\n\n    const onAddFeature = (feature: Feature) => {\n      const context = counterpart.context;\n      const prim: PrimitiveCollection = this.converter.convert(olLayer, view, feature, context);\n      if (prim) {\n        featurePrimitiveMap[getUid(feature)] = prim;\n        csPrimitives.add(prim);\n      }\n    };\n\n    const onRemoveFeature = (feature: Feature) => {\n      const id = getUid(feature);\n      const context: OlFeatureToCesiumContext = counterpart.context;\n      const bbs = context.featureToCesiumMap[id];\n      if (bbs) {\n        delete context.featureToCesiumMap[id];\n        bbs.forEach((bb) => {\n          if (bb instanceof Cesium.Billboard) {\n            context.billboards.remove(bb);\n          }\n        });\n      }\n      const csPrimitive = featurePrimitiveMap[id];\n      delete featurePrimitiveMap[id];\n      if (csPrimitive) {\n        csPrimitives.remove(csPrimitive);\n      }\n    };\n\n    olListenKeys.push(source.on('addfeature', (e: VectorSourceEvent) => {\n      console.assert(e.feature);\n      onAddFeature(e.feature);\n    }));\n\n    olListenKeys.push(source.on('removefeature', (e: VectorSourceEvent) => {\n      console.assert(e.feature);\n      onRemoveFeature(e.feature);\n    }));\n\n    olListenKeys.push(source.on('changefeature', (e: VectorSourceEvent) => {\n      const feature = e.feature;\n      console.assert(feature);\n      onRemoveFeature(feature);\n      onAddFeature(feature);\n    }));\n\n    return counterpart ? [counterpart] : null;\n  }\n}\n","const __WEBPACK_NAMESPACE_OBJECT__ = ol.Overlay;","import OLOverlay from 'ol/Overlay.js';\nimport {transform} from 'ol/proj.js';\nimport {unByKey as olObservableUnByKey} from 'ol/Observable.js';\nimport type {Scene} from 'cesium';\nimport type OverlaySynchronizer from './OverlaySynchronizer';\nimport type {EventsKey} from 'ol/events';\nimport type {ObjectEvent} from 'ol/Object';\n\n\n/**\n * @param node The node to remove.\n * @return The node that was removed or null.\n */\nfunction removeNode(node: Node): 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 */\nfunction removeChildren(node: Node) {\n  while (node.lastChild) {\n    node.removeChild(node.lastChild);\n  }\n}\n\nfunction cloneNode<T extends Node, U extends Node>(node: T, parent: U): T {\n  const clone = node.cloneNode() as T;\n  if (node.nodeName === 'CANVAS') {\n    const ctx = (clone as unknown as HTMLCanvasElement).getContext('2d');\n    ctx.drawImage(node as unknown as HTMLCanvasElement, 0, 0);\n  }\n  if (parent) {\n    parent.appendChild(clone);\n  }\n  if (node.nodeType !== Node.TEXT_NODE) {\n    clone.addEventListener('click', (event) => {\n      node.dispatchEvent(new MouseEvent('click', event));\n      event.stopPropagation();\n    });\n  }\n  const nodes = node.childNodes;\n  for (let i = 0; i < nodes.length; i++) {\n    if (!nodes[i]) {\n      continue;\n    }\n    cloneNode(nodes[i], clone);\n  }\n  return clone;\n}\n\n\ninterface SynchronizedOverlayOptions {\n  scene: Scene;\n  parent: OLOverlay;\n  synchronizer: OverlaySynchronizer;\n}\n\n\nexport default class SynchronizedOverlay extends OLOverlay {\n\n  private scenePostRenderListenerRemover_?: Function = null;\n  private scene_: Scene;\n  private synchronizer_: OverlaySynchronizer;\n  private parent_: OLOverlay;\n  private positionWGS84_: number[];\n  private observer_: MutationObserver;\n  private attributeObserver_: MutationObserver[] = [];\n  private listenerKeys_: EventsKey[];\n\n\n  /**\n   * @param options SynchronizedOverlay Options.\n   * @api\n   */\n  constructor(options: SynchronizedOverlayOptions) {\n    const parent = options.parent;\n    super(parent.getOptions());\n    this.scene_ = options.scene;\n    this.synchronizer_ = options.synchronizer;\n    this.parent_ = parent;\n    this.positionWGS84_ = undefined;\n    this.observer_ = new MutationObserver(this.handleElementChanged.bind(this));\n    this.attributeObserver_ = [];\n    this.listenerKeys_ = [];\n\n    // synchronize our Overlay with the parent Overlay\n    const setPropertyFromEvent = (event: ObjectEvent) => this.setPropertyFromEvent_(event);\n    this.listenerKeys_.push(this.parent_.on('change:element', setPropertyFromEvent));\n    this.listenerKeys_.push(this.parent_.on('change:offset', setPropertyFromEvent));\n    this.listenerKeys_.push(this.parent_.on('change:position', setPropertyFromEvent));\n    this.listenerKeys_.push(this.parent_.on('change:positioning', setPropertyFromEvent));\n\n    this.setProperties(this.parent_.getProperties());\n\n    this.handleMapChanged();\n    this.handleElementChanged();\n  }\n\n  /**\n   * @param target\n   */\n  private observeTarget_(target: Node) {\n    if (!this.observer_) {\n      // not ready, skip the event (this occurs on construction)\n      return;\n    }\n    this.observer_.disconnect();\n    this.observer_.observe(target, {\n      attributes: false,\n      childList: true,\n      characterData: true,\n      subtree: true\n    });\n    this.attributeObserver_.forEach((observer) => {\n      observer.disconnect();\n    });\n    this.attributeObserver_.length = 0;\n    for (let i = 0; i < target.childNodes.length; i++) {\n      const node = target.childNodes[i];\n      if (node.nodeType === 1) {\n        const observer = new MutationObserver(this.handleElementChanged.bind(this));\n        observer.observe(node, {\n          attributes: true,\n          subtree: true\n        });\n        this.attributeObserver_.push(observer);\n      }\n    }\n  }\n\n  /**\n   *\n   * @param event\n   */\n  private setPropertyFromEvent_(event: ObjectEvent) {\n    if (event.target && event.key) {\n      this.set(event.key, event.target.get(event.key));\n    }\n  }\n\n  /**\n   * Get the scene associated with this overlay.\n   * @see ol.Overlay.prototype.getMap\n   * @return The scene that the overlay is part of.\n   * @api\n   */\n  getScene(): Scene {\n    return this.scene_;\n  }\n\n  /**\n   * @override\n   */\n  handleMapChanged() {\n    if (this.scenePostRenderListenerRemover_) {\n      this.scenePostRenderListenerRemover_();\n      removeNode(this.element);\n    }\n    this.scenePostRenderListenerRemover_ = null;\n    const scene = this.getScene();\n    if (scene) {\n      this.scenePostRenderListenerRemover_ = scene.postRender.addEventListener(this.updatePixelPosition.bind(this));\n      this.updatePixelPosition();\n      const container = this.stopEvent ?\n        this.synchronizer_.getOverlayContainerStopEvent() : this.synchronizer_.getOverlayContainer();\n      if (this.insertFirst) {\n        container.insertBefore(this.element, container.childNodes[0] || null);\n      } else {\n        container.appendChild(this.element);\n      }\n    }\n  }\n\n  /**\n   * @override\n   */\n  handlePositionChanged() {\n    // transform position to WGS84\n    const position = this.getPosition();\n    if (position) {\n      const sourceProjection = this.parent_.getMap().getView().getProjection();\n      this.positionWGS84_ = transform(position, sourceProjection, 'EPSG:4326');\n    } else {\n      this.positionWGS84_ = undefined;\n    }\n    this.updatePixelPosition();\n  }\n\n  /**\n   * @override\n   */\n  handleElementChanged() {\n    removeChildren(this.element);\n    const element = this.getElement();\n    if (element) {\n      if (element.parentNode && element.parentNode.childNodes) {\n        for (const node of Array.from(element.parentNode.childNodes)) {\n          const clonedNode = cloneNode(node, null);\n          this.element.appendChild(clonedNode);\n        }\n      }\n    }\n    if (element.parentNode) {\n      // set new Observer\n      this.observeTarget_(element.parentNode);\n    }\n  }\n\n  /**\n   * @override\n   */\n  updatePixelPosition() {\n    const position = this.positionWGS84_;\n    if (!this.scene_ || !position) {\n      this.setVisible(false);\n      return;\n    }\n    let height = 0;\n    if (position.length === 2) {\n      const globeHeight = this.scene_.globe.getHeight(Cesium.Cartographic.fromDegrees(position[0], position[1]));\n      if (globeHeight && this.scene_.globe.tilesLoaded) {\n        position[2] = globeHeight;\n      }\n      if (globeHeight) {\n        height = globeHeight;\n      }\n    } else {\n      height = position[2];\n    }\n    const cartesian = Cesium.Cartesian3.fromDegrees(position[0], position[1], height);\n    const camera = this.scene_.camera;\n    const ellipsoidBoundingSphere = new Cesium.BoundingSphere(new Cesium.Cartesian3(), 6356752);\n    const occluder = new Cesium.Occluder(ellipsoidBoundingSphere, camera.position);\n    // check if overlay position is behind the horizon\n    if (!occluder.isPointVisible(cartesian)) {\n      this.setVisible(false);\n      return;\n    }\n    const cullingVolume = camera.frustum.computeCullingVolume(camera.position, camera.direction, camera.up);\n    // check if overlay position is visible from the camera\n    if (cullingVolume.computeVisibility(new Cesium.BoundingSphere(cartesian)) !== 1) {\n      this.setVisible(false);\n      return;\n    }\n    this.setVisible(true);\n\n    const pixelCartesian = this.scene_.cartesianToCanvasCoordinates(cartesian);\n    const pixel = [pixelCartesian.x, pixelCartesian.y];\n    const mapSize = [this.scene_.canvas.width, this.scene_.canvas.height];\n    this.updateRenderedPosition(pixel, mapSize);\n  }\n\n  /**\n   * Destroys the overlay, removing all its listeners and elements\n   * @api\n   */\n  destroy() {\n    if (this.scenePostRenderListenerRemover_) {\n      this.scenePostRenderListenerRemover_();\n    }\n    if (this.observer_) {\n      this.observer_.disconnect();\n    }\n    olObservableUnByKey(this.listenerKeys_);\n    this.listenerKeys_.splice(0);\n    if ('removeNode' in this.element) {\n      // @ts-ignore\n      this.element.removeNode(true);\n    } else {\n      this.element.remove();\n    }\n    this.element = null;\n  }\n}\n","import type {Collection, Map as OLMap, Overlay} from 'ol';\nimport SynchronizedOverlay from './SynchronizedOverlay';\nimport {getUid} from './util';\nimport type {Scene} from 'cesium';\nimport type {CollectionEvent} from 'ol/Collection.js';\n\nexport default class OverlaySynchronizer {\n  private overlayCollection_: Collection<Overlay>;\n  private overlayContainerStopEvent_: HTMLDivElement;\n  private overlayContainer_: HTMLDivElement;\n  private overlayMap_: Map<number, SynchronizedOverlay> = new Map();\n  private overlayEvents = ['click', 'dblclick', 'mousedown', 'touchstart', 'pointerdown', 'mousewheel', 'wheel'];\n\n  /**\n  * @param map\n  * @param scene\n  * @constructor\n  * @api\n  */\n  constructor(protected map: OLMap, protected scene: Scene) {\n    this.map = map;\n    this.overlayCollection_ = this.map.getOverlays();\n    this.scene = scene;\n    this.overlayContainerStopEvent_ = document.createElement('div');\n    this.overlayContainerStopEvent_.className = 'ol-overlaycontainer-stopevent';\n    this.overlayEvents.forEach((name) => {\n      this.overlayContainerStopEvent_.addEventListener(name, evt => evt.stopPropagation());\n    });\n    this.scene.canvas.parentElement.appendChild(this.overlayContainerStopEvent_);\n\n    this.overlayContainer_ = document.createElement('div');\n    this.overlayContainer_.className = 'ol-overlaycontainer';\n    this.scene.canvas.parentElement.appendChild(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 ol.MapBrowserEvent}.\n  * @return The map's overlay container that stops events.\n  */\n  getOverlayContainerStopEvent(): Element {\n    return this.overlayContainerStopEvent_;\n  }\n\n  /**\n  * Get the element that serves as a container for overlays.\n  * @return The map's overlay container.\n  */\n  getOverlayContainer(): Element {\n    return this.overlayContainer_;\n  }\n\n  /**\n  * Destroy all and perform complete synchronization of the overlays.\n  * @api\n  */\n  synchronize() {\n    this.destroyAll();\n    this.overlayCollection_.forEach((overlay) => { this.addOverlay(overlay); });\n    this.overlayCollection_.on('add', (evt: CollectionEvent<Overlay>) => this.addOverlay(evt.element));\n    this.overlayCollection_.on('remove', (evt: CollectionEvent<Overlay>) => this.removeOverlay(evt.element));\n  }\n\n\n  /**\n  * @api\n  */\n  addOverlay(overlay: Overlay) {\n    if (!overlay) {\n      return;\n    }\n    const cesiumOverlay = new SynchronizedOverlay({\n      scene: this.scene,\n      synchronizer: this,\n      parent: overlay\n    });\n\n    this.overlayMap_.set(getUid(overlay), cesiumOverlay);\n  }\n\n\n  /**\n  * Removes an overlay from the scene\n  * @api\n  */\n  removeOverlay(overlay: Overlay) {\n    const overlayId = getUid(overlay);\n    const csOverlay = this.overlayMap_.get(overlayId);\n    if (csOverlay) {\n      csOverlay.destroy();\n      this.overlayMap_.delete(overlayId);\n    }\n  }\n\n  /**\n  * Destroys all the created Cesium objects.\n  */\n  protected destroyAll() {\n    this.overlayMap_.forEach((overlay: SynchronizedOverlay) => {\n      overlay.destroy();\n    });\n    this.overlayMap_.clear();\n  }\n}\n","import olGeomPoint from 'ol/geom/Point.js';\nimport {supportsImageRenderingPixelated, imageRenderingValue} from './util';\nimport {ol4326CoordinateToCesiumCartesian} from './core';\nimport {getTransform, type TransformFunction} from 'ol/proj.js';\nimport olcsAutoRenderLoop from './AutoRenderLoop';\nimport olcsCamera from './Camera';\nimport olcsRasterSynchronizer from './RasterSynchronizer';\nimport olcsVectorSynchronizer from './VectorSynchronizer';\nimport olcsOverlaySynchronizer from './OverlaySynchronizer';\nimport type Map from 'ol/Map.js';\nimport type Interaction from 'ol/interaction/Interaction.js';\nimport type {Group} from 'ol/layer.js';\nimport type Feature from 'ol/Feature.js';\nimport type View from 'ol/View.js';\nimport type {\n  BoundingSphere, ContextOptions,\n  DataSourceCollection,\n  DataSourceDisplay,\n  Entity,\n  EntityView,\n  Globe,\n  JulianDate, MapMode2D, MapProjection, PerspectiveFrustum,\n  Scene,\n  ImageryLayer\n} from 'cesium';\nimport type AbstractSynchronizer from './AbstractSynchronizer';\nimport type VectorLayerCounterpart from './core/VectorLayerCounterpart';\n\n/**\n * Moved from Cesium\n * The state of a BoundingSphere computation being performed by a {@link Visualizer}.\n */\nconst BoundingSphereState: Record<string, number> = {\n  /**\n   * The BoundingSphere has been computed.\n   */\n  DONE: 0,\n  /**\n   * The BoundingSphere is still being computed.\n   */\n  PENDING: 1,\n  /**\n   * The BoundingSphere does not exist.\n   */\n  FAILED: 2,\n};\n\ntype SceneOptions = {\n  canvas: HTMLCanvasElement;\n  contextOptions?: ContextOptions;\n  creditContainer?: Element;\n  creditViewport?: Element;\n  mapProjection?: MapProjection;\n  orderIndependentTranslucency?: boolean;\n  scene3DOnly?: boolean;\n  shadows?: boolean;\n  mapMode2D?: MapMode2D;\n  requestRenderMode?: boolean;\n  maximumRenderTimeChange?: number;\n  depthPlaneEllipsoidOffset?: number;\n  msaaSamples?: number;\n}\n\ntype OLCesiumOptions = {\n  map: Map,\n  time?: () => JulianDate,\n  target?: Element | string,\n  createSynchronizers?: (map: Map, scene: Scene, dataSourceCollection: DataSourceCollection) => AbstractSynchronizer<ImageryLayer | VectorLayerCounterpart>[],\n  stopOpenLayersEventsPropagation?: boolean,\n  sceneOptions?: SceneOptions\n}\n\n// FIXME: remove this when all the synchronizers are migrated to typescript.\ntype SynchronizerType = AbstractSynchronizer<ImageryLayer | VectorLayerCounterpart>;\n\n/**\n * @typedef {Object} OLCesiumOptions\n * @property {import('ol/Map.js').default} map The OpenLayers map we want to show on a Cesium scene.\n * @property {Element|string} [target] Target element for the Cesium scene.\n * @property {function(!import('ol/Map.js').default, !Cesium.Scene, !Cesium.DataSourceCollection): Array<import('olcs/AbstractSynchronizer.js').default>}\n *      [createSynchronizers] Callback function which will be called by the {@link olcs.OLCesium}\n *      constructor to create custom synchronizers. Receives an `ol.Map` and a `Cesium.Scene` as arguments,\n *      and needs to return an array of {@link import('olcs/AbstractSynchronizer.js').default}.\n * @property {function(): Cesium.JulianDate} [time] Control the current time used by Cesium.\n * @property {boolean} [stopOpenLayersEventsPropagation] Prevent propagation of mouse/touch events to\n *      OpenLayers when Cesium is active.\n * @property {Cesium.SceneOptions} [sceneOptions] Allows the passing of property value to the\n *      `Cesium.Scene`.\n */\nexport default class OLCesium {\n  private autoRenderLoop_: olcsAutoRenderLoop | null = null;\n  private map_: Map;\n  private time_: () => JulianDate;\n  private to4326Transform_: TransformFunction;\n  private resolutionScale_ = 1.0;\n  private canvasClientWidth_ = 0.0;\n  private canvasClientHeight_ = 0.0;\n  private resolutionScaleChanged_ = true; // force resize\n  private container_: HTMLElement;\n  private isOverMap_: boolean;\n  private canvas_: HTMLCanvasElement;\n  private enabled_ = false;\n  private pausedInteractions_: Interaction[] = [];\n  private hiddenRootGroup_: Group | null = null;\n  private scene_: Scene;\n  private camera_: olcsCamera;\n  private globe_: Globe;\n  private dataSourceCollection_: DataSourceCollection;\n  private dataSourceDisplay_: DataSourceDisplay;\n  /** Time of the last rendered frame, as returned by `performance.now()`. */\n  private lastFrameTime_ = 0;\n  /** The identifier returned by `requestAnimationFrame`. */\n  private renderId_: number | undefined;\n  /** Target frame rate for the render loop.  */\n  private targetFrameRate_ = Number.POSITIVE_INFINITY;\n  /** If the Cesium render loop is being blocked. */\n  private blockCesiumRendering_ = false;\n  /** If the warmup routine is active. */\n  private warmingUp_ = false;\n  private trackedFeature_: Feature | null = null;\n  private trackedEntity_: Entity | null = null;\n  private entityView_: EntityView | null = null;\n  private needTrackedEntityUpdate_ = false;\n  private boundingSphereScratch_: BoundingSphere = new Cesium.BoundingSphere();\n  private synchronizers_: SynchronizerType[];\n\n  constructor(options: OLCesiumOptions) {\n    this.map_ = options.map;\n\n    this.time_ = options.time || function() {\n      return Cesium.JulianDate.now();\n    };\n\n    /**\n     * No change of the view projection.\n     */\n    this.to4326Transform_ = getTransform(this.map_.getView().getProjection(), 'EPSG:4326');\n\n    const fillArea = 'position:absolute;top:0;left:0;width:100%;height:100%;touch-action:none;';\n    this.container_ = document.createElement('DIV');\n    const containerAttribute = document.createAttribute('style');\n    containerAttribute.value = `${fillArea}visibility:hidden;`;\n    this.container_.setAttributeNode(containerAttribute);\n\n    let targetElement = options.target || this.map_.getViewport();\n    if (typeof targetElement === 'string') {\n      targetElement = document.getElementById(targetElement);\n    }\n    targetElement.appendChild(this.container_);\n\n    /**\n     * Whether the Cesium container is placed over the ol map.\n     * a target => side by side mode\n     * no target => over map mode\n     */\n    this.isOverMap_ = !options.target;\n\n\n    if (this.isOverMap_ && options.stopOpenLayersEventsPropagation) {\n      const overlayEvents = ['click', 'dblclick', 'mousedown', 'touchstart', 'pointerdown', 'mousewheel', 'wheel'];\n      for (let i = 0, ii = overlayEvents.length; i < ii; ++i) {\n        this.container_.addEventListener(overlayEvents[i], evt => evt.stopPropagation());\n      }\n    }\n\n    this.canvas_ = document.createElement<'canvas'>('canvas');\n    const canvasAttribute = document.createAttribute('style');\n    canvasAttribute.value = fillArea;\n    this.canvas_.setAttributeNode(canvasAttribute);\n\n    if (supportsImageRenderingPixelated()) {\n      // non standard CSS4\n      this.canvas_.style['imageRendering'] = imageRenderingValue();\n    }\n\n    this.canvas_.oncontextmenu = function() {\n      return false;\n    };\n    this.canvas_.onselectstart = function() {\n      return false;\n    };\n\n    this.container_.appendChild(this.canvas_);\n\n    const sceneOptions: SceneOptions = options.sceneOptions !== undefined ?\n      {...options.sceneOptions, canvas: this.canvas_, scene3DOnly: true} :\n      {canvas: this.canvas_, scene3DOnly: true};\n\n    this.scene_ = new Cesium.Scene(sceneOptions);\n\n    const sscc = this.scene_.screenSpaceCameraController;\n\n    if (!Array.isArray(sscc.tiltEventTypes)) {\n      console.log('sscc is not an array');\n    } else {\n      sscc.tiltEventTypes.push({\n        'eventType': Cesium.CameraEventType.LEFT_DRAG,\n        'modifier': Cesium.KeyboardEventModifier.SHIFT\n      });\n\n      sscc.tiltEventTypes.push({\n        'eventType': Cesium.CameraEventType.LEFT_DRAG,\n        'modifier': Cesium.KeyboardEventModifier.ALT\n      });\n    }\n\n    sscc.enableLook = false;\n\n    this.scene_.camera.constrainedAxis = Cesium.Cartesian3.UNIT_Z;\n\n    this.camera_ = new olcsCamera(this.scene_, this.map_);\n\n    this.globe_ = new Cesium.Globe(Cesium.Ellipsoid.WGS84);\n    this.globe_.baseColor = Cesium.Color.WHITE;\n    this.scene_.globe = this.globe_;\n    this.scene_.skyAtmosphere = new Cesium.SkyAtmosphere();\n\n    // The first layer of Cesium is special; using a 1x1 transparent image to workaround it.\n    // See https://github.com/AnalyticalGraphicsInc/cesium/issues/1323 for details.\n    const firstImageryProvider = new Cesium.SingleTileImageryProvider({\n      tileHeight: 1,\n      tileWidth: 1,\n      url: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=',\n      rectangle: Cesium.Rectangle.fromDegrees(0, 0, 1, 1) // the Rectangle dimensions are arbitrary\n    });\n    this.globe_.imageryLayers.addImageryProvider(firstImageryProvider, 0);\n\n    this.dataSourceCollection_ = new Cesium.DataSourceCollection();\n    this.dataSourceDisplay_ = new Cesium.DataSourceDisplay({\n      scene: this.scene_,\n      dataSourceCollection: this.dataSourceCollection_\n    });\n\n    this.synchronizers_ = options.createSynchronizers ?\n      options.createSynchronizers(this.map_, this.scene_, this.dataSourceCollection_) : [\n        new olcsRasterSynchronizer(this.map_, this.scene_),\n        new olcsVectorSynchronizer(this.map_, this.scene_),\n        new olcsOverlaySynchronizer(this.map_, this.scene_)\n      ] as unknown as SynchronizerType[];\n\n    // Assures correct canvas size after initialisation\n    this.handleResize_();\n\n    for (let i = this.synchronizers_.length - 1; i >= 0; --i) {\n      this.synchronizers_[i].synchronize();\n    }\n\n    const eventHelper = new Cesium.EventHelper();\n    eventHelper.add(this.scene_.postRender, OLCesium.prototype.updateTrackedEntity_, this);\n  }\n\n  /**\n   * Destroys the Cesium resources held by this object.\n   */\n  destroy() {\n    cancelAnimationFrame(this.renderId_);\n    this.renderId_ = undefined;\n    this.synchronizers_.forEach(synchronizer => synchronizer.destroyAll());\n    this.camera_.destroy();\n    this.scene_.destroy();\n    // @ts-ignore TS2341\n    this.scene_._postRender = null;\n    this.container_.remove();\n  }\n\n  /**\n   * Render the Cesium scene.\n   */\n  private render_() {\n    // if a call to `requestAnimationFrame` is pending, cancel it\n    if (this.renderId_ !== undefined) {\n      cancelAnimationFrame(this.renderId_);\n      this.renderId_ = undefined;\n    }\n\n    // only render if Cesium is enabled/warming and rendering hasn't been blocked\n    if ((this.enabled_ || this.warmingUp_) && !this.blockCesiumRendering_) {\n      this.renderId_ = requestAnimationFrame(this.onAnimationFrame_.bind(this));\n    }\n  }\n\n  /**\n   * Callback for `requestAnimationFrame`.\n   * @param {number} frameTime The frame time, from `performance.now()`.\n   */\n  private onAnimationFrame_(frameTime: number) {\n    this.renderId_ = undefined;\n\n    // check if a frame was rendered within the target frame rate\n    const interval = 1000.0 / this.targetFrameRate_;\n    const delta = frameTime - this.lastFrameTime_;\n    if (delta < interval) {\n      // too soon, don't render yet\n      this.render_();\n      return;\n    }\n\n    // time to render a frame, save the time\n    this.lastFrameTime_ = frameTime;\n\n    const julianDate = this.time_();\n    // initializeFrame private property\n    // @ts-ignore TS2341\n    this.scene_.initializeFrame();\n    this.handleResize_();\n    this.dataSourceDisplay_.update(julianDate);\n\n    // Update tracked entity\n    if (this.entityView_) {\n      const trackedEntity = this.trackedEntity_;\n      // getBoundingSphere private property\n      // @ts-ignore TS2341\n      const trackedState = this.dataSourceDisplay_.getBoundingSphere(trackedEntity, false, this.boundingSphereScratch_);\n      if (trackedState === BoundingSphereState.DONE) {\n        this.boundingSphereScratch_.radius = 1; // a radius of 1 is enough for tracking points\n        this.entityView_.update(julianDate, this.boundingSphereScratch_);\n      }\n    }\n\n    this.scene_.render(julianDate);\n    this.camera_.checkCameraChange();\n\n    // request the next render call after this one completes to ensure the browser doesn't get backed up\n    this.render_();\n  }\n\n  private updateTrackedEntity_() {\n    if (!this.needTrackedEntityUpdate_) {\n      return;\n    }\n\n    const trackedEntity = this.trackedEntity_;\n    const scene = this.scene_;\n\n    // getBoundingSphere private property\n    // @ts-ignore TS2341\n    const state = this.dataSourceDisplay_.getBoundingSphere(trackedEntity, false, this.boundingSphereScratch_);\n    if (state === BoundingSphereState.PENDING) {\n      return;\n    }\n\n    scene.screenSpaceCameraController.enableTilt = false;\n\n    const bs = state !== BoundingSphereState.FAILED ? this.boundingSphereScratch_ : undefined;\n    if (bs) {\n      bs.radius = 1;\n    }\n    this.entityView_ = new Cesium.EntityView(trackedEntity, scene, scene.mapProjection.ellipsoid);\n    this.entityView_.update(this.time_(), bs);\n    this.needTrackedEntityUpdate_ = false;\n  }\n\n  private handleResize_() {\n    let width = this.canvas_.clientWidth;\n    let height = this.canvas_.clientHeight;\n\n    if (width === 0 || height === 0) {\n      // The canvas DOM element is not ready yet.\n      return;\n    }\n\n    if (width === this.canvasClientWidth_ &&\n        height === this.canvasClientHeight_ &&\n        !this.resolutionScaleChanged_) {\n      return;\n    }\n\n    let resolutionScale = this.resolutionScale_;\n    if (!supportsImageRenderingPixelated()) {\n      resolutionScale *= window.devicePixelRatio || 1.0;\n    }\n    this.resolutionScaleChanged_ = false;\n\n    this.canvasClientWidth_ = width;\n    this.canvasClientHeight_ = height;\n\n    width *= resolutionScale;\n    height *= resolutionScale;\n\n    this.canvas_.width = width;\n    this.canvas_.height = height;\n    (<PerspectiveFrustum> this.scene_.camera.frustum).aspectRatio = width / height;\n  }\n\n  getCamera(): olcsCamera {\n    return this.camera_;\n  }\n\n  getOlMap(): Map {\n    return this.map_;\n  }\n\n  getOlView(): View {\n    const view = this.map_.getView();\n    console.assert(view);\n    return view;\n  }\n\n  getCesiumScene(): Scene {\n    return this.scene_;\n  }\n\n  getDataSources(): DataSourceCollection {\n    return this.dataSourceCollection_;\n  }\n\n  getDataSourceDisplay(): DataSourceDisplay {\n    return this.dataSourceDisplay_;\n  }\n\n  getEnabled(): boolean {\n    return this.enabled_;\n  }\n\n  /**\n   * Enables/disables the Cesium.\n   * This modifies the visibility style of the container element.\n   */\n  setEnabled(enable: boolean) {\n    if (this.enabled_ === enable) {\n      return;\n    }\n    this.enabled_ = enable;\n\n    // some Cesium operations are operating with canvas.clientWidth,\n    // so we can't remove it from DOM or even make display:none;\n    this.container_.style.visibility = this.enabled_ ? 'visible' : 'hidden';\n    let interactions;\n    if (this.enabled_) {\n      this.throwOnUnitializedMap_();\n      if (this.isOverMap_) {\n        interactions = this.map_.getInteractions();\n        interactions.forEach((el, i, arr) => {\n          this.pausedInteractions_.push(el);\n        });\n        interactions.clear();\n\n        this.map_.addInteraction = interaction => this.pausedInteractions_.push(interaction);\n        this.map_.removeInteraction = (interaction) => {\n          let interactionRemoved = false;\n          this.pausedInteractions_ = this.pausedInteractions_.filter((i) => {\n            const removed = i !== interaction;\n            if (!interactionRemoved) {interactionRemoved = removed;}\n            return removed;\n          });\n          return interactionRemoved ? interaction : undefined;\n        };\n\n        const rootGroup = this.map_.getLayerGroup();\n        if (rootGroup.getVisible()) {\n          this.hiddenRootGroup_ = rootGroup;\n          this.hiddenRootGroup_.setVisible(false);\n        }\n\n        this.map_.getOverlayContainer().classList.add('olcs-hideoverlay');\n      }\n\n      this.camera_.readFromView();\n      this.render_();\n    } else {\n      if (this.isOverMap_) {\n        interactions = this.map_.getInteractions();\n        this.pausedInteractions_.forEach((interaction) => {\n          interactions.push(interaction);\n        });\n        this.pausedInteractions_.length = 0;\n\n        this.map_.addInteraction = interaction => this.map_.getInteractions().push(interaction);\n        this.map_.removeInteraction = interaction => this.map_.getInteractions().remove(interaction);\n\n        this.map_.getOverlayContainer().classList.remove('olcs-hideoverlay');\n        if (this.hiddenRootGroup_) {\n          this.hiddenRootGroup_.setVisible(true);\n          this.hiddenRootGroup_ = null;\n        }\n      }\n\n      this.camera_.updateView();\n    }\n  }\n\n  /**\n   * Preload Cesium so that it is ready when transitioning from 2D to 3D.\n   * @param {number} height Target height of the camera\n   * @param {number} timeout Milliseconds after which the warming will stop\n  */\n  warmUp(height: number, timeout: number) {\n    if (this.enabled_) {\n      // already enabled\n      return;\n    }\n    this.throwOnUnitializedMap_();\n    this.camera_.readFromView();\n    const ellipsoid = this.globe_.ellipsoid;\n    const csCamera = this.scene_.camera;\n    const position = ellipsoid.cartesianToCartographic(csCamera.position);\n    if (position.height < height) {\n      position.height = height;\n      csCamera.position = ellipsoid.cartographicToCartesian(position);\n    }\n\n    this.warmingUp_ = true;\n    this.render_();\n\n    setTimeout(() => {\n      this.warmingUp_ = false;\n    }, timeout);\n  }\n\n  /**\n   * Block Cesium rendering to save resources.\n   * @param {boolean} block True to block.\n  */\n  setBlockCesiumRendering(block: boolean) {\n    if (this.blockCesiumRendering_ !== block) {\n      this.blockCesiumRendering_ = block;\n\n      // reset the render loop\n      this.render_();\n    }\n  }\n\n  /**\n   * Render the globe only when necessary in order to save resources.\n   * Experimental.\n   */\n  enableAutoRenderLoop() {\n    if (!this.autoRenderLoop_) {\n      this.autoRenderLoop_ = new olcsAutoRenderLoop(this);\n    }\n  }\n\n  /**\n   * Get the autorender loop.\n  */\n  getAutoRenderLoop(): olcsAutoRenderLoop {\n    return this.autoRenderLoop_;\n  }\n\n  /**\n   * The 3D Cesium globe is rendered in a canvas with two different dimensions:\n   * clientWidth and clientHeight which are the dimension on the screen and\n   * width and height which are the dimensions of the drawing buffer.\n   *\n   * By using a resolution scale lower than 1.0, it is possible to render the\n   * globe in a buffer smaller than the canvas client dimensions and improve\n   * performance, at the cost of quality.\n   *\n   * Pixel ratio should also be taken into account; by default, a device with\n   * pixel ratio of 2.0 will have a buffer surface 4 times bigger than the client\n   * surface.\n   */\n  setResolutionScale(value: number) {\n    value = Math.max(0, value);\n    if (value !== this.resolutionScale_) {\n      this.resolutionScale_ = Math.max(0, value);\n      this.resolutionScaleChanged_ = true;\n      if (this.autoRenderLoop_) {\n        this.autoRenderLoop_.restartRenderLoop();\n      }\n    }\n  }\n\n  /**\n   * Set the target frame rate for the renderer. Set to `Number.POSITIVE_INFINITY`\n   * to render as quickly as possible.\n   * @param {number} value The frame rate, in frames per second.\n   */\n  setTargetFrameRate(value: number) {\n    if (this.targetFrameRate_ !== value) {\n      this.targetFrameRate_ = value;\n\n      // reset the render loop\n      this.render_();\n    }\n  }\n\n  /**\n   * Check if OpenLayers map is not properly initialized.\n   */\n  private throwOnUnitializedMap_() {\n    const map = this.map_;\n    const view = map.getView();\n    const center = view.getCenter();\n    if (!view.isDef() || isNaN(center[0]) || isNaN(center[1])) {\n      throw new Error(`The OpenLayers map is not properly initialized: ${center} / ${view.getResolution()}`);\n    }\n  }\n\n  get trackedFeature(): Feature {\n    return this.trackedFeature_;\n  }\n\n  set trackedFeature(feature: Feature) {\n    if (this.trackedFeature_ !== feature) {\n\n      const scene = this.scene_;\n\n      //Stop tracking\n      if (!feature || !feature.getGeometry()) {\n        this.needTrackedEntityUpdate_ = false;\n        scene.screenSpaceCameraController.enableTilt = true;\n\n        if (this.trackedEntity_) {\n          this.dataSourceDisplay_.defaultDataSource.entities.remove(this.trackedEntity_);\n        }\n        this.trackedEntity_ = null;\n        this.trackedFeature_ = null;\n        this.entityView_ = null;\n        scene.camera.lookAtTransform(Cesium.Matrix4.IDENTITY);\n        return;\n      }\n\n      this.trackedFeature_ = feature;\n\n      //We can't start tracking immediately, so we set a flag and start tracking\n      //when the bounding sphere is ready (most likely next frame).\n      this.needTrackedEntityUpdate_ = true;\n\n      const to4326Transform = this.to4326Transform_;\n      const toCesiumPosition = function() {\n        const geometry = feature.getGeometry();\n        console.assert(geometry instanceof olGeomPoint);\n        const coo = geometry instanceof olGeomPoint ? geometry.getCoordinates() : [];\n        const coo4326 = to4326Transform(coo, undefined, coo.length);\n        return ol4326CoordinateToCesiumCartesian(coo4326);\n      };\n\n      // Create an invisible point entity for tracking.\n      // It is independent of the primitive/geometry created by the vector synchronizer.\n      const options: Entity.ConstructorOptions = {\n        // @ts-ignore according to Cesium types, not possible to pass CallbackProperty\n        position: new Cesium.CallbackProperty((time, result) => toCesiumPosition(), false),\n        point: {\n          pixelSize: 1,\n          color: Cesium.Color.TRANSPARENT\n        }\n      };\n\n      this.trackedEntity_ = this.dataSourceDisplay_.defaultDataSource.entities.add(options);\n    }\n  }\n}\n","export interface RectangleOutput {\n  scaling: [number, number];\n  offsetX: number;\n  offsetY: number;\n  width: number;\n  height: number;\n}\n\nexport function computeRectangle(canvas: HTMLCanvasElement, tw: number, th: number): RectangleOutput {\n\n  const maskAspectRatio = tw / th;\n  let maskSize;\n\n  if (maskAspectRatio > 1) {\n    // landscape\n    maskSize = [canvas.width, canvas.width / maskAspectRatio];\n    if (maskSize[1] > canvas.height) {\n      maskSize = [canvas.height * maskAspectRatio, canvas.height];\n    }\n  }\n  else {\n    // portrait\n    maskSize = [canvas.height * maskAspectRatio, canvas.height];\n    if (maskSize[0] > canvas.width) {\n      maskSize = [canvas.width, canvas.width / maskAspectRatio];\n    }\n  }\n\n  return {\n    scaling: [maskSize[0] / canvas.width, maskSize[1] / canvas.height],\n    width: maskSize[0],\n    height: maskSize[1],\n    offsetX: (canvas.width - maskSize[0]) / 2,\n    offsetY: (canvas.height - maskSize[1]) / 2,\n  };\n}\n","import type {Scene} from 'cesium';\n\nlet postUnlistener: Function = null;\n\ninterface ProgramInfo {\n  program: WebGLProgram,\n  attribLocations: {\n    vertexPosition: number\n  },\n  uniformLocations: {\n    uScaling: WebGLUniformLocation\n  }\n}\n\n\n// CC0 from https://github.com/mdn/dom-examples/tree/main/webgl-examples/tutorial/sample2\n\n\nexport class MaskDrawer {\n  private programInfo: ProgramInfo;\n  private positionBuffer: WebGLBuffer;\n\n  constructor(private gl: WebGL2RenderingContext | WebGLRenderingContext) {\n    const shaderProgram = this.initShaderProgram();\n\n    this.programInfo = {\n      program: shaderProgram,\n      attribLocations: {\n        vertexPosition: gl.getAttribLocation(shaderProgram, 'aVertexPosition')\n      },\n      uniformLocations: {\n        uScaling: gl.getUniformLocation(\n            shaderProgram,\n            'uScaling'\n        )\n      }\n    };\n\n    this.positionBuffer = gl.createBuffer();\n    const positions = [1.0, 1.0, -1.0, 1.0, 1.0, -1.0, -1.0, -1.0];\n\n    gl.bindBuffer(gl.ARRAY_BUFFER, this.positionBuffer);\n    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW);\n  }\n\n  getVertexShaderSource() {\n    return `\n      attribute vec4 aVertexPosition;\n      uniform vec2 uScaling;\n      void main() {\n        gl_Position = vec4(aVertexPosition[0] * uScaling[0], aVertexPosition[1] * uScaling[1], -1.0, 1.0);\n      }\n    `;\n  }\n\n  getFragmentShaderSource() {\n    return `\n      precision highp float;\n      void main() {\n        gl_FragColor = vec4(.5, .5, .5, .6);\n      }\n  `;\n  }\n\n  /**\n   *\n   */\n  private initShaderProgram(): WebGLProgram {\n    const gl = this.gl;\n    const vsSource = this.getVertexShaderSource();\n    const fsSource = this.getFragmentShaderSource();\n    const vertexShader = MaskDrawer.loadShader(gl, gl.VERTEX_SHADER, vsSource),\n        fragmentShader = MaskDrawer.loadShader(gl, gl.FRAGMENT_SHADER, fsSource),\n        shaderProgram = gl.createProgram();\n\n    gl.attachShader(shaderProgram, vertexShader);\n    gl.attachShader(shaderProgram, fragmentShader);\n    gl.linkProgram(shaderProgram);\n\n    // If creating the shader program failed, alert\n\n    if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {\n      throw new Error(\n          `Unable to initialize the shader program: ${gl.getProgramInfoLog(\n              shaderProgram\n          )}`\n      );\n    }\n\n    return shaderProgram;\n  }\n\n\n  /**\n   *\n   * @param {number[]} scaling scaling\n   */\n  drawMask(scaling: number[]) {\n    const gl = this.gl;\n    const programInfo = this.programInfo;\n    // Blend\n    gl.enable(gl.BLEND);\n\n    gl.bindBuffer(gl.ARRAY_BUFFER, this.positionBuffer);\n    gl.vertexAttribPointer(\n        programInfo.attribLocations.vertexPosition,\n        2,\n        gl.FLOAT,\n        false,\n        0,\n        0\n    );\n    gl.enableVertexAttribArray(programInfo.attribLocations.vertexPosition);\n    gl.useProgram(programInfo.program);\n\n\n    // Draw a first time to fill the stencil area while keeping the destination color\n    gl.enable(gl.STENCIL_TEST);\n    gl.stencilFunc(\n        gl.ALWAYS,\n        1,\n        0xFF\n    );\n    gl.stencilOp(\n        gl.KEEP,\n        gl.KEEP,\n        gl.REPLACE\n    );\n    gl.uniform2fv(\n        programInfo.uniformLocations.uScaling,\n        scaling\n    );\n    gl.blendFunc(gl.ZERO, gl.ONE);\n    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);\n\n\n    // Now draw again the whole viewport and darken the pixels that are not on the stencil\n    gl.stencilFunc(\n        gl.EQUAL,\n        0,\n        0xFF\n    );\n    gl.stencilOp(\n        gl.KEEP,\n        gl.KEEP,\n        gl.KEEP\n    );\n    gl.uniform2fv(\n        programInfo.uniformLocations.uScaling,\n        [1, 1]\n    );\n    gl.blendFunc(gl.ZERO, gl.SRC_ALPHA);\n    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);\n  }\n\n\n\n  /**\n   */\n  private static loadShader(gl: WebGL2RenderingContext | WebGLRenderingContext, type: number, source: string): WebGLShader {\n    const shader = gl.createShader(type);\n\n    gl.shaderSource(shader, source);\n    gl.compileShader(shader);\n\n    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {\n      throw new Error(\n          `An error occurred compiling the shaders: ${gl.getShaderInfoLog(shader)}`\n      );\n      // gl.deleteShader(shader);\n    }\n\n    return shader;\n  }\n}\n\n/**\n *\n */\nexport function autoDrawMask(scene: Scene, getScalings: () => number[]) {\n  const canvas = scene.canvas;\n  const ctx = canvas.getContext('webgl2') || canvas.getContext('webgl');\n\n  if (getScalings) {\n    if (!postUnlistener) {\n      const drawer = new MaskDrawer(ctx);\n      postUnlistener = scene.postRender.addEventListener(() => {\n        drawer.drawMask(getScalings());\n      });\n    }\n  }\n  else if (postUnlistener) {\n    postUnlistener();\n    // FIXME: destroy program\n    postUnlistener = null;\n  }\n  scene.requestRender();\n}\n","import type {Scene} from 'cesium';\n\ninterface ScreenshotOptions {\n  offsetX: number;\n  offsetY: number;\n  width: number;\n  height: number;\n}\n\n/**\n */\nexport function takeScreenshot(scene: Scene, options: ScreenshotOptions): Promise<string> {\n  return new Promise((resolve, reject) => {\n  // preserveDrawingBuffers is false so we render on demand and immediately read the buffer\n    const remover = scene.postRender.addEventListener(() => {\n      remover();\n      try {\n        let url;\n\n        if (options) {\n          const smallerCanvas = document.createElement('canvas');\n\n          smallerCanvas.width = options.width;\n          smallerCanvas.height = options.height;\n          smallerCanvas.getContext('2d').drawImage(\n              scene.canvas,\n              options.offsetX, options.offsetY, options.width, options.height,\n              0, 0, options.width, options.height);\n          url = smallerCanvas.toDataURL();\n        }\n        else {\n          url = scene.canvas.toDataURL();\n        }\n        resolve(url);\n      }\n      catch (e) {\n        reject(e);\n      }\n    });\n\n    scene.requestRender();\n  });\n}\n","export default class LazyLoader {\n  private promise: Promise<void> | undefined;\n  private url_: string;\n\n  /**\n   * @param url\n   * @api\n   */\n  constructor(url: string) {\n    this.url_ = url;\n  }\n\n  /**\n   * Load Cesium by injecting a script tag.\n   * @api\n   */\n  load(): Promise<void> {\n    if (!this.promise) {\n      // not yet loading\n      this.promise = new Promise((resolve, reject) => {\n        const script = document.createElement('script');\n        script.onload = () => resolve();\n        script.onerror = () => reject();\n        document.head.appendChild(script);\n        script.src = this.url_;\n      });\n    }\n    return this.promise;\n  }\n}\n","import olcsContribLazyLoader from './LazyLoader';\nimport OLCesium from '../OLCesium';\nimport {resetToNorthZenith, rotateAroundBottomCenter, computeSignedTiltAngleOnGlobe, pickBottomPoint, setHeadingUsingBottomCenter, limitCameraToBoundingSphere} from '../core';\nimport {toRadians} from '../math';\nimport Observable from 'ol/Observable.js';\nimport type OLMap from 'ol/Map.js';\nimport type {Extent} from 'ol/extent.js';\nimport type {BoundingSphere, Matrix4, Rectangle, Scene} from 'cesium';\n\n\n/**\n * @typedef {Object} ManagerOptions\n * @property {import('ol/Map.js').default} map\n * @property {import('ol/extent.js').Extent} [cameraExtentInRadians]\n * @property {string} [cesiumIonDefaultAccessToken]\n */\n\n\nexport default class Manager extends Observable {\n  private cesiumUrl_: string;\n  private boundingSphere_: BoundingSphere;\n  private promise_: Promise<OLCesium>;\n  private cesiumIonDefaultAccessToken_: string;\n  protected map: OLMap;\n  protected cameraExtentInRadians: Extent;\n  protected ol3d: OLCesium;\n  private cesiumInitialTilt_ = toRadians(50);\n\n  protected fogDensity = 0.0001;\n\n  protected fogSSEFactor = 25;\n\n  protected minimumZoomDistance = 2;\n\n  /**\n   * Limit the maximum distance to the earth to 10'000km.\n   */\n  protected maximumZoomDistance: number = 10000000;\n\n  // when closer to 3000m, restrict the available positions harder\n  protected limitCameraToBoundingSphereRatio = (height: number) => (height > 3000 ? 9 : 3);\n\n  /**\n   * @param {string} cesiumUrl\n   * @param {olcsx.contrib.ManagerOptions} options\n   * @api\n   */\n  constructor(cesiumUrl: string, {map, cameraExtentInRadians, cesiumIonDefaultAccessToken}: {map: OLMap, cameraExtentInRadians?: Extent, cesiumIonDefaultAccessToken?: string}) {\n    super();\n    this.cesiumUrl_ = cesiumUrl;\n    console.assert(map);\n    this.map = map;\n    this.cameraExtentInRadians = cameraExtentInRadians || null;\n    this.cesiumIonDefaultAccessToken_ = cesiumIonDefaultAccessToken;\n  }\n\n\n  /**\n   * Lazy load Cesium.\n   */\n  load(): Promise<OLCesium> {\n    if (!this.promise_) {\n      const cesiumLazyLoader = new olcsContribLazyLoader(this.cesiumUrl_);\n      this.promise_ = cesiumLazyLoader.load().then(() => this.onCesiumLoaded());\n    }\n    return this.promise_;\n  }\n\n\n  /**\n   * Hook called when Cesium has been lazy loaded.\n   */\n  protected onCesiumLoaded(): OLCesium {\n    if (this.cameraExtentInRadians) {\n      const rect = new Cesium.Rectangle(...this.cameraExtentInRadians);\n      // Set the fly home rectangle\n      Cesium.Camera.DEFAULT_VIEW_RECTANGLE = rect;\n      this.boundingSphere_ = Cesium.BoundingSphere.fromRectangle3D(rect, Cesium.Ellipsoid.WGS84, 300); // lux mean height is 300m\n    }\n\n    if (this.cesiumIonDefaultAccessToken_) {\n      Cesium.Ion.defaultAccessToken = this.cesiumIonDefaultAccessToken_;\n    }\n\n    this.ol3d = this.instantiateOLCesium();\n    const scene = this.ol3d.getCesiumScene();\n    this.configureForUsability(scene);\n    this.configureForPerformance(scene);\n    this.dispatchEvent('load');\n    return this.ol3d;\n  }\n\n\n  /**\n   * Application code should override this method.\n   */\n  instantiateOLCesium(): OLCesium {\n    const ol3d = new OLCesium({map: this.map});\n    const scene = ol3d.getCesiumScene();\n    // LEGACY\n    if ('createWorldTerrain' in Cesium) {\n      // @ts-ignore\n      const terrainProvider = Cesium.createWorldTerrain();\n      scene.terrainProvider = terrainProvider;\n    } else {\n      // v107+\n      Cesium.createWorldTerrainAsync().then(tp => scene.terrainProvider = tp);\n    }\n\n    return ol3d;\n  }\n\n\n  /**\n   * Override with custom performance optimization logics, if needed.\n   */\n  protected configureForPerformance(scene: Scene) {\n    const fog = scene.fog;\n    fog.enabled = true;\n    fog.density = this.fogDensity;\n    fog.screenSpaceErrorFactor = this.fogSSEFactor;\n  }\n\n\n  /**\n   * Override with custom usabliity logics, id needed.\n   */\n  configureForUsability(scene: Scene) {\n    const sscController = scene.screenSpaceCameraController;\n    sscController.minimumZoomDistance = this.minimumZoomDistance;\n    sscController.maximumZoomDistance = this.maximumZoomDistance;\n\n    // Do not see through the terrain. Seeing through the terrain does not make\n    // sense anyway, except for debugging\n    scene.globe.depthTestAgainstTerrain = true;\n\n    // Use white instead of the black default colour for the globe when tiles are missing\n    scene.globe.baseColor = Cesium.Color.WHITE;\n    scene.backgroundColor = Cesium.Color.WHITE;\n\n    if (this.boundingSphere_) {\n      scene.postRender.addEventListener(this.limitCameraToBoundingSphere.bind(this));\n    }\n    // Stop rendering Cesium when there is nothing to do. This drastically reduces CPU/GPU consumption.\n    this.ol3d.enableAutoRenderLoop();\n  }\n\n  /**\n   * Constrain the camera so that it stays close to the bounding sphere of the map extent.\n   * Near the ground the allowed distance is shorter.\n   */\n  protected limitCameraToBoundingSphere() {\n    const scene = this.ol3d.getCesiumScene();\n    limitCameraToBoundingSphere(scene.camera, this.boundingSphere_, this.limitCameraToBoundingSphereRatio);\n  }\n\n  /**\n   * Enable or disable ol3d with a default animation.\n   */\n  toggle3d(): Promise<void> {\n    return this.load().then((/** @const {!olcs.OLCesium} */ ol3d) => {\n      const is3DCurrentlyEnabled = ol3d.getEnabled();\n      const scene = ol3d.getCesiumScene();\n      if (is3DCurrentlyEnabled) {\n        // Disable 3D\n        console.assert(this.map);\n        return resetToNorthZenith(this.map, scene).then(() => {\n          ol3d.setEnabled(false);\n          this.dispatchEvent('toggle');\n        });\n      } else {\n        // Enable 3D\n        ol3d.setEnabled(true);\n        this.dispatchEvent('toggle');\n        return rotateAroundBottomCenter(scene, this.cesiumInitialTilt_);\n      }\n    });\n  }\n\n\n  /**\n   * Enable ol3d with a view built from parameters.\n   */\n  set3dWithView(lon: number, lat: number, elevation: number, headingDeg: number, pitchDeg: number): Promise<void> {\n    return this.load().then((ol3d) => {\n      const is3DCurrentlyEnabled = ol3d.getEnabled();\n      const scene = ol3d.getCesiumScene();\n      const camera = scene.camera;\n      const destination = Cesium.Cartesian3.fromDegrees(lon, lat, elevation);\n      const heading = Cesium.Math.toRadians(headingDeg);\n      const pitch = Cesium.Math.toRadians(pitchDeg);\n      const roll = 0;\n      const orientation = {heading, pitch, roll};\n\n      if (!is3DCurrentlyEnabled) {\n        ol3d.setEnabled(true);\n        this.dispatchEvent('toggle');\n      }\n\n      camera.setView({\n        destination,\n        orientation\n      });\n    });\n  }\n\n\n  /**\n   * Whether OL-Cesium has been loaded and 3D mode is enabled.\n   */\n  is3dEnabled(): boolean {\n    return !!this.ol3d && this.ol3d.getEnabled();\n  }\n\n\n  /**\n   * @return {number}\n   */\n  getHeading(): number {\n    return this.map ? this.map.getView().getRotation() || 0 : 0;\n  }\n\n\n  /**\n   * @return {number|undefined}\n   */\n  getTiltOnGlobe() {\n    const scene = this.ol3d.getCesiumScene();\n    const tiltOnGlobe = computeSignedTiltAngleOnGlobe(scene);\n    return -tiltOnGlobe;\n  }\n\n\n  /**\n   * Set heading.\n   * This assumes ol3d has been loaded.\n   */\n  setHeading(angle: number) {\n    const scene = this.ol3d.getCesiumScene();\n    const bottom = pickBottomPoint(scene);\n    if (bottom) {\n      setHeadingUsingBottomCenter(scene, angle, bottom);\n    }\n  }\n\n  getOl3d(): OLCesium {\n    return this.ol3d;\n  }\n\n  getCesiumViewMatrix(): Matrix4 {\n    return this.ol3d.getCesiumScene().camera.viewMatrix;\n  }\n\n  getCesiumScene(): Scene {\n    return this.ol3d.getCesiumScene();\n  }\n\n  /**\n   * Fly to some rectangle.\n   * This assumes ol3d has been loaded.\n   */\n  flyToRectangle(rectangle: Rectangle, offset = 0): Promise<void> {\n    const camera = this.getCesiumScene().camera;\n    const destination = camera.getRectangleCameraCoordinates(rectangle);\n\n    const mag = Cesium.Cartesian3.magnitude(destination) + offset;\n    Cesium.Cartesian3.normalize(destination, destination);\n    Cesium.Cartesian3.multiplyByScalar(destination, mag, destination);\n\n    return new Promise((resolve, reject) => {\n      if (!this.cameraExtentInRadians) {\n        reject();\n        return;\n      }\n\n      camera.flyTo({\n        destination,\n        complete: () => resolve(),\n        cancel: () => reject(),\n        endTransform: Cesium.Matrix4.IDENTITY\n      });\n    });\n  }\n}\n","import OLCesium from './olcs/OLCesium';\nexport default OLCesium;\n\nexport {default as AbstractSynchronizer} from './olcs/AbstractSynchronizer';\nexport {default as RasterSynchronizer} from './olcs/RasterSynchronizer';\nexport {default as VectorSynchronizer} from './olcs/VectorSynchronizer';\n\nexport {default as FeatureConverter} from './olcs/FeatureConverter';\nexport {default as OLCSCamera} from './olcs/Camera';\n\n// Core api functions\nexport * from './olcs/core';\nexport {default as OLImageryProvider} from './olcs/core/OLImageryProvider';\nexport {default as VectorLayerCounterpart} from './olcs/core/VectorLayerCounterpart';\n\n// Print functions\nexport * from './olcs/print';\n\n// Contrib Manager\nexport {default as ContribManager} from './olcs/contrib/Manager';\nexport {default as ContribLazyLoader} from './olcs/contrib/LazyLoader';\n\n// Deprecated export of olcs on window\nconst olcs = window['olcs'] = {};\nolcs.OLCesium = OLCesium;\n\nimport {default as AbstractSynchronizer} from './olcs/AbstractSynchronizer';\nimport {default as RasterSynchronizer} from './olcs/RasterSynchronizer';\nimport {default as VectorSynchronizer} from './olcs/VectorSynchronizer';\nolcs.AbstractSynchronizer = AbstractSynchronizer;\nolcs.RasterSynchronizer = RasterSynchronizer;\nolcs.VectorSynchronizer = VectorSynchronizer;\n\nimport * as core from './olcs/core';\nimport {default as OLImageryProvider} from './olcs/core/OLImageryProvider';\nimport {default as VectorLayerCounterpart} from './olcs/core/VectorLayerCounterpart';\nolcs.core = core;\nolcs.core.OLImageryProvider = OLImageryProvider;\nolcs.core.VectorLayerCounterpart = VectorLayerCounterpart;\n\nolcs.contrib = {};\nimport {default as ContribManager} from './olcs/contrib/Manager';\nimport {default as ContribLazyLoader} from './olcs/contrib/LazyLoader';\nolcs.contrib.LazyLoader = ContribLazyLoader;\nolcs.contrib.Manager = ContribManager;\n"],"names":["__webpack_require__","module","getter","__esModule","d","a","exports","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","ol","geom","Point","_imageRenderingPixelatedSupported","_imageRenderingValue","supportsImageRenderingPixelated","undefined","canvas","document","createElement","setAttribute","imageRenderingValue","style","imageRendering","getSourceProjection","source","getProjection","uidCounter_","getUid","olcs_uid","waitReady","object","p","readyPromise","ready","Promise","resolve","_","stopper","setInterval","clearInterval","reject","easing","layer","Tile","Image","proj","ImageStatic","ImageWMS","TileImage","TileWMS","VectorTile","createEmptyCanvas","width","height","olUseNewCoordinates","tileCoord","TileSource","projection","wrapX","getTileCoordForTileUrlFunction","OLImageryProvider","this","ready_","rectangle","rectangle_","tilingScheme","tilingScheme_","_ready","tileWidth","tileGrid","source_","getTileGrid","tileSizeAtZoom0","getTileSize","Array","isArray","tileHeight","maximumLevel","getMaxZoom","minimumLevel","tileDiscardPolicy","hasAlphaChannel","pickFeatures","x","y","level","longitude","latitude","constructor","olMap","opt_fallbackProj","emptyCanvas_","emptyCanvasPromise_","errorEvent","Cesium","Event","projection_","fallbackProj_","WebMercatorTilingScheme","map_","shouldRequestNextLevel","proxy","DefaultProxy","on","e","handleSourceChanged_","getState","options","numberOfLevelZeroTilesX","numberOfLevelZeroTilesY","forEachTileCoord","getExtent","_ref","zoom","xIndex","yIndex","getCode","GeographicTilingScheme","getTileCredits","attributionsFunction","getAttributions","extent","getView","calculateExtent","getSize","center","getCenter","attributionsFunctionToCredits","requestImage","request","tileUrlFunction","getTileUrlFunction","z_","y_","url","getURL","ImageryProvider","loadImage","format","MVT","Style","Stroke","render","util","structs","LRUCache","tilegrid","tileurlfunction","Feature","featureClass","RenderFeature","styles","stroke","color","MVTImageryProvider","minimumLevel_","urls","credit","styleFunction_","styleFunction","tileRectangle_","Rectangle","cacheSize","tileCache","featureCache","getTilegridForProjection","tileFunction_","createTileUrlFunctions","getTileFeatures","z","cacheKey","getCacheKey_","promise","containsKey","getUrl_","fetch","then","r","ok","arrayBuffer","buffer","readFeaturesFromBuffer","set","getCount","highWaterMark","canExpireCache","pop","OL_VERSION","dataProjection","featureProjection","features","readFeatures","scaleFactor","forEach","f","flatCoordinates","getFlatCoordinates","flip","i","length","tileXYToNativeRectangle","resolution","east","west","rasterizeFeatures","raiseEvent","vectorContext","toContext","getContext","size","setStyle","drawGeometry","computePixelSizeAtCoordinate","scene","target","camera","frustum","distance","Cartesian3","magnitude","subtract","position","getPixelDimensions","clientWidth","clientHeight","pixelRatio","Cartesian2","computeBoundingBoxAtTarget","amount","pixelSize","transform","Transforms","eastNorthUpToFixedFrame","bottomLeft","Matrix4","multiplyByPoint","topRight","Ellipsoid","WGS84","cartesianArrayToCartographicArray","applyHeightOffsetToGeometry","geometry","applyTransform","input","output","stride","createMatrixAtCoordinates","coordinates","rotation","translation","scale","ZERO","ol4326CoordinateToCesiumCartesian","rawMatrix","quaternion","Quaternion","fromAxisAngle","UNIT_Z","rotationMatrix","fromTranslationQuaternionRotationScale","multiply","rotateAroundAxis","angle","axis","opt_options","clamp","Math","defaultValue","duration","linearEasing","callback","lastProgress","oldTransform","start","Date","now","step","timestamp","progress","clone","stepAngle","lookAtTransform","rotate","window","requestAnimationFrame","setHeadingUsingBottomCenter","heading","bottomCenter","angleToZenith","computeAngleToZenith","right","Matrix3","fromQuaternion","vector","zenith","multiplyByVector","add","fromTranslation","pickOnTerrainOrEllipsoid","pixel","ray","getPickRay","globe","pick","pickEllipsoid","pickBottomPoint","pickCenterPoint","computeSignedTiltAngleOnGlobe","Ray","direction","ellipsoid","IntersectionTests","rayEllipsoid","getPoint","normal","geocentricSurfaceNormal","signedAngleBetween","PI","convertLongitudeRange","bottomFovRay","fovy2","fovy","matrix","first","second","b","c","normalize","cross","cosine","dot","sine","sign","atan2","pivot","fy","negate","left","extentToRectangle","ext","transformExtent","fromDegrees","sourceToImageryProvider","viewProj","olLayer","skip","provider","olSourceImageWMS","getUrl","getImageLoadFunction","defaultImageLoadFunction","sourceProps","olSourceTileWMS","attributions","params","getParams","setProperties","olSourceTileImage","isCesiumProjection","olcsCoreOLImageryProvider","olSourceImageStatic","olSourceVectorTile","VectorTileLayer","fromCode","split","map","u","replace","getStyleFunction","getExtentCenter","getImageExtent","SingleTileImageryProvider","tileLayerToImageryLayer","olLayerTile","olLayerImage","getSource","layerOptions","ImageryLayer","updateCesiumLayerProperties","olLayerWithParents","csLayer","opacity","visible","concat","parents","layerOpacity","getOpacity","layerVisible","getVisible","alpha","show","coordinate","coo","ol4326CoordinateArrayToCsCartesians","toCartesian","cartesians","push","olGeometryCloneTo4326","proj4326","properties","getProperties","convertColorToCesium","olColor","Color","byteToFloat","fromCssColorString","CanvasPattern","CanvasGradient","ctx","fillStyle","fillRect","ImageMaterialProperty","image","convertUrlToCesium","subdomains","re","match","exec","startCharCode","charCodeAt","stopCharCode","charCode","String","fromCharCode","resetToNorthZenith","currentHeading","getRotation","normalizeView","rotateAroundBottomCenter","view","getResolution","setRotation","constrainResolution","setResolution","getConstrainedResolution","is3857","is4326","viewState","html","Credit","calcDistanceForResolution","metersPerUnit","getMetersPerUnit","cos","abs","tan","calcResolutionForDistance","limitCameraToBoundingSphere","boundingSphere","ratio","blockLimiter","carto","Cartographic","fromCartesian","radius","flying","unblockLimiter","flyToBoundingSphere","complete","cancel","AutoRenderLoop","ol3d","repaintEventNames_","scene_","getCesiumScene","canvas_","_boundNotifyRepaintRequired","notifyRepaintRequired","bind","enable","requestRenderMode","maximumRenderTimeChange","repaintKey","addEventListener","getOlMap","getLayerGroup","disable","removeEventListener","un","restartRenderLoop","requestRender","Observable","toDegrees","angleInRadians","toRadians","angleInDegrees","identityProjection","opt_output","opt_dimension","dim","Camera","viewListenKey_","toLonLat_","fromLonLat_","tilt_","distance_","lastCameraViewMatrix_","viewUpdateInProgress_","cam_","setView_","destroy","olObservableUnByKey","view_","toLonLat","getTransform","fromLonLat","handleViewChangedEvent_","readFromView","setHeading","getHeading","setTilt","tilt","updateCamera_","getTilt","setDistance","updateView","getDistance","setCenter","setPosition","ll","getAltitude","setView","destination","cartographicToCartesian","getPosition","cartesianToCartographic","setAltitude","altitude","getHeight","orientation","pitch","PI_OVER_TWO","roll","moveBackward","checkCameraChange","bestTarget","positionCartographic","bestTargetCartographic","pos","targetNormal","targetToCamera","up","angleBetween","tiltAngle","acos","isNaN","opt_dontSync","old","current","viewMatrix","equalsEpsilon","Group","AbstractSynchronizer","layerMap","olLayerListenKeys","olGroupListenKeys_","olLayers","getLayers","mapLayerGroup","synchronize","destroyAll","addLayers_","orderLayers","root","fifo","splice","olLayerId","toString","cesiumObjects","LayerGroup","listenForGroupChanges_","createSingleLayerCounterparts","l","newOlLayerWithParents","layerId","layerWithParents","onLayerChange","cesiumObjs","addCesiumObjects_","cesiumObject","addCesiumObject","removeAndDestroySingleLayer_","uid","counterparts","counterpart","removeSingleCesiumObject","destroyCesiumObject","unlistenSingleGroup_","group","removeLayer_","done","uuid","listenKeyArray","contentKeys","listenAddRemove","collection","event","element","el","indexOf","objKey","removeAllCesiumObjects","BaseVector","RasterSynchronizer","olcsAbstractSynchronizer","super","cesiumLayers_","imageryLayers","ourLayers_","ImageryLayerCollection","remove","removeAll","convertLayerToCesiumImageries","result","olLayerItem","BaseVectorLayer","previousStyleFunction","currentStyleFunction","csObj","_imageryCache","ip","imageryProvider","_ip$tileCache","clear","layers","zIndices","queue","getZIndex","sublayers","unshift","getArray","sort","layer1","layer2","raiseToTop","Vector","Layer","Cluster","Icon","Polygon","SimpleGeometry","VectorLayerCounterpart","layerProjection","olListenKeys","billboards","BillboardCollection","primitives","PrimitiveCollection","rootCollection_","context","featureToCesiumMap","getRootPrimitive","FeatureConverter","boundOnRemoveOrClearFeatureListener_","onRemoveOrClearFeature_","defaultBillboardEyeOffset_","evt","cancellers","feature","id","canceller","setReferenceForPicking","primitive","olFeature","createColoredPrimitive","olGeometry","opt_lineWidth","flat","renderState","depthTest","enabled","lineWidth","instances","instance","GeometryInstance","attributes","ColorGeometryInstanceAttribute","fromColor","createInstance","getHeightReference","HeightReference","CLAMP_TO_GROUND","GroundPrimitive","geometryInstances","Primitive","dataUri","getValue","toDataURL","appearance","MaterialAppearance","material","Material","fabric","type","uniforms","translucent","shadows","extractColorFromOlStyle","outline","fillColor","getFill","getColor","strokeColor","getStroke","extractLineWidthFromOlStyle","getWidth","wrapFillAndOutlineGeometries","fillGeometry","outlineGeometry","olStyle","outlineColor","p1","p2","addTextStyle","getText","text","label","olGeometry4326TextPartToCesium","csAddBillboard","bbOptions","eyeOffset","bb","olCircleGeometryToCesium","olCenter","olPoint","slice","getRadius","point","CircleGeometry","outlinePrimitive","positions","olCreateCircularPolygon","getLinearRing","getCoordinates","op","GroundPolylinePrimitive","GroundPolylineGeometry","PolylineMaterialAppearance","olStyleToCesium","classificationType","ClassificationType","TERRAIN","_primitive","CircleOutlineGeometry","extrudedHeight","olLineStringGeometryToCesium","heightReference","PolylineGeometry","vertexFormat","olPolygonGeometryToCesium","boundingExtent","maxHeight","max","featureExtrudedHeight","RectangleGeometry","RectangleOutlineGeometry","rings","getLinearRings","hierarchy","holes","polygonHierarchy","PolygonGeometry","perPositionHeight","linePositions","polylineGeometry","PolygonOutlineGeometry","altitudeMode","NONE","RELATIVE_TO_GROUND","createBillboardFromImage","imageStyle","opt_newBillboardCallback","OLStyleIcon","load","getImage","reallyCreateBillboard","HTMLCanvasElement","HTMLImageElement","getScale","assign","anchor","getAnchor","xScale","yScale","pixelOffset","src","naturalHeight","naturalWidth","isImageLoaded","cancelled","fuid","listener","isDestroyed","olPointGeometryToCesium","modelPrimitive","olcsModelFunction","olcsModel","cesiumOptions","Model","model","fromGltf","fromGltfAsync","debugModelMatrix","DebugModelMatrixPrimitive","modelMatrix","olMultiGeometryToCesium","getType","points","getPoints","lineStrings","getLineStrings","polygons","getPolygons","labels","LabelCollection","extentCenter","olGeomSimpleGeometry","getFirstCoordinate","offsetX","getOffsetX","offsetY","getOffsetY","offset","labelStyle","horizontalOrigin","font","getFont","LabelStyle","FILL","outlineWidth","OUTLINE","FILL_AND_OUTLINE","getTextAlign","HorizontalOrigin","LEFT","RIGHT","CENTER","getTextBaseline","verticalOrigin","VerticalOrigin","TOP","BOTTOM","fill","getLineDash","fromType","horizontal","repeat","evenColor","oddColor","computePlainStyle","fallbackStyleFunction","featureStyleFunction","getGeometryFromFeature","opt_geom","geom3d","OLGeometry","geomFuncRes","getGeometryFunction","getGeometry","olFeatureToCesium","newBillboardAddedCallback","featureBb","getGeometriesArray","prims","bbs","Error","olVectorLayerToCesium","olView","featurePrimitiveMap","OLClusterSource","getFeatures","layerStyle","prim","convert","VectorSynchronizer","opt_converter","converter","olcsFeatureConverter","csAllPrimitives_","destroyPrimitives","updateLayerVisibility","csPrimitive","olLayerVector","olLayerVectorTile","olSourceCluster","csPrimitives","onAddFeature","onRemoveFeature","Billboard","Overlay","cloneNode","node","parent","nodeName","drawImage","appendChild","nodeType","Node","TEXT_NODE","dispatchEvent","MouseEvent","stopPropagation","nodes","childNodes","SynchronizedOverlay","OLOverlay","getOptions","scenePostRenderListenerRemover_","attributeObserver_","synchronizer_","synchronizer","parent_","positionWGS84_","observer_","MutationObserver","handleElementChanged","listenerKeys_","setPropertyFromEvent","setPropertyFromEvent_","handleMapChanged","observeTarget_","disconnect","observe","childList","characterData","subtree","observer","getScene","parentNode","removeChild","postRender","updatePixelPosition","container","stopEvent","getOverlayContainerStopEvent","getOverlayContainer","insertFirst","insertBefore","handlePositionChanged","sourceProjection","getMap","lastChild","removeChildren","getElement","from","clonedNode","setVisible","globeHeight","tilesLoaded","cartesian","ellipsoidBoundingSphere","BoundingSphere","Occluder","isPointVisible","computeCullingVolume","computeVisibility","pixelCartesian","cartesianToCanvasCoordinates","mapSize","updateRenderedPosition","removeNode","OverlaySynchronizer","overlayMap_","Map","overlayEvents","overlayCollection_","getOverlays","overlayContainerStopEvent_","className","name","parentElement","overlayContainer_","overlay","addOverlay","removeOverlay","cesiumOverlay","overlayId","csOverlay","delete","BoundingSphereState","OLCesium","autoRenderLoop_","resolutionScale_","canvasClientWidth_","canvasClientHeight_","resolutionScaleChanged_","enabled_","pausedInteractions_","hiddenRootGroup_","lastFrameTime_","targetFrameRate_","Number","POSITIVE_INFINITY","blockCesiumRendering_","warmingUp_","trackedFeature_","trackedEntity_","entityView_","needTrackedEntityUpdate_","boundingSphereScratch_","time_","time","JulianDate","to4326Transform_","fillArea","container_","containerAttribute","createAttribute","setAttributeNode","targetElement","getViewport","getElementById","isOverMap_","stopOpenLayersEventsPropagation","ii","canvasAttribute","oncontextmenu","onselectstart","sceneOptions","scene3DOnly","Scene","sscc","screenSpaceCameraController","tiltEventTypes","CameraEventType","LEFT_DRAG","KeyboardEventModifier","SHIFT","ALT","enableLook","constrainedAxis","camera_","olcsCamera","globe_","Globe","baseColor","WHITE","skyAtmosphere","SkyAtmosphere","firstImageryProvider","addImageryProvider","dataSourceCollection_","DataSourceCollection","dataSourceDisplay_","DataSourceDisplay","dataSourceCollection","synchronizers_","createSynchronizers","olcsRasterSynchronizer","olcsVectorSynchronizer","olcsOverlaySynchronizer","handleResize_","EventHelper","updateTrackedEntity_","cancelAnimationFrame","renderId_","_postRender","render_","onAnimationFrame_","frameTime","interval","julianDate","initializeFrame","update","trackedEntity","getBoundingSphere","state","enableTilt","bs","EntityView","mapProjection","resolutionScale","devicePixelRatio","aspectRatio","getCamera","getOlView","getDataSources","getDataSourceDisplay","getEnabled","setEnabled","interactions","visibility","throwOnUnitializedMap_","getInteractions","arr","addInteraction","interaction","removeInteraction","interactionRemoved","filter","removed","rootGroup","classList","warmUp","timeout","csCamera","setTimeout","setBlockCesiumRendering","block","enableAutoRenderLoop","olcsAutoRenderLoop","getAutoRenderLoop","setResolutionScale","setTargetFrameRate","isDef","trackedFeature","defaultDataSource","entities","IDENTITY","to4326Transform","toCesiumPosition","olGeomPoint","CallbackProperty","TRANSPARENT","computeRectangle","tw","th","maskAspectRatio","maskSize","scaling","postUnlistener","MaskDrawer","gl","shaderProgram","initShaderProgram","programInfo","program","attribLocations","vertexPosition","getAttribLocation","uniformLocations","uScaling","getUniformLocation","positionBuffer","createBuffer","bindBuffer","ARRAY_BUFFER","bufferData","Float32Array","STATIC_DRAW","getVertexShaderSource","getFragmentShaderSource","vsSource","fsSource","vertexShader","loadShader","VERTEX_SHADER","fragmentShader","FRAGMENT_SHADER","createProgram","attachShader","linkProgram","getProgramParameter","LINK_STATUS","getProgramInfoLog","drawMask","BLEND","vertexAttribPointer","FLOAT","enableVertexAttribArray","useProgram","STENCIL_TEST","stencilFunc","ALWAYS","stencilOp","KEEP","REPLACE","uniform2fv","blendFunc","ONE","drawArrays","TRIANGLE_STRIP","EQUAL","SRC_ALPHA","shader","createShader","shaderSource","compileShader","getShaderParameter","COMPILE_STATUS","getShaderInfoLog","autoDrawMask","getScalings","drawer","takeScreenshot","remover","smallerCanvas","LazyLoader","url_","script","onload","onerror","head","Manager","cesiumUrl","cameraExtentInRadians","cesiumIonDefaultAccessToken","cesiumInitialTilt_","fogDensity","fogSSEFactor","minimumZoomDistance","maximumZoomDistance","limitCameraToBoundingSphereRatio","cesiumUrl_","cesiumIonDefaultAccessToken_","promise_","cesiumLazyLoader","olcsContribLazyLoader","onCesiumLoaded","rect","DEFAULT_VIEW_RECTANGLE","boundingSphere_","fromRectangle3D","Ion","defaultAccessToken","instantiateOLCesium","configureForUsability","configureForPerformance","terrainProvider","createWorldTerrain","createWorldTerrainAsync","tp","fog","density","screenSpaceErrorFactor","sscController","depthTestAgainstTerrain","backgroundColor","toggle3d","is3DCurrentlyEnabled","set3dWithView","lon","lat","elevation","headingDeg","pitchDeg","is3dEnabled","getTiltOnGlobe","bottom","getOl3d","getCesiumViewMatrix","flyToRectangle","getRectangleCameraCoordinates","mag","multiplyByScalar","flyTo","endTransform","olcs","core","contrib","ContribLazyLoader","ContribManager"],"sourceRoot":""}