@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Graph/Rules/Edge/EdgeDotProperties.test.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphology_1 = require("graphology");
+const DotAdapter_js_1 = require("../../Adapters/DotAdapter.js");
+const GraphologyAdapter_js_1 = require("../../Adapters/GraphologyAdapter.js");
+const TgGraph_js_1 = require("../../TgGraph.js");
+const EdgeDotProperties_js_1 = require("./EdgeDotProperties.js");
+describe('EdgeDotProperties.constructor', () => {
+    it('shoud require options', () => {
+        expect(() => new EdgeDotProperties_js_1.EdgeDotProperties({
+            edge: { from: { any: true }, to: { any: true } },
+        })).toThrow(`Rule 'EdgeDotProperties' requires options in config`);
+    });
+});
+describe('EdgeDotProperties.supports', () => {
+    it('shoud only support DotAdapter instances', () => {
+        const rule = new EdgeDotProperties_js_1.EdgeDotProperties({
+            edge: { from: { any: true }, to: { any: true } },
+            options: { color: 'red' },
+        });
+        const dotAdapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph());
+        const graphAdapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph());
+        expect(rule.supports(dotAdapter)).toBe(true);
+        expect(rule.supports(graphAdapter)).toBe(false);
+    });
+});
+describe('EdgeDotProperties.apply', () => {
+    it('shoud store dot adapter options for matching edges', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new EdgeDotProperties_js_1.EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                color: 'red',
+                style: 'dashed',
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            weight: 1,
+            adapter: {
+                [DotAdapter_js_1.DotAdapter.name]: {
+                    color: 'red',
+                    style: 'dashed',
+                },
+            },
+        });
+    });
+    it('shoud keep graph unchanged when the hook does not match', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const hook = new EdgeDotProperties_js_1.EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.match(nodeB, node, adapter);
+        const result = hook.apply(nodeB, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    it('shoud merge dot adapter properties with existing attributes', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {
+                        adapter: {
+                            [DotAdapter_js_1.DotAdapter.name]: {
+                                style: 'dotted',
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new EdgeDotProperties_js_1.EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            adapter: {
+                [DotAdapter_js_1.DotAdapter.name]: {
+                    style: 'dotted',
+                    color: 'red',
+                },
+            },
+        });
+    });
+    it('shoud ignore outbound edges when the target does not match', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new EdgeDotProperties_js_1.EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    it('shoud return early when the source node no longer matches', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new EdgeDotProperties_js_1.EdgeDotProperties({
+            edge: {
+                from: { attr: { key: 'label', eq: 'A' } },
+                to: { any: true },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const mismatchedNode = { ...node, label: 'mismatch' };
+        const result = hook.apply(nodeA, mismatchedNode, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    it('shoud preserve non-dot adapter entries when applying dot properties', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {
+                        adapter: {
+                            OtherAdapter: { style: 'bold' },
+                        },
+                    },
+                },
+            ],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new EdgeDotProperties_js_1.EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            adapter: {
+                OtherAdapter: { style: 'bold' },
+                [DotAdapter_js_1.DotAdapter.name]: {
+                    color: 'red',
+                },
+            },
+        });
+    });
+    it('shoud fall back to empty properties when options are cleared', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: {},
+                },
+            ],
+        };
+        const adapter = new DotAdapter_js_1.DotAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const hook = new EdgeDotProperties_js_1.EdgeDotProperties({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                color: 'red',
+            },
+        });
+        hook.config.options = undefined;
+        hook.match(nodeA, node, adapter);
+        const result = hook.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            adapter: {
+                [DotAdapter_js_1.DotAdapter.name]: {},
+            },
+        });
+    });
+});

package/dist/cjs/Graph/Rules/Edge/EdgeLegend.d.ts

@@ -0,0 +1,8 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { EdgeRule } from '../Rule.js';
+import { EdgeRuleConfig } from '../RuleConfig.js';
+export declare class EdgeLegend extends EdgeRule {
+    constructor(config: EdgeRuleConfig);
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

package/dist/cjs/Graph/Rules/Edge/EdgeLegend.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeLegend = void 0;
+const Rule_js_1 = require("../Rule.js");
+class EdgeLegend extends Rule_js_1.EdgeRule {
+    constructor(config) {
+        if (config.options === undefined) {
+            throw new Error(`Rule '${EdgeLegend.name}' requires options in config`);
+        }
+        const options = config.options;
+        if (typeof options.title !== 'string' ||
+            typeof options.colour !== 'string') {
+            throw new Error(`Rule '${EdgeLegend.name}' requires options.title and options.colour`);
+        }
+        super(config);
+    }
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        let updated = graph;
+        const { from, to } = this.query;
+        if (!from.match(nodeId, node, updated)) {
+            return updated;
+        }
+        const options = this.config.options;
+        const edges = updated.outEdges(nodeId);
+        for (const edgeId of edges) {
+            const targetId = updated.edgeTarget(edgeId);
+            const target = updated.getNodeAttributes(targetId);
+            if (!target || !to.match(targetId, target, updated)) {
+                continue;
+            }
+            const current = updated.getEdgeAttributes(edgeId);
+            updated = updated.setEdge(edgeId, nodeId, targetId, {
+                ...current,
+                legend: {
+                    title: options.title,
+                    colour: options.colour,
+                },
+            });
+        }
+        return updated;
+    }
+}
+exports.EdgeLegend = EdgeLegend;
+Rule_js_1.EdgeRule.register(EdgeLegend);

package/dist/cjs/Graph/Rules/Edge/EdgeLegend.test.d.ts

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

package/dist/cjs/Graph/Rules/Edge/EdgeLegend.test.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphology_1 = require("graphology");
+const GraphologyAdapter_js_1 = require("../../Adapters/GraphologyAdapter.js");
+const TgGraph_js_1 = require("../../TgGraph.js");
+const EdgeLegend_js_1 = require("./EdgeLegend.js");
+describe('EdgeLegend.constructor', () => {
+    it('shoud require options', () => {
+        expect(() => new EdgeLegend_js_1.EdgeLegend({
+            edge: { from: { any: true }, to: { any: true } },
+        })).toThrow(`Rule 'EdgeLegend' requires options in config`);
+    });
+    it('shoud require title and colour options', () => {
+        expect(() => new EdgeLegend_js_1.EdgeLegend({
+            edge: { from: { any: true }, to: { any: true } },
+            options: {
+                title: 'Missing colour',
+            },
+        })).toThrow(`Rule 'EdgeLegend' requires options.title and options.colour`);
+    });
+});
+describe('EdgeLegend.apply', () => {
+    it('shoud set legend attributes for matching edges', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeLegend_js_1.EdgeLegend({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                title: 'Dead Letter Queue',
+                colour: '#c20202',
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({
+            weight: 1,
+            legend: {
+                title: 'Dead Letter Queue',
+                colour: '#c20202',
+            },
+        });
+    });
+    it('shoud keep graph unchanged when the rule does not match', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeB);
+        if (!node) {
+            throw new Error('Missing node attributes for node-b');
+        }
+        const rule = new EdgeLegend_js_1.EdgeLegend({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-b' } },
+            },
+            options: {
+                title: 'Dead Letter Queue',
+                colour: '#c20202',
+            },
+        });
+        rule.match(nodeB, node, adapter);
+        const result = rule.apply(nodeB, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    it('shoud ignore outbound edges when the target does not match', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeLegend_js_1.EdgeLegend({
+            edge: {
+                from: { nodeId: { eq: 'node-a' } },
+                to: { nodeId: { eq: 'node-c' } },
+            },
+            options: {
+                title: 'Dead Letter Queue',
+                colour: '#c20202',
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const result = rule.apply(nodeA, node, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+    it('shoud return early when the source node no longer matches', () => {
+        const nodeA = (0, TgGraph_js_1.asNodeId)('node-a');
+        const nodeB = (0, TgGraph_js_1.asNodeId)('node-b');
+        const edgeId = (0, TgGraph_js_1.asEdgeId)('edge-a-b');
+        const tg = {
+            schemaVersion: TgGraph_js_1.TG_SCHEMA_VERSION,
+            description: {},
+            nodes: {
+                [nodeA]: { id: nodeA, label: 'A' },
+                [nodeB]: { id: nodeB, label: 'B' },
+            },
+            edges: [
+                {
+                    id: edgeId,
+                    from: nodeA,
+                    to: nodeB,
+                    attributes: { weight: 1 },
+                },
+            ],
+        };
+        const adapter = new GraphologyAdapter_js_1.GraphologyAdapter(new graphology_1.DirectedGraph()).withTgGraph(tg);
+        const node = adapter.getNodeAttributes(nodeA);
+        if (!node) {
+            throw new Error('Missing node attributes for node-a');
+        }
+        const rule = new EdgeLegend_js_1.EdgeLegend({
+            edge: {
+                from: { attr: { key: 'label', eq: 'A' } },
+                to: { any: true },
+            },
+            options: {
+                title: 'Dead Letter Queue',
+                colour: '#c20202',
+            },
+        });
+        rule.match(nodeA, node, adapter);
+        const mismatchedNode = { ...node, label: 'mismatch' };
+        const result = rule.apply(nodeA, mismatchedNode, adapter);
+        expect(result.getEdgeAttributes(edgeId)).toEqual({ weight: 1 });
+    });
+});

package/dist/cjs/Graph/Rules/Edge/EdgeReverse.d.ts

@@ -0,0 +1,6 @@
+import { AdapterOperations } from '../../Operations/Operations.js';
+import { NodeId, TgNodeAttributes } from '../../TgGraph.js';
+import { EdgeRule } from '../Rule.js';
+export declare class EdgeReverse extends EdgeRule {
+    apply(nodeId: NodeId, node: TgNodeAttributes, graph: AdapterOperations): AdapterOperations;
+}

package/dist/cjs/Graph/Rules/Edge/EdgeReverse.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeReverse = void 0;
+const Rule_js_1 = require("../Rule.js");
+class EdgeReverse extends Rule_js_1.EdgeRule {
+    apply(nodeId, node, graph) {
+        if (!this.wasMatched(nodeId)) {
+            return graph;
+        }
+        let updated = graph;
+        const { from, to } = this.query;
+        if (!from.match(nodeId, node, updated)) {
+            return updated;
+        }
+        const inEdgeIds = updated.inEdges(nodeId);
+        for (const edgeId of inEdgeIds) {
+            const sourceId = updated.edgeSource(edgeId);
+            const source = updated.getNodeAttributes(sourceId);
+            if (!source || !to.match(sourceId, source, updated)) {
+                continue;
+            }
+            updated = updated.removeEdge(edgeId).setEdge(edgeId, nodeId, sourceId, {
+                ...updated.getEdgeAttributes(edgeId),
+            });
+        }
+        return updated;
+    }
+}
+exports.EdgeReverse = EdgeReverse;
+Rule_js_1.EdgeRule.register(EdgeReverse);

package/dist/cjs/Graph/Rules/Edge/EdgeReverse.test.d.ts

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