@digitraffic/common 2022.10.25-1 → 2022.10.28-2

package/src/utils/geometry.ts

@@ -0,0 +1,164 @@
+/**
+ * GeoJSON functions and tools
+ */
+import { Feature, FeatureCollection, Geometry, Position } from "geojson";
+import * as geoJsonValidator from "geojson-validation";
+
+export const SRID_WGS84 = 4326;
+
+/**
+ * Creates WKT geometry from GeoJSON geometry
+ * @param geometry GeoJson geometry to convert to WKT
+ */
+export function createGeometry(geometry: Geometry): string {
+    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";
+}
+
+function linestring(coordinates: Position[]): string {
+    return coordinates.map((c: Position) => coordinatePair(c)).join(",");
+}
+
+function polygon(coordinates: Position[][]): string {
+    const list = coordinates.map((c: Position[]) => linestring(c)).join(",");
+    return `(${list})`;
+}
+
+function multiPolygon(coordinates: Position[][][]): string {
+    const list = coordinates.map((c: Position[][]) => polygon(c)).join(",");
+    return `(${list})`;
+}
+
+function coordinatePair(coordinate: Position): string {
+    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
+ */
+export function createFeatureCollection(
+    features: Feature[],
+    lastUpdated: Date | null
+): FeatureCollection {
+    return {
+        type: "FeatureCollection",
+        lastUpdated: lastUpdated,
+        features: features,
+    } as FeatureCollection;
+}
+
+export function isValidGeoJson<T>(json: T): boolean {
+    return geoJsonValidator.valid(json);
+}
+
+export function isFeatureCollection<T>(json: T): boolean {
+    return geoJsonValidator.isFeatureCollection(json);
+}
+
+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: number,
+    fromYLat: number,
+    toXLon: number,
+    toYLat: number
+): number {
+    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
+ */
+export function distanceBetweenPositionsInKm(pos1: Position, pos2: Position) {
+    return distanceBetweenWGS84PointsInKm(pos1[0], pos1[1], pos2[0], pos2[1]);
+}
+
+export function areDistinctPositions(previous: Position, next: Position) {
+    return previous[0] !== next[0] || previous[1] !== next[1];
+}
+
+/**
+ * Calculates distance between two GeoJSON points (WGS84)
+ * @param pos1
+ * @param pos2
+ */
+export function distanceBetweenPositionsInM(pos1: Position, pos2: Position) {
+    return distanceBetweenPositionsInKm(pos1, pos2) * 1000; // km -> m
+}
+
+export function createGmlLineString(geometry: Geometry, srsName = "EPSG:4326") {
+    const posList = createPosList(geometry);
+
+    return {
+        srsName,
+        posList,
+    };
+}
+
+function createPosList(geometry: 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: Position[][], precision = 8) {
+    return positions.map((p) => lineStringToList(p, precision)).join(" ");
+}
+
+function lineStringToList(positions: Position[], precision = 8) {
+    return positions.map((p) => positionToList(p, precision)).join(" ");
+}
+
+export function positionToList(position: Position, precision = 8) {
+    return position.map((n) => n.toPrecision(precision)).join(" ");
+}
+
+// Converts numeric degrees to radians
+function toRadians(angdeg: number) {
+    return angdeg * DEGREES_TO_RADIANS;
+}

package/src/utils/retry.ts

@@ -0,0 +1,49 @@
+export enum RetryLogError {
+    LOG_ALL_AS_ERRORS,
+    LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS,
+    NO_LOGGING
+}
+
+/**
+ * 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
+ */
+export async function retry<T>(asyncFn: () => Promise<T>,
+    retries = 3,
+    logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS): Promise<T> {
+
+    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);
+    }
+}

package/src/utils/slack.ts

@@ -0,0 +1,22 @@
+import axios from "axios";
+
+export class SlackApi {
+
+    private readonly url: string;
+
+    constructor(url :string) {
+        this.url = url;
+    }
+
+    async notify(text: string) {
+        try {
+            console.info('method=notify Notifying Slack');
+            await axios.post(this.url, {
+                text,
+            });
+        } catch (error) {
+            console.error('method=notify Slack notify failed!');
+        }
+    }
+
+}

package/src/utils/utils.ts

@@ -0,0 +1,105 @@
+/**
+ * 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
+ */
+import { Either } from "../types/either";
+
+export function bothArraysHasSameValues(
+    a: null | undefined | unknown[],
+    b: null | undefined | unknown[]
+): boolean {
+    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));
+}
+
+/**
+ * Returns the last item on the array.  If the array is empty, throws an error!
+ */
+export function getLast<T>(array: T[], sortFunction?: (a: T) => number): T {
+    return getFirstOrLast(false, array, sortFunction);
+}
+
+/**
+ * Returns the first item on the array.  If the array is empty, throws an error!
+ */
+export function getFirst<T>(array: T[], sortFunction?: (a: T) => number): T {
+    return getFirstOrLast(true, array, sortFunction);
+}
+
+function getFirstOrLast<T>(
+    getFirst: boolean,
+    array: T[],
+    sortFunction?: (a: T) => number
+): T {
+    if (array.length == 0) {
+        throw new Error(
+            `can't get ${getFirst ? "first" : "last"} from empty array!`
+        );
+    }
+
+    const index = getFirst ? 0 : array.length - 1;
+
+    if (sortFunction) {
+        return array.sort(sortFunction)[index];
+    }
+
+    return array[index];
+}
+
+/**
+ * Gets environment variable. Throws error if variable is not found.
+ *
+ * @param key Environment key
+ * @return string
+ */
+export function getEnvVariable(key: string): string {
+    const either = getEnvVariableSafe(key);
+    if (either.result === "error") {
+        throw new Error(either.message);
+    }
+    return either.value;
+}
+
+/**
+ * Gets environment variable. Safe version returns object with either ok or error status.
+ * Easier to use for recovery than catching an error.
+ *
+ * @param key Environment key
+ * @return Either<string>
+ */
+export function getEnvVariableSafe(key: string): Either<string> {
+    const value = process.env[key];
+    if (value === undefined) {
+        return {
+            result: "error",
+            message: `Error: environment variable "${key}" is undefined.`,
+        };
+    }
+    return { result: "ok", value };
+}

package/aws/infra/api/integration.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DigitrafficIntegration = void 0;
-const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
-const mediatypes_1 = require("../../types/mediatypes");
-const digitraffic_integration_response_1 = require("../../runtime/digitraffic-integration-response");
-class DigitrafficIntegration {
-    constructor(lambda, mediaType = mediatypes_1.MediaType.TEXT_PLAIN) {
-        this.parameters = [];
-        this.lambda = lambda;
-        this.mediaType = mediaType;
-    }
-    addPathParameter(...names) {
-        names.forEach(name => this.parameters.push({ type: 'path', name }));
-        return this;
-    }
-    addQueryParameter(...names) {
-        names.forEach(name => this.parameters.push({ type: 'querystring', name }));
-        return this;
-    }
-    build() {
-        const integrationResponses = this.createResponses();
-        return new aws_apigateway_1.LambdaIntegration(this.lambda, {
-            proxy: false,
-            integrationResponses,
-            requestParameters: this.parameters.length == 0 ? undefined : this.createRequestParameters(),
-            requestTemplates: this.parameters.length == 0 ? undefined : this.createRequestTemplates(),
-            passthroughBehavior: aws_apigateway_1.PassthroughBehavior.WHEN_NO_MATCH,
-        });
-    }
-    createRequestParameters() {
-        const requestParameters = {};
-        this.parameters.forEach((parameter) => {
-            requestParameters[`integration.request.${parameter.type}.${parameter.name}`] = `method.request.${parameter.type}.${parameter.name}`;
-        });
-        return requestParameters;
-    }
-    createRequestTemplates() {
-        const requestJson = {};
-        this.parameters.forEach((parameter) => {
-            requestJson[parameter.name] = `$util.escapeJavaScript($input.params('${parameter.name}'))`;
-        });
-        return {
-            [mediatypes_1.MediaType.APPLICATION_JSON]: JSON.stringify(requestJson),
-        };
-    }
-    createResponses() {
-        return [digitraffic_integration_response_1.DigitrafficIntegrationResponse.ok(this.mediaType)];
-    }
-}
-exports.DigitrafficIntegration = DigitrafficIntegration;
-//# sourceMappingURL=data:application/json;base64,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

package/aws/infra/api/response.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createResponses = exports.InternalServerErrorResponseTemplate = exports.SvgResponseTemplate = exports.XmlResponseTemplate = exports.NotFoundResponseTemplate = exports.BadRequestResponseTemplate = exports.NotFoundResponse = exports.MessageModel = exports.RESPONSE_DEFAULT_LAMBDA = void 0;
-const apigateway = require("aws-cdk-lib/aws-apigateway");
-const mediatypes_1 = require("../../types/mediatypes");
-/**
- * This is velocity-script, that assumes the response to be LambdaResponse(status and body).
- * It will always return the body and status, but if status in something else than 200 OK the content-type
- * will be overridden to text/plain. (it's assumed, that lambda will return error text).
- *
- * If fileName is set, then Content-Disposition-header will be set to use it
- */
-exports.RESPONSE_DEFAULT_LAMBDA = `#set($inputRoot = $input.path('$'))
-$inputRoot.body
-#if ($inputRoot.status != 200)
-#set ($context.responseOverride.status = $inputRoot.status)
-#set ($context.responseOverride.header.Content-Type = 'text/plain')
-#end
-#set ($context.responseOverride.header.Access-Control-Allow-Origin = '*')
-#if ("$!inputRoot.fileName" != "")
-#set ($disposition = 'attachment; filename="FN"')
-#set ($context.responseOverride.header.Content-Disposition = $disposition.replaceAll('FN', $inputRoot.fileName))
-#end
-`;
-const BODY_FROM_INPUT_PATH = "$input.path('$').body";
-// DEPRECATED
-const messageSchema = {
-    schema: apigateway.JsonSchemaVersion.DRAFT4,
-    type: apigateway.JsonSchemaType.OBJECT,
-    description: 'Response with message',
-    properties: {
-        message: {
-            type: apigateway.JsonSchemaType.STRING,
-            description: 'Response message',
-        },
-    },
-};
-// DEPRECATED
-exports.MessageModel = {
-    contentType: mediatypes_1.MediaType.APPLICATION_JSON,
-    modelName: 'MessageResponseModel',
-    schema: messageSchema,
-};
-const NotFoundMessage = 'Not found';
-exports.NotFoundResponse = JSON.stringify({ message: NotFoundMessage });
-const InternalServerErrorMessage = 'Error';
-const InternalServerErrorResponse = JSON.stringify({ message: InternalServerErrorMessage });
-const BadRequestMessage = 'Bad request';
-const BadRequestResponse = JSON.stringify({ message: BadRequestMessage });
-exports.BadRequestResponseTemplate = createResponses(mediatypes_1.MediaType.APPLICATION_JSON, BadRequestResponse);
-exports.NotFoundResponseTemplate = createResponses(mediatypes_1.MediaType.APPLICATION_JSON, exports.NotFoundResponse);
-exports.XmlResponseTemplate = createResponses(mediatypes_1.MediaType.APPLICATION_XML, BODY_FROM_INPUT_PATH);
-exports.SvgResponseTemplate = createResponses(mediatypes_1.MediaType.IMAGE_SVG, BODY_FROM_INPUT_PATH);
-exports.InternalServerErrorResponseTemplate = createResponses(mediatypes_1.MediaType.APPLICATION_JSON, InternalServerErrorResponse);
-function createResponses(key, value) {
-    const map = {};
-    map[key] = value;
-    return map;
-}
-exports.createResponses = createResponses;
-//# sourceMappingURL=data:application/json;base64,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

package/aws/infra/api/responses.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getResponse = exports.defaultIntegration = exports.corsMethod = exports.methodResponse = exports.RESPONSE_404_NOT_FOUND = exports.RESPONSE_CORS_INTEGRATION = exports.RESPONSE_500_SERVER_ERROR = exports.RESPONSE_400_BAD_REQUEST = exports.RESPONSE_200_OK = void 0;
-const response_1 = require("./response");
-const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
-const errors_1 = require("../../types/errors");
-exports.RESPONSE_200_OK = {
-    statusCode: '200',
-};
-exports.RESPONSE_400_BAD_REQUEST = {
-    statusCode: '400',
-    selectionPattern: errors_1.BAD_REQUEST_MESSAGE,
-    responseTemplates: response_1.BadRequestResponseTemplate,
-};
-exports.RESPONSE_500_SERVER_ERROR = {
-    statusCode: '500',
-    selectionPattern: errors_1.ERROR_MESSAGE,
-    responseTemplates: response_1.InternalServerErrorResponseTemplate,
-};
-const RESPONSE_XML = {
-    responseTemplates: response_1.XmlResponseTemplate,
-};
-exports.RESPONSE_CORS_INTEGRATION = {
-    responseParameters: {
-        'method.response.header.Access-Control-Allow-Origin': "'*'",
-    },
-};
-exports.RESPONSE_404_NOT_FOUND = {
-    statusCode: '404',
-    selectionPattern: errors_1.NOT_FOUND_MESSAGE,
-    responseTemplates: response_1.NotFoundResponseTemplate,
-};
-function methodResponse(status, contentType, model, parameters) {
-    return {
-        statusCode: status,
-        responseModels: (0, response_1.createResponses)(contentType, model),
-        responseParameters: parameters || {},
-    };
-}
-exports.methodResponse = methodResponse;
-function corsMethod(response) {
-    return { ...response, ...{
-            responseParameters: {
-                'method.response.header.Access-Control-Allow-Origin': true,
-            },
-        } };
-}
-exports.corsMethod = corsMethod;
-/**
- * Creates a default Lambda integration for a REST API resource _root_
- * @param lambdaFunction The Lambda function
- * @param options Options
- */
-function defaultIntegration(lambdaFunction, options) {
-    return new aws_apigateway_1.LambdaIntegration(lambdaFunction, {
-        proxy: false,
-        integrationResponses: options?.responses || [
-            getResponse(exports.RESPONSE_200_OK, options),
-            getResponse(exports.RESPONSE_400_BAD_REQUEST, options),
-            getResponse(exports.RESPONSE_404_NOT_FOUND, options),
-            getResponse(exports.RESPONSE_500_SERVER_ERROR, options),
-        ],
-        requestParameters: options?.requestParameters || {},
-        requestTemplates: options?.requestTemplates || {},
-        passthroughBehavior: options?.passthroughBehavior ?? aws_apigateway_1.PassthroughBehavior.WHEN_NO_MATCH,
-    });
-}
-exports.defaultIntegration = defaultIntegration;
-function getResponse(response, options) {
-    if (options?.xml) {
-        response = { ...response, ...RESPONSE_XML };
-    }
-    if (!options?.disableCors) {
-        response = { ...response, ...exports.RESPONSE_CORS_INTEGRATION };
-    }
-    return response;
-}
-exports.getResponse = getResponse;
-//# sourceMappingURL=data:application/json;base64,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

package/aws/infra/api/static-integration.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DigitrafficStaticIntegration = void 0;
-const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
-const mediatypes_1 = require("../../types/mediatypes");
-const responses_1 = require("./responses");
-const INTEGRATION_RESPONSE_200 = `{
-    "statusCode": 200
-}`;
-const METHOD_RESPONSE_200 = {
-    statusCode: '200',
-};
-/**
- * Static integration, that returns the given response with given mediaType from given resource.
- *
- * @param resource
- * @param mediaType
- * @param response
- */
-class DigitrafficStaticIntegration extends aws_apigateway_1.MockIntegration {
-    constructor(resource, mediaType, response, enableCors = true, apiKeyRequired = true) {
-        const integrationResponse = DigitrafficStaticIntegration.createIntegrationResponse(response, mediaType, enableCors);
-        super({
-            passthroughBehavior: aws_apigateway_1.PassthroughBehavior.WHEN_NO_TEMPLATES,
-            requestTemplates: {
-                [mediaType]: INTEGRATION_RESPONSE_200,
-            },
-            integrationResponses: [integrationResponse],
-        });
-        ['GET', 'HEAD'].forEach((httpMethod) => {
-            resource.addMethod(httpMethod, this, {
-                apiKeyRequired,
-                methodResponses: [DigitrafficStaticIntegration.createMethodResponse(enableCors)],
-            });
-        });
-    }
-    static json(resource, response, enableCors = true, apiKeyRequired = true) {
-        return new DigitrafficStaticIntegration(resource, mediatypes_1.MediaType.APPLICATION_JSON, JSON.stringify(response), enableCors, apiKeyRequired);
-    }
-    static createIntegrationResponse(response, mediaType, enableCors) {
-        const integrationResponse = {
-            statusCode: '200',
-            responseTemplates: {
-                [mediaType]: response,
-            },
-        };
-        return enableCors ? { ...integrationResponse, ...responses_1.RESPONSE_CORS_INTEGRATION } : integrationResponse;
-    }
-    static createMethodResponse(enableCors) {
-        return enableCors ? (0, responses_1.corsMethod)(METHOD_RESPONSE_200) : METHOD_RESPONSE_200;
-    }
-}
-exports.DigitrafficStaticIntegration = DigitrafficStaticIntegration;
-//# sourceMappingURL=data:application/json;base64,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

package/aws/infra/canaries/canary-alarm.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CanaryAlarm = void 0;
-const aws_cloudwatch_1 = require("aws-cdk-lib/aws-cloudwatch");
-const aws_cloudwatch_actions_1 = require("aws-cdk-lib/aws-cloudwatch-actions");
-const aws_sns_1 = require("aws-cdk-lib/aws-sns");
-class CanaryAlarm {
-    constructor(stack, canary, params) {
-        if (params.alarm ?? true) {
-            const alarmName = params.alarm?.alarmName ?? `${params.name}-alarm`;
-            const alarm = new aws_cloudwatch_1.Alarm(stack, alarmName, {
-                alarmName,
-                alarmDescription: params.alarm?.description ?? '',
-                metric: canary.metricSuccessPercent(),
-                evaluationPeriods: params.alarm?.evalutionPeriods ?? 1,
-                threshold: params.alarm?.threshold ?? 100,
-                comparisonOperator: aws_cloudwatch_1.ComparisonOperator.LESS_THAN_THRESHOLD,
-            });
-            if (params.alarm?.topicArn) {
-                alarm.addAlarmAction(new aws_cloudwatch_actions_1.SnsAction(aws_sns_1.Topic.fromTopicArn(stack, `${alarmName}-action`, params.alarm.topicArn)));
-            }
-        }
-    }
-}
-exports.CanaryAlarm = CanaryAlarm;
-//# sourceMappingURL=data:application/json;base64,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