@digitraffic/common 2022.10.5

package/src/utils/base64.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase64 = exports.decodeBase64ToAscii = void 0;
+/**
+ * Decode given string from base64 to ascii
+ * @param str string
+ */
+function decodeBase64ToAscii(str) {
+    return decodeBase64(str, 'ascii');
+}
+exports.decodeBase64ToAscii = decodeBase64ToAscii;
+/**
+ * Decode given string from base64 to given encoding
+ * @param str
+ * @param encoding
+ */
+function decodeBase64(str, encoding) {
+    return Buffer.from(str, 'base64').toString(encoding);
+}
+exports.decodeBase64 = decodeBase64;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZTY0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL2Jhc2U2NC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQTs7O0dBR0c7QUFDSCxTQUFnQixtQkFBbUIsQ0FBQyxHQUFXO0lBQzNDLE9BQU8sWUFBWSxDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUMsQ0FBQztBQUN0QyxDQUFDO0FBRkQsa0RBRUM7QUFFRDs7OztHQUlHO0FBQ0gsU0FBZ0IsWUFBWSxDQUFDLEdBQVcsRUFBRSxRQUF3QjtJQUM5RCxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLFFBQVEsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUN6RCxDQUFDO0FBRkQsb0NBRUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIERlY29kZSBnaXZlbiBzdHJpbmcgZnJvbSBiYXNlNjQgdG8gYXNjaWlcbiAqIEBwYXJhbSBzdHIgc3RyaW5nXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWNvZGVCYXNlNjRUb0FzY2lpKHN0cjogc3RyaW5nKSB7XG4gICAgcmV0dXJuIGRlY29kZUJhc2U2NChzdHIsICdhc2NpaScpO1xufVxuXG4vKipcbiAqIERlY29kZSBnaXZlbiBzdHJpbmcgZnJvbSBiYXNlNjQgdG8gZ2l2ZW4gZW5jb2RpbmdcbiAqIEBwYXJhbSBzdHJcbiAqIEBwYXJhbSBlbmNvZGluZ1xuICovXG5leHBvcnQgZnVuY3Rpb24gZGVjb2RlQmFzZTY0KHN0cjogc3RyaW5nLCBlbmNvZGluZzogQnVmZmVyRW5jb2RpbmcpIHtcbiAgICByZXR1cm4gQnVmZmVyLmZyb20oc3RyLCAnYmFzZTY0JykudG9TdHJpbmcoZW5jb2RpbmcpO1xufVxuIl19

package/src/utils/date-utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateFromIsoString = exports.countDiffInSeconds = exports.countDiffMs = void 0;
+/**
+ * Counts difference in milliseconds between dates.
+ * @param start
+ * @param end
+ */
+function countDiffMs(start, end) {
+    return end.getTime() - start.getTime();
+}
+exports.countDiffMs = countDiffMs;
+/**
+ * Counts difference in seconds between dates.
+ * @param start
+ * @param end
+ */
+function countDiffInSeconds(start, end) {
+    return countDiffMs(start, end) / 1000;
+}
+exports.countDiffInSeconds = countDiffInSeconds;
+/**
+ * Converts ISO 8601 date-time -string to Date object
+ * @param isoString to convert
+ */
+function dateFromIsoString(isoString) {
+    const parsed = new Date(isoString);
+    if (!(parsed instanceof Date) || isNaN(parsed.getTime())) {
+        throw new Error(`Invalid ISO-DATE -string: ${isoString}`);
+    }
+    return parsed;
+}
+exports.dateFromIsoString = dateFromIsoString;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS11dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9kYXRlLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBOzs7O0dBSUc7QUFDSCxTQUFnQixXQUFXLENBQUMsS0FBVyxFQUFFLEdBQVM7SUFDOUMsT0FBTyxHQUFHLENBQUMsT0FBTyxFQUFFLEdBQUcsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDO0FBQzNDLENBQUM7QUFGRCxrQ0FFQztBQUVEOzs7O0dBSUc7QUFDSCxTQUFnQixrQkFBa0IsQ0FBQyxLQUFXLEVBQUUsR0FBUztJQUNyRCxPQUFPLFdBQVcsQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLEdBQUMsSUFBSSxDQUFDO0FBQ3hDLENBQUM7QUFGRCxnREFFQztBQUVEOzs7R0FHRztBQUNILFNBQWdCLGlCQUFpQixDQUFDLFNBQWlCO0lBQy9DLE1BQU0sTUFBTSxHQUFHLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ25DLElBQUksQ0FBQyxDQUFDLE1BQU0sWUFBWSxJQUFJLENBQUMsSUFBSSxLQUFLLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFDLEVBQUU7UUFDdEQsTUFBTSxJQUFJLEtBQUssQ0FBQyw2QkFBNkIsU0FBUyxFQUFFLENBQUMsQ0FBQztLQUM3RDtJQUNELE9BQU8sTUFBTSxDQUFDO0FBQ2xCLENBQUM7QUFORCw4Q0FNQyIsInNvdXJjZXNDb250ZW50IjpbIlxuLyoqXG4gKiBDb3VudHMgZGlmZmVyZW5jZSBpbiBtaWxsaXNlY29uZHMgYmV0d2VlbiBkYXRlcy5cbiAqIEBwYXJhbSBzdGFydFxuICogQHBhcmFtIGVuZFxuICovXG5leHBvcnQgZnVuY3Rpb24gY291bnREaWZmTXMoc3RhcnQ6IERhdGUsIGVuZDogRGF0ZSk6IG51bWJlciB7XG4gICAgcmV0dXJuIGVuZC5nZXRUaW1lKCkgLSBzdGFydC5nZXRUaW1lKCk7XG59XG5cbi8qKlxuICogQ291bnRzIGRpZmZlcmVuY2UgaW4gc2Vjb25kcyBiZXR3ZWVuIGRhdGVzLlxuICogQHBhcmFtIHN0YXJ0XG4gKiBAcGFyYW0gZW5kXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjb3VudERpZmZJblNlY29uZHMoc3RhcnQ6IERhdGUsIGVuZDogRGF0ZSk6IG51bWJlciB7XG4gICAgcmV0dXJuIGNvdW50RGlmZk1zKHN0YXJ0LCBlbmQpLzEwMDA7XG59XG5cbi8qKlxuICogQ29udmVydHMgSVNPIDg2MDEgZGF0ZS10aW1lIC1zdHJpbmcgdG8gRGF0ZSBvYmplY3RcbiAqIEBwYXJhbSBpc29TdHJpbmcgdG8gY29udmVydFxuICovXG5leHBvcnQgZnVuY3Rpb24gZGF0ZUZyb21Jc29TdHJpbmcoaXNvU3RyaW5nOiBzdHJpbmcpOiBEYXRlIHtcbiAgICBjb25zdCBwYXJzZWQgPSBuZXcgRGF0ZShpc29TdHJpbmcpO1xuICAgIGlmICghKHBhcnNlZCBpbnN0YW5jZW9mIERhdGUpIHx8IGlzTmFOKHBhcnNlZC5nZXRUaW1lKCkpKSB7XG4gICAgICAgIHRocm93IG5ldyBFcnJvcihgSW52YWxpZCBJU08tREFURSAtc3RyaW5nOiAke2lzb1N0cmluZ31gKTtcbiAgICB9XG4gICAgcmV0dXJuIHBhcnNlZDtcbn1cbiJdfQ==

package/src/utils/geojson-types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoJsonLineString = exports.GeoJsonPoint = void 0;
+class GeoJsonPoint {
+    constructor(coordinates) {
+        this.type = "Point";
+        this.coordinates = coordinates;
+    }
+}
+exports.GeoJsonPoint = GeoJsonPoint;
+class GeoJsonLineString {
+    constructor(coordinates) {
+        this.type = "LineString";
+        this.coordinates = coordinates;
+    }
+}
+exports.GeoJsonLineString = GeoJsonLineString;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VvanNvbi10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9nZW9qc29uLXR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUtBLE1BQWEsWUFBWTtJQUlyQixZQUFZLFdBQXFCO1FBSHhCLFNBQUksR0FBRyxPQUFPLENBQUM7UUFJcEIsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7SUFDbkMsQ0FBQztDQUNKO0FBUEQsb0NBT0M7QUFFRCxNQUFhLGlCQUFpQjtJQUkxQixZQUFZLFdBQXVCO1FBSDFCLFNBQUksR0FBRyxZQUFZLENBQUM7UUFJekIsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7SUFDbkMsQ0FBQztDQUNKO0FBUEQsOENBT0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlb0pTT04gdHlwZXNcbiAqL1xuaW1wb3J0IHtMaW5lU3RyaW5nLCBQb2ludCwgUG9zaXRpb259IGZyb20gXCJnZW9qc29uXCI7XG5cbmV4cG9ydCBjbGFzcyBHZW9Kc29uUG9pbnQgaW1wbGVtZW50cyBQb2ludCB7XG4gICAgcmVhZG9ubHkgdHlwZSA9IFwiUG9pbnRcIjtcbiAgICByZWFkb25seSBjb29yZGluYXRlczogUG9zaXRpb247XG5cbiAgICBjb25zdHJ1Y3Rvcihjb29yZGluYXRlczogUG9zaXRpb24pIHtcbiAgICAgICAgdGhpcy5jb29yZGluYXRlcyA9IGNvb3JkaW5hdGVzO1xuICAgIH1cbn1cblxuZXhwb3J0IGNsYXNzIEdlb0pzb25MaW5lU3RyaW5nIGltcGxlbWVudHMgTGluZVN0cmluZyB7XG4gICAgcmVhZG9ubHkgdHlwZSA9IFwiTGluZVN0cmluZ1wiO1xuICAgIHJlYWRvbmx5IGNvb3JkaW5hdGVzOiBQb3NpdGlvbltdO1xuXG4gICAgY29uc3RydWN0b3IoY29vcmRpbmF0ZXM6IFBvc2l0aW9uW10pIHtcbiAgICAgICAgdGhpcy5jb29yZGluYXRlcyA9IGNvb3JkaW5hdGVzO1xuICAgIH1cbn1cbiJdfQ==

package/src/utils/geometry.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.positionToList = exports.createGmlLineString = exports.distanceBetweenPositionsInM = exports.areDistinctPositions = exports.distanceBetweenPositionsInKm = exports.isFeatureCollection = exports.isValidGeoJson = exports.createFeatureCollection = exports.createGeometry = exports.SRID_WGS84 = void 0;
+exports.SRID_WGS84 = 4326;
+/**
+ * Creates WKT geometry from GeoJSON geometry
+ * @param geometry GeoJson geometry to convert to WKT
+ */
+function createGeometry(geometry) {
+    if (geometry.type === 'LineString') {
+        const coordinates = linestring(geometry.coordinates);
+        return `LINESTRING(${coordinates})`;
+    }
+    else if (geometry.type === 'Point') {
+        const coordinates = coordinatePair(geometry.coordinates);
+        return `POINT(${coordinates})`;
+    }
+    else if (geometry.type === 'Polygon') {
+        const coordinates = polygon(geometry.coordinates);
+        return `POLYGON(${coordinates})`;
+    }
+    else if (geometry.type === 'MultiPolygon') {
+        const coordinates = multiPolygon(geometry.coordinates);
+        return `MULTIPOLYGON(${coordinates})`;
+    }
+    console.error("unsupported locationType=%s", geometry.type);
+    return "POLYGON EMPTY";
+}
+exports.createGeometry = createGeometry;
+function linestring(coordinates) {
+    return coordinates.map((c) => coordinatePair(c)).join(',');
+}
+function polygon(coordinates) {
+    const list = coordinates.map((c) => linestring(c)).join(',');
+    return `(${list})`;
+}
+function multiPolygon(coordinates) {
+    const list = coordinates.map((c) => polygon(c)).join(',');
+    return `(${list})`;
+}
+function coordinatePair(coordinate) {
+    return `${coordinate[0]} ${coordinate[1]}`;
+}
+/**
+ * Create a GeoJSON FeatureCollection from a list of GeoJSON features with a 'last updated' property
+ * @param features List of Features
+ * @param lastUpdated Last updated date
+ */
+function createFeatureCollection(features, lastUpdated) {
+    return {
+        type: "FeatureCollection",
+        lastUpdated: lastUpdated,
+        features: features,
+    };
+}
+exports.createFeatureCollection = createFeatureCollection;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const geoJsonValidator = require('geojson-validation');
+function isValidGeoJson(json) {
+    return geoJsonValidator.valid(json);
+}
+exports.isValidGeoJson = isValidGeoJson;
+function isFeatureCollection(json) {
+    return geoJsonValidator.isFeatureCollection(json);
+}
+exports.isFeatureCollection = isFeatureCollection;
+const DEGREES_TO_RADIANS = 0.017453292519943295; // = Math.PI / 180
+const EARTH_RADIUS_KM = 6371;
+/**
+ * Returns the distance between this and given GeoJSON point in kilometers. Doesn't take in account altitude.
+ * Based on the following Stack Overflow question:
+ * http://stackoverflow.com/questions/27928/calculate-distance-between-two-latitude-longitude-points-haversine-formula,
+ * which is based on https://en.wikipedia.org/wiki/Haversine_formula (error rate: ~0.55%).
+ */
+function distanceBetweenWGS84PointsInKm(fromXLon, fromYLat, toXLon, toYLat) {
+    const diffLat = toRadians(toYLat - fromYLat);
+    const diffLon = toRadians(toXLon - fromXLon);
+    const a = Math.sin(diffLat / 2) * Math.sin(diffLat / 2) +
+        Math.cos(toRadians(fromYLat)) * Math.cos(toRadians(toYLat)) *
+            Math.sin(diffLon / 2) * Math.sin(diffLon / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return EARTH_RADIUS_KM * c;
+}
+/**
+ * Calculates distance between two GeoJSON points (WGS84)
+ * @param pos1
+ * @param pos2
+ */
+function distanceBetweenPositionsInKm(pos1, pos2) {
+    return distanceBetweenWGS84PointsInKm(pos1[0], pos1[1], pos2[0], pos2[1]);
+}
+exports.distanceBetweenPositionsInKm = distanceBetweenPositionsInKm;
+function areDistinctPositions(previous, next) {
+    return previous[0] !== next[0] || previous[1] !== next[1];
+}
+exports.areDistinctPositions = areDistinctPositions;
+/**
+ * Calculates distance between two GeoJSON points (WGS84)
+ * @param pos1
+ * @param pos2
+ */
+function distanceBetweenPositionsInM(pos1, pos2) {
+    return distanceBetweenPositionsInKm(pos1, pos2) * 1000; // km -> m
+}
+exports.distanceBetweenPositionsInM = distanceBetweenPositionsInM;
+function createGmlLineString(geometry, srsName = 'EPSG:4326') {
+    const posList = createPosList(geometry);
+    return {
+        srsName,
+        posList,
+    };
+}
+exports.createGmlLineString = createGmlLineString;
+function createPosList(geometry) {
+    if (geometry.type === 'Point') {
+        return positionToList(geometry.coordinates);
+    }
+    else if (geometry.type === 'LineString') {
+        return lineStringToList(geometry.coordinates);
+    }
+    else if (geometry.type === 'Polygon') {
+        return polygonToList(geometry.coordinates);
+    }
+    throw new Error("unknown geometry type " + JSON.stringify(geometry));
+}
+function polygonToList(positions, precision = 8) {
+    return positions.map(p => lineStringToList(p, precision)).join(' ');
+}
+function lineStringToList(positions, precision = 8) {
+    return positions.map(p => positionToList(p, precision)).join(' ');
+}
+function positionToList(position, precision = 8) {
+    return position.map(n => n.toPrecision(precision)).join(' ');
+}
+exports.positionToList = positionToList;
+// Converts numeric degrees to radians
+function toRadians(angdeg) {
+    return angdeg * DEGREES_TO_RADIANS;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../../src/utils/geometry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * GeoJSON functions and tools\r\n */\r\nimport {Feature, FeatureCollection, Geometry, Position} from \"geojson\";\r\n\r\nexport const SRID_WGS84 = 4326;\r\n\r\n/**\r\n * Creates WKT geometry from GeoJSON geometry\r\n * @param geometry GeoJson geometry to convert to WKT\r\n */\r\nexport function createGeometry(geometry: Geometry): string {\r\n    if (geometry.type === 'LineString') {\r\n        const coordinates = linestring(geometry.coordinates);\r\n\r\n        return `LINESTRING(${coordinates})`;\r\n    } else if (geometry.type === 'Point') {\r\n        const coordinates = coordinatePair(geometry.coordinates);\r\n\r\n        return `POINT(${coordinates})`;\r\n    } else if (geometry.type === 'Polygon') {\r\n        const coordinates = polygon(geometry.coordinates);\r\n\r\n        return `POLYGON(${coordinates})`;\r\n    } else if (geometry.type === 'MultiPolygon') {\r\n        const coordinates = multiPolygon(geometry.coordinates);\r\n\r\n        return `MULTIPOLYGON(${coordinates})`;\r\n    }\r\n\r\n    console.error(\"unsupported locationType=%s\", geometry.type);\r\n    return \"POLYGON EMPTY\";\r\n}\r\n\r\nfunction linestring(coordinates: Position[]): string {\r\n    return coordinates.map((c: Position) =>  coordinatePair(c)).join(',');\r\n}\r\n\r\nfunction polygon(coordinates: Position[][]):string {\r\n    const list = coordinates.map((c: Position[]) => linestring(c)).join(',');\r\n    return `(${list})`;\r\n}\r\n\r\nfunction multiPolygon(coordinates: Position[][][]):string {\r\n    const list = coordinates.map((c: Position[][]) => polygon(c)).join(',');\r\n    return `(${list})`;\r\n}\r\n\r\nfunction coordinatePair(coordinate: Position): string {\r\n    return `${coordinate[0]} ${coordinate[1]}`;\r\n}\r\n\r\n/**\r\n * Create a GeoJSON FeatureCollection from a list of GeoJSON features with a 'last updated' property\r\n * @param features List of Features\r\n * @param lastUpdated Last updated date\r\n */\r\nexport function createFeatureCollection(features: Feature[], lastUpdated: Date | null): FeatureCollection {\r\n    return {\r\n        type: \"FeatureCollection\",\r\n        lastUpdated: lastUpdated,\r\n        features: features,\r\n    } as FeatureCollection;\r\n}\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-var-requires\r\nconst geoJsonValidator = require('geojson-validation');\r\n\r\nexport function isValidGeoJson<T>(json: T): boolean {\r\n    return geoJsonValidator.valid(json);\r\n}\r\n\r\nexport function isFeatureCollection<T>(json: T): boolean {\r\n    return geoJsonValidator.isFeatureCollection(json);\r\n}\r\n\r\nconst DEGREES_TO_RADIANS = 0.017453292519943295; // = Math.PI / 180\r\nconst EARTH_RADIUS_KM = 6371;\r\n\r\n\r\n/**\r\n * Returns the distance between this and given GeoJSON point in kilometers. Doesn't take in account altitude.\r\n * Based on the following Stack Overflow question:\r\n * http://stackoverflow.com/questions/27928/calculate-distance-between-two-latitude-longitude-points-haversine-formula,\r\n * which is based on https://en.wikipedia.org/wiki/Haversine_formula (error rate: ~0.55%).\r\n */\r\nfunction distanceBetweenWGS84PointsInKm(fromXLon:number, fromYLat:number, toXLon:number, toYLat:number): number  {\r\n\r\n    const diffLat = toRadians(toYLat - fromYLat);\r\n    const diffLon = toRadians(toXLon - fromXLon);\r\n\r\n    const a =\r\n        Math.sin(diffLat / 2) * Math.sin(diffLat / 2) +\r\n        Math.cos(toRadians(fromYLat)) * Math.cos(toRadians(toYLat)) *\r\n        Math.sin(diffLon / 2) * Math.sin(diffLon / 2);\r\n    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\r\n    return EARTH_RADIUS_KM * c;\r\n}\r\n\r\n/**\r\n * Calculates distance between two GeoJSON points (WGS84)\r\n * @param pos1\r\n * @param pos2\r\n */\r\nexport function distanceBetweenPositionsInKm(pos1: Position, pos2: Position) {\r\n    return distanceBetweenWGS84PointsInKm(pos1[0], pos1[1], pos2[0], pos2[1]);\r\n}\r\n\r\nexport function areDistinctPositions(previous: Position, next: Position) {\r\n    return previous[0] !== next[0] || previous[1] !== next[1];\r\n}\r\n\r\n/**\r\n * Calculates distance between two GeoJSON points (WGS84)\r\n * @param pos1\r\n * @param pos2\r\n */\r\nexport function distanceBetweenPositionsInM(pos1: Position, pos2: Position) {\r\n    return distanceBetweenPositionsInKm(pos1, pos2) * 1000; // km -> m\r\n}\r\n\r\nexport function createGmlLineString(geometry: Geometry, srsName = 'EPSG:4326') {\r\n    const posList = createPosList(geometry);\r\n\r\n    return {\r\n        srsName,\r\n        posList,\r\n    };\r\n}\r\n\r\nfunction createPosList(geometry: Geometry) {\r\n    if (geometry.type === 'Point') {\r\n        return positionToList(geometry.coordinates);\r\n    } else if (geometry.type === 'LineString') {\r\n        return lineStringToList(geometry.coordinates);\r\n    } else if (geometry.type === 'Polygon') {\r\n        return polygonToList(geometry.coordinates);\r\n    }\r\n\r\n    throw new Error(\"unknown geometry type \" + JSON.stringify(geometry));\r\n}\r\n\r\nfunction polygonToList(positions: Position[][], precision = 8) {\r\n    return positions.map(p => lineStringToList(p, precision)).join(' ');\r\n}\r\n\r\nfunction lineStringToList(positions: Position[], precision = 8) {\r\n    return positions.map(p => positionToList(p, precision)).join(' ');\r\n}\r\n\r\nexport function positionToList(position: Position, precision = 8) {\r\n    return position.map(n => n.toPrecision(precision)).join(' ');\r\n}\r\n\r\n// Converts numeric degrees to radians\r\nfunction toRadians(angdeg:number) {\r\n    return angdeg * DEGREES_TO_RADIANS;\r\n}\r\n"]}

package/src/utils/retry.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retry = exports.RetryLogError = void 0;
+var RetryLogError;
+(function (RetryLogError) {
+    RetryLogError[RetryLogError["LOG_ALL_AS_ERRORS"] = 0] = "LOG_ALL_AS_ERRORS";
+    RetryLogError[RetryLogError["LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS"] = 1] = "LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS";
+    RetryLogError[RetryLogError["NO_LOGGING"] = 2] = "NO_LOGGING";
+})(RetryLogError = exports.RetryLogError || (exports.RetryLogError = {}));
+/**
+ * Utility function for retrying async functions.
+ * @param asyncFn Function
+ * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
+ * @param logError Logging options
+ * @return Promise return value
+ */
+async function retry(asyncFn, retries = 3, logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS) {
+    if (!isFinite(retries)) {
+        throw new Error('Only finite numbers are supported');
+    }
+    if (retries > 100) {
+        throw new Error('Exceeded the maximum retry count of 100');
+    }
+    try {
+        return await asyncFn();
+    }
+    catch (error) {
+        const remainingRetries = retries - 1;
+        const errorMessage = 'method=retry error';
+        if (logError === RetryLogError.LOG_ALL_AS_ERRORS) {
+            console.error(errorMessage, error);
+        }
+        else if (logError === RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS) {
+            if (remainingRetries < 0) {
+                console.error(errorMessage, error);
+            }
+            else {
+                console.warn(errorMessage, error);
+            }
+        }
+        if (remainingRetries < 0) {
+            console.warn('method=retry no retries left');
+            throw new Error('No retries left');
+        }
+        console.warn('method=retry invocation failed, retrying with remaining retries %d', remainingRetries);
+        return retry(asyncFn, remainingRetries, logError);
+    }
+}
+exports.retry = retry;
+//# sourceMappingURL=data:application/json;base64,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

package/src/utils/slack.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackApi = void 0;
+const axios_1 = __importDefault(require("axios"));
+class SlackApi {
+    constructor(url) {
+        this.url = url;
+    }
+    async notify(text) {
+        try {
+            console.info('method=notify Notifying Slack');
+            await axios_1.default.post(this.url, {
+                text,
+            });
+        }
+        catch (error) {
+            console.error('method=notify Slack notify failed!');
+        }
+    }
+}
+exports.SlackApi = SlackApi;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvc2xhY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsa0RBQTBCO0FBRTFCLE1BQWEsUUFBUTtJQUlqQixZQUFZLEdBQVc7UUFDbkIsSUFBSSxDQUFDLEdBQUcsR0FBRyxHQUFHLENBQUM7SUFDbkIsQ0FBQztJQUVELEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBWTtRQUNyQixJQUFJO1lBQ0EsT0FBTyxDQUFDLElBQUksQ0FBQywrQkFBK0IsQ0FBQyxDQUFDO1lBQzlDLE1BQU0sZUFBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFO2dCQUN2QixJQUFJO2FBQ1AsQ0FBQyxDQUFDO1NBQ047UUFBQyxPQUFPLEtBQUssRUFBRTtZQUNaLE9BQU8sQ0FBQyxLQUFLLENBQUMsb0NBQW9DLENBQUMsQ0FBQztTQUN2RDtJQUNMLENBQUM7Q0FFSjtBQW5CRCw0QkFtQkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgYXhpb3MgZnJvbSBcImF4aW9zXCI7XG5cbmV4cG9ydCBjbGFzcyBTbGFja0FwaSB7XG5cbiAgICBwcml2YXRlIHJlYWRvbmx5IHVybDogc3RyaW5nO1xuXG4gICAgY29uc3RydWN0b3IodXJsIDpzdHJpbmcpIHtcbiAgICAgICAgdGhpcy51cmwgPSB1cmw7XG4gICAgfVxuXG4gICAgYXN5bmMgbm90aWZ5KHRleHQ6IHN0cmluZykge1xuICAgICAgICB0cnkge1xuICAgICAgICAgICAgY29uc29sZS5pbmZvKCdtZXRob2Q9bm90aWZ5IE5vdGlmeWluZyBTbGFjaycpO1xuICAgICAgICAgICAgYXdhaXQgYXhpb3MucG9zdCh0aGlzLnVybCwge1xuICAgICAgICAgICAgICAgIHRleHQsXG4gICAgICAgICAgICB9KTtcbiAgICAgICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgICAgICAgIGNvbnNvbGUuZXJyb3IoJ21ldGhvZD1ub3RpZnkgU2xhY2sgbm90aWZ5IGZhaWxlZCEnKTtcbiAgICAgICAgfVxuICAgIH1cblxufVxuIl19

package/src/utils/utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bothArraysHasSameValues = void 0;
+/**
+ * Check if arrays have only elements that also exists also in other array.
+ * Individual element count doesn't matter.
+ * Function works only for primitive types and for other it just checks the reference to object.
+ *
+ * Some examples
+ * bothArraysHasSameValues( [a, b], [b, a] )    => true
+ * bothArraysHasSameValues( [a, a], [a, a, a] ) => true
+ * bothArraysHasSameValues( [a, b], [a] )       => false
+ *
+ * Object references:
+ * const o1 = { a: 1, b: 2};
+ * const o2 = { a: 1, b: 2};
+ * // Arrays has references to same objects
+ * bothArraysHasSameValues([o1], [o1]))         => true
+ * Arrays have references to different objects
+ * bothArraysHasSameValues([o1], [o2]))         => false
+ *
+ * @param a first array to compare
+ * @param b second array to compare
+ */
+function bothArraysHasSameValues(a, b) {
+    if ((a && !b) || (!a && b)) {
+        return false;
+    }
+    else if (!a && !b) {
+        return true;
+    }
+    const aSet = new Set(a);
+    const bSet = new Set(b);
+    if (aSet.size !== bSet.size) {
+        return false;
+    }
+    return Array.from(aSet).every(value => bSet.has(value));
+}
+exports.bothArraysHasSameValues = bothArraysHasSameValues;
+//# sourceMappingURL=data:application/json;base64,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

package/test/asserter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A simple asserter-class for writing canaries without dependency to testing-libraries.
+ */
+export declare abstract class Asserter {
+    static assertEquals<T>(value: T, expected: T): void;
+    static assertTrue<T>(value: T): void;
+    static assertLength<T>(data: T[], expected: number): void;
+    static assertLengthGreaterThan<T>(data: T[], expected: number): void;
+    static assertGreaterThan(value: number, expected: number): void;
+    static assertToBeCloseTo(value: number, expected: number, delta: number): void;
+}

package/test/asserter.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * A simple asserter-class for writing canaries without dependency to testing-libraries.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Asserter = void 0;
+class Asserter {
+    static assertEquals(value, expected) {
+        if (value != expected) {
+            throw new Error(`Given value ${value} was not expected ${expected}`);
+        }
+    }
+    static assertTrue(value) {
+        if (!value) {
+            throw new Error(`Given value ${value} was not true`);
+        }
+    }
+    static assertLength(data, expected) {
+        if (!data) {
+            throw new Error("Given array was not defined");
+        }
+        if (data.length != expected) {
+            throw new Error(`Given array length ${data.length} was not expected ${expected}`);
+        }
+    }
+    static assertLengthGreaterThan(data, expected) {
+        if (!data) {
+            throw new Error("Given array was not defined");
+        }
+        if (data.length <= expected) {
+            throw new Error(`Given array length ${data.length} was not greater than ${expected}`);
+        }
+    }
+    static assertGreaterThan(value, expected) {
+        if (value <= expected) {
+            throw new Error(`Value ${value} was expected to be greater than ${expected}`);
+        }
+    }
+    static assertToBeCloseTo(value, expected, delta) {
+        expect(expected - value).toBeGreaterThanOrEqual(-1 * delta);
+        expect(expected - value).toBeLessThanOrEqual(delta);
+    }
+}
+exports.Asserter = Asserter;
+//# sourceMappingURL=data:application/json;base64,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

package/test/db-testutils.d.ts

@@ -0,0 +1,2 @@
+import { DTDatabase } from "../database/database";
+export declare function dbTestBase(fn: (db: DTDatabase) => void, truncateFn: (db: DTDatabase) => void, dbUser: string, dbPass: string, dbUri: string): () => void;

package/test/db-testutils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbTestBase = void 0;
+const database_1 = require("../database/database");
+const dbsecret_1 = require("../aws/runtime/secrets/dbsecret");
+function dbTestBase(fn, truncateFn, dbUser, dbPass, dbUri) {
+    const theDbUri = process.env.DB_URI ?? dbUri;
+    console.log(`Test database URI: ${theDbUri}`);
+    return () => {
+        const db = (0, database_1.initDbConnection)(dbUser, dbPass, 'test', theDbUri, {
+            noWarnings: true, // ignore duplicate connection warning for tests
+        });
+        beforeAll(async () => {
+            process.env[dbsecret_1.DatabaseEnvironmentKeys.DB_USER] = dbUser;
+            process.env[dbsecret_1.DatabaseEnvironmentKeys.DB_PASS] = dbPass;
+            process.env[dbsecret_1.DatabaseEnvironmentKeys.DB_URI] = theDbUri;
+            process.env[dbsecret_1.DatabaseEnvironmentKeys.DB_RO_URI] = theDbUri;
+            await truncateFn(db);
+        });
+        afterAll(async () => {
+            await truncateFn(db);
+            await db.$pool.end();
+        });
+        beforeEach(async () => {
+            await truncateFn(db);
+        });
+        fn(db);
+    };
+}
+exports.dbTestBase = dbTestBase;
+//# sourceMappingURL=data:application/json;base64,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

package/test/httpserver.d.ts

@@ -0,0 +1,18 @@
+export declare const ERROR_NO_MATCH = "NO MATCH";
+export declare const ERRORCODE_NOT_FOUND = 404;
+/**
+ * A mock HTTP server created for testing connections from a Lambda to an outside integration
+ */
+export declare class TestHttpServer {
+    private server;
+    private debug;
+    private messageStack;
+    getCallCount(): number;
+    getRequestBody(callNumber: number): string;
+    listen(port: number, props: ListenProperties, debug?: boolean, statusCode?: number): void;
+    close(): void;
+    private debuglog;
+}
+export interface ListenProperties {
+    [key: string]: (url?: string, data?: string) => string;
+}

package/test/httpserver.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestHttpServer = exports.ERRORCODE_NOT_FOUND = exports.ERROR_NO_MATCH = void 0;
+const http_1 = require("http");
+exports.ERROR_NO_MATCH = "NO MATCH";
+exports.ERRORCODE_NOT_FOUND = 404;
+/**
+ * A mock HTTP server created for testing connections from a Lambda to an outside integration
+ */
+class TestHttpServer {
+    getCallCount() {
+        return this.messageStack.length;
+    }
+    getRequestBody(callNumber) {
+        return this.messageStack[callNumber];
+    }
+    listen(port, props, debug = false, statusCode = 200) {
+        this.debug = debug;
+        this.messageStack = [];
+        this.debuglog(`Starting test server on port ${port}`);
+        this.server = (0, http_1.createServer)(((req, res) => {
+            this.debuglog('Mapped urls: ');
+            Object.keys(props).forEach(k => this.debuglog(k));
+            this.debuglog('Received request to url ' + req.url + '..');
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const path = require('url').parse(req.url).pathname;
+            let dataStr = '';
+            req.on('data', chunk => {
+                if (chunk) {
+                    dataStr += chunk;
+                }
+            });
+            if (path in props) {
+                this.debuglog('..url matched');
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.setHeader('Access-Control-Allow-Headers', 'Authorization,X-User-Id,X-Auth-Token');
+                res.writeHead(statusCode);
+                req.on('end', () => {
+                    // assume sent data is in JSON format
+                    this.messageStack[this.messageStack.length] = dataStr;
+                    res.end(props[path](req.url, dataStr));
+                });
+            }
+            else {
+                this.debuglog('..no match for %' + path);
+                req.on('end', () => {
+                    // assume sent data is in JSON format
+                    this.messageStack[this.messageStack.length] = exports.ERROR_NO_MATCH;
+                    res.writeHead(exports.ERRORCODE_NOT_FOUND);
+                    res.end(exports.ERROR_NO_MATCH);
+                });
+            }
+        }));
+        this.server.listen(port);
+    }
+    close() {
+        this.debuglog('Closing test server');
+        this.server.close();
+    }
+    debuglog(str) {
+        if (this.debug) {
+            console.debug(str);
+        }
+    }
+}
+exports.TestHttpServer = TestHttpServer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cHNlcnZlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2h0dHBzZXJ2ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsK0JBQTBDO0FBRTdCLFFBQUEsY0FBYyxHQUFDLFVBQVUsQ0FBQztBQUMxQixRQUFBLG1CQUFtQixHQUFDLEdBQUcsQ0FBQztBQUVyQzs7R0FFRztBQUNILE1BQWEsY0FBYztJQU12QixZQUFZO1FBQ1IsT0FBTyxJQUFJLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQztJQUNwQyxDQUFDO0lBRUQsY0FBYyxDQUFDLFVBQWtCO1FBQzdCLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUN6QyxDQUFDO0lBRUQsTUFBTSxDQUFDLElBQVksRUFBRSxLQUF1QixFQUFFLEtBQUssR0FBRSxLQUFLLEVBQUUsVUFBVSxHQUFHLEdBQUc7UUFDeEUsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDbkIsSUFBSSxDQUFDLFlBQVksR0FBRyxFQUFFLENBQUM7UUFDdkIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxnQ0FBZ0MsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUN0RCxJQUFJLENBQUMsTUFBTSxHQUFHLElBQUEsbUJBQVksRUFBQyxDQUFDLENBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxFQUFFO1lBQ3JDLElBQUksQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDLENBQUM7WUFFL0IsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDbEQsSUFBSSxDQUFDLFFBQVEsQ0FBQywwQkFBMEIsR0FBRyxHQUFHLENBQUMsR0FBRyxHQUFHLElBQUksQ0FBQyxDQUFDO1lBQzNELDhEQUE4RDtZQUM5RCxNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxRQUFRLENBQUM7WUFFcEQsSUFBSSxPQUFPLEdBQUcsRUFBRSxDQUFDO1lBQ2pCLEdBQUcsQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQyxFQUFFO2dCQUNuQixJQUFJLEtBQUssRUFBRTtvQkFDUCxPQUFPLElBQUksS0FBSyxDQUFDO2lCQUNwQjtZQUNMLENBQUMsQ0FBQyxDQUFDO1lBRUgsSUFBSSxJQUFJLElBQUksS0FBSyxFQUFFO2dCQUNmLElBQUksQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDLENBQUM7Z0JBQy9CLEdBQUcsQ0FBQyxTQUFTLENBQUMsNkJBQTZCLEVBQUUsR0FBRyxDQUFDLENBQUM7Z0JBQ2xELEdBQUcsQ0FBQyxTQUFTLENBQUMsOEJBQThCLEVBQUUsc0NBQXNDLENBQUMsQ0FBQztnQkFDdEYsR0FBRyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsQ0FBQztnQkFFMUIsR0FBRyxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsR0FBRyxFQUFFO29CQUNmLHFDQUFxQztvQkFDckMsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQyxHQUFHLE9BQU8sQ0FBQztvQkFDdEQsR0FBRyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUMsQ0FBQyxDQUFDO2dCQUMzQyxDQUFDLENBQUMsQ0FBQzthQUNOO2lCQUFNO2dCQUNILElBQUksQ0FBQyxRQUFRLENBQUMsa0JBQWtCLEdBQUcsSUFBSSxDQUFDLENBQUM7Z0JBQ3pDLEdBQUcsQ0FBQyxFQUFFLENBQUMsS0FBSyxFQUFFLEdBQUcsRUFBRTtvQkFDZixxQ0FBcUM7b0JBQ3JDLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxNQUFNLENBQUMsR0FBRyxzQkFBYyxDQUFDO29CQUM3RCxHQUFHLENBQUMsU0FBUyxDQUFDLDJCQUFtQixDQUFDLENBQUM7b0JBQ25DLEdBQUcsQ0FBQyxHQUFHLENBQUMsc0JBQWMsQ0FBQyxDQUFDO2dCQUM1QixDQUFDLENBQUMsQ0FBQzthQUNOO1FBQ0wsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNKLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzdCLENBQUM7SUFFRCxLQUFLO1FBQ0QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO1FBQ3JDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDeEIsQ0FBQztJQUVPLFFBQVEsQ0FBQyxHQUFXO1FBQ3hCLElBQUksSUFBSSxDQUFDLEtBQUssRUFBRTtZQUNaLE9BQU8sQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7U0FDdEI7SUFDTCxDQUFDO0NBQ0o7QUFuRUQsd0NBbUVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtTZXJ2ZXIsIGNyZWF0ZVNlcnZlcn0gZnJvbSAnaHR0cCc7XHJcblxyXG5leHBvcnQgY29uc3QgRVJST1JfTk9fTUFUQ0g9XCJOTyBNQVRDSFwiO1xyXG5leHBvcnQgY29uc3QgRVJST1JDT0RFX05PVF9GT1VORD00MDQ7XHJcblxyXG4vKipcclxuICogQSBtb2NrIEhUVFAgc2VydmVyIGNyZWF0ZWQgZm9yIHRlc3RpbmcgY29ubmVjdGlvbnMgZnJvbSBhIExhbWJkYSB0byBhbiBvdXRzaWRlIGludGVncmF0aW9uXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgVGVzdEh0dHBTZXJ2ZXIge1xyXG4gICAgcHJpdmF0ZSBzZXJ2ZXI6IFNlcnZlcjtcclxuICAgIHByaXZhdGUgZGVidWc6IGJvb2xlYW47XHJcblxyXG4gICAgcHJpdmF0ZSBtZXNzYWdlU3RhY2s6IHN0cmluZ1tdO1xyXG5cclxuICAgIGdldENhbGxDb3VudCgpOiBudW1iZXIge1xyXG4gICAgICAgIHJldHVybiB0aGlzLm1lc3NhZ2VTdGFjay5sZW5ndGg7XHJcbiAgICB9XHJcblxyXG4gICAgZ2V0UmVxdWVzdEJvZHkoY2FsbE51bWJlcjogbnVtYmVyKTogc3RyaW5nIHtcclxuICAgICAgICByZXR1cm4gdGhpcy5tZXNzYWdlU3RhY2tbY2FsbE51bWJlcl07XHJcbiAgICB9XHJcblxyXG4gICAgbGlzdGVuKHBvcnQ6IG51bWJlciwgcHJvcHM6IExpc3RlblByb3BlcnRpZXMsIGRlYnVnPSBmYWxzZSwgc3RhdHVzQ29kZSA9IDIwMCkge1xyXG4gICAgICAgIHRoaXMuZGVidWcgPSBkZWJ1ZztcclxuICAgICAgICB0aGlzLm1lc3NhZ2VTdGFjayA9IFtdO1xyXG4gICAgICAgIHRoaXMuZGVidWdsb2coYFN0YXJ0aW5nIHRlc3Qgc2VydmVyIG9uIHBvcnQgJHtwb3J0fWApO1xyXG4gICAgICAgIHRoaXMuc2VydmVyID0gY3JlYXRlU2VydmVyKCgocmVxLCByZXMpID0+IHtcclxuICAgICAgICAgICAgdGhpcy5kZWJ1Z2xvZygnTWFwcGVkIHVybHM6ICcpO1xyXG5cclxuICAgICAgICAgICAgT2JqZWN0LmtleXMocHJvcHMpLmZvckVhY2goayA9PiB0aGlzLmRlYnVnbG9nKGspKTtcclxuICAgICAgICAgICAgdGhpcy5kZWJ1Z2xvZygnUmVjZWl2ZWQgcmVxdWVzdCB0byB1cmwgJyArIHJlcS51cmwgKyAnLi4nKTtcclxuICAgICAgICAgICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby12YXItcmVxdWlyZXNcclxuICAgICAgICAgICAgY29uc3QgcGF0aCA9IHJlcXVpcmUoJ3VybCcpLnBhcnNlKHJlcS51cmwpLnBhdGhuYW1lO1xyXG5cclxuICAgICAgICAgICAgbGV0IGRhdGFTdHIgPSAnJztcclxuICAgICAgICAgICAgcmVxLm9uKCdkYXRhJywgY2h1bmsgPT4ge1xyXG4gICAgICAgICAgICAgICAgaWYgKGNodW5rKSB7XHJcbiAgICAgICAgICAgICAgICAgICAgZGF0YVN0ciArPSBjaHVuaztcclxuICAgICAgICAgICAgICAgIH1cclxuICAgICAgICAgICAgfSk7XHJcblxyXG4gICAgICAgICAgICBpZiAocGF0aCBpbiBwcm9wcykge1xyXG4gICAgICAgICAgICAgICAgdGhpcy5kZWJ1Z2xvZygnLi51cmwgbWF0Y2hlZCcpO1xyXG4gICAgICAgICAgICAgICAgcmVzLnNldEhlYWRlcignQWNjZXNzLUNvbnRyb2wtQWxsb3ctT3JpZ2luJywgJyonKTtcclxuICAgICAgICAgICAgICAgIHJlcy5zZXRIZWFkZXIoJ0FjY2Vzcy1Db250cm9sLUFsbG93LUhlYWRlcnMnLCAnQXV0aG9yaXphdGlvbixYLVVzZXItSWQsWC1BdXRoLVRva2VuJyk7XHJcbiAgICAgICAgICAgICAgICByZXMud3JpdGVIZWFkKHN0YXR1c0NvZGUpO1xyXG5cclxuICAgICAgICAgICAgICAgIHJlcS5vbignZW5kJywgKCkgPT4ge1xyXG4gICAgICAgICAgICAgICAgICAgIC8vIGFzc3VtZSBzZW50IGRhdGEgaXMgaW4gSlNPTiBmb3JtYXRcclxuICAgICAgICAgICAgICAgICAgICB0aGlzLm1lc3NhZ2VTdGFja1t0aGlzLm1lc3NhZ2VTdGFjay5sZW5ndGhdID0gZGF0YVN0cjtcclxuICAgICAgICAgICAgICAgICAgICByZXMuZW5kKHByb3BzW3BhdGhdKHJlcS51cmwsIGRhdGFTdHIpKTtcclxuICAgICAgICAgICAgICAgIH0pO1xyXG4gICAgICAgICAgICB9IGVsc2Uge1xyXG4gICAgICAgICAgICAgICAgdGhpcy5kZWJ1Z2xvZygnLi5ubyBtYXRjaCBmb3IgJScgKyBwYXRoKTtcclxuICAgICAgICAgICAgICAgIHJlcS5vbignZW5kJywgKCkgPT4ge1xyXG4gICAgICAgICAgICAgICAgICAgIC8vIGFzc3VtZSBzZW50IGRhdGEgaXMgaW4gSlNPTiBmb3JtYXRcclxuICAgICAgICAgICAgICAgICAgICB0aGlzLm1lc3NhZ2VTdGFja1t0aGlzLm1lc3NhZ2VTdGFjay5sZW5ndGhdID0gRVJST1JfTk9fTUFUQ0g7XHJcbiAgICAgICAgICAgICAgICAgICAgcmVzLndyaXRlSGVhZChFUlJPUkNPREVfTk9UX0ZPVU5EKTtcclxuICAgICAgICAgICAgICAgICAgICByZXMuZW5kKEVSUk9SX05PX01BVENIKTtcclxuICAgICAgICAgICAgICAgIH0pO1xyXG4gICAgICAgICAgICB9XHJcbiAgICAgICAgfSkpO1xyXG4gICAgICAgIHRoaXMuc2VydmVyLmxpc3Rlbihwb3J0KTtcclxuICAgIH1cclxuXHJcbiAgICBjbG9zZSgpIHtcclxuICAgICAgICB0aGlzLmRlYnVnbG9nKCdDbG9zaW5nIHRlc3Qgc2VydmVyJyk7XHJcbiAgICAgICAgdGhpcy5zZXJ2ZXIuY2xvc2UoKTtcclxuICAgIH1cclxuXHJcbiAgICBwcml2YXRlIGRlYnVnbG9nKHN0cjogc3RyaW5nKSB7XHJcbiAgICAgICAgaWYgKHRoaXMuZGVidWcpIHtcclxuICAgICAgICAgICAgY29uc29sZS5kZWJ1ZyhzdHIpO1xyXG4gICAgICAgIH1cclxuICAgIH1cclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBMaXN0ZW5Qcm9wZXJ0aWVzIHtcclxuICAgIFtrZXk6c3RyaW5nXTogKHVybD86IHN0cmluZywgZGF0YT86IHN0cmluZykgPT4gc3RyaW5nO1xyXG59XHJcbiJdfQ==