dot-language-support 2.3.0 → 3.0.0

package/dist/index.js

@@ -0,0 +1,3853 @@
+// src/core.ts
+function createMapFromTemplate(template) {
+  const map = /* @__PURE__ */ new Map();
+  for (const key in template) {
+    if (key in template) {
+      map.set(key, template[key]);
+    }
+  }
+  return map;
+}
+
+// src/types.ts
+var ErrorSource = /* @__PURE__ */ ((ErrorSource2) => {
+  ErrorSource2[ErrorSource2["Scan"] = 1] = "Scan";
+  ErrorSource2[ErrorSource2["Parse"] = 2] = "Parse";
+  ErrorSource2[ErrorSource2["Check"] = 4] = "Check";
+  return ErrorSource2;
+})(ErrorSource || {});
+var ParseError = /* @__PURE__ */ ((ParseError2) => {
+  ParseError2[ParseError2["ExpectationFailed"] = 0] = "ExpectationFailed";
+  ParseError2[ParseError2["TrailingData"] = 1] = "TrailingData";
+  ParseError2[ParseError2["FailedListParsing"] = 2] = "FailedListParsing";
+  return ParseError2;
+})(ParseError || {});
+var ScanError = /* @__PURE__ */ ((ScanError2) => {
+  ScanError2[ScanError2["ExpectationFailed"] = 0] = "ExpectationFailed";
+  ScanError2[ScanError2["Unterminated"] = 1] = "Unterminated";
+  return ScanError2;
+})(ScanError || {});
+var CheckError = /* @__PURE__ */ ((CheckError2) => {
+  CheckError2[CheckError2["InvalidEdgeOperation"] = 0] = "InvalidEdgeOperation";
+  CheckError2[CheckError2["InvalidShapeName"] = 1] = "InvalidShapeName";
+  return CheckError2;
+})(CheckError || {});
+var DiagnosticCategory = /* @__PURE__ */ ((DiagnosticCategory2) => {
+  DiagnosticCategory2[DiagnosticCategory2["Error"] = 1] = "Error";
+  DiagnosticCategory2[DiagnosticCategory2["Warning"] = 2] = "Warning";
+  DiagnosticCategory2[DiagnosticCategory2["Message"] = 3] = "Message";
+  DiagnosticCategory2[DiagnosticCategory2["Suggestion"] = 4] = "Suggestion";
+  return DiagnosticCategory2;
+})(DiagnosticCategory || {});
+var SyntaxKind = /* @__PURE__ */ ((SyntaxKind2) => {
+  SyntaxKind2[SyntaxKind2["Unknown"] = 0] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EndOfFileToken"] = 1] = "EndOfFileToken";
+  SyntaxKind2[SyntaxKind2["NewLineTrivia"] = 2] = "NewLineTrivia";
+  SyntaxKind2[SyntaxKind2["WhitespaceTrivia"] = 3] = "WhitespaceTrivia";
+  SyntaxKind2[SyntaxKind2["HashCommentTrivia"] = 4] = "HashCommentTrivia";
+  SyntaxKind2[SyntaxKind2["SingleLineCommentTrivia"] = 5] = "SingleLineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["MultiLineCommentTrivia"] = 6] = "MultiLineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 7] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["SemicolonToken"] = 8] = "SemicolonToken";
+  SyntaxKind2[SyntaxKind2["PlusToken"] = 9] = "PlusToken";
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 10] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 11] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 12] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 13] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 14] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["EqualsToken"] = 15] = "EqualsToken";
+  SyntaxKind2[SyntaxKind2["LessThan"] = 16] = "LessThan";
+  SyntaxKind2[SyntaxKind2["GreaterThan"] = 17] = "GreaterThan";
+  SyntaxKind2[SyntaxKind2["CompassNorthToken"] = 18] = "CompassNorthToken";
+  SyntaxKind2[SyntaxKind2["CompassNorthEastToken"] = 19] = "CompassNorthEastToken";
+  SyntaxKind2[SyntaxKind2["CompassEastToken"] = 20] = "CompassEastToken";
+  SyntaxKind2[SyntaxKind2["CompassSouthEastToken"] = 21] = "CompassSouthEastToken";
+  SyntaxKind2[SyntaxKind2["CompassSouthToken"] = 22] = "CompassSouthToken";
+  SyntaxKind2[SyntaxKind2["CompassSouthWestToken"] = 23] = "CompassSouthWestToken";
+  SyntaxKind2[SyntaxKind2["CompassWestToken"] = 24] = "CompassWestToken";
+  SyntaxKind2[SyntaxKind2["CompassNorthWestToken"] = 25] = "CompassNorthWestToken";
+  SyntaxKind2[SyntaxKind2["CompassCenterToken"] = 26] = "CompassCenterToken";
+  SyntaxKind2[SyntaxKind2["UnderscoreToken"] = 27] = "UnderscoreToken";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 28] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["HtmlIdentifier"] = 29] = "HtmlIdentifier";
+  SyntaxKind2[SyntaxKind2["TextIdentifier"] = 30] = "TextIdentifier";
+  SyntaxKind2[SyntaxKind2["QuotedTextIdentifier"] = 31] = "QuotedTextIdentifier";
+  SyntaxKind2[SyntaxKind2["NumericIdentifier"] = 32] = "NumericIdentifier";
+  SyntaxKind2[SyntaxKind2["GraphKeyword"] = 33] = "GraphKeyword";
+  SyntaxKind2[SyntaxKind2["DigraphKeyword"] = 34] = "DigraphKeyword";
+  SyntaxKind2[SyntaxKind2["NodeKeyword"] = 35] = "NodeKeyword";
+  SyntaxKind2[SyntaxKind2["EdgeKeyword"] = 36] = "EdgeKeyword";
+  SyntaxKind2[SyntaxKind2["SubgraphKeyword"] = 37] = "SubgraphKeyword";
+  SyntaxKind2[SyntaxKind2["StrictKeyword"] = 38] = "StrictKeyword";
+  SyntaxKind2[SyntaxKind2["DirectedEdgeOp"] = 39] = "DirectedEdgeOp";
+  SyntaxKind2[SyntaxKind2["UndirectedEdgeOp"] = 40] = "UndirectedEdgeOp";
+  SyntaxKind2[SyntaxKind2["DirectedGraph"] = 41] = "DirectedGraph";
+  SyntaxKind2[SyntaxKind2["UndirectedGraph"] = 42] = "UndirectedGraph";
+  SyntaxKind2[SyntaxKind2["NodeStatement"] = 43] = "NodeStatement";
+  SyntaxKind2[SyntaxKind2["EdgeStatement"] = 44] = "EdgeStatement";
+  SyntaxKind2[SyntaxKind2["AttributeStatement"] = 45] = "AttributeStatement";
+  SyntaxKind2[SyntaxKind2["IdEqualsIdStatement"] = 46] = "IdEqualsIdStatement";
+  SyntaxKind2[SyntaxKind2["SubGraph"] = 47] = "SubGraph";
+  SyntaxKind2[SyntaxKind2["SubGraphStatement"] = 48] = "SubGraphStatement";
+  SyntaxKind2[SyntaxKind2["EdgeRhs"] = 49] = "EdgeRhs";
+  SyntaxKind2[SyntaxKind2["AttributeContainer"] = 50] = "AttributeContainer";
+  SyntaxKind2[SyntaxKind2["Assignment"] = 51] = "Assignment";
+  SyntaxKind2[SyntaxKind2["NormalPortDeclaration"] = 52] = "NormalPortDeclaration";
+  SyntaxKind2[SyntaxKind2["CompassPortDeclaration"] = 53] = "CompassPortDeclaration";
+  SyntaxKind2[SyntaxKind2["NodeId"] = 54] = "NodeId";
+  SyntaxKind2[SyntaxKind2["Count"] = 55] = "Count";
+  SyntaxKind2[SyntaxKind2["FirstNode"] = 41 /* DirectedGraph */] = "FirstNode";
+  SyntaxKind2[SyntaxKind2["CompassBegin"] = 18 /* CompassNorthToken */] = "CompassBegin";
+  SyntaxKind2[SyntaxKind2["CompassEnd"] = 27 /* UnderscoreToken */] = "CompassEnd";
+  SyntaxKind2[SyntaxKind2["LastKeyword"] = 38 /* StrictKeyword */] = "LastKeyword";
+  return SyntaxKind2;
+})(SyntaxKind || {});
+var SyntaxNodeFlags = /* @__PURE__ */ ((SyntaxNodeFlags2) => {
+  SyntaxNodeFlags2[SyntaxNodeFlags2["None"] = 0] = "None";
+  SyntaxNodeFlags2[SyntaxNodeFlags2["ContainsErrors"] = 2] = "ContainsErrors";
+  SyntaxNodeFlags2[SyntaxNodeFlags2["Synthesized"] = 4] = "Synthesized";
+  return SyntaxNodeFlags2;
+})(SyntaxNodeFlags || {});
+var GraphContext = /* @__PURE__ */ ((GraphContext2) => {
+  GraphContext2[GraphContext2["None"] = 0] = "None";
+  GraphContext2[GraphContext2["Strict"] = 2] = "Strict";
+  GraphContext2[GraphContext2["Directed"] = 4] = "Directed";
+  GraphContext2[GraphContext2["Undirected"] = 8] = "Undirected";
+  return GraphContext2;
+})(GraphContext || {});
+var TokenFlags = /* @__PURE__ */ ((TokenFlags2) => {
+  TokenFlags2[TokenFlags2["None"] = 0] = "None";
+  TokenFlags2[TokenFlags2["Unterminated"] = 2] = "Unterminated";
+  TokenFlags2[TokenFlags2["PrecedingLineBreak"] = 4] = "PrecedingLineBreak";
+  return TokenFlags2;
+})(TokenFlags || {});
+var CharacterCodes = /* @__PURE__ */ ((CharacterCodes2) => {
+  CharacterCodes2[CharacterCodes2["nullCharacter"] = 0] = "nullCharacter";
+  CharacterCodes2[CharacterCodes2["maxAsciiCharacter"] = 127] = "maxAsciiCharacter";
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["lineSeparator"] = 8232] = "lineSeparator";
+  CharacterCodes2[CharacterCodes2["paragraphSeparator"] = 8233] = "paragraphSeparator";
+  CharacterCodes2[CharacterCodes2["nextLine"] = 133] = "nextLine";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["nonBreakingSpace"] = 160] = "nonBreakingSpace";
+  CharacterCodes2[CharacterCodes2["enQuad"] = 8192] = "enQuad";
+  CharacterCodes2[CharacterCodes2["emQuad"] = 8193] = "emQuad";
+  CharacterCodes2[CharacterCodes2["enSpace"] = 8194] = "enSpace";
+  CharacterCodes2[CharacterCodes2["emSpace"] = 8195] = "emSpace";
+  CharacterCodes2[CharacterCodes2["threePerEmSpace"] = 8196] = "threePerEmSpace";
+  CharacterCodes2[CharacterCodes2["fourPerEmSpace"] = 8197] = "fourPerEmSpace";
+  CharacterCodes2[CharacterCodes2["sixPerEmSpace"] = 8198] = "sixPerEmSpace";
+  CharacterCodes2[CharacterCodes2["figureSpace"] = 8199] = "figureSpace";
+  CharacterCodes2[CharacterCodes2["punctuationSpace"] = 8200] = "punctuationSpace";
+  CharacterCodes2[CharacterCodes2["thinSpace"] = 8201] = "thinSpace";
+  CharacterCodes2[CharacterCodes2["hairSpace"] = 8202] = "hairSpace";
+  CharacterCodes2[CharacterCodes2["zeroWidthSpace"] = 8203] = "zeroWidthSpace";
+  CharacterCodes2[CharacterCodes2["narrowNoBreakSpace"] = 8239] = "narrowNoBreakSpace";
+  CharacterCodes2[CharacterCodes2["ideographicSpace"] = 12288] = "ideographicSpace";
+  CharacterCodes2[CharacterCodes2["mathematicalSpace"] = 8287] = "mathematicalSpace";
+  CharacterCodes2[CharacterCodes2["ogham"] = 5760] = "ogham";
+  CharacterCodes2[CharacterCodes2["_"] = 95] = "_";
+  CharacterCodes2[CharacterCodes2["$"] = 36] = "$";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["ampersand"] = 38] = "ampersand";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["at"] = 64] = "at";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["backtick"] = 96] = "backtick";
+  CharacterCodes2[CharacterCodes2["bar"] = 124] = "bar";
+  CharacterCodes2[CharacterCodes2["caret"] = 94] = "caret";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["closeParen"] = 41] = "closeParen";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["equals"] = 61] = "equals";
+  CharacterCodes2[CharacterCodes2["exclamation"] = 33] = "exclamation";
+  CharacterCodes2[CharacterCodes2["greaterThan"] = 62] = "greaterThan";
+  CharacterCodes2[CharacterCodes2["hash"] = 35] = "hash";
+  CharacterCodes2[CharacterCodes2["lessThan"] = 60] = "lessThan";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["openParen"] = 40] = "openParen";
+  CharacterCodes2[CharacterCodes2["percent"] = 37] = "percent";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["question"] = 63] = "question";
+  CharacterCodes2[CharacterCodes2["semicolon"] = 59] = "semicolon";
+  CharacterCodes2[CharacterCodes2["singleQuote"] = 39] = "singleQuote";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["tilde"] = 126] = "tilde";
+  CharacterCodes2[CharacterCodes2["backspace"] = 8] = "backspace";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["byteOrderMark"] = 65279] = "byteOrderMark";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+  CharacterCodes2[CharacterCodes2["verticalTab"] = 11] = "verticalTab";
+  return CharacterCodes2;
+})(CharacterCodes || {});
+
+// src/service/util.ts
+function getStart(sourceFile, node) {
+  return getTokenPosOfNode(sourceFile, node);
+}
+function getTokenPosOfNode(sourceFile, node) {
+  if (nodeIsMissing(node)) return node.pos;
+  return skipTrivia(sourceFile.content, node.pos);
+}
+function nodeIsMissing(node) {
+  return node === void 0 ? true : node.pos === node.end && node.pos >= 0 && node.kind !== 1 /* EndOfFileToken */;
+}
+function syntaxNodesToRanges(doc, sourceFile, nodes) {
+  return nodes.map((node) => syntaxNodeToRange(doc, sourceFile, node));
+}
+function syntaxNodeToRange(doc, sourceFile, node) {
+  const start = getStart(sourceFile, node);
+  return {
+    start: doc.positionAt(start),
+    end: doc.positionAt(node.end)
+  };
+}
+function escapeIdentifierText(text) {
+  if (text === "") return quote("");
+  if (text.includes('"') || text.includes("\n")) {
+    const esc = text.replace(/"/, '\\"').replace(/\n/, "\\\n");
+    return quote(esc);
+  }
+  const ch = text.charCodeAt(0);
+  if (!isIdentifierStart(ch) || text.includes(" ")) return quote(text);
+  return text;
+}
+var quote = (s) => `"${s}"`;
+function assertNever(v) {
+  throw new Error(`Should not have reached this. Value: ${v ?? ""}`);
+}
+
+// src/scanner.ts
+var textToToken = createMapFromTemplate({
+  digraph: 34 /* DigraphKeyword */,
+  graph: 33 /* GraphKeyword */,
+  edge: 36 /* EdgeKeyword */,
+  node: 35 /* NodeKeyword */,
+  strict: 38 /* StrictKeyword */,
+  subgraph: 37 /* SubgraphKeyword */,
+  n: 18 /* CompassNorthToken */,
+  ne: 19 /* CompassNorthEastToken */,
+  e: 20 /* CompassEastToken */,
+  se: 21 /* CompassSouthEastToken */,
+  s: 22 /* CompassSouthToken */,
+  sw: 23 /* CompassSouthWestToken */,
+  w: 24 /* CompassWestToken */,
+  nw: 25 /* CompassNorthWestToken */,
+  c: 26 /* CompassCenterToken */,
+  "+": 9 /* PlusToken */,
+  "=": 15 /* EqualsToken */,
+  "->": 39 /* DirectedEdgeOp */,
+  "--": 40 /* UndirectedEdgeOp */,
+  "{": 10 /* OpenBraceToken */,
+  "}": 11 /* CloseBraceToken */,
+  "[": 12 /* OpenBracketToken */,
+  "]": 13 /* CloseBracketToken */,
+  ";": 8 /* SemicolonToken */,
+  ":": 14 /* ColonToken */,
+  _: 27 /* UnderscoreToken */,
+  ",": 7 /* CommaToken */,
+  "<": 16 /* LessThan */,
+  ">": 17 /* GreaterThan */
+});
+function makeReverseMap(source) {
+  const result = /* @__PURE__ */ new Map();
+  source.forEach((value, key) => {
+    result.set(value, key);
+  });
+  return result;
+}
+var tokenToText = makeReverseMap(textToToken);
+function getTokenAsText(token) {
+  return tokenToText.get(token);
+}
+function getTextAsToken(token) {
+  return textToToken.get(token);
+}
+var DefaultScanner = class {
+  setText(newText, start = 0, length) {
+    this.text = newText || "";
+    this.end = length === void 0 ? this.text.length : start + length;
+    this.#setTextPos(start || 0);
+  }
+  setErrorCallback(cb) {
+    this.onError = cb;
+  }
+  #setTextPos(textPos) {
+    console.assert(textPos >= 0);
+    this.pos = textPos;
+    this.startPos = textPos;
+    this.tokenPos = textPos;
+    this.token = 0 /* Unknown */;
+    this.tokenValue = void 0;
+    this.tokenFlags = 0 /* None */;
+  }
+  scan(skipTrivia2 = true) {
+    this.startPos = this.pos;
+    this.tokenFlags = 0 /* None */;
+    this.isUnterminated = false;
+    while (true) {
+      this.tokenPos = this.pos;
+      if (this.pos >= this.end) {
+        return this.token = 1 /* EndOfFileToken */;
+      }
+      let ch = this.text.charCodeAt(this.pos);
+      switch (ch) {
+        case 10 /* lineFeed */:
+        case 13 /* carriageReturn */:
+          this.tokenFlags |= 4 /* PrecedingLineBreak */;
+          if (skipTrivia2) {
+            this.pos++;
+            continue;
+          }
+          if (ch === 13 /* carriageReturn */ && this.pos + 1 < this.end && this.text.charCodeAt(this.pos + 1) === 10 /* lineFeed */) {
+            this.pos += 2;
+          } else {
+            this.pos++;
+          }
+          return this.token = 2 /* NewLineTrivia */;
+        case 9 /* tab */:
+        case 11 /* verticalTab */:
+        case 12 /* formFeed */:
+        case 32 /* space */:
+          if (skipTrivia2) {
+            this.pos++;
+            continue;
+          }
+          while (this.pos < this.end && this.#isWhiteSpaceSingleLine(this.text.charCodeAt(this.pos)))
+            this.pos++;
+          return this.token = 3 /* WhitespaceTrivia */;
+        case 35 /* hash */: {
+          const content = this.#scanHashCommentTrivia(skipTrivia2);
+          if (skipTrivia2) continue;
+          this.tokenValue = content;
+          return this.token = 4 /* HashCommentTrivia */;
+        }
+        case 47 /* slash */: {
+          if (this.pos + 1 < this.end) {
+            const nextChar = this.text.charCodeAt(this.pos + 1);
+            switch (nextChar) {
+              case 47 /* slash */: {
+                const commentContent = this.#scanSingleLineCommentTrivia(skipTrivia2);
+                if (skipTrivia2) continue;
+                this.tokenValue = commentContent;
+                return this.token = 5 /* SingleLineCommentTrivia */;
+              }
+              case 42 /* asterisk */: {
+                const commentContent = this.#scanMultiLineCommentTrivia(skipTrivia2);
+                if (skipTrivia2) continue;
+                this.tokenValue = commentContent;
+                return this.token = 6 /* MultiLineCommentTrivia */;
+              }
+            }
+          }
+          this.#error(
+            'Unexpected "/". Did you mean to start a comment like "/*" or "//"? If you wanted to use it as an identifier, put it in double quotes.',
+            0 /* ExpectationFailed */
+          );
+          ++this.pos;
+          break;
+        }
+        case 123 /* openBrace */:
+          this.pos++;
+          return this.token = 10 /* OpenBraceToken */;
+        case 125 /* closeBrace */:
+          this.pos++;
+          return this.token = 11 /* CloseBraceToken */;
+        case 91 /* openBracket */:
+          this.pos++;
+          return this.token = 12 /* OpenBracketToken */;
+        case 93 /* closeBracket */:
+          this.pos++;
+          return this.token = 13 /* CloseBracketToken */;
+        case 43 /* plus */:
+          this.pos++;
+          return this.token = 9 /* PlusToken */;
+        case 61 /* equals */:
+          this.pos++;
+          return this.token = 15 /* EqualsToken */;
+        case 48 /* _0 */:
+        case 49 /* _1 */:
+        case 50 /* _2 */:
+        case 51 /* _3 */:
+        case 52 /* _4 */:
+        case 53 /* _5 */:
+        case 54 /* _6 */:
+        case 55 /* _7 */:
+        case 56 /* _8 */:
+        case 57 /* _9 */:
+        case 46 /* dot */:
+          this.tokenValue = this.#scanNumber();
+          return this.token = 32 /* NumericIdentifier */;
+        case 45 /* minus */: {
+          const nextChar = this.text.charCodeAt(this.pos + 1);
+          switch (nextChar) {
+            case 45 /* minus */:
+              this.pos += 2;
+              return this.token = 40 /* UndirectedEdgeOp */;
+            case 62 /* greaterThan */:
+              this.pos += 2;
+              return this.token = 39 /* DirectedEdgeOp */;
+            case 48 /* _0 */:
+            case 49 /* _1 */:
+            case 50 /* _2 */:
+            case 51 /* _3 */:
+            case 52 /* _4 */:
+            case 53 /* _5 */:
+            case 54 /* _6 */:
+            case 55 /* _7 */:
+            case 56 /* _8 */:
+            case 57 /* _9 */:
+            case 46 /* dot */:
+              this.tokenValue = this.#scanNumber();
+              return this.token = 32 /* NumericIdentifier */;
+            default: {
+              const chr = this.text.charAt(this.pos + 1);
+              this.#error(
+                `Unexpected "${chr}". Did you mean to define an edge? Depending on the type of graph you are defining, use "->" or "--".`,
+                0 /* ExpectationFailed */
+              );
+              break;
+            }
+          }
+          this.pos++;
+          break;
+        }
+        // TODO: Remove UnderscoreToken
+        case 95 /* _ */:
+          this.pos++;
+          return this.token = 27 /* UnderscoreToken */;
+        case 59 /* semicolon */:
+          this.pos++;
+          return this.token = 8 /* SemicolonToken */;
+        case 58 /* colon */:
+          this.pos++;
+          return this.token = 14 /* ColonToken */;
+        case 44 /* comma */:
+          this.pos++;
+          return this.token = 7 /* CommaToken */;
+        case 60 /* lessThan */:
+          this.tokenValue = this.#scanHtml();
+          return this.token = 29 /* HtmlIdentifier */;
+        case 34 /* doubleQuote */:
+          this.tokenValue = this.#scanString();
+          return this.token = 28 /* StringLiteral */;
+        default: {
+          if (isIdentifierStart(ch)) {
+            this.pos++;
+            while (this.pos < this.end && isIdentifierPart(ch = this.text.charCodeAt(this.pos)))
+              this.pos++;
+            const value = this.text.substring(this.tokenPos, this.pos);
+            this.tokenValue = value;
+            return this.token = this.#getIdentifierToken(value);
+          }
+          if (this.#isWhiteSpaceSingleLine(ch)) {
+            this.pos++;
+            continue;
+          }
+          const chr = this.text.charAt(this.pos);
+          this.#error(
+            `Unexpected "${chr}". Did you mean to start an identifier? Node names cannot start with "${chr}".`,
+            0 /* ExpectationFailed */
+          );
+          this.pos++;
+          break;
+        }
+      }
+    }
+  }
+  #error(message, sub, category = 1 /* Error */, errPos = this.pos, length = 0) {
+    const cb = this.onError;
+    if (cb) {
+      const posSave = this.pos;
+      this.pos = errPos;
+      cb(message, category, sub, length);
+      this.pos = posSave;
+    }
+  }
+  #isWhiteSpaceSingleLine(ch) {
+    return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ || ch === 160 /* nonBreakingSpace */ || ch === 133 /* nextLine */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ || ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;
+  }
+  #isAtMultiLineCommentEnd(pos) {
+    return pos + 1 < this.end && this.text.charCodeAt(pos) === 42 /* asterisk */ && this.text.charCodeAt(pos + 1) === 47 /* slash */;
+  }
+  #scanHashCommentTrivia(skip) {
+    ++this.pos;
+    const start = this.pos;
+    while (this.pos < this.end && !isLineBreak(this.text.charCodeAt(this.pos))) this.pos++;
+    return skip ? void 0 : this.text.substring(start, this.pos);
+  }
+  #scanSingleLineCommentTrivia(skip) {
+    this.pos += 2;
+    const start = this.pos;
+    while (this.pos < this.end && !isLineBreak(this.text.charCodeAt(this.pos))) this.pos++;
+    return skip ? void 0 : this.text.substring(start, this.pos);
+  }
+  #scanMultiLineCommentTrivia(skip) {
+    this.pos += 2;
+    const start = this.pos;
+    while (this.pos < this.end && !this.#isAtMultiLineCommentEnd(this.pos)) this.pos++;
+    const commentEnd = this.pos;
+    if (this.#isAtMultiLineCommentEnd(this.pos)) {
+      this.pos += 2;
+    }
+    return skip ? void 0 : this.text.substring(start, commentEnd);
+  }
+  #scanHtml() {
+    this.pos++;
+    let result = "";
+    const start = this.pos;
+    let subTagsLevel = 0;
+    while (true) {
+      if (this.pos >= this.end) {
+        result += this.text.substring(start, this.pos);
+        this.tokenFlags |= 2 /* Unterminated */;
+        this.isUnterminated = true;
+        this.#error("Unterminated html literal", 1 /* Unterminated */);
+        break;
+      }
+      const ch = this.text.charCodeAt(this.pos);
+      if (ch === 60 /* lessThan */) {
+        ++subTagsLevel;
+        this.pos++;
+        continue;
+      }
+      if (ch === 62 /* greaterThan */) {
+        this.pos++;
+        console.assert(subTagsLevel >= 0);
+        if (subTagsLevel === 0) {
+          result += this.text.substring(start, this.pos);
+          break;
+        }
+        --subTagsLevel;
+        continue;
+      }
+      this.pos++;
+    }
+    return result;
+  }
+  // biome-ignore lint/correctness/noUnusedFunctionParameters: todo
+  #scanString(allowEscapes = true) {
+    const quote2 = this.text.charCodeAt(this.pos);
+    this.pos++;
+    let result = "";
+    const start = this.pos;
+    let hasBackslash = false;
+    while (true) {
+      if (this.pos >= this.end) {
+        result += this.text.substring(start, this.pos);
+        this.tokenFlags |= 2 /* Unterminated */;
+        this.isUnterminated = true;
+        this.#error("Unterminated string", 1 /* Unterminated */);
+        break;
+      }
+      const ch = this.text.charCodeAt(this.pos);
+      if (ch === 92 /* backslash */) {
+        hasBackslash = true;
+      } else {
+        if (hasBackslash) {
+          hasBackslash = false;
+        } else {
+          if (ch === quote2) {
+            result += this.text.substring(start, this.pos);
+            this.pos++;
+            break;
+          }
+          if (isLineBreak(ch)) {
+            result += this.text.substring(start, this.pos);
+            this.tokenFlags |= 2 /* Unterminated */;
+            this.isUnterminated = true;
+            this.#error("Unterminated string", 1 /* Unterminated */);
+            break;
+          }
+        }
+      }
+      this.pos++;
+    }
+    const removedEscapes = result.replace(/\\"/g, '"').replace(/\\(\r?\n)/g, "$1");
+    return removedEscapes;
+  }
+  #scanNumber() {
+    let result = "";
+    let hadDot = false;
+    let hadMinus = false;
+    const start = this.pos;
+    while (true) {
+      const ch = this.text.charCodeAt(this.pos);
+      switch (ch) {
+        case 48 /* _0 */:
+        case 49 /* _1 */:
+        case 50 /* _2 */:
+        case 51 /* _3 */:
+        case 52 /* _4 */:
+        case 53 /* _5 */:
+        case 54 /* _6 */:
+        case 55 /* _7 */:
+        case 56 /* _8 */:
+        case 57 /* _9 */:
+          break;
+        case 46 /* dot */:
+          if (hadDot) {
+            result += this.text.substring(start, this.pos);
+            return result;
+          }
+          hadDot = true;
+          hadMinus = true;
+          break;
+        case 45 /* minus */:
+          if (this.pos !== start || hadMinus) {
+            result += this.text.substring(start, this.pos);
+            return result;
+          }
+          hadMinus = true;
+          break;
+        default:
+          result += this.text.substring(start, this.pos);
+          return result;
+      }
+      ++this.pos;
+    }
+  }
+  #getIdentifierToken(tokenValue) {
+    const len = tokenValue.length;
+    if (len >= 4 && len <= 8) {
+      const ch = tokenValue.charCodeAt(0);
+      if (ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 65 /* A */ && ch <= 90 /* Z */) {
+        const lowerCaseToken = tokenValue.toLowerCase();
+        const t = textToToken.get(lowerCaseToken);
+        if (t !== void 0) {
+          this.token = t;
+          return t;
+        }
+      }
+    }
+    return this.token = 30 /* TextIdentifier */;
+  }
+  lookAhead(callback) {
+    return this.#speculationHelper(
+      callback,
+      /*isLookahead*/
+      true
+    );
+  }
+  tryScan(callback) {
+    return this.#speculationHelper(
+      callback,
+      /*isLookahead*/
+      false
+    );
+  }
+  #speculationHelper(callback, isLookahead) {
+    const savePos = this.pos;
+    const saveStartPos = this.startPos;
+    const saveTokenPos = this.tokenPos;
+    const saveToken = this.token;
+    const saveTokenValue = this.tokenValue;
+    const saveTokenFlags = this.tokenFlags;
+    const result = callback();
+    if (!result || isLookahead) {
+      this.pos = savePos;
+      this.startPos = saveStartPos;
+      this.tokenPos = saveTokenPos;
+      this.token = saveToken;
+      this.tokenValue = saveTokenValue;
+      this.tokenFlags = saveTokenFlags;
+    }
+    return result;
+  }
+};
+function isIdentifierStart(ch) {
+  return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 95 /* _ */ || ch === 60 /* lessThan */ || ch === 34 /* doubleQuote */;
+}
+function isIdentifierPart(ch) {
+  return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || ch > 127 /* maxAsciiCharacter */;
+}
+function skipTrivia(text, pos) {
+  while (true) {
+    const ch = text.charCodeAt(pos);
+    switch (ch) {
+      case 13 /* carriageReturn */:
+        if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) ++pos;
+        continue;
+      case 10 /* lineFeed */:
+      case 9 /* tab */:
+      case 11 /* verticalTab */:
+      case 12 /* formFeed */:
+      case 32 /* space */:
+        ++pos;
+        continue;
+      case 35 /* hash */: {
+        ++pos;
+        while (pos < text.length) {
+          if (isLineBreak(text.charCodeAt(pos))) break;
+          ++pos;
+        }
+        continue;
+      }
+      case 47 /* slash */:
+        if (pos + 1 < text.length) {
+          const nextChar = text.charCodeAt(pos + 1);
+          switch (nextChar) {
+            case 47 /* slash */: {
+              pos += 2;
+              while (pos < text.length) {
+                if (isLineBreak(text.charCodeAt(pos))) break;
+                ++pos;
+              }
+              continue;
+            }
+            case 42 /* asterisk */: {
+              pos += 2;
+              while (pos < text.length) {
+                if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
+                  pos += 2;
+                  break;
+                }
+                ++pos;
+              }
+              continue;
+            }
+          }
+        }
+        break;
+    }
+    return pos;
+  }
+}
+function isLineBreak(ch) {
+  return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */;
+}
+
+// src/parser.ts
+var ParsingContext = /* @__PURE__ */ ((ParsingContext2) => {
+  ParsingContext2[ParsingContext2["None"] = 0] = "None";
+  ParsingContext2[ParsingContext2["StatementList"] = 1] = "StatementList";
+  ParsingContext2[ParsingContext2["AttributeContainerList"] = 2] = "AttributeContainerList";
+  ParsingContext2[ParsingContext2["AssignmentList"] = 3] = "AssignmentList";
+  ParsingContext2[ParsingContext2["EdgeRhsList"] = 4] = "EdgeRhsList";
+  ParsingContext2[ParsingContext2["QuotedTextIdentifierConcatenation"] = 5] = "QuotedTextIdentifierConcatenation";
+  ParsingContext2[ParsingContext2["Count"] = 6] = "Count";
+  return ParsingContext2;
+})(ParsingContext || {});
+var Parser = class {
+  // TODO
+  constructor() {
+    this.currentToken = 0 /* Unknown */;
+    this.identifierCount = 0;
+    this.scanner = new DefaultScanner();
+    this.#resetState();
+  }
+  #resetState() {
+    this.sourceText = "";
+    this.scanner.setText(this.sourceText);
+    this.scanner.setErrorCallback(this.#scanError.bind(this));
+    this.identifierCount = 0;
+    this.identifiers = /* @__PURE__ */ new Set();
+    this.nodeCount = 0;
+    this.diagnostics = [];
+    this.currentNodeHasError = false;
+    this.currentContext = 0 /* None */;
+  }
+  #nextToken() {
+    this.currentToken = this.scanner.scan(true);
+    return this.currentToken;
+  }
+  #token() {
+    return this.currentToken;
+  }
+  #getLinesFromFile(sourceText) {
+    return sourceText.split(/\r?\n/);
+  }
+  parse(sourceText) {
+    this.sourceText = sourceText;
+    this.scanner.setText(this.sourceText);
+    this.#nextToken();
+    let graph;
+    if (this.#token() !== 1 /* EndOfFileToken */) {
+      graph = this.#parseGraph();
+      if (this.#token() !== 1 /* EndOfFileToken */) {
+        this.#parseErrorAtPosition(
+          this.scanner.tokenPos,
+          this.scanner.text.length - 1,
+          "Content after the end of a graph declaration is invalid.",
+          { source: 2 /* Parse */, sub: 1 /* TrailingData */ }
+        );
+      }
+    }
+    const result = {
+      content: this.sourceText,
+      graph,
+      identifiers: this.identifiers,
+      diagnostics: this.diagnostics
+    };
+    this.#resetState();
+    return result;
+  }
+  #parseGraph() {
+    const strictToken = this.#parseOptionalToken(38 /* StrictKeyword */);
+    const keyword = this.#parseExpectedTokenOneOf(34 /* DigraphKeyword */, [
+      34 /* DigraphKeyword */,
+      33 /* GraphKeyword */
+    ]);
+    const kind = keyword === void 0 || keyword.kind === 34 /* DigraphKeyword */ ? 41 /* DirectedGraph */ : 42 /* UndirectedGraph */;
+    const graphStart = strictToken ? strictToken.pos : keyword.pos;
+    const node = this.#createNode(kind, graphStart);
+    node.strict = strictToken;
+    node.keyword = keyword;
+    node.id = this.#isIdentifier() ? this.#parseIdentifier() : void 0;
+    this.#parseExpectedToken(10 /* OpenBraceToken */);
+    node.statements = this.#parseList(
+      1 /* StatementList */,
+      () => this.#parseStatement()
+    );
+    this.#parseExpectedToken(11 /* CloseBraceToken */);
+    return this.#finishNode(node);
+  }
+  #parseIdentifier() {
+    let result;
+    const escapedIdTexts = [];
+    switch (this.#token()) {
+      case 30 /* TextIdentifier */:
+        result = this.#parseTextIdentifier();
+        escapedIdTexts.push(result.text);
+        break;
+      case 28 /* StringLiteral */:
+        result = this.#parseQuotedTextIdentifierConcatenation();
+        escapedIdTexts.push(...result.values.map((v) => v.text));
+        break;
+      case 29 /* HtmlIdentifier */:
+        result = this.#parseHtmlIdentifier();
+        escapedIdTexts.push(result.htmlContent);
+        break;
+      case 32 /* NumericIdentifier */:
+        result = this.#parseNumericIdentifier();
+        escapedIdTexts.push(result.text);
+        break;
+      default:
+        this.#reportExpectedError([30 /* TextIdentifier */]);
+        result = this.#createMissingNode(30 /* TextIdentifier */);
+        break;
+    }
+    for (const i of escapedIdTexts) {
+      this.#registerIdentifier(i);
+    }
+    return result;
+  }
+  #registerIdentifier(id) {
+    this.identifierCount++;
+    const has = this.identifiers.has(id);
+    if (!has) this.identifiers.add(id);
+  }
+  #parseTextIdentifier() {
+    const node = this.#createNode(30 /* TextIdentifier */);
+    const text = this.scanner.tokenValue;
+    this.#nextToken();
+    if (text === void 0) throw "Satisfy type checker";
+    node.text = text;
+    return this.#finishNode(node);
+  }
+  #parseQuotedTextIdentifierConcatenation() {
+    const node = this.#createNode(31 /* QuotedTextIdentifier */);
+    node.values = this.#parseList(
+      5 /* QuotedTextIdentifierConcatenation */,
+      () => this.#parseQuotedTextIdentifier(),
+      /* at least one */
+      true
+    );
+    return this.#finishNode(node);
+  }
+  #parseQuotedTextIdentifier() {
+    const node = this.#createNode(28 /* StringLiteral */);
+    if (this.#token() === 9 /* PlusToken */) this.#nextToken();
+    const text = this.scanner.tokenValue;
+    this.#nextToken();
+    if (text === void 0) throw "Satisfy type checker";
+    node.text = text;
+    return this.#finishNode(node);
+  }
+  #isQuotedStringFollowing() {
+    this.#nextToken();
+    return this.#token() === 28 /* StringLiteral */;
+  }
+  #parseHtmlIdentifier() {
+    const node = this.#createNode(29 /* HtmlIdentifier */);
+    const text = this.scanner.tokenValue;
+    this.#nextToken();
+    if (text === void 0) throw "Satisfy type checker";
+    node.htmlContent = text;
+    return this.#finishNode(node);
+  }
+  #parseNumericIdentifier() {
+    const node = this.#createNode(32 /* NumericIdentifier */);
+    const text = this.scanner.tokenValue;
+    this.#nextToken();
+    if (text === void 0) throw "Satisfy type checker";
+    node.text = text;
+    node.value = Number(text);
+    return this.#finishNode(node);
+  }
+  #parseStatement() {
+    switch (this.#token()) {
+      case 33 /* GraphKeyword */:
+      case 35 /* NodeKeyword */:
+      case 36 /* EdgeKeyword */:
+        return this.#parseAttributeStatement();
+      case 10 /* OpenBraceToken */:
+      case 37 /* SubgraphKeyword */: {
+        const subgraph = this.#parseSubGraph();
+        if (this.#token() === 8 /* SemicolonToken */) {
+          const subgraphStatement2 = this.#createNode(
+            48 /* SubGraphStatement */,
+            subgraph.pos
+          );
+          subgraphStatement2.subgraph = subgraph;
+          subgraphStatement2.terminator = this.#parseExpectedToken(
+            8 /* SemicolonToken */
+          );
+          return this.#finishNode(subgraphStatement2);
+        }
+        if (this.#isEdgeOp()) return this.#parseEdgeStatement(subgraph);
+        const subgraphStatement = this.#createNode(
+          48 /* SubGraphStatement */,
+          subgraph.pos
+        );
+        subgraphStatement.subgraph = subgraph;
+        return this.#finishNode(subgraphStatement);
+      }
+      default: {
+        if (!this.#isIdentifier) debugger;
+        if (this.#lookAhead(() => this.#isIdEqualsIdStatement())) {
+          return this.#parseIdEqualsIdStatement();
+        }
+        const ns = this.#parseNodeStatement();
+        if (ns.terminator !== void 0 || ns.attributes.length !== 0) return ns;
+        if (this.#isEdgeOp()) return this.#parseEdgeStatement(ns.id);
+        return ns;
+      }
+    }
+  }
+  #parseAttributeStatement() {
+    switch (this.#token()) {
+      case 33 /* GraphKeyword */:
+      case 35 /* NodeKeyword */:
+      case 36 /* EdgeKeyword */: {
+        const node = this.#createNode(45 /* AttributeStatement */);
+        node.subject = this.#parseTokenNode();
+        if (this.#token() === 12 /* OpenBracketToken */) {
+          node.attributes = this.#parseList(
+            2 /* AttributeContainerList */,
+            () => this.#parseAttributeContainer()
+          );
+        } else {
+          this.#reportExpectedError([12 /* OpenBracketToken */]);
+          const missingStatement = this.#createMissingNode(
+            45 /* AttributeStatement */
+          );
+          missingStatement.attributes = this.#createNodeArray(
+            [this.#createMissingNode(50 /* AttributeContainer */)],
+            this.scanner.tokenPos,
+            this.scanner.tokenPos
+          );
+        }
+        node.terminator = this.#parseOptionalToken(8 /* SemicolonToken */);
+        return this.#finishNode(node);
+      }
+      default:
+        throw "This should never happen";
+    }
+  }
+  #parseAttributeContainer() {
+    if (this.#token() !== 12 /* OpenBracketToken */) debugger;
+    const node = this.#createNode(50 /* AttributeContainer */);
+    node.openBracket = this.#parseExpectedToken(12 /* OpenBracketToken */);
+    if (this.#isIdentifier() && this.#lookAhead(() => this.#isAssignmentStart())) {
+      node.assignments = this.#parseList(
+        3 /* AssignmentList */,
+        () => this.#parseAssignment()
+      );
+    } else {
+      node.assignments = this.#createEmptyArray();
+    }
+    node.closeBracket = this.#parseExpectedToken(13 /* CloseBracketToken */);
+    return this.#finishNode(node);
+  }
+  #isAssignmentStart() {
+    if (!this.#isIdentifier) debugger;
+    this.#nextToken();
+    return this.#token() === 15 /* EqualsToken */;
+  }
+  #parseIdEqualsIdStatement() {
+    if (!this.#isIdentifier) debugger;
+    const leftIdentifier = this.#parseIdentifier();
+    const node = this.#createNode(
+      46 /* IdEqualsIdStatement */,
+      leftIdentifier.pos
+    );
+    node.leftId = leftIdentifier;
+    if (this.#token() !== 15 /* EqualsToken */) debugger;
+    this.#parseExpectedToken(15 /* EqualsToken */);
+    node.rightId = this.#parseIdentifier();
+    node.terminator = this.#parseOptionalToken(8 /* SemicolonToken */);
+    return this.#finishNode(node);
+  }
+  #isIdEqualsIdStatement() {
+    if (!this.#isIdentifier) debugger;
+    this.#nextToken();
+    return this.#token() === 15 /* EqualsToken */;
+  }
+  #parseNodeStatement() {
+    if (!this.#isIdentifier) debugger;
+    const node = this.#createNode(43 /* NodeStatement */);
+    node.id = this.#parseNodeId();
+    if (this.#token() === 12 /* OpenBracketToken */) {
+      node.attributes = this.#parseList(
+        2 /* AttributeContainerList */,
+        () => this.#parseAttributeContainer()
+      );
+    } else {
+      node.attributes = this.#createEmptyArray();
+    }
+    node.terminator = this.#parseOptionalToken(8 /* SemicolonToken */);
+    return this.#finishNode(node);
+  }
+  #parseEdgeStatement(precedingItem) {
+    console.assert(
+      precedingItem.kind === 47 /* SubGraph */ || precedingItem.kind === 54 /* NodeId */
+    );
+    console.assert(precedingItem.pos !== void 0);
+    if (!this.#isEdgeOp()) debugger;
+    const node = this.#createNode(44 /* EdgeStatement */, precedingItem.pos);
+    node.source = precedingItem;
+    node.rhs = this.#parseList(4 /* EdgeRhsList */, () => this.#parseEdgeRhs());
+    if (this.#token() === 12 /* OpenBracketToken */) {
+      node.attributes = this.#parseList(
+        2 /* AttributeContainerList */,
+        () => this.#parseAttributeContainer()
+      );
+    } else {
+      node.attributes = this.#createEmptyArray();
+    }
+    node.terminator = this.#parseOptionalToken(8 /* SemicolonToken */);
+    return this.#finishNode(node);
+  }
+  #parseEdgeRhs() {
+    const node = this.#createNode(49 /* EdgeRhs */);
+    const op = this.#parseExpectedTokenOneOf(39 /* DirectedEdgeOp */, [
+      39 /* DirectedEdgeOp */,
+      40 /* UndirectedEdgeOp */
+    ]);
+    node.operation = op;
+    switch (this.#token()) {
+      case 37 /* SubgraphKeyword */:
+      case 10 /* OpenBraceToken */:
+        node.target = this.#parseSubGraph();
+        break;
+      default: {
+        node.target = this.#parseNodeId();
+        break;
+      }
+    }
+    return this.#finishNode(node);
+  }
+  #createMissingNode(kind) {
+    const result = this.#createNode(kind);
+    if (isIdentifierNode(result)) {
+      switch (result.kind) {
+        case 31 /* QuotedTextIdentifier */: {
+          const literal = this.#createNode(28 /* StringLiteral */);
+          literal.text = "";
+          const values = this.#createNodeArray([literal], result.pos, result.pos);
+          result.values = values;
+          break;
+        }
+        case 29 /* HtmlIdentifier */:
+          result.htmlContent = "";
+          break;
+        case 30 /* TextIdentifier */:
+        case 32 /* NumericIdentifier */:
+          result.text = "";
+          break;
+      }
+    }
+    return this.#finishNode(result);
+  }
+  #parseAssignment() {
+    if (!this.#isIdentifier) debugger;
+    const node = this.#createNode(51 /* Assignment */);
+    node.leftId = this.#parseIdentifier();
+    this.#parseExpectedToken(15 /* EqualsToken */);
+    node.rightId = this.#parseIdentifier();
+    let terminator = this.#parseOptionalToken(
+      7 /* CommaToken */
+    );
+    if (terminator === void 0)
+      terminator = this.#parseOptionalToken(8 /* SemicolonToken */);
+    node.terminator = terminator;
+    return this.#finishNode(node);
+  }
+  #parseSubGraph() {
+    console.assert(
+      this.#token() === 37 /* SubgraphKeyword */ || this.#token() === 10 /* OpenBraceToken */
+    );
+    const subGraph = this.#parseOptionalToken(37 /* SubgraphKeyword */);
+    const subGraphStart = subGraph !== void 0 ? subGraph.pos : void 0;
+    const node = this.#createNode(47 /* SubGraph */, subGraphStart);
+    const identifier = subGraph !== void 0 && this.#isIdentifier() ? this.#parseIdentifier() : void 0;
+    node.id = identifier;
+    this.#parseExpectedToken(10 /* OpenBraceToken */);
+    node.statements = this.#parseList(
+      1 /* StatementList */,
+      () => this.#parseStatement()
+    );
+    this.#parseExpectedToken(11 /* CloseBraceToken */);
+    return this.#finishNode(node);
+  }
+  #parseNodeId() {
+    if (!this.#isIdentifier) debugger;
+    const node = this.#createNode(54 /* NodeId */);
+    node.id = this.#parseIdentifier();
+    node.port = this.#token() === 14 /* ColonToken */ ? this.#parsePortDeclaration() : void 0;
+    return this.#finishNode(node);
+  }
+  #parseCompassPortDeclaration() {
+    console.assert(this.#token() === 14 /* ColonToken */);
+    const node = this.#createNode(53 /* CompassPortDeclaration */);
+    node.colon = this.#parseTokenNode();
+    node.compassPt = this.#parseTokenNode();
+    return this.#finishNode(node);
+  }
+  #parseNormalPortDeclaration() {
+    console.assert(this.#token() === 14 /* ColonToken */);
+    const node = this.#createNode(52 /* NormalPortDeclaration */);
+    node.colon = this.#parseTokenNode();
+    node.id = this.#parseIdentifier();
+    node.compassPt = this.#token() === 14 /* ColonToken */ ? this.#parseCompassPortDeclaration() : void 0;
+    return this.#finishNode(node);
+  }
+  #parsePortDeclaration() {
+    console.assert(this.#token() === 14 /* ColonToken */);
+    if (this.#lookAhead(() => this.#isCompassPort()))
+      return this.#parseCompassPortDeclaration();
+    return this.#parseNormalPortDeclaration();
+  }
+  #isCompassPort() {
+    console.assert(this.#token() === 14 /* ColonToken */);
+    if (this.#token() !== 14 /* ColonToken */) return false;
+    this.#nextToken();
+    return this.#isCompassPortKind(this.#token());
+  }
+  #parseList(context, parseElement, atLeastOne = false) {
+    const saveParsingContext = this.currentContext;
+    this.currentContext |= 1 << context;
+    let isListTerminated = atLeastOne ? false : this.#isListTerminator(context);
+    const startPos = this.scanner.startPos;
+    const elements = [];
+    while (!isListTerminated) {
+      if (this.#isListElement(context, false)) {
+        const element = parseElement();
+        elements.push(element);
+        isListTerminated = this.#isListTerminator(context);
+        continue;
+      }
+      if (this.#abortListParsing(context)) break;
+    }
+    this.currentContext = saveParsingContext;
+    return this.#createNodeArray(elements, startPos);
+  }
+  #getContextParseError(context) {
+    switch (context) {
+      case 1 /* StatementList */:
+        return "Assignment, node definition, graph/node/edge attribute or edge definition expected.";
+      case 3 /* AssignmentList */:
+        return "Assignment expected.";
+      case 4 /* EdgeRhsList */:
+        return "Edge operation expected.";
+      case 5 /* QuotedTextIdentifierConcatenation */:
+        return "Quoted identifier expected";
+      case 2 /* AttributeContainerList */:
+        return "Attribute marker expected.";
+      // TODO: Was besseres finden
+      case 0 /* None */:
+        return "Wat, no parsing context";
+      case 6 /* Count */:
+        return "Wat, 'Count' parsing context";
+      default:
+        return assertNever(context);
+    }
+  }
+  #isInSomeParsingContext() {
+    for (let ctx = 0; ctx < 6 /* Count */; ctx++) {
+      if (this.currentContext & 1 << ctx) {
+        if (this.#isListElement(
+          ctx,
+          /*inErrorRecovery*/
+          true
+        ) || this.#isListTerminator(ctx)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  #abortListParsing(context) {
+    this.#parseErrorAtCurrentToken(
+      this.#getContextParseError(context),
+      2 /* FailedListParsing */
+    );
+    if (this.#isInSomeParsingContext()) {
+      return true;
+    }
+    this.#nextToken();
+    return false;
+  }
+  #isListElement(context, _inErrorRecovery) {
+    switch (context) {
+      case 3 /* AssignmentList */:
+        return this.#isIdentifier();
+      case 2 /* AttributeContainerList */:
+        return this.#token() === 12 /* OpenBracketToken */;
+      case 4 /* EdgeRhsList */:
+        return this.#token() === 39 /* DirectedEdgeOp */ || this.#token() === 40 /* UndirectedEdgeOp */;
+      case 5 /* QuotedTextIdentifierConcatenation */:
+        return this.#token() === 28 /* StringLiteral */ || this.#token() === 9 /* PlusToken */;
+      case 1 /* StatementList */:
+        return this.#isIdentifier() || this.#token() === 37 /* SubgraphKeyword */ || this.#token() === 10 /* OpenBraceToken */ || this.#token() === 33 /* GraphKeyword */ || this.#token() === 36 /* EdgeKeyword */ || this.#token() === 35 /* NodeKeyword */;
+      default:
+        throw "This should never happen";
+    }
+  }
+  #isListTerminator(context) {
+    const token = this.#token();
+    if (token === 1 /* EndOfFileToken */) return true;
+    switch (context) {
+      case 1 /* StatementList */:
+        return token === 11 /* CloseBraceToken */;
+      case 2 /* AttributeContainerList */:
+        return token !== 12 /* OpenBracketToken */;
+      case 3 /* AssignmentList */:
+        return token === 13 /* CloseBracketToken */;
+      case 4 /* EdgeRhsList */:
+        return token !== 39 /* DirectedEdgeOp */ && token !== 40 /* UndirectedEdgeOp */;
+      case 5 /* QuotedTextIdentifierConcatenation */:
+        return token !== 9 /* PlusToken */;
+      default:
+        throw "Unsupported parsing context";
+    }
+  }
+  #createEmptyArray() {
+    const startPos = this.scanner.startPos;
+    const elements = [];
+    return this.#createNodeArray(elements, startPos);
+  }
+  #finishNode(node, end) {
+    node.end = end === void 0 ? this.scanner.startPos : end;
+    if (this.currentNodeHasError) {
+      this.currentNodeHasError = false;
+      node.flags |= 2 /* ContainsErrors */;
+    }
+    return node;
+  }
+  #createNode(kind, pos) {
+    this.nodeCount++;
+    const p = pos !== void 0 && pos >= 0 ? pos : this.scanner.startPos;
+    if (isNodeKind(kind) || kind === 0 /* Unknown */) return newNode(kind, p, p);
+    return isIdentifier(kind) ? newIdentifier(kind, p, p) : newToken(kind, p, p);
+  }
+  #createNodeArray(elements, pos, end) {
+    const length = elements.length;
+    const array = length >= 1 && length <= 4 ? elements.slice() : elements;
+    array.pos = pos;
+    array.end = end === void 0 ? this.scanner.startPos : end;
+    return array;
+  }
+  #parseTokenNode() {
+    const node = this.#createNode(this.#token());
+    this.#nextToken();
+    return this.#finishNode(node);
+  }
+  #getLastError(diagnostics) {
+    return diagnostics && diagnostics.length > 0 ? diagnostics[diagnostics.length - 1] : void 0;
+  }
+  #parseErrorAtPosition(start, end, message, code) {
+    const ds = this.diagnostics;
+    const lastError = this.#getLastError(ds);
+    if (!lastError || start !== lastError.start) {
+      ds.push({
+        category: 1 /* Error */,
+        start,
+        end,
+        message,
+        code
+      });
+    }
+    this.currentNodeHasError = true;
+  }
+  #parseErrorAtCurrentToken(message, sub) {
+    const error = {
+      source: 2 /* Parse */,
+      sub
+    };
+    return this.#parseErrorAtPosition(this.scanner.tokenPos, this.scanner.pos, message, error);
+  }
+  #scanError(message, _category, sub, length) {
+    const errorPos = this.scanner.pos;
+    const err = {
+      source: 1 /* Scan */,
+      sub
+    };
+    this.#parseErrorAtPosition(errorPos, errorPos + length, message, err);
+  }
+  #reportExpectedError(expectedKinds) {
+    const found = this.#isIdentifier() ? "identifier" : this.#token() === 1 /* EndOfFileToken */ ? "end of file" : `"${getTokenAsText(this.#token())}"`;
+    const expected = expectedKinds.map((k) => {
+      if (isIdentifier(k)) {
+        return "identifier";
+      }
+      if (k === 1 /* EndOfFileToken */) {
+        return "end of file";
+      }
+      return `"${getTokenAsText(k)}"`;
+    });
+    const lastExpected = expected.pop();
+    const expectedJoined = expected.join(", ");
+    const msg = expected.length > 0 ? `Expected ${expectedJoined} or ${lastExpected} but found ${found} instead.` : `Expected ${lastExpected} but found ${found} instead.`;
+    this.#parseErrorAtCurrentToken(msg, 0 /* ExpectationFailed */);
+  }
+  #parseExpectedOneOf(...kinds) {
+    if (kinds.length < 2) {
+      console.assert(false);
+      debugger;
+    }
+    for (const kind of kinds) {
+      if (this.#token() === kind) {
+        this.#nextToken();
+        return true;
+      }
+    }
+    this.#reportExpectedError(kinds);
+    return false;
+  }
+  #parseExpectedTokenOneOf(fallback, kinds) {
+    if (kinds.length < 2) {
+      console.assert(false);
+      debugger;
+    }
+    for (const kind of kinds) {
+      if (this.#token() === kind) {
+        const node = this.#createNode(this.#token());
+        this.#nextToken();
+        return this.#finishNode(node);
+      }
+    }
+    this.#reportExpectedError(kinds);
+    return this.#createMissingNode(fallback);
+  }
+  #parseExpectedToken(kind) {
+    const tokenNode = this.#parseOptionalToken(kind);
+    if (tokenNode !== void 0) return tokenNode;
+    this.#reportExpectedError([kind]);
+    return this.#createMissingNode(kind);
+  }
+  #parseExpected(kind) {
+    const res = this.#parseOptional(kind);
+    if (!res) this.#reportExpectedError([kind]);
+    return res;
+  }
+  #parseOptionalToken(t) {
+    if (this.#token() === t) {
+      return this.#parseTokenNode();
+    }
+    return void 0;
+  }
+  #parseOptional(t) {
+    if (this.#token() === t) {
+      this.#nextToken();
+      return true;
+    }
+    return false;
+  }
+  #isEdgeOp() {
+    switch (this.#token()) {
+      case 39 /* DirectedEdgeOp */:
+      case 40 /* UndirectedEdgeOp */:
+        return true;
+      default:
+        return false;
+    }
+  }
+  #isIdentifier() {
+    switch (this.#token()) {
+      case 30 /* TextIdentifier */:
+      case 32 /* NumericIdentifier */:
+      case 28 /* StringLiteral */:
+      case 29 /* HtmlIdentifier */:
+        return true;
+      default:
+        return false;
+    }
+  }
+  #isCompassPortKind(kind) {
+    return kind >= 26 /* CompassCenterToken */ && kind <= 27 /* CompassEnd */;
+  }
+  #speculationHelper(callback, isLookAhead) {
+    const saveToken = this.#token();
+    const saveDiagnosticsLength = this.diagnostics.length;
+    const result = isLookAhead ? this.scanner.lookAhead(callback) : this.scanner.tryScan(callback);
+    if (!result || isLookAhead) {
+      this.currentToken = saveToken;
+      this.diagnostics.length = saveDiagnosticsLength;
+    }
+    return result;
+  }
+  /** Invokes the provided callback then unconditionally restores the parser to the state it
+   * was in immediately prior to invoking the callback. The result of invoking the callback
+   * is returned from this function.
+   */
+  #lookAhead(callback) {
+    return this.#speculationHelper(
+      callback,
+      /*isLookAhead*/
+      true
+    );
+  }
+  /** Invokes the provided callback. If the callback returns something falsy, then it restores
+   * the parser to the state it was in immediately prior to invoking the callback. If the
+   * callback returns something truthy, then the parser state is not rolled back. The result
+   * of invoking the callback is returned from this function.
+   */
+  #tryParse(callback) {
+    return this.#speculationHelper(
+      callback,
+      /*isLookAhead*/
+      false
+    );
+  }
+};
+function newNode(kind, pos, end) {
+  return {
+    kind,
+    flags: 0 /* None */,
+    end,
+    pos,
+    parent: void 0
+  };
+}
+var newIdentifier = newNode;
+var newToken = newNode;
+function isNodeKind(kind) {
+  return kind >= 41 /* FirstNode */;
+}
+function isIdentifier(kind) {
+  return kind === 29 /* HtmlIdentifier */ || kind === 32 /* NumericIdentifier */ || kind === 30 /* TextIdentifier */ || kind === 31 /* QuotedTextIdentifier */;
+}
+function isIdentifierNode(node) {
+  return isIdentifier(node.kind);
+}
+
+// src/service/languageFacts.ts
+var shapes = Object.freeze([
+  "box",
+  "polygon",
+  "ellipse",
+  "oval",
+  "circle",
+  "point",
+  "egg",
+  "triangle",
+  "plaintext",
+  "plain",
+  "diamond",
+  "trapezium",
+  "parallelogram",
+  "house",
+  "pentagon",
+  "hexagon",
+  "septagon",
+  "octagon",
+  "doublecircle",
+  "doubleoctagon",
+  "tripleoctagon",
+  "invtriangle",
+  "invtrapezium",
+  "invhouse",
+  "Mdiamond",
+  "Msquare",
+  "Mcircle",
+  "record",
+  "rect",
+  "rectangle",
+  "square",
+  "star",
+  "none",
+  "underline",
+  "cylinder",
+  "note",
+  "tab",
+  "folder",
+  "box3d",
+  "component",
+  "promoter",
+  "cds",
+  "terminator",
+  "utr",
+  "primersite",
+  "restrictionsite",
+  "fivepoverhang",
+  "threepoverhang",
+  "noverhang",
+  "assembly",
+  "signature",
+  "insulator",
+  "ribosite",
+  "rnastab",
+  "proteasesite",
+  "proteinstab",
+  "rpromoter",
+  "rarrow",
+  "larrow",
+  "lpromoter"
+]);
+var edgeAttributes = Object.freeze([
+  "URL",
+  "arrowhead",
+  "arrowsize",
+  "arrowtail",
+  "color",
+  "colorscheme",
+  "comment",
+  "constraint",
+  "decorate",
+  "dir",
+  "edgeURL",
+  "edgehref",
+  "edgetarget",
+  "edgetooltip",
+  "fillcolor",
+  "fontcolor",
+  "fontname",
+  "fontsize",
+  "headURL",
+  "head_lp",
+  "headclip",
+  "headhref",
+  "headlabel",
+  "headport",
+  "headtarget",
+  "headtooltip",
+  "href",
+  "id",
+  "label",
+  "labelURL",
+  "labelangle",
+  "labeldistance",
+  "labelfloat",
+  "labelfontcolor",
+  "labelfontname",
+  "labelfontsize",
+  "labelhref",
+  "labeltarget",
+  "labeltooltip",
+  "layer",
+  "len",
+  "lhead",
+  "lp",
+  "ltail",
+  "minlen",
+  "nojustify",
+  "penwidth",
+  "pos",
+  "samehead",
+  "sametail",
+  "showboxes",
+  "style",
+  "tailURL",
+  "tail_lp",
+  "tailclip",
+  "tailhref",
+  "taillabel",
+  "tailport",
+  "tailtarget",
+  "tailtooltip",
+  "target",
+  "tooltip",
+  "weight",
+  "xlabel",
+  "xlp"
+]);
+var nodeAttributes = Object.freeze([
+  "URL",
+  "area",
+  "color",
+  "colorscheme",
+  "comment",
+  "distortion",
+  "fillcolor",
+  "fixedsize",
+  "fontcolor",
+  "fontname",
+  "fontsize",
+  "gradientangle",
+  "group",
+  "height",
+  "href",
+  "id",
+  "image",
+  "imagepos",
+  "imagescale",
+  "label",
+  "labelloc",
+  "layer",
+  "margin",
+  "nojustify",
+  "ordering",
+  "orientation",
+  "penwidth",
+  "peripheries",
+  "pin",
+  "pos",
+  "rects",
+  "regular",
+  "root",
+  "samplepoints",
+  "shape",
+  "shapefile",
+  "showboxes",
+  "sides",
+  "skew",
+  "sortv",
+  "style",
+  "target",
+  "tooltip",
+  "vertices",
+  "width",
+  "xlabel",
+  "xlp",
+  "z"
+]);
+var graphAttributes = Object.freeze([
+  "Damping",
+  "K",
+  "URL",
+  "_background",
+  "bb",
+  "bgcolor",
+  "center",
+  "charset",
+  "clusterrank",
+  "colorscheme",
+  "comment",
+  "compound",
+  "concentrate",
+  "defaultdist",
+  "dim",
+  "dimen",
+  "diredgeconstraints",
+  "dpi",
+  "epsilon",
+  "esep",
+  "fontcolor",
+  "fontname",
+  "fontnames",
+  "fontpath",
+  "fontsize",
+  "forcelabels",
+  "gradientangle",
+  "href",
+  "id",
+  "imagepath",
+  "inputscale",
+  "label",
+  "label_scheme",
+  "labeljust",
+  "labelloc",
+  "landscape",
+  "layerlistsep",
+  "layers",
+  "layerselect",
+  "layersep",
+  "layout",
+  "levels",
+  "levelsgap",
+  "lheight",
+  "lp",
+  "lwidth",
+  "margin",
+  "maxiter",
+  "mclimit",
+  "mindist",
+  "mode",
+  "model",
+  "mosek",
+  "newrank",
+  "nodesep",
+  "nojustify",
+  "normalize",
+  "notranslate",
+  "nslimit",
+  "nslimit1",
+  "ordering",
+  "orientation",
+  "outputorder",
+  "overlap",
+  "overlap_scaling",
+  "overlap_shrink",
+  "pack",
+  "packmode",
+  "pad",
+  "page",
+  "pagedir",
+  "quadtree",
+  "quantum",
+  "rankdir",
+  "ranksep",
+  "ratio",
+  "remincross",
+  "repulsiveforce",
+  "resolution",
+  "root",
+  "rotate",
+  "rotation",
+  "scale",
+  "searchsize",
+  "sep",
+  "showboxes",
+  "size",
+  "smoothing",
+  "sortv",
+  "splines",
+  "start",
+  "style",
+  "stylesheet",
+  "target",
+  "truecolor",
+  "viewport",
+  "voro_margin",
+  "xdotversion"
+]);
+var clusterAttributes = Object.freeze([
+  "K",
+  "URL",
+  "area",
+  "bgcolor",
+  "color",
+  "colorscheme",
+  "fillcolor",
+  "fontcolor",
+  "fontname",
+  "fontsize",
+  "gradientangle",
+  "href",
+  "id",
+  "label",
+  "labeljust",
+  "labelloc",
+  "layer",
+  "lheight",
+  "lp",
+  "lwidth",
+  "margin",
+  "nojustify",
+  "pencolor",
+  "penwidth",
+  "peripheries",
+  "sortv",
+  "style",
+  "target",
+  "tooltip"
+]);
+var attributes = Array.from(
+  /* @__PURE__ */ new Set([...nodeAttributes, ...edgeAttributes, ...graphAttributes, ...clusterAttributes])
+).sort();
+var colors = Object.freeze({
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  antiquewhite1: "#ffefdb",
+  antiquewhite2: "#eedfcc",
+  antiquewhite3: "#cdc0b0",
+  antiquewhite4: "#8b8378",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  aquamarine1: "#7fffd4",
+  aquamarine2: "#76eec6",
+  aquamarine3: "#66cdaa",
+  aquamarine4: "#458b74",
+  azure: "#f0ffff",
+  azure1: "#f0ffff",
+  azure2: "#e0eeee",
+  azure3: "#c1cdcd",
+  azure4: "#838b8b",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  bisque1: "#ffe4c4",
+  bisque2: "#eed5b7",
+  bisque3: "#cdb79e",
+  bisque4: "#8b7d6b",
+  black: "#000000",
+  blanchedalmond: "#ffebcd",
+  blue: "#0000ff",
+  blue1: "#0000ff",
+  blue2: "#0000ee",
+  blue3: "#0000cd",
+  blue4: "#00008b",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  brown1: "#ff4040",
+  brown2: "#ee3b3b",
+  brown3: "#cd3333",
+  brown4: "#8b2323",
+  burlywood: "#deb887",
+  burlywood1: "#ffd39b",
+  burlywood2: "#eec591",
+  burlywood3: "#cdaa7d",
+  burlywood4: "#8b7355",
+  cadetblue: "#5f9ea0",
+  cadetblue1: "#98f5ff",
+  cadetblue2: "#8ee5ee",
+  cadetblue3: "#7ac5cd",
+  cadetblue4: "#53868b",
+  chartreuse: "#7fff00",
+  chartreuse1: "#7fff00",
+  chartreuse2: "#76ee00",
+  chartreuse3: "#66cd00",
+  chartreuse4: "#458b00",
+  chocolate: "#d2691e",
+  chocolate1: "#ff7f24",
+  chocolate2: "#ee7621",
+  chocolate3: "#cd661d",
+  chocolate4: "#8b4513",
+  coral: "#ff7f50",
+  coral1: "#ff7256",
+  coral2: "#ee6a50",
+  coral3: "#cd5b45",
+  coral4: "#8b3e2f",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  cornsilk1: "#fff8dc",
+  cornsilk2: "#eee8cd",
+  cornsilk3: "#cdc8b1",
+  cornsilk4: "#8b8878",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  cyan1: "#00ffff",
+  cyan2: "#00eeee",
+  cyan3: "#00cdcd",
+  cyan4: "#008b8b",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgoldenrod1: "#ffb90f",
+  darkgoldenrod2: "#eead0e",
+  darkgoldenrod3: "#cd950c",
+  darkgoldenrod4: "#8b6508",
+  darkgray: "#a9a9a9",
+  darkgreen: "#006400",
+  darkgrey: "#a9a9a9",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkolivegreen1: "#caff70",
+  darkolivegreen2: "#bcee68",
+  darkolivegreen3: "#a2cd5a",
+  darkolivegreen4: "#6e8b3d",
+  darkorange: "#ff8c00",
+  darkorange1: "#ff7f00",
+  darkorange2: "#ee7600",
+  darkorange3: "#cd6600",
+  darkorange4: "#8b4500",
+  darkorchid: "#9932cc",
+  darkorchid1: "#bf3eff",
+  darkorchid2: "#b23aee",
+  darkorchid3: "#9a32cd",
+  darkorchid4: "#68228b",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkseagreen1: "#c1ffc1",
+  darkseagreen2: "#b4eeb4",
+  darkseagreen3: "#9bcd9b",
+  darkseagreen4: "#698b69",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkslategray1: "#97ffff",
+  darkslategray2: "#8deeee",
+  darkslategray3: "#79cdcd",
+  darkslategray4: "#528b8b",
+  darkslategrey: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deeppink1: "#ff1493",
+  deeppink2: "#ee1289",
+  deeppink3: "#cd1076",
+  deeppink4: "#8b0a50",
+  deepskyblue: "#00bfff",
+  deepskyblue1: "#00bfff",
+  deepskyblue2: "#00b2ee",
+  deepskyblue3: "#009acd",
+  deepskyblue4: "#00688b",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  dodgerblue: "#1e90ff",
+  dodgerblue1: "#1e90ff",
+  dodgerblue2: "#1c86ee",
+  dodgerblue3: "#1874cd",
+  dodgerblue4: "#104e8b",
+  firebrick: "#b22222",
+  firebrick1: "#ff3030",
+  firebrick2: "#ee2c2c",
+  firebrick3: "#cd2626",
+  firebrick4: "#8b1a1a",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  gold1: "#ffd700",
+  gold2: "#eec900",
+  gold3: "#cdad00",
+  gold4: "#8b7500",
+  goldenrod: "#daa520",
+  goldenrod1: "#ffc125",
+  goldenrod2: "#eeb422",
+  goldenrod3: "#cd9b1d",
+  goldenrod4: "#8b6914",
+  gray: "#c0c0c0",
+  gray0: "#000000",
+  gray1: "#030303",
+  gray10: "#1a1a1a",
+  gray100: "#ffffff",
+  gray11: "#1c1c1c",
+  gray12: "#1f1f1f",
+  gray13: "#212121",
+  gray14: "#242424",
+  gray15: "#262626",
+  gray16: "#292929",
+  gray17: "#2b2b2b",
+  gray18: "#2e2e2e",
+  gray19: "#303030",
+  gray2: "#050505",
+  gray20: "#333333",
+  gray21: "#363636",
+  gray22: "#383838",
+  gray23: "#3b3b3b",
+  gray24: "#3d3d3d",
+  gray25: "#404040",
+  gray26: "#424242",
+  gray27: "#454545",
+  gray28: "#474747",
+  gray29: "#4a4a4a",
+  gray3: "#080808",
+  gray30: "#4d4d4d",
+  gray31: "#4f4f4f",
+  gray32: "#525252",
+  gray33: "#545454",
+  gray34: "#575757",
+  gray35: "#595959",
+  gray36: "#5c5c5c",
+  gray37: "#5e5e5e",
+  gray38: "#616161",
+  gray39: "#636363",
+  gray4: "#0a0a0a",
+  gray40: "#666666",
+  gray41: "#696969",
+  gray42: "#6b6b6b",
+  gray43: "#6e6e6e",
+  gray44: "#707070",
+  gray45: "#737373",
+  gray46: "#757575",
+  gray47: "#787878",
+  gray48: "#7a7a7a",
+  gray49: "#7d7d7d",
+  gray5: "#0d0d0d",
+  gray50: "#7f7f7f",
+  gray51: "#828282",
+  gray52: "#858585",
+  gray53: "#878787",
+  gray54: "#8a8a8a",
+  gray55: "#8c8c8c",
+  gray56: "#8f8f8f",
+  gray57: "#919191",
+  gray58: "#949494",
+  gray59: "#969696",
+  gray6: "#0f0f0f",
+  gray60: "#999999",
+  gray61: "#9c9c9c",
+  gray62: "#9e9e9e",
+  gray63: "#a1a1a1",
+  gray64: "#a3a3a3",
+  gray65: "#a6a6a6",
+  gray66: "#a8a8a8",
+  gray67: "#ababab",
+  gray68: "#adadad",
+  gray69: "#b0b0b0",
+  gray7: "#121212",
+  gray70: "#b3b3b3",
+  gray71: "#b5b5b5",
+  gray72: "#b8b8b8",
+  gray73: "#bababa",
+  gray74: "#bdbdbd",
+  gray75: "#bfbfbf",
+  gray76: "#c2c2c2",
+  gray77: "#c4c4c4",
+  gray78: "#c7c7c7",
+  gray79: "#c9c9c9",
+  gray8: "#141414",
+  gray80: "#cccccc",
+  gray81: "#cfcfcf",
+  gray82: "#d1d1d1",
+  gray83: "#d4d4d4",
+  gray84: "#d6d6d6",
+  gray85: "#d9d9d9",
+  gray86: "#dbdbdb",
+  gray87: "#dedede",
+  gray88: "#e0e0e0",
+  gray89: "#e3e3e3",
+  gray9: "#171717",
+  gray90: "#e5e5e5",
+  gray91: "#e8e8e8",
+  gray92: "#ebebeb",
+  gray93: "#ededed",
+  gray94: "#f0f0f0",
+  gray95: "#f2f2f2",
+  gray96: "#f5f5f5",
+  gray97: "#f7f7f7",
+  gray98: "#fafafa",
+  gray99: "#fcfcfc",
+  green: "#00ff00",
+  green1: "#00ff00",
+  green2: "#00ee00",
+  green3: "#00cd00",
+  green4: "#008b00",
+  greenyellow: "#adff2f",
+  grey: "#c0c0c0",
+  grey0: "#000000",
+  grey1: "#030303",
+  grey10: "#1a1a1a",
+  grey100: "#ffffff",
+  grey11: "#1c1c1c",
+  grey12: "#1f1f1f",
+  grey13: "#212121",
+  grey14: "#242424",
+  grey15: "#262626",
+  grey16: "#292929",
+  grey17: "#2b2b2b",
+  grey18: "#2e2e2e",
+  grey19: "#303030",
+  grey2: "#050505",
+  grey20: "#333333",
+  grey21: "#363636",
+  grey22: "#383838",
+  grey23: "#3b3b3b",
+  grey24: "#3d3d3d",
+  grey25: "#404040",
+  grey26: "#424242",
+  grey27: "#454545",
+  grey28: "#474747",
+  grey29: "#4a4a4a",
+  grey3: "#080808",
+  grey30: "#4d4d4d",
+  grey31: "#4f4f4f",
+  grey32: "#525252",
+  grey33: "#545454",
+  grey34: "#575757",
+  grey35: "#595959",
+  grey36: "#5c5c5c",
+  grey37: "#5e5e5e",
+  grey38: "#616161",
+  grey39: "#636363",
+  grey4: "#0a0a0a",
+  grey40: "#666666",
+  grey41: "#696969",
+  grey42: "#6b6b6b",
+  grey43: "#6e6e6e",
+  grey44: "#707070",
+  grey45: "#737373",
+  grey46: "#757575",
+  grey47: "#787878",
+  grey48: "#7a7a7a",
+  grey49: "#7d7d7d",
+  grey5: "#0d0d0d",
+  grey50: "#7f7f7f",
+  grey51: "#828282",
+  grey52: "#858585",
+  grey53: "#878787",
+  grey54: "#8a8a8a",
+  grey55: "#8c8c8c",
+  grey56: "#8f8f8f",
+  grey57: "#919191",
+  grey58: "#949494",
+  grey59: "#969696",
+  grey6: "#0f0f0f",
+  grey60: "#999999",
+  grey61: "#9c9c9c",
+  grey62: "#9e9e9e",
+  grey63: "#a1a1a1",
+  grey64: "#a3a3a3",
+  grey65: "#a6a6a6",
+  grey66: "#a8a8a8",
+  grey67: "#ababab",
+  grey68: "#adadad",
+  grey69: "#b0b0b0",
+  grey7: "#121212",
+  grey70: "#b3b3b3",
+  grey71: "#b5b5b5",
+  grey72: "#b8b8b8",
+  grey73: "#bababa",
+  grey74: "#bdbdbd",
+  grey75: "#bfbfbf",
+  grey76: "#c2c2c2",
+  grey77: "#c4c4c4",
+  grey78: "#c7c7c7",
+  grey79: "#c9c9c9",
+  grey8: "#141414",
+  grey80: "#cccccc",
+  grey81: "#cfcfcf",
+  grey82: "#d1d1d1",
+  grey83: "#d4d4d4",
+  grey84: "#d6d6d6",
+  grey85: "#d9d9d9",
+  grey86: "#dbdbdb",
+  grey87: "#dedede",
+  grey88: "#e0e0e0",
+  grey89: "#e3e3e3",
+  grey9: "#171717",
+  grey90: "#e5e5e5",
+  grey91: "#e8e8e8",
+  grey92: "#ebebeb",
+  grey93: "#ededed",
+  grey94: "#f0f0f0",
+  grey95: "#f2f2f2",
+  grey96: "#f5f5f5",
+  grey97: "#f7f7f7",
+  grey98: "#fafafa",
+  grey99: "#fcfcfc",
+  honeydew: "#f0fff0",
+  honeydew1: "#f0fff0",
+  honeydew2: "#e0eee0",
+  honeydew3: "#c1cdc1",
+  honeydew4: "#838b83",
+  hotpink: "#ff69b4",
+  hotpink1: "#ff6eb4",
+  hotpink2: "#ee6aa7",
+  hotpink3: "#cd6090",
+  hotpink4: "#8b3a62",
+  indianred: "#cd5c5c",
+  indianred1: "#ff6a6a",
+  indianred2: "#ee6363",
+  indianred3: "#cd5555",
+  indianred4: "#8b3a3a",
+  indigo: "#4b0082",
+  invis: "#fffffe",
+  ivory: "#fffff0",
+  ivory1: "#fffff0",
+  ivory2: "#eeeee0",
+  ivory3: "#cdcdc1",
+  ivory4: "#8b8b83",
+  khaki: "#f0e68c",
+  khaki1: "#fff68f",
+  khaki2: "#eee685",
+  khaki3: "#cdc673",
+  khaki4: "#8b864e",
+  lavender: "#e6e6fa",
+  lavenderblush: "#fff0f5",
+  lavenderblush1: "#fff0f5",
+  lavenderblush2: "#eee0e5",
+  lavenderblush3: "#cdc1c5",
+  lavenderblush4: "#8b8386",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lemonchiffon1: "#fffacd",
+  lemonchiffon2: "#eee9bf",
+  lemonchiffon3: "#cdc9a5",
+  lemonchiffon4: "#8b8970",
+  lightblue: "#add8e6",
+  lightblue1: "#bfefff",
+  lightblue2: "#b2dfee",
+  lightblue3: "#9ac0cd",
+  lightblue4: "#68838b",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightcyan1: "#e0ffff",
+  lightcyan2: "#d1eeee",
+  lightcyan3: "#b4cdcd",
+  lightcyan4: "#7a8b8b",
+  lightgoldenrod: "#eedd82",
+  lightgoldenrod1: "#ffec8b",
+  lightgoldenrod2: "#eedc82",
+  lightgoldenrod3: "#cdbe70",
+  lightgoldenrod4: "#8b814c",
+  lightgoldenrodyellow: "#fafad2",
+  lightgray: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightgrey: "#d3d3d3",
+  lightpink: "#ffb6c1",
+  lightpink1: "#ffaeb9",
+  lightpink2: "#eea2ad",
+  lightpink3: "#cd8c95",
+  lightpink4: "#8b5f65",
+  lightsalmon: "#ffa07a",
+  lightsalmon1: "#ffa07a",
+  lightsalmon2: "#ee9572",
+  lightsalmon3: "#cd8162",
+  lightsalmon4: "#8b5742",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightskyblue1: "#b0e2ff",
+  lightskyblue2: "#a4d3ee",
+  lightskyblue3: "#8db6cd",
+  lightskyblue4: "#607b8b",
+  lightslateblue: "#8470ff",
+  lightslategray: "#778899",
+  lightslategrey: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightsteelblue1: "#cae1ff",
+  lightsteelblue2: "#bcd2ee",
+  lightsteelblue3: "#a2b5cd",
+  lightsteelblue4: "#6e7b8b",
+  lightyellow: "#ffffe0",
+  lightyellow1: "#ffffe0",
+  lightyellow2: "#eeeed1",
+  lightyellow3: "#cdcdb4",
+  lightyellow4: "#8b8b7a",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  magenta1: "#ff00ff",
+  magenta2: "#ee00ee",
+  magenta3: "#cd00cd",
+  magenta4: "#8b008b",
+  maroon: "#b03060",
+  maroon1: "#ff34b3",
+  maroon2: "#ee30a7",
+  maroon3: "#cd2990",
+  maroon4: "#8b1c62",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumorchid1: "#e066ff",
+  mediumorchid2: "#d15fee",
+  mediumorchid3: "#b452cd",
+  mediumorchid4: "#7a378b",
+  mediumpurple: "#9370db",
+  mediumpurple1: "#ab82ff",
+  mediumpurple2: "#9f79ee",
+  mediumpurple3: "#8968cd",
+  mediumpurple4: "#5d478b",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  mistyrose1: "#ffe4e1",
+  mistyrose2: "#eed5d2",
+  mistyrose3: "#cdb7b5",
+  mistyrose4: "#8b7d7b",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  navajowhite1: "#ffdead",
+  navajowhite2: "#eecfa1",
+  navajowhite3: "#cdb38b",
+  navajowhite4: "#8b795e",
+  navy: "#000080",
+  navyblue: "#000080",
+  none: "#fffffe",
+  oldlace: "#fdf5e6",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  olivedrab1: "#c0ff3e",
+  olivedrab2: "#b3ee3a",
+  olivedrab3: "#9acd32",
+  olivedrab4: "#698b22",
+  orange: "#ffa500",
+  orange1: "#ffa500",
+  orange2: "#ee9a00",
+  orange3: "#cd8500",
+  orange4: "#8b5a00",
+  orangered: "#ff4500",
+  orangered1: "#ff4500",
+  orangered2: "#ee4000",
+  orangered3: "#cd3700",
+  orangered4: "#8b2500",
+  orchid: "#da70d6",
+  orchid1: "#ff83fa",
+  orchid2: "#ee7ae9",
+  orchid3: "#cd69c9",
+  orchid4: "#8b4789",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  palegreen1: "#9aff9a",
+  palegreen2: "#90ee90",
+  palegreen3: "#7ccd7c",
+  palegreen4: "#548b54",
+  paleturquoise: "#afeeee",
+  paleturquoise1: "#bbffff",
+  paleturquoise2: "#aeeeee",
+  paleturquoise3: "#96cdcd",
+  paleturquoise4: "#668b8b",
+  palevioletred: "#db7093",
+  palevioletred1: "#ff82ab",
+  palevioletred2: "#ee799f",
+  palevioletred3: "#cd6889",
+  palevioletred4: "#8b475d",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peachpuff1: "#ffdab9",
+  peachpuff2: "#eecbad",
+  peachpuff3: "#cdaf95",
+  peachpuff4: "#8b7765",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  pink1: "#ffb5c5",
+  pink2: "#eea9b8",
+  pink3: "#cd919e",
+  pink4: "#8b636c",
+  plum: "#dda0dd",
+  plum1: "#ffbbff",
+  plum2: "#eeaeee",
+  plum3: "#cd96cd",
+  plum4: "#8b668b",
+  powderblue: "#b0e0e6",
+  purple: "#a020f0",
+  purple1: "#9b30ff",
+  purple2: "#912cee",
+  purple3: "#7d26cd",
+  purple4: "#551a8b",
+  rebeccapurple: "#663399",
+  red: "#ff0000",
+  red1: "#ff0000",
+  red2: "#ee0000",
+  red3: "#cd0000",
+  red4: "#8b0000",
+  rosybrown: "#bc8f8f",
+  rosybrown1: "#ffc1c1",
+  rosybrown2: "#eeb4b4",
+  rosybrown3: "#cd9b9b",
+  rosybrown4: "#8b6969",
+  royalblue: "#4169e1",
+  royalblue1: "#4876ff",
+  royalblue2: "#436eee",
+  royalblue3: "#3a5fcd",
+  royalblue4: "#27408b",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  salmon1: "#ff8c69",
+  salmon2: "#ee8262",
+  salmon3: "#cd7054",
+  salmon4: "#8b4c39",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seagreen1: "#54ff9f",
+  seagreen2: "#4eee94",
+  seagreen3: "#43cd80",
+  seagreen4: "#2e8b57",
+  seashell: "#fff5ee",
+  seashell1: "#fff5ee",
+  seashell2: "#eee5de",
+  seashell3: "#cdc5bf",
+  seashell4: "#8b8682",
+  sienna: "#a0522d",
+  sienna1: "#ff8247",
+  sienna2: "#ee7942",
+  sienna3: "#cd6839",
+  sienna4: "#8b4726",
+  silver: "#c0c0c0",
+  skyblue: "#87ceeb",
+  skyblue1: "#87ceff",
+  skyblue2: "#7ec0ee",
+  skyblue3: "#6ca6cd",
+  skyblue4: "#4a708b",
+  slateblue: "#6a5acd",
+  slateblue1: "#836fff",
+  slateblue2: "#7a67ee",
+  slateblue3: "#6959cd",
+  slateblue4: "#473c8b",
+  slategray: "#708090",
+  slategray1: "#c6e2ff",
+  slategray2: "#b9d3ee",
+  slategray3: "#9fb6cd",
+  slategray4: "#6c7b8b",
+  slategrey: "#708090",
+  snow: "#fffafa",
+  snow1: "#fffafa",
+  snow2: "#eee9e9",
+  snow3: "#cdc9c9",
+  snow4: "#8b8989",
+  springgreen: "#00ff7f",
+  springgreen1: "#00ff7f",
+  springgreen2: "#00ee76",
+  springgreen3: "#00cd66",
+  springgreen4: "#008b45",
+  steelblue: "#4682b4",
+  steelblue1: "#63b8ff",
+  steelblue2: "#5cacee",
+  steelblue3: "#4f94cd",
+  steelblue4: "#36648b",
+  tan: "#d2b48c",
+  tan1: "#ffa54f",
+  tan2: "#ee9a49",
+  tan3: "#cd853f",
+  tan4: "#8b5a2b",
+  teal: "#008080",
+  thistle: "#d8bfd8",
+  thistle1: "#ffe1ff",
+  thistle2: "#eed2ee",
+  thistle3: "#cdb5cd",
+  thistle4: "#8b7b8b",
+  tomato: "#ff6347",
+  tomato1: "#ff6347",
+  tomato2: "#ee5c42",
+  tomato3: "#cd4f39",
+  tomato4: "#8b3626",
+  transparent: "#fffffe",
+  turquoise: "#40e0d0",
+  turquoise1: "#00f5ff",
+  turquoise2: "#00e5ee",
+  turquoise3: "#00c5cd",
+  turquoise4: "#00868b",
+  violet: "#ee82ee",
+  violetred: "#d02090",
+  violetred1: "#ff3e96",
+  violetred2: "#ee3a8c",
+  violetred3: "#cd3278",
+  violetred4: "#8b2252",
+  webgray: "#808080",
+  webgreen: "#008000",
+  webgrey: "#808080",
+  webmaroon: "#800000",
+  webpurple: "#800080",
+  wheat: "#f5deb3",
+  wheat1: "#ffe7ba",
+  wheat2: "#eed8ae",
+  wheat3: "#cdba96",
+  wheat4: "#8b7e66",
+  white: "#ffffff",
+  whitesmoke: "#f5f5f5",
+  x11gray: "#bebebe",
+  x11green: "#00ff00",
+  x11grey: "#bebebe",
+  x11maroon: "#b03060",
+  x11purple: "#a020f0",
+  yellow: "#ffff00",
+  yellow1: "#ffff00",
+  yellow2: "#eeee00",
+  yellow3: "#cdcd00",
+  yellow4: "#8b8b00",
+  yellowgreen: "#9acd32"
+});
+
+// src/visitor.ts
+function visitNode(cbNode, node) {
+  return node && cbNode(node);
+}
+function visitNodes(cbNode, cbNodes, nodes) {
+  if (nodes) {
+    if (cbNodes) return cbNodes(nodes);
+    for (const node of nodes) {
+      const result = cbNode(node);
+      if (result) return result;
+    }
+  }
+  return void 0;
+}
+function forEachChild(node, cbNode, cbNodes) {
+  if (!node || node.kind <= 38 /* LastKeyword */) return;
+  switch (node.kind) {
+    case 41 /* DirectedGraph */:
+    case 42 /* UndirectedGraph */:
+      return visitNodes(cbNode, cbNodes, node.statements) || visitNode(cbNode, node.strict) || visitNode(cbNode, node.id);
+    case 45 /* AttributeStatement */:
+      return visitNodes(cbNode, cbNodes, node.attributes) || visitNode(cbNode, node.subject) || visitNode(cbNode, node.terminator);
+    case 44 /* EdgeStatement */:
+      return visitNodes(cbNode, cbNodes, node.attributes) || visitNodes(cbNode, cbNodes, node.rhs) || visitNode(cbNode, node.source) || visitNode(cbNode, node.terminator);
+    case 43 /* NodeStatement */:
+      return visitNodes(cbNode, cbNodes, node.attributes) || visitNode(cbNode, node.id) || visitNode(cbNode, node.terminator);
+    case 47 /* SubGraph */:
+      return visitNodes(cbNode, cbNodes, node.statements) || visitNode(cbNode, node.id);
+    case 48 /* SubGraphStatement */:
+      return visitNode(cbNode, node.subgraph) || visitNode(cbNode, node.terminator);
+    case 46 /* IdEqualsIdStatement */:
+      return visitNode(cbNode, node.leftId) || visitNode(cbNode, node.rightId) || visitNode(cbNode, node.terminator);
+    case 31 /* QuotedTextIdentifier */:
+      return visitNodes(cbNode, cbNodes, node.values);
+    case 49 /* EdgeRhs */:
+      return visitNode(cbNode, node.operation) || visitNode(cbNode, node.target);
+    case 50 /* AttributeContainer */:
+      return visitNodes(cbNode, cbNodes, node.assignments);
+    case 51 /* Assignment */:
+      return visitNode(cbNode, node.leftId) || visitNode(cbNode, node.rightId) || visitNode(cbNode, node.terminator);
+    case 52 /* NormalPortDeclaration */:
+      return visitNode(cbNode, node.colon) || visitNode(cbNode, node.id) || visitNode(cbNode, node.compassPt);
+    case 53 /* CompassPortDeclaration */:
+      return visitNode(cbNode, node.colon) || visitNode(cbNode, node.compassPt);
+    case 54 /* NodeId */:
+      return visitNode(cbNode, node.port) || visitNode(cbNode, node.id);
+    default:
+      return void 0;
+  }
+}
+
+// src/checker.ts
+function checkSourceFile(file) {
+  const g = file.graph;
+  if (g) {
+    const messages = checkGraphSemantics(file, g);
+    if (messages) {
+      file.diagnostics.push.apply(file.diagnostics, messages);
+    }
+  }
+}
+function rangeContainsOffset(range, offset, inclusiveEnd) {
+  return inclusiveEnd ? range.pos <= offset && offset <= range.end : range.pos <= offset && offset < range.end;
+}
+function findNodeAtOffset(root, offset, inclusiveEnd = false) {
+  if (root.pos === offset && root.pos === root.end) return root;
+  if (rangeContainsOffset(root, offset, inclusiveEnd)) {
+    const narrowerChild = forEachChild(
+      root,
+      (child) => findNodeAtOffset(child, offset, inclusiveEnd)
+    );
+    return narrowerChild ? narrowerChild : root;
+  }
+  return void 0;
+}
+function getAllowedEdgeOperation(graph) {
+  return graph.kind === 41 /* DirectedGraph */ ? 39 /* DirectedEdgeOp */ : 40 /* UndirectedEdgeOp */;
+}
+function checkGraphSemantics(file, root) {
+  const expectedEdgeOp = getAllowedEdgeOperation(root);
+  const invalidEdgeRhses = findEdgeErrors(expectedEdgeOp, root);
+  const invalidShapes = checkShapeLabelValues(root);
+  const invalidEdgeDiagnostics = invalidEdgeRhses === void 0 || invalidEdgeRhses.length === 0 ? [] : createEdgeViolationDiagnostics(file, expectedEdgeOp, invalidEdgeRhses);
+  return [...invalidEdgeDiagnostics, ...invalidShapes];
+}
+function forEachAssignmentTransitive(root, cb) {
+  forEachChild(root, (child) => {
+    if (child.kind === 51 /* Assignment */) {
+      cb(child);
+      return;
+    }
+    forEachChild(child, (c) => forEachAssignmentTransitive(c, cb));
+  });
+}
+function checkShapeLabelValues(root) {
+  const invalidShapes = [];
+  forEachAssignmentTransitive(root, (assignment) => {
+    const { leftId, rightId } = assignment;
+    if (leftId.kind !== 30 /* TextIdentifier */ || rightId.kind !== 30 /* TextIdentifier */) {
+      return;
+    }
+    const leftText = leftId.text.trim();
+    if (leftText.toLocaleLowerCase() !== "shape") {
+      return;
+    }
+    const rightText = rightId.text.trim();
+    const shapeCandidate = rightText.toLowerCase();
+    if (shapes.includes(shapeCandidate)) {
+      return;
+    }
+    invalidShapes.push({
+      category: 2 /* Warning */,
+      code: createCheckerError(1 /* InvalidShapeName */),
+      message: `Unknown shape "${rightText}".`,
+      start: rightId.pos,
+      end: rightId.end
+    });
+  });
+  return invalidShapes;
+}
+function findAllEdges(node) {
+  const allEdges = [];
+  forEachChild(node, (child) => {
+    if (isEdgeStatement(child)) {
+      if (child.rhs && child.rhs.length > 0) {
+        for (const edgeRhs of child.rhs) allEdges.push(edgeRhs);
+      }
+    }
+    const childEdges = findAllEdges(child);
+    if (childEdges && childEdges.length > 0) allEdges.push.apply(allEdges, childEdges);
+  });
+  return allEdges;
+}
+function findOptionalSemicolons(node) {
+  const statements = findAllStatements(node);
+  const terminators = statements.map((p) => p.terminator);
+  return terminators.filter((t) => !!t);
+}
+function isStatement(node) {
+  return node.kind === 48 /* SubGraphStatement */ || node.kind === 44 /* EdgeStatement */ || node.kind === 43 /* NodeStatement */ || node.kind === 46 /* IdEqualsIdStatement */ || node.kind === 45 /* AttributeStatement */;
+}
+function findAllStatements(node, kind) {
+  const allStatements = [];
+  forEachChild(node, (child) => {
+    if (kind === void 0 && isStatement(child) || child.kind === kind) {
+      allStatements.push(child);
+    }
+    const childStatements = findAllStatements(child, kind);
+    if (childStatements && childStatements.length > 0)
+      allStatements.push.apply(allStatements, childStatements);
+  });
+  return allStatements;
+}
+function findEdgeErrors(expectedEdgeOp, node) {
+  const edges = findAllEdges(node);
+  const wrongEdges = edges && edges.length > 0 ? edges.filter((e) => e.operation.kind !== expectedEdgeOp) : void 0;
+  if (wrongEdges && wrongEdges.length > 0) {
+    for (const edge of wrongEdges) {
+      edge.operation.flags |= 2 /* ContainsErrors */;
+    }
+    return wrongEdges;
+  }
+  return void 0;
+}
+function createEdgeViolationDiagnostics(file, expectedEdgeOp, violators) {
+  const op = expectedEdgeOp === 40 /* UndirectedEdgeOp */ ? "--" : "->";
+  const graphType = expectedEdgeOp === 40 /* UndirectedEdgeOp */ ? "undirected" : "directed";
+  const message = `Invalid edge operation, use "${op}" in ${graphType} graph`;
+  const code = createCheckerError(0 /* InvalidEdgeOperation */);
+  const category = 1 /* Error */;
+  for (const edge of violators) {
+    edge.operation.flags |= 2 /* ContainsErrors */;
+  }
+  return violators.map((edge) => {
+    const start = getStart(file, edge.operation);
+    const end = edge.operation.end;
+    return {
+      message,
+      code,
+      category,
+      start,
+      end
+    };
+  });
+}
+function isAttrStatement(node) {
+  return node.kind === 45 /* AttributeStatement */;
+}
+function isEdgeStatement(node) {
+  return node.kind === 44 /* EdgeStatement */;
+}
+function isNodeId(node) {
+  return node.kind === 54 /* NodeId */;
+}
+function edgeStatementHasAttributes(es) {
+  return es.attributes && es.attributes.length > 0 && es.attributes.some((a) => a.assignments && a.assignments.length > 0);
+}
+function getIdentifierText(n) {
+  switch (n.kind) {
+    case 29 /* HtmlIdentifier */:
+      return n.htmlContent;
+    case 30 /* TextIdentifier */:
+      return n.text;
+    case 32 /* NumericIdentifier */:
+      return n.text;
+    case 31 /* QuotedTextIdentifier */:
+      return n.concatenation;
+    // Assertion because concatenation is filled in binding step
+    default:
+      return assertNever(n);
+  }
+}
+function createCheckerError(sub) {
+  return {
+    source: 4 /* Check */,
+    sub
+  };
+}
+function nodeContainsErrors(node) {
+  return (node.flags & 2 /* ContainsErrors */) === 2 /* ContainsErrors */;
+}
+
+// src/binder.ts
+var binder = createBinder();
+function bindSourceFile(file) {
+  binder.bind(file);
+}
+function createBinder() {
+  let parent;
+  let symbolTable;
+  let colorTable;
+  let graphContext = 0 /* None */;
+  function bind(node) {
+    if (!node) return;
+    const saveParent = parent;
+    const saveContext = graphContext;
+    node.parent = saveParent;
+    node.graphContext = saveContext;
+    parent = node;
+    innerBind(node);
+    parent = saveParent;
+    graphContext = saveContext;
+  }
+  function innerBind(node) {
+    switch (node.kind) {
+      case 41 /* DirectedGraph */:
+      case 42 /* UndirectedGraph */:
+        return bindGraph(node);
+      case 45 /* AttributeStatement */:
+        return bindAttributeStatement(node);
+      case 44 /* EdgeStatement */:
+        return bindEdgeStatement(node);
+      case 43 /* NodeStatement */:
+        return bindNodeStatement(node);
+      case 47 /* SubGraph */:
+        return bindSubGraph(node);
+      case 48 /* SubGraphStatement */:
+        return bindSubGraphStatement(node);
+      case 46 /* IdEqualsIdStatement */:
+        return bindIdEqualsIdStatement(node);
+      case 31 /* QuotedTextIdentifier */:
+        return bindQuotedTextIdentifier(node);
+      case 49 /* EdgeRhs */:
+        return bindEdgeRhs(node);
+      case 50 /* AttributeContainer */:
+        return bindAttributeContainer(node);
+      case 51 /* Assignment */:
+        return bindAssignment(node);
+      case 52 /* NormalPortDeclaration */:
+        return bindNormalPortDeclaration(node);
+      case 53 /* CompassPortDeclaration */:
+        return bindCompassPortDeclaration(node);
+      case 54 /* NodeId */:
+        return bindNodeId(node);
+      default:
+        if (node.kind >= 41 /* FirstNode */) throw "TODO";
+    }
+  }
+  function bindGraph(node) {
+    if (node.strict) {
+      graphContext |= 2 /* Strict */;
+    }
+    switch (node.kind) {
+      case 41 /* DirectedGraph */:
+        graphContext |= 4 /* Directed */;
+        break;
+      case 42 /* UndirectedGraph */:
+        graphContext |= 8 /* Undirected */;
+        break;
+    }
+    if (node.id) {
+      ensureGlobalSymbol(node.id);
+      bind(node.id);
+    }
+    if (node.strict) bind(node.strict);
+    bindChildren(node.statements);
+  }
+  function bindAttributeStatement(node) {
+    bind(node.subject);
+    bindChildren(node.attributes);
+    if (node.terminator) bind(node.terminator);
+  }
+  function bindEdgeStatement(node) {
+    bindChildren(node.attributes);
+    bindChildren(node.rhs);
+    bind(node.source);
+    if (node.terminator) bind(node.terminator);
+  }
+  function bindNodeStatement(node) {
+    bind(node.id);
+    bindChildren(node.attributes);
+    if (node.terminator) bind(node.terminator);
+  }
+  function bindSubGraph(node) {
+    if (node.id) {
+      bind(node.id);
+    }
+    bindChildren(node.statements);
+  }
+  function bindSubGraphStatement(node) {
+    bind(node.subgraph);
+    if (node.terminator) bind(node.terminator);
+  }
+  function bindIdEqualsIdStatement(node) {
+    bind(node.leftId);
+    bind(node.rightId);
+    if (node.rightId && !nodeContainsErrors(node.rightId)) {
+      if (isAttributeName("color", node.leftId)) {
+        ensureGlobalColor(node.rightId);
+      } else if (isAttributeName("fillcolor", node.leftId)) {
+        ensureGlobalColor(node.rightId);
+      } else if (isAttributeName("bgcolor", node.leftId)) {
+        ensureGlobalColor(node.rightId);
+      } else if (isAttributeName("fontcolor", node.leftId)) {
+        ensureGlobalColor(node.rightId);
+      }
+    }
+    if (node.terminator) bind(node.terminator);
+  }
+  function bindQuotedTextIdentifier(node) {
+    bindChildren(node.values);
+    node.concatenation = node.values.map((v) => v.text).join("");
+  }
+  function bindEdgeRhs(node) {
+    bind(node.operation);
+    bind(node.target);
+  }
+  function bindAttributeContainer(node) {
+    bind(node.openBracket);
+    bindChildren(node.assignments);
+    bind(node.closeBracket);
+  }
+  function bindAssignment(node) {
+    const attrContainer = node.parent;
+    console.assert(!!attrContainer);
+    const superParentStatement = attrContainer.parent;
+    console.assert(!!superParentStatement);
+    bind(node.leftId);
+    let carrierIdentifier;
+    switch (superParentStatement.kind) {
+      case 43 /* NodeStatement */:
+        carrierIdentifier = superParentStatement.id.id;
+        break;
+      case 44 /* EdgeStatement */:
+        break;
+      case 48 /* SubGraphStatement */:
+        break;
+      case 45 /* AttributeStatement */:
+        break;
+    }
+    if (carrierIdentifier) ensureMemberSymbol(node.leftId, carrierIdentifier);
+    bind(node.rightId);
+    if (node.rightId && !nodeContainsErrors(node.rightId)) {
+      if (isAttributeName("color", node.leftId)) {
+        ensureGlobalColor(node.rightId);
+      }
+    }
+    if (node.terminator) bind(node.terminator);
+  }
+  function bindNormalPortDeclaration(node) {
+    bind(node.colon);
+    ensureGlobalSymbol(node.id);
+    bind(node.id);
+    if (node.compassPt) bind(node.compassPt);
+  }
+  function bindCompassPortDeclaration(node) {
+    bind(node.colon);
+    if (node.compassPt) bind(node.compassPt);
+  }
+  function bindNodeId(node) {
+    ensureGlobalSymbol(node.id);
+    bind(node.id);
+    if (node.port) bind(node.port);
+  }
+  function bindChildren(nodes) {
+    for (const n of nodes) bind(n);
+  }
+  function createSymbolTable() {
+    return /* @__PURE__ */ new Map();
+  }
+  function createColorTable() {
+    return /* @__PURE__ */ new Map();
+  }
+  function ensureMemberSymbol(node, carrier) {
+    if (node && carrier && isIdentifierNode(node)) {
+      const name = getIdentifierText(node);
+      if (name === void 0) return;
+      const carrierSymbol = carrier.symbol;
+      if (carrierSymbol === void 0) throw "carrierSymbol is undefined";
+      let symbols = carrierSymbol.members;
+      if (symbols === void 0) carrierSymbol.members = symbols = createSymbolTable();
+      ensureSymbolOnTable(name, node, symbols);
+      return;
+    }
+    console.warn("ensureSymbol called on non-identifier node");
+    debugger;
+  }
+  function ensureGlobalSymbol(node) {
+    if (node && isIdentifierNode(node)) {
+      const symbols = symbolTable;
+      const name = getIdentifierText(node);
+      if (name === void 0) return;
+      if (symbols === void 0) throw "symbolTable is undefined";
+      ensureSymbolOnTable(name, node, symbols);
+      return;
+    }
+    console.warn("ensureSymbol called on non-identifier node");
+    debugger;
+  }
+  function ensureSymbolOnTable(name, node, symbols) {
+    if (!name) return;
+    let sym = symbols.get(name);
+    if (sym === void 0) {
+      sym = createSymbol(name, node);
+      symbols.set(name, sym);
+    } else {
+      if (!sym.references) sym.references = [node];
+      else sym.references.push(node);
+    }
+    node.symbol = sym;
+  }
+  function ensureGlobalColor(node) {
+    if (node && isIdentifierNode(node)) {
+      const colors2 = colorTable;
+      const name = getIdentifierText(node);
+      if (name === void 0) return;
+      if (colors2 === void 0) throw "symbolTable is undefined";
+      const color = createColor(node);
+      colors2.set(name, color);
+      return;
+    }
+    console.warn("ensureSymbol called on non-identifier node");
+    debugger;
+  }
+  function createSymbol(name, node) {
+    if (!name) throw "name is falsy";
+    if (!node) throw "node is undefined or null";
+    return {
+      name,
+      firstMention: node,
+      references: void 0
+    };
+  }
+  function createColor(node) {
+    return {
+      node
+    };
+  }
+  function isAttributeName(name, id) {
+    return id ? getIdentifierText(id).trim().toLowerCase() === name : false;
+  }
+  return {
+    bind: (file) => {
+      symbolTable = createSymbolTable();
+      colorTable = createColorTable();
+      const { graph } = file;
+      if (graph) bind(graph);
+      file.symbols = symbolTable;
+      file.colors = colorTable;
+    }
+  };
+}
+
+// src/service/command/common.ts
+import { Range, TextEdit } from "vscode-languageserver-types";
+function createChangeToEdit(start, end, changeTo) {
+  return TextEdit.replace(Range.create(start, end), changeTo);
+}
+function getEdgeStr(op) {
+  return op === 39 /* DirectedEdgeOp */ ? "->" : "--";
+}
+function getGraphKeywordStr(g) {
+  return g === 34 /* DigraphKeyword */ ? "digraph" : "graph";
+}
+function getOppositeKind(g) {
+  return g === 34 /* DigraphKeyword */ ? 33 /* GraphKeyword */ : 34 /* DigraphKeyword */;
+}
+function getOppositeEdgeOp(g) {
+  return g === 39 /* DirectedEdgeOp */ ? 40 /* UndirectedEdgeOp */ : 39 /* DirectedEdgeOp */;
+}
+function getAllowedOp(g) {
+  return g === 34 /* DigraphKeyword */ ? 39 /* DirectedEdgeOp */ : 40 /* UndirectedEdgeOp */;
+}
+
+// src/service/command/ChangeAllOtherEdgeOpsAndFixGraphCommand.ts
+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" /* ConvertGraphType */,
+    arguments: [edgeOffsets, edgeStr, graphOffset, toGraph]
+  };
+}
+function execute(doc, _sourceFile, cmd) {
+  if (!isChangeAllOtherEdgeOpsAndFixGraphCommand(cmd)) return void 0;
+  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" /* ConvertGraphType */ && !!cmd.arguments && cmd.arguments.length === 4;
+}
+
+// src/service/command/ChangeEdgeOpCommand.ts
+import * as lst from "vscode-languageserver-types";
+function create2(startOffset, endOffset, changeTo, changeFrom) {
+  const from = getEdgeStr(changeFrom);
+  const to = getEdgeStr(changeTo);
+  return {
+    title: `Change "${from}" to "${to}".`,
+    command: "DOT.changeEdgeOp" /* ChangeEdgeOp */,
+    arguments: [startOffset, endOffset, to]
+  };
+}
+function execute2(doc, _sourceFile, cmd) {
+  if (!isChangeEdgeOpCommand(cmd)) return void 0;
+  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)]
+      }
+    }
+  };
+}
+function isChangeEdgeOpCommand(cmd) {
+  return cmd.command === "DOT.changeEdgeOp" /* ChangeEdgeOp */ && !!cmd.arguments && cmd.arguments.length === 3;
+}
+
+// src/service/command/ConsolidateDescendantsCommand.ts
+function create3(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" /* ConsolidateDescendants */,
+    arguments: statements.map((s) => s.pos)
+  };
+}
+function execute3(doc, sourceFile, cmd) {
+  if (!isConsolidateDescendantsCommand(cmd)) return void 0;
+  const g = sourceFile.graph;
+  if (!g) return void 0;
+  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 !== void 0) {
+      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" /* ConsolidateDescendants */ && !!cmd.arguments && cmd.arguments.length > 1;
+}
+
+// src/service/command/RemoveSemicolons.ts
+function create4() {
+  return {
+    title: "Remove optional semicolons",
+    command: "DOT.removeSemicolons" /* RemoveSemicolons */,
+    arguments: void 0
+  };
+}
+function execute4(doc, sourceFile, cmd) {
+  if (!isRemoveSemicolonsCommand(cmd)) return void 0;
+  const g = sourceFile.graph;
+  if (!g) return void 0;
+  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" /* RemoveSemicolons */ && (!cmd.arguments || cmd.arguments.length === 0 || cmd.arguments.every((e) => e === void 0));
+}
+
+// src/service/codeAction.ts
+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;
+}
+function getActionsFromDiagnostics(doc, file, range) {
+  const ds = file.diagnostics;
+  if (!ds || ds.length === 0) return void 0;
+  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 ? void 0 : res;
+}
+function getGeneralRefactorings(doc, file, range) {
+  if (!file.graph) return void 0;
+  const g = file.graph;
+  const kw = g.keyword;
+  const rangeStartOffset = doc.offsetAt(range.start);
+  const rangeEndOffset = doc.offsetAt(range.end);
+  const keywordStart = getStart(file, kw);
+  const res = [];
+  if (isInRange(rangeStartOffset, rangeEndOffset, keywordStart, kw.end)) {
+    if (!subtreeContainsErrors(g)) {
+      const oppositeGraphType = getOppositeKind(kw.kind);
+      const convertGraph = convertGraphTypeCommand(file, g, oppositeGraphType);
+      res.push(convertGraph);
+    }
+  }
+  if (rangeStartOffset === rangeEndOffset) {
+    const candidates = [];
+    let clickedNode = findNodeAtOffset(g, rangeStartOffset);
+    if (clickedNode && !!clickedNode.parent) {
+      if (clickedNode.kind === 8 /* SemicolonToken */) {
+        res.push(create4());
+      }
+      if (isIdentifierNode(clickedNode)) {
+        clickedNode = clickedNode.parent;
+      }
+      const clickedEdgeStatement = clickedNode.parent;
+      if (clickedEdgeStatement && !subtreeContainsErrors(clickedEdgeStatement)) {
+        if (isEdgeStatement(clickedEdgeStatement) && clickedEdgeStatement.rhs.length === 1 && isNodeId(clickedEdgeStatement.source) && !edgeStatementHasAttributes(
+          clickedEdgeStatement
+        )) {
+          candidates.push(clickedEdgeStatement);
+          const source = clickedEdgeStatement.source;
+          const sourceText = getIdentifierText(source.id);
+          const graphParent = clickedEdgeStatement.parent;
+          if (graphParent) {
+            let hasVisitedStatement = false;
+            let hasVisitedNodeModifier = false;
+            forEachChild(graphParent, (statement) => {
+              if (statement === clickedEdgeStatement) {
+                hasVisitedStatement = true;
+                return void 0;
+              }
+              if (hasVisitedNodeModifier) {
+                return;
+              }
+              if (hasVisitedStatement) {
+                if (isAttrStatement(statement) || // we have encountered a semantic-changing AttrStatement
+                subtreeContainsErrors(statement)) {
+                  hasVisitedNodeModifier = true;
+                  return true;
+                }
+              }
+              if (hasVisitedStatement) {
+                if (isEdgeStatement(statement) && statement.rhs.length === 1 && !edgeStatementHasAttributes(
+                  statement
+                )) {
+                  const statementSource = statement.source;
+                  if (isNodeId(statementSource)) {
+                    const lowerSourceText = getIdentifierText(
+                      statementSource.id
+                    );
+                    if (sourceText === lowerSourceText) {
+                      candidates.push(statement);
+                    }
+                  }
+                }
+              }
+              return void 0;
+            });
+          }
+        }
+        if (candidates.length > 1) {
+          const action = create3(candidates, true);
+          res.push(action);
+        }
+      }
+    }
+  }
+  return res.length === 0 ? void 0 : res;
+}
+function getCommandsForDiagnostic(doc, file, d) {
+  switch (d.code.source) {
+    case 1 /* Scan */:
+      return getScannerErrorCommand(doc, file, d, d.code);
+    case 2 /* Parse */:
+      return getParserErrorCommand(doc, file, d, d.code);
+    case 4 /* Check */:
+      return getCheckerErrorCommand(doc, file, d, d.code);
+    default:
+      return assertNever(d.code);
+  }
+}
+function getScannerErrorCommand(_doc, _file, d, code) {
+  console.assert(d.code.source === 1 /* Scan */);
+  console.assert(code.source === 1 /* Scan */);
+  return void 0;
+}
+function getParserErrorCommand(_doc, _file, d, code) {
+  console.assert(d.code.source === 2 /* Parse */);
+  console.assert(code.source === 2 /* Parse */);
+  return void 0;
+}
+function getCheckerErrorCommand(_doc, file, d, code) {
+  console.assert(d.code.source === 4 /* Check */);
+  console.assert(code.source === 4 /* Check */);
+  switch (code.sub) {
+    case 0 /* InvalidEdgeOperation */: {
+      const graph = file.graph;
+      if (!graph) return void 0;
+      const allowedOp = getAllowedEdgeOperation(graph);
+      const wrongOp = getOppositeEdgeOp(allowedOp);
+      const kwk = graph.keyword.kind;
+      const fixSingleEdge = create2(d.start, d.end, allowedOp, wrongOp);
+      const fixAll = convertGraphTypeCommand(file, graph, kwk);
+      const convertToThisWrongType = convertGraphTypeCommand(
+        file,
+        graph,
+        getOppositeKind(kwk)
+      );
+      return [fixSingleEdge, fixAll, convertToThisWrongType];
+    }
+    case 1 /* InvalidShapeName */:
+      return void 0;
+  }
+}
+function convertGraphTypeCommand(file, graph, changeToGraphType) {
+  const changeToEdgeOp = getAllowedOp(changeToGraphType);
+  const allEdges = findAllEdges(graph);
+  const edgeOffsets = allEdges.filter((e) => e.operation.kind !== changeToEdgeOp).map((e) => ({
+    start: getStart(file, e.operation),
+    end: e.operation.end
+  }));
+  const graphTypeOffset = {
+    start: getStart(file, graph.keyword),
+    end: graph.keyword.end
+  };
+  return 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;
+}
+var commandHandlers = {
+  ["DOT.changeEdgeOp" /* ChangeEdgeOp */]: execute2,
+  ["DOT.convertGraphType" /* ConvertGraphType */]: execute,
+  ["DOT.consolidateDescendants" /* ConsolidateDescendants */]: execute3,
+  ["DOT.removeSemicolons" /* RemoveSemicolons */]: execute4
+};
+function getAvailableCommands() {
+  return Object.keys(commandHandlers);
+}
+function executeCommand(doc, sourceFile, cmd) {
+  const handler = commandHandlers[cmd.command];
+  return handler === void 0 ? void 0 : handler(doc, sourceFile, cmd);
+}
+function subtreeContainsErrors(node) {
+  if (nodeContainsErrors(node)) return true;
+  let hasError = false;
+  forEachChild(node, (child) => {
+    if (nodeContainsErrors(child)) {
+      hasError = true;
+    }
+    if (!hasError) {
+      hasError = subtreeContainsErrors(child);
+    }
+  });
+  return hasError;
+}
+
+// src/service/colorProvider.ts
+var colorMap = colors;
+function getDocumentColors(doc, sourceFile) {
+  const cs = sourceFile.colors;
+  return cs ? colorTableToColorInformation(doc, sourceFile, cs) : void 0;
+}
+function getColorRepresentations(_doc, _sourceFile, color, range) {
+  return !color || !range ? void 0 : [{ label: `"${getColorStringFromColor(color)}"` }];
+}
+function colorTableToColorInformation(doc, sf, colors2) {
+  if (!colors2 || colors2.size === 0) return [];
+  const res = [];
+  for (const [name, value] of colors2) {
+    if (!name || !value) continue;
+    const color = getColorFromName(name);
+    if (color) {
+      res.push({
+        range: syntaxNodeToRange(doc, sf, value.node),
+        color
+      });
+    }
+  }
+  return res;
+}
+function getColorFromName(name) {
+  if (name.charAt(0) === "#") return getHexCodeColor(name);
+  const colorAlias = colorMap[name.toLowerCase()];
+  return colorAlias ? getHexCodeColor(colorAlias) : void 0;
+}
+function getHexCodeColor(colorCode) {
+  const hexCode = colorCode.charAt(0) === "#" ? colorCode.substring(1) : colorCode;
+  const colorInt = Number.parseInt(hexCode, 16);
+  return {
+    red: (colorInt >> 16 & 255) / 255,
+    green: (colorInt >> 8 & 255) / 255,
+    blue: (colorInt & 255) / 255,
+    alpha: hexCode.length === 8 ? (colorInt >> 24 & 255) / 255 : 1
+  };
+}
+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();
+}
+
+// src/service/completion.ts
+import * as lst2 from "vscode-languageserver-types";
+function getCompletions(doc, sourceFile, position) {
+  const symbols = sourceFile.symbols;
+  if (!symbols) throw "sourceFile is not bound";
+  const g = sourceFile.graph;
+  if (!g) return [];
+  const offset = doc.offsetAt(position);
+  const node = findNodeAtOffset(g, offset, true);
+  if (!node) return [];
+  const prevOffsetNode = findNodeAtOffset(g, offset - 1, true);
+  const parent = node.parent;
+  const prevOffsetNodeParent = prevOffsetNode?.parent;
+  if (parent?.parent && isEdgeStatement(parent.parent) || prevOffsetNodeParent?.parent && isEdgeStatement(prevOffsetNodeParent.parent)) {
+    return getNodeCompletions(symbols);
+  }
+  if (node.kind === 50 /* AttributeContainer */) {
+    const openingBracket = node.openBracket;
+    if (openingBracket.end - 1 > offset - 1) {
+      const exclusions = prevOffsetNode?.kind === 30 /* TextIdentifier */ && prevOffsetNode.symbol ? [prevOffsetNode.symbol.name] : void 0;
+      return getNodeCompletions(symbols, exclusions);
+    }
+  }
+  if (node.kind === 30 /* TextIdentifier */ && parent?.kind === 54 /* NodeId */) {
+    const exclusions = node.symbol ? [node.symbol.name] : void 0;
+    return getNodeCompletions(symbols, exclusions);
+  }
+  if (node.kind === 50 /* AttributeContainer */ || node.kind === 7 /* CommaToken */ && parent?.kind === 51 /* Assignment */) {
+    return getAttributeCompletions(position);
+  }
+  const prevNode = findNodeAtOffset(g, node.pos - 1, true);
+  if (!prevNode) return [];
+  if (isIdentifierNode(prevNode)) {
+    const p = prevNode.parent;
+    if (p) {
+      switch (p.kind) {
+        case 54 /* NodeId */: {
+          return getNodeCompletions(symbols);
+        }
+        case 51 /* Assignment */: {
+          return getAssignmentCompletion(p);
+        }
+      }
+    }
+  }
+  if (node.flags & 2 /* ContainsErrors */ || node.end === node.pos) {
+    const attribute = prevNode;
+    if (!attribute) return [];
+    if (!attribute.parent) throw "sourceFile is not bound";
+    const parent2 = attribute.parent;
+    if (parent2.kind === 51 /* Assignment */) {
+      return getAssignmentCompletion(parent2);
+    }
+  }
+  return [];
+}
+function getAssignmentCompletion(assignment) {
+  const property = getIdentifierText(assignment.leftId);
+  if (!property) return [];
+  switch (property.toLowerCase()) {
+    case "shape":
+      return getShapeCompletions();
+    case "color":
+      return getColorCompletions();
+    default:
+      return [];
+  }
+}
+function getShapeCompletions() {
+  const kind = lst2.CompletionItemKind.EnumMember;
+  return shapes.map((s) => ({
+    kind,
+    label: escapeIdentifierText(s)
+  }));
+}
+function getColorCompletions() {
+  const kind = lst2.CompletionItemKind.Color;
+  const colors2 = colors;
+  return Object.keys(colors2).map((label) => ({
+    kind,
+    label,
+    // If the completion kind is "color", the documentation can hold the color code
+    // The color name is then displayed along with a preview of the color
+    documentation: colors2[label]
+  }));
+}
+function getAttributeCompletions(posistion) {
+  const kind = lst2.CompletionItemKind.Property;
+  const range = {
+    start: posistion,
+    end: posistion
+  };
+  return attributes.map((label) => ({
+    kind,
+    label,
+    textEdit: {
+      range,
+      newText: `${escapeIdentifierText(label)}=`
+    }
+  }));
+}
+function getNodeCompletions(symbols, exlucdedSymbols) {
+  const res = [];
+  for (const [key, value] of symbols) {
+    if (exlucdedSymbols?.includes(key)) continue;
+    let kind = lst2.CompletionItemKind.Variable;
+    const a = value.firstMention.parent;
+    if (a) {
+      switch (a.kind) {
+        case 41 /* DirectedGraph */:
+        case 42 /* UndirectedGraph */:
+          kind = lst2.CompletionItemKind.Class;
+          break;
+      }
+    }
+    res.push({
+      label: escapeIdentifierText(key),
+      kind
+    });
+  }
+  return res;
+}
+
+// src/service/hover.ts
+function hover(doc, sourceFile, position) {
+  const offset = doc.offsetAt(position);
+  const g = sourceFile.graph;
+  if (!g) return void 0;
+  const node = findNodeAtOffset(g, offset);
+  if (node === void 0) return void 0;
+  return getNodeHover(doc, sourceFile, node);
+}
+function getNodeHover(doc, sf, n) {
+  const contents = getHoverContents(n);
+  if (contents) {
+    return {
+      contents,
+      range: syntaxNodeToRange(doc, sf, n)
+    };
+  }
+  return void 0;
+}
+function getAssignedLabel(statement) {
+  const assignments = statement.attributes.flatMap((a) => a.assignments);
+  const assignedLabel = assignments?.find((a) => getIdentifierText(a.leftId) === "label");
+  return assignedLabel?.rightId ? getIdentifierText(assignedLabel.rightId) : void 0;
+}
+function getHoverContents(n) {
+  if (isIdentifierNode(n)) {
+    const parent = n.parent;
+    if (parent) {
+      switch (parent.kind) {
+        case 54 /* NodeId */: {
+          if (n.symbol?.references) {
+            const nodeIdentifierRefs = n.symbol?.references;
+            const labelMentions = nodeIdentifierRefs.map(
+              (e) => e.symbol?.members?.get("label")?.firstMention.parent
+            );
+            for (let i = labelMentions.length; i >= 0; i--) {
+              const s = labelMentions[i];
+              if (s?.rightId) {
+                return `(node) ${getIdentifierText(n)}: ${getIdentifierText(
+                  s.rightId
+                )}`;
+              }
+            }
+          } else if (parent.parent?.kind === 43 /* NodeStatement */) {
+            const label = getAssignedLabel(parent.parent);
+            if (label) {
+              return `(node) ${getIdentifierText(n)}: ${label}`;
+            }
+          }
+          return `(node) ${getIdentifierText(n)}`;
+        }
+        case 51 /* Assignment */: {
+          const assignment = parent;
+          const left = getIdentifierText(assignment.leftId);
+          const right = getIdentifierText(assignment.rightId);
+          return `(assignment) \`${left}\` = \`${right}\``;
+        }
+        case 41 /* DirectedGraph */:
+          return getGraphHover(parent);
+        case 42 /* UndirectedGraph */:
+          return getGraphHover(parent);
+        case 48 /* SubGraphStatement */: {
+          const sgs = parent;
+          const sg = sgs.subgraph;
+          return sg.id ? `(sub graph) ${getIdentifierText(sg.id)}` : "(sub graph)";
+        }
+        case 47 /* SubGraph */: {
+          const sg = parent;
+          return sg.id ? `(sub graph) ${getIdentifierText(sg.id)}` : "(sub graph)";
+        }
+        case 46 /* IdEqualsIdStatement */: {
+          const idEqId = parent;
+          const left = getIdentifierText(idEqId.leftId);
+          const right = getIdentifierText(idEqId.rightId);
+          return `(graph property) \`${left}\` = \`${right}\``;
+        }
+        case 49 /* EdgeRhs */:
+          return getEdgeHover(parent);
+      }
+      return SyntaxKind[parent.kind];
+    }
+    const fallback = SyntaxKind[n.kind];
+    return fallback ? `(${fallback.toLowerCase()})` : void 0;
+  }
+  switch (n.kind) {
+    case 33 /* GraphKeyword */:
+    case 34 /* DigraphKeyword */:
+    case 38 /* StrictKeyword */:
+      return getGraphHover(n.parent);
+    // TODO: Why does findNodeAtOffset() return a non-leaf node
+    // Did not expect to need to have this here.
+    case 41 /* DirectedGraph */:
+    case 42 /* UndirectedGraph */:
+      return getGraphHover(n);
+    case 39 /* DirectedEdgeOp */:
+    case 40 /* UndirectedEdgeOp */:
+      return getEdgeHover(n.parent);
+    default:
+      return void 0;
+  }
+}
+function getGraphHover(g) {
+  const direction = g.kind === 41 /* DirectedGraph */ ? "directed" : "undirected";
+  const graphId = g.id;
+  const strict = g.strict ? "strict " : "";
+  return graphId ? `(${strict}${direction} graph) ${getIdentifierText(graphId)}` : `(${strict}${direction} graph)`;
+}
+function getEdgeHover(n) {
+  const p = n.parent;
+  if (!p || p.rhs.length === 0) return void 0;
+  let source;
+  for (const curr of p.rhs) {
+    if (curr === n) break;
+    source = curr.target;
+  }
+  if (source === void 0) source = p.source;
+  const edgeOpStr = getEdgeStr(n.operation.kind);
+  return source === void 0 ? void 0 : `(edge) ${getEdgeSourceOrTargetText(source)} ${edgeOpStr} ${getEdgeSourceOrTargetText(
+    n.target
+  )}`;
+}
+function getEdgeSourceOrTargetText(n) {
+  return n.kind === 54 /* NodeId */ ? getIdentifierText(n.id) : n.id !== void 0 ? `${getIdentifierText(n.id)}` : "sub graph";
+}
+
+// src/service/reference.ts
+function findReferences(doc, sourceFile, position, context) {
+  if (!sourceFile.symbols) throw "sourceFile is not bound";
+  const g = sourceFile.graph;
+  if (!g) return [];
+  const offset = doc.offsetAt(position);
+  const node = findNodeAtOffset(g, offset);
+  if (!node) return [];
+  if (isIdentifierNode(node)) {
+    const nodeSymbol = node.symbol;
+    if (!nodeSymbol) throw "node.symbol is not bound";
+    const refs = nodeSymbol.references || [];
+    let symbolRefs;
+    if (context.includeDeclaration) {
+      symbolRefs = [nodeSymbol.firstMention, ...refs];
+    } else {
+      if (nodeSymbol.firstMention === node) {
+        symbolRefs = refs;
+      } else {
+        symbolRefs = [nodeSymbol.firstMention, ...refs.filter((r) => r !== node)];
+      }
+    }
+    const ranges = syntaxNodesToRanges(doc, sourceFile, symbolRefs);
+    const uri = doc.uri;
+    return ranges.map((range) => {
+      return { uri, range };
+    });
+  }
+  debugger;
+  return [];
+}
+function findDefinition(doc, sourceFile, position) {
+  if (!sourceFile.symbols) throw "sourceFile is not bound";
+  const g = sourceFile.graph;
+  if (!g) return void 0;
+  const offset = doc.offsetAt(position);
+  const node = findNodeAtOffset(g, offset);
+  if (!node) return void 0;
+  if (isIdentifierNode(node)) {
+    const nodeSymbol = node.symbol;
+    if (!nodeSymbol) throw "node.symbol is not bound";
+    const firstMention = nodeSymbol.firstMention;
+    if (!firstMention) return void 0;
+    const range = syntaxNodeToRange(doc, sourceFile, firstMention);
+    return { uri: doc.uri, range };
+  }
+  debugger;
+  return void 0;
+}
+
+// src/service/rename.ts
+import { TextEdit as TextEdit3 } from "vscode-languageserver-types";
+function renameSymbol(doc, sourceFile, position, newName) {
+  if (!sourceFile.symbols) throw "sourceFile is not bound";
+  if (!newName) return void 0;
+  const g = sourceFile.graph;
+  if (!g) return void 0;
+  const offset = doc.offsetAt(position);
+  const node = findNodeAtOffset(g, offset);
+  if (!node) return void 0;
+  const parent = node.parent;
+  if (isIdentifierNode(node) && isRenamableIdentifier(node) && !!parent && isRenameableNode(parent)) {
+    const nodeSymbol = node.symbol;
+    if (!nodeSymbol) throw "node.symbol is not bound";
+    const r = nodeSymbol.references;
+    const refs = r ? [nodeSymbol.firstMention, ...r] : [nodeSymbol.firstMention];
+    const ranges = syntaxNodesToRanges(doc, sourceFile, refs);
+    const uri = doc.uri;
+    const res = {
+      changes: {
+        [uri]: ranges.map((r2) => TextEdit3.replace(r2, newName))
+      }
+    };
+    return res;
+  }
+  debugger;
+  return void 0;
+}
+function isRenameableNode(node) {
+  return node.kind === 54 /* NodeId */ || node.kind === 41 /* DirectedGraph */ || node.kind === 42 /* UndirectedGraph */;
+}
+function isRenamableIdentifier(node) {
+  return node.kind !== 31 /* QuotedTextIdentifier */;
+}
+
+// src/error.ts
+var diagnosicSource = "DOT";
+var errorCodeLength = 4;
+var subErrorCodeLength = errorCodeLength - 1;
+function formatError(error) {
+  const subCode = (error.sub | 0).toString().padStart(subErrorCodeLength, "0");
+  return diagnosicSource + error.source + subCode;
+}
+
+// src/service/validation.ts
+function convertDiagnostic(document, source) {
+  return {
+    range: {
+      start: document.positionAt(source.start),
+      end: document.positionAt(source.end)
+    },
+    severity: source.category,
+    code: formatError(source.code),
+    source: diagnosicSource,
+    message: source.message
+  };
+}
+function validateDocument(doc, sourceFile) {
+  const diagnostics = sourceFile.diagnostics;
+  if (!diagnostics || diagnostics.length <= 0) return [];
+  return diagnostics.map((d) => convertDiagnostic(doc, d));
+}
+
+// src/service/service.ts
+function parseDocument(doc) {
+  const parser = new Parser();
+  const content = typeof doc === "string" ? doc : doc.getText();
+  const sourceFile = parser.parse(content);
+  bindSourceFile(sourceFile);
+  checkSourceFile(sourceFile);
+  return sourceFile;
+}
+function createService() {
+  return {
+    parseDocument,
+    validateDocument,
+    hover,
+    findReferences,
+    findDefinition,
+    renameSymbol,
+    getCompletions,
+    getDocumentColors,
+    getColorRepresentations,
+    getCodeActions,
+    executeCommand,
+    getAvailableCommands
+    // formatDocument,
+  };
+}
+export {
+  CharacterCodes,
+  CheckError,
+  DefaultScanner,
+  DiagnosticCategory,
+  ErrorSource,
+  GraphContext,
+  ParseError,
+  Parser,
+  ParsingContext,
+  ScanError,
+  SyntaxKind,
+  SyntaxNodeFlags,
+  TokenFlags,
+  createService,
+  forEachChild,
+  getTextAsToken,
+  getTokenAsText,
+  isIdentifier,
+  isIdentifierNode,
+  isIdentifierStart,
+  isLineBreak,
+  skipTrivia
+};