dot-language-support 1.5.4

package/lib/service/codeAction.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCommand = exports.getAvailableCommands = exports.getCodeActions = void 0;
+const __1 = require("../");
+const util_1 = require("./util");
+const checker_1 = require("../checker");
+const ChangeEdgeOpCommand = require("./command/ChangeEdgeOpCommand");
+const ChangeAllOtherEdgeOpsAndFixGraphCommand = require("./command/ChangeAllOtherEdgeOpsAndFixGraphCommand");
+const ConsolidateDescendantsCommand = require("./command/ConsolidateDescendantsCommand");
+const RemoveSemicolonsCommand = require("./command/RemoveSemicolons");
+const common_1 = require("./command/common");
+function getCodeActions(doc, sourceFile, range, context) {
+    let actions = getActionsFromDiagnostics(doc, sourceFile, range);
+    const general = getGeneralRefactorings(doc, sourceFile, range);
+    if (general) {
+        if (!actions)
+            actions = general;
+        else
+            actions.push.apply(actions, general);
+    }
+    return actions;
+}
+exports.getCodeActions = getCodeActions;
+function getActionsFromDiagnostics(doc, file, range) {
+    const ds = file.diagnostics;
+    if (!ds || ds.length === 0)
+        return undefined;
+    const rangeStartOffset = doc.offsetAt(range.start);
+    const rangeEndOffset = doc.offsetAt(range.end);
+    const res = [];
+    for (const d of ds) {
+        if (isInRange(rangeStartOffset, rangeEndOffset, d.start, d.end)) {
+            const commands = getCommandsForDiagnostic(doc, file, d);
+            if (commands && commands.length > 0)
+                res.push.apply(res, commands);
+        }
+    }
+    return res.length === 0 ? undefined : res;
+}
+function getGeneralRefactorings(doc, file, range) {
+    if (!file.graph)
+        return undefined;
+    const g = file.graph;
+    const kw = g.keyword;
+    const rangeStartOffset = doc.offsetAt(range.start);
+    const rangeEndOffset = doc.offsetAt(range.end);
+    const keywordStart = (0, util_1.getStart)(file, kw);
+    const res = [];
+    if (isInRange(rangeStartOffset, rangeEndOffset, keywordStart, kw.end)) {
+        if (!subtreeContainsErrors(g)) {
+            const oppositeGraphType = (0, common_1.getOppositeKind)(kw.kind);
+            const convertGraph = convertGraphTypeCommand(file, g, oppositeGraphType);
+            res.push(convertGraph);
+        }
+    }
+    if (rangeStartOffset === rangeEndOffset) {
+        const candidates = [];
+        let clickedNode = (0, checker_1.findNodeAtOffset)(g, rangeStartOffset);
+        if (clickedNode && !!clickedNode.parent) {
+            if (clickedNode.kind === __1.SyntaxKind.SemicolonToken) {
+                res.push(RemoveSemicolonsCommand.create());
+            }
+            if ((0, __1.isIdentifierNode)(clickedNode)) {
+                clickedNode = clickedNode.parent;
+            }
+            const clickedEdgeStatement = clickedNode.parent;
+            if (clickedEdgeStatement && !subtreeContainsErrors(clickedEdgeStatement)) {
+                if ((0, checker_1.isEdgeStatement)(clickedEdgeStatement)
+                    && clickedEdgeStatement.rhs.length === 1
+                    && (0, checker_1.isNodeId)(clickedEdgeStatement.source)
+                    && !(0, checker_1.edgeStatementHasAttributes)(clickedEdgeStatement)) {
+                    candidates.push(clickedEdgeStatement);
+                    const source = clickedEdgeStatement.source;
+                    const sourceText = (0, checker_1.getIdentifierText)(source.id);
+                    const graphParent = clickedEdgeStatement.parent;
+                    if (graphParent) {
+                        let hasVisitedStatement = false;
+                        let hasVisitedNodeModifier = false;
+                        (0, __1.forEachChild)(graphParent, statement => {
+                            if (statement === clickedEdgeStatement) {
+                                hasVisitedStatement = true;
+                                return undefined;
+                            }
+                            if (hasVisitedNodeModifier) {
+                                return;
+                            }
+                            else if (hasVisitedStatement) {
+                                if ((0, checker_1.isAttrStatement)(statement)
+                                    || subtreeContainsErrors(statement)) {
+                                    hasVisitedNodeModifier = true;
+                                    return true;
+                                }
+                            }
+                            if (hasVisitedStatement) {
+                                if ((0, checker_1.isEdgeStatement)(statement)
+                                    && statement.rhs.length === 1
+                                    && !(0, checker_1.edgeStatementHasAttributes)(statement)) {
+                                    const statementSource = statement.source;
+                                    if ((0, checker_1.isNodeId)(statementSource)) {
+                                        const lowerSourceText = (0, checker_1.getIdentifierText)(statementSource.id);
+                                        if (sourceText === lowerSourceText) {
+                                            candidates.push(statement);
+                                        }
+                                    }
+                                }
+                            }
+                            return undefined;
+                        });
+                    }
+                }
+                if (candidates.length > 1) {
+                    const action = ConsolidateDescendantsCommand.create(candidates, true);
+                    res.push(action);
+                }
+            }
+        }
+    }
+    return res.length === 0 ? undefined : res;
+    ;
+}
+function getCommandsForDiagnostic(doc, file, d) {
+    switch (d.code.source) {
+        case 1: return getScannerErrorCommand(doc, file, d, d.code);
+        case 2: return getParserErrorCommand(doc, file, d, d.code);
+        case 4: return getCheckerErrorCommand(doc, file, d, d.code);
+        default: return (0, util_1.assertNever)(d.code);
+    }
+}
+function getScannerErrorCommand(doc, file, d, code) {
+    console.assert(d.code.source === 1);
+    console.assert(code.source === 1);
+    return undefined;
+}
+function getParserErrorCommand(doc, file, d, code) {
+    console.assert(d.code.source === 2);
+    console.assert(code.source === 2);
+    return undefined;
+}
+function getCheckerErrorCommand(doc, file, d, code) {
+    console.assert(d.code.source === 4);
+    console.assert(code.source === 4);
+    switch (code.sub) {
+        case 0: {
+            const graph = file.graph;
+            if (!graph)
+                return undefined;
+            const allowedOp = (0, checker_1.getAllowedEdgeOperation)(graph);
+            const wrongOp = (0, common_1.getOppositeEdgeOp)(allowedOp);
+            const kwk = graph.keyword.kind;
+            const fixSingleEdge = ChangeEdgeOpCommand.create(d.start, d.end, allowedOp, wrongOp);
+            const fixAll = convertGraphTypeCommand(file, graph, kwk);
+            const convertToThisWrongType = convertGraphTypeCommand(file, graph, (0, common_1.getOppositeKind)(kwk));
+            return [
+                fixSingleEdge,
+                fixAll,
+                convertToThisWrongType,
+            ];
+        }
+    }
+}
+function convertGraphTypeCommand(file, graph, changeToGraphType) {
+    const changeToEdgeOp = (0, common_1.getAllowedOp)(changeToGraphType);
+    const allEdges = (0, checker_1.findAllEdges)(graph);
+    const edgeOffsets = allEdges
+        .filter(e => e.operation.kind !== changeToEdgeOp)
+        .map(e => ({
+        start: (0, util_1.getStart)(file, e.operation),
+        end: e.operation.end
+    }));
+    const graphTypeOffset = {
+        start: (0, util_1.getStart)(file, graph.keyword),
+        end: graph.keyword.end
+    };
+    return ChangeAllOtherEdgeOpsAndFixGraphCommand.create(edgeOffsets, changeToEdgeOp, graphTypeOffset, graph.keyword.kind, changeToGraphType);
+}
+function isInRange(rangeStartOffset, rangeEndOffset, startOffset, endOffset) {
+    if (rangeStartOffset === rangeEndOffset)
+        return startOffset <= rangeStartOffset && rangeEndOffset <= endOffset;
+    if (rangeStartOffset === startOffset && rangeEndOffset === endOffset)
+        return true;
+    return false;
+}
+const commandHandlers = {
+    ["DOT.changeEdgeOp"]: ChangeEdgeOpCommand.execute,
+    ["DOT.convertGraphType"]: ChangeAllOtherEdgeOpsAndFixGraphCommand.execute,
+    ["DOT.consolidateDescendants"]: ConsolidateDescendantsCommand.execute,
+    ["DOT.removeSemicolons"]: RemoveSemicolonsCommand.execute,
+};
+function getAvailableCommands() {
+    return Object.keys(commandHandlers);
+}
+exports.getAvailableCommands = getAvailableCommands;
+function executeCommand(doc, sourceFile, cmd) {
+    const handler = commandHandlers[cmd.command];
+    return handler === undefined
+        ? undefined
+        : handler(doc, sourceFile, cmd);
+}
+exports.executeCommand = executeCommand;
+function subtreeContainsErrors(node) {
+    if ((0, checker_1.nodeContainsErrors)(node))
+        return true;
+    let hasError = false;
+    (0, __1.forEachChild)(node, child => {
+        if ((0, checker_1.nodeContainsErrors)(child)) {
+            hasError = true;
+        }
+        if (!hasError) {
+            hasError = subtreeContainsErrors(child);
+        }
+    });
+    return hasError;
+}
+//# sourceMappingURL=codeAction.js.map

package/lib/service/colorProvider.d.ts

@@ -0,0 +1,6 @@
+import * as lst from "vscode-languageserver-types";
+import { ColorInformation, Color, ColorPresentation } from "./polyfill";
+import { SourceFile } from "../types";
+import { DocumentLike } from "../";
+export declare function getDocumentColors(doc: DocumentLike, sourceFile: SourceFile): ColorInformation[] | undefined;
+export declare function getColorRepresentations(doc: DocumentLike, sourceFile: SourceFile, color: Color, range: lst.Range): ColorPresentation[] | undefined;

package/lib/service/colorProvider.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColorRepresentations = exports.getDocumentColors = void 0;
+const util_1 = require("./util");
+const languageFacts = require("./languageFacts");
+const colorMap = languageFacts.colors;
+function getDocumentColors(doc, sourceFile) {
+    const cs = sourceFile.colors;
+    return cs
+        ? colorTableToColorInformation(doc, sourceFile, cs)
+        : undefined;
+}
+exports.getDocumentColors = getDocumentColors;
+function getColorRepresentations(doc, sourceFile, color, range) {
+    if (!color || !range)
+        return undefined;
+    const hexColor = getColorStringFromColor(color);
+    return [
+        {
+            label: '"' + hexColor + '"',
+        }
+    ];
+}
+exports.getColorRepresentations = getColorRepresentations;
+function colorTableToColorInformation(doc, sf, colors) {
+    if (!colors || colors.size === 0)
+        return [];
+    const res = [];
+    for (const [name, value] of colors) {
+        if (!name || !value)
+            continue;
+        const color = getColorFromName(name);
+        if (color) {
+            res.push({
+                range: (0, util_1.syntaxNodeToRange)(doc, sf, value.node),
+                color,
+            });
+        }
+    }
+    return res;
+}
+function getColorFromName(name) {
+    if (name.charAt(0) === "#")
+        return getHexCodeColor(name);
+    const colorAlias = colorMap[name];
+    return colorAlias
+        ? getHexCodeColor(colorAlias)
+        : undefined;
+}
+function getHexCodeColor(colorCode) {
+    const hexCode = colorCode.charAt(0) === "#"
+        ? colorCode.substring(1)
+        : colorCode;
+    const colorInt = parseInt(hexCode, 16);
+    return {
+        red: (colorInt >> 16 & 0xff) / 255.0,
+        green: (colorInt >> 8 & 0xff) / 255.0,
+        blue: (colorInt & 0xff) / 255.0,
+        alpha: hexCode.length === 8 ? (colorInt >> 24 & 0xff) / 255.0 : 1.0,
+    };
+}
+function getColorStringFromColor(c) {
+    const red = (c.red * 255) | 0;
+    const green = (c.green * 255) | 0;
+    const blue = (c.blue * 255) | 0;
+    return "#" + numberToPaddedString(red) + numberToPaddedString(green) + numberToPaddedString(blue);
+}
+function numberToPaddedString(n) {
+    const s = n.toString(16);
+    return (s.length === 1
+        ? "0" + s
+        : s).toLowerCase();
+}
+//# sourceMappingURL=colorProvider.js.map

package/lib/service/command/ChangeAllOtherEdgeOpsAndFixGraphCommand.d.ts

@@ -0,0 +1,10 @@
+import * as lst from "vscode-languageserver-types";
+import { CommandIds } from "../codeAction";
+import { GraphTypeStr, Offset, EdgeOpStr, ExecutableCommand, EdgeType, GraphType } from "./common";
+import { DocumentLike, SourceFile, CommandApplication } from "../../";
+export interface ChangeAllOtherEdgeOpsAndFixGraphCommand extends lst.Command {
+    command: CommandIds.ConvertGraphType;
+    arguments: [Offset[], EdgeOpStr, Offset, GraphTypeStr];
+}
+export declare function create(edgeOffsets: Offset[], changeEdgesTo: EdgeType, graphOffset: Offset, changeFromGraph: GraphType, changeGraphTo: GraphType): ChangeAllOtherEdgeOpsAndFixGraphCommand;
+export declare function execute(doc: DocumentLike, sourceFile: SourceFile, cmd: ExecutableCommand): CommandApplication | undefined;

package/lib/service/command/ChangeAllOtherEdgeOpsAndFixGraphCommand.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = exports.create = void 0;
+const common_1 = require("./common");
+function create(edgeOffsets, changeEdgesTo, graphOffset, changeFromGraph, changeGraphTo) {
+    const toGraph = (0, common_1.getGraphKeywordStr)(changeGraphTo);
+    const title = changeGraphTo === changeFromGraph
+        ? `Fix all edges to match ${toGraph}`
+        : `Convert ${(0, common_1.getGraphKeywordStr)(changeFromGraph)} to ${toGraph}`;
+    const edgeStr = (0, common_1.getEdgeStr)(changeEdgesTo);
+    return {
+        title,
+        command: "DOT.convertGraphType",
+        arguments: [edgeOffsets, edgeStr, graphOffset, toGraph],
+    };
+}
+exports.create = create;
+function execute(doc, sourceFile, cmd) {
+    if (!isChangeAllOtherEdgeOpsAndFixGraphCommand(cmd))
+        return undefined;
+    const [edgeOffsets, changeEdgeTo, graphOffset, changeGraphTo] = cmd.arguments;
+    const edits = edgeOffsets.map(o => {
+        const startPos = doc.positionAt(o.start);
+        const endPos = doc.positionAt(o.end);
+        return (0, common_1.createChangeToEdit)(startPos, endPos, changeEdgeTo);
+    });
+    const graphStart = doc.positionAt(graphOffset.start);
+    const graphEnd = doc.positionAt(graphOffset.end);
+    edits.push((0, common_1.createChangeToEdit)(graphStart, graphEnd, changeGraphTo));
+    return {
+        label: `Convert graph to "${changeGraphTo}"`,
+        edit: {
+            changes: {
+                [doc.uri]: edits,
+            }
+        }
+    };
+}
+exports.execute = execute;
+function isChangeAllOtherEdgeOpsAndFixGraphCommand(cmd) {
+    return cmd.command === "DOT.convertGraphType" && !!cmd.arguments && cmd.arguments.length === 4;
+}
+//# sourceMappingURL=ChangeAllOtherEdgeOpsAndFixGraphCommand.js.map

package/lib/service/command/ChangeEdgeOpCommand.d.ts

@@ -0,0 +1,10 @@
+import * as lst from "vscode-languageserver-types";
+import { CommandIds } from "../codeAction";
+import { EdgeOpStr, ExecutableCommand, EdgeType } from "./common";
+import { DocumentLike, SourceFile, CommandApplication } from "../../";
+export interface ChangeEdgeOpCommand extends lst.Command {
+    command: CommandIds.ChangeEdgeOp;
+    arguments: [number, number, EdgeOpStr];
+}
+export declare function create(startOffset: number, endOffset: number, changeTo: EdgeType, changeFrom: EdgeType): ChangeEdgeOpCommand;
+export declare function execute(doc: DocumentLike, sourceFile: SourceFile, cmd: ExecutableCommand): CommandApplication | undefined;

package/lib/service/command/ChangeEdgeOpCommand.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = exports.create = void 0;
+const lst = require("vscode-languageserver-types");
+const common_1 = require("./common");
+function create(startOffset, endOffset, changeTo, changeFrom) {
+    const from = (0, common_1.getEdgeStr)(changeFrom);
+    const to = (0, common_1.getEdgeStr)(changeTo);
+    return {
+        title: `Change "${from}" to "${to}".`,
+        command: "DOT.changeEdgeOp",
+        arguments: [startOffset, endOffset, to],
+    };
+}
+exports.create = create;
+function execute(doc, sourceFile, cmd) {
+    if (!isChangeEdgeOpCommand(cmd))
+        return undefined;
+    const [startOffset, endOffset, changeTo] = cmd.arguments;
+    const startPos = doc.positionAt(startOffset);
+    const endPos = doc.positionAt(endOffset);
+    return {
+        label: `Change of invalid edge to "${changeTo}"'"`,
+        edit: {
+            changes: {
+                [doc.uri]: [
+                    lst.TextEdit.replace(lst.Range.create(startPos, endPos), changeTo),
+                ],
+            }
+        }
+    };
+}
+exports.execute = execute;
+function isChangeEdgeOpCommand(cmd) {
+    return cmd.command === "DOT.changeEdgeOp" && !!cmd.arguments && cmd.arguments.length === 3;
+}
+//# sourceMappingURL=ChangeEdgeOpCommand.js.map

package/lib/service/command/ConsolidateDescendantsCommand.d.ts

@@ -0,0 +1,10 @@
+import * as lst from "vscode-languageserver-types";
+import { CommandIds } from "../codeAction";
+import { ExecutableCommand } from "./common";
+import { DocumentLike, SourceFile, CommandApplication, EdgeStatement } from "../../";
+export interface ConsolidateDescendantsCommand extends lst.Command {
+    command: CommandIds.ConsolidateDescendants;
+    arguments: number[];
+}
+export declare function create(statements: EdgeStatement[], below: boolean): ConsolidateDescendantsCommand;
+export declare function execute(doc: DocumentLike, sourceFile: SourceFile, cmd: ExecutableCommand): CommandApplication | undefined;

package/lib/service/command/ConsolidateDescendantsCommand.js

@@ -0,0 +1,106 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = exports.create = void 0;
+const checker_1 = require("../../checker");
+const util_1 = require("../util");
+function create(statements, below) {
+    const first = statements[0];
+    const from = (0, checker_1.getIdentifierText)(first.source.id);
+    const title = below
+        ? `Convert edges below from "${from}" to subgraph`
+        : `Convert edges from "${from}" to subgraph`;
+    return {
+        title,
+        command: "DOT.consolidateDescendants",
+        arguments: statements.map(s => s.pos),
+    };
+}
+exports.create = create;
+function unbind(statements) {
+    const res = [];
+    for (const statement of statements) {
+        const { parent } = statement, copy = __rest(statement, ["parent"]);
+    }
+    return res;
+}
+function execute(doc, sourceFile, cmd) {
+    if (!isConsolidateDescendantsCommand(cmd))
+        return undefined;
+    const g = sourceFile.graph;
+    if (!g)
+        return undefined;
+    const candidateIndexes = cmd.arguments;
+    const candidates = candidateIndexes.map(i => (0, checker_1.findNodeAtOffset)(g, i).parent.parent);
+    const first = candidates.shift();
+    const from = (0, checker_1.getIdentifierText)(first.source.id);
+    const edits = [];
+    const firstRight = first.rhs[0];
+    const firstRightTargetStart = (0, util_1.getStart)(sourceFile, firstRight.target);
+    const firstRightTargetEnd = firstRight.target.end;
+    const contents = [
+        sourceFile.content.substring(firstRightTargetStart, firstRightTargetEnd)
+    ];
+    for (const descendant of candidates) {
+        const rightItem = descendant.rhs[0];
+        const rightItemTarget = rightItem.target;
+        const rightItemTargetStart = rightItemTarget.pos;
+        const rightItemTargetEnd = rightItem.target.end;
+        const rightItemContent = sourceFile.content.substring(rightItemTargetStart, rightItemTargetEnd);
+        edits.push({
+            newText: "",
+            range: {
+                start: doc.positionAt(descendant.pos),
+                end: doc.positionAt(rightItemTargetStart),
+            }
+        });
+        edits.push({
+            newText: "",
+            range: {
+                start: doc.positionAt(rightItemTargetStart),
+                end: doc.positionAt(rightItemTargetEnd),
+            }
+        });
+        if (descendant.terminator !== undefined) {
+            edits.push({
+                newText: "",
+                range: {
+                    start: doc.positionAt((0, util_1.getStart)(sourceFile, descendant.terminator)),
+                    end: doc.positionAt(descendant.terminator.end),
+                }
+            });
+        }
+        contents.push(rightItemContent);
+    }
+    const toInsert = `{ ${contents.map(s => s.trim()).join(" ")} }`;
+    edits.push({
+        newText: toInsert,
+        range: {
+            start: doc.positionAt(firstRightTargetStart),
+            end: doc.positionAt(firstRightTargetEnd),
+        }
+    });
+    return {
+        label: `Convert edges from "${from}" to subgraph.`,
+        edit: {
+            changes: {
+                [doc.uri]: edits,
+            }
+        }
+    };
+}
+exports.execute = execute;
+function isConsolidateDescendantsCommand(cmd) {
+    return cmd.command === "DOT.consolidateDescendants" && !!cmd.arguments && cmd.arguments.length > 1;
+}
+//# sourceMappingURL=ConsolidateDescendantsCommand.js.map

package/lib/service/command/RemoveSemicolons.d.ts

@@ -0,0 +1,10 @@
+import * as lst from "vscode-languageserver-types";
+import { CommandIds } from "../codeAction";
+import { ExecutableCommand } from "./common";
+import { DocumentLike, SourceFile, CommandApplication } from "../../";
+export interface RemoveSemicolonsCommand extends lst.Command {
+    command: CommandIds.RemoveSemicolons;
+    arguments: undefined;
+}
+export declare function create(): RemoveSemicolonsCommand;
+export declare function execute(doc: DocumentLike, sourceFile: SourceFile, cmd: ExecutableCommand): CommandApplication | undefined;

package/lib/service/command/RemoveSemicolons.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = exports.create = void 0;
+const common_1 = require("./common");
+const checker_1 = require("../../checker");
+function create() {
+    return {
+        title: "Remove optional semicolons",
+        command: "DOT.removeSemicolons",
+        arguments: undefined,
+    };
+}
+exports.create = create;
+function execute(doc, sourceFile, cmd) {
+    if (!isRemoveSemicolonsCommand(cmd))
+        return undefined;
+    const g = sourceFile.graph;
+    if (!g)
+        return undefined;
+    const semicolons = (0, checker_1.findOptionalSemicolons)(g);
+    const edits = semicolons.map(s => {
+        const end = s.end;
+        const start = end - 1;
+        return (0, common_1.createChangeToEdit)(doc.positionAt(start), doc.positionAt(end), "");
+    });
+    return {
+        label: `Remove optional semicolons`,
+        edit: {
+            changes: {
+                [doc.uri]: edits,
+            }
+        }
+    };
+}
+exports.execute = execute;
+function isRemoveSemicolonsCommand(cmd) {
+    return cmd.command === "DOT.removeSemicolons"
+        && (!cmd.arguments
+            || cmd.arguments.length === 0
+            || cmd.arguments.every(e => e === undefined));
+}
+//# sourceMappingURL=RemoveSemicolons.js.map

package/lib/service/command/common.d.ts

@@ -0,0 +1,31 @@
+import * as lst from "vscode-languageserver-types";
+import { SyntaxKind } from "../../";
+import { CommandIds } from "../codeAction";
+export declare function createChangeToEdit(start: lst.Position, end: lst.Position, changeTo: string): lst.TextEdit;
+export interface Offset {
+    start: number;
+    end: number;
+}
+export declare type ExecutableCommand = {
+    command: CommandIds;
+    arguments?: any[];
+};
+export declare type EdgeOpStr = "--" | "->";
+export declare function getEdgeStr(op: SyntaxKind.UndirectedEdgeOp): "--";
+export declare function getEdgeStr(op: SyntaxKind.DirectedEdgeOp): "->";
+export declare function getEdgeStr(op: SyntaxKind.DirectedEdgeOp | SyntaxKind.UndirectedEdgeOp): "->" | "--";
+export declare type GraphTypeStr = "graph" | "digraph";
+export declare function getGraphKeywordStr(g: SyntaxKind.GraphKeyword): "graph";
+export declare function getGraphKeywordStr(g: SyntaxKind.DigraphKeyword): "digraph";
+export declare function getGraphKeywordStr(g: GraphType): "digraph" | "graph";
+export declare type GraphType = SyntaxKind.DigraphKeyword | SyntaxKind.GraphKeyword;
+export declare function getOppositeKind(g: SyntaxKind.DigraphKeyword): SyntaxKind.GraphKeyword;
+export declare function getOppositeKind(g: SyntaxKind.GraphKeyword): SyntaxKind.DigraphKeyword;
+export declare function getOppositeKind(g: GraphType): GraphType;
+export declare type EdgeType = SyntaxKind.DirectedEdgeOp | SyntaxKind.UndirectedEdgeOp;
+export declare function getOppositeEdgeOp(g: SyntaxKind.DirectedEdgeOp): SyntaxKind.UndirectedEdgeOp;
+export declare function getOppositeEdgeOp(g: SyntaxKind.UndirectedEdgeOp): SyntaxKind.DirectedEdgeOp;
+export declare function getOppositeEdgeOp(g: EdgeType): EdgeType;
+export declare function getAllowedOp(g: SyntaxKind.GraphKeyword): SyntaxKind.UndirectedEdgeOp;
+export declare function getAllowedOp(g: SyntaxKind.DigraphKeyword): SyntaxKind.DirectedEdgeOp;
+export declare function getAllowedOp(g: GraphType): EdgeType;

package/lib/service/command/common.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllowedOp = exports.getOppositeEdgeOp = exports.getOppositeKind = exports.getGraphKeywordStr = exports.getEdgeStr = exports.createChangeToEdit = void 0;
+const lst = require("vscode-languageserver-types");
+const __1 = require("../../");
+function createChangeToEdit(start, end, changeTo) {
+    return lst.TextEdit.replace(lst.Range.create(start, end), changeTo);
+}
+exports.createChangeToEdit = createChangeToEdit;
+;
+function getEdgeStr(op) {
+    return op === __1.SyntaxKind.DirectedEdgeOp ? "->" : "--";
+}
+exports.getEdgeStr = getEdgeStr;
+function getGraphKeywordStr(g) {
+    return g === __1.SyntaxKind.DigraphKeyword ? "digraph" : "graph";
+}
+exports.getGraphKeywordStr = getGraphKeywordStr;
+function getOppositeKind(g) {
+    return g === __1.SyntaxKind.DigraphKeyword ? __1.SyntaxKind.GraphKeyword : __1.SyntaxKind.DigraphKeyword;
+}
+exports.getOppositeKind = getOppositeKind;
+function getOppositeEdgeOp(g) {
+    return g === __1.SyntaxKind.DirectedEdgeOp ? __1.SyntaxKind.UndirectedEdgeOp : __1.SyntaxKind.DirectedEdgeOp;
+}
+exports.getOppositeEdgeOp = getOppositeEdgeOp;
+function getAllowedOp(g) {
+    return g === __1.SyntaxKind.DigraphKeyword ? __1.SyntaxKind.DirectedEdgeOp : __1.SyntaxKind.UndirectedEdgeOp;
+}
+exports.getAllowedOp = getAllowedOp;
+//# sourceMappingURL=common.js.map

package/lib/service/completion.d.ts

@@ -0,0 +1,4 @@
+import * as lst from "vscode-languageserver-types";
+import { SourceFile } from "../types";
+import { DocumentLike } from "../";
+export declare function getCompletions(doc: DocumentLike, sourceFile: SourceFile, position: lst.Position): lst.CompletionItem[];