@digitraffic/common 2026.3.17-1 → 2026.3.26-1-beta

package/dist/__test__/infra/api/integration.test.js

@@ -0,0 +1,162 @@
+import { App, Stack } from "aws-cdk-lib";
+import { Code, Function as LambdaFunction, Runtime, } from "aws-cdk-lib/aws-lambda";
+import velocity from "velocityjs";
+import { describe, expect, test } from "vitest";
+import { DigitrafficIntegration } from "../../../aws/infra/api/integration.js";
+import { MediaType } from "../../../aws/types/mediatypes.js";
+import { decodeBase64ToAscii } from "../../../utils/base64.js";
+describe("integration tests", () => {
+    function createTemplate(i) {
+        const template = i
+            .createRequestTemplates()[MediaType.APPLICATION_JSON].trim();
+        // assert template parses
+        const response = createResponseFromTemplate(template);
+        // assert response parses
+        console.info(`response ${response}`);
+        return JSON.parse(response);
+    }
+    function createResponseFromTemplate(template) {
+        console.info(`compile ${template}`);
+        const compile = new velocity.Compile(velocity.parse(template));
+        return compile.render({
+            method: {
+                request: {
+                    multivaluequerystring: {
+                        m1: ["multi1", "multi2"],
+                    },
+                },
+            },
+            input: {
+                body: '{ body: "\'moi" }',
+                params: () => ({
+                    header: {
+                        h1: "header1",
+                    },
+                    querystring: {
+                        q1: "querystring1",
+                        q2: "querystring2",
+                    },
+                    path: {
+                        p1: "path1",
+                    },
+                }),
+            },
+            util: {
+                base64Encode: (data) => Buffer.from(data).toString("base64"),
+                base64Decode: decodeBase64ToAscii,
+                escapeJavaScript: (data) => encodeURIComponent(data),
+                parseJson: (data) => JSON.stringify(data),
+            },
+            context: {
+                c1: "context1",
+                authorizer: {
+                    c2: "context2",
+                },
+            },
+        });
+    }
+    function createIntegration() {
+        const app = new App();
+        const stack = new Stack(app);
+        const f = new LambdaFunction(stack, "id", {
+            runtime: Runtime.NODEJS_24_X,
+            code: Code.fromInline("placeholder"),
+            handler: "handler",
+        });
+        return new DigitrafficIntegration(f);
+    }
+    test("no parameters", () => {
+        const i = createIntegration();
+        const t = createTemplate(i);
+        expect(t).toEqual({});
+    });
+    test("query parameter", () => {
+        const i = createIntegration().addQueryParameter("q1");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            q1: "querystring1",
+        });
+    });
+    test("two query parameters", () => {
+        const i = createIntegration()
+            .addQueryParameter("q1")
+            .addQueryParameter("q2");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            q1: "querystring1",
+            q2: "querystring2",
+        });
+    });
+    test("multivaluequery parameter", () => {
+        const i = createIntegration().addMultiValueQueryParameter("m1");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            m1: ["multi1", "multi2"],
+        });
+    });
+    test("all parameters", () => {
+        const i = createIntegration().passAllQueryParameters();
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            q1: "querystring1",
+            q2: "querystring2",
+        });
+    });
+    test("path parameter", () => {
+        const i = createIntegration().addPathParameter("p1");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            p1: "path1",
+        });
+    });
+    test("context parameter", () => {
+        const i = createIntegration().addContextParameter("c1");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            c1: "context1",
+        });
+    });
+    test("context parameter authorizer", () => {
+        const i = createIntegration().addContextParameter("authorizer.c2");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            "authorizer.c2": "context2",
+        });
+    });
+    test("all parameters and header", () => {
+        const i = createIntegration()
+            .passAllQueryParameters()
+            .addHeaderParameter("h1");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            h1: "header1",
+            q1: "querystring1",
+            q2: "querystring2",
+        });
+    });
+    test("all parameters & parameter - fail", () => {
+        expect(() => {
+            createIntegration().passAllQueryParameters().addQueryParameter("q1");
+        }).toThrow();
+    });
+    test("path parameters & pass all ", () => {
+        const i = createIntegration()
+            .addPathParameter("p1")
+            .passAllQueryParameters();
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            p1: "path1",
+            q1: "querystring1",
+            q2: "querystring2",
+        });
+    });
+    test("path body", () => {
+        const i = createIntegration().passBody();
+        const t = createTemplate(i);
+        // body base64-encoded
+        expect(t).toEqual({
+            payload: "eyBib2R5OiAiJ21vaSIgfQ==",
+        });
+    });
+});
+//# sourceMappingURL=integration.test.js.map

package/dist/__test__/infra/api/response.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/infra/api/response.test.js

@@ -0,0 +1,77 @@
+import etag from "etag";
+import velocity from "velocityjs";
+import { describe, expect, test } from "vitest";
+import { RESPONSE_DEFAULT_LAMBDA } from "../../../aws/infra/api/response.js";
+const TEST_BODY = "Hello world!";
+describe("response tests", () => {
+    function generateEtagValueFromString(body) {
+        return generateEtagValueFromBase64String(Buffer.from(body).toString("base64"));
+    }
+    function generateEtagValueFromBase64String(bodyBase64) {
+        return etag(bodyBase64);
+    }
+    function generateResponse(status, fileName, timestamp) {
+        const compile = new velocity.Compile(velocity.parse(RESPONSE_DEFAULT_LAMBDA));
+        const output = compile.render({
+            input: {
+                path: () => ({
+                    body: Buffer.from(TEST_BODY).toString("base64"),
+                    status,
+                    fileName,
+                    timestamp: timestamp?.toUTCString(),
+                    etag: generateEtagValueFromString(TEST_BODY),
+                }),
+            },
+            util: {
+                base64Decode: (data) => Buffer.from(data, "base64").toString(),
+            },
+            context: {
+                responseOverride: {
+                    status: undefined,
+                    header: {
+                        "Content-Type": undefined,
+                        "Access-Control-Allow-Origin": undefined,
+                        ETag: undefined,
+                        "Last-Modified": undefined,
+                        "Content-Disposition": undefined,
+                    },
+                },
+            },
+        });
+        // @ts-expect-error: context is not in the type definition
+        return [output, compile.context.context];
+    }
+    function assertOutputAndContext(output, context, status, contentType, fileName, timestamp) {
+        expect(output).toEqual(TEST_BODY);
+        expect(context).toMatchObject({
+            responseOverride: {
+                status,
+                header: {
+                    "Content-Type": contentType,
+                    "Access-Control-Allow-Origin": "*",
+                    "Content-Disposition": fileName,
+                    "Last-Modified": timestamp?.toUTCString(),
+                    ETag: generateEtagValueFromString(TEST_BODY),
+                },
+            },
+        });
+    }
+    test("test 200", () => {
+        const [output, context] = generateResponse(200);
+        assertOutputAndContext(output, context);
+    });
+    test("test 200 - filename", () => {
+        const [output, context] = generateResponse(200, "test.txt");
+        assertOutputAndContext(output, context, undefined, undefined, 'attachment; filename="test.txt"');
+    });
+    test("test 200 - filename and timestamp", () => {
+        const now = new Date();
+        const [output, context] = generateResponse(200, "test.txt", now);
+        assertOutputAndContext(output, context, undefined, undefined, 'attachment; filename="test.txt"', now);
+    });
+    test("test 204", () => {
+        const [output, context] = generateResponse(204);
+        assertOutputAndContext(output, context, 204, "text/plain");
+    });
+});
+//# sourceMappingURL=response.test.js.map

package/dist/__test__/infra/api/static-integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/infra/api/static-integration.test.js

@@ -0,0 +1,35 @@
+import { Model } from "aws-cdk-lib/aws-apigateway";
+import { describe, expect, test } from "vitest";
+import { DigitrafficStaticIntegration } from "../../../aws/infra/api/static-integration.js";
+import { MediaType } from "../../../aws/types/mediatypes.js";
+describe("response tests", () => {
+    test("createIntegrationResponse works", () => {
+        const integrationResponse = DigitrafficStaticIntegration.createIntegrationResponse("FakeResource", MediaType.APPLICATION_JSON, { "test-header": "test-value" });
+        expect(integrationResponse).toEqual({
+            responseParameters: {
+                "method.response.header.test-header": "'test-value'",
+            },
+            responseTemplates: {
+                "application/json": "FakeResource",
+            },
+            statusCode: "200",
+        });
+    });
+    test("createMethodResponse works", () => {
+        const methodResponse = DigitrafficStaticIntegration.createMethodResponse({
+            "test-header": "test-value",
+        }, MediaType.TEXT_PLAIN, Model.EMPTY_MODEL);
+        expect(methodResponse).toEqual({
+            responseModels: {
+                "text/plain": {
+                    modelId: "Empty",
+                },
+            },
+            responseParameters: {
+                "method.response.header.test-header": true,
+            },
+            statusCode: "200",
+        });
+    });
+});
+//# sourceMappingURL=static-integration.test.js.map

package/dist/__test__/infra/documentation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/infra/documentation.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "vitest";
+import { DocumentationPart } from "../../aws/infra/documentation.js";
+const METHOD_NAME = "test";
+const SUMMARY = "summary";
+const PARAMETER_NAME = "parameter";
+const DESCRIPTION = "description";
+const DEPRECATION_NOTE = "note";
+describe("DocumentationPart tests", () => {
+    test("method", () => {
+        const part = DocumentationPart.method([], METHOD_NAME, SUMMARY);
+        expect(part.type).toEqual("METHOD");
+        expect(part.parameterName).toEqual(METHOD_NAME);
+        expect(part.documentationProperties.summary).toEqual(SUMMARY);
+        expect(part.documentationProperties.deprecated).toBeFalsy();
+    });
+    test("method - deprecated", () => {
+        const part = DocumentationPart.method([], METHOD_NAME, SUMMARY).deprecated(DEPRECATION_NOTE);
+        expect(part.type).toEqual("METHOD");
+        expect(part.parameterName).toEqual(METHOD_NAME);
+        expect(part.documentationProperties.summary).toEqual(`${SUMMARY}. ${DEPRECATION_NOTE}`);
+        expect(part.documentationProperties.deprecated).toBeTruthy();
+    });
+    test("queryparameter", () => {
+        const part = DocumentationPart.queryParameter(PARAMETER_NAME, DESCRIPTION);
+        expect(part.type).toEqual("QUERY_PARAMETER");
+        expect(part.parameterName).toEqual(PARAMETER_NAME);
+        expect(part.documentationProperties.description).toEqual(DESCRIPTION);
+        expect(part.documentationProperties.deprecated).toBeFalsy();
+    });
+    test("pathparameter", () => {
+        const part = DocumentationPart.pathParameter(PARAMETER_NAME, DESCRIPTION);
+        expect(part.type).toEqual("PATH_PARAMETER");
+        expect(part.parameterName).toEqual(PARAMETER_NAME);
+        expect(part.documentationProperties.description).toEqual(DESCRIPTION);
+        expect(part.documentationProperties.deprecated).toBeFalsy();
+    });
+});
+//# sourceMappingURL=documentation.test.js.map

package/dist/__test__/infra/scheduler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/infra/scheduler.test.js

@@ -0,0 +1,23 @@
+import { App, Stack } from "aws-cdk-lib";
+import { Template } from "aws-cdk-lib/assertions";
+import { describe, test } from "vitest";
+import { Scheduler } from "../../aws/infra/scheduler.js";
+describe("scheduler tests", () => {
+    function expectRate(createScheduler, expectedRate) {
+        const app = new App();
+        const stack = new Stack(app);
+        createScheduler(stack);
+        const template = Template.fromStack(stack);
+        template.hasResource("AWS::Events::Rule", {
+            Properties: {
+                ScheduleExpression: expectedRate,
+                State: "ENABLED",
+            },
+        });
+    }
+    test("everyMinute", () => expectRate((stack) => Scheduler.everyMinute(stack, "test"), "rate(1 minute)"));
+    test("everyMinutes", () => expectRate((stack) => Scheduler.everyMinutes(stack, "test", 12), "rate(12 minutes)"));
+    test("everyHour", () => expectRate((stack) => Scheduler.everyHour(stack, "test"), "rate(1 hour)"));
+    test("everyDay", () => expectRate((stack) => Scheduler.everyDay(stack, "test"), "rate(1 day)"));
+});
+//# sourceMappingURL=scheduler.test.js.map

package/dist/__test__/infra/security-rule.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/infra/security-rule.test.js

@@ -0,0 +1,21 @@
+import { App, Stack } from "aws-cdk-lib";
+import { Template } from "aws-cdk-lib/assertions";
+import { Topic } from "aws-cdk-lib/aws-sns";
+import { describe, test } from "vitest";
+import { DigitrafficSecurityRule } from "../../aws/infra/security-rule.js";
+describe("security-rule tests", () => {
+    test("create", () => {
+        const app = new App();
+        const stack = new Stack(app);
+        const topic = new Topic(stack, "test");
+        new DigitrafficSecurityRule(stack, topic);
+        const template = Template.fromStack(stack);
+        template.hasResource("AWS::Events::Rule", {
+            Properties: {
+                EventPattern: {},
+                State: "ENABLED",
+            },
+        });
+    });
+});
+//# sourceMappingURL=security-rule.test.js.map

package/dist/__test__/infra/stack/rest-apis.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/infra/stack/rest-apis.test.js

@@ -0,0 +1,47 @@
+import { App } from "aws-cdk-lib";
+import { describe, expect, test } from "vitest";
+import { DigitrafficRestApi } from "../../../aws/infra/stack/rest-api.js";
+import { DigitrafficStack } from "../../../aws/infra/stack/stack.js";
+describe("DigitrafficRestApi tests", () => {
+    function createRestApi() {
+        const app = new App();
+        const stack = new DigitrafficStack(app, "name", {
+            shortName: "TEST",
+        });
+        return new DigitrafficRestApi(stack, "id", "name");
+    }
+    test("exportEndpoint - no apikeys", () => {
+        expect(() => {
+            const restApi = createRestApi();
+            restApi.exportEndpoint();
+        }).toThrow("No apikeys to export");
+    });
+    test("exportEndpoint - multiple keys", () => {
+        expect(() => {
+            const restApi = createRestApi();
+            restApi.apiKeyIds.push("key1");
+            restApi.apiKeyIds.push("key2");
+            restApi.exportEndpoint();
+        }).toThrow("Multiple apikeys, configure which to export");
+    });
+    test("exportEndpoint - multiple keys, set key", () => {
+        const restApi = createRestApi();
+        restApi.apiKeyIds.push("key1");
+        restApi.apiKeyIds.push("key2");
+        const [sp1, sp2] = restApi.exportEndpoint({
+            apiKeyId: "key3",
+        });
+        expect(sp1.node.id).toEqual("export.endpoint.TEST");
+        expect(sp2.node.id).toEqual("export.apiKeyId.TEST");
+    });
+    test("exportEndpoint - override name", () => {
+        const restApi = createRestApi();
+        restApi.apiKeyIds.push("key1");
+        const [sp1, sp2] = restApi.exportEndpoint({
+            exportName: "exp1",
+        });
+        expect(sp1.node.id).toEqual("export.endpoint.exp1");
+        expect(sp2.node.id).toEqual("export.apiKeyId.exp1");
+    });
+});
+//# sourceMappingURL=rest-apis.test.js.map

package/dist/__test__/marine/id_utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/marine/id_utils.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "vitest";
+import { getRandomNumber } from "../../__test__/testutils.js";
+import * as IdUtils from "../../marine/id_utils.js";
+describe("IdUtils tests", () => {
+    test("isValidLOCODE - success", () => {
+        expect(IdUtils.isValidLOCODE("FILOL")).toBe(true);
+    });
+    test("isValidLOCODE - fail with non-finnish prefix", () => {
+        expect(IdUtils.isValidLOCODE("SEABS")).toBe(false);
+    });
+    test("isValidLOCODE - fail with numbers", () => {
+        expect(IdUtils.isValidLOCODE("FIAA1")).toBe(false);
+    });
+    test("isValidIMO - successful checksum - ship TRANSMAR", () => {
+        expect(IdUtils.isValidIMO(9167332)).toBe(true);
+    });
+    test("isValidIMO - successful checksum - ship ANNIKA B", () => {
+        expect(IdUtils.isValidIMO(9213715)).toBe(true);
+    });
+    test("isValidIMO - successful checksum - ship X PRESS ELBE", () => {
+        expect(IdUtils.isValidIMO(9483669)).toBe(true);
+    });
+    test("isValidIMO - successful checksum - ship SILVERFORS", () => {
+        expect(IdUtils.isValidIMO(8322765)).toBe(true);
+    });
+    test("isValidIMO - invalid checksum", () => {
+        expect(IdUtils.isValidIMO(8322766)).toBe(false);
+    });
+    test("isValidIMO - fail with number smaller than 1000000", () => {
+        expect(IdUtils.isValidIMO(getRandomNumber(0, 1000000 - 1))).toBe(false);
+    });
+    test("isValidIMO - fail with number larger than 9999999", () => {
+        expect(IdUtils.isValidIMO(getRandomNumber(9999999 + 1, 99999999))).toBe(false);
+    });
+    test("isValidMMSI - success", () => {
+        expect(IdUtils.isValidMMSI(230927000)).toBe(true);
+    });
+    test("isValidMMSI - fail with number smaller than 100000000", () => {
+        expect(IdUtils.isValidMMSI(getRandomNumber(0, 100000000 - 1))).toBe(false);
+    });
+    test("isValidMMSI - fail with number larger than 999999999", () => {
+        expect(IdUtils.isValidMMSI(getRandomNumber(999999999 + 1, 9999999999))).toBe(false);
+    });
+});
+//# sourceMappingURL=id_utils.test.js.map

package/dist/__test__/mock-ky.d.ts

@@ -0,0 +1,2 @@
+import type { ResponsePromise } from "ky";
+export declare function mockKyResponse(status: number, body: string): ResponsePromise;

package/dist/__test__/mock-ky.js

@@ -0,0 +1,15 @@
+export function mockKyResponse(status, body) {
+    const response = new Response(body, {
+        status: status,
+    });
+    const promise = Promise.resolve(response);
+    // The ky ResponsePromise is just Promise<Response> with some convenience methods.
+    return Object.assign(promise, {
+        arrayBuffer: () => response.arrayBuffer(),
+        blob: () => response.blob(),
+        formData: () => response.formData(),
+        json: () => response.json(),
+        text: () => response.text(),
+    });
+}
+//# sourceMappingURL=mock-ky.js.map

package/dist/__test__/promise/promise.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/promise/promise.test.js

@@ -0,0 +1,126 @@
+import { describe, expect, test, vi } from "vitest";
+import { getRandomInteger } from "../../__test__/testutils.js";
+import { logger } from "../../aws/runtime/dt-logger-default.js";
+import { RetryLogError, retry } from "../../utils/retry.js";
+vi.useFakeTimers();
+describe("Promise utils tests", () => {
+    test("retry - no retries", async () => {
+        const fn = vi.fn(() => Promise.resolve(1));
+        const ret = await retry(fn, 0, RetryLogError.NO_LOGGING);
+        expect(ret).toBe(1);
+        expect(fn.mock.calls.length).toBe(1);
+    });
+    test("retry - error with n+1 retries", async () => {
+        const fn = vi.fn(() => Promise.reject("error"));
+        const retries = getRandomInteger(1, 10);
+        try {
+            await retry(fn, retries, RetryLogError.NO_LOGGING);
+        }
+        catch {
+            // ignore
+        }
+        finally {
+            expect(fn.mock.calls.length).toBe(retries + 1);
+        }
+    });
+    test("retry - no error with n+1 retries", async () => {
+        const fn = vi.fn(() => Promise.resolve(1));
+        const retries = getRandomInteger(1, 10);
+        const ret = await retry(fn, retries, RetryLogError.NO_LOGGING);
+        expect(ret).toBe(1);
+        expect(fn.mock.calls.length).toBe(1);
+    });
+    test("retry - errors with no error logging", async () => {
+        const fn = vi.fn(() => Promise.reject("error"));
+        const consoleErrorSpy = vi.spyOn(logger, "error");
+        try {
+            await retry(fn, getRandomInteger(0, 10), RetryLogError.NO_LOGGING);
+        }
+        catch {
+            // ignore
+        }
+        finally {
+            expect(consoleErrorSpy).toHaveBeenCalledTimes(0);
+            consoleErrorSpy.mockRestore();
+        }
+    });
+    test("retry - no retries with error logging", async () => {
+        const fn = vi.fn(() => Promise.reject("error"));
+        const consoleErrorSpy = vi.spyOn(logger, "error");
+        try {
+            await retry(fn, 0, RetryLogError.LOG_ALL_AS_ERRORS);
+        }
+        catch {
+            // ignore
+        }
+        finally {
+            expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+            consoleErrorSpy.mockRestore();
+        }
+    });
+    test("retry - retries with error logging", async () => {
+        const fn = vi.fn(() => Promise.reject("error"));
+        const retries = getRandomInteger(1, 10);
+        const consoleErrorSpy = vi.spyOn(logger, "error");
+        try {
+            await retry(fn, retries, RetryLogError.LOG_ALL_AS_ERRORS);
+        }
+        catch {
+            // ignore
+        }
+        finally {
+            expect(consoleErrorSpy).toHaveBeenCalledTimes(retries + 1);
+            consoleErrorSpy.mockRestore();
+        }
+    });
+    test("retry - exceeded retry count throws error", async () => {
+        const fn = vi.fn(() => Promise.reject("error"));
+        await expect(() => retry(fn, 3, RetryLogError.LOG_ALL_AS_ERRORS)).rejects.toThrow();
+    });
+    test("retry - defaults", async () => {
+        const fn = vi.fn(() => Promise.reject("error"));
+        const consoleErrorSpy = vi.spyOn(logger, "error");
+        try {
+            await retry(fn);
+        }
+        catch {
+            // ignore
+        }
+        finally {
+            expect(fn.mock.calls.length).toBe(3 + 1);
+            expect(consoleErrorSpy).toHaveBeenCalledTimes(1); // last retry
+        }
+    });
+    test("retry - NaN throws error", async () => {
+        const fn = vi.fn(() => Promise.resolve(NaN));
+        await expect(() => retry(fn, NaN, RetryLogError.NO_LOGGING)).rejects.toThrow();
+    });
+    test("retry - Infinity throws error", async () => {
+        const fn = vi.fn(() => Promise.resolve(NaN));
+        await expect(() => retry(fn, Infinity, RetryLogError.NO_LOGGING)).rejects.toThrow();
+    });
+    test("retry - exceeded maximum retry count throws error", async () => {
+        const fn = vi.fn(() => Promise.resolve(NaN));
+        await expect(() => retry(fn, getRandomInteger(101, 1000000), RetryLogError.NO_LOGGING)).rejects.toThrow();
+    });
+    test("retry - use without mocks without retry", async () => {
+        const val = 1;
+        const fn = () => Promise.resolve(val);
+        const ret = await retry(fn);
+        expect(ret).toBe(val);
+    });
+    test("retry - use without mocks with retry", async () => {
+        let i = 0;
+        const val = 1;
+        const fn = () => {
+            if (i < 3) {
+                i++;
+                throw new Error("not yet");
+            }
+            return Promise.resolve(val);
+        };
+        const ret = await retry(fn);
+        expect(ret).toBe(val);
+    });
+});
+//# sourceMappingURL=promise.test.js.map

package/dist/__test__/runtime/dt-logger.test.d.ts

@@ -0,0 +1 @@
+export {};