@igo2/geo 1.15.4 → 16.0.0-rc.0

package/esm2022/lib/import-export/import-export/index.mjs

@@ -0,0 +1,2 @@
+export * from './import-export.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9pbXBvcnQtZXhwb3J0L2ltcG9ydC1leHBvcnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW1wb3J0LWV4cG9ydC5jb21wb25lbnQnO1xuIl19

package/esm2022/lib/import-export/import-export.module.mjs

@@ -0,0 +1,98 @@
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { MatButtonToggleModule } from '@angular/material/button-toggle';
+import { MatOptionModule } from '@angular/material/core';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatTabsModule } from '@angular/material/tabs';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { IgoLanguageModule } from '@igo2/core';
+import { IgoKeyValueModule, IgoDrapDropModule, IgoSpinnerModule, IgoCustomHtmlModule } from '@igo2/common';
+import { ExportButtonComponent } from './export-button/export-button.component';
+import { ImportExportComponent } from './import-export/import-export.component';
+import { DropGeoFileDirective } from './shared/drop-geo-file.directive';
+import * as i0 from "@angular/core";
+export class IgoImportExportModule {
+    static forRoot() {
+        return {
+            ngModule: IgoImportExportModule
+        };
+    }
+    static ɵfac = function IgoImportExportModule_Factory(t) { return new (t || IgoImportExportModule)(); };
+    static ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: IgoImportExportModule });
+    static ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [MatIconModule,
+            MatTooltipModule,
+            FormsModule,
+            ReactiveFormsModule,
+            CommonModule,
+            MatButtonModule,
+            MatButtonToggleModule,
+            MatTabsModule,
+            MatSelectModule,
+            MatOptionModule,
+            MatFormFieldModule,
+            MatInputModule,
+            MatSlideToggleModule,
+            IgoLanguageModule,
+            IgoSpinnerModule,
+            IgoKeyValueModule,
+            IgoDrapDropModule,
+            IgoCustomHtmlModule] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(IgoImportExportModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    MatIconModule,
+                    MatTooltipModule,
+                    FormsModule,
+                    ReactiveFormsModule,
+                    CommonModule,
+                    MatButtonModule,
+                    MatButtonToggleModule,
+                    MatTabsModule,
+                    MatSelectModule,
+                    MatOptionModule,
+                    MatFormFieldModule,
+                    MatInputModule,
+                    MatSlideToggleModule,
+                    IgoLanguageModule,
+                    IgoSpinnerModule,
+                    IgoKeyValueModule,
+                    IgoDrapDropModule,
+                    IgoCustomHtmlModule
+                ],
+                exports: [ImportExportComponent, DropGeoFileDirective, ExportButtonComponent],
+                declarations: [
+                    ImportExportComponent,
+                    DropGeoFileDirective,
+                    ExportButtonComponent
+                ]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(IgoImportExportModule, { declarations: [ImportExportComponent,
+        DropGeoFileDirective,
+        ExportButtonComponent], imports: [MatIconModule,
+        MatTooltipModule,
+        FormsModule,
+        ReactiveFormsModule,
+        CommonModule,
+        MatButtonModule,
+        MatButtonToggleModule,
+        MatTabsModule,
+        MatSelectModule,
+        MatOptionModule,
+        MatFormFieldModule,
+        MatInputModule,
+        MatSlideToggleModule,
+        IgoLanguageModule,
+        IgoSpinnerModule,
+        IgoKeyValueModule,
+        IgoDrapDropModule,
+        IgoCustomHtmlModule], exports: [ImportExportComponent, DropGeoFileDirective, ExportButtonComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/import-export/index.mjs

@@ -0,0 +1,4 @@
+export * from './shared';
+export * from './import-export';
+export * from './export-button';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9pbXBvcnQtZXhwb3J0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2hhcmVkJztcbmV4cG9ydCAqIGZyb20gJy4vaW1wb3J0LWV4cG9ydCc7XG5leHBvcnQgKiBmcm9tICcuL2V4cG9ydC1idXR0b24nO1xuIl19

package/esm2022/lib/import-export/shared/drop-geo-file.directive.mjs

@@ -0,0 +1,174 @@
+import { Directive, HostListener, EventEmitter, Input } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { MessageService, ConfigService } from '@igo2/core';
+import { ConfirmDialogService, DragAndDropDirective } from '@igo2/common';
+import { MapBrowserComponent } from '../../map/map-browser/map-browser.component';
+import { ImportService } from './import.service';
+import { handleFileImportSuccess, handleFileImportError } from '../shared/import.utils';
+import { StyleService } from '../../style/style-service/style.service';
+import { StyleListService } from '../../style/style-list/style-list.service';
+import { concatMap, first, skipWhile } from 'rxjs/operators';
+import { LayerService } from '../../layer/shared/layer.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../map/map-browser/map-browser.component";
+import * as i2 from "./import.service";
+import * as i3 from "../../style/style-list/style-list.service";
+import * as i4 from "../../style/style-service/style.service";
+import * as i5 from "@igo2/core";
+import * as i6 from "../../layer/shared/layer.service";
+import * as i7 from "@igo2/common";
+export class DropGeoFileDirective extends DragAndDropDirective {
+    component;
+    importService;
+    styleListService;
+    styleService;
+    config;
+    messageService;
+    layerService;
+    confirmDialogService;
+    filesDropped = new EventEmitter();
+    filesInvalid = new EventEmitter();
+    epsgCode$ = new BehaviorSubject(undefined);
+    epsgCode$$ = [];
+    filesDropped$$;
+    get map() {
+        return this.component.map;
+    }
+    contextUri;
+    constructor(component, importService, styleListService, styleService, config, messageService, layerService, confirmDialogService) {
+        super();
+        this.component = component;
+        this.importService = importService;
+        this.styleListService = styleListService;
+        this.styleService = styleService;
+        this.config = config;
+        this.messageService = messageService;
+        this.layerService = layerService;
+        this.confirmDialogService = confirmDialogService;
+    }
+    ngOnInit() {
+        this.filesDropped$$ = this.filesDropped.subscribe((files) => {
+            this.onFilesDropped(files);
+        });
+    }
+    ngOnDestroy() {
+        this.filesDropped$$.unsubscribe();
+    }
+    onDragOver(evt) {
+        super.onDragOver(evt);
+    }
+    onDragLeave(evt) {
+        super.onDragLeave(evt);
+    }
+    onDrop(evt) {
+        super.onDrop(evt);
+    }
+    onFilesDropped(files) {
+        for (const file of files) {
+            this.detectEPSG(file);
+            this.epsgCode$$.push(this.epsgCode$
+                .pipe(skipWhile((code) => !code), first(), concatMap((epsgCode) => {
+                const epsg = epsgCode === 'epsgNotDefined' ? undefined : epsgCode;
+                this.epsgCode$.next(undefined);
+                return this.importService.import(file, epsg);
+            }))
+                .subscribe((features) => this.onFileImportSuccess(file, features), (error) => this.onFileImportError(file, error)));
+        }
+    }
+    detectEPSG(file, nbLines = 500) {
+        if (!file.name.toLowerCase().endsWith('.geojson') &&
+            !file.name.toLowerCase().endsWith('.gml')) {
+            this.epsgCode$.next('epsgNotDefined');
+            return;
+        }
+        const reader = new FileReader();
+        reader.onload = (e) => {
+            if (file.name.toLowerCase().endsWith('.geojson')) {
+                const geojson = JSON.parse(reader.result);
+                if (geojson.crs?.properties?.name) {
+                    const epsg = geojson.crs.properties.name.match(/EPSG:{1,2}\d{0,6}/gm);
+                    if (epsg !== null && epsg.length) {
+                        this.epsgCode$.next(epsg[0].replace(/::/g, ':'));
+                        return;
+                    }
+                    else {
+                        this.epsgCode$.next('epsgNotDefined');
+                        return;
+                    }
+                }
+                else {
+                    this.epsgCode$.next('epsgNotDefined');
+                    return;
+                }
+            }
+            else if (file.name.toLowerCase().endsWith('.gml')) {
+                const text = reader.result;
+                const lines = text.split('\n');
+                for (let line = 0; line <= nbLines; line++) {
+                    const epsg = lines[line].match(/EPSG:\d{0,6}/gm);
+                    if (epsg !== null && epsg.length) {
+                        this.epsgCode$.next(epsg[0]);
+                        break;
+                    }
+                    else {
+                        this.epsgCode$.next(undefined);
+                        return;
+                    }
+                }
+            }
+            else {
+                this.epsgCode$.next('epsgNotDefined');
+                return;
+            }
+        };
+        reader.readAsText(file, 'UTF-8');
+    }
+    onFileImportSuccess(file, features) {
+        const importExportOptions = this.config.getConfig('importExport');
+        const importWithStyle = importExportOptions?.importWithStyle ||
+            this.config.getConfig('importWithStyle');
+        if (this.config.getConfig('importWithStyle')) {
+            console.warn(`
+      The location of this config importWithStyle is deprecated.
+      Please move this property within importExport configuration.
+      Ex: importWithStyle: true/false must be transfered to importExport: { importWithStyle: true/false }
+      Refer to environnement.ts OR config/config.json
+      This legacy conversion will be deleted in 2024.
+      `);
+        }
+        const confirmDialogService = importExportOptions?.allowToStoreLayer
+            ? this.confirmDialogService
+            : undefined;
+        if (!importWithStyle) {
+            handleFileImportSuccess(file, features, this.map, this.contextUri, this.messageService, this.layerService, confirmDialogService);
+        }
+        else {
+            handleFileImportSuccess(file, features, this.map, this.contextUri, this.messageService, this.layerService, confirmDialogService, this.styleListService, this.styleService);
+        }
+    }
+    onFileImportError(file, error) {
+        handleFileImportError(file, error, this.messageService, this.config.getConfig('importExport.clientSideFileSizeMaxMb'));
+    }
+    static ɵfac = function DropGeoFileDirective_Factory(t) { return new (t || DropGeoFileDirective)(i0.ɵɵdirectiveInject(i1.MapBrowserComponent), i0.ɵɵdirectiveInject(i2.ImportService), i0.ɵɵdirectiveInject(i3.StyleListService), i0.ɵɵdirectiveInject(i4.StyleService), i0.ɵɵdirectiveInject(i5.ConfigService), i0.ɵɵdirectiveInject(i5.MessageService), i0.ɵɵdirectiveInject(i6.LayerService), i0.ɵɵdirectiveInject(i7.ConfirmDialogService)); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: DropGeoFileDirective, selectors: [["", "igoDropGeoFile", ""]], hostBindings: function DropGeoFileDirective_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("dragover", function DropGeoFileDirective_dragover_HostBindingHandler($event) { return ctx.onDragOver($event); })("dragleave", function DropGeoFileDirective_dragleave_HostBindingHandler($event) { return ctx.onDragLeave($event); })("drop", function DropGeoFileDirective_drop_HostBindingHandler($event) { return ctx.onDrop($event); });
+        } }, inputs: { contextUri: "contextUri" }, features: [i0.ɵɵInheritDefinitionFeature] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DropGeoFileDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[igoDropGeoFile]'
+            }]
+    }], function () { return [{ type: i1.MapBrowserComponent }, { type: i2.ImportService }, { type: i3.StyleListService }, { type: i4.StyleService }, { type: i5.ConfigService }, { type: i5.MessageService }, { type: i6.LayerService }, { type: i7.ConfirmDialogService }]; }, { contextUri: [{
+            type: Input
+        }], onDragOver: [{
+            type: HostListener,
+            args: ['dragover', ['$event']]
+        }], onDragLeave: [{
+            type: HostListener,
+            args: ['dragleave', ['$event']]
+        }], onDrop: [{
+            type: HostListener,
+            args: ['drop', ['$event']]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drop-geo-file.directive.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/import-export/shared/drop-geo-file.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Directive,\r\n  HostListener,\r\n  EventEmitter,\r\n  OnInit,\r\n  OnDestroy,\r\n  Input\r\n} from '@angular/core';\r\n\r\nimport { BehaviorSubject, Subscription } from 'rxjs';\r\n\r\nimport { MessageService, ConfigService } from '@igo2/core';\r\nimport { ConfirmDialogService, DragAndDropDirective } from '@igo2/common';\r\n\r\nimport { Feature } from '../../feature/shared/feature.interfaces';\r\nimport { IgoMap } from '../../map/shared/map';\r\nimport { MapBrowserComponent } from '../../map/map-browser/map-browser.component';\r\nimport { ImportService } from './import.service';\r\nimport {\r\n  handleFileImportSuccess,\r\n  handleFileImportError\r\n} from '../shared/import.utils';\r\nimport { StyleService } from '../../style/style-service/style.service';\r\nimport { StyleListService } from '../../style/style-list/style-list.service';\r\nimport { concatMap, first, skipWhile } from 'rxjs/operators';\r\nimport { LayerService } from '../../layer/shared/layer.service';\r\nimport { ImportExportServiceOptions } from './import.interface';\r\n\r\n@Directive({\r\n  selector: '[igoDropGeoFile]'\r\n})\r\nexport class DropGeoFileDirective\r\n  extends DragAndDropDirective\r\n  implements OnInit, OnDestroy\r\n{\r\n  protected filesDropped: EventEmitter<File[]> = new EventEmitter();\r\n  protected filesInvalid: EventEmitter<File[]> = new EventEmitter();\r\n  private epsgCode$: BehaviorSubject<string> = new BehaviorSubject(undefined);\r\n  private epsgCode$$: Subscription[] = [];\r\n  private filesDropped$$: Subscription;\r\n\r\n  get map(): IgoMap {\r\n    return this.component.map;\r\n  }\r\n\r\n  @Input() contextUri: string;\r\n\r\n  constructor(\r\n    private component: MapBrowserComponent,\r\n    private importService: ImportService,\r\n    private styleListService: StyleListService,\r\n    private styleService: StyleService,\r\n    private config: ConfigService,\r\n    private messageService: MessageService,\r\n    private layerService: LayerService,\r\n    private confirmDialogService: ConfirmDialogService\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.filesDropped$$ = this.filesDropped.subscribe((files: File[]) => {\r\n      this.onFilesDropped(files);\r\n    });\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.filesDropped$$.unsubscribe();\r\n  }\r\n\r\n  @HostListener('dragover', ['$event'])\r\n  public onDragOver(evt) {\r\n    super.onDragOver(evt);\r\n  }\r\n\r\n  @HostListener('dragleave', ['$event'])\r\n  public onDragLeave(evt) {\r\n    super.onDragLeave(evt);\r\n  }\r\n\r\n  @HostListener('drop', ['$event'])\r\n  public onDrop(evt) {\r\n    super.onDrop(evt);\r\n  }\r\n\r\n  private onFilesDropped(files: File[]) {\r\n    for (const file of files) {\r\n      this.detectEPSG(file);\r\n      this.epsgCode$$.push(\r\n        this.epsgCode$\r\n          .pipe(\r\n            skipWhile((code) => !code),\r\n            first(),\r\n            concatMap((epsgCode) => {\r\n              const epsg = epsgCode === 'epsgNotDefined' ? undefined : epsgCode;\r\n              this.epsgCode$.next(undefined);\r\n              return this.importService.import(file, epsg);\r\n            })\r\n          )\r\n          .subscribe(\r\n            (features: Feature[]) => this.onFileImportSuccess(file, features),\r\n            (error: Error) => this.onFileImportError(file, error)\r\n          )\r\n      );\r\n    }\r\n  }\r\n\r\n  private detectEPSG(file: File, nbLines: number = 500) {\r\n    if (\r\n      !file.name.toLowerCase().endsWith('.geojson') &&\r\n      !file.name.toLowerCase().endsWith('.gml')\r\n    ) {\r\n      this.epsgCode$.next('epsgNotDefined');\r\n      return;\r\n    }\r\n    const reader = new FileReader();\r\n    reader.onload = (e) => {\r\n      if (file.name.toLowerCase().endsWith('.geojson')) {\r\n        const geojson = JSON.parse(reader.result as string);\r\n        if (geojson.crs?.properties?.name) {\r\n          const epsg = geojson.crs.properties.name.match(/EPSG:{1,2}\\d{0,6}/gm);\r\n          if (epsg !== null && epsg.length) {\r\n            this.epsgCode$.next(epsg[0].replace(/::/g, ':'));\r\n            return;\r\n          } else {\r\n            this.epsgCode$.next('epsgNotDefined');\r\n            return;\r\n          }\r\n        } else {\r\n          this.epsgCode$.next('epsgNotDefined');\r\n          return;\r\n        }\r\n      } else if (file.name.toLowerCase().endsWith('.gml')) {\r\n        const text = reader.result as string;\r\n        const lines = (text as string).split('\\n');\r\n        for (let line = 0; line <= nbLines; line++) {\r\n          const epsg = lines[line].match(/EPSG:\\d{0,6}/gm);\r\n          if (epsg !== null && epsg.length) {\r\n            this.epsgCode$.next(epsg[0]);\r\n            break;\r\n          } else {\r\n            this.epsgCode$.next(undefined);\r\n            return;\r\n          }\r\n        }\r\n      } else {\r\n        this.epsgCode$.next('epsgNotDefined');\r\n        return;\r\n      }\r\n    };\r\n    reader.readAsText(file, 'UTF-8');\r\n  }\r\n\r\n  private onFileImportSuccess(file: File, features: Feature[]) {\r\n    const importExportOptions = this.config.getConfig(\r\n      'importExport'\r\n    ) as ImportExportServiceOptions;\r\n    const importWithStyle =\r\n      importExportOptions?.importWithStyle ||\r\n      this.config.getConfig('importWithStyle');\r\n    if (this.config.getConfig('importWithStyle')) {\r\n      console.warn(`\r\n      The location of this config importWithStyle is deprecated.\r\n      Please move this property within importExport configuration.\r\n      Ex: importWithStyle: true/false must be transfered to importExport: { importWithStyle: true/false }\r\n      Refer to environnement.ts OR config/config.json\r\n      This legacy conversion will be deleted in 2024.\r\n      `);\r\n    }\r\n    const confirmDialogService = importExportOptions?.allowToStoreLayer\r\n      ? this.confirmDialogService\r\n      : undefined;\r\n    if (!importWithStyle) {\r\n      handleFileImportSuccess(\r\n        file,\r\n        features,\r\n        this.map,\r\n        this.contextUri,\r\n        this.messageService,\r\n        this.layerService,\r\n        confirmDialogService\r\n      );\r\n    } else {\r\n      handleFileImportSuccess(\r\n        file,\r\n        features,\r\n        this.map,\r\n        this.contextUri,\r\n        this.messageService,\r\n        this.layerService,\r\n        confirmDialogService,\r\n        this.styleListService,\r\n        this.styleService\r\n      );\r\n    }\r\n  }\r\n\r\n  private onFileImportError(file: File, error: Error) {\r\n    handleFileImportError(\r\n      file,\r\n      error,\r\n      this.messageService,\r\n      this.config.getConfig('importExport.clientSideFileSizeMaxMb')\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2022/lib/import-export/shared/export.errors.mjs

@@ -0,0 +1,15 @@
+export class ExportError extends Error {
+}
+export class ExportInvalidFileError extends ExportError {
+    constructor() {
+        super('Invalid file');
+        Object.setPrototypeOf(this, ExportInvalidFileError.prototype);
+    }
+}
+export class ExportNothingToExportError extends ExportError {
+    constructor() {
+        super('Nothing to export');
+        Object.setPrototypeOf(this, ExportNothingToExportError.prototype);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LmVycm9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL2ltcG9ydC1leHBvcnQvc2hhcmVkL2V4cG9ydC5lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFdBQVksU0FBUSxLQUFLO0NBQUc7QUFFekMsTUFBTSxPQUFPLHNCQUF1QixTQUFRLFdBQVc7SUFDckQ7UUFDRSxLQUFLLENBQUMsY0FBYyxDQUFDLENBQUM7UUFDdEIsTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsc0JBQXNCLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDaEUsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLDBCQUEyQixTQUFRLFdBQVc7SUFDekQ7UUFDRSxLQUFLLENBQUMsbUJBQW1CLENBQUMsQ0FBQztRQUMzQixNQUFNLENBQUMsY0FBYyxDQUFDLElBQUksRUFBRSwwQkFBMEIsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNwRSxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgRXhwb3J0RXJyb3IgZXh0ZW5kcyBFcnJvciB7fVxuXG5leHBvcnQgY2xhc3MgRXhwb3J0SW52YWxpZEZpbGVFcnJvciBleHRlbmRzIEV4cG9ydEVycm9yIHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgc3VwZXIoJ0ludmFsaWQgZmlsZScpO1xuICAgIE9iamVjdC5zZXRQcm90b3R5cGVPZih0aGlzLCBFeHBvcnRJbnZhbGlkRmlsZUVycm9yLnByb3RvdHlwZSk7XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIEV4cG9ydE5vdGhpbmdUb0V4cG9ydEVycm9yIGV4dGVuZHMgRXhwb3J0RXJyb3Ige1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcignTm90aGluZyB0byBleHBvcnQnKTtcbiAgICBPYmplY3Quc2V0UHJvdG90eXBlT2YodGhpcywgRXhwb3J0Tm90aGluZ1RvRXhwb3J0RXJyb3IucHJvdG90eXBlKTtcbiAgfVxufVxuIl19

package/esm2022/lib/import-export/shared/export.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2dlby9zcmMvbGliL2ltcG9ydC1leHBvcnQvc2hhcmVkL2V4cG9ydC5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEV4cG9ydEZvcm1hdCwgRW5jb2RpbmdGb3JtYXQgfSBmcm9tICcuL2V4cG9ydC50eXBlJztcblxuZXhwb3J0IGludGVyZmFjZSBFeHBvcnRPcHRpb25zIHtcbiAgZm9ybWF0PzogRXhwb3J0Rm9ybWF0O1xuICBlbmNvZGluZz86IEVuY29kaW5nRm9ybWF0O1xuICBsYXllcnM6IHN0cmluZ1tdO1xuICBsYXllcnNXaXRoU2VsZWN0aW9uPzogc3RyaW5nW107XG4gIG5hbWU/OiBzdHJpbmc7XG4gIGNvbWJpbmVMYXllcnM/OiBib29sZWFuO1xuICBzZXBhcmF0b3I/OiBib29sZWFuO1xuICBmZWF0dXJlSW5NYXBFeHRlbnQ/OiBib29sZWFuO1xufVxuIl19

package/esm2022/lib/import-export/shared/export.service.mjs

@@ -0,0 +1,205 @@
+import { Injectable } from '@angular/core';
+import { ConfigService } from '@igo2/core';
+import { downloadContent } from '@igo2/utils';
+import { Observable } from 'rxjs';
+import * as olformat from 'ol/format';
+import OlFeature from 'ol/Feature';
+import { encode } from 'windows-1252';
+import { ExportFormat, EncodingFormat } from './export.type';
+import { ExportInvalidFileError, ExportNothingToExportError } from './export.errors';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+export class ExportService {
+    config;
+    static ogreFormats = {
+        GML: 'gml',
+        GPX: 'gpx',
+        KML: 'kml',
+        Shapefile: 'ESRI Shapefile',
+        CSVcomma: 'CSVcomma',
+        CSVsemicolon: 'CSVsemicolon'
+    };
+    static noOgreFallbacks = ['GML', 'GPX', 'KML'];
+    ogreUrl;
+    aggregateInComment = true;
+    constructor(config) {
+        this.config = config;
+        this.ogreUrl = this.config.getConfig('importExport.url');
+        const gpxAggregateInComment = this.config.getConfig('importExport.gpxAggregateInComment');
+        if (gpxAggregateInComment !== undefined) {
+            this.aggregateInComment = gpxAggregateInComment;
+        }
+    }
+    export(olFeatures, format, title, encoding, projectionIn = 'EPSG:4326', projectionOut = 'EPSG:4326') {
+        const exportOlFeatures = this.generateFeature(olFeatures, format, '_featureStore');
+        return this.exportAsync(exportOlFeatures, format, title, encoding, projectionIn, projectionOut);
+    }
+    generateFeature(olFeatures, format, excludePrefix = '_') {
+        if (format === ExportFormat.GPX && this.aggregateInComment) {
+            return this.generateAggregatedFeature(olFeatures);
+        }
+        return olFeatures.map((olFeature) => {
+            const keys = olFeature
+                .getKeys()
+                .filter((key) => !key.startsWith(excludePrefix));
+            const properties = keys.reduce((acc, key) => {
+                acc[key] = olFeature.get(key);
+                return acc;
+            }, { geometry: olFeature.getGeometry() });
+            return new OlFeature(properties);
+        });
+    }
+    generateAggregatedFeature(olFeatures) {
+        return olFeatures.map((olFeature) => {
+            const keys = olFeature
+                .getKeys()
+                .filter((key) => !key.startsWith('_'));
+            let comment = '';
+            const properties = keys.reduce((acc, key) => {
+                if (key && key !== 'geometry') {
+                    key === 'id' && olFeature.get('draw')
+                        ? (comment += key + ':' + olFeature.get('draw') + '   \r\n')
+                        : (comment += key + ':' + olFeature.get(key) + '   \r\n');
+                }
+                acc[key] = olFeature.get(key);
+                return acc;
+            }, {
+                geometry: olFeature.getGeometry()
+            });
+            const newFeature = new OlFeature(properties);
+            newFeature.set('name', olFeature.getId());
+            newFeature.set('cmt', comment);
+            return newFeature;
+        });
+    }
+    exportAsync(olFeatures, format, title, encoding, projectionIn, projectionOut) {
+        const doExport = (observer) => {
+            const nothingToExport = this.nothingToExport(olFeatures, format);
+            if (nothingToExport) {
+                observer.error(new ExportNothingToExportError());
+                return;
+            }
+            const ogreFormats = Object.keys(ExportService.ogreFormats);
+            if (ogreFormats.indexOf(format) >= 0) {
+                if (!this.ogreUrl) {
+                    if (ExportService.noOgreFallbacks.indexOf(format) >= 0) {
+                        this.exportToFile(olFeatures, observer, format, title, projectionIn, projectionOut);
+                    }
+                    else {
+                        observer.error(new ExportInvalidFileError());
+                    }
+                    return;
+                }
+                this.exportWithOgre(olFeatures, observer, format, title, encoding, projectionIn, projectionOut);
+            }
+            else {
+                this.exportToFile(olFeatures, observer, format, title, projectionIn, projectionOut);
+            }
+        };
+        return new Observable(doExport);
+    }
+    exportToFile(olFeatures, observer, format, title, projectionIn, projectionOut) {
+        const olFormat = new olformat[format]();
+        const featuresText = olFormat.writeFeatures(olFeatures, {
+            dataProjection: projectionOut,
+            featureProjection: projectionIn,
+            featureType: 'feature',
+            featureNS: 'http://example.com/feature'
+        });
+        const fileName = `${title}.${format.toLowerCase()}`;
+        downloadContent(featuresText, 'text/plain;charset=utf-8', fileName);
+        observer.complete();
+    }
+    exportWithOgre(olFeatures, observer, format, title, encodingType, projectionIn, projectionOut) {
+        let featuresText = new olformat.GeoJSON().writeFeatures(olFeatures, {
+            dataProjection: projectionOut,
+            featureProjection: projectionIn
+        });
+        const url = `${this.ogreUrl}/convertJson`;
+        const form = document.createElement('form');
+        form.style.display = 'none';
+        document.body.appendChild(form);
+        form.setAttribute('method', 'post');
+        form.setAttribute('target', '_blank');
+        form.setAttribute('action', url);
+        if (encodingType === EncodingFormat.UTF8) {
+            form.acceptCharset = 'UTF-8';
+            form.enctype = 'application/x-www-form-urlencoded; charset=utf-8;';
+        }
+        else if (encodingType === EncodingFormat.LATIN1) {
+            const enctype = 'ISO-8859-1';
+            const featuresJson = JSON.parse(featuresText);
+            featuresJson.features.map((f) => {
+                const encodedProperties = String.fromCharCode.apply(null, encode(JSON.stringify(f.properties), { mode: 'replacement' }));
+                f.properties = JSON.parse(encodedProperties);
+            });
+            featuresText = JSON.stringify(featuresJson);
+            const encoding = document.createElement('input');
+            encoding.setAttribute('type', 'hidden');
+            encoding.setAttribute('name', 'encoding');
+            encoding.setAttribute('value', enctype);
+            form.appendChild(encoding);
+        }
+        if (format === 'CSVsemicolon') {
+            const options = document.createElement('input');
+            options.setAttribute('type', 'hidden');
+            options.setAttribute('name', 'lco');
+            options.setAttribute('value', 'SEPARATOR=SEMICOLON');
+            form.appendChild(options);
+        }
+        const geojsonField = document.createElement('input');
+        geojsonField.setAttribute('type', 'hidden');
+        geojsonField.setAttribute('name', 'json');
+        geojsonField.setAttribute('value', featuresText);
+        form.appendChild(geojsonField);
+        const outputNameField = document.createElement('input');
+        let outputName = format === 'Shapefile'
+            ? `${title}.zip`
+            : `${title}.${format.toLowerCase()}`;
+        if (format === 'CSVcomma' || format === 'CSVsemicolon') {
+            outputName = `${title}.csv`;
+        }
+        outputName = outputName.replace(' ', '_');
+        outputName = outputName
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .replace(/’/g, "'");
+        outputNameField.setAttribute('type', 'hidden');
+        outputNameField.setAttribute('name', 'outputName');
+        outputNameField.setAttribute('value', outputName);
+        form.appendChild(outputNameField);
+        let ogreFormat = ExportService.ogreFormats[format];
+        if (format === 'CSVcomma' || format === 'CSVsemicolon') {
+            ogreFormat = 'CSV';
+        }
+        const outputFormatField = document.createElement('input');
+        outputFormatField.setAttribute('type', 'hidden');
+        outputFormatField.setAttribute('name', 'format');
+        outputFormatField.setAttribute('value', ogreFormat);
+        form.appendChild(outputFormatField);
+        form.submit();
+        document.body.removeChild(form);
+        observer.complete();
+    }
+    nothingToExport(olFeatures, format) {
+        if (olFeatures.length === 0) {
+            return true;
+        }
+        if (format === 'GPX') {
+            const pointOrLine = olFeatures.find((olFeature) => {
+                return (['Point', 'LineString', 'MultiLineString'].indexOf(olFeature.getGeometry().getType()) >= 0);
+            });
+            return pointOrLine === undefined;
+        }
+        return false;
+    }
+    static ɵfac = function ExportService_Factory(t) { return new (t || ExportService)(i0.ɵɵinject(i1.ConfigService)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ExportService, factory: ExportService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ExportService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.ConfigService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"export.service.js","sourceRoot":"","sources":["../../../../../../packages/geo/src/lib/import-export/shared/export.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\nimport { ConfigService } from '@igo2/core';\r\nimport { downloadContent } from '@igo2/utils';\r\n\r\nimport { Observable, Observer } from 'rxjs';\r\n\r\nimport * as olformat from 'ol/format';\r\nimport OlFeature from 'ol/Feature';\r\nimport type { default as OlGeometry } from 'ol/geom/Geometry';\r\nimport { encode } from 'windows-1252';\r\n\r\nimport { ExportFormat, EncodingFormat } from './export.type';\r\n\r\nimport {\r\n  ExportInvalidFileError,\r\n  ExportNothingToExportError\r\n} from './export.errors';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ExportService {\r\n  static ogreFormats = {\r\n    GML: 'gml',\r\n    GPX: 'gpx',\r\n    KML: 'kml',\r\n    Shapefile: 'ESRI Shapefile',\r\n    CSVcomma: 'CSVcomma',\r\n    CSVsemicolon: 'CSVsemicolon'\r\n  };\r\n\r\n  static noOgreFallbacks = ['GML', 'GPX', 'KML'];\r\n\r\n  private ogreUrl: string;\r\n  private aggregateInComment: boolean = true;\r\n\r\n  constructor(private config: ConfigService) {\r\n    this.ogreUrl = this.config.getConfig('importExport.url');\r\n    const gpxAggregateInComment = this.config.getConfig(\r\n      'importExport.gpxAggregateInComment'\r\n    );\r\n    if (gpxAggregateInComment !== undefined) {\r\n      this.aggregateInComment = gpxAggregateInComment;\r\n    }\r\n  }\r\n\r\n  export(\r\n    olFeatures: OlFeature<OlGeometry>[],\r\n    format: ExportFormat,\r\n    title: string,\r\n    encoding: EncodingFormat,\r\n    projectionIn = 'EPSG:4326',\r\n    projectionOut = 'EPSG:4326'\r\n  ): Observable<void> {\r\n    const exportOlFeatures = this.generateFeature(\r\n      olFeatures,\r\n      format,\r\n      '_featureStore'\r\n    );\r\n\r\n    return this.exportAsync(\r\n      exportOlFeatures,\r\n      format,\r\n      title,\r\n      encoding,\r\n      projectionIn,\r\n      projectionOut\r\n    );\r\n  }\r\n\r\n  public generateFeature(\r\n    olFeatures: OlFeature<OlGeometry>[],\r\n    format: ExportFormat,\r\n    excludePrefix: string = '_'\r\n  ): OlFeature<OlGeometry>[] {\r\n    if (format === ExportFormat.GPX && this.aggregateInComment) {\r\n      return this.generateAggregatedFeature(olFeatures);\r\n    }\r\n\r\n    return olFeatures.map((olFeature: OlFeature<OlGeometry>) => {\r\n      const keys = olFeature\r\n        .getKeys()\r\n        .filter((key: string) => !key.startsWith(excludePrefix));\r\n      const properties = keys.reduce(\r\n        (acc: object, key: string) => {\r\n          acc[key] = olFeature.get(key);\r\n          return acc;\r\n        },\r\n        { geometry: olFeature.getGeometry() }\r\n      );\r\n      return new OlFeature(properties);\r\n    });\r\n  }\r\n\r\n  private generateAggregatedFeature(\r\n    olFeatures: OlFeature<OlGeometry>[]\r\n  ): OlFeature<OlGeometry>[] {\r\n    return olFeatures.map((olFeature: OlFeature<OlGeometry>) => {\r\n      const keys = olFeature\r\n        .getKeys()\r\n        .filter((key: string) => !key.startsWith('_'));\r\n      let comment: string = '';\r\n      const properties = keys.reduce(\r\n        (acc: object, key: string) => {\r\n          if (key && key !== 'geometry') {\r\n            key === 'id' && olFeature.get('draw')\r\n              ? (comment += key + ':' + olFeature.get('draw') + '   \\r\\n')\r\n              : (comment += key + ':' + olFeature.get(key) + '   \\r\\n');\r\n          }\r\n          acc[key] = olFeature.get(key);\r\n          return acc;\r\n        },\r\n        {\r\n          geometry: olFeature.getGeometry()\r\n        }\r\n      );\r\n      const newFeature = new OlFeature(properties);\r\n      newFeature.set('name', olFeature.getId());\r\n      newFeature.set('cmt', comment);\r\n\r\n      return newFeature;\r\n    });\r\n  }\r\n\r\n  private exportAsync(\r\n    olFeatures: OlFeature<OlGeometry>[],\r\n    format: ExportFormat,\r\n    title: string,\r\n    encoding: EncodingFormat,\r\n    projectionIn: string,\r\n    projectionOut: string\r\n  ): Observable<void> {\r\n    const doExport = (observer: Observer<void>) => {\r\n      const nothingToExport = this.nothingToExport(olFeatures, format);\r\n      if (nothingToExport) {\r\n        observer.error(new ExportNothingToExportError());\r\n        return;\r\n      }\r\n\r\n      const ogreFormats = Object.keys(ExportService.ogreFormats);\r\n      if (ogreFormats.indexOf(format) >= 0) {\r\n        if (!this.ogreUrl) {\r\n          if (ExportService.noOgreFallbacks.indexOf(format) >= 0) {\r\n            this.exportToFile(\r\n              olFeatures,\r\n              observer,\r\n              format,\r\n              title,\r\n              projectionIn,\r\n              projectionOut\r\n            );\r\n          } else {\r\n            observer.error(new ExportInvalidFileError());\r\n          }\r\n          return;\r\n        }\r\n        this.exportWithOgre(\r\n          olFeatures,\r\n          observer,\r\n          format,\r\n          title,\r\n          encoding,\r\n          projectionIn,\r\n          projectionOut\r\n        );\r\n      } else {\r\n        this.exportToFile(\r\n          olFeatures,\r\n          observer,\r\n          format,\r\n          title,\r\n          projectionIn,\r\n          projectionOut\r\n        );\r\n      }\r\n    };\r\n\r\n    return new Observable(doExport);\r\n  }\r\n\r\n  protected exportToFile(\r\n    olFeatures: OlFeature<OlGeometry>[],\r\n    observer: Observer<void>,\r\n    format: ExportFormat,\r\n    title: string,\r\n    projectionIn: string,\r\n    projectionOut: string\r\n  ) {\r\n    const olFormat = new olformat[format]();\r\n    const featuresText = olFormat.writeFeatures(olFeatures, {\r\n      dataProjection: projectionOut,\r\n      featureProjection: projectionIn,\r\n      featureType: 'feature',\r\n      featureNS: 'http://example.com/feature'\r\n    });\r\n\r\n    const fileName = `${title}.${format.toLowerCase()}`;\r\n\r\n    downloadContent(featuresText, 'text/plain;charset=utf-8', fileName);\r\n    observer.complete();\r\n  }\r\n\r\n  private exportWithOgre(\r\n    olFeatures: OlFeature<OlGeometry>[],\r\n    observer: Observer<void>,\r\n    format: string,\r\n    title: string,\r\n    encodingType: EncodingFormat,\r\n    projectionIn: string,\r\n    projectionOut: string\r\n  ) {\r\n    let featuresText: string = new olformat.GeoJSON().writeFeatures(\r\n      olFeatures,\r\n      {\r\n        dataProjection: projectionOut,\r\n        featureProjection: projectionIn\r\n      }\r\n    );\r\n\r\n    const url = `${this.ogreUrl}/convertJson`;\r\n    const form = document.createElement('form');\r\n    form.style.display = 'none';\r\n    document.body.appendChild(form);\r\n    form.setAttribute('method', 'post');\r\n    form.setAttribute('target', '_blank');\r\n    form.setAttribute('action', url);\r\n\r\n    if (encodingType === EncodingFormat.UTF8) {\r\n      form.acceptCharset = 'UTF-8';\r\n      form.enctype = 'application/x-www-form-urlencoded; charset=utf-8;';\r\n    } else if (encodingType === EncodingFormat.LATIN1) {\r\n      const enctype = 'ISO-8859-1';\r\n      const featuresJson = JSON.parse(featuresText);\r\n      featuresJson.features.map((f) => {\r\n        const encodedProperties = String.fromCharCode.apply(\r\n          null,\r\n          encode(JSON.stringify(f.properties), { mode: 'replacement' })\r\n        );\r\n        f.properties = JSON.parse(encodedProperties);\r\n      });\r\n      featuresText = JSON.stringify(featuresJson);\r\n      const encoding = document.createElement('input');\r\n      encoding.setAttribute('type', 'hidden');\r\n      encoding.setAttribute('name', 'encoding');\r\n      encoding.setAttribute('value', enctype);\r\n      form.appendChild(encoding);\r\n    }\r\n\r\n    if (format === 'CSVsemicolon') {\r\n      const options = document.createElement('input');\r\n      options.setAttribute('type', 'hidden');\r\n      options.setAttribute('name', 'lco');\r\n      options.setAttribute('value', 'SEPARATOR=SEMICOLON');\r\n      form.appendChild(options);\r\n    }\r\n\r\n    const geojsonField = document.createElement('input');\r\n    geojsonField.setAttribute('type', 'hidden');\r\n    geojsonField.setAttribute('name', 'json');\r\n    geojsonField.setAttribute('value', featuresText);\r\n    form.appendChild(geojsonField);\r\n\r\n    const outputNameField = document.createElement('input');\r\n    let outputName =\r\n      format === 'Shapefile'\r\n        ? `${title}.zip`\r\n        : `${title}.${format.toLowerCase()}`;\r\n    if (format === 'CSVcomma' || format === 'CSVsemicolon') {\r\n      outputName = `${title}.csv`;\r\n    }\r\n    outputName = outputName.replace(' ', '_');\r\n    outputName = outputName\r\n      .normalize('NFD')\r\n      .replace(/[\\u0300-\\u036f]/g, '')\r\n      .replace(/’/g, \"'\");\r\n    outputNameField.setAttribute('type', 'hidden');\r\n    outputNameField.setAttribute('name', 'outputName');\r\n    outputNameField.setAttribute('value', outputName);\r\n    form.appendChild(outputNameField);\r\n\r\n    let ogreFormat = ExportService.ogreFormats[format];\r\n    if (format === 'CSVcomma' || format === 'CSVsemicolon') {\r\n      ogreFormat = 'CSV';\r\n    }\r\n    const outputFormatField = document.createElement('input');\r\n    outputFormatField.setAttribute('type', 'hidden');\r\n    outputFormatField.setAttribute('name', 'format');\r\n    outputFormatField.setAttribute('value', ogreFormat);\r\n    form.appendChild(outputFormatField);\r\n\r\n    form.submit();\r\n    document.body.removeChild(form);\r\n\r\n    observer.complete();\r\n  }\r\n\r\n  private nothingToExport(\r\n    olFeatures: OlFeature<OlGeometry>[],\r\n    format: string\r\n  ): boolean {\r\n    if (olFeatures.length === 0) {\r\n      return true;\r\n    }\r\n    if (format === 'GPX') {\r\n      const pointOrLine = olFeatures.find((olFeature) => {\r\n        return (\r\n          ['Point', 'LineString', 'MultiLineString'].indexOf(\r\n            olFeature.getGeometry().getType()\r\n          ) >= 0\r\n        );\r\n      });\r\n      return pointOrLine === undefined;\r\n    }\r\n    return false;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/import-export/shared/export.type.mjs

@@ -0,0 +1,13 @@
+import { strEnum } from '@igo2/utils';
+export const ExportFormat = strEnum([
+    'URL',
+    'GeoJSON',
+    'GML',
+    'GPX',
+    'KML',
+    'Shapefile',
+    'CSVcomma',
+    'CSVsemicolon'
+]);
+export const EncodingFormat = strEnum(['UTF8', 'LATIN1']);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9pbXBvcnQtZXhwb3J0L3NoYXJlZC9leHBvcnQudHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRXRDLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUM7SUFDbEMsS0FBSztJQUNMLFNBQVM7SUFDVCxLQUFLO0lBQ0wsS0FBSztJQUNMLEtBQUs7SUFDTCxXQUFXO0lBQ1gsVUFBVTtJQUNWLGNBQWM7Q0FDZixDQUFDLENBQUM7QUFHSCxNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsT0FBTyxDQUFDLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzdHJFbnVtIH0gZnJvbSAnQGlnbzIvdXRpbHMnO1xyXG5cclxuZXhwb3J0IGNvbnN0IEV4cG9ydEZvcm1hdCA9IHN0ckVudW0oW1xyXG4gICdVUkwnLFxyXG4gICdHZW9KU09OJyxcclxuICAnR01MJyxcclxuICAnR1BYJyxcclxuICAnS01MJyxcclxuICAnU2hhcGVmaWxlJyxcclxuICAnQ1NWY29tbWEnLFxyXG4gICdDU1ZzZW1pY29sb24nXHJcbl0pO1xyXG5leHBvcnQgdHlwZSBFeHBvcnRGb3JtYXQgPSBrZXlvZiB0eXBlb2YgRXhwb3J0Rm9ybWF0O1xyXG5cclxuZXhwb3J0IGNvbnN0IEVuY29kaW5nRm9ybWF0ID0gc3RyRW51bShbJ1VURjgnLCAnTEFUSU4xJ10pO1xyXG5leHBvcnQgdHlwZSBFbmNvZGluZ0Zvcm1hdCA9IGtleW9mIHR5cGVvZiBFbmNvZGluZ0Zvcm1hdDtcclxuIl19