@digitraffic/common 2024.1.10-1 → 2024.1.23-1

package/dist/utils/date-utils.mjs

@@ -0,0 +1,44 @@
+import { formatInTimeZone } from "date-fns-tz";
+/**
+ * Constant for the 1970-01-01T00:00:00Z epoch Date.
+ */
+export const EPOCH = new Date(Date.UTC(1970, 0, 1));
+export const UTC = "UTC";
+export const MYSQL_DATETIME_FORMAT = "yyyy-MM-dd HH:mm";
+/**
+ * Counts difference in milliseconds between dates.
+ * @param start
+ * @param end
+ */
+export function countDiffMs(start, end) {
+    return end.getTime() - start.getTime();
+}
+/**
+ * Counts difference in seconds between dates.
+ * @param start
+ * @param end
+ */
+export function countDiffInSeconds(start, end) {
+    return countDiffMs(start, end) / 1000;
+}
+/**
+ * Converts ISO 8601 date-time -string to Date object
+ * @param isoString to convert
+ */
+export function dateFromIsoString(isoString) {
+    const parsed = new Date(isoString);
+    if (!isValidDate(parsed)) {
+        throw new Error(`Could not parse iso date-time string: "${isoString}" to date`);
+    }
+    return parsed;
+}
+function isValidDate(d) {
+    return d instanceof Date && !isNaN(d.getTime());
+}
+/**
+ * Formats a date in UTC in the given format, regardless of system time zone
+ */
+export function dateToUTCString(date, format) {
+    return formatInTimeZone(date, UTC, format);
+}
+//# sourceMappingURL=date-utils.mjs.map

package/dist/utils/geojson-types.mjs

@@ -0,0 +1,13 @@
+export class GeoJsonPoint {
+    constructor(coordinates) {
+        this.type = "Point";
+        this.coordinates = coordinates;
+    }
+}
+export class GeoJsonLineString {
+    constructor(coordinates) {
+        this.type = "LineString";
+        this.coordinates = coordinates;
+    }
+}
+//# sourceMappingURL=geojson-types.mjs.map

package/dist/utils/{geometry.js → geometry.mjs}

@@ -1,37 +1,11 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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;
-const geoJsonValidator = __importStar(require("geojson-validation"));
-const dt_logger_default_1 = require("../aws/runtime/dt-logger-default");
-exports.SRID_WGS84 = 4326;
+import * as geoJsonValidator from "geojson-validation";
+import { logger } from "../aws/runtime/dt-logger-default.mjs";
+export const SRID_WGS84 = 4326;
 /**
  * Creates WKT geometry from GeoJSON geometry
  * @param geometry GeoJson geometry to convert to WKT
  */
-function createGeometry(geometry) {
+export function createGeometry(geometry) {
     if (geometry.type === "LineString") {
         const coordinates = linestring(geometry.coordinates);
         return `LINESTRING(${coordinates})`;
@@ -48,13 +22,12 @@ function createGeometry(geometry) {
         const coordinates = multiPolygon(geometry.coordinates);
         return `MULTIPOLYGON(${coordinates})`;
     }
-    dt_logger_default_1.logger.error({
+    logger.error({
         method: "Geometry.createGeometry",
         message: "Unsupported locationType " + geometry.type,
     });
     return "POLYGON EMPTY";
 }
-exports.createGeometry = createGeometry;
 function linestring(coordinates) {
     return coordinates.map((c) => coordinatePair(c)).join(",");
 }
@@ -74,22 +47,21 @@ function coordinatePair(coordinate) {
  * @param features List of Features
  * @param lastUpdated Last updated date
  */
-function createFeatureCollection(features, lastUpdated) {
+export function createFeatureCollection(features, lastUpdated) {
     return {
         type: "FeatureCollection",
         lastUpdated: lastUpdated,
         features: features,
     };
 }
-exports.createFeatureCollection = createFeatureCollection;
-function isValidGeoJson(json) {
+export function isValidGeoJson(json) {
+    // Tests complain about this method returning type string[] which is obviously wrong. Therefore, this casting.
     return geoJsonValidator.valid(json);
 }
-exports.isValidGeoJson = isValidGeoJson;
-function isFeatureCollection(json) {
+export function isFeatureCollection(json) {
+    // Tests complain about this method returning type string[] which is obviously wrong. Therefore, this casting.
     return geoJsonValidator.isFeatureCollection(json);
 }
-exports.isFeatureCollection = isFeatureCollection;
 const DEGREES_TO_RADIANS = 0.017453292519943295; // = Math.PI / 180
 const EARTH_RADIUS_KM = 6371;
 /**
@@ -114,31 +86,27 @@ function distanceBetweenWGS84PointsInKm(fromXLon, fromYLat, toXLon, toYLat) {
  * @param pos1
  * @param pos2
  */
-function distanceBetweenPositionsInKm(pos1, pos2) {
+export function distanceBetweenPositionsInKm(pos1, pos2) {
     return distanceBetweenWGS84PointsInKm(pos1[0], pos1[1], pos2[0], pos2[1]);
 }
-exports.distanceBetweenPositionsInKm = distanceBetweenPositionsInKm;
-function areDistinctPositions(previous, next) {
+export 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) {
+export function distanceBetweenPositionsInM(pos1, pos2) {
     return distanceBetweenPositionsInKm(pos1, pos2) * 1000; // km -> m
 }
-exports.distanceBetweenPositionsInM = distanceBetweenPositionsInM;
-function createGmlLineString(geometry, srsName = "EPSG:4326") {
+export 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);
@@ -157,12 +125,11 @@ function polygonToList(positions, precision = 8) {
 function lineStringToList(positions, precision = 8) {
     return positions.map((p) => positionToList(p, precision)).join(" ");
 }
-function positionToList(position, precision = 8) {
+export 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=geometry.js.map
+//# sourceMappingURL=geometry.mjs.map

package/dist/utils/{logging.d.ts → logging.d.mts}

@@ -1,4 +1,4 @@
-import { DtLogger } from "../aws/runtime/dt-logger";
+import { DtLogger } from "../aws/runtime/dt-logger.mjs";
 /**
  * Curried version of logException.
  *

package/dist/utils/{logging.js → logging.mjs}

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logException = exports.createExceptionLogger = void 0;
-const axios_1 = require("axios");
-const dt_logger_1 = require("../aws/runtime/dt-logger");
-const utils_1 = require("./utils");
-const functionName = (0, utils_1.getEnvVariableOrElse)("AWS_LAMBDA_FUNCTION_NAME", "test");
+import { AxiosError } from "axios";
+import { DtLogger } from "../aws/runtime/dt-logger.mjs";
+import { getEnvVariableOrElse } from "./utils.mjs";
+const functionName = getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "test");
 /**
  * Curried version of logException.
  *
@@ -21,19 +18,18 @@ const functionName = (0, utils_1.getEnvVariableOrElse)("AWS_LAMBDA_FUNCTION_NAME
  * @returns Logs the error without rethrowing.
  * @see {@link logException}
  */
-function createExceptionLogger(logger = undefined, includeStack = false) {
+export function createExceptionLogger(logger = undefined, includeStack = false) {
     let thatLogger;
     if (logger) {
         thatLogger = logger;
     }
     else {
-        thatLogger = new dt_logger_1.DtLogger();
+        thatLogger = new DtLogger();
     }
     return (error) => {
         logException(thatLogger, error, includeStack);
     };
 }
-exports.createExceptionLogger = createExceptionLogger;
 /**
  * Log given exception with level ERROR to given logger.
  *
@@ -46,14 +42,14 @@ exports.createExceptionLogger = createExceptionLogger;
  * @see {@link DtLogger.log}
  * @see {@link createExceptionLogger} for a curried setup
  */
-function logException(logger, error, includeStack = false) {
+export function logException(logger, error, includeStack = false) {
     const message = error instanceof Error
         ? error.message
         : typeof error === "string"
             ? error
             : JSON.stringify(error);
     const stack = error instanceof Error && includeStack ? error.stack : undefined;
-    const customCode = error instanceof axios_1.AxiosError ? error.code : undefined;
+    const customCode = error instanceof AxiosError ? error.code : undefined;
     logger.error({
         type: "Error",
         method: `${functionName}.logException`,
@@ -62,5 +58,4 @@ function logException(logger, error, includeStack = false) {
         stack,
     });
 }
-exports.logException = logException;
-//# sourceMappingURL=logging.js.map
+//# sourceMappingURL=logging.mjs.map

package/dist/utils/{retry.js → retry.mjs}

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryRequest = exports.retry = exports.retryCount = exports.retryPredicates = exports.timeoutFunctions = exports.RetryLogError = void 0;
-const http_error_1 = require("../types/http-error");
-const async_timeout_error_1 = require("../types/async-timeout-error");
-const dt_logger_default_1 = require("../aws/runtime/dt-logger-default");
-var RetryLogError;
+import { HttpError } from "../types/http-error.mjs";
+import { AsyncTimeoutError } from "../types/async-timeout-error.mjs";
+import { logger } from "../aws/runtime/dt-logger-default.mjs";
+export 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 = RetryLogError = {}));
+})(RetryLogError || (RetryLogError = {}));
 /**
  * Utility timeout functions for "retry" function.
  */
-exports.timeoutFunctions = (function () {
+export const timeoutFunctions = (function () {
     return {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         noTimeout: (retryCount) => {
@@ -27,7 +24,7 @@ exports.timeoutFunctions = (function () {
 /**
  * Utility retry predicates for "retry" function.
  */
-exports.retryPredicates = (function () {
+export const retryPredicates = (function () {
     const retryStatusCodes = new Set([
         // service might return 403 for no apparent reason
         403,
@@ -36,7 +33,7 @@ exports.retryPredicates = (function () {
     ]);
     return {
         retryBasedOnStatusCode: (error) => {
-            if (error instanceof http_error_1.HttpError) {
+            if (error instanceof HttpError) {
                 return retryStatusCodes.has(error.statusCode);
             }
             return false;
@@ -54,7 +51,7 @@ function readPossibleErrorMessage(error) {
     return "Something else than an Error object was thrown";
 }
 // Tämä muuttuja on testejä varten määritelty täällä.
-exports.retryCount = 0;
+export let retryCount = 0;
 async function retryRecursive(asyncFn, retries, retryCountInj, logError, timeoutBetweenRetries, retryPredicate) {
     const asyncFnTimeout = 30 * 60 * 1000; // 30 minutes
     if (!isFinite(retries)) {
@@ -68,46 +65,46 @@ async function retryRecursive(asyncFn, retries, retryCountInj, logError, timeout
         // then the rest of async/await pairs will be called even though AysncTimeoutError is allready thrown.
         const result = await Promise.race([
             asyncFn(),
-            new Promise((_, reject) => setTimeout(() => reject(new async_timeout_error_1.AsyncTimeoutError()), asyncFnTimeout)),
+            new Promise((_, reject) => setTimeout(() => reject(new AsyncTimeoutError()), asyncFnTimeout)),
         ]);
         return result;
     }
     catch (error) {
         const remainingRetries = retries - 1;
         if (logError === RetryLogError.LOG_ALL_AS_ERRORS) {
-            dt_logger_default_1.logger.error({
+            logger.error({
                 message: readPossibleErrorMessage(error),
                 method: "retry.retryRecursive",
             });
         }
         else if (logError === RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS) {
             if (remainingRetries < 0) {
-                dt_logger_default_1.logger.error({
+                logger.error({
                     message: readPossibleErrorMessage(error),
                     method: "retry.retryRecursive",
                 });
             }
             else {
-                dt_logger_default_1.logger.warn({
+                logger.warn({
                     message: readPossibleErrorMessage(error),
                     method: "retry.retryRecursive",
                 });
             }
         }
         if (remainingRetries < 0) {
-            dt_logger_default_1.logger.warn({
+            logger.warn({
                 message: "No retries left",
                 method: "retry.retryRecursive",
             });
             throw new Error("No retries left");
         }
-        dt_logger_default_1.logger.warn({
+        logger.warn({
             message: `Retrying with remaining retries ${remainingRetries}`,
             method: "retry.retryRecursive",
         });
         if (retryPredicate(error)) {
             retryCountInj++;
-            exports.retryCount = retryCountInj;
+            retryCount = retryCountInj;
             const milliseconds = timeoutBetweenRetries(retryCountInj);
             if (milliseconds > 0) {
                 await new Promise((resolve) => setTimeout(resolve, milliseconds));
@@ -128,21 +125,19 @@ async function retryRecursive(asyncFn, retries, retryCountInj, logError, timeout
  * @param retryPredicate A function that returns true if the error should be retried. Default is a function that always returns true. The function is called with the error object.
  * @return Promise return value
  */
-async function retry(asyncFn, retries = 3, logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS, timeoutBetweenRetries = exports.timeoutFunctions.noTimeout, retryPredicate = exports.retryPredicates.alwaysRetry) {
-    exports.retryCount = 0;
-    dt_logger_default_1.logger.debug({
+export async function retry(asyncFn, retries = 3, logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS, timeoutBetweenRetries = timeoutFunctions.noTimeout, retryPredicate = retryPredicates.alwaysRetry) {
+    retryCount = 0;
+    logger.debug({
         message: `Retrying with ${retries} retries`,
         method: "retry.retry",
     });
     return retryRecursive(asyncFn, retries, 0, logError, timeoutBetweenRetries, retryPredicate);
 }
-exports.retry = retry;
 function wrapArgsToFn(fn, ...args) {
     return async () => await fn(...args);
 }
-async function retryRequest(request, ...args) {
+export async function retryRequest(request, ...args) {
     const asyncFn = wrapArgsToFn(request, ...args);
-    return retry(asyncFn, 5, RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS, exports.timeoutFunctions.exponentialTimeout, exports.retryPredicates.retryBasedOnStatusCode);
+    return retry(asyncFn, 5, RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS, timeoutFunctions.exponentialTimeout, retryPredicates.retryBasedOnStatusCode);
 }
-exports.retryRequest = retryRequest;
-//# sourceMappingURL=retry.js.map
+//# sourceMappingURL=retry.mjs.map

package/dist/utils/slack.mjs

@@ -0,0 +1,23 @@
+import axios from "axios";
+import { logger } from "../aws/runtime/dt-logger-default.mjs";
+import { logException } from "./logging.mjs";
+export class SlackApi {
+    constructor(url) {
+        this.url = url;
+    }
+    async notify(text) {
+        try {
+            logger.info({
+                method: "SlackApi.notify",
+                message: "Sending slack notification",
+            });
+            await axios.post(this.url, {
+                text,
+            });
+        }
+        catch (error) {
+            logException(logger, error);
+        }
+    }
+}
+//# sourceMappingURL=slack.mjs.map

package/dist/utils/{utils.d.ts → utils.d.mts}

@@ -1,5 +1,5 @@
-import { AwsEnv } from "../types/aws-env";
-import { Either } from "../types/either";
+import { AwsEnv } from "../types/aws-env.mjs";
+import { Either } from "../types/either.mjs";
 /**
  * Check if arrays have only elements that also exists also in other array.
  * Individual element count doesn't matter.

package/dist/utils/{utils.js → utils.mjs}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getErrorMessage = exports.hasOwnPropertySafe = exports.setSecretOverideAwsRegionEnv = exports.getEnvVariableOrElse = exports.getEnvVariableOr = exports.setEnvVariable = exports.getEnvVariableSafe = exports.getEnvVariable = exports.getAwsEnv = exports.getFirst = exports.getLast = exports.bothArraysHasSameValues = void 0;
-const environment_1 = require("../aws/runtime/environment");
+import { EnvKeys } from "../aws/runtime/environment.mjs";
 /**
  * Check if arrays have only elements that also exists also in other array.
  * Individual element count doesn't matter.
@@ -23,7 +20,7 @@ const environment_1 = require("../aws/runtime/environment");
  * @param a first array to compare
  * @param b second array to compare
  */
-function bothArraysHasSameValues(a, b) {
+export function bothArraysHasSameValues(a, b) {
     if ((a && !b) || (!a && b)) {
         return false;
     }
@@ -37,21 +34,18 @@ function bothArraysHasSameValues(a, b) {
     }
     return Array.from(aSet).every((value) => bSet.has(value));
 }
-exports.bothArraysHasSameValues = bothArraysHasSameValues;
 /**
  * Returns the last item on the array.  If the array is empty, throws an error!
  */
-function getLast(array, sortFunction) {
+export function getLast(array, sortFunction) {
     return getFirstOrLast(false, array, sortFunction);
 }
-exports.getLast = getLast;
 /**
  * Returns the first item on the array.  If the array is empty, throws an error!
  */
-function getFirst(array, sortFunction) {
+export function getFirst(array, sortFunction) {
     return getFirstOrLast(true, array, sortFunction);
 }
-exports.getFirst = getFirst;
 function getFirstOrLast(getFirst, array, sortFunction) {
     if (array.length == 0) {
         throw new Error(`can't get ${getFirst ? "first" : "last"} from empty array!`);
@@ -69,26 +63,24 @@ function getFirstOrLast(getFirst, array, sortFunction) {
  * @return string
  * @See https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html
  */
-function getAwsEnv() {
+export function getAwsEnv() {
     return {
         region: getEnvVariable("AWS_REGION"),
     };
 }
-exports.getAwsEnv = getAwsEnv;
 /**
  * Gets environment variable. Throws error if variable is not found.
  *
  * @param key Environment key
  * @return string
  */
-function getEnvVariable(key) {
+export function getEnvVariable(key) {
     const either = getEnvVariableSafe(key);
     if (either.result === "error") {
         throw new Error(either.message);
     }
     return either.value;
 }
-exports.getEnvVariable = getEnvVariable;
 /**
  * Gets environment variable. Safe version returns object with either ok or error status.
  * Easier to use for recovery than catching an error.
@@ -96,7 +88,7 @@ exports.getEnvVariable = getEnvVariable;
  * @param key Environment key
  * @return Either<string>
  */
-function getEnvVariableSafe(key) {
+export function getEnvVariableSafe(key) {
     const value = process.env[key];
     if (value === undefined) {
         return {
@@ -106,31 +98,28 @@ function getEnvVariableSafe(key) {
     }
     return { result: "ok", value };
 }
-exports.getEnvVariableSafe = getEnvVariableSafe;
 /**
  * Sets environment variable.
  *
  * @param key Environment key
  * @param value Environment variable value
  */
-function setEnvVariable(key, value) {
+export function setEnvVariable(key, value) {
     process.env[key] = value;
 }
-exports.setEnvVariable = setEnvVariable;
 /**
  * Gets environment variable. If environment variable is undefined, returns value of given function.
  *
  * @param key Environment key
  * @param fn Alternative function
  */
-function getEnvVariableOr(key, fn) {
+export function getEnvVariableOr(key, fn) {
     const either = getEnvVariableSafe(key);
     if (either.result === "ok") {
         return either.value;
     }
     return fn();
 }
-exports.getEnvVariableOr = getEnvVariableOr;
 /**
  * Gets environment variable. If environment variable is undefined, returns given value.
  * Use to return an explicit alternative value e.g. in cases where environment variable may be undefined.
@@ -138,14 +127,12 @@ exports.getEnvVariableOr = getEnvVariableOr;
  * @param key Environment key
  * @param orElse Alternative value
  */
-function getEnvVariableOrElse(key, orElse) {
+export function getEnvVariableOrElse(key, orElse) {
     return getEnvVariableOr(key, () => orElse);
 }
-exports.getEnvVariableOrElse = getEnvVariableOrElse;
-function setSecretOverideAwsRegionEnv(region) {
-    setEnvVariable(environment_1.EnvKeys.SECRET_OVERRIDE_AWS_REGION, region);
+export function setSecretOverideAwsRegionEnv(region) {
+    setEnvVariable(EnvKeys.SECRET_OVERRIDE_AWS_REGION, region);
 }
-exports.setSecretOverideAwsRegionEnv = setSecretOverideAwsRegionEnv;
 /**
  * ESLint won't allow to call Object.prototype builtin methods.
  * To call hasOwnProperty we must use Object.prototype.hasOwnProperty.call()
@@ -153,19 +140,17 @@ exports.setSecretOverideAwsRegionEnv = setSecretOverideAwsRegionEnv;
  * @param propertyName property name to check
  * @see https://eslint.org/docs/latest/rules/no-prototype-builtins
  */
-function hasOwnPropertySafe(object, propertyName) {
+export function hasOwnPropertySafe(object, propertyName) {
     return Object.prototype.hasOwnProperty.call(object, propertyName);
 }
-exports.hasOwnPropertySafe = hasOwnPropertySafe;
 /**
  * Return an error message from the given object hat might be an Error object.
  * @param maybeError
  */
-function getErrorMessage(maybeError) {
+export function getErrorMessage(maybeError) {
     if (maybeError instanceof Error) {
         return maybeError.name + ": " + maybeError.message;
     }
     return String(maybeError);
 }
-exports.getErrorMessage = getErrorMessage;
-//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=utils.mjs.map