dot-language-support 3.0.1 → 4.0.0

package/dist/index.d.ts

@@ -2,37 +2,41 @@ import { TextDocument } from 'vscode-languageserver-textdocument';
 import * as lst from 'vscode-languageserver-types';
 import { ColorInformation, Color as Color$1, ColorPresentation } from 'vscode-languageserver-types';
 
-declare const enum ErrorSource {
-    Scan = 1,
-    Parse = 2,
-    Check = 4
-}
+declare const errorSource: {
+    readonly Scan: 1;
+    readonly Parse: 2;
+    readonly Check: 4;
+};
+type ErrorSource = (typeof errorSource)[keyof typeof errorSource];
 type ErrorCode = ParseErrorCode | ScanErrorCode | CheckErrorCode;
 interface ParseErrorCode {
-    source: ErrorSource.Parse;
+    source: typeof errorSource.Parse;
     sub: ParseError;
 }
 interface ScanErrorCode {
-    source: ErrorSource.Scan;
+    source: typeof errorSource.Scan;
     sub: ScanError;
 }
 interface CheckErrorCode {
-    source: ErrorSource.Check;
+    source: typeof errorSource.Check;
     sub: CheckError;
 }
-declare const enum ParseError {
-    ExpectationFailed = 0,
-    TrailingData = 1,
-    FailedListParsing = 2
-}
-declare const enum ScanError {
-    ExpectationFailed = 0,
-    Unterminated = 1
-}
-declare const enum CheckError {
-    InvalidEdgeOperation = 0,
-    InvalidShapeName = 1
-}
+declare const parseError: {
+    readonly ExpectationFailed: 0;
+    readonly TrailingData: 1;
+    readonly FailedListParsing: 2;
+};
+type ParseError = (typeof parseError)[keyof typeof parseError];
+declare const scanError: {
+    readonly ExpectationFailed: 0;
+    readonly Unterminated: 1;
+};
+type ScanError = (typeof scanError)[keyof typeof scanError];
+declare const checkError: {
+    readonly InvalidEdgeOperation: 0;
+    readonly InvalidShapeName: 1;
+};
+type CheckError = (typeof checkError)[keyof typeof checkError];
 interface DiagnosticMessage {
     message: string;
     code: ErrorCode;
@@ -40,12 +44,13 @@ interface DiagnosticMessage {
     start: number;
     end: number;
 }
-declare enum DiagnosticCategory {
-    Error = 1,
-    Warning = 2,
-    Message = 3,
-    Suggestion = 4
-}
+declare const diagnosticCategory: {
+    readonly Error: 1;
+    readonly Warning: 2;
+    readonly Message: 3;
+    readonly Suggestion: 4;
+};
+type DiagnosticCategory = (typeof diagnosticCategory)[keyof typeof diagnosticCategory];
 type ID = string;
 interface SourceFile {
     content: string;
@@ -56,174 +61,233 @@ interface SourceFile {
     colors?: ColorTable;
 }
 interface HtmlIdentifier extends SyntaxNode {
-    kind: SyntaxKind.HtmlIdentifier;
+    kind: typeof syntaxKind.HtmlIdentifier;
     htmlContent: string;
 }
 interface TextIdentifier extends SyntaxNode {
-    kind: SyntaxKind.TextIdentifier;
+    kind: typeof syntaxKind.TextIdentifier;
     text: string;
 }
 interface QuotedTextIdentifier extends SyntaxNode {
-    kind: SyntaxKind.QuotedTextIdentifier;
+    kind: typeof syntaxKind.QuotedTextIdentifier;
     values: SyntaxNodeArray<StringLiteral>;
     concatenation?: string;
 }
 interface StringLiteral extends SyntaxNode {
-    kind: SyntaxKind.StringLiteral;
+    kind: typeof syntaxKind.StringLiteral;
     text: string;
 }
 interface NumericIdentifier extends SyntaxNode {
-    kind: SyntaxKind.NumericIdentifier;
+    kind: typeof syntaxKind.NumericIdentifier;
     text: string;
     value: number;
 }
 type Identifier = TextIdentifier | QuotedTextIdentifier | HtmlIdentifier | NumericIdentifier;
 interface Graph extends SyntaxNode {
-    kind: SyntaxKind.DirectedGraph | SyntaxKind.UndirectedGraph;
-    keyword: Token<SyntaxKind.GraphKeyword | SyntaxKind.DigraphKeyword>;
-    strict?: Token<SyntaxKind.StrictKeyword>;
+    kind: typeof syntaxKind.DirectedGraph | typeof syntaxKind.UndirectedGraph;
+    keyword: Token<typeof syntaxKind.GraphKeyword | typeof syntaxKind.DigraphKeyword>;
+    strict?: Token<typeof syntaxKind.StrictKeyword>;
     id?: Identifier;
     statements: SyntaxNodeArray<Statement>;
 }
 interface StatementBase {
     terminator?: StatementSeparator;
 }
-type StatementSeparator = Token<SyntaxKind.SemicolonToken>;
+type StatementSeparator = Token<typeof syntaxKind.SemicolonToken>;
 type Statement = NodeStatement | EdgeStatement | AttributeStatement | IdEqualsIdStatement | SubGraphStatement;
 interface NodeStatement extends SyntaxNode, StatementBase {
-    kind: SyntaxKind.NodeStatement;
+    kind: typeof syntaxKind.NodeStatement;
     id: NodeId;
     attributes: SyntaxNodeArray<AttributeContainer>;
 }
 interface NodeId extends SyntaxNode {
-    kind: SyntaxKind.NodeId;
+    kind: typeof syntaxKind.NodeId;
     id: Identifier;
     port?: PortDeclaration;
 }
 type EdgeSourceOrTarget = NodeId | SubGraph;
 interface EdgeStatement extends SyntaxNode, StatementBase {
-    kind: SyntaxKind.EdgeStatement;
+    kind: typeof syntaxKind.EdgeStatement;
     source: EdgeSourceOrTarget;
     rhs: SyntaxNodeArray<EdgeRhs>;
     attributes: SyntaxNodeArray<AttributeContainer>;
 }
 interface AttributeStatement extends SyntaxNode, StatementBase {
-    kind: SyntaxKind.AttributeStatement;
-    subject: Token<SyntaxKind.GraphKeyword> | Token<SyntaxKind.NodeKeyword> | Token<SyntaxKind.EdgeKeyword>;
+    kind: typeof syntaxKind.AttributeStatement;
+    subject: Token<typeof syntaxKind.GraphKeyword> | Token<typeof syntaxKind.NodeKeyword> | Token<typeof syntaxKind.EdgeKeyword>;
     attributes: SyntaxNodeArray<AttributeContainer>;
 }
 interface IdEqualsIdStatement extends SyntaxNode, StatementBase {
-    kind: SyntaxKind.IdEqualsIdStatement;
+    kind: typeof syntaxKind.IdEqualsIdStatement;
     leftId: Identifier;
     rightId: Identifier;
 }
 interface SubGraph extends SyntaxNode {
-    kind: SyntaxKind.SubGraph;
+    kind: typeof syntaxKind.SubGraph;
     id?: Identifier;
     statements: SyntaxNodeArray<Statement>;
 }
 interface SubGraphStatement extends SyntaxNode, StatementBase {
-    kind: SyntaxKind.SubGraphStatement;
+    kind: typeof syntaxKind.SubGraphStatement;
     subgraph: SubGraph;
 }
 interface EdgeRhs extends SyntaxNode {
-    kind: SyntaxKind.EdgeRhs;
+    kind: typeof syntaxKind.EdgeRhs;
     operation: EdgeOp;
     target: EdgeSourceOrTarget;
 }
 interface AttributeContainer extends SyntaxNode {
-    kind: SyntaxKind.AttributeContainer;
-    openBracket: Token<SyntaxKind.OpenBracketToken>;
+    kind: typeof syntaxKind.AttributeContainer;
+    openBracket: Token<typeof syntaxKind.OpenBracketToken>;
     assignments: SyntaxNodeArray<Assignment>;
-    closeBracket: Token<SyntaxKind.CloseBracketToken>;
+    closeBracket: Token<typeof syntaxKind.CloseBracketToken>;
 }
 interface Assignment extends SyntaxNode {
-    kind: SyntaxKind.Assignment;
+    kind: typeof syntaxKind.Assignment;
     leftId: Identifier;
     rightId: Identifier;
     terminator?: AssignmentSeparator;
 }
-type AssignmentSeparator = Token<SyntaxKind.SemicolonToken> | Token<SyntaxKind.CommaToken>;
+type AssignmentSeparator = Token<typeof syntaxKind.SemicolonToken> | Token<typeof syntaxKind.CommaToken>;
 type PortDeclaration = NormalPortDeclaration | CompassPortDeclaration;
 interface NormalPortDeclaration extends SyntaxNode {
-    kind: SyntaxKind.NormalPortDeclaration;
-    colon: Token<SyntaxKind.ColonToken>;
+    kind: typeof syntaxKind.NormalPortDeclaration;
+    colon: Token<typeof syntaxKind.ColonToken>;
     id: Identifier;
     compassPt?: CompassPortDeclaration;
 }
 interface CompassPortDeclaration extends SyntaxNode {
-    kind: SyntaxKind.CompassPortDeclaration;
-    colon: Token<SyntaxKind.ColonToken>;
+    kind: typeof syntaxKind.CompassPortDeclaration;
+    colon: Token<typeof syntaxKind.ColonToken>;
     compassPt: CompassPort;
 }
-type CompassPort = Token<SyntaxKind.CompassNorthToken> | Token<SyntaxKind.CompassNorthEastToken> | Token<SyntaxKind.CompassEastToken> | Token<SyntaxKind.CompassSouthEastToken> | Token<SyntaxKind.CompassSouthToken> | Token<SyntaxKind.CompassSouthWestToken> | Token<SyntaxKind.CompassWestToken> | Token<SyntaxKind.CompassNorthWestToken> | Token<SyntaxKind.CompassCenterToken> | Token<SyntaxKind.UnderscoreToken>;
-type EdgeOp = Token<SyntaxKind.DirectedEdgeOp> | Token<SyntaxKind.UndirectedEdgeOp>;
+type CompassPort = Token<typeof syntaxKind.CompassNorthToken> | Token<typeof syntaxKind.CompassNorthEastToken> | Token<typeof syntaxKind.CompassEastToken> | Token<typeof syntaxKind.CompassSouthEastToken> | Token<typeof syntaxKind.CompassSouthToken> | Token<typeof syntaxKind.CompassSouthWestToken> | Token<typeof syntaxKind.CompassWestToken> | Token<typeof syntaxKind.CompassNorthWestToken> | Token<typeof syntaxKind.CompassCenterToken> | Token<typeof syntaxKind.UnderscoreToken>;
+type EdgeOp = Token<typeof syntaxKind.DirectedEdgeOp> | Token<typeof syntaxKind.UndirectedEdgeOp>;
 interface TextRange {
     pos: number;
     end: number;
 }
-declare enum SyntaxKind {
-    Unknown = 0,
-    EndOfFileToken = 1,
-    NewLineTrivia = 2,
-    WhitespaceTrivia = 3,
-    HashCommentTrivia = 4,
-    SingleLineCommentTrivia = 5,
-    MultiLineCommentTrivia = 6,
-    CommaToken = 7,
-    SemicolonToken = 8,
-    PlusToken = 9,
-    OpenBraceToken = 10,
-    CloseBraceToken = 11,
-    OpenBracketToken = 12,
-    CloseBracketToken = 13,
-    ColonToken = 14,
-    EqualsToken = 15,
-    LessThan = 16,
-    GreaterThan = 17,
-    CompassNorthToken = 18,
-    CompassNorthEastToken = 19,
-    CompassEastToken = 20,
-    CompassSouthEastToken = 21,
-    CompassSouthToken = 22,
-    CompassSouthWestToken = 23,
-    CompassWestToken = 24,
-    CompassNorthWestToken = 25,
-    CompassCenterToken = 26,
-    UnderscoreToken = 27,
-    StringLiteral = 28,
-    HtmlIdentifier = 29,
-    TextIdentifier = 30,
-    QuotedTextIdentifier = 31,
-    NumericIdentifier = 32,
-    GraphKeyword = 33,
-    DigraphKeyword = 34,
-    NodeKeyword = 35,
-    EdgeKeyword = 36,
-    SubgraphKeyword = 37,
-    StrictKeyword = 38,
-    DirectedEdgeOp = 39,
-    UndirectedEdgeOp = 40,
-    DirectedGraph = 41,
-    UndirectedGraph = 42,
-    NodeStatement = 43,
-    EdgeStatement = 44,
-    AttributeStatement = 45,
-    IdEqualsIdStatement = 46,
-    SubGraph = 47,
-    SubGraphStatement = 48,
-    EdgeRhs = 49,
-    AttributeContainer = 50,
-    Assignment = 51,
-    NormalPortDeclaration = 52,
-    CompassPortDeclaration = 53,
-    NodeId = 54,
-    Count = 55,
-    FirstNode = 41,
-    CompassBegin = 18,
-    CompassEnd = 27,
-    LastKeyword = 38
-}
+type SyntaxKind = (typeof syntaxKind)[keyof typeof syntaxKind];
+declare const syntaxKind: {
+    readonly Unknown: 0;
+    readonly EndOfFileToken: 1;
+    readonly NewLineTrivia: 2;
+    readonly WhitespaceTrivia: 3;
+    readonly HashCommentTrivia: 4;
+    readonly SingleLineCommentTrivia: 5;
+    readonly MultiLineCommentTrivia: 6;
+    readonly CommaToken: 7;
+    readonly SemicolonToken: 8;
+    readonly PlusToken: 9;
+    readonly OpenBraceToken: 10;
+    readonly CloseBraceToken: 11;
+    readonly OpenBracketToken: 12;
+    readonly CloseBracketToken: 13;
+    readonly ColonToken: 14;
+    readonly EqualsToken: 15;
+    readonly LessThan: 16;
+    readonly GreaterThan: 17;
+    readonly CompassNorthToken: 18;
+    readonly CompassNorthEastToken: 19;
+    readonly CompassEastToken: 20;
+    readonly CompassSouthEastToken: 21;
+    readonly CompassSouthToken: 22;
+    readonly CompassSouthWestToken: 23;
+    readonly CompassWestToken: 24;
+    readonly CompassNorthWestToken: 25;
+    readonly CompassCenterToken: 26;
+    readonly UnderscoreToken: 27;
+    readonly StringLiteral: 28;
+    readonly HtmlIdentifier: 29;
+    readonly TextIdentifier: 30;
+    readonly QuotedTextIdentifier: 31;
+    readonly NumericIdentifier: 32;
+    readonly GraphKeyword: 33;
+    readonly DigraphKeyword: 34;
+    readonly NodeKeyword: 35;
+    readonly EdgeKeyword: 36;
+    readonly SubgraphKeyword: 37;
+    readonly StrictKeyword: 38;
+    readonly DirectedEdgeOp: 39;
+    readonly UndirectedEdgeOp: 40;
+    readonly DirectedGraph: 41;
+    readonly UndirectedGraph: 42;
+    readonly NodeStatement: 43;
+    readonly EdgeStatement: 44;
+    readonly AttributeStatement: 45;
+    readonly IdEqualsIdStatement: 46;
+    readonly SubGraph: 47;
+    readonly SubGraphStatement: 48;
+    readonly EdgeRhs: 49;
+    readonly AttributeContainer: 50;
+    readonly Assignment: 51;
+    readonly NormalPortDeclaration: 52;
+    readonly CompassPortDeclaration: 53;
+    readonly NodeId: 54;
+    readonly Count: 55;
+    readonly FirstNode: 41;
+    readonly CompassBegin: 18;
+    readonly CompassEnd: 27;
+    readonly LastKeyword: 38;
+};
+declare const syntaxKindNames: {
+    readonly 0: "Unknown";
+    readonly 1: "EndOfFileToken";
+    readonly 2: "NewLineTrivia";
+    readonly 3: "WhitespaceTrivia";
+    readonly 4: "HashCommentTrivia";
+    readonly 5: "SingleLineCommentTrivia";
+    readonly 6: "MultiLineCommentTrivia";
+    readonly 7: "CommaToken";
+    readonly 8: "SemicolonToken";
+    readonly 9: "PlusToken";
+    readonly 10: "OpenBraceToken";
+    readonly 11: "CloseBraceToken";
+    readonly 12: "OpenBracketToken";
+    readonly 13: "CloseBracketToken";
+    readonly 14: "ColonToken";
+    readonly 15: "EqualsToken";
+    readonly 16: "LessThan";
+    readonly 17: "GreaterThan";
+    readonly 18: "CompassNorthToken";
+    readonly 19: "CompassNorthEastToken";
+    readonly 20: "CompassEastToken";
+    readonly 21: "CompassSouthEastToken";
+    readonly 22: "CompassSouthToken";
+    readonly 23: "CompassSouthWestToken";
+    readonly 24: "CompassWestToken";
+    readonly 25: "CompassNorthWestToken";
+    readonly 26: "CompassCenterToken";
+    readonly 27: "UnderscoreToken";
+    readonly 28: "StringLiteral";
+    readonly 29: "HtmlIdentifier";
+    readonly 30: "TextIdentifier";
+    readonly 31: "QuotedTextIdentifier";
+    readonly 32: "NumericIdentifier";
+    readonly 33: "GraphKeyword";
+    readonly 34: "DigraphKeyword";
+    readonly 35: "NodeKeyword";
+    readonly 36: "EdgeKeyword";
+    readonly 37: "SubgraphKeyword";
+    readonly 38: "StrictKeyword";
+    readonly 39: "DirectedEdgeOp";
+    readonly 40: "UndirectedEdgeOp";
+    readonly 41: "DirectedGraph";
+    readonly 42: "UndirectedGraph";
+    readonly 43: "NodeStatement";
+    readonly 44: "EdgeStatement";
+    readonly 45: "AttributeStatement";
+    readonly 46: "IdEqualsIdStatement";
+    readonly 47: "SubGraph";
+    readonly 48: "SubGraphStatement";
+    readonly 49: "EdgeRhs";
+    readonly 50: "AttributeContainer";
+    readonly 51: "Assignment";
+    readonly 52: "NormalPortDeclaration";
+    readonly 53: "CompassPortDeclaration";
+    readonly 54: "NodeId";
+    readonly 55: "Count";
+};
 interface SyntaxNode extends TextRange {
     kind: SyntaxKind;
     flags: SyntaxNodeFlags;
@@ -238,148 +302,152 @@ interface SyntaxNodeArray<T extends SyntaxNode> extends ReadonlyArray<T>, TextRa
     hasTrailingComma?: boolean;
 }
 type MutableSyntaxNodeArray<T extends SyntaxNode> = SyntaxNodeArray<T> & T[];
-declare const enum SyntaxNodeFlags {
-    None = 0,
-    ContainsErrors = 2,
-    Synthesized = 4
-}
-declare const enum GraphContext {
-    None = 0,
-    Strict = 2,
-    Directed = 4,
-    Undirected = 8
-}
-declare const enum TokenFlags {
-    None = 0,
-    Unterminated = 2,
-    PrecedingLineBreak = 4
-}
-declare const enum CharacterCodes {
-    nullCharacter = 0,
-    maxAsciiCharacter = 127,
-    lineFeed = 10,
-    carriageReturn = 13,
-    lineSeparator = 8232,
-    paragraphSeparator = 8233,
-    nextLine = 133,
-    space = 32,
-    nonBreakingSpace = 160,
-    enQuad = 8192,
-    emQuad = 8193,
-    enSpace = 8194,
-    emSpace = 8195,
-    threePerEmSpace = 8196,
-    fourPerEmSpace = 8197,
-    sixPerEmSpace = 8198,
-    figureSpace = 8199,
-    punctuationSpace = 8200,
-    thinSpace = 8201,
-    hairSpace = 8202,
-    zeroWidthSpace = 8203,
-    narrowNoBreakSpace = 8239,
-    ideographicSpace = 12288,
-    mathematicalSpace = 8287,
-    ogham = 5760,
-    _ = 95,
-    $ = 36,
-    _0 = 48,
-    _1 = 49,
-    _2 = 50,
-    _3 = 51,
-    _4 = 52,
-    _5 = 53,
-    _6 = 54,
-    _7 = 55,
-    _8 = 56,
-    _9 = 57,
-    a = 97,
-    b = 98,
-    c = 99,
-    d = 100,
-    e = 101,
-    f = 102,
-    g = 103,
-    h = 104,
-    i = 105,
-    j = 106,
-    k = 107,
-    l = 108,
-    m = 109,
-    n = 110,
-    o = 111,
-    p = 112,
-    q = 113,
-    r = 114,
-    s = 115,
-    t = 116,
-    u = 117,
-    v = 118,
-    w = 119,
-    x = 120,
-    y = 121,
-    z = 122,
-    A = 65,
-    B = 66,
-    C = 67,
-    D = 68,
-    E = 69,
-    F = 70,
-    G = 71,
-    H = 72,
-    I = 73,
-    J = 74,
-    K = 75,
-    L = 76,
-    M = 77,
-    N = 78,
-    O = 79,
-    P = 80,
-    Q = 81,
-    R = 82,
-    S = 83,
-    T = 84,
-    U = 85,
-    V = 86,
-    W = 87,
-    X = 88,
-    Y = 89,
-    Z = 90,
-    ampersand = 38,
-    asterisk = 42,
-    at = 64,
-    backslash = 92,
-    backtick = 96,
-    bar = 124,
-    caret = 94,
-    closeBrace = 125,
-    closeBracket = 93,
-    closeParen = 41,
-    colon = 58,
-    comma = 44,
-    dot = 46,
-    doubleQuote = 34,
-    equals = 61,
-    exclamation = 33,
-    greaterThan = 62,
-    hash = 35,
-    lessThan = 60,
-    minus = 45,
-    openBrace = 123,
-    openBracket = 91,
-    openParen = 40,
-    percent = 37,
-    plus = 43,
-    question = 63,
-    semicolon = 59,
-    singleQuote = 39,
-    slash = 47,
-    tilde = 126,
-    backspace = 8,
-    formFeed = 12,
-    byteOrderMark = 65279,
-    tab = 9,
-    verticalTab = 11
-}
+declare const syntaxNodeFlags: {
+    readonly None: 0;
+    readonly ContainsErrors: number;
+    readonly Synthesized: number;
+};
+type SyntaxNodeFlags = (typeof syntaxNodeFlags)[keyof typeof syntaxNodeFlags];
+declare const graphContext: {
+    readonly None: 0;
+    readonly Strict: number;
+    readonly Directed: number;
+    readonly Undirected: number;
+};
+type GraphContext = (typeof graphContext)[keyof typeof graphContext];
+declare const tokenFlags: {
+    readonly None: 0;
+    readonly Unterminated: number;
+    readonly PrecedingLineBreak: number;
+};
+type TokenFlags = (typeof tokenFlags)[keyof typeof tokenFlags];
+type CharacterCodes = (typeof characterCodes)[keyof typeof characterCodes];
+declare const characterCodes: {
+    readonly nullCharacter: 0;
+    readonly maxAsciiCharacter: 127;
+    readonly lineFeed: 10;
+    readonly carriageReturn: 13;
+    readonly lineSeparator: 8232;
+    readonly paragraphSeparator: 8233;
+    readonly nextLine: 133;
+    readonly space: 32;
+    readonly nonBreakingSpace: 160;
+    readonly enQuad: 8192;
+    readonly emQuad: 8193;
+    readonly enSpace: 8194;
+    readonly emSpace: 8195;
+    readonly threePerEmSpace: 8196;
+    readonly fourPerEmSpace: 8197;
+    readonly sixPerEmSpace: 8198;
+    readonly figureSpace: 8199;
+    readonly punctuationSpace: 8200;
+    readonly thinSpace: 8201;
+    readonly hairSpace: 8202;
+    readonly zeroWidthSpace: 8203;
+    readonly narrowNoBreakSpace: 8239;
+    readonly ideographicSpace: 12288;
+    readonly mathematicalSpace: 8287;
+    readonly ogham: 5760;
+    readonly _: 95;
+    readonly $: 36;
+    readonly _0: 48;
+    readonly _1: 49;
+    readonly _2: 50;
+    readonly _3: 51;
+    readonly _4: 52;
+    readonly _5: 53;
+    readonly _6: 54;
+    readonly _7: 55;
+    readonly _8: 56;
+    readonly _9: 57;
+    readonly a: 97;
+    readonly b: 98;
+    readonly c: 99;
+    readonly d: 100;
+    readonly e: 101;
+    readonly f: 102;
+    readonly g: 103;
+    readonly h: 104;
+    readonly i: 105;
+    readonly j: 106;
+    readonly k: 107;
+    readonly l: 108;
+    readonly m: 109;
+    readonly n: 110;
+    readonly o: 111;
+    readonly p: 112;
+    readonly q: 113;
+    readonly r: 114;
+    readonly s: 115;
+    readonly t: 116;
+    readonly u: 117;
+    readonly v: 118;
+    readonly w: 119;
+    readonly x: 120;
+    readonly y: 121;
+    readonly z: 122;
+    readonly A: 65;
+    readonly B: 66;
+    readonly C: 67;
+    readonly D: 68;
+    readonly E: 69;
+    readonly F: 70;
+    readonly G: 71;
+    readonly H: 72;
+    readonly I: 73;
+    readonly J: 74;
+    readonly K: 75;
+    readonly L: 76;
+    readonly M: 77;
+    readonly N: 78;
+    readonly O: 79;
+    readonly P: 80;
+    readonly Q: 81;
+    readonly R: 82;
+    readonly S: 83;
+    readonly T: 84;
+    readonly U: 85;
+    readonly V: 86;
+    readonly W: 87;
+    readonly X: 88;
+    readonly Y: 89;
+    readonly Z: 90;
+    readonly ampersand: 38;
+    readonly asterisk: 42;
+    readonly at: 64;
+    readonly backslash: 92;
+    readonly backtick: 96;
+    readonly bar: 124;
+    readonly caret: 94;
+    readonly closeBrace: 125;
+    readonly closeBracket: 93;
+    readonly closeParen: 41;
+    readonly colon: 58;
+    readonly comma: 44;
+    readonly dot: 46;
+    readonly doubleQuote: 34;
+    readonly equals: 61;
+    readonly exclamation: 33;
+    readonly greaterThan: 62;
+    readonly hash: 35;
+    readonly lessThan: 60;
+    readonly minus: 45;
+    readonly openBrace: 123;
+    readonly openBracket: 91;
+    readonly openParen: 40;
+    readonly percent: 37;
+    readonly plus: 43;
+    readonly question: 63;
+    readonly semicolon: 59;
+    readonly singleQuote: 39;
+    readonly slash: 47;
+    readonly tilde: 126;
+    readonly backspace: 8;
+    readonly formFeed: 12;
+    readonly byteOrderMark: 65279;
+    readonly tab: 9;
+    readonly verticalTab: 11;
+};
 type SymbolTable = Map<string, TypeSymbol>;
 type ColorTable = Map<string, ColorInfo>;
 interface TypeSymbol {
@@ -398,7 +466,7 @@ interface Color {
     readonly alpha: number;
 }
 type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-type StatementOf<T extends Statement["kind"]> = T extends SyntaxKind.SubGraphStatement ? SubGraphStatement : T extends SyntaxKind.AttributeStatement ? AttributeStatement : T extends SyntaxKind.EdgeStatement ? EdgeStatement : T extends SyntaxKind.IdEqualsIdStatement ? IdEqualsIdStatement : T extends SyntaxKind.NodeStatement ? NodeStatement : never;
+type StatementOf<T extends Statement["kind"]> = T extends typeof syntaxKind.SubGraphStatement ? SubGraphStatement : T extends typeof syntaxKind.AttributeStatement ? AttributeStatement : T extends typeof syntaxKind.EdgeStatement ? EdgeStatement : T extends typeof syntaxKind.IdEqualsIdStatement ? IdEqualsIdStatement : T extends typeof syntaxKind.NodeStatement ? NodeStatement : never;
 
 interface Scanner {
     readonly end: number;
@@ -441,15 +509,16 @@ declare function isIdentifierStart(ch: number): boolean;
 declare function skipTrivia(text: string, pos: number): number;
 declare function isLineBreak(ch: number): boolean;
 
-declare enum ParsingContext {
-    None = 0,
-    StatementList = 1,
-    AttributeContainerList = 2,
-    AssignmentList = 3,
-    EdgeRhsList = 4,
-    QuotedTextIdentifierConcatenation = 5,
-    Count = 6
-}
+type ParsingContext = (typeof parsingContext)[keyof typeof parsingContext];
+declare const parsingContext: {
+    readonly None: 0;
+    readonly StatementList: 1;
+    readonly AttributeContainerList: 2;
+    readonly AssignmentList: 3;
+    readonly EdgeRhsList: 4;
+    readonly QuotedTextIdentifierConcatenation: 5;
+    readonly Count: 6;
+};
 declare class Parser {
     #private;
     currentToken: SyntaxKind;
@@ -464,7 +533,7 @@ declare class Parser {
     constructor();
     parse(sourceText: string): SourceFile;
 }
-declare function isIdentifier(kind: SyntaxKind): kind is SyntaxKind.HtmlIdentifier | SyntaxKind.TextIdentifier | SyntaxKind.QuotedTextIdentifier | SyntaxKind.NumericIdentifier;
+declare function isIdentifier(kind: SyntaxKind): kind is 29 | 30 | 31 | 32;
 declare function isIdentifierNode(node: SyntaxNode): node is Identifier;
 
 interface DocumentLike {
@@ -494,4 +563,4 @@ declare function createService(): LanguageService;
 
 declare function forEachChild<TReturn>(node: SyntaxNode, cbNode: (node: SyntaxNode) => TReturn, cbNodes?: (nodes: SyntaxNodeArray<SyntaxNode>) => TReturn): TReturn | undefined;
 
-export { type Assignment, type AssignmentSeparator, type AttributeContainer, type AttributeStatement, CharacterCodes, CheckError, type CheckErrorCode, type Color, type ColorInfo, type ColorTable, type CommandApplication, type CompassPort, type CompassPortDeclaration, DefaultScanner, DiagnosticCategory, type DiagnosticMessage, type DocumentLike, type EdgeOp, type EdgeRhs, type EdgeSourceOrTarget, type EdgeStatement, type ErrorCallback, type ErrorCode, ErrorSource, type Graph, GraphContext, type HtmlIdentifier, type ID, type IdEqualsIdStatement, type Identifier, type LanguageService, type MutableSyntaxNodeArray, type NodeId, type NodeStatement, type NormalPortDeclaration, type NumericIdentifier, type Omit, ParseError, type ParseErrorCode, Parser, ParsingContext, type PortDeclaration, type QuotedTextIdentifier, ScanError, type ScanErrorCode, type Scanner, type SourceFile, type Statement, type StatementBase, type StatementOf, type StatementSeparator, type StringLiteral, type SubGraph, type SubGraphStatement, type SymbolTable, SyntaxKind, type SyntaxNode, type SyntaxNodeArray, SyntaxNodeFlags, type TextIdentifier, type TextRange, type Token, TokenFlags, type TypeSymbol, createService, forEachChild, getTextAsToken, getTokenAsText, isIdentifier, isIdentifierNode, isIdentifierStart, isLineBreak, skipTrivia };
+export { type Assignment, type AssignmentSeparator, type AttributeContainer, type AttributeStatement, type CharacterCodes, type CheckError, type CheckErrorCode, type Color, type ColorInfo, type ColorTable, type CommandApplication, type CompassPort, type CompassPortDeclaration, DefaultScanner, type DiagnosticCategory, type DiagnosticMessage, type DocumentLike, type EdgeOp, type EdgeRhs, type EdgeSourceOrTarget, type EdgeStatement, type ErrorCallback, type ErrorCode, type ErrorSource, type Graph, type GraphContext, type HtmlIdentifier, type ID, type IdEqualsIdStatement, type Identifier, type LanguageService, type MutableSyntaxNodeArray, type NodeId, type NodeStatement, type NormalPortDeclaration, type NumericIdentifier, type Omit, type ParseError, type ParseErrorCode, Parser, type ParsingContext, type PortDeclaration, type QuotedTextIdentifier, type ScanError, type ScanErrorCode, type Scanner, type SourceFile, type Statement, type StatementBase, type StatementOf, type StatementSeparator, type StringLiteral, type SubGraph, type SubGraphStatement, type SymbolTable, type SyntaxKind, type SyntaxNode, type SyntaxNodeArray, type SyntaxNodeFlags, type TextIdentifier, type TextRange, type Token, type TokenFlags, type TypeSymbol, characterCodes, checkError, createService, diagnosticCategory, errorSource, forEachChild, getTextAsToken, getTokenAsText, graphContext, isIdentifier, isIdentifierNode, isIdentifierStart, isLineBreak, parseError, parsingContext, scanError, skipTrivia, syntaxKind, syntaxKindNames, syntaxNodeFlags, tokenFlags };