@progress/kendo-angular-map 0.3.3 → 11.0.0-develop.80

package/fesm2020/progress-kendo-angular-map.mjs

@@ -0,0 +1,1852 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2022 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import * as i0 from '@angular/core';
+import { Injectable, SimpleChange, Directive, TemplateRef, Component, ChangeDetectionStrategy, ContentChild, SecurityContext, Input, forwardRef, ElementRef, EventEmitter, ViewChild, Output, ContentChildren, Optional, NgModule } from '@angular/core';
+import * as i3 from '@angular/platform-browser';
+import { Subject, BehaviorSubject } from 'rxjs';
+import * as i5 from '@progress/kendo-angular-common';
+import { isDocumentAvailable, hasObservers, ResizeSensorModule } from '@progress/kendo-angular-common';
+import * as i3$1 from '@progress/kendo-angular-l10n';
+import { LocalizationService, L10N_PREFIX } from '@progress/kendo-angular-l10n';
+import { InstanceObserver, Map } from '@progress/kendo-charts';
+export { Extent, Location } from '@progress/kendo-charts';
+import { validatePackage } from '@progress/kendo-licensing';
+import { tap } from 'rxjs/operators';
+import * as i1 from '@progress/kendo-angular-popup';
+import { PopupService, POPUP_CONTAINER } from '@progress/kendo-angular-popup';
+import * as i4 from '@angular/common';
+import { CommonModule } from '@angular/common';
+
+/**
+ * @hidden
+ */
+class ItemChange {
+    constructor(sender, options) {
+        this.sender = sender;
+        this.options = options;
+    }
+}
+/**
+ * @hidden
+ */
+class CollectionService {
+    constructor() {
+        this.source = new Subject();
+        this.itemChanges = this.source.asObservable();
+    }
+    notify(change) {
+        this.source.next(change);
+    }
+}
+CollectionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CollectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CollectionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CollectionService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CollectionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+
+/**
+ * @hidden
+ */
+class Change {
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+}
+/**
+ * @hidden
+ */
+class ConfigurationService {
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+        this.store = {};
+        this.source = new BehaviorSubject({});
+        this.initSource();
+    }
+    initSource() {
+        this.changes = this.source.asObservable();
+    }
+    push(store) {
+        this.store = store;
+        this.next();
+    }
+    notify(change) {
+        this.set(change.key, change.value);
+        this.next();
+    }
+    set(field, value) {
+        let store = this.store;
+        const parts = field.split('.');
+        let key = parts.shift();
+        while (parts.length > 0) {
+            store = store[key] = store[key] || {};
+            key = parts.shift();
+        }
+        store[key] = value;
+    }
+    next() {
+        this.ngZone.runOutsideAngular(() => {
+            this.source.next(this.store);
+        });
+    }
+}
+ConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ConfigurationService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ConfigurationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ConfigurationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
+
+/**
+ * @hidden
+ */
+function copyChanges(changes, options) {
+    for (const propertyName in changes) {
+        if (!changes.hasOwnProperty(propertyName)) {
+            continue;
+        }
+        const value = changes[propertyName].currentValue;
+        if (value === undefined) {
+            delete options[propertyName];
+        }
+        else {
+            options[propertyName] = value;
+        }
+    }
+}
+
+/**
+ * @hidden
+ */
+function toSimpleChanges(changes) {
+    const result = {};
+    for (const propertyName in changes) {
+        if (!changes.hasOwnProperty(propertyName)) {
+            continue;
+        }
+        result[propertyName] = new SimpleChange(null, changes[propertyName], false);
+    }
+    return result;
+}
+
+/**
+ * @hidden
+ */
+class CollectionItemComponent {
+    constructor(configurationService, collectionService) {
+        this.configurationService = configurationService;
+        this.collectionService = collectionService;
+        this.index = -1;
+        this.options = {};
+        this.subscription = configurationService.changes.subscribe(store => {
+            this.options = store;
+            this.notify();
+        });
+    }
+    ngOnChanges(changes) {
+        const store = this.configurationService.store;
+        copyChanges(changes, store);
+        this.configurationService.push(store);
+    }
+    /**
+     * Updates the component fields with the specified values and refreshes the Chart.
+     *
+     * Use this method when the configuration values cannot be set through the template.
+     *
+     * @example
+     * ```ts-no-run
+     * item.notifyChanges({ visible: true });
+     * ```
+     *
+     * @param changes An object containing the updated input fields.
+     */
+    notifyChanges(changes) {
+        this.ngOnChanges(toSimpleChanges(changes));
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    notify() {
+        if (!this.collectionService) {
+            return;
+        }
+        this.collectionService.notify(new ItemChange(this, this.options));
+    }
+}
+CollectionItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CollectionItemComponent, deps: [{ token: ConfigurationService }, { token: CollectionService }], target: i0.ɵɵFactoryTarget.Directive });
+CollectionItemComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: CollectionItemComponent, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CollectionItemComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: ConfigurationService }, { type: CollectionService }]; } });
+
+/**
+ * @hidden
+ */
+class SettingsComponent {
+    constructor(configKey, configurationService) {
+        this.configKey = configKey;
+        this.configurationService = configurationService;
+        this.store = {};
+        if (configKey === undefined) {
+            throw new Error('Configuration key not set');
+        }
+    }
+    ngOnDestroy() {
+        this.store = undefined;
+        this.notify();
+    }
+    ngOnChanges(changes) {
+        copyChanges(changes, this.store);
+        this.notify();
+    }
+    /**
+     * Updates the component fields with the specified values and refreshes the component.
+     *
+     * Use this method when the configuration values cannot be set through the template.
+     *
+     * @example
+     * ```ts-no-run
+     * item.notifyChanges({ visible: true });
+     * ```
+     *
+     * @param changes An object containing the updated input fields.
+     */
+    notifyChanges(changes) {
+        this.ngOnChanges(toSimpleChanges(changes));
+    }
+    markAsVisible() {
+        this.store.visible = true;
+        this.notify();
+    }
+    notify() {
+        this.configurationService.notify(new Change(this.configKey, this.store));
+    }
+}
+SettingsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: SettingsComponent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+SettingsComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: SettingsComponent, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: SettingsComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: ConfigurationService }]; } });
+
+/**
+ * The configuration options of the Map layer tooltip.
+ *
+ * @hidden
+ */
+class LayerTooltipComponent extends SettingsComponent {
+    constructor(configurationService) {
+        super('tooltip', configurationService);
+        this.configurationService = configurationService;
+    }
+    get layerTooltipTemplateRef() {
+        return this.layerTooltipTemplate;
+    }
+}
+LayerTooltipComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LayerTooltipComponent, deps: [{ token: ConfigurationService }], target: i0.ɵɵFactoryTarget.Component });
+LayerTooltipComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: LayerTooltipComponent, selector: "kendo-map-layer-tooltip", queries: [{ propertyName: "layerTooltipTemplate", first: true, predicate: TemplateRef, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LayerTooltipComponent, decorators: [{
+            type: Component,
+            args: [{
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    selector: 'kendo-map-layer-tooltip',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }]; }, propDecorators: { layerTooltipTemplate: [{
+                type: ContentChild,
+                args: [TemplateRef, { static: false }]
+            }] } });
+
+/**
+ * @hidden
+ */
+class LayerComponent extends CollectionItemComponent {
+    constructor(type, configurationService, collectionService, sanitizer) {
+        super(configurationService, collectionService);
+        this.type = type;
+        this.configurationService = configurationService;
+        this.collectionService = collectionService;
+        this.sanitizer = sanitizer;
+    }
+    ngOnChanges(changes) {
+        const store = this.configurationService.store;
+        store.type = this.type;
+        const attrChange = changes['attribution'];
+        if (attrChange && this.sanitizer) {
+            attrChange.currentValue = this.sanitizer.sanitize(SecurityContext.HTML, attrChange.currentValue);
+        }
+        super.ngOnChanges(changes);
+    }
+    get layerTooltipTemplateRef() {
+        if (this.layerTooltip) {
+            return this.layerTooltip.layerTooltipTemplateRef;
+        }
+    }
+}
+LayerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LayerComponent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+LayerComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: LayerComponent, inputs: { attribution: "attribution", extent: "extent", maxZoom: "maxZoom", minZoom: "minZoom", opacity: "opacity", zIndex: "zIndex" }, queries: [{ propertyName: "layerTooltip", first: true, predicate: LayerTooltipComponent, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LayerComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: ConfigurationService }, { type: CollectionService }, { type: i3.DomSanitizer }]; }, propDecorators: { attribution: [{
+                type: Input
+            }], extent: [{
+                type: Input
+            }], maxZoom: [{
+                type: Input
+            }], minZoom: [{
+                type: Input
+            }], opacity: [{
+                type: Input
+            }], zIndex: [{
+                type: Input
+            }], layerTooltip: [{
+                type: ContentChild,
+                args: [LayerTooltipComponent, { static: false }]
+            }] } });
+
+/**
+ * A vector shape layer for bubble maps.
+ */
+class BubbleLayerComponent extends LayerComponent {
+    constructor(configurationService, collectionService, sanitizer) {
+        super('bubble', configurationService, collectionService, sanitizer);
+        this.configurationService = configurationService;
+        this.collectionService = collectionService;
+        this.sanitizer = sanitizer;
+    }
+}
+BubbleLayerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BubbleLayerComponent, deps: [{ token: ConfigurationService }, { token: CollectionService }, { token: i3.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component });
+BubbleLayerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: BubbleLayerComponent, selector: "kendo-map-bubble-layer", inputs: { data: "data", locationField: "locationField", valueField: "valueField", symbol: "symbol", style: "style", maxSize: "maxSize", minSize: "minSize" }, providers: [
+        ConfigurationService,
+        {
+            provide: LayerComponent,
+            useExisting: forwardRef(() => BubbleLayerComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BubbleLayerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [
+                        ConfigurationService,
+                        {
+                            provide: LayerComponent,
+                            useExisting: forwardRef(() => BubbleLayerComponent)
+                        }
+                    ],
+                    selector: 'kendo-map-bubble-layer',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }, { type: CollectionService }, { type: i3.DomSanitizer }]; }, propDecorators: { data: [{
+                type: Input
+            }], locationField: [{
+                type: Input
+            }], valueField: [{
+                type: Input
+            }], symbol: [{
+                type: Input
+            }], style: [{
+                type: Input
+            }], maxSize: [{
+                type: Input
+            }], minSize: [{
+                type: Input
+            }] } });
+
+/**
+ * @hidden
+ */
+function hasParent(element, parent) {
+    let current = element;
+    while (current && current !== parent) {
+        current = current.parentNode;
+    }
+    return current ? true : false;
+}
+
+/**
+ * @hidden
+ */
+class MapInstanceObserver extends InstanceObserver {
+    constructor(instance) {
+        super(instance);
+        this.handlerMap = {
+            hideTooltip: 'onHideTooltip',
+            init: 'onInit',
+            render: 'onRender',
+            showTooltip: 'onShowTooltip',
+            centerChange: 'onCenterChange',
+            zoomChange: 'onZoomChange'
+        };
+    }
+}
+
+/**
+ * @hidden
+ */
+class BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(sender) {
+        this.sender = sender;
+    }
+}
+BaseEvent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BaseEvent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+BaseEvent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: BaseEvent, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BaseEvent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }]; } });
+
+/**
+ * Fired immediately before the map is reset. This event is typically used for cleanup by layer implementers.
+ */
+class BeforeResetEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(_, sender) {
+        super(sender);
+    }
+}
+
+/**
+ * Fired when the user clicks on the map.
+ */
+class MapClickEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.location = e.location;
+        this.originalEvent = e.originalEvent;
+    }
+}
+
+/**
+ * Fired when a marker has been displayed and has a DOM element assigned.
+ */
+class MarkerActivateEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.marker = e.marker;
+        this.layer = e.layer;
+    }
+}
+
+/**
+ * Fired when a marker has been clicked or tapped.
+ */
+class MarkerClickEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.marker = e.marker;
+        this.layer = e.layer;
+    }
+}
+
+/**
+ * @hidden
+ */
+class PreventableEvent extends BaseEvent {
+    constructor() {
+        super(...arguments);
+        this.prevented = false;
+    }
+    /**
+     * Prevents the default action for a specified event.
+     * In this way, the source component suppresses
+     * the built-in behavior that follows the event.
+     */
+    preventDefault() {
+        this.prevented = true;
+    }
+    /**
+     * Returns `true` if the event was prevented
+     * by any of its subscribers.
+     *
+     * @returns `true` if the default action was prevented.
+     * Otherwise, returns `false`.
+     */
+    isDefaultPrevented() {
+        return this.prevented;
+    }
+}
+PreventableEvent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: PreventableEvent, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+PreventableEvent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: PreventableEvent, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: PreventableEvent, decorators: [{
+            type: Directive
+        }] });
+
+/**
+ * Fired when a marker has been created and is about to be displayed.
+ *
+ * Cancelling the event will prevent the marker from being shown.
+ */
+class MarkerCreatedEvent extends PreventableEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.marker = e.marker;
+        this.layer = e.layer;
+    }
+}
+
+/**
+ * Fires after the map viewport has been moved.
+ */
+class PanEndEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.origin = e.origin;
+        this.center = e.center;
+        this.originalEvent = e.originalEvent;
+    }
+}
+
+/**
+ * Fired while the map viewport is being moved.
+ */
+class PanEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.origin = e.origin;
+        this.center = e.center;
+        this.originalEvent = e.originalEvent;
+    }
+}
+
+/**
+ * Fired when the map is reset.
+ *
+ * This typically occurs on initial load and after a zoom/center change.
+ */
+class ResetEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(_, sender) {
+        super(sender);
+    }
+}
+
+/**
+ * Fired when a shape is clicked or tapped.
+ */
+class ShapeClickEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.layer = e.layer;
+        this.shape = e.shape;
+        this.originalEvent = e.originalEvent;
+    }
+}
+
+/**
+ * Fired when a shape is created, but is not rendered yet.
+ */
+class ShapeCreatedEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.layer = e.layer;
+        this.shape = e.shape;
+        this.dataItem = e.shape.dataItem;
+        this.location = e.shape.location;
+    }
+}
+
+/**
+ * Fired when a [GeoJSON Feature](https://geojson.org/geojson-spec.html#feature-objects) is created on a shape layer.
+ */
+class ShapeFeatureCreatedEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.dataItem = e.dataItem;
+        this.layer = e.layer;
+        this.group = e.group;
+        this.properties = e.properties;
+    }
+}
+
+/**
+ * Fired when the mouse enters a shape.
+ *
+ * > This event will fire reliably only for shapes that have set fill color.
+ * > The opacity can still be set to 0 so the shapes appear to have no fill.
+ */
+class ShapeMouseEnterEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.layer = e.layer;
+        this.shape = e.shape;
+        this.originalEvent = e.originalEvent;
+    }
+}
+
+/**
+ * Fired when the mouse leaves a shape.
+ *
+ * > This event will fire reliably only for shapes that have set fill color.
+ * > The opacity can still be set to 0 so the shapes appear to have no fill.
+ */
+class ShapeMouseLeaveEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.layer = e.layer;
+        this.shape = e.shape;
+        this.originalEvent = e.originalEvent;
+    }
+}
+
+/**
+ * Fired when the map zoom level has changed.
+ */
+class ZoomEndEvent extends BaseEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.originalEvent = e.originalEvent;
+    }
+}
+
+/**
+ * Fired when the map zoom level is about to change.
+ *
+ * Cancelling the event will prevent the user action.
+ */
+class ZoomStartEvent extends PreventableEvent {
+    /**
+     * @hidden
+     */
+    constructor(e, sender) {
+        super(sender);
+        this.originalEvent = e.originalEvent;
+    }
+}
+
+const EVENT_MAP = {
+    beforeReset: BeforeResetEvent,
+    click: MapClickEvent,
+    markerActivate: MarkerActivateEvent,
+    markerClick: MarkerClickEvent,
+    markerCreated: MarkerCreatedEvent,
+    panEnd: PanEndEvent,
+    pan: PanEvent,
+    reset: ResetEvent,
+    shapeClick: ShapeClickEvent,
+    shapeCreated: ShapeCreatedEvent,
+    shapeFeatureCreated: ShapeFeatureCreatedEvent,
+    shapeMouseEnter: ShapeMouseEnterEvent,
+    shapeMouseLeave: ShapeMouseLeaveEvent,
+    zoomEnd: ZoomEndEvent,
+    zoomStart: ZoomStartEvent
+};
+/**
+ * @hidden
+ */
+class InstanceEventService {
+    create(name, args, sender) {
+        if (EVENT_MAP[name]) {
+            return new EVENT_MAP[name](args, sender);
+        }
+    }
+}
+
+/**
+ * @hidden
+ */
+const packageMetadata = {
+    name: '@progress/kendo-angular-map',
+    productName: 'Kendo UI for Angular',
+    productCodes: ['KENDOUIANGULAR', 'KENDOUICOMPLETE'],
+    publishDate: 1672394481,
+    version: '',
+    licensingDocsUrl: 'https://www.telerik.com/kendo-angular-ui/my-license/'
+};
+
+const POSITION_MODE = 'absolute';
+const COLLISION = { horizontal: "fit", vertical: "fit" };
+/**
+ * @hidden
+ */
+class BaseTooltip {
+    constructor(popupService, localizationService) {
+        this.popupService = popupService;
+        this.localizationService = localizationService;
+        this.animate = true;
+        this.style = {
+            position: 'relative'
+        };
+        this.popupRef = null;
+    }
+    get active() {
+        return this.popupRef !== null;
+    }
+    show(e) {
+        const offset = this.position(e.anchor);
+        if (!this.popupRef) {
+            this.popupRef = this.popupService.open(Object.assign({
+                offset: offset,
+                popupAlign: { vertical: 'bottom', horizontal: 'center' },
+                animate: this.animate,
+                content: this.templateRef,
+                collision: COLLISION,
+                positionMode: POSITION_MODE
+            }, this.popupSettings));
+            if (this.localizationService.rtl) {
+                this.popupRef.popupElement.setAttribute('dir', 'rtl');
+            }
+            this.onInit();
+        }
+        else {
+            const popup = this.popupRef.popup.instance;
+            popup.offset = offset;
+        }
+    }
+    hide() {
+        if (this.popupRef) {
+            this.popupRef.close();
+            this.popupRef = null;
+        }
+    }
+    onInit() {
+        //calling on init
+    }
+    ngOnDestroy() {
+        this.hide();
+    }
+    position(offset) {
+        if (!this.popupSettings || !this.popupSettings.appendTo) {
+            return offset;
+        }
+        const appendTo = this.popupSettings.appendTo.element.nativeElement;
+        const bbox = appendTo.getBoundingClientRect();
+        const { scrollLeft, scrollTop } = this.scrollOffset(appendTo);
+        return {
+            left: offset.left - bbox.left - scrollLeft,
+            top: offset.top - bbox.top - scrollTop
+        };
+    }
+    scrollOffset(element) {
+        if (!element) {
+            return null;
+        }
+        let scrollLeft = element.scrollLeft;
+        let scrollTop = element.scrollTop;
+        let parent = element.parentElement;
+        while (parent) {
+            scrollLeft += parent.scrollLeft;
+            scrollTop += parent.scrollTop;
+            parent = parent.parentElement;
+        }
+        return { scrollLeft, scrollTop };
+    }
+}
+BaseTooltip.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BaseTooltip, deps: [{ token: i1.PopupService }, { token: i3$1.LocalizationService }], target: i0.ɵɵFactoryTarget.Directive });
+BaseTooltip.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: BaseTooltip, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BaseTooltip, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.PopupService }, { type: i3$1.LocalizationService }]; } });
+
+/**
+ * @hidden
+ */
+class TooltipTemplateService {
+    constructor() {
+        this.templates = [];
+    }
+    registerTemplate(layerIndex, template) {
+        if (layerIndex > -1) {
+            this.templates[layerIndex] = template;
+        }
+    }
+    getTemplate(layerIndex) {
+        if (layerIndex > -1) {
+            return this.templates[layerIndex];
+        }
+    }
+}
+TooltipTemplateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TooltipTemplateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TooltipTemplateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TooltipTemplateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TooltipTemplateService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * @hidden
+ */
+function bodyFactory() {
+    if (isDocumentAvailable()) {
+        return new ElementRef(document.body);
+    }
+}
+
+/**
+ * @hidden
+ */
+class TooltipPopupComponent extends BaseTooltip {
+    constructor(popupService, templateService, localizationService, ngZone) {
+        super(popupService, localizationService);
+        this.popupService = popupService;
+        this.templateService = templateService;
+        this.localizationService = localizationService;
+        this.ngZone = ngZone;
+        this.tooltipContext = {};
+        this.animate = true;
+        this.wrapperClass = 'k-tooltip-wrapper';
+        this.leave = new EventEmitter();
+        this.popupClasses = {};
+    }
+    show(e) {
+        this.tooltipTemplateRef = this.templateService.getTemplate(e.layerIndex);
+        if (!this.tooltipTemplateRef) {
+            return;
+        }
+        this.popupClasses = Object.assign({
+            'k-tooltip': true,
+            'k-map-tooltip': true,
+            [e.className]: Boolean(e.className)
+        }, this.classNames);
+        this.tooltipContext = e;
+        super.show(e);
+    }
+    containsElement(element) {
+        if (this.popupRef) {
+            return hasParent(element, this.popupRef.popupElement);
+        }
+    }
+    onInit() {
+        this.ngZone.runOutsideAngular(() => {
+            this.mouseleaveSubscription = this.popupRef.popupElement.addEventListener('mouseleave', (args) => {
+                this.leave.emit(args);
+            });
+        });
+        this.popupRef.popupElement.classList.add(this.wrapperClass);
+    }
+    hide() {
+        if (this.mouseleaveSubscription) {
+            this.mouseleaveSubscription();
+            this.mouseleaveSubscription = null;
+        }
+        this.tooltipTemplateRef = null;
+        super.hide();
+    }
+}
+TooltipPopupComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TooltipPopupComponent, deps: [{ token: i1.PopupService }, { token: TooltipTemplateService }, { token: i3$1.LocalizationService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+TooltipPopupComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: TooltipPopupComponent, selector: "kendo-map-tooltip-popup", inputs: { animate: "animate", classNames: "classNames", popupSettings: "popupSettings", wrapperClass: "wrapperClass" }, outputs: { leave: "leave" }, providers: [PopupService, {
+            provide: POPUP_CONTAINER,
+            useFactory: bodyFactory
+        }], viewQueries: [{ propertyName: "templateRef", first: true, predicate: ["content"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: `
+    <ng-template #content>
+        <div [ngClass]="popupClasses" [ngStyle]="style">
+            <div class="k-tooltip-content">
+                <ng-template [ngTemplateOutlet]="tooltipTemplateRef"
+                            [ngTemplateOutletContext]="tooltipContext">
+                </ng-template>
+            </div>
+        </div>
+    </ng-template>
+    `, isInline: true, directives: [{ type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i4.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i4.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TooltipPopupComponent, decorators: [{
+            type: Component,
+            args: [{
+                    providers: [PopupService, {
+                            provide: POPUP_CONTAINER,
+                            useFactory: bodyFactory
+                        }],
+                    selector: 'kendo-map-tooltip-popup',
+                    template: `
+    <ng-template #content>
+        <div [ngClass]="popupClasses" [ngStyle]="style">
+            <div class="k-tooltip-content">
+                <ng-template [ngTemplateOutlet]="tooltipTemplateRef"
+                            [ngTemplateOutletContext]="tooltipContext">
+                </ng-template>
+            </div>
+        </div>
+    </ng-template>
+    `
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PopupService }, { type: TooltipTemplateService }, { type: i3$1.LocalizationService }, { type: i0.NgZone }]; }, propDecorators: { templateRef: [{
+                type: ViewChild,
+                args: ['content', { static: true }]
+            }], animate: [{
+                type: Input
+            }], classNames: [{
+                type: Input
+            }], popupSettings: [{
+                type: Input
+            }], wrapperClass: [{
+                type: Input
+            }], leave: [{
+                type: Output
+            }] } });
+
+/**
+ * A sample component
+ */
+class MapComponent {
+    constructor(configurationService, instanceEventService, element, localizationService, changeDetector, ngZone, renderer) {
+        this.configurationService = configurationService;
+        this.instanceEventService = instanceEventService;
+        this.element = element;
+        this.localizationService = localizationService;
+        this.changeDetector = changeDetector;
+        this.ngZone = ngZone;
+        this.renderer = renderer;
+        /**
+         * Limits the automatic resizing of the Map. Sets the maximum number of times per second
+         * that the component redraws its content when the size of its container changes.
+         * Defaults to `10`. To disable the automatic resizing, set it to `0`.
+         *
+         * @example
+         * ```ts
+         * _@Component({
+         *     selector: 'my-app',
+         *     template: `
+         *         <kendo-map [resizeRateLimit]="2">
+         * <!--                 ^^^^^^^^^^^^^^^^^^^^^^
+         *       Will update the size of the Map up to two times a second.
+         *       Resize the example pane or window to try it out.
+         * -->
+         *       </kendo-map>
+         *   `
+         * })
+         * export class AppComponent {
+         * }
+         * ```
+         */
+        this.resizeRateLimit = 10;
+        /**
+         * The initial zoom level.
+         *
+         * Typical web maps use zoom levels from 0 (whole world) to 19 (sub-meter features).
+         *
+         * The map size is derived from the zoom level and minScale options: `size = (2 ^ zoom) * minSize`
+         *
+         * > Map zoom rounds floating point numbers. This is done so as the majority of web maps use the whole [`zoom levels`](https://wiki.openstreetmap.org/wiki/Zoom_levels) 0 through to 19.
+         *
+         * @default 3
+         */
+        this.zoom = 3;
+        /**
+         * Fired immediately before the map is reset. This event is typically used for cleanup by layer implementers.
+         */
+        this.beforeReset = new EventEmitter();
+        /**
+         * Fired when the user clicks on the map.
+         */
+        this.mapClick = new EventEmitter();
+        /**
+         * Fired when a marker has been displayed and has a DOM element assigned.
+         */
+        this.markerActivate = new EventEmitter();
+        /**
+         * Fired when a marker has been clicked or tapped.
+         */
+        this.markerClick = new EventEmitter();
+        /**
+         * Fired when a marker has been created and is about to be displayed.
+         *
+         * Cancelling the event will prevent the marker from being shown.
+         */
+        this.markerCreated = new EventEmitter();
+        /**
+         * Fires after the map viewport has been moved.
+         */
+        this.panEnd = new EventEmitter();
+        /**
+         * Fired while the map viewport is being moved.
+         */
+        this.pan = new EventEmitter();
+        /**
+         * Fired when the map is reset.
+         *
+         * This typically occurs on initial load and after a zoom/center change.
+         */
+        this.reset = new EventEmitter();
+        /**
+         * Fired when a shape is clicked or tapped.
+         */
+        this.shapeClick = new EventEmitter();
+        /**
+         * Fired when a shape is created, but is not rendered yet.
+         */
+        this.shapeCreated = new EventEmitter();
+        /**
+         * Fired when a [GeoJSON Feature](https://geojson.org/geojson-spec.html#feature-objects) is created on a shape layer.
+         */
+        this.shapeFeatureCreated = new EventEmitter();
+        /**
+         * Fired when the mouse enters a shape.
+         *
+         * > This event will fire reliably only for shapes that have set fill color.
+         * > The opacity can still be set to 0 so the shapes appear to have no fill.
+         */
+        this.shapeMouseEnter = new EventEmitter();
+        /**
+         * Fired when the mouse leaves a shape.
+         *
+         * > This event will fire reliably only for shapes that have set fill color.
+         * > The opacity can still be set to 0 so the shapes appear to have no fill.
+         */
+        this.shapeMouseLeave = new EventEmitter();
+        /**
+         * Fired when the map zoom level is about to change.
+         *
+         * Cancelling the event will prevent the user action.
+         */
+        this.zoomStart = new EventEmitter();
+        /**
+         * Fired when the map zoom level has changed.
+         */
+        this.zoomEnd = new EventEmitter();
+        /**
+         * Fired when the map center has been changed.
+         */
+        this.centerChange = new EventEmitter();
+        /**
+         * Fired when the map zoom level has been changed.
+         */
+        this.zoomChange = new EventEmitter();
+        this.theme = null;
+        this.rtl = false;
+        validatePackage(packageMetadata);
+    }
+    ngAfterViewInit() {
+        if (this.canRender) {
+            this.ngZone.runOutsideAngular(() => {
+                const mapMouseleave = this.renderer.listen(this.surfaceElement.nativeElement, 'mouseleave', this.mapMouseleave.bind(this));
+                this.domSubscriptions = () => {
+                    mapMouseleave();
+                };
+            });
+        }
+        this.setDirection();
+        this.initConfig();
+        this.subscriptions = this.localizationService.changes.subscribe(() => this.setDirection());
+    }
+    ngAfterViewChecked() {
+        if (this.instance && this.autoResize) {
+            this.ngZone.runOutsideAngular(() => {
+                clearTimeout(this.resizeTimeout);
+                this.resizeTimeout = setTimeout(() => {
+                    this.resize();
+                }, 0);
+            });
+        }
+    }
+    ngOnChanges(changes) {
+        if (this.instance) {
+            if (changes['zoom']) {
+                this.instance.zoom(changes['zoom'].currentValue);
+                delete changes['zoom'];
+            }
+            if (changes['center']) {
+                this.instance.center(changes['center'].currentValue);
+                delete changes['center'];
+            }
+            if (Object.keys(changes).length === 0) {
+                return;
+            }
+        }
+        const store = this.configurationService.store;
+        copyChanges(changes, store);
+        store.popupSettings = null;
+        this.configurationService.push(store);
+    }
+    ngOnDestroy() {
+        this.destroyed = true;
+        if (this.optionsChange) {
+            this.optionsChange.unsubscribe();
+        }
+        if (this.domSubscriptions) {
+            this.domSubscriptions();
+            this.domSubscriptions = null;
+        }
+        if (this.instance) {
+            this.instance.destroy();
+            this.instance = null;
+        }
+        if (this.subscriptions) {
+            this.subscriptions.unsubscribe();
+        }
+    }
+    /**
+     * The marker layers instances.
+     */
+    get layers() {
+        return this.instance?.layers;
+    }
+    /**
+     * Gets the extent (visible area) of the map.
+     */
+    get extent() {
+        return this.instance?.extent();
+    }
+    /**
+     * Sets the extent (visible area) of the map.
+     */
+    set extent(extent) {
+        this.instance?.extent(extent);
+    }
+    /**
+     * Detects the size of the container and redraws the Map.
+     * Resizing is automatic unless you set the `resizeRateLimit` option to `0`.
+     */
+    resize() {
+        //this.instance?.resize();
+    }
+    /**
+     * Retrieves the size of the visible portion of the map.
+     *
+     * @returns The size (width and height) of the visible portion of the map.
+     */
+    viewSize() {
+        return this.instance?.viewSize();
+    }
+    /**
+     * Returns the event coordinates relative to the map element. Offset coordinates are not synchronized to a particular location on the map.
+     *
+     * @param e The mouse event.
+     * @returns The event coordinates relative to the map element.
+     */
+    eventOffset(e) {
+        return this.instance?.eventOffset(e);
+    }
+    /**
+     * Retrieves projected (layer) coordinates that correspond to this mouse event. Layer coordinates are absolute and change only when the zoom level is changed.
+     *
+     * @param e The mouse event.
+     * @returns The projected (layer) coordinates that correspond to this event.
+     */
+    eventToLayer(e) {
+        return this.instance?.eventToLayer(e);
+    }
+    /**
+     * Retrieves the geographic location that correspond to this mouse event.
+     *
+     * @param e The mouse event.
+     * @returns The geographic location that correspond to this mouse event.
+     */
+    eventToLocation(e) {
+        return this.instance?.eventToLocation(e);
+    }
+    /**
+     * Retrieves relative (view) coordinates that correspond to this mouse event. Layer elements positioned on these coordinates will appear under the mouse cursor.
+     * View coordinates are no longer valid after a map reset.
+     *
+     * @param e The mouse event.
+     * @returns The relative (view) coordinates that correspond to this mouse event.
+     */
+    eventToView(e) {
+        return this.instance?.eventToView(e);
+    }
+    /**
+     * Transforms layer (projected) coordinates to geographical location.
+     *
+     * @param point The layer (projected) coordinates. An array argument is assumed to be in x, y order.
+     * @param zoom Optional. Assumed zoom level. Defaults to the current zoom level.
+     * @returns The geographic location that corresponds to the layer coordinates.
+     */
+    layerToLocation(point, zoom) {
+        return this.instance?.layerToLocation(point, zoom);
+    }
+    /**
+     * Returns the layer (projected) coordinates that correspond to a geographical location.
+     *
+     * @param location The geographic location. An array argument is assumed to be in [Latitude, Longitude] order.
+     * @param zoom Optional. Assumed zoom level. Defaults to the current zoom level.
+     * @returns The layer (projected) coordinates.
+     */
+    locationToLayer(location, zoom) {
+        return this.instance?.locationToLayer(location, zoom);
+    }
+    /**
+     * Returns the view (relative) coordinates that correspond to a geographical location.
+     *
+     * @param location The geographic location. An array argument is assumed to be in [Latitude, Longitude] order.
+     * @returns The view coordinates that correspond to a geographical location.
+     */
+    locationToView(location) {
+        return this.instance?.locationToView(location);
+    }
+    /**
+     * Returns the geographical location that correspond to the view (relative) coordinates.
+     *
+     * @param point The view coordinates. An array argument is assumed to be in x, y order.
+     * @param zoom Optional. Assumed zoom level. Defaults to the current zoom level.
+     * @returns The geographic location that corresponds to the view coordinates.
+     */
+    viewToLocation(point, zoom) {
+        return this.instance?.viewToLocation(point, zoom);
+    }
+    /**
+     * @hidden
+     */
+    onResize() {
+        if (this.autoResize) {
+            this.resize();
+        }
+    }
+    get canRender() {
+        return isDocumentAvailable() && Boolean(this.surfaceElement);
+    }
+    get autoResize() {
+        return this.resizeRateLimit > 0;
+    }
+    init() {
+        if (!this.canRender) {
+            return;
+        }
+        const element = this.surfaceElement.nativeElement;
+        const instanceObserver = new MapInstanceObserver(this);
+        this.createInstance(element, instanceObserver);
+    }
+    initConfig() {
+        if (!isDocumentAvailable()) {
+            return;
+        }
+        this.ngZone.runOutsideAngular(() => {
+            this.optionsChange = this.configurationService.changes
+                .pipe(tap((result) => {
+                this.options = result;
+            }))
+                .subscribe(() => {
+                if (!this.instance) {
+                    this.init();
+                    return;
+                }
+                this.instance.setOptions(this.options);
+            });
+        });
+    }
+    createInstance(element, observer) {
+        this.instance = new Map(element, this.options, this.theme, {
+            observer: observer,
+            rtl: this.rtl,
+            sender: this
+        });
+    }
+    activeEmitter(name) {
+        const alias = name === 'click' ? 'mapClick' : name;
+        const emitter = this[alias];
+        if (emitter && emitter.emit && hasObservers(emitter)) {
+            return emitter;
+        }
+    }
+    trigger(name, e) {
+        const emitter = this.activeEmitter(name);
+        if (emitter) {
+            const args = this.instanceEventService.create(name, e, this);
+            if (!this.instance && e.sender) {
+                // Ensure instance reference is populated for events trigger during initialization.
+                this.instance = e.sender;
+            }
+            this.run(() => {
+                emitter.emit(args);
+            });
+            return args.isDefaultPrevented && args.isDefaultPrevented();
+        }
+    }
+    run(callback, inZone = true, detectChanges) {
+        if (inZone) {
+            if (detectChanges) {
+                this.changeDetector.markForCheck();
+            }
+            this.ngZone.run(callback);
+        }
+        else {
+            callback();
+            if (detectChanges) {
+                this.detectChanges();
+            }
+        }
+    }
+    detectChanges() {
+        if (!this.destroyed) {
+            this.changeDetector.detectChanges();
+        }
+    }
+    setDirection() {
+        this.rtl = this.isRTL;
+        if (this.element) {
+            this.renderer.setAttribute(this.element.nativeElement, 'dir', this.rtl ? 'rtl' : 'ltr');
+        }
+    }
+    get isRTL() {
+        return Boolean(this.localizationService.rtl);
+    }
+    onInit(e) {
+        this.instance = e.sender;
+    }
+    onShowTooltip(e) {
+        this.run(() => {
+            this.tooltipInstance.show(e);
+        }, true, true);
+    }
+    onHideTooltip() {
+        this.run(() => {
+            this.tooltipInstance.hide();
+        }, true, true);
+    }
+    onCenterChange(e) {
+        this.centerChange.next(e.center);
+    }
+    onZoomChange(e) {
+        this.zoomChange.next(e.zoom);
+    }
+    /**
+     * @hidden
+     */
+    tooltipMouseleave(e) {
+        const relatedTarget = e.relatedTarget;
+        const chartElement = this.element.nativeElement;
+        if (this.instance && (!relatedTarget || !hasParent(relatedTarget, chartElement))) {
+            this.tooltipInstance.hide();
+        }
+    }
+    /**
+     * @hidden
+     */
+    mapMouseleave(e) {
+        const relatedTarget = e.relatedTarget;
+        const chartElement = this.element.nativeElement;
+        if (this.instance && (!relatedTarget || !(this.tooltipInstance.containsElement(relatedTarget) || hasParent(relatedTarget, chartElement)))) {
+            this.tooltipInstance.hide();
+        }
+    }
+}
+MapComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapComponent, deps: [{ token: ConfigurationService }, { token: InstanceEventService }, { token: i0.ElementRef }, { token: i3$1.LocalizationService }, { token: i0.ChangeDetectorRef }, { token: i0.NgZone }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+MapComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: MapComponent, selector: "kendo-map", inputs: { resizeRateLimit: "resizeRateLimit", center: "center", controls: "controls", minZoom: "minZoom", maxZoom: "maxZoom", minSize: "minSize", pannable: "pannable", popupSettings: "popupSettings", wraparound: "wraparound", zoom: "zoom", zoomable: "zoomable" }, outputs: { beforeReset: "beforeReset", mapClick: "mapClick", markerActivate: "markerActivate", markerClick: "markerClick", markerCreated: "markerCreated", panEnd: "panEnd", pan: "pan", reset: "reset", shapeClick: "shapeClick", shapeCreated: "shapeCreated", shapeFeatureCreated: "shapeFeatureCreated", shapeMouseEnter: "shapeMouseEnter", shapeMouseLeave: "shapeMouseLeave", zoomStart: "zoomStart", zoomEnd: "zoomEnd", centerChange: "centerChange", zoomChange: "zoomChange" }, providers: [
+        ConfigurationService,
+        InstanceEventService,
+        LocalizationService,
+        TooltipTemplateService,
+        {
+            provide: L10N_PREFIX,
+            useValue: 'kendo.map'
+        }
+    ], viewQueries: [{ propertyName: "surfaceElement", first: true, predicate: ["surface"], descendants: true, static: true }, { propertyName: "tooltipInstance", first: true, predicate: TooltipPopupComponent, descendants: true, static: true }], exportAs: ["kendoChart"], usesOnChanges: true, ngImport: i0, template: `
+    <div #surface></div>
+    <kendo-map-tooltip-popup (leave)="tooltipMouseleave($event)" [popupSettings]="popupSettings">
+    </kendo-map-tooltip-popup>
+    <kendo-resize-sensor (resize)="onResize()" [rateLimit]="resizeRateLimit"></kendo-resize-sensor>
+  `, isInline: true, components: [{ type: TooltipPopupComponent, selector: "kendo-map-tooltip-popup", inputs: ["animate", "classNames", "popupSettings", "wrapperClass"], outputs: ["leave"] }, { type: i5.ResizeSensorComponent, selector: "kendo-resize-sensor", inputs: ["rateLimit"], outputs: ["resize"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'kendo-map',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    exportAs: 'kendoChart',
+                    providers: [
+                        ConfigurationService,
+                        InstanceEventService,
+                        LocalizationService,
+                        TooltipTemplateService,
+                        {
+                            provide: L10N_PREFIX,
+                            useValue: 'kendo.map'
+                        }
+                    ],
+                    template: `
+    <div #surface></div>
+    <kendo-map-tooltip-popup (leave)="tooltipMouseleave($event)" [popupSettings]="popupSettings">
+    </kendo-map-tooltip-popup>
+    <kendo-resize-sensor (resize)="onResize()" [rateLimit]="resizeRateLimit"></kendo-resize-sensor>
+  `
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }, { type: InstanceEventService }, { type: i0.ElementRef }, { type: i3$1.LocalizationService }, { type: i0.ChangeDetectorRef }, { type: i0.NgZone }, { type: i0.Renderer2 }]; }, propDecorators: { resizeRateLimit: [{
+                type: Input
+            }], center: [{
+                type: Input
+            }], controls: [{
+                type: Input
+            }], minZoom: [{
+                type: Input
+            }], maxZoom: [{
+                type: Input
+            }], minSize: [{
+                type: Input
+            }], pannable: [{
+                type: Input
+            }], popupSettings: [{
+                type: Input
+            }], wraparound: [{
+                type: Input
+            }], zoom: [{
+                type: Input
+            }], zoomable: [{
+                type: Input
+            }], beforeReset: [{
+                type: Output
+            }], mapClick: [{
+                type: Output
+            }], markerActivate: [{
+                type: Output
+            }], markerClick: [{
+                type: Output
+            }], markerCreated: [{
+                type: Output
+            }], panEnd: [{
+                type: Output
+            }], pan: [{
+                type: Output
+            }], reset: [{
+                type: Output
+            }], shapeClick: [{
+                type: Output
+            }], shapeCreated: [{
+                type: Output
+            }], shapeFeatureCreated: [{
+                type: Output
+            }], shapeMouseEnter: [{
+                type: Output
+            }], shapeMouseLeave: [{
+                type: Output
+            }], zoomStart: [{
+                type: Output
+            }], zoomEnd: [{
+                type: Output
+            }], centerChange: [{
+                type: Output
+            }], zoomChange: [{
+                type: Output
+            }], surfaceElement: [{
+                type: ViewChild,
+                args: ['surface', { static: true }]
+            }], tooltipInstance: [{
+                type: ViewChild,
+                args: [TooltipPopupComponent, { static: true }]
+            }] } });
+
+/**
+ * @hidden
+ */
+class CollectionComponent {
+    constructor(configKey, configurationService, collectionService) {
+        this.configKey = configKey;
+        this.configurationService = configurationService;
+        this.collectionService = collectionService;
+        this.items = [];
+        this.subscription = collectionService.itemChanges.subscribe(changes => this.processChanges(changes));
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+    }
+    ngAfterContentInit() {
+        this.readItems();
+        this.children.changes.subscribe(() => this.readItems());
+    }
+    processChanges(changes) {
+        if (!this.children) {
+            return;
+        }
+        const index = this.children.toArray().indexOf(changes.sender);
+        if (index < 0) {
+            return;
+        }
+        this.items[index] = changes.options;
+        changes.sender.index = index;
+        this.change();
+    }
+    readItems() {
+        this.items = this.children.map((item, index) => {
+            item.index = index;
+            return item.options;
+        });
+        this.change();
+    }
+    change() {
+        this.configurationService.notify(new Change(this.configKey, this.items.length === 0 ? undefined : this.items));
+    }
+}
+CollectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CollectionComponent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+CollectionComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: CollectionComponent, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CollectionComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: undefined }, { type: ConfigurationService }, { type: CollectionService }]; } });
+
+/**
+ * A collection of one or more layers.
+ */
+class LayersComponent extends CollectionComponent {
+    constructor(configurationService, collectionService) {
+        super('layers', configurationService, collectionService);
+        this.configurationService = configurationService;
+        this.collectionService = collectionService;
+    }
+}
+LayersComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LayersComponent, deps: [{ token: ConfigurationService }, { token: CollectionService }], target: i0.ɵɵFactoryTarget.Component });
+LayersComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: LayersComponent, selector: "kendo-map-layers", providers: [CollectionService], queries: [{ propertyName: "children", predicate: LayerComponent }], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: LayersComponent, decorators: [{
+            type: Component,
+            args: [{
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [CollectionService],
+                    selector: 'kendo-map-layers',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }, { type: CollectionService }]; }, propDecorators: { children: [{
+                type: ContentChildren,
+                args: [LayerComponent]
+            }] } });
+
+/**
+ * A vector shape layer for bubble maps.
+ */
+class MarkerLayerComponent extends LayerComponent {
+    constructor(configurationService, collectionService, sanitizer) {
+        super('marker', configurationService, collectionService, sanitizer);
+        this.configurationService = configurationService;
+        this.collectionService = collectionService;
+        this.sanitizer = sanitizer;
+    }
+}
+MarkerLayerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MarkerLayerComponent, deps: [{ token: ConfigurationService }, { token: CollectionService }, { token: i3.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component });
+MarkerLayerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: MarkerLayerComponent, selector: "kendo-map-marker-layer", inputs: { data: "data", locationField: "locationField", titleField: "titleField", shape: "shape" }, providers: [
+        ConfigurationService,
+        {
+            provide: LayerComponent,
+            useExisting: forwardRef(() => MarkerLayerComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MarkerLayerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [
+                        ConfigurationService,
+                        {
+                            provide: LayerComponent,
+                            useExisting: forwardRef(() => MarkerLayerComponent)
+                        }
+                    ],
+                    selector: 'kendo-map-marker-layer',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }, { type: CollectionService }, { type: i3.DomSanitizer }]; }, propDecorators: { data: [{
+                type: Input
+            }], locationField: [{
+                type: Input
+            }], titleField: [{
+                type: Input
+            }], shape: [{
+                type: Input
+            }] } });
+
+/**
+ * Defines a vector shape layer bound to GeoJSON data.
+ */
+class ShapeLayerComponent extends LayerComponent {
+    constructor(configurationService, collectionService, sanitizer) {
+        super('shape', configurationService, collectionService, sanitizer);
+        this.configurationService = configurationService;
+        this.collectionService = collectionService;
+        this.sanitizer = sanitizer;
+    }
+}
+ShapeLayerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ShapeLayerComponent, deps: [{ token: ConfigurationService }, { token: CollectionService }, { token: i3.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component });
+ShapeLayerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: ShapeLayerComponent, selector: "kendo-map-shape-layer", inputs: { data: "data", style: "style" }, providers: [
+        ConfigurationService,
+        {
+            provide: LayerComponent,
+            useExisting: forwardRef(() => ShapeLayerComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ShapeLayerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [
+                        ConfigurationService,
+                        {
+                            provide: LayerComponent,
+                            useExisting: forwardRef(() => ShapeLayerComponent)
+                        }
+                    ],
+                    selector: 'kendo-map-shape-layer',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }, { type: CollectionService }, { type: i3.DomSanitizer }]; }, propDecorators: { data: [{
+                type: Input
+            }], style: [{
+                type: Input
+            }] } });
+
+/**
+ * Defines a vector shape layer bound to GeoJSON data.
+ */
+class TileLayerComponent extends LayerComponent {
+    constructor(configurationService, collectionService, sanitizer) {
+        super('tile', configurationService, collectionService, sanitizer);
+        this.configurationService = configurationService;
+        this.collectionService = collectionService;
+        this.sanitizer = sanitizer;
+    }
+}
+TileLayerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TileLayerComponent, deps: [{ token: ConfigurationService }, { token: CollectionService }, { token: i3.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component });
+TileLayerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: TileLayerComponent, selector: "kendo-map-tile-layer", inputs: { tileSize: "tileSize", subdomains: "subdomains", urlTemplate: "urlTemplate" }, providers: [
+        ConfigurationService,
+        {
+            provide: LayerComponent,
+            useExisting: forwardRef(() => TileLayerComponent)
+        }
+    ], usesInheritance: true, ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: TileLayerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [
+                        ConfigurationService,
+                        {
+                            provide: LayerComponent,
+                            useExisting: forwardRef(() => TileLayerComponent)
+                        }
+                    ],
+                    selector: 'kendo-map-tile-layer',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }, { type: CollectionService }, { type: i3.DomSanitizer }]; }, propDecorators: { tileSize: [{
+                type: Input
+            }], subdomains: [{
+                type: Input
+            }], urlTemplate: [{
+                type: Input
+            }] } });
+
+/**
+ * A directive that sets a [template](link:site.data.urls.angular['templatesyntax'])
+ * within the `<kendo-map-tooltip>` component for the Map
+ * [Bubble layer tooltip]({% slug bubble_layers_map %}#toc-tooltip).
+ *
+ * The available inputs for the bubble tooltip template are:
+ *    * `dataItem: any`&mdash;The original data item used to create the bubble.
+ *    * `layerIndex: number`&mdash;The index of the layer for the tooltip.
+ *    * `location: Location`&mdash;The location of the bubble.
+ *    * `value: number`&mdash;The value of the bubble.
+ */
+class BubbleTooltipTemplateDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+}
+BubbleTooltipTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BubbleTooltipTemplateDirective, deps: [{ token: i0.TemplateRef, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+BubbleTooltipTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: BubbleTooltipTemplateDirective, selector: "[kendoMapBubbleTooltipTemplate]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BubbleTooltipTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoMapBubbleTooltipTemplate]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+/**
+ * A directive that sets a [template](link:site.data.urls.angular['templatesyntax'])
+ * within the `<kendo-map-tooltip>` component for the Map
+ * [Marker layer tooltip]({% slug marker_layers_map %}#toc-tooltip).
+ *
+ * The available inputs for the marker tooltip template are:
+ *    * `title: string`&mdash;The marker title.
+ *    * `layerIndex: number`&mdash;The index of the layer for the tooltip.
+ *    * `location: Location`&mdash;The marker location.
+ */
+class MarkerTooltipTemplateDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+}
+MarkerTooltipTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MarkerTooltipTemplateDirective, deps: [{ token: i0.TemplateRef, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+MarkerTooltipTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: MarkerTooltipTemplateDirective, selector: "[kendoMapMarkerTooltipTemplate]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MarkerTooltipTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoMapMarkerTooltipTemplate]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+/**
+ * A directive that sets a [template](link:site.data.urls.angular['templatesyntax'])
+ * within the `<kendo-map-tooltip>` component for the Map
+ * [Shape layer tooltip]({% slug shape_layers_map %}#toc-tooltip).
+ *
+ * The available inputs for the shape tooltip template are:
+ *    * `dataItem: any`&mdash;The original data item used to create the shape.
+ *    * `layerIndex: number`&mdash;The index of the layer for the tooltip.
+ *    * `location: Location`&mdash;The location of the center of the shape.
+ */
+class ShapeTooltipTemplateDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+}
+ShapeTooltipTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ShapeTooltipTemplateDirective, deps: [{ token: i0.TemplateRef, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+ShapeTooltipTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: ShapeTooltipTemplateDirective, selector: "[kendoMapShapeTooltipTemplate]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ShapeTooltipTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoMapShapeTooltipTemplate]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+/**
+ * The configuration options of the [Bubble Layer Tooltip]({% slug bubble_layers_map %}#toc-tooltip).
+ */
+class BubbleTooltipComponent extends SettingsComponent {
+    constructor(configurationService, templateService, layer) {
+        super('tooltip', configurationService);
+        this.configurationService = configurationService;
+        this.templateService = templateService;
+        this.layer = layer;
+    }
+    ngAfterContentChecked() {
+        this.templateService.registerTemplate(this.layer.index, this.bubbleTooltipTemplate?.templateRef);
+    }
+}
+BubbleTooltipComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BubbleTooltipComponent, deps: [{ token: ConfigurationService }, { token: TooltipTemplateService }, { token: LayerComponent }], target: i0.ɵɵFactoryTarget.Component });
+BubbleTooltipComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: BubbleTooltipComponent, selector: "kendo-map-bubble-layer-tooltip", queries: [{ propertyName: "bubbleTooltipTemplate", first: true, predicate: BubbleTooltipTemplateDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: BubbleTooltipComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'kendo-map-bubble-layer-tooltip',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }, { type: TooltipTemplateService }, { type: LayerComponent }]; }, propDecorators: { bubbleTooltipTemplate: [{
+                type: ContentChild,
+                args: [BubbleTooltipTemplateDirective, { static: false }]
+            }] } });
+
+/**
+ * The configuration options of the [Marker Layer Tooltip]({% slug marker_layers_map %}#toc-tooltip).
+ */
+class MarkerTooltipComponent extends SettingsComponent {
+    constructor(configurationService, templateService, layer) {
+        super('tooltip', configurationService);
+        this.configurationService = configurationService;
+        this.templateService = templateService;
+        this.layer = layer;
+    }
+    ngAfterContentChecked() {
+        this.templateService.registerTemplate(this.layer.index, this.markerTooltipTemplate?.templateRef);
+    }
+}
+MarkerTooltipComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MarkerTooltipComponent, deps: [{ token: ConfigurationService }, { token: TooltipTemplateService }, { token: LayerComponent }], target: i0.ɵɵFactoryTarget.Component });
+MarkerTooltipComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: MarkerTooltipComponent, selector: "kendo-map-marker-layer-tooltip", queries: [{ propertyName: "markerTooltipTemplate", first: true, predicate: MarkerTooltipTemplateDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MarkerTooltipComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'kendo-map-marker-layer-tooltip',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }, { type: TooltipTemplateService }, { type: LayerComponent }]; }, propDecorators: { markerTooltipTemplate: [{
+                type: ContentChild,
+                args: [MarkerTooltipTemplateDirective, { static: false }]
+            }] } });
+
+/**
+ * The configuration options of the [Shape Layer Tooltip]({% slug shape_layers_map %}#toc-tooltip).
+ */
+class ShapeTooltipComponent extends SettingsComponent {
+    constructor(configurationService, templateService, layer) {
+        super('tooltip', configurationService);
+        this.configurationService = configurationService;
+        this.templateService = templateService;
+        this.layer = layer;
+    }
+    ngAfterContentChecked() {
+        this.templateService.registerTemplate(this.layer.index, this.shapeTooltipTemplate?.templateRef);
+    }
+}
+ShapeTooltipComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ShapeTooltipComponent, deps: [{ token: ConfigurationService }, { token: TooltipTemplateService }, { token: LayerComponent }], target: i0.ɵɵFactoryTarget.Component });
+ShapeTooltipComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: ShapeTooltipComponent, selector: "kendo-map-shape-layer-tooltip", queries: [{ propertyName: "shapeTooltipTemplate", first: true, predicate: ShapeTooltipTemplateDirective, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ShapeTooltipComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'kendo-map-shape-layer-tooltip',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }, { type: TooltipTemplateService }, { type: LayerComponent }]; }, propDecorators: { shapeTooltipTemplate: [{
+                type: ContentChild,
+                args: [ShapeTooltipTemplateDirective, { static: false }]
+            }] } });
+
+/**
+ * @hidden
+ */
+const MAP_DIRECTIVES = [
+    BubbleLayerComponent,
+    BubbleTooltipComponent,
+    BubbleTooltipTemplateDirective,
+    LayerTooltipComponent,
+    LayersComponent,
+    MapComponent,
+    MarkerLayerComponent,
+    MarkerTooltipComponent,
+    MarkerTooltipTemplateDirective,
+    ShapeLayerComponent,
+    ShapeTooltipComponent,
+    ShapeTooltipTemplateDirective,
+    TileLayerComponent,
+    TooltipPopupComponent
+];
+
+/**
+ * Sample module
+ */
+class MapModule {
+}
+MapModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MapModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapModule, declarations: [BubbleLayerComponent, BubbleTooltipComponent, BubbleTooltipTemplateDirective, LayerTooltipComponent, LayersComponent, MapComponent, MarkerLayerComponent, MarkerTooltipComponent, MarkerTooltipTemplateDirective, ShapeLayerComponent, ShapeTooltipComponent, ShapeTooltipTemplateDirective, TileLayerComponent, TooltipPopupComponent], imports: [CommonModule, ResizeSensorModule], exports: [BubbleLayerComponent, BubbleTooltipComponent, BubbleTooltipTemplateDirective, LayerTooltipComponent, LayersComponent, MapComponent, MarkerLayerComponent, MarkerTooltipComponent, MarkerTooltipTemplateDirective, ShapeLayerComponent, ShapeTooltipComponent, ShapeTooltipTemplateDirective, TileLayerComponent, TooltipPopupComponent] });
+MapModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapModule, imports: [[CommonModule, ResizeSensorModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: MapModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [MAP_DIRECTIVES],
+                    imports: [CommonModule, ResizeSensorModule],
+                    exports: [MAP_DIRECTIVES]
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BeforeResetEvent, BubbleLayerComponent, BubbleTooltipComponent, BubbleTooltipTemplateDirective, LayerTooltipComponent, LayersComponent, MapClickEvent, MapComponent, MapModule, MarkerActivateEvent, MarkerClickEvent, MarkerCreatedEvent, MarkerLayerComponent, MarkerTooltipComponent, MarkerTooltipTemplateDirective, PanEndEvent, PanEvent, ResetEvent, ShapeClickEvent, ShapeCreatedEvent, ShapeFeatureCreatedEvent, ShapeLayerComponent, ShapeMouseEnterEvent, ShapeMouseLeaveEvent, ShapeTooltipComponent, ShapeTooltipTemplateDirective, TileLayerComponent, TooltipPopupComponent, ZoomEndEvent, ZoomStartEvent, bodyFactory };
+