Deployed the page to Github Pages.

node_modules/@agm/core/README.md

@@ -0,0 +1,6 @@
+Angular Google Maps (AGM) Core - Angular 2+ Google Maps components
+=========
+
+@agm/core contains solutions for the Google Maps JavaScript Core API.
+
+The sources for this package are in the [angular-google-maps](https://github.com/SebastianM/angular-google-maps) repository. Please file issues and pull requests against that repo.

node_modules/@agm/core/agm-core.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+export { AgmMapControl as ɵb } from './lib/directives/map';
+export { FitBoundsService as ɵa } from './lib/services/fit-bounds';
+export { BROWSER_GLOBALS_PROVIDERS as ɵe, DocumentRef as ɵd, WindowRef as ɵc } from './lib/utils/browser-globals';

node_modules/@agm/core/esm2015/agm-core.js

@@ -0,0 +1,8 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+export { AgmMapControl as ɵb } from './lib/directives/map';
+export { FitBoundsService as ɵa } from './lib/services/fit-bounds';
+export { BROWSER_GLOBALS_PROVIDERS as ɵe, DocumentRef as ɵd, WindowRef as ɵc } from './lib/utils/browser-globals';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdtLWNvcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9hZ20tY29yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDO0FBRTdCLE9BQU8sRUFBQyxhQUFhLElBQUksRUFBRSxFQUFDLE1BQU0sc0JBQXNCLENBQUM7QUFDekQsT0FBTyxFQUFDLGdCQUFnQixJQUFJLEVBQUUsRUFBQyxNQUFNLDJCQUEyQixDQUFDO0FBQ2pFLE9BQU8sRUFBQyx5QkFBeUIsSUFBSSxFQUFFLEVBQUMsV0FBVyxJQUFJLEVBQUUsRUFBQyxTQUFTLElBQUksRUFBRSxFQUFDLE1BQU0sNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG5cbmV4cG9ydCB7QWdtTWFwQ29udHJvbCBhcyDJtWJ9IGZyb20gJy4vbGliL2RpcmVjdGl2ZXMvbWFwJztcbmV4cG9ydCB7Rml0Qm91bmRzU2VydmljZSBhcyDJtWF9IGZyb20gJy4vbGliL3NlcnZpY2VzL2ZpdC1ib3VuZHMnO1xuZXhwb3J0IHtCUk9XU0VSX0dMT0JBTFNfUFJPVklERVJTIGFzIMm1ZSxEb2N1bWVudFJlZiBhcyDJtWQsV2luZG93UmVmIGFzIMm1Y30gZnJvbSAnLi9saWIvdXRpbHMvYnJvd3Nlci1nbG9iYWxzJzsiXX0=

node_modules/@agm/core/esm2015/lib/directives.js

@@ -0,0 +1,15 @@
+export { AgmBicyclingLayer } from './directives/bicycling-layer';
+export { AgmCircle } from './directives/circle';
+export { AgmDataLayer } from './directives/data-layer';
+export { AgmFitBounds } from './directives/fit-bounds';
+export { AgmInfoWindow } from './directives/info-window';
+export { AgmKmlLayer } from './directives/kml-layer';
+export { AgmMap, AgmFullscreenControl, AgmMapTypeControl, AgmPanControl, AgmRotateControl, AgmScaleControl, AgmStreetViewControl, AgmZoomControl } from './directives/map';
+export { AgmMarker } from './directives/marker';
+export { AgmPolygon } from './directives/polygon';
+export { AgmPolyline } from './directives/polyline';
+export { AgmPolylineIcon } from './directives/polyline-icon';
+export { AgmPolylinePoint } from './directives/polyline-point';
+export { AgmRectangle } from './directives/rectangle';
+export { AgmTransitLayer } from './directives/transit-layer';
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@agm/core/esm2015/lib/directives/bicycling-layer.js

@@ -0,0 +1,45 @@
+import { Directive, Input } from '@angular/core';
+import { LayerManager } from '../services/managers/layer-manager';
+let layerId = 0;
+/*
+ * This directive adds a bicycling layer to a google map instance
+ * <agm-bicycling-layer [visible]="true|false"> <agm-bicycling-layer>
+ * */
+export class AgmBicyclingLayer {
+    constructor(_manager) {
+        this._manager = _manager;
+        this._addedToManager = false;
+        this._id = (layerId++).toString();
+        /**
+         * Hide/show bicycling layer
+         */
+        this.visible = true;
+    }
+    ngOnInit() {
+        if (this._addedToManager) {
+            return;
+        }
+        this._manager.addBicyclingLayer(this);
+        this._addedToManager = true;
+    }
+    /** @internal */
+    id() { return this._id; }
+    /** @internal */
+    toString() { return `AgmBicyclingLayer-${this._id.toString()}`; }
+    /** @internal */
+    ngOnDestroy() {
+        this._manager.deleteLayer(this);
+    }
+}
+AgmBicyclingLayer.decorators = [
+    { type: Directive, args: [{
+                selector: 'agm-bicycling-layer',
+            },] }
+];
+AgmBicyclingLayer.ctorParameters = () => [
+    { type: LayerManager }
+];
+AgmBicyclingLayer.propDecorators = {
+    visible: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@agm/core/esm2015/lib/directives/polyline-point.js

@@ -0,0 +1,44 @@
+import { Directive, EventEmitter, forwardRef, Input, Output } from '@angular/core';
+import { map, startWith } from 'rxjs/operators';
+import { FitBoundsAccessor } from '../services/fit-bounds';
+/**
+ * AgmPolylinePoint represents one element of a polyline within a  {@link
+ * AgmPolyline}
+ */
+export class AgmPolylinePoint {
+    constructor() {
+        /**
+         * This event emitter gets emitted when the position of the point changed.
+         */
+        this.positionChanged = new EventEmitter();
+    }
+    ngOnChanges(changes) {
+        // tslint:disable: no-string-literal
+        if (changes['latitude'] || changes['longitude']) {
+            this.positionChanged.emit({
+                lat: changes['latitude'] ? changes['latitude'].currentValue : this.latitude,
+                lng: changes['longitude'] ? changes['longitude'].currentValue : this.longitude,
+            });
+        }
+        // tslint:enable: no-string-literal
+    }
+    /** @internal */
+    getFitBoundsDetails$() {
+        return this.positionChanged.pipe(startWith({ lat: this.latitude, lng: this.longitude }), map(position => ({ latLng: position })));
+    }
+}
+AgmPolylinePoint.decorators = [
+    { type: Directive, args: [{
+                selector: 'agm-polyline-point',
+                providers: [
+                    { provide: FitBoundsAccessor, useExisting: forwardRef(() => AgmPolylinePoint) },
+                ],
+            },] }
+];
+AgmPolylinePoint.ctorParameters = () => [];
+AgmPolylinePoint.propDecorators = {
+    latitude: [{ type: Input }],
+    longitude: [{ type: Input }],
+    positionChanged: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@agm/core/esm2015/lib/directives/transit-layer.js

@@ -0,0 +1,45 @@
+import { Directive, Input } from '@angular/core';
+import { LayerManager } from '../services/managers/layer-manager';
+let layerId = 0;
+/*
+ * This directive adds a transit layer to a google map instance
+ * <agm-transit-layer [visible]="true|false"> <agm-transit-layer>
+ * */
+export class AgmTransitLayer {
+    constructor(_manager) {
+        this._manager = _manager;
+        this._addedToManager = false;
+        this._id = (layerId++).toString();
+        /**
+         * Hide/show transit layer
+         */
+        this.visible = true;
+    }
+    ngOnInit() {
+        if (this._addedToManager) {
+            return;
+        }
+        this._manager.addTransitLayer(this);
+        this._addedToManager = true;
+    }
+    /** @internal */
+    id() { return this._id; }
+    /** @internal */
+    toString() { return `AgmTransitLayer-${this._id.toString()}`; }
+    /** @internal */
+    ngOnDestroy() {
+        this._manager.deleteLayer(this);
+    }
+}
+AgmTransitLayer.decorators = [
+    { type: Directive, args: [{
+                selector: 'agm-transit-layer',
+            },] }
+];
+AgmTransitLayer.ctorParameters = () => [
+    { type: LayerManager }
+];
+AgmTransitLayer.propDecorators = {
+    visible: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@agm/core/esm2015/lib/services.js

@@ -0,0 +1,16 @@
+export { CircleManager } from './services/managers/circle-manager';
+export { DataLayerManager } from './services/managers/data-layer-manager';
+export { FitBoundsAccessor } from './services/fit-bounds';
+export { AgmGeocoder } from './services/geocoder-service';
+export { GoogleMapsAPIWrapper } from './services/google-maps-api-wrapper';
+export { GoogleMapsScriptProtocol, LAZY_MAPS_API_CONFIG, LazyMapsAPILoader, } from './services/maps-api-loader/lazy-maps-api-loader';
+export { InfoWindowManager } from './services/managers/info-window-manager';
+export { KmlLayerManager } from './services/managers/kml-layer-manager';
+export { LayerManager } from './services/managers/layer-manager';
+export { MapsAPILoader } from './services/maps-api-loader/maps-api-loader';
+export { MarkerManager } from './services/managers/marker-manager';
+export { NoOpMapsAPILoader } from './services/maps-api-loader/noop-maps-api-loader';
+export { PolygonManager } from './services/managers/polygon-manager';
+export { PolylineManager } from './services/managers/polyline-manager';
+export { RectangleManager } from './services/managers/rectangle-manager';
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@agm/core/esm2015/lib/services/geocoder-service.js

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import { bindCallback, Observable, of, ReplaySubject, throwError } from 'rxjs';
+import { map, multicast, switchMap } from 'rxjs/operators';
+import { MapsAPILoader } from './maps-api-loader/maps-api-loader';
+import * as i0 from "@angular/core";
+import * as i1 from "./maps-api-loader/maps-api-loader";
+export class AgmGeocoder {
+    constructor(loader) {
+        const connectableGeocoder$ = new Observable(subscriber => {
+            loader.load().then(() => subscriber.next());
+        })
+            .pipe(map(() => this._createGeocoder()), multicast(new ReplaySubject(1)));
+        connectableGeocoder$.connect(); // ignore the subscription
+        // since we will remain subscribed till application exits
+        this.geocoder$ = connectableGeocoder$;
+    }
+    geocode(request) {
+        return this.geocoder$.pipe(switchMap((geocoder) => this._getGoogleResults(geocoder, request)));
+    }
+    _getGoogleResults(geocoder, request) {
+        const geocodeObservable = bindCallback(geocoder.geocode);
+        return geocodeObservable(request).pipe(switchMap(([results, status]) => {
+            if (status === google.maps.GeocoderStatus.OK) {
+                return of(results);
+            }
+            return throwError(status);
+        }));
+    }
+    _createGeocoder() {
+        return new google.maps.Geocoder();
+    }
+}
+AgmGeocoder.ɵprov = i0.ɵɵdefineInjectable({ factory: function AgmGeocoder_Factory() { return new AgmGeocoder(i0.ɵɵinject(i1.MapsAPILoader)); }, token: AgmGeocoder, providedIn: "root" });
+AgmGeocoder.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+AgmGeocoder.ctorParameters = () => [
+    { type: MapsAPILoader }
+];
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@agm/core/esm2015/lib/services/managers/kml-layer-manager.js

@@ -0,0 +1,57 @@
+import { Injectable, NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { GoogleMapsAPIWrapper } from './../google-maps-api-wrapper';
+/**
+ * Manages all KML Layers for a Google Map instance.
+ */
+export class KmlLayerManager {
+    constructor(_wrapper, _zone) {
+        this._wrapper = _wrapper;
+        this._zone = _zone;
+        this._layers = new Map();
+    }
+    /**
+     * Adds a new KML Layer to the map.
+     */
+    addKmlLayer(layer) {
+        const newLayer = this._wrapper.getNativeMap().then(m => {
+            return new google.maps.KmlLayer({
+                clickable: layer.clickable,
+                map: m,
+                preserveViewport: layer.preserveViewport,
+                screenOverlays: layer.screenOverlays,
+                suppressInfoWindows: layer.suppressInfoWindows,
+                url: layer.url,
+                zIndex: layer.zIndex,
+            });
+        });
+        this._layers.set(layer, newLayer);
+    }
+    setOptions(layer, options) {
+        this._layers.get(layer).then(l => l.setOptions(options));
+    }
+    deleteKmlLayer(layer) {
+        this._layers.get(layer).then(l => {
+            l.setMap(null);
+            this._layers.delete(layer);
+        });
+    }
+    /**
+     * Creates a Google Maps event listener for the given KmlLayer as an Observable
+     */
+    createEventObservable(eventName, layer) {
+        return new Observable((observer) => {
+            this._layers.get(layer).then((m) => {
+                m.addListener(eventName, (e) => this._zone.run(() => observer.next(e)));
+            });
+        });
+    }
+}
+KmlLayerManager.decorators = [
+    { type: Injectable }
+];
+KmlLayerManager.ctorParameters = () => [
+    { type: GoogleMapsAPIWrapper },
+    { type: NgZone }
+];
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@agm/core/esm2015/lib/services/managers/layer-manager.js

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+/**
+ * This class manages Transit and Bicycling Layers for a Google Map instance.
+ */
+export class LayerManager {
+    constructor(_wrapper) {
+        this._wrapper = _wrapper;
+        this._layers = new Map();
+    }
+    /**
+     * Adds a transit layer to a map instance.
+     * @param layer - a TransitLayer object
+     * @param _options - TransitLayerOptions options
+     * @returns void
+     */
+    addTransitLayer(layer) {
+        const newLayer = this._wrapper.createTransitLayer();
+        this._layers.set(layer, newLayer);
+    }
+    /**
+     * Adds a bicycling layer to a map instance.
+     * @param layer - a bicycling layer object
+     * @param _options - BicyclingLayer options
+     * @returns void
+     */
+    addBicyclingLayer(layer) {
+        const newLayer = this._wrapper.createBicyclingLayer();
+        this._layers.set(layer, newLayer);
+    }
+    /**
+     * Deletes a map layer
+     * @param layer - the layer to delete
+     */
+    deleteLayer(layer) {
+        return this._layers.get(layer).then(currentLayer => {
+            currentLayer.setMap(null);
+            this._layers.delete(layer);
+        });
+    }
+}
+LayerManager.decorators = [
+    { type: Injectable }
+];
+LayerManager.ctorParameters = () => [
+    { type: GoogleMapsAPIWrapper }
+];
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@agm/core/esm2015/lib/services/maps-api-loader/maps-api-loader.js

@@ -0,0 +1,7 @@
+import { Injectable } from '@angular/core';
+export class MapsAPILoader {
+}
+MapsAPILoader.decorators = [
+    { type: Injectable }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwcy1hcGktbG9hZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvbGliL3NlcnZpY2VzL21hcHMtYXBpLWxvYWRlci9tYXBzLWFwaS1sb2FkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUczQyxNQUFNLE9BQWdCLGFBQWE7OztZQURsQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgTWFwc0FQSUxvYWRlciB7XG4gIGFic3RyYWN0IGxvYWQoKTogUHJvbWlzZTx2b2lkPjtcbn1cbiJdfQ==

node_modules/@agm/core/esm2015/lib/services/maps-api-loader/noop-maps-api-loader.js

@@ -0,0 +1,14 @@
+/**
+ * When using the NoOpMapsAPILoader, the Google Maps API must be added to the page via a `<script>`
+ * Tag.
+ * It's important that the Google Maps API script gets loaded first on the page.
+ */
+export class NoOpMapsAPILoader {
+    load() {
+        if (!window.google || !window.google.maps) {
+            throw new Error('Google Maps API not loaded on page. Make sure window.google.maps is available!');
+        }
+        return Promise.resolve();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9vcC1tYXBzLWFwaS1sb2FkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9saWIvc2VydmljZXMvbWFwcy1hcGktbG9hZGVyL25vb3AtbWFwcy1hcGktbG9hZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8saUJBQWlCO0lBQzVCLElBQUk7UUFDRixJQUFJLENBQUUsTUFBYyxDQUFDLE1BQU0sSUFBSSxDQUFFLE1BQWMsQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFO1lBQzNELE1BQU0sSUFBSSxLQUFLLENBQ1gsZ0ZBQWdGLENBQUMsQ0FBQztTQUN2RjtRQUNELE9BQU8sT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzNCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1hcHNBUElMb2FkZXIgfSBmcm9tICcuL21hcHMtYXBpLWxvYWRlcic7XG5cbi8qKlxuICogV2hlbiB1c2luZyB0aGUgTm9PcE1hcHNBUElMb2FkZXIsIHRoZSBHb29nbGUgTWFwcyBBUEkgbXVzdCBiZSBhZGRlZCB0byB0aGUgcGFnZSB2aWEgYSBgPHNjcmlwdD5gXG4gKiBUYWcuXG4gKiBJdCdzIGltcG9ydGFudCB0aGF0IHRoZSBHb29nbGUgTWFwcyBBUEkgc2NyaXB0IGdldHMgbG9hZGVkIGZpcnN0IG9uIHRoZSBwYWdlLlxuICovXG5leHBvcnQgY2xhc3MgTm9PcE1hcHNBUElMb2FkZXIgaW1wbGVtZW50cyBNYXBzQVBJTG9hZGVyIHtcbiAgbG9hZCgpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBpZiAoISh3aW5kb3cgYXMgYW55KS5nb29nbGUgfHwgISh3aW5kb3cgYXMgYW55KS5nb29nbGUubWFwcykge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgICAgICdHb29nbGUgTWFwcyBBUEkgbm90IGxvYWRlZCBvbiBwYWdlLiBNYWtlIHN1cmUgd2luZG93Lmdvb2dsZS5tYXBzIGlzIGF2YWlsYWJsZSEnKTtcbiAgICB9XG4gICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSgpO1xuICB9XG59XG4iXX0=

node_modules/@agm/core/esm2015/lib/utils/browser-globals.js

@@ -0,0 +1,8 @@
+export class WindowRef {
+    getNativeWindow() { return window; }
+}
+export class DocumentRef {
+    getNativeDocument() { return document; }
+}
+export const BROWSER_GLOBALS_PROVIDERS = [WindowRef, DocumentRef];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3Nlci1nbG9iYWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvbGliL3V0aWxzL2Jyb3dzZXItZ2xvYmFscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLE9BQU8sU0FBUztJQUNwQixlQUFlLEtBQVUsT0FBTyxNQUFNLENBQUMsQ0FBQyxDQUFDO0NBQzFDO0FBRUQsTUFBTSxPQUFPLFdBQVc7SUFDdEIsaUJBQWlCLEtBQVUsT0FBTyxRQUFRLENBQUMsQ0FBQyxDQUFDO0NBQzlDO0FBRUQsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQWUsQ0FBQyxTQUFTLEVBQUUsV0FBVyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQcm92aWRlciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgY2xhc3MgV2luZG93UmVmIHtcbiAgZ2V0TmF0aXZlV2luZG93KCk6IGFueSB7IHJldHVybiB3aW5kb3c7IH1cbn1cblxuZXhwb3J0IGNsYXNzIERvY3VtZW50UmVmIHtcbiAgZ2V0TmF0aXZlRG9jdW1lbnQoKTogYW55IHsgcmV0dXJuIGRvY3VtZW50OyB9XG59XG5cbmV4cG9ydCBjb25zdCBCUk9XU0VSX0dMT0JBTFNfUFJPVklERVJTOiBQcm92aWRlcltdID0gW1dpbmRvd1JlZiwgRG9jdW1lbnRSZWZdO1xuIl19

node_modules/@agm/core/esm2015/public-api.js

@@ -0,0 +1,7 @@
+/*
+ * Public API Surface of core
+ */
+export * from './lib/services';
+export * from './lib/directives';
+export * from './lib/core.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgY29yZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RpcmVjdGl2ZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29yZS5tb2R1bGUnO1xuIl19

node_modules/@agm/core/lib/core.module.d.ts

@@ -0,0 +1,30 @@
+import { ModuleWithProviders } from '@angular/core';
+import { AgmBicyclingLayer } from './directives/bicycling-layer';
+import { AgmCircle } from './directives/circle';
+import { AgmDataLayer } from './directives/data-layer';
+import { AgmFitBounds } from './directives/fit-bounds';
+import { AgmInfoWindow } from './directives/info-window';
+import { AgmKmlLayer } from './directives/kml-layer';
+import { AgmFullscreenControl, AgmMap } from './directives/map';
+import { AgmMarker } from './directives/marker';
+import { AgmPolygon } from './directives/polygon';
+import { AgmPolyline } from './directives/polyline';
+import { AgmPolylineIcon } from './directives/polyline-icon';
+import { AgmPolylinePoint } from './directives/polyline-point';
+import { AgmRectangle } from './directives/rectangle';
+import { AgmTransitLayer } from './directives/transit-layer';
+import { LazyMapsAPILoaderConfigLiteral } from './services/maps-api-loader/lazy-maps-api-loader';
+/**
+ * @internal
+ */
+export declare function coreDirectives(): (typeof AgmCircle | typeof AgmDataLayer | typeof AgmMarker | typeof AgmInfoWindow | typeof AgmKmlLayer | typeof AgmBicyclingLayer | typeof AgmTransitLayer | typeof AgmPolygon | typeof AgmPolylineIcon | typeof AgmPolylinePoint | typeof AgmPolyline | typeof AgmRectangle | typeof AgmFitBounds | typeof AgmFullscreenControl | typeof AgmMap)[];
+/**
+ * The angular-google-maps core module. Contains all Directives/Services/Pipes
+ * of the core module. Please use `AgmCoreModule.forRoot()` in your app module.
+ */
+export declare class AgmCoreModule {
+    /**
+     * Please use this method when you register the module at the root level.
+     */
+    static forRoot(lazyMapsAPILoaderConfig?: LazyMapsAPILoaderConfigLiteral): ModuleWithProviders<AgmCoreModule>;
+}

node_modules/@agm/core/lib/directives.d.ts

@@ -0,0 +1,14 @@
+export { AgmBicyclingLayer } from './directives/bicycling-layer';
+export { AgmCircle } from './directives/circle';
+export { AgmDataLayer } from './directives/data-layer';
+export { AgmFitBounds } from './directives/fit-bounds';
+export { AgmInfoWindow } from './directives/info-window';
+export { AgmKmlLayer } from './directives/kml-layer';
+export { AgmMap, AgmFullscreenControl, AgmMapTypeControl, AgmPanControl, AgmRotateControl, AgmScaleControl, AgmStreetViewControl, AgmZoomControl } from './directives/map';
+export { AgmMarker } from './directives/marker';
+export { AgmPolygon } from './directives/polygon';
+export { AgmPolyline } from './directives/polyline';
+export { AgmPolylineIcon } from './directives/polyline-icon';
+export { AgmPolylinePoint } from './directives/polyline-point';
+export { AgmRectangle } from './directives/rectangle';
+export { AgmTransitLayer } from './directives/transit-layer';

node_modules/@agm/core/lib/directives/bicycling-layer.d.ts

@@ -0,0 +1,19 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { LayerManager } from '../services/managers/layer-manager';
+export declare class AgmBicyclingLayer implements OnInit, OnDestroy {
+    private _manager;
+    private _addedToManager;
+    private _id;
+    /**
+     * Hide/show bicycling layer
+     */
+    visible: boolean;
+    constructor(_manager: LayerManager);
+    ngOnInit(): void;
+    /** @internal */
+    id(): string;
+    /** @internal */
+    toString(): string;
+    /** @internal */
+    ngOnDestroy(): void;
+}

node_modules/@agm/core/lib/directives/circle.d.ts

@@ -0,0 +1,135 @@
+/// <reference types="googlemaps" />
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChange } from '@angular/core';
+import { CircleManager } from '../services/managers/circle-manager';
+export declare class AgmCircle implements OnInit, OnChanges, OnDestroy {
+    private _manager;
+    /**
+     * The latitude position of the circle (required).
+     */
+    latitude: number;
+    /**
+     * The clickable position of the circle (required).
+     */
+    longitude: number;
+    /**
+     * Indicates whether this Circle handles mouse events. Defaults to true.
+     */
+    clickable: boolean;
+    /**
+     * If set to true, the user can drag this circle over the map. Defaults to false.
+     */
+    draggable: boolean;
+    /**
+     * If set to true, the user can edit this circle by dragging the control points shown at
+     * the center and around the circumference of the circle. Defaults to false.
+     */
+    editable: boolean;
+    /**
+     * The fill color. All CSS3 colors are supported except for extended named colors.
+     */
+    fillColor: string;
+    /**
+     * The fill opacity between 0.0 and 1.0.
+     */
+    fillOpacity: number;
+    /**
+     * The radius in meters on the Earth's surface.
+     */
+    radius: number;
+    /**
+     * The stroke color. All CSS3 colors are supported except for extended named colors.
+     */
+    strokeColor: string;
+    /**
+     * The stroke opacity between 0.0 and 1.0
+     */
+    strokeOpacity: number;
+    /**
+     * The stroke position. Defaults to CENTER.
+     * This property is not supported on Internet Explorer 8 and earlier.
+     */
+    strokePosition: keyof typeof google.maps.StrokePosition;
+    /**
+     * The stroke width in pixels.
+     */
+    strokeWeight: number;
+    /**
+     * Whether this circle is visible on the map. Defaults to true.
+     */
+    visible: boolean;
+    /**
+     * The zIndex compared to other polys.
+     */
+    zIndex: number;
+    /**
+     * This event is fired when the circle's center is changed.
+     */
+    centerChange: EventEmitter<google.maps.LatLngLiteral>;
+    /**
+     * This event emitter gets emitted when the user clicks on the circle.
+     */
+    circleClick: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event emitter gets emitted when the user clicks on the circle.
+     */
+    circleDblClick: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is repeatedly fired while the user drags the circle.
+     */
+    drag: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user stops dragging the circle.
+     */
+    dragEnd: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user starts dragging the circle.
+     */
+    dragStart: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the DOM mousedown event is fired on the circle.
+     */
+    mouseDown: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the DOM mousemove event is fired on the circle.
+     */
+    mouseMove: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired on circle mouseout.
+     */
+    mouseOut: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired on circle mouseover.
+     */
+    mouseOver: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the DOM mouseup event is fired on the circle.
+     */
+    mouseUp: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the circle's radius is changed.
+     */
+    radiusChange: EventEmitter<number>;
+    /**
+     * This event is fired when the circle is right-clicked on.
+     */
+    rightClick: EventEmitter<google.maps.MouseEvent>;
+    private _circleAddedToManager;
+    private static _mapOptions;
+    private _eventSubscriptions;
+    constructor(_manager: CircleManager);
+    /** @internal */
+    ngOnInit(): void;
+    /** @internal */
+    ngOnChanges(changes: {
+        [key: string]: SimpleChange;
+    }): void;
+    private _updateCircleOptionsChanges;
+    private _registerEventListeners;
+    /** @internal */
+    ngOnDestroy(): void;
+    /**
+     * Gets the LatLngBounds of this Circle.
+     */
+    getBounds(): Promise<google.maps.LatLngBounds>;
+    getCenter(): Promise<google.maps.LatLng>;
+}

node_modules/@agm/core/lib/directives/data-layer.d.ts

@@ -0,0 +1,223 @@
+/// <reference types="googlemaps" />
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { DataLayerManager } from './../services/managers/data-layer-manager';
+/**
+ * AgmDataLayer enables the user to add data layers to the map.
+ *
+ * ### Example
+ * ```typescript
+ * import { Component } from 'angular2/core';
+ * import { AgmMap, AgmDataLayer } from
+ * 'angular-google-maps/core';
+ *
+ * @Component({
+ *  selector: 'my-map-cmp',
+ *  directives: [AgmMap, AgmDataLayer],
+ *  styles: [`
+ *    .agm-container {
+ *      height: 300px;
+ *    }
+ * `],
+ *  template: `
+ * <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
+ * 	  <agm-data-layer [geoJson]="geoJsonObject" (layerClick)="clicked($event)" [style]="styleFunc">
+ * 	  </agm-data-layer>
+ * </agm-map>
+ *  `
+ * })
+ * export class MyMapCmp {
+ *   lat: number = -25.274449;
+ *   lng: number = 133.775060;
+ *   zoom: number = 5;
+ *
+ * clicked(clickEvent) {
+ *    console.log(clickEvent);
+ *  }
+ *
+ *  styleFunc(feature) {
+ *    return ({
+ *      clickable: false,
+ *      fillColor: feature.getProperty('color'),
+ *      strokeWeight: 1
+ *    });
+ *  }
+ *
+ *  geoJsonObject: Object = {
+ *    "type": "FeatureCollection",
+ *    "features": [
+ *      {
+ *        "type": "Feature",
+ *        "properties": {
+ *          "letter": "G",
+ *          "color": "blue",
+ *          "rank": "7",
+ *          "ascii": "71"
+ *        },
+ *        "geometry": {
+ *          "type": "Polygon",
+ *          "coordinates": [
+ *            [
+ *              [123.61, -22.14], [122.38, -21.73], [121.06, -21.69], [119.66, -22.22], [119.00, -23.40],
+ *              [118.65, -24.76], [118.43, -26.07], [118.78, -27.56], [119.22, -28.57], [120.23, -29.49],
+ *              [121.77, -29.87], [123.57, -29.64], [124.45, -29.03], [124.71, -27.95], [124.80, -26.70],
+ *              [124.80, -25.60], [123.61, -25.64], [122.56, -25.64], [121.72, -25.72], [121.81, -26.62],
+ *              [121.86, -26.98], [122.60, -26.90], [123.57, -27.05], [123.57, -27.68], [123.35, -28.18],
+ *              [122.51, -28.38], [121.77, -28.26], [121.02, -27.91], [120.49, -27.21], [120.14, -26.50],
+ *              [120.10, -25.64], [120.27, -24.52], [120.67, -23.68], [121.72, -23.32], [122.43, -23.48],
+ *              [123.04, -24.04], [124.54, -24.28], [124.58, -23.20], [123.61, -22.14]
+ *            ]
+ *          ]
+ *        }
+ *      },
+ *      {
+ *        "type": "Feature",
+ *        "properties": {
+ *          "letter": "o",
+ *          "color": "red",
+ *          "rank": "15",
+ *          "ascii": "111"
+ *        },
+ *        "geometry": {
+ *          "type": "Polygon",
+ *          "coordinates": [
+ *            [
+ *              [128.84, -25.76], [128.18, -25.60], [127.96, -25.52], [127.88, -25.52], [127.70, -25.60],
+ *              [127.26, -25.79], [126.60, -26.11], [126.16, -26.78], [126.12, -27.68], [126.21, -28.42],
+ *              [126.69, -29.49], [127.74, -29.80], [128.80, -29.72], [129.41, -29.03], [129.72, -27.95],
+ *              [129.68, -27.21], [129.33, -26.23], [128.84, -25.76]
+ *            ],
+ *            [
+ *              [128.45, -27.44], [128.32, -26.94], [127.70, -26.82], [127.35, -27.05], [127.17, -27.80],
+ *              [127.57, -28.22], [128.10, -28.42], [128.49, -27.80], [128.45, -27.44]
+ *            ]
+ *          ]
+ *        }
+ *      },
+ *      {
+ *        "type": "Feature",
+ *        "properties": {
+ *          "letter": "o",
+ *          "color": "yellow",
+ *          "rank": "15",
+ *          "ascii": "111"
+ *        },
+ *        "geometry": {
+ *          "type": "Polygon",
+ *          "coordinates": [
+ *            [
+ *              [131.87, -25.76], [131.35, -26.07], [130.95, -26.78], [130.82, -27.64], [130.86, -28.53],
+ *              [131.26, -29.22], [131.92, -29.76], [132.45, -29.87], [133.06, -29.76], [133.72, -29.34],
+ *              [134.07, -28.80], [134.20, -27.91], [134.07, -27.21], [133.81, -26.31], [133.37, -25.83],
+ *              [132.71, -25.64], [131.87, -25.76]
+ *            ],
+ *            [
+ *              [133.15, -27.17], [132.71, -26.86], [132.09, -26.90], [131.74, -27.56], [131.79, -28.26],
+ *              [132.36, -28.45], [132.93, -28.34], [133.15, -27.76], [133.15, -27.17]
+ *            ]
+ *          ]
+ *        }
+ *      },
+ *      {
+ *        "type": "Feature",
+ *        "properties": {
+ *          "letter": "g",
+ *          "color": "blue",
+ *          "rank": "7",
+ *          "ascii": "103"
+ *        },
+ *        "geometry": {
+ *          "type": "Polygon",
+ *          "coordinates": [
+ *            [
+ *              [138.12, -25.04], [136.84, -25.16], [135.96, -25.36], [135.26, -25.99], [135, -26.90],
+ *              [135.04, -27.91], [135.26, -28.88], [136.05, -29.45], [137.02, -29.49], [137.81, -29.49],
+ *              [137.94, -29.99], [137.90, -31.20], [137.85, -32.24], [136.88, -32.69], [136.45, -32.36],
+ *              [136.27, -31.80], [134.95, -31.84], [135.17, -32.99], [135.52, -33.43], [136.14, -33.76],
+ *              [137.06, -33.83], [138.12, -33.65], [138.86, -33.21], [139.30, -32.28], [139.30, -31.24],
+ *              [139.30, -30.14], [139.21, -28.96], [139.17, -28.22], [139.08, -27.41], [139.08, -26.47],
+ *              [138.99, -25.40], [138.73, -25.00], [138.12, -25.04]
+ *            ],
+ *            [
+ *              [137.50, -26.54], [136.97, -26.47], [136.49, -26.58], [136.31, -27.13], [136.31, -27.72],
+ *              [136.58, -27.99], [137.50, -28.03], [137.68, -27.68], [137.59, -26.78], [137.50, -26.54]
+ *            ]
+ *          ]
+ *        }
+ *      },
+ *      {
+ *        "type": "Feature",
+ *        "properties": {
+ *          "letter": "l",
+ *          "color": "green",
+ *          "rank": "12",
+ *          "ascii": "108"
+ *        },
+ *        "geometry": {
+ *          "type": "Polygon",
+ *          "coordinates": [
+ *            [
+ *              [140.14, -21.04], [140.31, -29.42], [141.67, -29.49], [141.59, -20.92], [140.14, -21.04]
+ *            ]
+ *          ]
+ *        }
+ *      },
+ *      {
+ *        "type": "Feature",
+ *        "properties": {
+ *          "letter": "e",
+ *          "color": "red",
+ *          "rank": "5",
+ *          "ascii": "101"
+ *        },
+ *        "geometry": {
+ *          "type": "Polygon",
+ *          "coordinates": [
+ *            [
+ *              [144.14, -27.41], [145.67, -27.52], [146.86, -27.09], [146.82, -25.64], [146.25, -25.04],
+ *              [145.45, -24.68], [144.66, -24.60], [144.09, -24.76], [143.43, -25.08], [142.99, -25.40],
+ *              [142.64, -26.03], [142.64, -27.05], [142.64, -28.26], [143.30, -29.11], [144.18, -29.57],
+ *              [145.41, -29.64], [146.46, -29.19], [146.64, -28.72], [146.82, -28.14], [144.84, -28.42],
+ *              [144.31, -28.26], [144.14, -27.41]
+ *            ],
+ *            [
+ *              [144.18, -26.39], [144.53, -26.58], [145.19, -26.62], [145.72, -26.35], [145.81, -25.91],
+ *              [145.41, -25.68], [144.97, -25.68], [144.49, -25.64], [144, -25.99], [144.18, -26.39]
+ *            ]
+ *          ]
+ *        }
+ *      }
+ *    ]
+ *  };
+ * }
+ * ```
+ */
+export declare class AgmDataLayer implements OnInit, OnDestroy, OnChanges {
+    private _manager;
+    private static _dataOptionsAttributes;
+    private _addedToManager;
+    private _id;
+    private _subscriptions;
+    /**
+     * This event is fired when a feature in the layer is clicked.
+     */
+    layerClick: EventEmitter<google.maps.Data.MouseEvent>;
+    /**
+     * The geoJson to be displayed
+     */
+    geoJson: object | string | null;
+    /**
+     * The layer's style function.
+     */
+    style: (param: google.maps.Data.Feature) => google.maps.Data.StyleOptions;
+    constructor(_manager: DataLayerManager);
+    ngOnInit(): void;
+    private _addEventListeners;
+    /** @internal */
+    id(): string;
+    /** @internal */
+    toString(): string;
+    /** @internal */
+    ngOnDestroy(): void;
+    /** @internal */
+    ngOnChanges(changes: SimpleChanges): void;
+}

node_modules/@agm/core/lib/directives/fit-bounds.d.ts

@@ -0,0 +1,33 @@
+import { OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { FitBoundsAccessor, FitBoundsService } from '../services/fit-bounds';
+/**
+ * Adds the given directive to the auto fit bounds feature when the value is true.
+ * To make it work with you custom AGM component, you also have to implement the {@link FitBoundsAccessor} abstract class.
+ * @example
+ * <agm-marker [agmFitBounds]="true"></agm-marker>
+ */
+export declare class AgmFitBounds implements OnInit, OnDestroy, OnChanges {
+    private readonly _fitBoundsAccessor;
+    private readonly _fitBoundsService;
+    /**
+     * If the value is true, the element gets added to the bounds of the map.
+     * Default: true.
+     */
+    agmFitBounds: boolean;
+    private _destroyed$;
+    private _latestFitBoundsDetails;
+    constructor(_fitBoundsAccessor: FitBoundsAccessor, _fitBoundsService: FitBoundsService);
+    /**
+     * @internal
+     */
+    ngOnChanges(): void;
+    /**
+     * @internal
+     */
+    ngOnInit(): void;
+    private _updateBounds;
+    /**
+     * @internal
+     */
+    ngOnDestroy(): void;
+}

node_modules/@agm/core/lib/directives/info-window.d.ts

@@ -0,0 +1,103 @@
+import { ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChange } from '@angular/core';
+import { InfoWindowManager } from '../services/managers/info-window-manager';
+import { AgmMarker } from './marker';
+/**
+ * AgmInfoWindow renders a info window inside a {@link AgmMarker} or standalone.
+ *
+ * ### Example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ *
+ * @Component({
+ *  selector: 'my-map-cmp',
+ *  styles: [`
+ *    .agm-map-container {
+ *      height: 300px;
+ *    }
+ * `],
+ *  template: `
+ *    <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
+ *      <agm-marker [latitude]="lat" [longitude]="lng" [label]="'M'">
+ *        <agm-info-window [disableAutoPan]="true">
+ *          Hi, this is the content of the <strong>info window</strong>
+ *        </agm-info-window>
+ *      </agm-marker>
+ *    </agm-map>
+ *  `
+ * })
+ * ```
+ */
+export declare class AgmInfoWindow implements OnDestroy, OnChanges, OnInit {
+    private _infoWindowManager;
+    private _el;
+    /**
+     * The latitude position of the info window (only usefull if you use it ouside of a {@link
+     * AgmMarker}).
+     */
+    latitude: number;
+    /**
+     * The longitude position of the info window (only usefull if you use it ouside of a {@link
+     * AgmMarker}).
+     */
+    longitude: number;
+    /**
+     * Disable auto-pan on open. By default, the info window will pan the map so that it is fully
+     * visible when it opens.
+     */
+    disableAutoPan: boolean;
+    /**
+     * All InfoWindows are displayed on the map in order of their zIndex, with higher values
+     * displaying in front of InfoWindows with lower values. By default, InfoWindows are displayed
+     * according to their latitude, with InfoWindows of lower latitudes appearing in front of
+     * InfoWindows at higher latitudes. InfoWindows are always displayed in front of markers.
+     */
+    zIndex: number;
+    /**
+     * Maximum width of the infowindow, regardless of content's width. This value is only considered
+     * if it is set before a call to open. To change the maximum width when changing content, call
+     * close, update maxWidth, and then open.
+     */
+    maxWidth: number;
+    /**
+     * Holds the marker that is the host of the info window (if available)
+     */
+    hostMarker: AgmMarker;
+    /**
+     * Holds the native element that is used for the info window content.
+     */
+    content: Node;
+    /**
+     * Sets the open state for the InfoWindow. You can also call the open() and close() methods.
+     */
+    isOpen: boolean;
+    /**
+     * Emits an event when the info window is closed.
+     */
+    infoWindowClose: EventEmitter<void>;
+    private static _infoWindowOptionsInputs;
+    private _infoWindowAddedToManager;
+    private _id;
+    constructor(_infoWindowManager: InfoWindowManager, _el: ElementRef);
+    ngOnInit(): void;
+    /** @internal */
+    ngOnChanges(changes: {
+        [key: string]: SimpleChange;
+    }): void;
+    private _registerEventListeners;
+    private _updateOpenState;
+    private _setInfoWindowOptions;
+    /**
+     * Opens the info window.
+     */
+    open(): Promise<void>;
+    /**
+     * Closes the info window.
+     */
+    close(): Promise<void>;
+    /** @internal */
+    id(): string;
+    /** @internal */
+    toString(): string;
+    /** @internal */
+    ngOnDestroy(): void;
+}

node_modules/@agm/core/lib/directives/kml-layer.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="googlemaps" />
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { KmlLayerManager } from './../services/managers/kml-layer-manager';
+export declare class AgmKmlLayer implements OnInit, OnDestroy, OnChanges {
+    private _manager;
+    private _addedToManager;
+    private _id;
+    private _subscriptions;
+    private static _kmlLayerOptions;
+    /**
+     * If true, the layer receives mouse events. Default value is true.
+     */
+    clickable: boolean;
+    /**
+     * By default, the input map is centered and zoomed to the bounding box of the contents of the
+     * layer.
+     * If this option is set to true, the viewport is left unchanged, unless the map's center and zoom
+     * were never set.
+     */
+    preserveViewport: boolean;
+    /**
+     * Whether to render the screen overlays. Default true.
+     */
+    screenOverlays: boolean;
+    /**
+     * Suppress the rendering of info windows when layer features are clicked.
+     */
+    suppressInfoWindows: boolean;
+    /**
+     * The URL of the KML document to display.
+     */
+    url: string;
+    /**
+     * The z-index of the layer.
+     */
+    zIndex: number | null;
+    /**
+     * This event is fired when a feature in the layer is clicked.
+     */
+    layerClick: EventEmitter<google.maps.KmlMouseEvent>;
+    /**
+     * This event is fired when the KML layers default viewport has changed.
+     */
+    defaultViewportChange: EventEmitter<void>;
+    /**
+     * This event is fired when the KML layer has finished loading.
+     * At this point it is safe to read the status property to determine if the layer loaded
+     * successfully.
+     */
+    statusChange: EventEmitter<void>;
+    constructor(_manager: KmlLayerManager);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _updatePolygonOptions;
+    private _addEventListeners;
+    /** @internal */
+    id(): string;
+    /** @internal */
+    toString(): string;
+    /** @internal */
+    ngOnDestroy(): void;
+}

node_modules/@agm/core/lib/directives/map.d.ts

@@ -0,0 +1,275 @@
+/// <reference types="googlemaps" />
+import { AfterContentInit, ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, QueryList, SimpleChanges } from '@angular/core';
+import { FitBoundsService } from '../services/fit-bounds';
+import { GoogleMapsAPIWrapper } from '../services/google-maps-api-wrapper';
+export declare type ControlPosition = keyof typeof google.maps.ControlPosition;
+export declare abstract class AgmMapControl {
+    position: ControlPosition;
+    abstract getOptions(): Partial<google.maps.MapOptions>;
+}
+export declare class AgmFullscreenControl extends AgmMapControl {
+    getOptions(): Partial<google.maps.MapOptions>;
+}
+export declare class AgmMapTypeControl extends AgmMapControl {
+    mapTypeIds: (keyof typeof google.maps.MapTypeId)[];
+    style: keyof typeof google.maps.MapTypeControlStyle;
+    getOptions(): Partial<google.maps.MapOptions>;
+}
+export declare class AgmPanControl extends AgmMapControl {
+    getOptions(): Partial<google.maps.MapOptions>;
+}
+export declare class AgmRotateControl extends AgmMapControl {
+    getOptions(): Partial<google.maps.MapOptions>;
+}
+export declare class AgmScaleControl extends AgmMapControl {
+    getOptions(): Partial<google.maps.MapOptions>;
+}
+export declare class AgmStreetViewControl extends AgmMapControl {
+    getOptions(): Partial<google.maps.MapOptions>;
+}
+export declare class AgmZoomControl extends AgmMapControl {
+    style: keyof typeof google.maps.ZoomControlStyle;
+    getOptions(): Partial<google.maps.MapOptions>;
+}
+/**
+ * AgmMap renders a Google Map.
+ * **Important note**: To be able see a map in the browser, you have to define a height for the
+ * element `agm-map`.
+ *
+ * ### Example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ *
+ * @Component({
+ *  selector: 'my-map-cmp',
+ *  styles: [`
+ *    agm-map {
+ *      height: 300px;
+ *    }
+ * `],
+ *  template: `
+ *    <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
+ *    </agm-map>
+ *  `
+ * })
+ * ```
+ */
+export declare class AgmMap implements OnChanges, AfterContentInit, OnDestroy {
+    private _elem;
+    private _mapsWrapper;
+    private _platformId;
+    protected _fitBoundsService: FitBoundsService;
+    private _zone;
+    /**
+     * The longitude that defines the center of the map.
+     */
+    longitude: number;
+    /**
+     * The latitude that defines the center of the map.
+     */
+    latitude: number;
+    /**
+     * The zoom level of the map. The default zoom level is 8.
+     */
+    zoom: number;
+    /**
+     * The minimal zoom level of the map allowed. When not provided, no restrictions to the zoom level
+     * are enforced.
+     */
+    minZoom: number;
+    /**
+     * The maximal zoom level of the map allowed. When not provided, no restrictions to the zoom level
+     * are enforced.
+     */
+    maxZoom: number;
+    /**
+     * The control size for the default map controls. Only governs the controls made by the Maps API itself
+     */
+    controlSize: number;
+    /**
+     * Enables/disables if map is draggable.
+     */
+    draggable: boolean;
+    /**
+     * Enables/disables zoom and center on double click. Enabled by default.
+     */
+    disableDoubleClickZoom: boolean;
+    /**
+     * Enables/disables all default UI of the Google map. Please note: When the map is created, this
+     * value cannot get updated.
+     */
+    disableDefaultUI: boolean;
+    /**
+     * If false, disables scrollwheel zooming on the map. The scrollwheel is enabled by default.
+     */
+    scrollwheel: boolean;
+    /**
+     * Color used for the background of the Map div. This color will be visible when tiles have not
+     * yet loaded as the user pans. This option can only be set when the map is initialized.
+     */
+    backgroundColor: string;
+    /**
+     * The name or url of the cursor to display when mousing over a draggable map. This property uses
+     * the css  * cursor attribute to change the icon. As with the css property, you must specify at
+     * least one fallback cursor that is not a URL. For example:
+     * [draggableCursor]="'url(http://www.example.com/icon.png), auto;'"
+     */
+    draggableCursor: string;
+    /**
+     * The name or url of the cursor to display when the map is being dragged. This property uses the
+     * css cursor attribute to change the icon. As with the css property, you must specify at least
+     * one fallback cursor that is not a URL. For example:
+     * [draggingCursor]="'url(http://www.example.com/icon.png), auto;'"
+     */
+    draggingCursor: string;
+    /**
+     * If false, prevents the map from being controlled by the keyboard. Keyboard shortcuts are
+     * enabled by default.
+     */
+    keyboardShortcuts: boolean;
+    /**
+     * Styles to apply to each of the default map types. Note that for Satellite/Hybrid and Terrain
+     * modes, these styles will only apply to labels and geometry.
+     */
+    styles: google.maps.MapTypeStyle[];
+    /**
+     * When true and the latitude and/or longitude values changes, the Google Maps panTo method is
+     * used to
+     * center the map. See: https://developers.google.com/maps/documentation/javascript/reference#Map
+     */
+    usePanning: boolean;
+    /**
+     * Sets the viewport to contain the given bounds.
+     * If this option to `true`, the bounds get automatically computed from all elements that use the {@link AgmFitBounds} directive.
+     */
+    fitBounds: google.maps.LatLngBoundsLiteral | google.maps.LatLngBounds | boolean;
+    /**
+     * Padding amount for the bounds.
+     */
+    fitBoundsPadding: number | google.maps.Padding;
+    /**
+     * The map mapTypeId. Defaults to 'roadmap'.
+     */
+    mapTypeId: keyof typeof google.maps.MapTypeId;
+    /**
+     * When false, map icons are not clickable. A map icon represents a point of interest,
+     * also known as a POI. By default map icons are clickable.
+     */
+    clickableIcons: boolean;
+    /**
+     * A map icon represents a point of interest, also known as a POI.
+     * When map icons are clickable by default, an info window is displayed.
+     * When this property is set to false, the info window will not be shown but the click event
+     * will still fire
+     */
+    showDefaultInfoWindow: boolean;
+    /**
+     * This setting controls how gestures on the map are handled.
+     * Allowed values:
+     * - 'cooperative' (Two-finger touch gestures pan and zoom the map. One-finger touch gestures are not handled by the map.)
+     * - 'greedy'      (All touch gestures pan or zoom the map.)
+     * - 'none'        (The map cannot be panned or zoomed by user gestures.)
+     * - 'auto'        [default] (Gesture handling is either cooperative or greedy, depending on whether the page is scrollable or not.
+     */
+    gestureHandling: google.maps.GestureHandlingOptions;
+    /**
+     * Controls the automatic switching behavior for the angle of incidence of
+     * the map. The only allowed values are 0 and 45. The value 0 causes the map
+     * to always use a 0° overhead view regardless of the zoom level and
+     * viewport. The value 45 causes the tilt angle to automatically switch to
+     * 45 whenever 45° imagery is available for the current zoom level and
+     * viewport, and switch back to 0 whenever 45° imagery is not available
+     * (this is the default behavior). 45° imagery is only available for
+     * satellite and hybrid map types, within some locations, and at some zoom
+     * levels. Note: getTilt returns the current tilt angle, not the value
+     * specified by this option. Because getTilt and this option refer to
+     * different things, do not bind() the tilt property; doing so may yield
+     * unpredictable effects. (Default of AGM is 0 (disabled). Enable it with value 45.)
+     */
+    tilt: number;
+    /**
+     * Options for restricting the bounds of the map.
+     * User cannot pan or zoom away from restricted area.
+     */
+    restriction: google.maps.MapRestriction;
+    /**
+     * Map option attributes that can change over time
+     */
+    private static _mapOptionsAttributes;
+    private _observableSubscriptions;
+    private _fitBoundsSubscription;
+    /**
+     * This event emitter gets emitted when the user clicks on the map (but not when they click on a
+     * marker or infoWindow).
+     */
+    mapClick: EventEmitter<google.maps.MouseEvent | google.maps.IconMouseEvent>;
+    /**
+     * This event emitter gets emitted when the user right-clicks on the map (but not when they click
+     * on a marker or infoWindow).
+     */
+    mapRightClick: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event emitter gets emitted when the user double-clicks on the map (but not when they click
+     * on a marker or infoWindow).
+     */
+    mapDblClick: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event emitter is fired when the map center changes.
+     */
+    centerChange: EventEmitter<google.maps.LatLngLiteral>;
+    /**
+     * This event is fired when the viewport bounds have changed.
+     */
+    boundsChange: EventEmitter<google.maps.LatLngBounds>;
+    /**
+     * This event is fired when the mapTypeId property changes.
+     */
+    mapTypeIdChange: EventEmitter<google.maps.MapTypeId>;
+    /**
+     * This event is fired when the map becomes idle after panning or zooming.
+     */
+    idle: EventEmitter<void>;
+    /**
+     * This event is fired when the zoom level has changed.
+     */
+    zoomChange: EventEmitter<number>;
+    /**
+     * This event is fired when the google map is fully initialized.
+     * You get the google.maps.Map instance as a result of this EventEmitter.
+     */
+    mapReady: EventEmitter<any>;
+    /**
+     * This event is fired when the visible tiles have finished loading.
+     */
+    tilesLoaded: EventEmitter<void>;
+    mapControls: QueryList<AgmMapControl>;
+    constructor(_elem: ElementRef, _mapsWrapper: GoogleMapsAPIWrapper, _platformId: Object, _fitBoundsService: FitBoundsService, _zone: NgZone);
+    /** @internal */
+    ngAfterContentInit(): void;
+    private _initMapInstance;
+    /** @internal */
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private _updateMapOptionsChanges;
+    /**
+     * Triggers a resize event on the google map instance.
+     * When recenter is true, the of the google map gets called with the current lat/lng values or fitBounds value to recenter the map.
+     * Returns a promise that gets resolved after the event was triggered.
+     */
+    triggerResize(recenter?: boolean): Promise<void>;
+    private _updatePosition;
+    private _setCenter;
+    private _fitBounds;
+    private _subscribeToFitBoundsUpdates;
+    protected _updateBounds(bounds: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral, padding?: number | google.maps.Padding): void;
+    private _isLatLngBoundsLiteral;
+    private _handleMapCenterChange;
+    private _handleBoundsChange;
+    private _handleMapTypeIdChange;
+    private _handleMapZoomChange;
+    private _handleIdleEvent;
+    private _handleTilesLoadedEvent;
+    private _handleMapMouseEvents;
+    _handleControlChange(): void;
+    _setControls(): void;
+}

node_modules/@agm/core/lib/directives/marker.d.ts

@@ -0,0 +1,143 @@
+/// <reference types="googlemaps" />
+import { AfterContentInit, EventEmitter, OnChanges, OnDestroy, QueryList, SimpleChange } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { FitBoundsAccessor, FitBoundsDetails } from '../services/fit-bounds';
+import { MarkerManager } from '../services/managers/marker-manager';
+import { AgmInfoWindow } from './info-window';
+/**
+ * AgmMarker renders a map marker inside a {@link AgmMap}.
+ *
+ * ### Example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ *
+ * @Component({
+ *  selector: 'my-map-cmp',
+ *  styles: [`
+ *    .agm-map-container {
+ *      height: 300px;
+ *    }
+ * `],
+ *  template: `
+ *    <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
+ *      <agm-marker [latitude]="lat" [longitude]="lng" [label]="'M'">
+ *      </agm-marker>
+ *    </agm-map>
+ *  `
+ * })
+ * ```
+ */
+export declare class AgmMarker implements OnDestroy, OnChanges, AfterContentInit, FitBoundsAccessor {
+    private _markerManager;
+    /**
+     * The latitude position of the marker.
+     */
+    latitude: number;
+    /**
+     * The longitude position of the marker.
+     */
+    longitude: number;
+    /**
+     * The title of the marker.
+     */
+    title: string;
+    /**
+     * The label (a single uppercase character) for the marker.
+     */
+    label: string | google.maps.MarkerLabel;
+    /**
+     * If true, the marker can be dragged. Default value is false.
+     */
+    draggable: boolean;
+    /**
+     * Icon (the URL of the image) for the foreground.
+     */
+    iconUrl: string | google.maps.Icon | google.maps.Symbol;
+    /**
+     * If true, the marker is visible
+     */
+    visible: boolean;
+    /**
+     * Whether to automatically open the child info window when the marker is clicked.
+     */
+    openInfoWindow: boolean;
+    /**
+     * The marker's opacity between 0.0 and 1.0.
+     */
+    opacity: number;
+    /**
+     * All markers are displayed on the map in order of their zIndex, with higher values displaying in
+     * front of markers with lower values. By default, markers are displayed according to their
+     * vertical position on screen, with lower markers appearing in front of markers further up the
+     * screen.
+     */
+    zIndex: number;
+    /**
+     * If true, the marker can be clicked. Default value is true.
+     */
+    clickable: boolean;
+    /**
+     * Which animation to play when marker is added to a map.
+     * This can be 'BOUNCE' or 'DROP'
+     */
+    animation: keyof typeof google.maps.Animation;
+    /**
+     * This event is fired when the marker's animation property changes.
+     */
+    animationChange: EventEmitter<"BOUNCE" | "DROP">;
+    /**
+     * This event emitter gets emitted when the user clicks on the marker.
+     */
+    markerClick: EventEmitter<AgmMarker>;
+    /**
+     * This event emitter gets emitted when the user clicks twice on the marker.
+     */
+    markerDblClick: EventEmitter<AgmMarker>;
+    /**
+     * This event is fired when the user rightclicks on the marker.
+     */
+    markerRightClick: EventEmitter<void>;
+    /**
+     * This event is fired when the user starts dragging the marker.
+     */
+    dragStart: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is repeatedly fired while the user drags the marker.
+     */
+    drag: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user stops dragging the marker.
+     */
+    dragEnd: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user mouses over the marker.
+     */
+    mouseOver: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user mouses outside the marker.
+     */
+    mouseOut: EventEmitter<google.maps.MouseEvent>;
+    /** @internal */
+    infoWindow: QueryList<AgmInfoWindow>;
+    private _markerAddedToManger;
+    private _id;
+    private _observableSubscriptions;
+    protected readonly _fitBoundsDetails$: ReplaySubject<FitBoundsDetails>;
+    constructor(_markerManager: MarkerManager);
+    ngAfterContentInit(): void;
+    private handleInfoWindowUpdate;
+    /** @internal */
+    ngOnChanges(changes: {
+        [key: string]: SimpleChange;
+    }): void;
+    /** @internal */
+    getFitBoundsDetails$(): Observable<FitBoundsDetails>;
+    protected _updateFitBoundsDetails(): void;
+    private _addEventListeners;
+    /** @internal */
+    id(): string;
+    /** @internal */
+    toString(): string;
+    /** @internal */
+    ngOnDestroy(): void;
+}

node_modules/@agm/core/lib/directives/polygon.d.ts

@@ -0,0 +1,185 @@
+/// <reference types="googlemaps" />
+import { AfterContentInit, EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { PolygonManager } from '../services/managers/polygon-manager';
+import { MVCEvent } from '../utils/mvcarray-utils';
+/**
+ * AgmPolygon renders a polygon on a {@link AgmMap}
+ *
+ * ### Example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ *
+ * @Component({
+ *  selector: 'my-map-cmp',
+ *  styles: [`
+ *    agm-map {
+ *      height: 300px;
+ *    }
+ * `],
+ *  template: `
+ *    <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
+ *      <agm-polygon [paths]="paths">
+ *      </agm-polygon>
+ *    </agm-map>
+ *  `
+ * })
+ * export class MyMapCmp {
+ *   lat: number = 0;
+ *   lng: number = 0;
+ *   zoom: number = 10;
+ *   paths: LatLngLiteral[] = [
+ *     { lat: 0,  lng: 10 },
+ *     { lat: 0,  lng: 20 },
+ *     { lat: 10, lng: 20 },
+ *     { lat: 10, lng: 10 },
+ *     { lat: 0,  lng: 10 }
+ *   ]
+ *   // Nesting paths will create a hole where they overlap;
+ *   nestedPaths: LatLngLiteral[][] = [[
+ *     { lat: 0,  lng: 10 },
+ *     { lat: 0,  lng: 20 },
+ *     { lat: 10, lng: 20 },
+ *     { lat: 10, lng: 10 },
+ *     { lat: 0,  lng: 10 }
+ *   ], [
+ *     { lat: 0, lng: 15 },
+ *     { lat: 0, lng: 20 },
+ *     { lat: 5, lng: 20 },
+ *     { lat: 5, lng: 15 },
+ *     { lat: 0, lng: 15 }
+ *   ]]
+ * }
+ * ```
+ */
+export declare class AgmPolygon implements OnDestroy, OnChanges, AfterContentInit {
+    private _polygonManager;
+    /**
+     * Indicates whether this Polygon handles mouse events. Defaults to true.
+     */
+    clickable: boolean;
+    /**
+     * If set to true, the user can drag this shape over the map. The geodesic
+     * property defines the mode of dragging. Defaults to false.
+     */
+    draggable: boolean;
+    /**
+     * If set to true, the user can edit this shape by dragging the control
+     * points shown at the vertices and on each segment. Defaults to false.
+     */
+    editable: boolean;
+    /**
+     * The fill color. All CSS3 colors are supported except for extended
+     * named colors.
+     */
+    fillColor: string;
+    /**
+     * The fill opacity between 0.0 and 1.0
+     */
+    fillOpacity: number;
+    /**
+     * When true, edges of the polygon are interpreted as geodesic and will
+     * follow the curvature of the Earth. When false, edges of the polygon are
+     * rendered as straight lines in screen space. Note that the shape of a
+     * geodesic polygon may appear to change when dragged, as the dimensions
+     * are maintained relative to the surface of the earth. Defaults to false.
+     */
+    geodesic: boolean;
+    /**
+     * The ordered sequence of coordinates that designates a closed loop.
+     * Unlike polylines, a polygon may consist of one or more paths.
+     *  As a result, the paths property may specify one or more arrays of
+     * LatLng coordinates. Paths are closed automatically; do not repeat the
+     * first vertex of the path as the last vertex. Simple polygons may be
+     * defined using a single array of LatLngs. More complex polygons may
+     * specify an array of arrays. Any simple arrays are converted into Arrays.
+     * Inserting or removing LatLngs from the Array will automatically update
+     * the polygon on the map.
+     */
+    paths: google.maps.LatLng[] | google.maps.LatLng[][] | google.maps.MVCArray<google.maps.LatLng> | google.maps.MVCArray<google.maps.MVCArray<google.maps.LatLng>> | google.maps.LatLngLiteral[] | google.maps.LatLngLiteral[][];
+    /**
+     * The stroke color. All CSS3 colors are supported except for extended
+     * named colors.
+     */
+    strokeColor: string;
+    /**
+     * The stroke opacity between 0.0 and 1.0
+     */
+    strokeOpacity: number;
+    /**
+     * The stroke width in pixels.
+     */
+    strokeWeight: number;
+    /**
+     * Whether this polygon is visible on the map. Defaults to true.
+     */
+    visible: boolean;
+    /**
+     * The zIndex compared to other polys.
+     */
+    zIndex: number;
+    /**
+     * This event is fired when the DOM click event is fired on the Polygon.
+     */
+    polyClick: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired when the DOM dblclick event is fired on the Polygon.
+     */
+    polyDblClick: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is repeatedly fired while the user drags the polygon.
+     */
+    polyDrag: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user stops dragging the polygon.
+     */
+    polyDragEnd: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user starts dragging the polygon.
+     */
+    polyDragStart: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the DOM mousedown event is fired on the Polygon.
+     */
+    polyMouseDown: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired when the DOM mousemove event is fired on the Polygon.
+     */
+    polyMouseMove: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired on Polygon mouseout.
+     */
+    polyMouseOut: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired on Polygon mouseover.
+     */
+    polyMouseOver: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired whe the DOM mouseup event is fired on the Polygon
+     */
+    polyMouseUp: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired when the Polygon is right-clicked on.
+     */
+    polyRightClick: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired after Polygon first path changes.
+     */
+    polyPathsChange: EventEmitter<MVCEvent<google.maps.LatLng[] | google.maps.LatLngLiteral[]>>;
+    private static _polygonOptionsAttributes;
+    private _id;
+    private _polygonAddedToManager;
+    private _subscriptions;
+    constructor(_polygonManager: PolygonManager);
+    /** @internal */
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): any;
+    private _init;
+    private _addEventListeners;
+    private _updatePolygonOptions;
+    /** @internal */
+    id(): string;
+    /** @internal */
+    ngOnDestroy(): void;
+    getPath(): Promise<google.maps.LatLng[]>;
+    getPaths(): Promise<google.maps.LatLng[][]>;
+}

node_modules/@agm/core/lib/directives/polyline-icon.d.ts

@@ -0,0 +1,91 @@
+/// <reference types="googlemaps" />
+import { OnInit } from '@angular/core';
+/**
+ * AgmPolylineIcon enables to add polyline sequences to add arrows, circle,
+ * or custom icons either along the entire line, or in a specific part of it.
+ * See https://developers.google.com/maps/documentation/javascript/shapes#polyline_customize
+ *
+ * ### Example
+ * ```html
+ *    <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
+ *      <agm-polyline>
+ *          <agm-icon-sequence [fixedRotation]="true" [path]="'FORWARD_OPEN_ARROW'">
+ *          </agm-icon-sequence>
+ *      </agm-polyline>
+ *    </agm-map>
+ * ```
+ */
+export declare class AgmPolylineIcon implements OnInit {
+    /**
+     * If `true`, each icon in the sequence has the same fixed rotation regardless of the
+     * angle of the edge on which it lies. Defaults to `false`, in which case each icon
+     * in the sequence is rotated to align with its edge.
+     */
+    fixedRotation: boolean;
+    /**
+     * The distance from the start of the line at which an icon is to be rendered. This
+     * distance may be expressed as a percentage of line's length (e.g. '50%') or in pixels
+     * (e.g. '50px'). Defaults to '100%'.
+     */
+    offset: string;
+    /**
+     * The distance between consecutive icons on the line. This distance may be expressed as
+     * a percentage of the line's length (e.g. '50%') or in pixels (e.g. '50px'). To disable
+     * repeating of the icon, specify '0'. Defaults to '0'.
+     */
+    repeat: string;
+    /**
+     * The x coordinate of the position of the symbol relative to the polyline. The coordinate
+     * of the symbol's path is translated _left_ by the anchor's x coordinate. By default, a
+     * symbol is anchored at (0, 0). The position is expressed in the same coordinate system as the
+     * symbol's path.
+     */
+    anchorX: number;
+    /**
+     * The y coordinate of the position of the symbol relative to the polyline. The coordinate
+     * of the symbol's path is translated _up_ by the anchor's y coordinate. By default, a
+     * symbol is anchored at (0, 0). The position is expressed in the same coordinate system as the
+     * symbol's path.
+     */
+    anchorY: number;
+    /**
+     * The symbol's fill color. All CSS3 colors are supported except for extended named
+     * colors. Defaults to the stroke color of the corresponding polyline.
+     */
+    fillColor: string;
+    /**
+     * The symbol's fill opacity. Defaults to 0.
+     */
+    fillOpacity: number;
+    /**
+     * The symbol's path, which is a built-in symbol path, or a custom path expressed using
+     * SVG path notation. Required.
+     */
+    path: keyof typeof google.maps.SymbolPath | string;
+    /**
+     * The angle by which to rotate the symbol, expressed clockwise in degrees.
+     * Defaults to 0. A symbol where `fixedRotation` is `false` is rotated relative to
+     * the angle of the edge on which it lies.
+     */
+    rotation: number;
+    /**
+     * The amount by which the symbol is scaled in size. Defaults to the stroke weight
+     * of the polyline; after scaling, the symbol must lie inside a square 22 pixels in
+     * size centered at the symbol's anchor.
+     */
+    scale: number;
+    /**
+     * The symbol's stroke color. All CSS3 colors are supported except for extended named
+     * colors. Defaults to the stroke color of the polyline.
+     */
+    strokeColor: string;
+    /**
+     * The symbol's stroke opacity. Defaults to the stroke opacity of the polyline.
+     */
+    strokeOpacity: number;
+    /**
+     * The symbol's stroke weight. Defaults to the scale of the symbol.
+     */
+    strokeWeight: number;
+    ngOnInit(): void;
+}

node_modules/@agm/core/lib/directives/polyline-point.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="googlemaps" />
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { Observable } from 'rxjs';
+import { FitBoundsAccessor, FitBoundsDetails } from '../services/fit-bounds';
+/**
+ * AgmPolylinePoint represents one element of a polyline within a  {@link
+ * AgmPolyline}
+ */
+export declare class AgmPolylinePoint implements OnChanges, FitBoundsAccessor {
+    /**
+     * The latitude position of the point.
+     */
+    latitude: number;
+    /**
+     * The longitude position of the point;
+     */
+    longitude: number;
+    /**
+     * This event emitter gets emitted when the position of the point changed.
+     */
+    positionChanged: EventEmitter<google.maps.LatLngLiteral>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): any;
+    /** @internal */
+    getFitBoundsDetails$(): Observable<FitBoundsDetails>;
+}

node_modules/@agm/core/lib/directives/polyline.d.ts

@@ -0,0 +1,148 @@
+/// <reference types="googlemaps" />
+import { AfterContentInit, EventEmitter, OnChanges, OnDestroy, QueryList, SimpleChanges } from '@angular/core';
+import { PolylineManager } from '../services/managers/polyline-manager';
+import { MVCEvent } from '../utils/mvcarray-utils';
+import { AgmPolylineIcon } from './polyline-icon';
+import { AgmPolylinePoint } from './polyline-point';
+/**
+ * AgmPolyline renders a polyline on a {@link AgmMap}
+ *
+ * ### Example
+ * ```typescript
+ * import { Component } from '@angular/core';
+ *
+ * @Component({
+ *  selector: 'my-map-cmp',
+ *  styles: [`
+ *    .agm-map-container {
+ *      height: 300px;
+ *    }
+ * `],
+ *  template: `
+ *    <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
+ *      <agm-polyline>
+ *          <agm-polyline-point [latitude]="latA" [longitude]="lngA">
+ *          </agm-polyline-point>
+ *          <agm-polyline-point [latitude]="latB" [longitude]="lngB">
+ *          </agm-polyline-point>
+ *      </agm-polyline>
+ *    </agm-map>
+ *  `
+ * })
+ * ```
+ */
+export declare class AgmPolyline implements OnDestroy, OnChanges, AfterContentInit {
+    private _polylineManager;
+    /**
+     * Indicates whether this Polyline handles mouse events. Defaults to true.
+     */
+    clickable: boolean;
+    /**
+     * If set to true, the user can drag this shape over the map. The geodesic property defines the
+     * mode of dragging. Defaults to false.
+     */
+    draggable: boolean;
+    /**
+     * If set to true, the user can edit this shape by dragging the control points shown at the
+     * vertices and on each segment. Defaults to false.
+     */
+    editable: boolean;
+    /**
+     * When true, edges of the polygon are interpreted as geodesic and will follow the curvature of
+     * the Earth. When false, edges of the polygon are rendered as straight lines in screen space.
+     * Note that the shape of a geodesic polygon may appear to change when dragged, as the dimensions
+     * are maintained relative to the surface of the earth. Defaults to false.
+     */
+    geodesic: boolean;
+    /**
+     * The stroke color. All CSS3 colors are supported except for extended named colors.
+     */
+    strokeColor: string;
+    /**
+     * The stroke opacity between 0.0 and 1.0.
+     */
+    strokeOpacity: number;
+    /**
+     * The stroke width in pixels.
+     */
+    strokeWeight: number;
+    /**
+     * Whether this polyline is visible on the map. Defaults to true.
+     */
+    visible: boolean;
+    /**
+     * The zIndex compared to other polys.
+     */
+    zIndex: number;
+    /**
+     * This event is fired when the DOM click event is fired on the Polyline.
+     */
+    lineClick: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired when the DOM dblclick event is fired on the Polyline.
+     */
+    lineDblClick: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is repeatedly fired while the user drags the polyline.
+     */
+    lineDrag: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user stops dragging the polyline.
+     */
+    lineDragEnd: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user starts dragging the polyline.
+     */
+    lineDragStart: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the DOM mousedown event is fired on the Polyline.
+     */
+    lineMouseDown: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired when the DOM mousemove event is fired on the Polyline.
+     */
+    lineMouseMove: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired on Polyline mouseout.
+     */
+    lineMouseOut: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired on Polyline mouseover.
+     */
+    lineMouseOver: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired whe the DOM mouseup event is fired on the Polyline
+     */
+    lineMouseUp: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired when the Polyline is right-clicked on.
+     */
+    lineRightClick: EventEmitter<google.maps.PolyMouseEvent>;
+    /**
+     * This event is fired after Polyline's path changes.
+     */
+    polyPathChange: EventEmitter<MVCEvent<google.maps.LatLng>>;
+    /**
+     * @internal
+     */
+    points: QueryList<AgmPolylinePoint>;
+    iconSequences: QueryList<AgmPolylineIcon>;
+    private static _polylineOptionsAttributes;
+    private _id;
+    private _polylineAddedToManager;
+    private _subscriptions;
+    constructor(_polylineManager: PolylineManager);
+    /** @internal */
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): any;
+    getPath(): Promise<google.maps.LatLng[]>;
+    private _init;
+    private _addEventListeners;
+    /** @internal */
+    _getPoints(): AgmPolylinePoint[];
+    _getIcons(): Array<AgmPolylineIcon>;
+    /** @internal */
+    id(): string;
+    /** @internal */
+    ngOnDestroy(): void;
+}

node_modules/@agm/core/lib/directives/rectangle.d.ts

@@ -0,0 +1,134 @@
+/// <reference types="googlemaps" />
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChange } from '@angular/core';
+import { RectangleManager } from '../services/managers/rectangle-manager';
+export declare class AgmRectangle implements OnInit, OnChanges, OnDestroy {
+    private _manager;
+    /**
+     * The north position of the rectangle (required).
+     */
+    north: number;
+    /**
+     * The east position of the rectangle (required).
+     */
+    east: number;
+    /**
+     * The south position of the rectangle (required).
+     */
+    south: number;
+    /**
+     * The west position of the rectangle (required).
+     */
+    west: number;
+    /**
+     * Indicates whether this Rectangle handles mouse events. Defaults to true.
+     */
+    clickable: boolean;
+    /**
+     * If set to true, the user can drag this rectangle over the map. Defaults to false.
+     */
+    draggable: boolean;
+    /**
+     * If set to true, the user can edit this rectangle by dragging the control points shown at
+     * the center and around the circumference of the rectangle. Defaults to false.
+     */
+    editable: boolean;
+    /**
+     * The fill color. All CSS3 colors are supported except for extended named colors.
+     */
+    fillColor: string;
+    /**
+     * The fill opacity between 0.0 and 1.0.
+     */
+    fillOpacity: number;
+    /**
+     * The stroke color. All CSS3 colors are supported except for extended named colors.
+     */
+    strokeColor: string;
+    /**
+     * The stroke opacity between 0.0 and 1.0
+     */
+    strokeOpacity: number;
+    /**
+     * The stroke position. Defaults to CENTER.
+     * This property is not supported on Internet Explorer 8 and earlier.
+     */
+    strokePosition: keyof typeof google.maps.StrokePosition;
+    /**
+     * The stroke width in pixels.
+     */
+    strokeWeight: number;
+    /**
+     * Whether this rectangle is visible on the map. Defaults to true.
+     */
+    visible: boolean;
+    /**
+     * The zIndex compared to other polys.
+     */
+    zIndex: number;
+    /**
+     * This event is fired when the rectangle's is changed.
+     */
+    boundsChange: EventEmitter<google.maps.LatLngBoundsLiteral>;
+    /**
+     * This event emitter gets emitted when the user clicks on the rectangle.
+     */
+    rectangleClick: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event emitter gets emitted when the user clicks on the rectangle.
+     */
+    rectangleDblClick: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is repeatedly fired while the user drags the rectangle.
+     */
+    drag: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user stops dragging the rectangle.
+     */
+    dragEnd: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the user starts dragging the rectangle.
+     */
+    dragStart: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the DOM mousedown event is fired on the rectangle.
+     */
+    mouseDown: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the DOM mousemove event is fired on the rectangle.
+     */
+    mouseMove: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired on rectangle mouseout.
+     */
+    mouseOut: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired on rectangle mouseover.
+     */
+    mouseOver: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the DOM mouseup event is fired on the rectangle.
+     */
+    mouseUp: EventEmitter<google.maps.MouseEvent>;
+    /**
+     * This event is fired when the rectangle is right-clicked on.
+     */
+    rightClick: EventEmitter<google.maps.MouseEvent>;
+    private _rectangleAddedToManager;
+    private static _mapOptions;
+    private _eventSubscriptions;
+    constructor(_manager: RectangleManager);
+    /** @internal */
+    ngOnInit(): void;
+    /** @internal */
+    ngOnChanges(changes: {
+        [key: string]: SimpleChange;
+    }): void;
+    private _updateRectangleOptionsChanges;
+    private _registerEventListeners;
+    /** @internal */
+    ngOnDestroy(): void;
+    /**
+     * Gets the LatLngBounds of this Rectangle.
+     */
+    getBounds(): Promise<google.maps.LatLngBounds>;
+}

node_modules/@agm/core/lib/directives/transit-layer.d.ts

@@ -0,0 +1,19 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { LayerManager } from '../services/managers/layer-manager';
+export declare class AgmTransitLayer implements OnInit, OnDestroy {
+    private _manager;
+    private _addedToManager;
+    private _id;
+    /**
+     * Hide/show transit layer
+     */
+    visible: boolean;
+    constructor(_manager: LayerManager);
+    ngOnInit(): void;
+    /** @internal */
+    id(): string;
+    /** @internal */
+    toString(): string;
+    /** @internal */
+    ngOnDestroy(): void;
+}

node_modules/@agm/core/lib/services.d.ts

@@ -0,0 +1,15 @@
+export { CircleManager } from './services/managers/circle-manager';
+export { DataLayerManager } from './services/managers/data-layer-manager';
+export { FitBoundsAccessor, FitBoundsDetails } from './services/fit-bounds';
+export { AgmGeocoder } from './services/geocoder-service';
+export { GoogleMapsAPIWrapper } from './services/google-maps-api-wrapper';
+export { GoogleMapsScriptProtocol, LAZY_MAPS_API_CONFIG, LazyMapsAPILoader, LazyMapsAPILoaderConfigLiteral, } from './services/maps-api-loader/lazy-maps-api-loader';
+export { InfoWindowManager } from './services/managers/info-window-manager';
+export { KmlLayerManager } from './services/managers/kml-layer-manager';
+export { LayerManager } from './services/managers/layer-manager';
+export { MapsAPILoader } from './services/maps-api-loader/maps-api-loader';
+export { MarkerManager } from './services/managers/marker-manager';
+export { NoOpMapsAPILoader } from './services/maps-api-loader/noop-maps-api-loader';
+export { PolygonManager } from './services/managers/polygon-manager';
+export { PolylineManager } from './services/managers/polyline-manager';
+export { RectangleManager } from './services/managers/rectangle-manager';

node_modules/@agm/core/lib/services/fit-bounds.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="googlemaps" />
+import { BehaviorSubject, Observable } from 'rxjs';
+import { MapsAPILoader } from './maps-api-loader/maps-api-loader';
+export interface FitBoundsDetails {
+    latLng: google.maps.LatLng | google.maps.LatLngLiteral;
+}
+/**
+ * @internal
+ */
+export declare type BoundsMap = Map<string, google.maps.LatLng | google.maps.LatLngLiteral>;
+/**
+ * Class to implement when you what to be able to make it work with the auto fit bounds feature
+ * of AGM.
+ */
+export declare abstract class FitBoundsAccessor {
+    abstract getFitBoundsDetails$(): Observable<FitBoundsDetails>;
+}
+/**
+ * The FitBoundsService is responsible for computing the bounds of the a single map.
+ */
+export declare class FitBoundsService {
+    protected readonly bounds$: Observable<google.maps.LatLngBounds>;
+    protected readonly _boundsChangeSampleTime$: BehaviorSubject<number>;
+    protected readonly _includeInBounds$: BehaviorSubject<BoundsMap>;
+    constructor(loader: MapsAPILoader);
+    private _generateBounds;
+    addToBounds(latLng: google.maps.LatLng | google.maps.LatLngLiteral): void;
+    removeFromBounds(latLng: google.maps.LatLng | google.maps.LatLngLiteral): void;
+    changeFitBoundsChangeSampleTime(timeMs: number): void;
+    getBounds$(): Observable<google.maps.LatLngBounds>;
+    protected _createIdentifier(latLng: google.maps.LatLng | google.maps.LatLngLiteral): string;
+}

node_modules/@agm/core/lib/services/geocoder-service.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="googlemaps" />
+import { Observable } from 'rxjs';
+import { MapsAPILoader } from './maps-api-loader/maps-api-loader';
+export declare class AgmGeocoder {
+    protected readonly geocoder$: Observable<google.maps.Geocoder>;
+    constructor(loader: MapsAPILoader);
+    geocode(request: google.maps.GeocoderRequest): Observable<google.maps.GeocoderResult[]>;
+    private _getGoogleResults;
+    private _createGeocoder;
+}

node_modules/@agm/core/lib/services/google-maps-api-wrapper.d.ts

@@ -0,0 +1,70 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { MapsAPILoader } from './maps-api-loader/maps-api-loader';
+/**
+ * Wrapper class that handles the communication with the Google Maps Javascript
+ * API v3
+ */
+export declare class GoogleMapsAPIWrapper {
+    private _loader;
+    private _zone;
+    private _map;
+    private _mapResolver;
+    constructor(_loader: MapsAPILoader, _zone: NgZone);
+    createMap(el: HTMLElement, mapOptions: google.maps.MapOptions): Promise<void>;
+    setMapOptions(options: google.maps.MapOptions): void;
+    /**
+     * Creates a google map marker with the map context
+     */
+    createMarker(options?: google.maps.MarkerOptions, addToMap?: boolean): Promise<google.maps.Marker>;
+    createInfoWindow(options?: google.maps.InfoWindowOptions): Promise<google.maps.InfoWindow>;
+    /**
+     * Creates a google.map.Circle for the current map.
+     */
+    createCircle(options: google.maps.CircleOptions): Promise<google.maps.Circle>;
+    /**
+     * Creates a google.map.Rectangle for the current map.
+     */
+    createRectangle(options: google.maps.RectangleOptions): Promise<google.maps.Rectangle>;
+    createPolyline(options: google.maps.PolylineOptions): Promise<google.maps.Polyline>;
+    createPolygon(options: google.maps.PolygonOptions): Promise<google.maps.Polygon>;
+    /**
+     * Creates a new google.map.Data layer for the current map
+     */
+    createDataLayer(options?: google.maps.Data.DataOptions): Promise<google.maps.Data>;
+    /**
+     * Creates a TransitLayer instance for a map
+     * @returns a new transit layer object
+     */
+    createTransitLayer(): Promise<google.maps.TransitLayer>;
+    /**
+     * Creates a BicyclingLayer instance for a map
+     * @returns a new bicycling layer object
+     */
+    createBicyclingLayer(): Promise<google.maps.BicyclingLayer>;
+    /**
+     * Determines if given coordinates are insite a Polygon path.
+     */
+    containsLocation(latLng: google.maps.LatLng, polygon: google.maps.Polygon): Promise<boolean>;
+    subscribeToMapEvent<N extends keyof google.maps.MapHandlerMap>(eventName: N): Observable<google.maps.MapHandlerMap[N]>;
+    clearInstanceListeners(): void;
+    setCenter(latLng: google.maps.LatLngLiteral): Promise<void>;
+    getZoom(): Promise<number>;
+    getBounds(): Promise<google.maps.LatLngBounds>;
+    getMapTypeId(): Promise<google.maps.MapTypeId>;
+    setZoom(zoom: number): Promise<void>;
+    getCenter(): Promise<google.maps.LatLng>;
+    panTo(latLng: google.maps.LatLng | google.maps.LatLngLiteral): Promise<void>;
+    panBy(x: number, y: number): Promise<void>;
+    fitBounds(latLng: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral, padding?: number | google.maps.Padding): Promise<void>;
+    panToBounds(latLng: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral, padding?: number | google.maps.Padding): Promise<void>;
+    /**
+     * Returns the native Google Maps Map instance. Be careful when using this instance directly.
+     */
+    getNativeMap(): Promise<google.maps.Map>;
+    /**
+     * Triggers the given event name on the map instance.
+     */
+    triggerMapEvent(eventName: string): Promise<void>;
+}

node_modules/@agm/core/lib/services/managers/circle-manager.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmCircle } from '../../directives/circle';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+export declare class CircleManager {
+    private _apiWrapper;
+    private _zone;
+    private _circles;
+    constructor(_apiWrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    addCircle(circle: AgmCircle): void;
+    /**
+     * Removes the given circle from the map.
+     */
+    removeCircle(circle: AgmCircle): Promise<void>;
+    setOptions(circle: AgmCircle, options: google.maps.CircleOptions): Promise<void>;
+    getBounds(circle: AgmCircle): Promise<google.maps.LatLngBounds>;
+    getCenter(circle: AgmCircle): Promise<google.maps.LatLng>;
+    getRadius(circle: AgmCircle): Promise<number>;
+    setCenter(circle: AgmCircle): Promise<void>;
+    setEditable(circle: AgmCircle): Promise<void>;
+    setDraggable(circle: AgmCircle): Promise<void>;
+    setVisible(circle: AgmCircle): Promise<void>;
+    setRadius(circle: AgmCircle): Promise<void>;
+    getNativeCircle(circle: AgmCircle): Promise<google.maps.Circle>;
+    createEventObservable<T>(eventName: string, circle: AgmCircle): Observable<T>;
+}

node_modules/@agm/core/lib/services/managers/data-layer-manager.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmDataLayer } from './../../directives/data-layer';
+import { GoogleMapsAPIWrapper } from './../google-maps-api-wrapper';
+/**
+ * Manages all Data Layers for a Google Map instance.
+ */
+export declare class DataLayerManager {
+    private _wrapper;
+    private _zone;
+    private _layers;
+    constructor(_wrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    /**
+     * Adds a new Data Layer to the map.
+     */
+    addDataLayer(layer: AgmDataLayer): void;
+    deleteDataLayer(layer: AgmDataLayer): void;
+    updateGeoJson(layer: AgmDataLayer, geoJson: object | string): void;
+    setDataOptions(layer: AgmDataLayer, options: google.maps.Data.DataOptions): void;
+    /**
+     * Creates a Google Maps event listener for the given DataLayer as an Observable
+     */
+    createEventObservable<T>(eventName: string, layer: AgmDataLayer): Observable<T>;
+    /**
+     * Extract features from a geoJson using google.maps Data Class
+     * @param d : google.maps.Data class instance
+     * @param geoJson : url or geojson object
+     */
+    getDataFeatures(d: google.maps.Data, geoJson: object | string): Promise<google.maps.Data.Feature[]>;
+}

node_modules/@agm/core/lib/services/managers/info-window-manager.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmInfoWindow } from '../../directives/info-window';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+import { MarkerManager } from './marker-manager';
+export declare class InfoWindowManager {
+    private _mapsWrapper;
+    private _zone;
+    private _markerManager;
+    private _infoWindows;
+    constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: NgZone, _markerManager: MarkerManager);
+    deleteInfoWindow(infoWindow: AgmInfoWindow): Promise<void>;
+    setPosition(infoWindow: AgmInfoWindow): Promise<void>;
+    setZIndex(infoWindow: AgmInfoWindow): Promise<void>;
+    open(infoWindow: AgmInfoWindow): Promise<void>;
+    close(infoWindow: AgmInfoWindow): Promise<void>;
+    setOptions(infoWindow: AgmInfoWindow, options: google.maps.InfoWindowOptions): Promise<void>;
+    addInfoWindow(infoWindow: AgmInfoWindow): void;
+    /**
+     * Creates a Google Maps event listener for the given InfoWindow as an Observable
+     */
+    createEventObservable<T>(eventName: string, infoWindow: AgmInfoWindow): Observable<T>;
+}

node_modules/@agm/core/lib/services/managers/kml-layer-manager.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmKmlLayer } from './../../directives/kml-layer';
+import { GoogleMapsAPIWrapper } from './../google-maps-api-wrapper';
+/**
+ * Manages all KML Layers for a Google Map instance.
+ */
+export declare class KmlLayerManager {
+    private _wrapper;
+    private _zone;
+    private _layers;
+    constructor(_wrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    /**
+     * Adds a new KML Layer to the map.
+     */
+    addKmlLayer(layer: AgmKmlLayer): void;
+    setOptions(layer: AgmKmlLayer, options: google.maps.KmlLayerOptions): void;
+    deleteKmlLayer(layer: AgmKmlLayer): void;
+    /**
+     * Creates a Google Maps event listener for the given KmlLayer as an Observable
+     */
+    createEventObservable<T>(eventName: string, layer: AgmKmlLayer): Observable<T>;
+}

node_modules/@agm/core/lib/services/managers/layer-manager.d.ts

@@ -0,0 +1,30 @@
+import { AgmBicyclingLayer } from '../../directives/bicycling-layer';
+import { AgmTransitLayer } from '../../directives/transit-layer';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+/**
+ * This class manages Transit and Bicycling Layers for a Google Map instance.
+ */
+export declare class LayerManager {
+    private _wrapper;
+    private _layers;
+    constructor(_wrapper: GoogleMapsAPIWrapper);
+    /**
+     * Adds a transit layer to a map instance.
+     * @param layer - a TransitLayer object
+     * @param _options - TransitLayerOptions options
+     * @returns void
+     */
+    addTransitLayer(layer: AgmTransitLayer): void;
+    /**
+     * Adds a bicycling layer to a map instance.
+     * @param layer - a bicycling layer object
+     * @param _options - BicyclingLayer options
+     * @returns void
+     */
+    addBicyclingLayer(layer: AgmBicyclingLayer): void;
+    /**
+     * Deletes a map layer
+     * @param layer - the layer to delete
+     */
+    deleteLayer(layer: AgmTransitLayer | AgmBicyclingLayer): Promise<void>;
+}

node_modules/@agm/core/lib/services/managers/marker-manager.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmMarker } from './../../directives/marker';
+import { GoogleMapsAPIWrapper } from './../google-maps-api-wrapper';
+export declare class MarkerManager {
+    protected _mapsWrapper: GoogleMapsAPIWrapper;
+    protected _zone: NgZone;
+    protected _markers: Map<AgmMarker, Promise<google.maps.Marker>>;
+    constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    convertAnimation(uiAnim: keyof typeof google.maps.Animation | null): Promise<google.maps.Animation>;
+    deleteMarker(markerDirective: AgmMarker): Promise<void>;
+    updateMarkerPosition(marker: AgmMarker): Promise<void>;
+    updateTitle(marker: AgmMarker): Promise<void>;
+    updateLabel(marker: AgmMarker): Promise<void>;
+    updateDraggable(marker: AgmMarker): Promise<void>;
+    updateIcon(marker: AgmMarker): Promise<void>;
+    updateOpacity(marker: AgmMarker): Promise<void>;
+    updateVisible(marker: AgmMarker): Promise<void>;
+    updateZIndex(marker: AgmMarker): Promise<void>;
+    updateClickable(marker: AgmMarker): Promise<void>;
+    updateAnimation(marker: AgmMarker): Promise<void>;
+    addMarker(marker: AgmMarker): void;
+    getNativeMarker(marker: AgmMarker): Promise<google.maps.Marker>;
+    createEventObservable<T extends (google.maps.MouseEvent | void)>(eventName: google.maps.MarkerMouseEventNames | google.maps.MarkerChangeOptionEventNames, marker: AgmMarker): Observable<T>;
+}

node_modules/@agm/core/lib/services/managers/polygon-manager.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmPolygon } from '../../directives/polygon';
+import { MVCEvent } from '../../utils/mvcarray-utils';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+export declare class PolygonManager {
+    private _mapsWrapper;
+    private _zone;
+    private _polygons;
+    constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    addPolygon(path: AgmPolygon): void;
+    updatePolygon(polygon: AgmPolygon): Promise<void>;
+    setPolygonOptions(path: AgmPolygon, options: {
+        [propName: string]: any;
+    }): Promise<void>;
+    deletePolygon(paths: AgmPolygon): Promise<void>;
+    getPath(polygonDirective: AgmPolygon): Promise<google.maps.LatLng[]>;
+    getPaths(polygonDirective: AgmPolygon): Promise<google.maps.LatLng[][]>;
+    createEventObservable<T>(eventName: string, path: AgmPolygon): Observable<T>;
+    createPathEventObservable(agmPolygon: AgmPolygon): Promise<Observable<MVCEvent<google.maps.LatLng[] | google.maps.LatLngLiteral[]>>>;
+}

node_modules/@agm/core/lib/services/managers/polyline-manager.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmPolyline } from '../../directives/polyline';
+import { MVCEvent } from '../../utils/mvcarray-utils';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+export declare class PolylineManager {
+    private _mapsWrapper;
+    private _zone;
+    private _polylines;
+    constructor(_mapsWrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    private static _convertPoints;
+    private static _convertPath;
+    private static _convertIcons;
+    addPolyline(line: AgmPolyline): void;
+    updatePolylinePoints(line: AgmPolyline): Promise<void>;
+    updateIconSequences(line: AgmPolyline): Promise<void>;
+    setPolylineOptions(line: AgmPolyline, options: {
+        [propName: string]: any;
+    }): Promise<void>;
+    deletePolyline(line: AgmPolyline): Promise<void>;
+    private getMVCPath;
+    getPath(agmPolyline: AgmPolyline): Promise<google.maps.LatLng[]>;
+    createEventObservable<T>(eventName: string, line: AgmPolyline): Observable<T>;
+    createPathEventObservable(line: AgmPolyline): Promise<Observable<MVCEvent<google.maps.LatLng>>>;
+}

node_modules/@agm/core/lib/services/managers/rectangle-manager.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="googlemaps" />
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AgmRectangle } from '../../directives/rectangle';
+import { GoogleMapsAPIWrapper } from '../google-maps-api-wrapper';
+export declare class RectangleManager {
+    private _apiWrapper;
+    private _zone;
+    private _rectangles;
+    constructor(_apiWrapper: GoogleMapsAPIWrapper, _zone: NgZone);
+    addRectangle(rectangle: AgmRectangle): void;
+    /**
+     * Removes the given rectangle from the map.
+     */
+    removeRectangle(rectangle: AgmRectangle): Promise<void>;
+    setOptions(rectangle: AgmRectangle, options: google.maps.RectangleOptions): Promise<void>;
+    getBounds(rectangle: AgmRectangle): Promise<google.maps.LatLngBounds>;
+    setBounds(rectangle: AgmRectangle): Promise<void>;
+    setEditable(rectangle: AgmRectangle): Promise<void>;
+    setDraggable(rectangle: AgmRectangle): Promise<void>;
+    setVisible(rectangle: AgmRectangle): Promise<void>;
+    createEventObservable<T>(eventName: string, rectangle: AgmRectangle): Observable<T>;
+}

node_modules/@agm/core/lib/services/maps-api-loader/lazy-maps-api-loader.d.ts

@@ -0,0 +1,79 @@
+import { InjectionToken } from '@angular/core';
+import { DocumentRef, WindowRef } from '../../utils/browser-globals';
+import { MapsAPILoader } from './maps-api-loader';
+export declare enum GoogleMapsScriptProtocol {
+    HTTP = 1,
+    HTTPS = 2,
+    AUTO = 3
+}
+/**
+ * Token for the config of the LazyMapsAPILoader. Please provide an object of type {@link
+ * LazyMapsAPILoaderConfig}.
+ */
+export declare const LAZY_MAPS_API_CONFIG: InjectionToken<LazyMapsAPILoaderConfigLiteral>;
+/**
+ * Configuration for the {@link LazyMapsAPILoader}.
+ */
+export interface LazyMapsAPILoaderConfigLiteral {
+    /**
+     * The Google Maps API Key (see:
+     * https://developers.google.com/maps/documentation/javascript/get-api-key)
+     */
+    apiKey?: string;
+    /**
+     * The Google Maps client ID (for premium plans).
+     * When you have a Google Maps APIs Premium Plan license, you must authenticate
+     * your application with either an API key or a client ID.
+     * The Google Maps API will fail to load if both a client ID and an API key are included.
+     */
+    clientId?: string;
+    /**
+     * The Google Maps channel name (for premium plans).
+     * A channel parameter is an optional parameter that allows you to track usage under your client
+     * ID by assigning a distinct channel to each of your applications.
+     */
+    channel?: string;
+    /**
+     * Google Maps API version.
+     */
+    apiVersion?: string;
+    /**
+     * Host and Path used for the `<script>` tag.
+     */
+    hostAndPath?: string;
+    /**
+     * Protocol used for the `<script>` tag.
+     */
+    protocol?: GoogleMapsScriptProtocol;
+    /**
+     * Defines which Google Maps libraries should get loaded.
+     */
+    libraries?: string[];
+    /**
+     * The default bias for the map behavior is US.
+     * If you wish to alter your application to serve different map tiles or bias the
+     * application, you can overwrite the default behavior (US) by defining a `region`.
+     * See https://developers.google.com/maps/documentation/javascript/basics#Region
+     */
+    region?: string;
+    /**
+     * The Google Maps API uses the browser's preferred language when displaying
+     * textual information. If you wish to overwrite this behavior and force the API
+     * to use a given language, you can use this setting.
+     * See https://developers.google.com/maps/documentation/javascript/basics#Language
+     */
+    language?: string;
+}
+export declare class LazyMapsAPILoader extends MapsAPILoader {
+    private localeId;
+    protected _scriptLoadingPromise: Promise<void>;
+    protected _config: LazyMapsAPILoaderConfigLiteral;
+    protected _windowRef: WindowRef;
+    protected _documentRef: DocumentRef;
+    protected readonly _SCRIPT_ID: string;
+    protected readonly callbackName: string;
+    constructor(config: any, w: WindowRef, d: DocumentRef, localeId: string);
+    load(): Promise<void>;
+    private _assignScriptLoadingPromise;
+    protected _getScriptSrc(callbackName: string): string;
+}

node_modules/@agm/core/lib/services/maps-api-loader/maps-api-loader.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class MapsAPILoader {
+    abstract load(): Promise<void>;
+}

node_modules/@agm/core/lib/services/maps-api-loader/noop-maps-api-loader.d.ts

@@ -0,0 +1,9 @@
+import { MapsAPILoader } from './maps-api-loader';
+/**
+ * When using the NoOpMapsAPILoader, the Google Maps API must be added to the page via a `<script>`
+ * Tag.
+ * It's important that the Google Maps API script gets loaded first on the page.
+ */
+export declare class NoOpMapsAPILoader implements MapsAPILoader {
+    load(): Promise<void>;
+}

node_modules/@agm/core/lib/utils/browser-globals.d.ts

@@ -0,0 +1,8 @@
+import { Provider } from '@angular/core';
+export declare class WindowRef {
+    getNativeWindow(): any;
+}
+export declare class DocumentRef {
+    getNativeDocument(): any;
+}
+export declare const BROWSER_GLOBALS_PROVIDERS: Provider[];

node_modules/@agm/core/lib/utils/mvcarray-utils.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="googlemaps" />
+import { Observable } from 'rxjs';
+export declare function createMVCEventObservable<T>(array: google.maps.MVCArray<T>): Observable<MVCEvent<T>>;
+export declare type MvcEventType = 'insert_at' | 'remove_at' | 'set_at';
+export interface MVCEvent<T> {
+    newArr: T[];
+    eventName: MvcEventType;
+    index: number;
+    previous?: T;
+}
+export declare class MvcArrayMock<T> implements google.maps.MVCArray<T> {
+    private vals;
+    private listeners;
+    clear(): void;
+    getArray(): T[];
+    getAt(i: number): T;
+    getLength(): number;
+    insertAt(i: number, elem: T): void;
+    pop(): T;
+    push(elem: T): number;
+    removeAt(i: number): T;
+    setAt(i: number, elem: T): void;
+    forEach(callback: (elem: T, i: number) => void): void;
+    addListener(eventName: 'remove_at' | 'insert_at' | 'set_at', handler: (...args: any[]) => void): google.maps.MapsEventListener;
+    bindTo(): never;
+    changed(): never;
+    get(): never;
+    notify(): never;
+    set(): never;
+    setValues(): never;
+    unbind(): never;
+    unbindAll(): never;
+}

node_modules/@agm/core/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@agm/core",
+  "version": "3.0.0-beta.0",
+  "description": "Angular components for Google Maps",
+  "author": "Sebastian Holstein <info@sebastian-holstein.de>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SebastianM/angular-google-maps.git"
+  },
+  "bugs": {
+    "url": "https://github.com/SebastianM/angular-google-maps/issues"
+  },
+  "homepage": "https://angular-maps.com",
+  "keywords": [
+    "angular",
+    "ng",
+    "google-maps",
+    "maps",
+    "google",
+    "gmaps"
+  ],
+  "peerDependencies": {
+    "@angular/common": "^9.1.0 || ^10.0.0",
+    "@angular/core": "^9.1.0 || ^10.0.0",
+    "@types/googlemaps": "^3.39.8"
+  },
+  "dependencies": {
+    "tslib": "^2.0.0"
+  },
+  "main": "bundles/agm-core.umd.js",
+  "module": "fesm2015/agm-core.js",
+  "es2015": "fesm2015/agm-core.js",
+  "esm2015": "esm2015/agm-core.js",
+  "fesm2015": "fesm2015/agm-core.js",
+  "typings": "agm-core.d.ts",
+  "metadata": "agm-core.metadata.json",
+  "sideEffects": false
+}

node_modules/@agm/core/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/services';
+export * from './lib/directives';
+export * from './lib/core.module';