dot-language-support 1.6.2 → 2.0.2

package/lib/{service → esm/service}/codeAction.js

@@ -1,15 +1,12 @@
-"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) {
+import { SyntaxKind, forEachChild, isIdentifierNode, } from "../index.js";
+import { assertNever, getStart } from "./util.js";
+import { getAllowedEdgeOperation, findAllEdges, findNodeAtOffset, isEdgeStatement, isNodeId, getIdentifierText, isAttrStatement, edgeStatementHasAttributes, nodeContainsErrors, } from "../checker.js";
+import * as ChangeEdgeOpCommand from "./command/ChangeEdgeOpCommand.js";
+import * as ChangeAllOtherEdgeOpsAndFixGraphCommand from "./command/ChangeAllOtherEdgeOpsAndFixGraphCommand.js";
+import * as ConsolidateDescendantsCommand from "./command/ConsolidateDescendantsCommand.js";
+import * as RemoveSemicolonsCommand from "./command/RemoveSemicolons.js";
+import { getOppositeKind, getOppositeEdgeOp, getAllowedOp } from "./command/common.js";
+export function getCodeActions(doc, sourceFile, range, _context) {
     let actions = getActionsFromDiagnostics(doc, sourceFile, range);
     const general = getGeneralRefactorings(doc, sourceFile, range);
     if (general) {
@@ -20,7 +17,6 @@ function getCodeActions(doc, sourceFile, range, context) {
     }
     return actions;
 }
-exports.getCodeActions = getCodeActions;
 function getActionsFromDiagnostics(doc, file, range) {
     const ds = file.diagnostics;
     if (!ds || ds.length === 0)
@@ -44,39 +40,39 @@ function getGeneralRefactorings(doc, file, range) {
     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 keywordStart = getStart(file, kw);
     const res = [];
     if (isInRange(rangeStartOffset, rangeEndOffset, keywordStart, kw.end)) {
         if (!subtreeContainsErrors(g)) {
-            const oppositeGraphType = (0, common_1.getOppositeKind)(kw.kind);
+            const oppositeGraphType = 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);
+        let clickedNode = findNodeAtOffset(g, rangeStartOffset);
         if (clickedNode && !!clickedNode.parent) {
-            if (clickedNode.kind === __1.SyntaxKind.SemicolonToken) {
+            if (clickedNode.kind === SyntaxKind.SemicolonToken) {
                 res.push(RemoveSemicolonsCommand.create());
             }
-            if ((0, __1.isIdentifierNode)(clickedNode)) {
+            if (isIdentifierNode(clickedNode)) {
                 clickedNode = clickedNode.parent;
             }
             const clickedEdgeStatement = clickedNode.parent;
             if (clickedEdgeStatement && !subtreeContainsErrors(clickedEdgeStatement)) {
-                if ((0, checker_1.isEdgeStatement)(clickedEdgeStatement)
+                if (isEdgeStatement(clickedEdgeStatement)
                     && clickedEdgeStatement.rhs.length === 1
-                    && (0, checker_1.isNodeId)(clickedEdgeStatement.source)
-                    && !(0, checker_1.edgeStatementHasAttributes)(clickedEdgeStatement)) {
+                    && isNodeId(clickedEdgeStatement.source)
+                    && !edgeStatementHasAttributes(clickedEdgeStatement)) {
                     candidates.push(clickedEdgeStatement);
                     const source = clickedEdgeStatement.source;
-                    const sourceText = (0, checker_1.getIdentifierText)(source.id);
+                    const sourceText = getIdentifierText(source.id);
                     const graphParent = clickedEdgeStatement.parent;
                     if (graphParent) {
                         let hasVisitedStatement = false;
                         let hasVisitedNodeModifier = false;
-                        (0, __1.forEachChild)(graphParent, statement => {
+                        forEachChild(graphParent, statement => {
                             if (statement === clickedEdgeStatement) {
                                 hasVisitedStatement = true;
                                 return undefined;
@@ -85,19 +81,19 @@ function getGeneralRefactorings(doc, file, range) {
                                 return;
                             }
                             else if (hasVisitedStatement) {
-                                if ((0, checker_1.isAttrStatement)(statement)
+                                if (isAttrStatement(statement)
                                     || subtreeContainsErrors(statement)) {
                                     hasVisitedNodeModifier = true;
                                     return true;
                                 }
                             }
                             if (hasVisitedStatement) {
-                                if ((0, checker_1.isEdgeStatement)(statement)
+                                if (isEdgeStatement(statement)
                                     && statement.rhs.length === 1
-                                    && !(0, checker_1.edgeStatementHasAttributes)(statement)) {
+                                    && !edgeStatementHasAttributes(statement)) {
                                     const statementSource = statement.source;
-                                    if ((0, checker_1.isNodeId)(statementSource)) {
-                                        const lowerSourceText = (0, checker_1.getIdentifierText)(statementSource.id);
+                                    if (isNodeId(statementSource)) {
+                                        const lowerSourceText = getIdentifierText(statementSource.id);
                                         if (sourceText === lowerSourceText) {
                                             candidates.push(statement);
                                         }
@@ -123,20 +119,20 @@ function getCommandsForDiagnostic(doc, file, d) {
         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);
+        default: return assertNever(d.code);
     }
 }
-function getScannerErrorCommand(doc, file, 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) {
+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) {
+function getCheckerErrorCommand(_doc, file, d, code) {
     console.assert(d.code.source === 4);
     console.assert(code.source === 4);
     switch (code.sub) {
@@ -144,12 +140,12 @@ function getCheckerErrorCommand(doc, file, d, code) {
             const graph = file.graph;
             if (!graph)
                 return undefined;
-            const allowedOp = (0, checker_1.getAllowedEdgeOperation)(graph);
-            const wrongOp = (0, common_1.getOppositeEdgeOp)(allowedOp);
+            const allowedOp = getAllowedEdgeOperation(graph);
+            const wrongOp = 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));
+            const convertToThisWrongType = convertGraphTypeCommand(file, graph, getOppositeKind(kwk));
             return [
                 fixSingleEdge,
                 fixAll,
@@ -159,16 +155,16 @@ function getCheckerErrorCommand(doc, file, d, code) {
     }
 }
 function convertGraphTypeCommand(file, graph, changeToGraphType) {
-    const changeToEdgeOp = (0, common_1.getAllowedOp)(changeToGraphType);
-    const allEdges = (0, checker_1.findAllEdges)(graph);
+    const changeToEdgeOp = getAllowedOp(changeToGraphType);
+    const allEdges = findAllEdges(graph);
     const edgeOffsets = allEdges
         .filter(e => e.operation.kind !== changeToEdgeOp)
         .map(e => ({
-        start: (0, util_1.getStart)(file, e.operation),
+        start: getStart(file, e.operation),
         end: e.operation.end
     }));
     const graphTypeOffset = {
-        start: (0, util_1.getStart)(file, graph.keyword),
+        start: getStart(file, graph.keyword),
         end: graph.keyword.end
     };
     return ChangeAllOtherEdgeOpsAndFixGraphCommand.create(edgeOffsets, changeToEdgeOp, graphTypeOffset, graph.keyword.kind, changeToGraphType);
@@ -186,23 +182,21 @@ const commandHandlers = {
     ["DOT.consolidateDescendants"]: ConsolidateDescendantsCommand.execute,
     ["DOT.removeSemicolons"]: RemoveSemicolonsCommand.execute,
 };
-function getAvailableCommands() {
+export function getAvailableCommands() {
     return Object.keys(commandHandlers);
 }
-exports.getAvailableCommands = getAvailableCommands;
-function executeCommand(doc, sourceFile, cmd) {
+export 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))
+    if (nodeContainsErrors(node))
         return true;
     let hasError = false;
-    (0, __1.forEachChild)(node, child => {
-        if ((0, checker_1.nodeContainsErrors)(child)) {
+    forEachChild(node, child => {
+        if (nodeContainsErrors(child)) {
             hasError = true;
         }
         if (!hasError) {

package/lib/esm/service/colorProvider.d.ts

@@ -0,0 +1,5 @@
+import type { ColorInformation, ColorPresentation, Range, Color } from "vscode-languageserver-types";
+import { SourceFile } from "../types.js";
+import { DocumentLike } from "../index.js";
+export declare function getDocumentColors(doc: DocumentLike, sourceFile: SourceFile): ColorInformation[] | undefined;
+export declare function getColorRepresentations(_doc: DocumentLike, _sourceFile: SourceFile, color: Color, range: Range): ColorPresentation[] | undefined;

package/lib/{service → esm/service}/colorProvider.js

@@ -1,27 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getColorRepresentations = exports.getDocumentColors = void 0;
-const util_1 = require("./util");
-const languageFacts = require("./languageFacts");
+import { syntaxNodeToRange } from "./util.js";
+import * as languageFacts from "./languageFacts.js";
 const colorMap = languageFacts.colors;
-function getDocumentColors(doc, sourceFile) {
+export 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 + '"',
-        }
-    ];
+export function getColorRepresentations(_doc, _sourceFile, color, range) {
+    return !color || !range
+        ? undefined
+        : [{ label: '"' + getColorStringFromColor(color) + '"', }];
 }
-exports.getColorRepresentations = getColorRepresentations;
 function colorTableToColorInformation(doc, sf, colors) {
     if (!colors || colors.size === 0)
         return [];
@@ -32,7 +22,7 @@ function colorTableToColorInformation(doc, sf, colors) {
         const color = getColorFromName(name);
         if (color) {
             res.push({
-                range: (0, util_1.syntaxNodeToRange)(doc, sf, value.node),
+                range: syntaxNodeToRange(doc, sf, value.node),
                 color,
             });
         }

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

@@ -0,0 +1,10 @@
+import * as lst from "vscode-languageserver-types";
+import { CommandIds } from "../codeAction.js";
+import { GraphTypeStr, Offset, EdgeOpStr, ExecutableCommand, EdgeType, GraphType } from "./common.js";
+import { DocumentLike, SourceFile, CommandApplication } from "../../index.js";
+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/esm/service/command/ChangeAllOtherEdgeOpsAndFixGraphCommand.js

@@ -0,0 +1,38 @@
+import { createChangeToEdit, getEdgeStr, getGraphKeywordStr } from "./common.js";
+export function create(edgeOffsets, changeEdgesTo, graphOffset, changeFromGraph, changeGraphTo) {
+    const toGraph = getGraphKeywordStr(changeGraphTo);
+    const title = changeGraphTo === changeFromGraph
+        ? `Fix all edges to match ${toGraph}`
+        : `Convert ${getGraphKeywordStr(changeFromGraph)} to ${toGraph}`;
+    const edgeStr = getEdgeStr(changeEdgesTo);
+    return {
+        title,
+        command: "DOT.convertGraphType",
+        arguments: [edgeOffsets, edgeStr, graphOffset, toGraph],
+    };
+}
+export 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 createChangeToEdit(startPos, endPos, changeEdgeTo);
+    });
+    const graphStart = doc.positionAt(graphOffset.start);
+    const graphEnd = doc.positionAt(graphOffset.end);
+    edits.push(createChangeToEdit(graphStart, graphEnd, changeGraphTo));
+    return {
+        label: `Convert graph to "${changeGraphTo}"`,
+        edit: {
+            changes: {
+                [doc.uri]: edits,
+            }
+        }
+    };
+}
+function isChangeAllOtherEdgeOpsAndFixGraphCommand(cmd) {
+    return cmd.command === "DOT.convertGraphType" && !!cmd.arguments && cmd.arguments.length === 4;
+}
+//# sourceMappingURL=ChangeAllOtherEdgeOpsAndFixGraphCommand.js.map

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

@@ -0,0 +1,10 @@
+import * as lst from "vscode-languageserver-types";
+import { CommandIds } from "../codeAction.js";
+import { EdgeOpStr, ExecutableCommand, EdgeType } from "./common.js";
+import { DocumentLike, SourceFile, CommandApplication } from "../../index.js";
+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 → esm/service}/command/ChangeEdgeOpCommand.js

@@ -1,19 +1,15 @@
-"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);
+import * as lst from "vscode-languageserver-types";
+import { getEdgeStr } from "./common.js";
+export function create(startOffset, endOffset, changeTo, changeFrom) {
+    const from = getEdgeStr(changeFrom);
+    const to = getEdgeStr(changeTo);
     return {
         title: `Change "${from}" to "${to}".`,
         command: "DOT.changeEdgeOp",
         arguments: [startOffset, endOffset, to],
     };
 }
-exports.create = create;
-function execute(doc, sourceFile, cmd) {
+export function execute(doc, _sourceFile, cmd) {
     if (!isChangeEdgeOpCommand(cmd))
         return undefined;
     const [startOffset, endOffset, changeTo] = cmd.arguments;
@@ -30,7 +26,6 @@ function execute(doc, sourceFile, cmd) {
         }
     };
 }
-exports.execute = execute;
 function isChangeEdgeOpCommand(cmd) {
     return cmd.command === "DOT.changeEdgeOp" && !!cmd.arguments && cmd.arguments.length === 3;
 }

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

@@ -0,0 +1,10 @@
+import * as lst from "vscode-languageserver-types";
+import { CommandIds } from "../codeAction.js";
+import { ExecutableCommand } from "./common.js";
+import { DocumentLike, SourceFile, CommandApplication, EdgeStatement } from "../../index.js";
+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/esm/service/command/ConsolidateDescendantsCommand.js

@@ -0,0 +1,83 @@
+import { getIdentifierText, findNodeAtOffset } from "../../checker.js";
+import { getStart } from "../util.js";
+export function create(statements, below) {
+    const first = statements[0];
+    const from = 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),
+    };
+}
+export 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 => findNodeAtOffset(g, i).parent.parent);
+    const first = candidates.shift();
+    const from = getIdentifierText(first.source.id);
+    const edits = [];
+    const firstRight = first.rhs[0];
+    const firstRightTargetStart = 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(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,
+            }
+        }
+    };
+}
+function isConsolidateDescendantsCommand(cmd) {
+    return cmd.command === "DOT.consolidateDescendants" && !!cmd.arguments && cmd.arguments.length > 1;
+}
+//# sourceMappingURL=ConsolidateDescendantsCommand.js.map

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

@@ -0,0 +1,10 @@
+import * as lst from "vscode-languageserver-types";
+import { CommandIds } from "../codeAction.js";
+import { ExecutableCommand } from "./common.js";
+import { DocumentLike, SourceFile, CommandApplication } from "../../index.js";
+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/esm/service/command/RemoveSemicolons.js

@@ -0,0 +1,37 @@
+import { createChangeToEdit } from "./common.js";
+import { findOptionalSemicolons } from "../../checker.js";
+export function create() {
+    return {
+        title: "Remove optional semicolons",
+        command: "DOT.removeSemicolons",
+        arguments: undefined,
+    };
+}
+export function execute(doc, sourceFile, cmd) {
+    if (!isRemoveSemicolonsCommand(cmd))
+        return undefined;
+    const g = sourceFile.graph;
+    if (!g)
+        return undefined;
+    const semicolons = findOptionalSemicolons(g);
+    const edits = semicolons.map(s => {
+        const end = s.end;
+        const start = end - 1;
+        return createChangeToEdit(doc.positionAt(start), doc.positionAt(end), "");
+    });
+    return {
+        label: `Remove optional semicolons`,
+        edit: {
+            changes: {
+                [doc.uri]: edits,
+            }
+        }
+    };
+}
+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/esm/service/command/common.d.ts

@@ -0,0 +1,31 @@
+import { TextEdit, type Position } from "vscode-languageserver-types";
+import { SyntaxKind } from "../../index.js";
+import { CommandIds } from "../codeAction.js";
+export declare function createChangeToEdit(start: Position, end: Position, changeTo: string): 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/esm/service/command/common.js

@@ -0,0 +1,22 @@
+import { TextEdit, Range } from "vscode-languageserver-types";
+import { SyntaxKind } from "../../index.js";
+export function createChangeToEdit(start, end, changeTo) {
+    return TextEdit.replace(Range.create(start, end), changeTo);
+}
+;
+export function getEdgeStr(op) {
+    return op === SyntaxKind.DirectedEdgeOp ? "->" : "--";
+}
+export function getGraphKeywordStr(g) {
+    return g === SyntaxKind.DigraphKeyword ? "digraph" : "graph";
+}
+export function getOppositeKind(g) {
+    return g === SyntaxKind.DigraphKeyword ? SyntaxKind.GraphKeyword : SyntaxKind.DigraphKeyword;
+}
+export function getOppositeEdgeOp(g) {
+    return g === SyntaxKind.DirectedEdgeOp ? SyntaxKind.UndirectedEdgeOp : SyntaxKind.DirectedEdgeOp;
+}
+export function getAllowedOp(g) {
+    return g === SyntaxKind.DigraphKeyword ? SyntaxKind.DirectedEdgeOp : SyntaxKind.UndirectedEdgeOp;
+}
+//# sourceMappingURL=common.js.map

package/lib/esm/service/completion.d.ts

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