@hpcc-js/map 3.4.10 → 3.4.11

package/src/leaflet/Pins.ts

@@ -1,73 +1,73 @@
-import { BeautifyIcon, Map } from "./leaflet-shim.ts";
-import { Markers } from "./Markers.ts";
-
-export class Pins extends Markers {
-
-    constructor(cluster = false) {
-        super(cluster);
-    }
-
-    layerUpdate(map: Map) {
-        const columns = this.columns();
-        const faCharIdx = columns.indexOf(this.faCharColumn());
-        const faCharColorIdx = columns.indexOf(this.faCharColorColumn());
-        const strokeColorIdx = columns.indexOf(this.strokeColorColumn());
-        const fillColorIdx = columns.indexOf(this.fillColorColumn());
-        super.layerUpdate(map, (row) => {
-            return {
-                icon: BeautifyIcon({
-                    iconShape: "marker",
-                    icon: this.propValue(faCharIdx, row, this.faChar()),
-                    textColor: this.propValue(faCharColorIdx, row, this.faCharColor()),
-                    borderColor: this.propValue(strokeColorIdx, row, this.strokeColor()),
-                    backgroundColor: this.propValue(fillColorIdx, row, this.fillColor()),
-                    props: {
-                        owner: this,
-                        row
-                    }
-                }),
-                draggable: false
-            };
-        });
-    }
-}
-Pins.prototype._class += " map_Pins";
-
-export interface Pins {
-    faChar(): string;
-    faChar(_: string);
-    faCharColumn(): string;
-    faCharColumn(_: string);
-    faCharColumn_exists(): boolean;
-    faCharColor(): string;
-    faCharColor(_: string);
-    faCharColorColumn(): string;
-    faCharColorColumn(_: string);
-    faCharColorColumn_exists(): boolean;
-    strokeColor(): string;
-    strokeColor(_: string);
-    strokeColorColumn(): string;
-    strokeColorColumn(_: string);
-    strokColorColumn_exists(): boolean;
-    fillColor(): string;
-    fillColor(_: string);
-    fillColorColumn(): string;
-    fillColorColumn(_: string);
-    fillColorColumn_exists(): boolean;
-}
-
-Pins.prototype.publish("faChar", "fa-circle", "string", "Default font awesome character");
-Pins.prototype.publish("faCharColumn", null, "set", "Font awesome column", function () { return this.columns(); }, { optional: true });
-Pins.prototype.publish("faCharColor", "#ffffff", "html-color", "Default  font awesome Color");
-Pins.prototype.publish("faCharColorColumn", null, "set", "Font awesome color column", function () { return this.columns(); }, { optional: true });
-Pins.prototype.publish("strokeColor", "transparent", "html-color", "Default stroke Color", null, { optional: true });
-Pins.prototype.publish("strokeColorColumn", null, "set", "Stroke color column", function () { return this.columns(); }, { optional: true });
-Pins.prototype.publish("fillColor", "#376cea", "html-color", "Default fill Color", null, { optional: true });
-Pins.prototype.publish("fillColorColumn", null, "set", "Fill color column", function () { return this.columns(); }, { optional: true });
-
-export class ClusterPins extends Pins {
-    constructor() {
-        super(true);
-    }
-}
-ClusterPins.prototype._class += " map_ClusterPins";
+import { BeautifyIcon, Map } from "./leaflet-shim.ts";
+import { Markers } from "./Markers.ts";
+
+export class Pins extends Markers {
+
+    constructor(cluster = false) {
+        super(cluster);
+    }
+
+    layerUpdate(map: Map) {
+        const columns = this.columns();
+        const faCharIdx = columns.indexOf(this.faCharColumn());
+        const faCharColorIdx = columns.indexOf(this.faCharColorColumn());
+        const strokeColorIdx = columns.indexOf(this.strokeColorColumn());
+        const fillColorIdx = columns.indexOf(this.fillColorColumn());
+        super.layerUpdate(map, (row) => {
+            return {
+                icon: BeautifyIcon({
+                    iconShape: "marker",
+                    icon: this.propValue(faCharIdx, row, this.faChar()),
+                    textColor: this.propValue(faCharColorIdx, row, this.faCharColor()),
+                    borderColor: this.propValue(strokeColorIdx, row, this.strokeColor()),
+                    backgroundColor: this.propValue(fillColorIdx, row, this.fillColor()),
+                    props: {
+                        owner: this,
+                        row
+                    }
+                }),
+                draggable: false
+            };
+        });
+    }
+}
+Pins.prototype._class += " map_Pins";
+
+export interface Pins {
+    faChar(): string;
+    faChar(_: string);
+    faCharColumn(): string;
+    faCharColumn(_: string);
+    faCharColumn_exists(): boolean;
+    faCharColor(): string;
+    faCharColor(_: string);
+    faCharColorColumn(): string;
+    faCharColorColumn(_: string);
+    faCharColorColumn_exists(): boolean;
+    strokeColor(): string;
+    strokeColor(_: string);
+    strokeColorColumn(): string;
+    strokeColorColumn(_: string);
+    strokColorColumn_exists(): boolean;
+    fillColor(): string;
+    fillColor(_: string);
+    fillColorColumn(): string;
+    fillColorColumn(_: string);
+    fillColorColumn_exists(): boolean;
+}
+
+Pins.prototype.publish("faChar", "fa-circle", "string", "Default font awesome character");
+Pins.prototype.publish("faCharColumn", null, "set", "Font awesome column", function () { return this.columns(); }, { optional: true });
+Pins.prototype.publish("faCharColor", "#ffffff", "html-color", "Default  font awesome Color");
+Pins.prototype.publish("faCharColorColumn", null, "set", "Font awesome color column", function () { return this.columns(); }, { optional: true });
+Pins.prototype.publish("strokeColor", "transparent", "html-color", "Default stroke Color", null, { optional: true });
+Pins.prototype.publish("strokeColorColumn", null, "set", "Stroke color column", function () { return this.columns(); }, { optional: true });
+Pins.prototype.publish("fillColor", "#376cea", "html-color", "Default fill Color", null, { optional: true });
+Pins.prototype.publish("fillColorColumn", null, "set", "Fill color column", function () { return this.columns(); }, { optional: true });
+
+export class ClusterPins extends Pins {
+    constructor() {
+        super(true);
+    }
+}
+ClusterPins.prototype._class += " map_ClusterPins";

package/src/leaflet/Polygons.ts

@@ -1,113 +1,113 @@
-import { extent as d3Extent, Palette } from "@hpcc-js/common";
-import { LeafletEvent, Map, Polygon } from "./leaflet-shim.ts";
-import { FeatureLayer } from "./FeatureLayer.ts";
-
-function lngLat2LatLng(d: [number, number]): [number, number] {
-    return [d[1], d[0]];
-}
-
-type Lat = number;
-type Lon = number;
-type Point = [Lon, Lat];
-
-type Spread = [number, number];
-const calcSpread = (prev: Spread, p: Point): Spread => {
-    if (p[0] < -90) prev[0]++;
-    else if (p[0] > 90) prev[1]++;
-    return prev;
-};
-
-const shiftLeft = (lng: number): number => lng > 90 ? lng - 360 : lng;
-const shiftRight = (lng: number): number => lng < -90 ? lng + 360 : lng;
-const shiftPoint = (left: boolean): (p: Point) => Point => {
-    const shiftFunc = left ? shiftLeft : shiftRight;
-    return (p: Point) => [shiftFunc(p[0]), p[1]];
-};
-
-export class Polygons extends FeatureLayer {
-
-    _palette;
-
-    protected fixDateLine(points: Point[]): Point[] {
-        const [lhsCount, rhsCount] = points.reduce(calcSpread, [0, 0]);
-        if (lhsCount && rhsCount) {
-            return points.map(shiftPoint(lhsCount > rhsCount));
-        }
-        return points;
-    }
-
-    hasBounds(): boolean {
-        return true;
-    }
-
-    updateHexagons() {
-        this._palette = this._palette.switch(this.paletteID());
-        if (this.useClonedPalette()) {
-            this._palette = this._palette.cloneNotExists(this.paletteID() + "_" + this.id());
-        }
-
-        const polyFunc = this.cellFunc(this.polygonColumn(), []);
-        const weightFunc = this.cellFunc(this.weightColumn(), 0);
-
-        const data = this.data();
-
-        const extent = d3Extent(data, weightFunc);
-
-        this.clear();
-        data.forEach(row => {
-            this.add(new Polygon(this.fixDateLine(polyFunc(row)).map(lngLat2LatLng), {
-                color: this._palette(extent[1], extent[0], extent[1]),
-                fillColor: this._palette(weightFunc(row), extent[0], extent[1]),
-                fillOpacity: this.opacity(),
-                weight: 1,
-                origRow: row
-            } as any).on("click", e => this.clickHandler(e, row)));
-        });
-    }
-
-    layerUpdate(map: Map) {
-        super.layerUpdate(map);
-        this.updateHexagons();
-    }
-
-    //  Events  ---
-    zoomEnd(e: LeafletEvent) {
-        super.zoomEnd(e);
-        // this.updateHexagons();
-    }
-
-    moveEnd(e: LeafletEvent) {
-        super.moveEnd(e);
-        this.updateHexagons();
-    }
-
-    clickHandler(e, row) {
-    }
-}
-Polygons.prototype._class += " map_Polygons";
-Polygons.prototype._palette = Palette.rainbow("default");
-
-export interface Polygons {
-    paletteID(): string;
-    paletteID(_: string): this;
-    paletteID_exists(): boolean;
-    useClonedPalette(): boolean;
-    useClonedPalette(_: boolean): this;
-    useClonedPalette_exists(): boolean;
-
-    polygonColumn(): string;
-    polygonColumn(_: string): this;
-    weightColumn(): string;
-    weightColumn(_: string): this;
-
-    opacity(): number;
-    opacity(_: number): this;
-    opacity_default(_: number): this;
-    opacity_exists(): boolean;
-}
-
-Polygons.prototype.publish("paletteID", "YlOrRd", "set", "Color palette for this widget", Polygons.prototype._palette.switch(), { tags: ["Basic", "Shared"] });
-Polygons.prototype.publish("useClonedPalette", false, "boolean", "Enable or disable using a cloned palette", null, { tags: ["Intermediate", "Shared"] });
-Polygons.prototype.publish("polygonColumn", null, "set", "Polygon column", function () { return this.columns(); }, { optional: true });
-Polygons.prototype.publish("weightColumn", null, "set", "Weight column", function () { return this.columns(); }, { optional: true });
-Polygons.prototype.publish("opacity", 0.5, "number", "Opacity", null, { tags: ["Advanced"] });
+import { extent as d3Extent, Palette } from "@hpcc-js/common";
+import { LeafletEvent, Map, Polygon } from "./leaflet-shim.ts";
+import { FeatureLayer } from "./FeatureLayer.ts";
+
+function lngLat2LatLng(d: [number, number]): [number, number] {
+    return [d[1], d[0]];
+}
+
+type Lat = number;
+type Lon = number;
+type Point = [Lon, Lat];
+
+type Spread = [number, number];
+const calcSpread = (prev: Spread, p: Point): Spread => {
+    if (p[0] < -90) prev[0]++;
+    else if (p[0] > 90) prev[1]++;
+    return prev;
+};
+
+const shiftLeft = (lng: number): number => lng > 90 ? lng - 360 : lng;
+const shiftRight = (lng: number): number => lng < -90 ? lng + 360 : lng;
+const shiftPoint = (left: boolean): (p: Point) => Point => {
+    const shiftFunc = left ? shiftLeft : shiftRight;
+    return (p: Point) => [shiftFunc(p[0]), p[1]];
+};
+
+export class Polygons extends FeatureLayer {
+
+    _palette;
+
+    protected fixDateLine(points: Point[]): Point[] {
+        const [lhsCount, rhsCount] = points.reduce(calcSpread, [0, 0]);
+        if (lhsCount && rhsCount) {
+            return points.map(shiftPoint(lhsCount > rhsCount));
+        }
+        return points;
+    }
+
+    hasBounds(): boolean {
+        return true;
+    }
+
+    updateHexagons() {
+        this._palette = this._palette.switch(this.paletteID());
+        if (this.useClonedPalette()) {
+            this._palette = this._palette.cloneNotExists(this.paletteID() + "_" + this.id());
+        }
+
+        const polyFunc = this.cellFunc(this.polygonColumn(), []);
+        const weightFunc = this.cellFunc(this.weightColumn(), 0);
+
+        const data = this.data();
+
+        const extent = d3Extent(data, weightFunc);
+
+        this.clear();
+        data.forEach(row => {
+            this.add(new Polygon(this.fixDateLine(polyFunc(row)).map(lngLat2LatLng), {
+                color: this._palette(extent[1], extent[0], extent[1]),
+                fillColor: this._palette(weightFunc(row), extent[0], extent[1]),
+                fillOpacity: this.opacity(),
+                weight: 1,
+                origRow: row
+            } as any).on("click", e => this.clickHandler(e, row)));
+        });
+    }
+
+    layerUpdate(map: Map) {
+        super.layerUpdate(map);
+        this.updateHexagons();
+    }
+
+    //  Events  ---
+    zoomEnd(e: LeafletEvent) {
+        super.zoomEnd(e);
+        // this.updateHexagons();
+    }
+
+    moveEnd(e: LeafletEvent) {
+        super.moveEnd(e);
+        this.updateHexagons();
+    }
+
+    clickHandler(e, row) {
+    }
+}
+Polygons.prototype._class += " map_Polygons";
+Polygons.prototype._palette = Palette.rainbow("default");
+
+export interface Polygons {
+    paletteID(): string;
+    paletteID(_: string): this;
+    paletteID_exists(): boolean;
+    useClonedPalette(): boolean;
+    useClonedPalette(_: boolean): this;
+    useClonedPalette_exists(): boolean;
+
+    polygonColumn(): string;
+    polygonColumn(_: string): this;
+    weightColumn(): string;
+    weightColumn(_: string): this;
+
+    opacity(): number;
+    opacity(_: number): this;
+    opacity_default(_: number): this;
+    opacity_exists(): boolean;
+}
+
+Polygons.prototype.publish("paletteID", "YlOrRd", "set", "Color palette for this widget", Polygons.prototype._palette.switch(), { tags: ["Basic", "Shared"] });
+Polygons.prototype.publish("useClonedPalette", false, "boolean", "Enable or disable using a cloned palette", null, { tags: ["Intermediate", "Shared"] });
+Polygons.prototype.publish("polygonColumn", null, "set", "Polygon column", function () { return this.columns(); }, { optional: true });
+Polygons.prototype.publish("weightColumn", null, "set", "Weight column", function () { return this.columns(); }, { optional: true });
+Polygons.prototype.publish("opacity", 0.5, "number", "Opacity", null, { tags: ["Advanced"] });

package/src/leaflet/Region.ts

@@ -1,138 +1,138 @@
-import { json as d3Json } from "d3-request";
-import * as topojson from "topojson-client";
-import { topoJsonFolder } from "../Choropleth.ts";
-import { World } from "./World.ts";
-
-const topo_indexes = {
-    "GB": ["administrative_area_level_3", "administrative_area_level_2", "administrative_area_level_1"],
-    "IE": ["administrative_area_level_2", "administrative_area_level_1"],
-    "ND": ["administrative_area_level_2", "administrative_area_level_1"]
-};
-
-type NameCodes = { [name: string]: { code: any, codes: any[] } };
-type CodeNames = { [code: string]: { name: string, score: number, names: string[] } };
-type CachedItem = { topology: any, nameIdx: NameCodes, codeIdx: CodeNames };
-const _cachedRegion: { [id: string]: CachedItem } = {};
-function cachedRegion(id: string): CachedItem {
-    if (!_cachedRegion[id]) {
-        _cachedRegion[id] = {
-            topology: undefined,
-            nameIdx: {},
-            codeIdx: {}
-        };
-    }
-    return _cachedRegion[id];
-}
-
-export class Region extends World {
-
-    constructor() {
-        super();
-    }
-
-    protected fetchTopo(regionID: string) {
-        if (cachedRegion(regionID).topology) {
-            return Promise.resolve(cachedRegion(regionID).topology);
-        }
-        return new Promise((resolve, reject) => {
-            d3Json(`${topoJsonFolder()}/${regionID}.json`, function (region) {
-                cachedRegion(regionID).topology = region;
-                resolve(region);
-            });
-        });
-    }
-
-    protected fetchTopoIdx(regionID: string) {
-        for (const _key in cachedRegion(regionID).nameIdx) {
-            return Promise.resolve(cachedRegion(regionID).nameIdx);
-        }
-        return new Promise((resolve, reject) => {
-            d3Json(`${topoJsonFolder()}/${regionID}_idx.json`, function (index) {
-                const { nameIdx, codeIdx } = cachedRegion(regionID);
-                topo_indexes[regionID]?.forEach(level => {
-                    for (const name in index[level]) {
-                        const codes = index[level][name];
-                        if (Array.isArray(codes)) {
-                            if (!nameIdx[name]) {
-                                nameIdx[name] = { code: undefined, codes: [] };
-                            }
-                            nameIdx[name].codes = nameIdx[name].codes.concat(codes);
-                            if (codes.length === 1) {
-                                nameIdx[name].code = nameIdx[name].codes[0];
-                            }
-                            codes.forEach(code => {
-                                if (!codeIdx[code]) {
-                                    codeIdx[code] = { name: undefined, score: 9999, names: [] };
-                                }
-                                if (codes.length <= codeIdx[code].score) {
-                                    codeIdx[code].name = name;
-                                    codeIdx[code].score = codes.length;
-                                }
-                                codeIdx[code].names.push(name);
-                            });
-                        }
-                    }
-                });
-                resolve(nameIdx);
-            });
-        });
-    }
-
-    updateDataMap(_?) {
-        const expandedRetVal = [];
-        const nameIdx = cachedRegion(this.region()).nameIdx;
-        _.forEach(row => {
-            const codes = nameIdx[row[0]]?.codes;
-            if (codes) {
-                codes?.forEach(code => {
-                    expandedRetVal.push([code, row[1], row]);
-                });
-            } else {
-                expandedRetVal.push([row[0], row[1], row]);
-            }
-        });
-        return super.updateDataMap(expandedRetVal);
-    }
-
-    _prevRegion: string;
-    init(): Promise<void> {
-        const regionID = this.region();
-        if (!this._initPromise || this._prevRegion !== regionID) {
-            this._prevRegion = regionID;
-            this._initPromise = Promise.all([
-                this.fetchTopo(regionID),
-                this.fetchTopoIdx(regionID)
-            ]).then(([region, index]: [any, any]) => {
-                this._features = topojson.feature(region, region.objects.PolbndA).features;
-                for (const key in this._features) {
-                    const code = this._features[key].id || key;
-                    this._features[key].properties.hpccID = code;
-                }
-                this.updateDataMap(this.data());
-            });
-        }
-        return this._initPromise;
-    }
-
-    tooltipHandler(l, featureID) {
-        const row = this._dataMap[featureID];
-        const codeIdx = cachedRegion(this.region()).codeIdx;
-        const value = row && row[1] || "";
-        const featureName = codeIdx[featureID]?.names.map(name => {
-            if (codeIdx[featureID]?.name === name) {
-                return `<u>${name}</u>`;
-            }
-            return name;
-        }).join(", ");
-        return this.tooltipText(this.rowToObj(row), `<b>${row && row[2][0] || featureName || featureID}</b>:  ${value}`);
-    }
-}
-Region.prototype._class += " map_Region";
-
-export interface Region {
-    region(): string;
-    region(_: string): this;
-}
-
-Region.prototype.publish("region", "GB", "set", "Region Data", ["AT", "BE", "BG", "BR", "CHLI", "CY", "CZ", "DE", "DK", "EE", "ES", "FI", "FR", "GB", "GE", "GR", "HR", "HU", "IE", "IS", "IT", "KS", "LT", "LU", "LV", "MD", "MK", "MT", "ND", "NL", "NO", "PL", "PT", "RO", "RS", "SE", "SI", "SK", "UA"]);
-
+import { json as d3Json } from "d3-request";
+import * as topojson from "topojson-client";
+import { topoJsonFolder } from "../Choropleth.ts";
+import { World } from "./World.ts";
+
+const topo_indexes = {
+    "GB": ["administrative_area_level_3", "administrative_area_level_2", "administrative_area_level_1"],
+    "IE": ["administrative_area_level_2", "administrative_area_level_1"],
+    "ND": ["administrative_area_level_2", "administrative_area_level_1"]
+};
+
+type NameCodes = { [name: string]: { code: any, codes: any[] } };
+type CodeNames = { [code: string]: { name: string, score: number, names: string[] } };
+type CachedItem = { topology: any, nameIdx: NameCodes, codeIdx: CodeNames };
+const _cachedRegion: { [id: string]: CachedItem } = {};
+function cachedRegion(id: string): CachedItem {
+    if (!_cachedRegion[id]) {
+        _cachedRegion[id] = {
+            topology: undefined,
+            nameIdx: {},
+            codeIdx: {}
+        };
+    }
+    return _cachedRegion[id];
+}
+
+export class Region extends World {
+
+    constructor() {
+        super();
+    }
+
+    protected fetchTopo(regionID: string) {
+        if (cachedRegion(regionID).topology) {
+            return Promise.resolve(cachedRegion(regionID).topology);
+        }
+        return new Promise((resolve, reject) => {
+            d3Json(`${topoJsonFolder()}/${regionID}.json`, function (region) {
+                cachedRegion(regionID).topology = region;
+                resolve(region);
+            });
+        });
+    }
+
+    protected fetchTopoIdx(regionID: string) {
+        for (const _key in cachedRegion(regionID).nameIdx) {
+            return Promise.resolve(cachedRegion(regionID).nameIdx);
+        }
+        return new Promise((resolve, reject) => {
+            d3Json(`${topoJsonFolder()}/${regionID}_idx.json`, function (index) {
+                const { nameIdx, codeIdx } = cachedRegion(regionID);
+                topo_indexes[regionID]?.forEach(level => {
+                    for (const name in index[level]) {
+                        const codes = index[level][name];
+                        if (Array.isArray(codes)) {
+                            if (!nameIdx[name]) {
+                                nameIdx[name] = { code: undefined, codes: [] };
+                            }
+                            nameIdx[name].codes = nameIdx[name].codes.concat(codes);
+                            if (codes.length === 1) {
+                                nameIdx[name].code = nameIdx[name].codes[0];
+                            }
+                            codes.forEach(code => {
+                                if (!codeIdx[code]) {
+                                    codeIdx[code] = { name: undefined, score: 9999, names: [] };
+                                }
+                                if (codes.length <= codeIdx[code].score) {
+                                    codeIdx[code].name = name;
+                                    codeIdx[code].score = codes.length;
+                                }
+                                codeIdx[code].names.push(name);
+                            });
+                        }
+                    }
+                });
+                resolve(nameIdx);
+            });
+        });
+    }
+
+    updateDataMap(_?) {
+        const expandedRetVal = [];
+        const nameIdx = cachedRegion(this.region()).nameIdx;
+        _.forEach(row => {
+            const codes = nameIdx[row[0]]?.codes;
+            if (codes) {
+                codes?.forEach(code => {
+                    expandedRetVal.push([code, row[1], row]);
+                });
+            } else {
+                expandedRetVal.push([row[0], row[1], row]);
+            }
+        });
+        return super.updateDataMap(expandedRetVal);
+    }
+
+    _prevRegion: string;
+    init(): Promise<void> {
+        const regionID = this.region();
+        if (!this._initPromise || this._prevRegion !== regionID) {
+            this._prevRegion = regionID;
+            this._initPromise = Promise.all([
+                this.fetchTopo(regionID),
+                this.fetchTopoIdx(regionID)
+            ]).then(([region, index]: [any, any]) => {
+                this._features = topojson.feature(region, region.objects.PolbndA).features;
+                for (const key in this._features) {
+                    const code = this._features[key].id || key;
+                    this._features[key].properties.hpccID = code;
+                }
+                this.updateDataMap(this.data());
+            });
+        }
+        return this._initPromise;
+    }
+
+    tooltipHandler(l, featureID) {
+        const row = this._dataMap[featureID];
+        const codeIdx = cachedRegion(this.region()).codeIdx;
+        const value = row && row[1] || "";
+        const featureName = codeIdx[featureID]?.names.map(name => {
+            if (codeIdx[featureID]?.name === name) {
+                return `<u>${name}</u>`;
+            }
+            return name;
+        }).join(", ");
+        return this.tooltipText(this.rowToObj(row), `<b>${row && row[2][0] || featureName || featureID}</b>:  ${value}`);
+    }
+}
+Region.prototype._class += " map_Region";
+
+export interface Region {
+    region(): string;
+    region(_: string): this;
+}
+
+Region.prototype.publish("region", "GB", "set", "Region Data", ["AT", "BE", "BG", "BR", "CHLI", "CY", "CZ", "DE", "DK", "EE", "ES", "FI", "FR", "GB", "GE", "GR", "HR", "HU", "IE", "IS", "IT", "KS", "LT", "LU", "LV", "MD", "MK", "MT", "ND", "NL", "NO", "PL", "PT", "RO", "RS", "SE", "SI", "SK", "UA"]);
+