@igo2/geo 18.0.1-next.2 → 18.0.2

package/esm2022/lib/measure/measurer/measurer.component.mjs

@@ -0,0 +1,948 @@
+import { AsyncPipe, DOCUMENT, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Inject, Input, ViewChild } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MatButtonToggleModule } from '@angular/material/button-toggle';
+import { MatDialog } from '@angular/material/dialog';
+import { MatDividerModule } from '@angular/material/divider';
+import { MatIconModule } from '@angular/material/icon';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { EntityTableComponent } from '@igo2/common/entity';
+import { LanguageService } from '@igo2/core/language';
+import { IgoLanguageModule } from '@igo2/core/language';
+import { StorageScope, StorageService } from '@igo2/core/storage';
+import { uuid } from '@igo2/utils';
+import { unByKey } from 'ol/Observable';
+import OlGeoJSON from 'ol/format/GeoJSON';
+import OlVectorSource from 'ol/source/Vector';
+import OlStyle from 'ol/style/Style';
+import { BehaviorSubject } from 'rxjs';
+import { skip } from 'rxjs/operators';
+import { FeatureDataSource } from '../../datasource/shared/datasources';
+import { FEATURE, FeatureStore, FeatureStoreLoadingStrategy, FeatureStoreSelectionStrategy, tryAddLoadingStrategy, tryAddSelectionStrategy, tryBindStoreLayer } from '../../feature';
+import { DrawControl, ModifyControl } from '../../geometry/shared';
+import { VectorLayer } from '../../layer/shared';
+import { IgoMap } from '../../map/shared/map';
+import { MeasureAreaUnit, MeasureLengthUnit, MeasureType } from '../shared/measure.enum';
+import { createMeasureInteractionStyle, createMeasureLayerStyle, formatMeasure, getTooltipsOfOlGeometry, measureOlGeometry, metersToUnit, squareMetersToUnit, updateOlTooltipAtCenter, updateOlTooltipsAtMidpoints } from '../shared/measure.utils';
+import { MeasurerDialogComponent } from './measurer-dialog.component';
+import { MeasurerItemComponent } from './measurer-item.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core/language";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "@igo2/core/storage";
+import * as i4 from "@angular/material/button-toggle";
+import * as i5 from "@angular/material/slide-toggle";
+import * as i6 from "@angular/material/divider";
+import * as i7 from "@angular/material/button";
+import * as i8 from "@angular/material/tooltip";
+import * as i9 from "@angular/material/icon";
+import * as i10 from "@ngx-translate/core";
+/**
+ * Tool to measure lengths and areas
+ */
+export class MeasurerComponent {
+    languageService;
+    dialog;
+    storageService;
+    document;
+    /**
+     * Table template
+     * @internal
+     */
+    tableTemplate;
+    subscriptions$$ = [];
+    /**
+     * Reference to the MeasureType enum
+     * @internal
+     */
+    measureType = MeasureType;
+    /**
+     * Reference to the AreaMeasureUnit enum
+     * @internal
+     */
+    measureAreaUnit = MeasureAreaUnit;
+    /**
+     * Reference to the LengthMeasureUnit enum
+     * @internal
+     */
+    measureLengthUnit = MeasureLengthUnit;
+    /**
+     * Whether measure units should be automatically determined
+     * @internal
+     */
+    measureUnitsAuto = false;
+    /**
+     * Whether display of distances of areas
+     * @internal
+     */
+    displayDistance = true;
+    /**
+     * Whether display of distances of lines
+     * @internal
+     */
+    displayLines = true;
+    /**
+     * Whether display of areas
+     * @internal
+     */
+    displayAreas = true;
+    /**
+     * Observable of line boolean
+     * @internal
+     */
+    hasLine$ = new BehaviorSubject(false);
+    /**
+     * Observable of area boolean
+     * @internal
+     */
+    hasArea$ = new BehaviorSubject(false);
+    /**
+     * Observable of area
+     * @internal
+     */
+    measure$ = new BehaviorSubject({});
+    /**
+     * Observable of selected features
+     * @internal
+     */
+    selectedFeatures$ = new BehaviorSubject([]);
+    /**
+     * OL draw source
+     * @internal
+     */
+    showTooltips = true;
+    /**
+     * Whether draw control toggle is disabled or not
+     * @internal
+     */
+    drawControlIsDisabled = true;
+    /**
+     * Draw line control
+     */
+    drawLineControl;
+    /**
+     * Draw polygon control
+     */
+    drawPolygonControl;
+    /**
+     * Modify control
+     */
+    modifyControl;
+    /**
+     * Active OL geometry
+     */
+    activeOlGeometry;
+    /**
+     * Active mlength unit
+     */
+    activeLengthUnit = MeasureLengthUnit.Meters;
+    /**
+     * Active area unit
+     */
+    activeAreaUnit = MeasureAreaUnit.SquareMeters;
+    /**
+     * Feature added listener key
+     */
+    onFeatureAddedKey;
+    /**
+     * Feature removed listener key
+     */
+    onFeatureRemovedKey;
+    /**
+     * Active draw control
+     * @internal
+     */
+    activeDrawControl;
+    /**
+     * Subscription to draw start
+     */
+    drawStart$$;
+    /**
+     * Subscription to draw end
+     */
+    drawEnd$$;
+    /**
+     * Subscription to controls changes
+     */
+    drawChanges$$;
+    /**
+     * Subscription to modify start
+     */
+    modifyStart$$;
+    /**
+     * Subscription to modify end
+     */
+    modifyEnd$$;
+    /**
+     * Subscription to controls changes
+     */
+    modifyChanges$$;
+    /**
+     * Subscription to measures selection
+     */
+    selectedFeatures$$;
+    /**
+     * OL draw source
+     */
+    olDrawSource = new OlVectorSource();
+    /**
+     * The map to measure on
+     */
+    map;
+    /**
+     * The measures store
+     */
+    store;
+    /**
+     * Measure type
+     * @internal
+     */
+    set activeMeasureType(value) {
+        this.setActiveMeasureType(value);
+    }
+    get activeMeasureType() {
+        return this._activeMeasureType;
+    }
+    _activeMeasureType;
+    /**
+     * The minimum length a segment must have to display a tooltip.
+     * It also applies to area tooltips.
+     */
+    minSegmentLength = 10;
+    table;
+    /**
+     * Wheter one of the draw control is active
+     * @internal
+     */
+    get drawControlIsActive() {
+        return this.activeDrawControl !== undefined;
+    }
+    get projection() {
+        return this.map.ol.getView().getProjection().getCode();
+    }
+    constructor(languageService, dialog, storageService, document) {
+        this.languageService = languageService;
+        this.dialog = dialog;
+        this.storageService = storageService;
+        this.document = document;
+        this.tableTemplate = {
+            selection: true,
+            selectMany: true,
+            selectionCheckbox: true,
+            sort: true,
+            columns: [
+                {
+                    name: 'length',
+                    title: this.languageService.translate.instant('igo.geo.measure.lengthHeader'),
+                    valueAccessor: (localFeature) => {
+                        const unit = this.activeLengthUnit;
+                        const measure = metersToUnit(localFeature.properties.measure.length, unit);
+                        return formatMeasure(measure, {
+                            decimal: 1,
+                            unit,
+                            unitAbbr: false,
+                            locale: 'fr'
+                        });
+                    }
+                },
+                {
+                    name: 'area',
+                    title: this.languageService.translate.instant('igo.geo.measure.areaHeader'),
+                    valueAccessor: (localFeature) => {
+                        const unit = this.activeAreaUnit;
+                        const measure = squareMetersToUnit(localFeature.properties.measure.area, unit);
+                        return measure
+                            ? formatMeasure(measure, {
+                                decimal: 1,
+                                unit,
+                                unitAbbr: false,
+                                locale: 'fr'
+                            })
+                            : '';
+                    }
+                }
+            ]
+        };
+    }
+    /**
+     * Add draw controls and activate one
+     * @internal
+     */
+    ngOnInit() {
+        this.getSavedUnits();
+        this.initStore();
+        this.createDrawLineControl();
+        this.createDrawPolygonControl();
+        this.createModifyControl();
+        this.toggleDrawControl();
+        this.updateTooltipsOfOlSource(this.store.source.ol);
+        this.checkDistanceAreaToggle();
+        this.setActiveMeasureType(MeasureType.Length);
+    }
+    /**
+     * Clear the overlay layer and any interaction added by this component.
+     * @internal
+     */
+    ngOnDestroy() {
+        if (this.store.count === 0) {
+            this.store.map.layerController.remove(this.store.layer);
+        }
+        this.setActiveMeasureType(undefined);
+        this.deactivateModifyControl();
+        this.freezeStore();
+        this.subscriptions$$.map((s) => s.unsubscribe());
+    }
+    /**
+     * Set the measure type
+     * @internal
+     */
+    onMeasureTypeChange(measureType) {
+        this.activeMeasureType = measureType;
+    }
+    /**
+     * Activate or deactivate the current draw control
+     * @internal
+     */
+    onToggleDrawControl(toggle) {
+        if (toggle === true) {
+            this.toggleDrawControl();
+        }
+        else {
+            this.deactivateDrawControl();
+        }
+    }
+    /**
+     * Activate or deactivate the current draw control
+     * @internal
+     */
+    onToggleMeasureUnitsAuto(toggle) {
+        this.measureUnitsAuto = toggle;
+    }
+    /**
+     * Activate or deactivate the current display of distances of the areas
+     * @internal
+     */
+    onToggleDisplayDistance(toggle) {
+        this.displayDistance = toggle;
+        this.onDisplayDistance();
+        this.storageService.set('distanceToggle', toggle, StorageScope.SESSION);
+    }
+    /**
+     * Activate or deactivate the current display of distances of the lines
+     * @internal
+     */
+    onToggleDisplayLines(toggle) {
+        this.displayLines = toggle;
+        this.onDisplayLines();
+        this.storageService.set('linesToggle', toggle, StorageScope.SESSION);
+    }
+    /**
+     * Activate or deactivate the current display of areas
+     * @internal
+     */
+    onToggleDisplayAreas(toggle) {
+        this.displayAreas = toggle;
+        this.onDisplayAreas();
+        this.storageService.set('areasToggle', toggle, StorageScope.SESSION);
+    }
+    /**
+     * Set display parametres in current values
+     * @internal
+     */
+    checkDistanceAreaToggle() {
+        if (this.storageService.get('distanceToggle') === false) {
+            this.displayDistance = false;
+        }
+        if (this.storageService.get('linesToggle') === false) {
+            this.displayLines = false;
+        }
+        if (this.storageService.get('areasToggle') === false) {
+            this.displayAreas = false;
+        }
+    }
+    /**
+     * Activate or deactivate the current display of distances of areas
+     * @internal
+     */
+    onDisplayDistance() {
+        const elements = this.document.getElementsByClassName('igo-map-tooltip-measure-polygone-segments');
+        if (this.displayDistance) {
+            Array.from(elements).map((value) => value.classList.remove('igo-map-tooltip-hidden'));
+        }
+        else {
+            Array.from(elements).map((value) => value.classList.add('igo-map-tooltip-hidden'));
+        }
+    }
+    /**
+     * Activate or deactivate the current display of distances of lines
+     * @internal
+     */
+    onDisplayLines() {
+        const elements = this.document.getElementsByClassName('igo-map-tooltip-measure-line-segments');
+        if (this.displayLines) {
+            Array.from(elements).map((value) => {
+                value.classList.remove('igo-map-tooltip-hidden');
+            });
+        }
+        else {
+            Array.from(elements).map((value) => {
+                value.classList.add('igo-map-tooltip-hidden');
+            });
+        }
+    }
+    /**
+     * Activate or deactivate the current display of areas
+     * @internal
+     */
+    onDisplayAreas() {
+        const elements = this.document.getElementsByClassName('igo-map-tooltip-measure-area');
+        if (this.displayAreas) {
+            Array.from(elements).map((value) => value.classList.remove('igo-map-tooltip-hidden'));
+        }
+        else {
+            Array.from(elements).map((value) => value.classList.add('igo-map-tooltip-hidden'));
+        }
+    }
+    /**
+     * Set the measure type
+     * @internal
+     */
+    onLengthUnitChange(unit) {
+        this.activeLengthUnit = unit;
+        this.saveCurrentUnits();
+        this.refreshTableAndTooltip();
+    }
+    /**
+     * Set the measure type
+     * @internal
+     */
+    onAreaUnitChange(unit) {
+        this.activeAreaUnit = unit;
+        this.saveCurrentUnits();
+        this.refreshTableAndTooltip();
+    }
+    refreshTableAndTooltip() {
+        this.store.stateView.clear();
+        this.updateTooltipsOfOlSource(this.store.source.ol);
+        if (this.activeOlGeometry !== undefined) {
+            this.updateTooltipsOfOlGeometry(this.activeOlGeometry);
+        }
+    }
+    onCalculateClick() {
+        const features = this.selectedFeatures$.value;
+        const area = features.reduce((sum, localFeature) => {
+            return sum + localFeature.properties.measure.area || 0;
+        }, 0);
+        const length = features.reduce((sum, localFeature) => {
+            if (localFeature.geometry.type === 'Polygon') {
+                return sum;
+            }
+            return sum + localFeature.properties.measure.length || 0;
+        }, 0);
+        const perimeter = features.reduce((sum, localFeature) => {
+            if (localFeature.geometry.type === 'LineString') {
+                return sum;
+            }
+            return sum + localFeature.properties.measure.length || 0;
+        }, 0);
+        this.openDialog({
+            area,
+            length,
+            perimeter
+        });
+    }
+    onDeleteClick() {
+        this.store.deleteMany(this.selectedFeatures$.value);
+        this.selectedFeatures$.value.forEach((selectedFeature) => {
+            this.olDrawSource.getFeatures().forEach((drawingLayerFeature) => {
+                const geometry = drawingLayerFeature.getGeometry();
+                if (selectedFeature.properties.id === geometry.ol_uid) {
+                    this.olDrawSource.removeFeature(drawingLayerFeature);
+                }
+            });
+        });
+    }
+    onModifyClick() {
+        if (this.selectedFeatures$.value.length !== 1) {
+            return;
+        }
+        if (this.modifyControl.active === true) {
+            this.deactivateModifyControl();
+            this.toggleDrawControl();
+        }
+        else {
+            const localFeature = this.selectedFeatures$.value[0];
+            const olFeatures = this.store.layer.ol.getSource().getFeatures();
+            const olFeature = olFeatures.find((_olFeature) => {
+                return _olFeature.get('id') === localFeature.properties.id;
+            });
+            if (olFeature !== undefined) {
+                this.deactivateDrawControl();
+                this.activateModifyControl();
+                const olGeometry = olFeature.getGeometry();
+                this.clearTooltipsOfOlGeometry(olGeometry);
+                this.modifyControl.setOlGeometry(olGeometry);
+            }
+        }
+    }
+    openDialog(data) {
+        this.dialog.open(MeasurerDialogComponent, { data });
+    }
+    /**
+     * Initialize the measure store and set up some listeners
+     * @internal
+     */
+    initStore() {
+        const store = this.store;
+        let layer = new VectorLayer({
+            title: this.languageService.translate.instant('igo.geo.measure.layerTitle'),
+            isIgoInternalLayer: true,
+            id: `igo-measures-${uuid()}`,
+            zIndex: 200,
+            source: new FeatureDataSource(),
+            style: createMeasureLayerStyle(),
+            showInLayerList: true,
+            exportable: true,
+            visible: true,
+            browsable: false,
+            workspace: { enabled: false }
+        });
+        layer = tryBindStoreLayer(store, layer);
+        layer.visible$.subscribe((visible) => {
+            const elements = this.document.getElementsByClassName('igo-map-tooltip-measure');
+            if (visible) {
+                Array.from(elements).map((value) => value.classList.remove('igo-map-tooltip-measure-by-display'));
+            }
+            else {
+                Array.from(elements).map((value) => value.classList.add('igo-map-tooltip-measure-by-display'));
+            }
+        });
+        tryAddLoadingStrategy(store);
+        tryAddSelectionStrategy(store, new FeatureStoreSelectionStrategy({
+            map: this.map,
+            many: true
+        }));
+        this.onFeatureAddedKey = store.source.ol.on('addfeature', (event) => {
+            const localFeature = event.feature;
+            const olGeometry = localFeature.getGeometry();
+            this.updateMeasureOfOlGeometry(olGeometry, localFeature.get('measure'));
+            this.onDisplayDistance();
+            this.onDisplayLines();
+            this.onDisplayAreas();
+        });
+        this.onFeatureRemovedKey = store.source.ol.on('removefeature', (event) => {
+            const olGeometry = event.feature.getGeometry();
+            this.clearTooltipsOfOlGeometry(olGeometry);
+        });
+        this.selectedFeatures$$ = store.stateView
+            .manyBy$((record) => {
+            return record.state.selected === true;
+        })
+            .pipe(skip(1) // Skip initial emission
+        )
+            .subscribe((records) => {
+            if (this.modifyControl.active === true) {
+                this.deactivateModifyControl();
+            }
+            this.selectedFeatures$.next(records.map((record) => record.entity));
+        });
+        this.subscriptions$$.push(this.store.entities$.subscribe((objectsExists) => {
+            if (objectsExists.find((objectExist) => objectExist.geometry.type === 'Polygon')) {
+                this.hasArea$.next(true);
+            }
+            else {
+                this.hasArea$.next(false);
+            }
+            if (objectsExists.find((objectExist) => objectExist.geometry.type === 'LineString')) {
+                this.hasLine$.next(true);
+            }
+            else {
+                this.hasLine$.next(false);
+            }
+        }));
+    }
+    /**
+     * Freeze any store, meaning the layer is removed, strategies are deactivated
+     * and some listener removed
+     * @internal
+     */
+    freezeStore() {
+        const store = this.store;
+        this.selectedFeatures$$.unsubscribe();
+        unByKey(this.onFeatureAddedKey);
+        unByKey(this.onFeatureRemovedKey);
+        store.deactivateStrategyOfType(FeatureStoreLoadingStrategy);
+        store.deactivateStrategyOfType(FeatureStoreSelectionStrategy);
+    }
+    /**
+     * Create a draw line control
+     */
+    createDrawLineControl() {
+        this.drawLineControl = new DrawControl({
+            geometryType: 'LineString',
+            drawingLayerSource: this.olDrawSource,
+            interactionStyle: createMeasureInteractionStyle(),
+            drawingLayerStyle: new OlStyle({})
+        });
+    }
+    /**
+     * Create a draw polygon control
+     */
+    createDrawPolygonControl() {
+        this.drawPolygonControl = new DrawControl({
+            geometryType: 'Polygon',
+            drawingLayerSource: this.olDrawSource,
+            interactionStyle: createMeasureInteractionStyle(),
+            drawingLayerStyle: new OlStyle({})
+        });
+    }
+    /**
+     * Create a draw polygon control
+     */
+    createModifyControl() {
+        this.modifyControl = new ModifyControl({
+            source: this.olDrawSource,
+            drawStyle: createMeasureInteractionStyle(),
+            layerStyle: new OlStyle({})
+        });
+    }
+    /**
+     * Activate the right control
+     */
+    toggleDrawControl() {
+        this.deactivateDrawControl();
+        // this.deactivateModifyControl();
+        if (this.activeMeasureType === MeasureType.Length) {
+            this.activateDrawControl(this.drawLineControl);
+        }
+        else if (this.activeMeasureType === MeasureType.Area) {
+            this.activateDrawControl(this.drawPolygonControl);
+        }
+    }
+    /**
+     * Activate a given control
+     * @param drawControl Draw control
+     */
+    activateDrawControl(drawControl) {
+        this.drawControlIsDisabled = false;
+        this.activeDrawControl = drawControl;
+        this.drawStart$$ = drawControl.start$.subscribe((olGeometry) => this.onDrawStart(olGeometry));
+        this.drawEnd$$ = drawControl.end$.subscribe((olGeometry) => this.onDrawEnd(olGeometry));
+        this.drawChanges$$ = drawControl.changes$.subscribe((olGeometry) => this.onDrawChanges(olGeometry));
+        this.drawChanges$$ = drawControl.abort$.subscribe((olGeometry) => {
+            this.clearTooltipsOfOlGeometry(olGeometry);
+            this.clearMeasures();
+        });
+        drawControl.setOlMap(this.map.ol, false);
+    }
+    /**
+     * Deactivate the active draw control
+     */
+    deactivateDrawControl() {
+        if (this.activeDrawControl === undefined) {
+            return;
+        }
+        this.olDrawSource.clear();
+        if (this.drawStart$$ !== undefined) {
+            this.drawStart$$.unsubscribe();
+        }
+        if (this.drawEnd$$ !== undefined) {
+            this.drawEnd$$.unsubscribe();
+        }
+        if (this.drawChanges$$ !== undefined) {
+            this.drawChanges$$.unsubscribe();
+        }
+        this.clearTooltipsOfOlSource(this.olDrawSource);
+        if (this.activeOlGeometry !== undefined) {
+            this.clearTooltipsOfOlGeometry(this.activeOlGeometry);
+        }
+        this.activeDrawControl.setOlMap(undefined);
+        this.activeDrawControl = undefined;
+        this.activeOlGeometry = undefined;
+    }
+    setActiveMeasureType(measureType) {
+        this._activeMeasureType = measureType;
+        this.clearMeasures();
+        this.toggleDrawControl();
+    }
+    /**
+     * Clear the draw source and track the geometry being drawn
+     * @param olGeometry Ol linestring or polygon
+     */
+    onDrawStart(olGeometry) {
+        this.activeOlGeometry = olGeometry;
+    }
+    /**
+     * Clear the draw source and track the geometry being draw
+     * @param olGeometry Ol linestring or polygon
+     */
+    onDrawEnd(olGeometry) {
+        this.activeOlGeometry = undefined;
+        this.finalizeMeasureOfOlGeometry(olGeometry);
+        this.addFeatureToStore(olGeometry);
+        this.clearTooltipsOfOlGeometry(olGeometry);
+        this.olDrawSource.clear(true);
+    }
+    /**
+     * Update measures observables and map tooltips
+     * @param olGeometry Ol linestring or polygon
+     */
+    onDrawChanges(olGeometry) {
+        const measure = measureOlGeometry(olGeometry, this.projection);
+        this.updateMeasureOfOlGeometry(olGeometry, Object.assign({}, measure, {
+            area: undefined // We don't want to display an area tooltip while drawing.
+        }));
+        this.measure$.next(measure);
+    }
+    /**
+     * Activate a given control
+     * @param modifyControl Modify control
+     */
+    activateModifyControl() {
+        const selection = this.store.getStrategyOfType(FeatureStoreSelectionStrategy);
+        selection.deactivate();
+        selection.clear();
+        this.modifyStart$$ = this.modifyControl.start$.subscribe((olGeometry) => this.onModifyStart(olGeometry));
+        this.modifyEnd$$ = this.modifyControl.end$.subscribe((olGeometry) => this.onModifyEnd(olGeometry));
+        this.modifyChanges$$ = this.modifyControl.changes$.subscribe((olGeometry) => this.onModifyChanges(olGeometry));
+        this.modifyControl.setOlMap(this.map.ol);
+    }
+    /**
+     * Deactivate the active modify control
+     */
+    deactivateModifyControl() {
+        if (this.modifyStart$$ !== undefined) {
+            this.modifyStart$$.unsubscribe();
+        }
+        if (this.modifyEnd$$ !== undefined) {
+            this.modifyEnd$$.unsubscribe();
+        }
+        if (this.modifyChanges$$ !== undefined) {
+            this.modifyChanges$$.unsubscribe();
+        }
+        if (this.activeOlGeometry !== undefined) {
+            if (this.selectedFeatures$.value.length === 1) {
+                const localFeature = this.selectedFeatures$.value[0];
+                this.addFeatureToStore(this.activeOlGeometry, localFeature);
+            }
+            this.finalizeMeasureOfOlGeometry(this.activeOlGeometry);
+        }
+        this.olDrawSource.clear();
+        this.store.activateStrategyOfType(FeatureStoreSelectionStrategy);
+        this.activeOlGeometry = undefined;
+        this.modifyControl.setOlMap(undefined);
+    }
+    /**
+     * Clear the draw source and track the geometry being drawn
+     * @param olGeometry Ol linestring or polygon
+     */
+    onModifyStart(olGeometry) {
+        this.onDrawStart(olGeometry);
+    }
+    /**
+     * Update measures observables and map tooltips
+     * @param olGeometry Ol linestring or polygon
+     */
+    onModifyChanges(olGeometry) {
+        this.onDrawChanges(olGeometry);
+    }
+    /**
+     * Clear the draw source and track the geometry being draw
+     * @param olGeometry Ol linestring or polygon
+     */
+    onModifyEnd(olGeometry) {
+        this.finalizeMeasureOfOlGeometry(olGeometry);
+    }
+    finalizeMeasureOfOlGeometry(olGeometry) {
+        const measure = measureOlGeometry(olGeometry, this.projection);
+        this.updateMeasureOfOlGeometry(olGeometry, measure);
+    }
+    /**
+     * Update measures observables
+     * @param olGeometry Ol linestring or polygon
+     * @param measure Measure
+     */
+    updateMeasureOfOlGeometry(olGeometry, measure) {
+        olGeometry.setProperties({ _measure: measure }, true);
+        this.updateTooltipsOfOlGeometry(olGeometry);
+    }
+    /**
+     * Clear the measures observables
+     */
+    clearMeasures() {
+        this.measure$.next({});
+    }
+    /**
+     * Add a feature with measures to the store. The loading stragegy of the store
+     * will trigger and add the feature to the map.
+     * @internal
+     */
+    addFeatureToStore(olGeometry, localFeature) {
+        const featureId = localFeature
+            ? localFeature.properties.id
+            : olGeometry.ol_uid;
+        const projection = this.map.ol.getView().getProjection();
+        const geometry = new OlGeoJSON().writeGeometryObject(olGeometry, {
+            featureProjection: projection,
+            dataProjection: projection
+        });
+        this.store.update({
+            type: FEATURE,
+            geometry,
+            projection: projection.getCode(),
+            properties: {
+                id: featureId,
+                measure: olGeometry.get('_measure')
+            },
+            meta: {
+                id: featureId
+            }
+        });
+    }
+    /**
+     * Update all the tooltips of an OL geometry
+     * @param olGeometry OL Geometry
+     * @param lengths Lengths of the OL geometry's segments
+     * @param measureUnit Display tooltip measure in those units
+     */
+    updateTooltipsOfOlGeometry(olGeometry) {
+        const measure = olGeometry.get('_measure');
+        const lengths = measure.lengths;
+        const area = measure.area;
+        const olMidpointsTooltips = updateOlTooltipsAtMidpoints(olGeometry);
+        if (lengths.length === olMidpointsTooltips.length) {
+            for (let i = 0; i < olMidpointsTooltips.length; i++) {
+                const length = lengths[i];
+                if (length !== undefined) {
+                    this.updateOlTooltip(olMidpointsTooltips[i], metersToUnit(length, this.activeLengthUnit), this.activeLengthUnit, MeasureType.Length);
+                }
+            }
+        }
+        if (area !== undefined) {
+            this.updateOlTooltip(updateOlTooltipAtCenter(olGeometry), squareMetersToUnit(area, this.activeAreaUnit), this.activeAreaUnit, MeasureType.Area);
+        }
+    }
+    /**
+     * Clear the tooltips of an OL geometrys
+     * @param olGeometry OL geometry with tooltips
+     */
+    clearTooltipsOfOlGeometry(olGeometry) {
+        getTooltipsOfOlGeometry(olGeometry).forEach((olTooltip) => {
+            if (olTooltip !== undefined && olTooltip.getMap() !== undefined) {
+                this.map.ol.removeOverlay(olTooltip);
+            }
+        });
+    }
+    /**
+     * Show the map tooltips of all the geometries of a source
+     */
+    updateTooltipsOfOlSource(olSource) {
+        olSource.forEachFeature((olFeature) => {
+            this.updateTooltipsOfOlGeometry(olFeature.getGeometry());
+        });
+    }
+    /**
+     * Clear the map tooltips
+     * @param olDrawSource OL vector source
+     */
+    clearTooltipsOfOlSource(olSource) {
+        olSource.forEachFeature((olFeature) => {
+            const olGeometry = olFeature.getGeometry();
+            if (olGeometry !== undefined) {
+                this.clearTooltipsOfOlGeometry(olFeature.getGeometry());
+            }
+        });
+    }
+    /**
+     * Update an OL tooltip properties and inner HTML and add it to the map if possible
+     * @param olTooltip OL tooltip
+     * @param measure The measure valeu ti display
+     * @param measureUnit Display tooltip measure in those units
+     */
+    updateOlTooltip(olTooltip, measure, unit, type) {
+        olTooltip.setProperties({ _measure: measure, _unit: unit, _type: type }, true);
+        olTooltip.getElement().innerHTML = this.computeTooltipInnerHTML(olTooltip);
+        if (this.shouldShowTooltip(olTooltip)) {
+            this.map.ol.addOverlay(olTooltip);
+        }
+    }
+    /**
+     * Compute a tooltip's content
+     * @param olTooltip OL overlay
+     * @returns Inner HTML
+     */
+    computeTooltipInnerHTML(olTooltip) {
+        const properties = olTooltip.getProperties();
+        return formatMeasure(properties._measure, {
+            decimal: 1,
+            unit: properties._unit,
+            unitAbbr: true,
+            locale: 'fr'
+        }, this.languageService);
+    }
+    /**
+     * Whether a tooltip should be showned based on the length
+     * of the segment it is bound to.
+     * @param olTooltip OL overlay
+     * @returns True if the tooltip should be shown
+     */
+    shouldShowTooltip(olTooltip) {
+        if (this.showTooltips === false) {
+            return false;
+        }
+        const properties = olTooltip.getProperties();
+        const measure = properties._measure;
+        if (measure === undefined) {
+            return false;
+        }
+        if (properties._unit === MeasureType.Length) {
+            const minSegmentLength = metersToUnit(this.minSegmentLength, properties._unit) || 0;
+            return measure > Math.max(minSegmentLength, 0);
+        }
+        return true;
+    }
+    saveCurrentUnits() {
+        this.storageService.set('distanceUnit', this.activeLengthUnit, StorageScope.SESSION);
+        this.storageService.set('areaUnit', this.activeAreaUnit, StorageScope.SESSION);
+    }
+    getSavedUnits() {
+        const distanceUnit = this.storageService.get('distanceUnit');
+        const areaUnit = this.storageService.get('areaUnit');
+        this.activeLengthUnit = distanceUnit ? distanceUnit : this.activeLengthUnit;
+        this.activeAreaUnit = areaUnit ? areaUnit : this.activeAreaUnit;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MeasurerComponent, deps: [{ token: i1.LanguageService }, { token: i2.MatDialog }, { token: i3.StorageService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: MeasurerComponent, isStandalone: true, selector: "igo-measurer", inputs: { map: "map", store: "store", activeMeasureType: "activeMeasureType", minSegmentLength: "minSegmentLength" }, viewQueries: [{ propertyName: "table", first: true, predicate: ["table"], descendants: true, static: true }], ngImport: i0, template: "<div>\n  <div class=\"measure-type-toggle mat-typography\">\n    <mat-button-toggle-group\n      [value]=\"activeMeasureType\"\n      (change)=\"onMeasureTypeChange($event.value)\"\n    >\n      <mat-button-toggle [value]=\"measureType.Length\">\n        {{ 'igo.geo.measure.' + measureType.Length | translate }}\n      </mat-button-toggle>\n      <mat-button-toggle [value]=\"measureType.Area\">\n        {{ 'igo.geo.measure.' + measureType.Area | translate }}\n      </mat-button-toggle>\n    </mat-button-toggle-group>\n  </div>\n\n  <div class=\"measure-options mat-typography\">\n    <mat-slide-toggle\n      [disabled]=\"drawControlIsDisabled\"\n      [checked]=\"drawControlIsActive\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDrawControl($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleActive' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"hasLine$ | async\"></mat-divider>\n\n    <mat-slide-toggle\n      *ngIf=\"hasLine$ | async\"\n      [checked]=\"displayLines\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayLines($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayLines' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\n\n    <mat-slide-toggle\n      *ngIf=\"hasArea$ | async\"\n      [checked]=\"displayDistance\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayDistance($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayDistance' | translate }}\n    </mat-slide-toggle>\n\n    <mat-slide-toggle\n      *ngIf=\"hasArea$ | async\"\n      [checked]=\"displayAreas\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayAreas($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayAreas' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"hasArea$ | async\"></mat-divider>\n\n    <mat-slide-toggle\n      [checked]=\"measureUnitsAuto\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleMeasureUnitsAuto($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleAutoUnits' | translate }}\n    </mat-slide-toggle>\n  </div>\n\n  <ng-container *ngIf=\"measure$ | async as measure\">\n    <igo-measurer-item\n      *ngIf=\"\n        activeMeasureType === measureType.Length ||\n        activeMeasureType === measureType.Area\n      \"\n      [measureType]=\"measureType.Length\"\n      [measureUnit]=\"activeLengthUnit\"\n      [measure]=\"measure.length\"\n      [auto]=\"measureUnitsAuto\"\n      [placeholder]=\"\n        (activeMeasureType === measureType.Area\n          ? 'igo.geo.measure.perimeter'\n          : 'igo.geo.measure.length'\n        ) | translate\n      \"\n      (measureUnitChange)=\"onLengthUnitChange($any($event))\"\n    >\n    </igo-measurer-item>\n\n    <igo-measurer-item\n      *ngIf=\"activeMeasureType === measureType.Area\"\n      [measureType]=\"measureType.Area\"\n      [measureUnit]=\"activeAreaUnit\"\n      [measure]=\"measure.area\"\n      [auto]=\"measureUnitsAuto\"\n      [placeholder]=\"'igo.geo.measure.area' | translate\"\n      (measureUnitChange)=\"onAreaUnitChange($any($event))\"\n    >\n    </igo-measurer-item>\n  </ng-container>\n\n  <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\n\n  <div class=\"measure-store-buttons\">\n    <button\n      *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.calculate.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      color=\"accent\"\n      (click)=\"onCalculateClick()\"\n    >\n      <mat-icon>calculate</mat-icon>\n    </button>\n\n    <button\n      *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.delete.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      color=\"warn\"\n      (click)=\"onDeleteClick()\"\n    >\n      <mat-icon>delete</mat-icon>\n    </button>\n  </div>\n\n  <igo-entity-table\n    #table\n    class=\"table-compact\"\n    [store]=\"store\"\n    [template]=\"tableTemplate\"\n  >\n  </igo-entity-table>\n</div>\n", styles: [":host .measure-type-toggle{padding:10px;text-align:center}:host .measure-type-toggle mat-button-toggle-group{width:100%}:host .measure-type-toggle mat-button-toggle-group mat-button-toggle{width:50%}:host .measure-options mat-slide-toggle{width:100%;padding:10px}:host .measure-options mat-slide-toggle ::ng-deep .mdc-form-field{width:100%}:host .measure-options mat-slide-toggle ::ng-deep .mdc-label{margin-left:0;width:calc(100% - 60px)}:host .measure-store-buttons{margin-left:-2px}:host .measure-store-buttons button:first-of-type{margin-left:14px}:host .table-compact ::ng-deep .mat-mdc-header-cell.mat-column-selectionCheckbox{width:52px}:host .igo-map-tooltip{position:relative;border-radius:4px;padding:4px 8px;white-space:nowrap}::ng-deep .igo-map-tooltip-hidden,.igo-map-tooltip-measure-by-display{display:none}\n"], dependencies: [{ kind: "ngmodule", type: MatButtonToggleModule }, { kind: "directive", type: i4.MatButtonToggleGroup, selector: "mat-button-toggle-group", inputs: ["appearance", "name", "vertical", "value", "multiple", "disabled", "disabledInteractive", "hideSingleSelectionIndicator", "hideMultipleSelectionIndicator"], outputs: ["valueChange", "change"], exportAs: ["matButtonToggleGroup"] }, { kind: "component", type: i4.MatButtonToggle, selector: "mat-button-toggle", inputs: ["aria-label", "aria-labelledby", "id", "name", "value", "tabIndex", "disableRipple", "appearance", "checked", "disabled", "disabledInteractive"], outputs: ["change"], exportAs: ["matButtonToggle"] }, { kind: "ngmodule", type: MatSlideToggleModule }, { kind: "component", type: i5.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "color", "disabled", "disableRipple", "tabIndex", "checked", "hideIcon", "disabledInteractive"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatDividerModule }, { kind: "component", type: i6.MatDivider, selector: "mat-divider", inputs: ["vertical", "inset"] }, { kind: "component", type: MeasurerItemComponent, selector: "igo-measurer-item", inputs: ["measureType", "measureUnit", "measure", "auto", "placeholder"], outputs: ["measureUnitChange"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i7.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i8.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i9.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: EntityTableComponent, selector: "igo-entity-table", inputs: ["store", "paginator", "template", "scrollBehavior", "sortNullsFirst", "withPaginator", "paginatorOptions"], outputs: ["entityClick", "entitySelectChange", "entitySortChange"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "ngmodule", type: IgoLanguageModule }, { kind: "pipe", type: i10.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MeasurerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'igo-measurer', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        MatButtonToggleModule,
+                        MatSlideToggleModule,
+                        NgIf,
+                        MatDividerModule,
+                        MeasurerItemComponent,
+                        MatButtonModule,
+                        MatTooltipModule,
+                        MatIconModule,
+                        EntityTableComponent,
+                        AsyncPipe,
+                        IgoLanguageModule
+                    ], template: "<div>\n  <div class=\"measure-type-toggle mat-typography\">\n    <mat-button-toggle-group\n      [value]=\"activeMeasureType\"\n      (change)=\"onMeasureTypeChange($event.value)\"\n    >\n      <mat-button-toggle [value]=\"measureType.Length\">\n        {{ 'igo.geo.measure.' + measureType.Length | translate }}\n      </mat-button-toggle>\n      <mat-button-toggle [value]=\"measureType.Area\">\n        {{ 'igo.geo.measure.' + measureType.Area | translate }}\n      </mat-button-toggle>\n    </mat-button-toggle-group>\n  </div>\n\n  <div class=\"measure-options mat-typography\">\n    <mat-slide-toggle\n      [disabled]=\"drawControlIsDisabled\"\n      [checked]=\"drawControlIsActive\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDrawControl($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleActive' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"hasLine$ | async\"></mat-divider>\n\n    <mat-slide-toggle\n      *ngIf=\"hasLine$ | async\"\n      [checked]=\"displayLines\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayLines($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayLines' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\n\n    <mat-slide-toggle\n      *ngIf=\"hasArea$ | async\"\n      [checked]=\"displayDistance\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayDistance($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayDistance' | translate }}\n    </mat-slide-toggle>\n\n    <mat-slide-toggle\n      *ngIf=\"hasArea$ | async\"\n      [checked]=\"displayAreas\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayAreas($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayAreas' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"hasArea$ | async\"></mat-divider>\n\n    <mat-slide-toggle\n      [checked]=\"measureUnitsAuto\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleMeasureUnitsAuto($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleAutoUnits' | translate }}\n    </mat-slide-toggle>\n  </div>\n\n  <ng-container *ngIf=\"measure$ | async as measure\">\n    <igo-measurer-item\n      *ngIf=\"\n        activeMeasureType === measureType.Length ||\n        activeMeasureType === measureType.Area\n      \"\n      [measureType]=\"measureType.Length\"\n      [measureUnit]=\"activeLengthUnit\"\n      [measure]=\"measure.length\"\n      [auto]=\"measureUnitsAuto\"\n      [placeholder]=\"\n        (activeMeasureType === measureType.Area\n          ? 'igo.geo.measure.perimeter'\n          : 'igo.geo.measure.length'\n        ) | translate\n      \"\n      (measureUnitChange)=\"onLengthUnitChange($any($event))\"\n    >\n    </igo-measurer-item>\n\n    <igo-measurer-item\n      *ngIf=\"activeMeasureType === measureType.Area\"\n      [measureType]=\"measureType.Area\"\n      [measureUnit]=\"activeAreaUnit\"\n      [measure]=\"measure.area\"\n      [auto]=\"measureUnitsAuto\"\n      [placeholder]=\"'igo.geo.measure.area' | translate\"\n      (measureUnitChange)=\"onAreaUnitChange($any($event))\"\n    >\n    </igo-measurer-item>\n  </ng-container>\n\n  <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\n\n  <div class=\"measure-store-buttons\">\n    <button\n      *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.calculate.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      color=\"accent\"\n      (click)=\"onCalculateClick()\"\n    >\n      <mat-icon>calculate</mat-icon>\n    </button>\n\n    <button\n      *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.delete.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      color=\"warn\"\n      (click)=\"onDeleteClick()\"\n    >\n      <mat-icon>delete</mat-icon>\n    </button>\n  </div>\n\n  <igo-entity-table\n    #table\n    class=\"table-compact\"\n    [store]=\"store\"\n    [template]=\"tableTemplate\"\n  >\n  </igo-entity-table>\n</div>\n", styles: [":host .measure-type-toggle{padding:10px;text-align:center}:host .measure-type-toggle mat-button-toggle-group{width:100%}:host .measure-type-toggle mat-button-toggle-group mat-button-toggle{width:50%}:host .measure-options mat-slide-toggle{width:100%;padding:10px}:host .measure-options mat-slide-toggle ::ng-deep .mdc-form-field{width:100%}:host .measure-options mat-slide-toggle ::ng-deep .mdc-label{margin-left:0;width:calc(100% - 60px)}:host .measure-store-buttons{margin-left:-2px}:host .measure-store-buttons button:first-of-type{margin-left:14px}:host .table-compact ::ng-deep .mat-mdc-header-cell.mat-column-selectionCheckbox{width:52px}:host .igo-map-tooltip{position:relative;border-radius:4px;padding:4px 8px;white-space:nowrap}::ng-deep .igo-map-tooltip-hidden,.igo-map-tooltip-measure-by-display{display:none}\n"] }]
+        }], ctorParameters: () => [{ type: i1.LanguageService }, { type: i2.MatDialog }, { type: i3.StorageService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }], propDecorators: { map: [{
+                type: Input
+            }], store: [{
+                type: Input
+            }], activeMeasureType: [{
+                type: Input
+            }], minSegmentLength: [{
+                type: Input
+            }], table: [{
+                type: ViewChild,
+                args: ['table', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"measurer.component.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/measure/measurer/measurer.component.ts","../../../../../../packages/geo/src/lib/measure/measurer/measurer.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EACL,uBAAuB,EACvB,SAAS,EACT,MAAM,EACN,KAAK,EAGL,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D,OAAO,EAEL,oBAAoB,EAErB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGnC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAG1C,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAE9C,OAAO,OAAO,MAAM,gBAAgB,CAAC;AAErC,OAAO,EAAE,eAAe,EAAgB,MAAM,MAAM,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EACL,OAAO,EACP,YAAY,EACZ,2BAA2B,EAC3B,6BAA6B,EAC7B,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAMhC,OAAO,EACL,6BAA6B,EAC7B,uBAAuB,EACvB,aAAa,EACb,uBAAuB,EACvB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;;;;;;;;;;;;AAElE;;GAEG;AAqBH,MAAM,OAAO,iBAAiB;IAyNlB;IACA;IACA;IACkB;IA3N5B;;;OAGG;IACI,aAAa,CAAsB;IAElC,eAAe,GAAmB,EAAE,CAAC;IAE7C;;;OAGG;IACI,WAAW,GAAG,WAAW,CAAC;IAEjC;;;OAGG;IACI,eAAe,GAAG,eAAe,CAAC;IAEzC;;;OAGG;IACI,iBAAiB,GAAG,iBAAiB,CAAC;IAE7C;;;OAGG;IACI,gBAAgB,GAAG,KAAK,CAAC;IAEhC;;;OAGG;IACI,eAAe,GAAG,IAAI,CAAC;IAE9B;;;OAGG;IACI,YAAY,GAAG,IAAI,CAAC;IAE3B;;;OAGG;IACI,YAAY,GAAG,IAAI,CAAC;IAE3B;;;OAGG;IACI,QAAQ,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;IAEtD;;;OAGG;IACI,QAAQ,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;IAEtD;;;OAGG;IACI,QAAQ,GAAG,IAAI,eAAe,CAAU,EAAE,CAAC,CAAC;IAEnD;;;OAGG;IACI,iBAAiB,GAAG,IAAI,eAAe,CAAuB,EAAE,CAAC,CAAC;IAEzE;;;OAGG;IACI,YAAY,GAAG,IAAI,CAAC;IAE3B;;;OAGG;IACI,qBAAqB,GAAG,IAAI,CAAC;IAEpC;;OAEG;IACK,eAAe,CAAc;IAErC;;OAEG;IACK,kBAAkB,CAAc;IAExC;;OAEG;IACK,aAAa,CAAgB;IAErC;;OAEG;IACK,gBAAgB,CAA2B;IAEnD;;OAEG;IACI,gBAAgB,GAAsB,iBAAiB,CAAC,MAAM,CAAC;IAEtE;;OAEG;IACI,cAAc,GAAoB,eAAe,CAAC,YAAY,CAAC;IAEtE;;OAEG;IACK,iBAAiB,CAAC;IAE1B;;OAEG;IACK,mBAAmB,CAAC;IAE5B;;;OAGG;IACK,iBAAiB,CAAc;IAEvC;;OAEG;IACK,WAAW,CAAe;IAElC;;OAEG;IACK,SAAS,CAAe;IAEhC;;OAEG;IACK,aAAa,CAAe;IAEpC;;OAEG;IACK,aAAa,CAAe;IAEpC;;OAEG;IACK,WAAW,CAAe;IAElC;;OAEG;IACK,eAAe,CAAe;IAEtC;;OAEG;IACK,kBAAkB,CAAe;IAEzC;;OAEG;IACK,YAAY,GAAG,IAAI,cAAc,EAAE,CAAC;IAE5C;;OAEG;IACM,GAAG,CAAS;IAErB;;OAEG;IACM,KAAK,CAAmC;IAEjD;;;OAGG;IACH,IACI,iBAAiB,CAAC,KAAkB;QACtC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IACD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACO,kBAAkB,CAAc;IAExC;;;OAGG;IACM,gBAAgB,GAAG,EAAE,CAAC;IAEO,KAAK,CAAuB;IAElE;;;OAGG;IACH,IAAI,mBAAmB;QACrB,OAAO,IAAI,CAAC,iBAAiB,KAAK,SAAS,CAAC;IAC9C,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,CAAC;IACzD,CAAC;IAED,YACU,eAAgC,EAChC,MAAiB,EACjB,cAA8B,EACZ,QAAkB;QAHpC,oBAAe,GAAf,eAAe,CAAiB;QAChC,WAAM,GAAN,MAAM,CAAW;QACjB,mBAAc,GAAd,cAAc,CAAgB;QACZ,aAAQ,GAAR,QAAQ,CAAU;QAE5C,IAAI,CAAC,aAAa,GAAG;YACnB,SAAS,EAAE,IAAI;YACf,UAAU,EAAE,IAAI;YAChB,iBAAiB,EAAE,IAAI;YACvB,IAAI,EAAE,IAAI;YACV,OAAO,EAAE;gBACP;oBACE,IAAI,EAAE,QAAQ;oBACd,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,OAAO,CAC3C,8BAA8B,CAC/B;oBACD,aAAa,EAAE,CAAC,YAAgC,EAAE,EAAE;wBAClD,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC;wBACnC,MAAM,OAAO,GAAG,YAAY,CAC1B,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,EACtC,IAAI,CACL,CAAC;wBACF,OAAO,aAAa,CAAC,OAAO,EAAE;4BAC5B,OAAO,EAAE,CAAC;4BACV,IAAI;4BACJ,QAAQ,EAAE,KAAK;4BACf,MAAM,EAAE,IAAI;yBACb,CAAC,CAAC;oBACL,CAAC;iBACF;gBACD;oBACE,IAAI,EAAE,MAAM;oBACZ,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,OAAO,CAC3C,4BAA4B,CAC7B;oBACD,aAAa,EAAE,CAAC,YAAgC,EAAE,EAAE;wBAClD,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC;wBACjC,MAAM,OAAO,GAAG,kBAAkB,CAChC,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,EACpC,IAAI,CACL,CAAC;wBACF,OAAO,OAAO;4BACZ,CAAC,CAAC,aAAa,CAAC,OAAO,EAAE;gCACrB,OAAO,EAAE,CAAC;gCACV,IAAI;gCACJ,QAAQ,EAAE,KAAK;gCACf,MAAM,EAAE,IAAI;6BACb,CAAC;4BACJ,CAAC,CAAC,EAAE,CAAC;oBACT,CAAC;iBACF;aACF;SACF,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,QAAQ;QACN,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAChD,CAAC;IAED;;;OAGG;IACH,WAAW;QACT,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;YAC3B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC1D,CAAC;QAED,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC;QACrC,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;IACnD,CAAC;IAED;;;OAGG;IACH,mBAAmB,CAAC,WAAwB;QAC1C,IAAI,CAAC,iBAAiB,GAAG,WAAW,CAAC;IACvC,CAAC;IAED;;;OAGG;IACH,mBAAmB,CAAC,MAAe;QACjC,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;YACpB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC3B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC/B,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,wBAAwB,CAAC,MAAe;QACtC,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC;IACjC,CAAC;IAED;;;OAGG;IACH,uBAAuB,CAAC,MAAe;QACrC,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC;QAC9B,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IAC1E,CAAC;IAED;;;OAGG;IACH,oBAAoB,CAAC,MAAe;QAClC,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC;QAC3B,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IACvE,CAAC;IAED;;;OAGG;IACH,oBAAoB,CAAC,MAAe;QAClC,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC;QAC3B,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IACvE,CAAC;IAED;;;OAGG;IACH,uBAAuB;QACrB,IAAI,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,gBAAgB,CAAC,KAAK,KAAK,EAAE,CAAC;YACxD,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAC/B,CAAC;QACD,IAAI,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,KAAK,EAAE,CAAC;YACrD,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC5B,CAAC;QACD,IAAI,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,KAAK,EAAE,CAAC;YACrD,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,iBAAiB;QACf,MAAM,QAAQ,GACZ,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAClC,2CAA2C,CAC5C,CAAC;QACJ,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE,CAC1C,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,wBAAwB,CAAC,CACjD,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE,CAC1C,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAC9C,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,cAAc;QACZ,MAAM,QAAQ,GACZ,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAClC,uCAAuC,CACxC,CAAC;QAEJ,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE;gBAC1C,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,wBAAwB,CAAC,CAAC;YACnD,CAAC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE;gBAC1C,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;YAChD,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,cAAc;QACZ,MAAM,QAAQ,GACZ,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,8BAA8B,CAAC,CAAC;QAEvE,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE,CAC1C,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,wBAAwB,CAAC,CACjD,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE,CAC1C,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAC9C,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,kBAAkB,CAAC,IAAuB;QACxC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAED;;;OAGG;IACH,gBAAgB,CAAC,IAAqB;QACpC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAEO,sBAAsB;QAC5B,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QAE7B,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACpD,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACxC,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IAED,gBAAgB;QACd,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC;QAC9C,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAC1B,CAAC,GAAW,EAAE,YAAgC,EAAE,EAAE;YAChD,OAAO,GAAG,GAAG,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,CAAC;QACzD,CAAC,EACD,CAAC,CACF,CAAC;QACF,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAC5B,CAAC,GAAW,EAAE,YAAgC,EAAE,EAAE;YAChD,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC7C,OAAO,GAAG,CAAC;YACb,CAAC;YACD,OAAO,GAAG,GAAG,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;QAC3D,CAAC,EACD,CAAC,CACF,CAAC;QACF,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAC/B,CAAC,GAAW,EAAE,YAAgC,EAAE,EAAE;YAChD,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBAChD,OAAO,GAAG,CAAC;YACb,CAAC;YACD,OAAO,GAAG,GAAG,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;QAC3D,CAAC,EACD,CAAC,CACF,CAAC;QAEF,IAAI,CAAC,UAAU,CAAC;YACd,IAAI;YACJ,MAAM;YACN,SAAS;SACV,CAAC,CAAC;IACL,CAAC;IAED,aAAa;QACX,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QACpD,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,eAAe,EAAE,EAAE;YACvD,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,CAAC,mBAAmB,EAAE,EAAE;gBAC9D,MAAM,QAAQ,GAAG,mBAAmB,CAAC,WAAW,EAAS,CAAC;gBAC1D,IAAI,eAAe,CAAC,UAAU,CAAC,EAAE,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;oBACtD,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;gBACvD,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED,aAAa;QACX,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9C,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;YACvC,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAC/B,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC3B,CAAC;aAAM,CAAC;YACN,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACrD,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,WAAW,EAAE,CAAC;YACjE,MAAM,SAAS,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,UAAqB,EAAE,EAAE;gBAC1D,OAAO,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,YAAY,CAAC,UAAU,CAAC,EAAE,CAAC;YAC7D,CAAC,CAAC,CAAC;YAEH,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;gBAC5B,IAAI,CAAC,qBAAqB,EAAE,CAAC;gBAC7B,IAAI,CAAC,qBAAqB,EAAE,CAAC;gBAE7B,MAAM,UAAU,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;gBAC3C,IAAI,CAAC,yBAAyB,CAAC,UAAsC,CAAC,CAAC;gBACvE,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC;IACH,CAAC;IAEO,UAAU,CAAC,IAAwB;QACzC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,uBAAuB,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACK,SAAS;QACf,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QAEzB,IAAI,KAAK,GAAG,IAAI,WAAW,CAAC;YAC1B,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,OAAO,CAC3C,4BAA4B,CAC7B;YACD,kBAAkB,EAAE,IAAI;YACxB,EAAE,EAAE,gBAAgB,IAAI,EAAE,EAAE;YAC5B,MAAM,EAAE,GAAG;YACX,MAAM,EAAE,IAAI,iBAAiB,EAAE;YAC/B,KAAK,EAAE,uBAAuB,EAAE;YAChC,eAAe,EAAE,IAAI;YACrB,UAAU,EAAE,IAAI;YAChB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,KAAK;YAChB,SAAS,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;SAC9B,CAAC,CAAC;QACH,KAAK,GAAG,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAExC,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;YACnC,MAAM,QAAQ,GACZ,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,yBAAyB,CAAC,CAAC;YAElE,IAAI,OAAO,EAAE,CAAC;gBACZ,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE,CAC1C,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,oCAAoC,CAAC,CAC7D,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,KAAc,EAAE,EAAE,CAC1C,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAC1D,CAAC;YACJ,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAE7B,uBAAuB,CACrB,KAAK,EACL,IAAI,6BAA6B,CAAC;YAChC,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,IAAI,EAAE,IAAI;SACX,CAAC,CACH,CAAC;QAEF,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CACzC,YAAY,EACZ,CAAC,KAA0B,EAAE,EAAE;YAC7B,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC;YACnC,MAAM,UAAU,GAAG,YAAY,CAAC,WAAW,EAAS,CAAC;YACrD,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;YACxE,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC,CACF,CAAC;QAEF,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAC3C,eAAe,EACf,CAAC,KAA0B,EAAE,EAAE;YAC7B,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,EAAS,CAAC;YACtD,IAAI,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAC;QAC7C,CAAC,CACF,CAAC;QAEF,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,SAAS;aACtC,OAAO,CAAC,CAAC,MAAwC,EAAE,EAAE;YACpD,OAAO,MAAM,CAAC,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC;QACxC,CAAC,CAAC;aACD,IAAI,CACH,IAAI,CAAC,CAAC,CAAC,CAAC,wBAAwB;SACjC;aACA,SAAS,CAAC,CAAC,OAA2C,EAAE,EAAE;YACzD,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;gBACvC,IAAI,CAAC,uBAAuB,EAAE,CAAC;YACjC,CAAC;YACD,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QACtE,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,eAAe,CAAC,IAAI,CACvB,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,aAAa,EAAE,EAAE;YAC/C,IACE,aAAa,CAAC,IAAI,CAChB,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS,CACzD,EACD,CAAC;gBACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3B,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC5B,CAAC;YAED,IACE,aAAa,CAAC,IAAI,CAChB,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY,CAC5D,EACD,CAAC;gBACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3B,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC5B,CAAC;QACH,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACK,WAAW;QACjB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC;QACtC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAChC,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAClC,KAAK,CAAC,wBAAwB,CAAC,2BAA2B,CAAC,CAAC;QAC5D,KAAK,CAAC,wBAAwB,CAAC,6BAA6B,CAAC,CAAC;IAChE,CAAC;IAED;;OAEG;IACK,qBAAqB;QAC3B,IAAI,CAAC,eAAe,GAAG,IAAI,WAAW,CAAC;YACrC,YAAY,EAAE,YAAY;YAC1B,kBAAkB,EAAE,IAAI,CAAC,YAAY;YACrC,gBAAgB,EAAE,6BAA6B,EAAE;YACjD,iBAAiB,EAAE,IAAI,OAAO,CAAC,EAAE,CAAC;SACnC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,wBAAwB;QAC9B,IAAI,CAAC,kBAAkB,GAAG,IAAI,WAAW,CAAC;YACxC,YAAY,EAAE,SAAS;YACvB,kBAAkB,EAAE,IAAI,CAAC,YAAY;YACrC,gBAAgB,EAAE,6BAA6B,EAAE;YACjD,iBAAiB,EAAE,IAAI,OAAO,CAAC,EAAE,CAAC;SACnC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,mBAAmB;QACzB,IAAI,CAAC,aAAa,GAAG,IAAI,aAAa,CAAC;YACrC,MAAM,EAAE,IAAI,CAAC,YAAY;YACzB,SAAS,EAAE,6BAA6B,EAAE;YAC1C,UAAU,EAAE,IAAI,OAAO,CAAC,EAAE,CAAC;SAC5B,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,iBAAiB;QACvB,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7B,kCAAkC;QAClC,IAAI,IAAI,CAAC,iBAAiB,KAAK,WAAW,CAAC,MAAM,EAAE,CAAC;YAClD,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACjD,CAAC;aAAM,IAAI,IAAI,CAAC,iBAAiB,KAAK,WAAW,CAAC,IAAI,EAAE,CAAC;YACvD,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,mBAAmB,CAAC,WAAwB;QAClD,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACnC,IAAI,CAAC,iBAAiB,GAAG,WAAW,CAAC;QACrC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,SAAS,CAC7C,CAAC,UAAoC,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CACvE,CAAC;QACF,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,IAAI,CAAC,SAAS,CACzC,CAAC,UAAoC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CACrE,CAAC;QACF,IAAI,CAAC,aAAa,GAAG,WAAW,CAAC,QAAQ,CAAC,SAAS,CACjD,CAAC,UAAoC,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CACzE,CAAC;QACF,IAAI,CAAC,aAAa,GAAG,WAAW,CAAC,MAAM,CAAC,SAAS,CAC/C,CAAC,UAAoC,EAAE,EAAE;YACvC,IAAI,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAC;YAC3C,IAAI,CAAC,aAAa,EAAE,CAAC;QACvB,CAAC,CACF,CAAC;QACF,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACK,qBAAqB;QAC3B,IAAI,IAAI,CAAC,iBAAiB,KAAK,SAAS,EAAE,CAAC;YACzC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAC1B,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACnC,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;QACjC,CAAC;QACD,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;QAC/B,CAAC;QACD,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;YACrC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;QACnC,CAAC;QAED,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAChD,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACxC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,iBAAiB,GAAG,SAAS,CAAC;QACnC,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC;IACpC,CAAC;IAEO,oBAAoB,CAAC,WAAwB;QACnD,IAAI,CAAC,kBAAkB,GAAG,WAAW,CAAC;QACtC,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACK,WAAW,CAAC,UAAoC;QACtD,IAAI,CAAC,gBAAgB,GAAG,UAAU,CAAC;IACrC,CAAC;IAED;;;OAGG;IACK,SAAS,CAAC,UAAoC;QACpD,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC;QAClC,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;QAC7C,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QACnC,IAAI,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAC;QAC3C,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED;;;OAGG;IACK,aAAa,CAAC,UAAoC;QACxD,MAAM,OAAO,GAAG,iBAAiB,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAC/D,IAAI,CAAC,yBAAyB,CAC5B,UAAU,EACV,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE;YACzB,IAAI,EAAE,SAAS,CAAC,0DAA0D;SAC3E,CAAC,CACH,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACK,qBAAqB;QAC3B,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAC5C,6BAA6B,CACG,CAAC;QACnC,SAAS,CAAC,UAAU,EAAE,CAAC;QACvB,SAAS,CAAC,KAAK,EAAE,CAAC;QAElB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,SAAS,CACtD,CAAC,UAAoC,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CACzE,CAAC;QACF,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAClD,CAAC,UAAoC,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CACvE,CAAC;QACF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAS,CAC1D,CAAC,UAAoC,EAAE,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAC3E,CAAC;QACF,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACK,uBAAuB;QAC7B,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;YACrC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;QACnC,CAAC;QACD,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACnC,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;QACjC,CAAC;QACD,IAAI,IAAI,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;YACvC,IAAI,CAAC,eAAe,CAAC,WAAW,EAAE,CAAC;QACrC,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACxC,IAAI,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC9C,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACrD,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC;YAC9D,CAAC;YACD,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC1D,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAE1B,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,6BAA6B,CAAC,CAAC;QAEjE,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC;QAClC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IACzC,CAAC;IAED;;;OAGG;IACK,aAAa,CAAC,UAAoC;QACxD,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACK,eAAe,CAAC,UAAoC;QAC1D,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACjC,CAAC;IAED;;;OAGG;IACK,WAAW,CAAC,UAAoC;QACtD,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;IAC/C,CAAC;IAEO,2BAA2B,CAAC,UAAoC;QACtE,MAAM,OAAO,GAAG,iBAAiB,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAC/D,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACtD,CAAC;IAED;;;;OAIG;IACK,yBAAyB,CAC/B,UAAoC,EACpC,OAAgB;QAEhB,UAAU,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,CAAC;QACtD,IAAI,CAAC,0BAA0B,CAAC,UAAU,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACK,aAAa;QACnB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACK,iBAAiB,CAAC,UAAU,EAAE,YAAiC;QACrE,MAAM,SAAS,GAAG,YAAY;YAC5B,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE;YAC5B,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC;QACtB,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,aAAa,EAAE,CAAC;QACzD,MAAM,QAAQ,GAAG,IAAI,SAAS,EAAE,CAAC,mBAAmB,CAAC,UAAU,EAAE;YAC/D,iBAAiB,EAAE,UAAU;YAC7B,cAAc,EAAE,UAAU;SAC3B,CAAQ,CAAC;QACV,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;YAChB,IAAI,EAAE,OAAO;YACb,QAAQ;YACR,UAAU,EAAE,UAAU,CAAC,OAAO,EAAE;YAChC,UAAU,EAAE;gBACV,EAAE,EAAE,SAAS;gBACb,OAAO,EAAE,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC;aACpC;YACD,IAAI,EAAE;gBACJ,EAAE,EAAE,SAAS;aACd;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,0BAA0B,CAAC,UAAoC;QACrE,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC3C,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAChC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QAE1B,MAAM,mBAAmB,GAAG,2BAA2B,CAAC,UAAU,CAAC,CAAC;QACpE,IAAI,OAAO,CAAC,MAAM,KAAK,mBAAmB,CAAC,MAAM,EAAE,CAAC;YAClD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACpD,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC1B,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;oBACzB,IAAI,CAAC,eAAe,CAClB,mBAAmB,CAAC,CAAC,CAAC,EACtB,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,EAC3C,IAAI,CAAC,gBAAgB,EACrB,WAAW,CAAC,MAAM,CACnB,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,IAAI,CAAC,eAAe,CAClB,uBAAuB,CAAC,UAAU,CAAC,EACnC,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC,EAC7C,IAAI,CAAC,cAAc,EACnB,WAAW,CAAC,IAAI,CACjB,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,yBAAyB,CAAC,UAAoC;QACpE,uBAAuB,CAAC,UAAU,CAAC,CAAC,OAAO,CACzC,CAAC,SAAgC,EAAE,EAAE;YACnC,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,CAAC,MAAM,EAAE,KAAK,SAAS,EAAE,CAAC;gBAChE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;YACvC,CAAC;QACH,CAAC,CACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,wBAAwB,CAAC,QAAwB;QACvD,QAAQ,CAAC,cAAc,CAAC,CAAC,SAAoB,EAAE,EAAE;YAC/C,IAAI,CAAC,0BAA0B,CAAC,SAAS,CAAC,WAAW,EAAS,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,uBAAuB,CAAC,QAAwB;QACtD,QAAQ,CAAC,cAAc,CAAC,CAAC,SAAoB,EAAE,EAAE;YAC/C,MAAM,UAAU,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;YAC3C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;gBAC7B,IAAI,CAAC,yBAAyB,CAAC,SAAS,CAAC,WAAW,EAAS,CAAC,CAAC;YACjE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,eAAe,CACrB,SAAoB,EACpB,OAAe,EACf,IAAyC,EACzC,IAAiB;QAEjB,SAAS,CAAC,aAAa,CACrB,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,EAC/C,IAAI,CACL,CAAC;QACF,SAAS,CAAC,UAAU,EAAE,CAAC,SAAS,GAAG,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC;QAC3E,IAAI,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAAE,CAAC;YACtC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,uBAAuB,CAAC,SAAoB;QAClD,MAAM,UAAU,GAAG,SAAS,CAAC,aAAa,EAAS,CAAC;QACpD,OAAO,aAAa,CAClB,UAAU,CAAC,QAAQ,EACnB;YACE,OAAO,EAAE,CAAC;YACV,IAAI,EAAE,UAAU,CAAC,KAAK;YACtB,QAAQ,EAAE,IAAI;YACd,MAAM,EAAE,IAAI;SACb,EACD,IAAI,CAAC,eAAe,CACrB,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACK,iBAAiB,CAAC,SAAoB;QAC5C,IAAI,IAAI,CAAC,YAAY,KAAK,KAAK,EAAE,CAAC;YAChC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,UAAU,GAAG,SAAS,CAAC,aAAa,EAAS,CAAC;QACpD,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC;QACpC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,UAAU,CAAC,KAAK,KAAK,WAAW,CAAC,MAAM,EAAE,CAAC;YAC5C,MAAM,gBAAgB,GACpB,YAAY,CAAC,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC7D,OAAO,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,gBAAgB;QACtB,IAAI,CAAC,cAAc,CAAC,GAAG,CACrB,cAAc,EACd,IAAI,CAAC,gBAAgB,EACrB,YAAY,CAAC,OAAO,CACrB,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,GAAG,CACrB,UAAU,EACV,IAAI,CAAC,cAAc,EACnB,YAAY,CAAC,OAAO,CACrB,CAAC;IACJ,CAAC;IAEO,aAAa;QACnB,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAC1C,cAAc,CACM,CAAC;QACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,UAAU,CAAoB,CAAC;QAExE,IAAI,CAAC,gBAAgB,GAAG,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC;QAC5E,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC;IAClE,CAAC;wGAxkCU,iBAAiB,wGA4NlB,QAAQ;4FA5NP,iBAAiB,4SCrG9B,iqIAqIA,g3BD7CI,qBAAqB,soBACrB,oBAAoB,0XACpB,IAAI,4FACJ,gBAAgB,mIAChB,qBAAqB,uKACrB,eAAe,2IACf,gBAAgB,4TAChB,aAAa,oLACb,oBAAoB,iPACpB,SAAS,6CACT,iBAAiB;;4FAGR,iBAAiB;kBApB7B,SAAS;+BACE,cAAc,mBAGP,uBAAuB,CAAC,MAAM,cACnC,IAAI,WACP;wBACP,qBAAqB;wBACrB,oBAAoB;wBACpB,IAAI;wBACJ,gBAAgB;wBAChB,qBAAqB;wBACrB,eAAe;wBACf,gBAAgB;wBAChB,aAAa;wBACb,oBAAoB;wBACpB,SAAS;wBACT,iBAAiB;qBAClB;;0BA8NE,MAAM;2BAAC,QAAQ;yCA5CT,GAAG;sBAAX,KAAK;gBAKG,KAAK;sBAAb,KAAK;gBAOF,iBAAiB;sBADpB,KAAK;gBAaG,gBAAgB;sBAAxB,KAAK;gBAEgC,KAAK;sBAA1C,SAAS;uBAAC,OAAO,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["import { AsyncPipe, DOCUMENT, NgIf } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  Inject,\n  Input,\n  OnDestroy,\n  OnInit,\n  ViewChild\n} from '@angular/core';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatButtonToggleModule } from '@angular/material/button-toggle';\nimport { MatDialog } from '@angular/material/dialog';\nimport { MatDividerModule } from '@angular/material/divider';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\nimport { MatTooltipModule } from '@angular/material/tooltip';\n\nimport {\n  EntityRecord,\n  EntityTableComponent,\n  EntityTableTemplate\n} from '@igo2/common/entity';\nimport { LanguageService } from '@igo2/core/language';\nimport { IgoLanguageModule } from '@igo2/core/language';\nimport { StorageScope, StorageService } from '@igo2/core/storage';\nimport { uuid } from '@igo2/utils';\n\nimport OlFeature from 'ol/Feature';\nimport { unByKey } from 'ol/Observable';\nimport OlOverlay from 'ol/Overlay';\nimport OlGeoJSON from 'ol/format/GeoJSON';\nimport OlLineString from 'ol/geom/LineString';\nimport OlPolygon from 'ol/geom/Polygon';\nimport OlVectorSource from 'ol/source/Vector';\nimport { VectorSourceEvent as OlVectorSourceEvent } from 'ol/source/Vector';\nimport OlStyle from 'ol/style/Style';\n\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { skip } from 'rxjs/operators';\n\nimport { FeatureDataSource } from '../../datasource/shared/datasources';\nimport {\n  FEATURE,\n  FeatureStore,\n  FeatureStoreLoadingStrategy,\n  FeatureStoreSelectionStrategy,\n  tryAddLoadingStrategy,\n  tryAddSelectionStrategy,\n  tryBindStoreLayer\n} from '../../feature';\nimport { DrawControl, ModifyControl } from '../../geometry/shared';\nimport { VectorLayer } from '../../layer/shared';\nimport { IgoMap } from '../../map/shared/map';\nimport {\n  MeasureAreaUnit,\n  MeasureLengthUnit,\n  MeasureType\n} from '../shared/measure.enum';\nimport {\n  FeatureWithMeasure,\n  Measure,\n  MeasurerDialogData\n} from '../shared/measure.interfaces';\nimport {\n  createMeasureInteractionStyle,\n  createMeasureLayerStyle,\n  formatMeasure,\n  getTooltipsOfOlGeometry,\n  measureOlGeometry,\n  metersToUnit,\n  squareMetersToUnit,\n  updateOlTooltipAtCenter,\n  updateOlTooltipsAtMidpoints\n} from '../shared/measure.utils';\nimport { MeasurerDialogComponent } from './measurer-dialog.component';\nimport { MeasurerItemComponent } from './measurer-item.component';\n\n/**\n * Tool to measure lengths and areas\n */\n@Component({\n  selector: 'igo-measurer',\n  templateUrl: './measurer.component.html',\n  styleUrls: ['./measurer.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    MatButtonToggleModule,\n    MatSlideToggleModule,\n    NgIf,\n    MatDividerModule,\n    MeasurerItemComponent,\n    MatButtonModule,\n    MatTooltipModule,\n    MatIconModule,\n    EntityTableComponent,\n    AsyncPipe,\n    IgoLanguageModule\n  ]\n})\nexport class MeasurerComponent implements OnInit, OnDestroy {\n  /**\n   * Table template\n   * @internal\n   */\n  public tableTemplate: EntityTableTemplate;\n\n  private subscriptions$$: Subscription[] = [];\n\n  /**\n   * Reference to the MeasureType enum\n   * @internal\n   */\n  public measureType = MeasureType;\n\n  /**\n   * Reference to the AreaMeasureUnit enum\n   * @internal\n   */\n  public measureAreaUnit = MeasureAreaUnit;\n\n  /**\n   * Reference to the LengthMeasureUnit enum\n   * @internal\n   */\n  public measureLengthUnit = MeasureLengthUnit;\n\n  /**\n   * Whether measure units should be automatically determined\n   * @internal\n   */\n  public measureUnitsAuto = false;\n\n  /**\n   * Whether display of distances of areas\n   * @internal\n   */\n  public displayDistance = true;\n\n  /**\n   * Whether display of distances of lines\n   * @internal\n   */\n  public displayLines = true;\n\n  /**\n   * Whether display of areas\n   * @internal\n   */\n  public displayAreas = true;\n\n  /**\n   * Observable of line boolean\n   * @internal\n   */\n  public hasLine$ = new BehaviorSubject<boolean>(false);\n\n  /**\n   * Observable of area boolean\n   * @internal\n   */\n  public hasArea$ = new BehaviorSubject<boolean>(false);\n\n  /**\n   * Observable of area\n   * @internal\n   */\n  public measure$ = new BehaviorSubject<Measure>({});\n\n  /**\n   * Observable of selected features\n   * @internal\n   */\n  public selectedFeatures$ = new BehaviorSubject<FeatureWithMeasure[]>([]);\n\n  /**\n   * OL draw source\n   * @internal\n   */\n  public showTooltips = true;\n\n  /**\n   * Whether draw control toggle is disabled or not\n   * @internal\n   */\n  public drawControlIsDisabled = true;\n\n  /**\n   * Draw line control\n   */\n  private drawLineControl: DrawControl;\n\n  /**\n   * Draw polygon control\n   */\n  private drawPolygonControl: DrawControl;\n\n  /**\n   * Modify control\n   */\n  private modifyControl: ModifyControl;\n\n  /**\n   * Active OL geometry\n   */\n  private activeOlGeometry: OlLineString | OlPolygon;\n\n  /**\n   * Active mlength unit\n   */\n  public activeLengthUnit: MeasureLengthUnit = MeasureLengthUnit.Meters;\n\n  /**\n   * Active area unit\n   */\n  public activeAreaUnit: MeasureAreaUnit = MeasureAreaUnit.SquareMeters;\n\n  /**\n   * Feature added listener key\n   */\n  private onFeatureAddedKey;\n\n  /**\n   * Feature removed listener key\n   */\n  private onFeatureRemovedKey;\n\n  /**\n   * Active draw control\n   * @internal\n   */\n  private activeDrawControl: DrawControl;\n\n  /**\n   * Subscription to draw start\n   */\n  private drawStart$$: Subscription;\n\n  /**\n   * Subscription to draw end\n   */\n  private drawEnd$$: Subscription;\n\n  /**\n   * Subscription to controls changes\n   */\n  private drawChanges$$: Subscription;\n\n  /**\n   * Subscription to modify start\n   */\n  private modifyStart$$: Subscription;\n\n  /**\n   * Subscription to modify end\n   */\n  private modifyEnd$$: Subscription;\n\n  /**\n   * Subscription to controls changes\n   */\n  private modifyChanges$$: Subscription;\n\n  /**\n   * Subscription to measures selection\n   */\n  private selectedFeatures$$: Subscription;\n\n  /**\n   * OL draw source\n   */\n  private olDrawSource = new OlVectorSource();\n\n  /**\n   * The map to measure on\n   */\n  @Input() map: IgoMap;\n\n  /**\n   * The measures store\n   */\n  @Input() store: FeatureStore<FeatureWithMeasure>;\n\n  /**\n   * Measure type\n   * @internal\n   */\n  @Input()\n  set activeMeasureType(value: MeasureType) {\n    this.setActiveMeasureType(value);\n  }\n  get activeMeasureType(): MeasureType {\n    return this._activeMeasureType;\n  }\n  private _activeMeasureType: MeasureType;\n\n  /**\n   * The minimum length a segment must have to display a tooltip.\n   * It also applies to area tooltips.\n   */\n  @Input() minSegmentLength = 10;\n\n  @ViewChild('table', { static: true }) table: EntityTableComponent;\n\n  /**\n   * Wheter one of the draw control is active\n   * @internal\n   */\n  get drawControlIsActive(): boolean {\n    return this.activeDrawControl !== undefined;\n  }\n\n  get projection(): string {\n    return this.map.ol.getView().getProjection().getCode();\n  }\n\n  constructor(\n    private languageService: LanguageService,\n    private dialog: MatDialog,\n    private storageService: StorageService,\n    @Inject(DOCUMENT) private document: Document\n  ) {\n    this.tableTemplate = {\n      selection: true,\n      selectMany: true,\n      selectionCheckbox: true,\n      sort: true,\n      columns: [\n        {\n          name: 'length',\n          title: this.languageService.translate.instant(\n            'igo.geo.measure.lengthHeader'\n          ),\n          valueAccessor: (localFeature: FeatureWithMeasure) => {\n            const unit = this.activeLengthUnit;\n            const measure = metersToUnit(\n              localFeature.properties.measure.length,\n              unit\n            );\n            return formatMeasure(measure, {\n              decimal: 1,\n              unit,\n              unitAbbr: false,\n              locale: 'fr'\n            });\n          }\n        },\n        {\n          name: 'area',\n          title: this.languageService.translate.instant(\n            'igo.geo.measure.areaHeader'\n          ),\n          valueAccessor: (localFeature: FeatureWithMeasure) => {\n            const unit = this.activeAreaUnit;\n            const measure = squareMetersToUnit(\n              localFeature.properties.measure.area,\n              unit\n            );\n            return measure\n              ? formatMeasure(measure, {\n                  decimal: 1,\n                  unit,\n                  unitAbbr: false,\n                  locale: 'fr'\n                })\n              : '';\n          }\n        }\n      ]\n    };\n  }\n\n  /**\n   * Add draw controls and activate one\n   * @internal\n   */\n  ngOnInit() {\n    this.getSavedUnits();\n    this.initStore();\n    this.createDrawLineControl();\n    this.createDrawPolygonControl();\n    this.createModifyControl();\n    this.toggleDrawControl();\n    this.updateTooltipsOfOlSource(this.store.source.ol);\n    this.checkDistanceAreaToggle();\n    this.setActiveMeasureType(MeasureType.Length);\n  }\n\n  /**\n   * Clear the overlay layer and any interaction added by this component.\n   * @internal\n   */\n  ngOnDestroy() {\n    if (this.store.count === 0) {\n      this.store.map.layerController.remove(this.store.layer);\n    }\n\n    this.setActiveMeasureType(undefined);\n    this.deactivateModifyControl();\n    this.freezeStore();\n    this.subscriptions$$.map((s) => s.unsubscribe());\n  }\n\n  /**\n   * Set the measure type\n   * @internal\n   */\n  onMeasureTypeChange(measureType: MeasureType) {\n    this.activeMeasureType = measureType;\n  }\n\n  /**\n   * Activate or deactivate the current draw control\n   * @internal\n   */\n  onToggleDrawControl(toggle: boolean) {\n    if (toggle === true) {\n      this.toggleDrawControl();\n    } else {\n      this.deactivateDrawControl();\n    }\n  }\n\n  /**\n   * Activate or deactivate the current draw control\n   * @internal\n   */\n  onToggleMeasureUnitsAuto(toggle: boolean) {\n    this.measureUnitsAuto = toggle;\n  }\n\n  /**\n   * Activate or deactivate the current display of distances of the areas\n   * @internal\n   */\n  onToggleDisplayDistance(toggle: boolean) {\n    this.displayDistance = toggle;\n    this.onDisplayDistance();\n    this.storageService.set('distanceToggle', toggle, StorageScope.SESSION);\n  }\n\n  /**\n   * Activate or deactivate the current display of distances of the lines\n   * @internal\n   */\n  onToggleDisplayLines(toggle: boolean) {\n    this.displayLines = toggle;\n    this.onDisplayLines();\n    this.storageService.set('linesToggle', toggle, StorageScope.SESSION);\n  }\n\n  /**\n   * Activate or deactivate the current display of areas\n   * @internal\n   */\n  onToggleDisplayAreas(toggle: boolean) {\n    this.displayAreas = toggle;\n    this.onDisplayAreas();\n    this.storageService.set('areasToggle', toggle, StorageScope.SESSION);\n  }\n\n  /**\n   * Set display parametres in current values\n   * @internal\n   */\n  checkDistanceAreaToggle() {\n    if (this.storageService.get('distanceToggle') === false) {\n      this.displayDistance = false;\n    }\n    if (this.storageService.get('linesToggle') === false) {\n      this.displayLines = false;\n    }\n    if (this.storageService.get('areasToggle') === false) {\n      this.displayAreas = false;\n    }\n  }\n\n  /**\n   * Activate or deactivate the current display of distances of areas\n   * @internal\n   */\n  onDisplayDistance() {\n    const elements: HTMLCollectionOf<Element> =\n      this.document.getElementsByClassName(\n        'igo-map-tooltip-measure-polygone-segments'\n      );\n    if (this.displayDistance) {\n      Array.from(elements).map((value: Element) =>\n        value.classList.remove('igo-map-tooltip-hidden')\n      );\n    } else {\n      Array.from(elements).map((value: Element) =>\n        value.classList.add('igo-map-tooltip-hidden')\n      );\n    }\n  }\n\n  /**\n   * Activate or deactivate the current display of distances of lines\n   * @internal\n   */\n  onDisplayLines() {\n    const elements: HTMLCollectionOf<Element> =\n      this.document.getElementsByClassName(\n        'igo-map-tooltip-measure-line-segments'\n      );\n\n    if (this.displayLines) {\n      Array.from(elements).map((value: Element) => {\n        value.classList.remove('igo-map-tooltip-hidden');\n      });\n    } else {\n      Array.from(elements).map((value: Element) => {\n        value.classList.add('igo-map-tooltip-hidden');\n      });\n    }\n  }\n\n  /**\n   * Activate or deactivate the current display of areas\n   * @internal\n   */\n  onDisplayAreas() {\n    const elements: HTMLCollectionOf<Element> =\n      this.document.getElementsByClassName('igo-map-tooltip-measure-area');\n\n    if (this.displayAreas) {\n      Array.from(elements).map((value: Element) =>\n        value.classList.remove('igo-map-tooltip-hidden')\n      );\n    } else {\n      Array.from(elements).map((value: Element) =>\n        value.classList.add('igo-map-tooltip-hidden')\n      );\n    }\n  }\n\n  /**\n   * Set the measure type\n   * @internal\n   */\n  onLengthUnitChange(unit: MeasureLengthUnit) {\n    this.activeLengthUnit = unit;\n    this.saveCurrentUnits();\n    this.refreshTableAndTooltip();\n  }\n\n  /**\n   * Set the measure type\n   * @internal\n   */\n  onAreaUnitChange(unit: MeasureAreaUnit) {\n    this.activeAreaUnit = unit;\n    this.saveCurrentUnits();\n    this.refreshTableAndTooltip();\n  }\n\n  private refreshTableAndTooltip(): void {\n    this.store.stateView.clear();\n\n    this.updateTooltipsOfOlSource(this.store.source.ol);\n    if (this.activeOlGeometry !== undefined) {\n      this.updateTooltipsOfOlGeometry(this.activeOlGeometry);\n    }\n  }\n\n  onCalculateClick() {\n    const features = this.selectedFeatures$.value;\n    const area = features.reduce(\n      (sum: number, localFeature: FeatureWithMeasure) => {\n        return sum + localFeature.properties.measure.area || 0;\n      },\n      0\n    );\n    const length = features.reduce(\n      (sum: number, localFeature: FeatureWithMeasure) => {\n        if (localFeature.geometry.type === 'Polygon') {\n          return sum;\n        }\n        return sum + localFeature.properties.measure.length || 0;\n      },\n      0\n    );\n    const perimeter = features.reduce(\n      (sum: number, localFeature: FeatureWithMeasure) => {\n        if (localFeature.geometry.type === 'LineString') {\n          return sum;\n        }\n        return sum + localFeature.properties.measure.length || 0;\n      },\n      0\n    );\n\n    this.openDialog({\n      area,\n      length,\n      perimeter\n    });\n  }\n\n  onDeleteClick() {\n    this.store.deleteMany(this.selectedFeatures$.value);\n    this.selectedFeatures$.value.forEach((selectedFeature) => {\n      this.olDrawSource.getFeatures().forEach((drawingLayerFeature) => {\n        const geometry = drawingLayerFeature.getGeometry() as any;\n        if (selectedFeature.properties.id === geometry.ol_uid) {\n          this.olDrawSource.removeFeature(drawingLayerFeature);\n        }\n      });\n    });\n  }\n\n  onModifyClick() {\n    if (this.selectedFeatures$.value.length !== 1) {\n      return;\n    }\n\n    if (this.modifyControl.active === true) {\n      this.deactivateModifyControl();\n      this.toggleDrawControl();\n    } else {\n      const localFeature = this.selectedFeatures$.value[0];\n      const olFeatures = this.store.layer.ol.getSource().getFeatures();\n      const olFeature = olFeatures.find((_olFeature: OlFeature) => {\n        return _olFeature.get('id') === localFeature.properties.id;\n      });\n\n      if (olFeature !== undefined) {\n        this.deactivateDrawControl();\n        this.activateModifyControl();\n\n        const olGeometry = olFeature.getGeometry();\n        this.clearTooltipsOfOlGeometry(olGeometry as OlLineString | OlPolygon);\n        this.modifyControl.setOlGeometry(olGeometry);\n      }\n    }\n  }\n\n  private openDialog(data: MeasurerDialogData): void {\n    this.dialog.open(MeasurerDialogComponent, { data });\n  }\n\n  /**\n   * Initialize the measure store and set up some listeners\n   * @internal\n   */\n  private initStore() {\n    const store = this.store;\n\n    let layer = new VectorLayer({\n      title: this.languageService.translate.instant(\n        'igo.geo.measure.layerTitle'\n      ),\n      isIgoInternalLayer: true,\n      id: `igo-measures-${uuid()}`,\n      zIndex: 200,\n      source: new FeatureDataSource(),\n      style: createMeasureLayerStyle(),\n      showInLayerList: true,\n      exportable: true,\n      visible: true,\n      browsable: false,\n      workspace: { enabled: false }\n    });\n    layer = tryBindStoreLayer(store, layer);\n\n    layer.visible$.subscribe((visible) => {\n      const elements: HTMLCollectionOf<Element> =\n        this.document.getElementsByClassName('igo-map-tooltip-measure');\n\n      if (visible) {\n        Array.from(elements).map((value: Element) =>\n          value.classList.remove('igo-map-tooltip-measure-by-display')\n        );\n      } else {\n        Array.from(elements).map((value: Element) =>\n          value.classList.add('igo-map-tooltip-measure-by-display')\n        );\n      }\n    });\n\n    tryAddLoadingStrategy(store);\n\n    tryAddSelectionStrategy(\n      store,\n      new FeatureStoreSelectionStrategy({\n        map: this.map,\n        many: true\n      })\n    );\n\n    this.onFeatureAddedKey = store.source.ol.on(\n      'addfeature',\n      (event: OlVectorSourceEvent) => {\n        const localFeature = event.feature;\n        const olGeometry = localFeature.getGeometry() as any;\n        this.updateMeasureOfOlGeometry(olGeometry, localFeature.get('measure'));\n        this.onDisplayDistance();\n        this.onDisplayLines();\n        this.onDisplayAreas();\n      }\n    );\n\n    this.onFeatureRemovedKey = store.source.ol.on(\n      'removefeature',\n      (event: OlVectorSourceEvent) => {\n        const olGeometry = event.feature.getGeometry() as any;\n        this.clearTooltipsOfOlGeometry(olGeometry);\n      }\n    );\n\n    this.selectedFeatures$$ = store.stateView\n      .manyBy$((record: EntityRecord<FeatureWithMeasure>) => {\n        return record.state.selected === true;\n      })\n      .pipe(\n        skip(1) // Skip initial emission\n      )\n      .subscribe((records: EntityRecord<FeatureWithMeasure>[]) => {\n        if (this.modifyControl.active === true) {\n          this.deactivateModifyControl();\n        }\n        this.selectedFeatures$.next(records.map((record) => record.entity));\n      });\n\n    this.subscriptions$$.push(\n      this.store.entities$.subscribe((objectsExists) => {\n        if (\n          objectsExists.find(\n            (objectExist) => objectExist.geometry.type === 'Polygon'\n          )\n        ) {\n          this.hasArea$.next(true);\n        } else {\n          this.hasArea$.next(false);\n        }\n\n        if (\n          objectsExists.find(\n            (objectExist) => objectExist.geometry.type === 'LineString'\n          )\n        ) {\n          this.hasLine$.next(true);\n        } else {\n          this.hasLine$.next(false);\n        }\n      })\n    );\n  }\n\n  /**\n   * Freeze any store, meaning the layer is removed, strategies are deactivated\n   * and some listener removed\n   * @internal\n   */\n  private freezeStore() {\n    const store = this.store;\n    this.selectedFeatures$$.unsubscribe();\n    unByKey(this.onFeatureAddedKey);\n    unByKey(this.onFeatureRemovedKey);\n    store.deactivateStrategyOfType(FeatureStoreLoadingStrategy);\n    store.deactivateStrategyOfType(FeatureStoreSelectionStrategy);\n  }\n\n  /**\n   * Create a draw line control\n   */\n  private createDrawLineControl() {\n    this.drawLineControl = new DrawControl({\n      geometryType: 'LineString',\n      drawingLayerSource: this.olDrawSource,\n      interactionStyle: createMeasureInteractionStyle(),\n      drawingLayerStyle: new OlStyle({})\n    });\n  }\n\n  /**\n   * Create a draw polygon control\n   */\n  private createDrawPolygonControl() {\n    this.drawPolygonControl = new DrawControl({\n      geometryType: 'Polygon',\n      drawingLayerSource: this.olDrawSource,\n      interactionStyle: createMeasureInteractionStyle(),\n      drawingLayerStyle: new OlStyle({})\n    });\n  }\n\n  /**\n   * Create a draw polygon control\n   */\n  private createModifyControl() {\n    this.modifyControl = new ModifyControl({\n      source: this.olDrawSource,\n      drawStyle: createMeasureInteractionStyle(),\n      layerStyle: new OlStyle({})\n    });\n  }\n\n  /**\n   * Activate the right control\n   */\n  private toggleDrawControl() {\n    this.deactivateDrawControl();\n    // this.deactivateModifyControl();\n    if (this.activeMeasureType === MeasureType.Length) {\n      this.activateDrawControl(this.drawLineControl);\n    } else if (this.activeMeasureType === MeasureType.Area) {\n      this.activateDrawControl(this.drawPolygonControl);\n    }\n  }\n\n  /**\n   * Activate a given control\n   * @param drawControl Draw control\n   */\n  private activateDrawControl(drawControl: DrawControl) {\n    this.drawControlIsDisabled = false;\n    this.activeDrawControl = drawControl;\n    this.drawStart$$ = drawControl.start$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onDrawStart(olGeometry)\n    );\n    this.drawEnd$$ = drawControl.end$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onDrawEnd(olGeometry)\n    );\n    this.drawChanges$$ = drawControl.changes$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onDrawChanges(olGeometry)\n    );\n    this.drawChanges$$ = drawControl.abort$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => {\n        this.clearTooltipsOfOlGeometry(olGeometry);\n        this.clearMeasures();\n      }\n    );\n    drawControl.setOlMap(this.map.ol, false);\n  }\n\n  /**\n   * Deactivate the active draw control\n   */\n  private deactivateDrawControl() {\n    if (this.activeDrawControl === undefined) {\n      return;\n    }\n\n    this.olDrawSource.clear();\n    if (this.drawStart$$ !== undefined) {\n      this.drawStart$$.unsubscribe();\n    }\n    if (this.drawEnd$$ !== undefined) {\n      this.drawEnd$$.unsubscribe();\n    }\n    if (this.drawChanges$$ !== undefined) {\n      this.drawChanges$$.unsubscribe();\n    }\n\n    this.clearTooltipsOfOlSource(this.olDrawSource);\n    if (this.activeOlGeometry !== undefined) {\n      this.clearTooltipsOfOlGeometry(this.activeOlGeometry);\n    }\n    this.activeDrawControl.setOlMap(undefined);\n    this.activeDrawControl = undefined;\n    this.activeOlGeometry = undefined;\n  }\n\n  private setActiveMeasureType(measureType: MeasureType) {\n    this._activeMeasureType = measureType;\n    this.clearMeasures();\n    this.toggleDrawControl();\n  }\n\n  /**\n   * Clear the draw source and track the geometry being drawn\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onDrawStart(olGeometry: OlLineString | OlPolygon) {\n    this.activeOlGeometry = olGeometry;\n  }\n\n  /**\n   * Clear the draw source and track the geometry being draw\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onDrawEnd(olGeometry: OlLineString | OlPolygon) {\n    this.activeOlGeometry = undefined;\n    this.finalizeMeasureOfOlGeometry(olGeometry);\n    this.addFeatureToStore(olGeometry);\n    this.clearTooltipsOfOlGeometry(olGeometry);\n    this.olDrawSource.clear(true);\n  }\n\n  /**\n   * Update measures observables and map tooltips\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onDrawChanges(olGeometry: OlLineString | OlPolygon) {\n    const measure = measureOlGeometry(olGeometry, this.projection);\n    this.updateMeasureOfOlGeometry(\n      olGeometry,\n      Object.assign({}, measure, {\n        area: undefined // We don't want to display an area tooltip while drawing.\n      })\n    );\n    this.measure$.next(measure);\n  }\n\n  /**\n   * Activate a given control\n   * @param modifyControl Modify control\n   */\n  private activateModifyControl() {\n    const selection = this.store.getStrategyOfType(\n      FeatureStoreSelectionStrategy\n    ) as FeatureStoreSelectionStrategy;\n    selection.deactivate();\n    selection.clear();\n\n    this.modifyStart$$ = this.modifyControl.start$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onModifyStart(olGeometry)\n    );\n    this.modifyEnd$$ = this.modifyControl.end$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onModifyEnd(olGeometry)\n    );\n    this.modifyChanges$$ = this.modifyControl.changes$.subscribe(\n      (olGeometry: OlLineString | OlPolygon) => this.onModifyChanges(olGeometry)\n    );\n    this.modifyControl.setOlMap(this.map.ol);\n  }\n\n  /**\n   * Deactivate the active modify control\n   */\n  private deactivateModifyControl() {\n    if (this.modifyStart$$ !== undefined) {\n      this.modifyStart$$.unsubscribe();\n    }\n    if (this.modifyEnd$$ !== undefined) {\n      this.modifyEnd$$.unsubscribe();\n    }\n    if (this.modifyChanges$$ !== undefined) {\n      this.modifyChanges$$.unsubscribe();\n    }\n\n    if (this.activeOlGeometry !== undefined) {\n      if (this.selectedFeatures$.value.length === 1) {\n        const localFeature = this.selectedFeatures$.value[0];\n        this.addFeatureToStore(this.activeOlGeometry, localFeature);\n      }\n      this.finalizeMeasureOfOlGeometry(this.activeOlGeometry);\n    }\n\n    this.olDrawSource.clear();\n\n    this.store.activateStrategyOfType(FeatureStoreSelectionStrategy);\n\n    this.activeOlGeometry = undefined;\n    this.modifyControl.setOlMap(undefined);\n  }\n\n  /**\n   * Clear the draw source and track the geometry being drawn\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onModifyStart(olGeometry: OlLineString | OlPolygon) {\n    this.onDrawStart(olGeometry);\n  }\n\n  /**\n   * Update measures observables and map tooltips\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onModifyChanges(olGeometry: OlLineString | OlPolygon) {\n    this.onDrawChanges(olGeometry);\n  }\n\n  /**\n   * Clear the draw source and track the geometry being draw\n   * @param olGeometry Ol linestring or polygon\n   */\n  private onModifyEnd(olGeometry: OlLineString | OlPolygon) {\n    this.finalizeMeasureOfOlGeometry(olGeometry);\n  }\n\n  private finalizeMeasureOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\n    const measure = measureOlGeometry(olGeometry, this.projection);\n    this.updateMeasureOfOlGeometry(olGeometry, measure);\n  }\n\n  /**\n   * Update measures observables\n   * @param olGeometry Ol linestring or polygon\n   * @param measure Measure\n   */\n  private updateMeasureOfOlGeometry(\n    olGeometry: OlLineString | OlPolygon,\n    measure: Measure\n  ) {\n    olGeometry.setProperties({ _measure: measure }, true);\n    this.updateTooltipsOfOlGeometry(olGeometry);\n  }\n\n  /**\n   * Clear the measures observables\n   */\n  private clearMeasures() {\n    this.measure$.next({});\n  }\n\n  /**\n   * Add a feature with measures to the store. The loading stragegy of the store\n   * will trigger and add the feature to the map.\n   * @internal\n   */\n  private addFeatureToStore(olGeometry, localFeature?: FeatureWithMeasure) {\n    const featureId = localFeature\n      ? localFeature.properties.id\n      : olGeometry.ol_uid;\n    const projection = this.map.ol.getView().getProjection();\n    const geometry = new OlGeoJSON().writeGeometryObject(olGeometry, {\n      featureProjection: projection,\n      dataProjection: projection\n    }) as any;\n    this.store.update({\n      type: FEATURE,\n      geometry,\n      projection: projection.getCode(),\n      properties: {\n        id: featureId,\n        measure: olGeometry.get('_measure')\n      },\n      meta: {\n        id: featureId\n      }\n    });\n  }\n\n  /**\n   * Update all the tooltips of an OL geometry\n   * @param olGeometry OL Geometry\n   * @param lengths Lengths of the OL geometry's segments\n   * @param measureUnit Display tooltip measure in those units\n   */\n  private updateTooltipsOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\n    const measure = olGeometry.get('_measure');\n    const lengths = measure.lengths;\n    const area = measure.area;\n\n    const olMidpointsTooltips = updateOlTooltipsAtMidpoints(olGeometry);\n    if (lengths.length === olMidpointsTooltips.length) {\n      for (let i = 0; i < olMidpointsTooltips.length; i++) {\n        const length = lengths[i];\n        if (length !== undefined) {\n          this.updateOlTooltip(\n            olMidpointsTooltips[i],\n            metersToUnit(length, this.activeLengthUnit),\n            this.activeLengthUnit,\n            MeasureType.Length\n          );\n        }\n      }\n    }\n\n    if (area !== undefined) {\n      this.updateOlTooltip(\n        updateOlTooltipAtCenter(olGeometry),\n        squareMetersToUnit(area, this.activeAreaUnit),\n        this.activeAreaUnit,\n        MeasureType.Area\n      );\n    }\n  }\n\n  /**\n   * Clear the tooltips of an OL geometrys\n   * @param olGeometry OL geometry with tooltips\n   */\n  private clearTooltipsOfOlGeometry(olGeometry: OlLineString | OlPolygon) {\n    getTooltipsOfOlGeometry(olGeometry).forEach(\n      (olTooltip: OlOverlay | undefined) => {\n        if (olTooltip !== undefined && olTooltip.getMap() !== undefined) {\n          this.map.ol.removeOverlay(olTooltip);\n        }\n      }\n    );\n  }\n\n  /**\n   * Show the map tooltips of all the geometries of a source\n   */\n  private updateTooltipsOfOlSource(olSource: OlVectorSource) {\n    olSource.forEachFeature((olFeature: OlFeature) => {\n      this.updateTooltipsOfOlGeometry(olFeature.getGeometry() as any);\n    });\n  }\n\n  /**\n   * Clear the map tooltips\n   * @param olDrawSource OL vector source\n   */\n  private clearTooltipsOfOlSource(olSource: OlVectorSource) {\n    olSource.forEachFeature((olFeature: OlFeature) => {\n      const olGeometry = olFeature.getGeometry();\n      if (olGeometry !== undefined) {\n        this.clearTooltipsOfOlGeometry(olFeature.getGeometry() as any);\n      }\n    });\n  }\n\n  /**\n   * Update an OL tooltip properties and inner HTML and add it to the map if possible\n   * @param olTooltip OL tooltip\n   * @param measure The measure valeu ti display\n   * @param measureUnit Display tooltip measure in those units\n   */\n  private updateOlTooltip(\n    olTooltip: OlOverlay,\n    measure: number,\n    unit: MeasureAreaUnit | MeasureLengthUnit,\n    type: MeasureType\n  ) {\n    olTooltip.setProperties(\n      { _measure: measure, _unit: unit, _type: type },\n      true\n    );\n    olTooltip.getElement().innerHTML = this.computeTooltipInnerHTML(olTooltip);\n    if (this.shouldShowTooltip(olTooltip)) {\n      this.map.ol.addOverlay(olTooltip);\n    }\n  }\n\n  /**\n   * Compute a tooltip's content\n   * @param olTooltip OL overlay\n   * @returns Inner HTML\n   */\n  private computeTooltipInnerHTML(olTooltip: OlOverlay): string {\n    const properties = olTooltip.getProperties() as any;\n    return formatMeasure(\n      properties._measure,\n      {\n        decimal: 1,\n        unit: properties._unit,\n        unitAbbr: true,\n        locale: 'fr'\n      },\n      this.languageService\n    );\n  }\n\n  /**\n   * Whether a tooltip should be showned based on the length\n   * of the segment it is bound to.\n   * @param olTooltip OL overlay\n   * @returns True if the tooltip should be shown\n   */\n  private shouldShowTooltip(olTooltip: OlOverlay): boolean {\n    if (this.showTooltips === false) {\n      return false;\n    }\n\n    const properties = olTooltip.getProperties() as any;\n    const measure = properties._measure;\n    if (measure === undefined) {\n      return false;\n    }\n\n    if (properties._unit === MeasureType.Length) {\n      const minSegmentLength =\n        metersToUnit(this.minSegmentLength, properties._unit) || 0;\n      return measure > Math.max(minSegmentLength, 0);\n    }\n\n    return true;\n  }\n\n  private saveCurrentUnits() {\n    this.storageService.set(\n      'distanceUnit',\n      this.activeLengthUnit,\n      StorageScope.SESSION\n    );\n    this.storageService.set(\n      'areaUnit',\n      this.activeAreaUnit,\n      StorageScope.SESSION\n    );\n  }\n\n  private getSavedUnits() {\n    const distanceUnit = this.storageService.get(\n      'distanceUnit'\n    ) as MeasureLengthUnit;\n    const areaUnit = this.storageService.get('areaUnit') as MeasureAreaUnit;\n\n    this.activeLengthUnit = distanceUnit ? distanceUnit : this.activeLengthUnit;\n    this.activeAreaUnit = areaUnit ? areaUnit : this.activeAreaUnit;\n  }\n}\n","<div>\n  <div class=\"measure-type-toggle mat-typography\">\n    <mat-button-toggle-group\n      [value]=\"activeMeasureType\"\n      (change)=\"onMeasureTypeChange($event.value)\"\n    >\n      <mat-button-toggle [value]=\"measureType.Length\">\n        {{ 'igo.geo.measure.' + measureType.Length | translate }}\n      </mat-button-toggle>\n      <mat-button-toggle [value]=\"measureType.Area\">\n        {{ 'igo.geo.measure.' + measureType.Area | translate }}\n      </mat-button-toggle>\n    </mat-button-toggle-group>\n  </div>\n\n  <div class=\"measure-options mat-typography\">\n    <mat-slide-toggle\n      [disabled]=\"drawControlIsDisabled\"\n      [checked]=\"drawControlIsActive\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDrawControl($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleActive' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"hasLine$ | async\"></mat-divider>\n\n    <mat-slide-toggle\n      *ngIf=\"hasLine$ | async\"\n      [checked]=\"displayLines\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayLines($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayLines' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\n\n    <mat-slide-toggle\n      *ngIf=\"hasArea$ | async\"\n      [checked]=\"displayDistance\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayDistance($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayDistance' | translate }}\n    </mat-slide-toggle>\n\n    <mat-slide-toggle\n      *ngIf=\"hasArea$ | async\"\n      [checked]=\"displayAreas\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleDisplayAreas($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleDisplayAreas' | translate }}\n    </mat-slide-toggle>\n\n    <mat-divider *ngIf=\"hasArea$ | async\"></mat-divider>\n\n    <mat-slide-toggle\n      [checked]=\"measureUnitsAuto\"\n      [labelPosition]=\"'before'\"\n      (change)=\"onToggleMeasureUnitsAuto($event.checked)\"\n    >\n      {{ 'igo.geo.measure.toggleAutoUnits' | translate }}\n    </mat-slide-toggle>\n  </div>\n\n  <ng-container *ngIf=\"measure$ | async as measure\">\n    <igo-measurer-item\n      *ngIf=\"\n        activeMeasureType === measureType.Length ||\n        activeMeasureType === measureType.Area\n      \"\n      [measureType]=\"measureType.Length\"\n      [measureUnit]=\"activeLengthUnit\"\n      [measure]=\"measure.length\"\n      [auto]=\"measureUnitsAuto\"\n      [placeholder]=\"\n        (activeMeasureType === measureType.Area\n          ? 'igo.geo.measure.perimeter'\n          : 'igo.geo.measure.length'\n        ) | translate\n      \"\n      (measureUnitChange)=\"onLengthUnitChange($any($event))\"\n    >\n    </igo-measurer-item>\n\n    <igo-measurer-item\n      *ngIf=\"activeMeasureType === measureType.Area\"\n      [measureType]=\"measureType.Area\"\n      [measureUnit]=\"activeAreaUnit\"\n      [measure]=\"measure.area\"\n      [auto]=\"measureUnitsAuto\"\n      [placeholder]=\"'igo.geo.measure.area' | translate\"\n      (measureUnitChange)=\"onAreaUnitChange($any($event))\"\n    >\n    </igo-measurer-item>\n  </ng-container>\n\n  <mat-divider *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"></mat-divider>\n\n  <div class=\"measure-store-buttons\">\n    <button\n      *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.calculate.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      color=\"accent\"\n      (click)=\"onCalculateClick()\"\n    >\n      <mat-icon>calculate</mat-icon>\n    </button>\n\n    <button\n      *ngIf=\"(hasLine$ | async) || (hasArea$ | async)\"\n      mat-icon-button\n      [matTooltip]=\"'igo.geo.measure.actionbar.delete.tooltip' | translate\"\n      [disabled]=\"(selectedFeatures$ | async).length === 0\"\n      color=\"warn\"\n      (click)=\"onDeleteClick()\"\n    >\n      <mat-icon>delete</mat-icon>\n    </button>\n  </div>\n\n  <igo-entity-table\n    #table\n    class=\"table-compact\"\n    [store]=\"store\"\n    [template]=\"tableTemplate\"\n  >\n  </igo-entity-table>\n</div>\n"]}