dot-language-support 1.6.2 → 2.0.2

package/lib/{service → cjs/service}/reference.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findDefinition = exports.findReferences = void 0;
-const __1 = require("../");
-const checker_1 = require("../checker");
-const util_1 = require("./util");
+const index_js_1 = require("../index.js");
+const checker_js_1 = require("../checker.js");
+const util_js_1 = require("./util.js");
 function findReferences(doc, sourceFile, position, context) {
     if (!sourceFile.symbols)
         throw "sourceFile is not bound";
@@ -11,10 +11,10 @@ function findReferences(doc, sourceFile, position, context) {
     if (!g)
         return [];
     const offset = doc.offsetAt(position);
-    const node = (0, checker_1.findNodeAtOffset)(g, offset);
+    const node = (0, checker_js_1.findNodeAtOffset)(g, offset);
     if (!node)
         return [];
-    if ((0, __1.isIdentifierNode)(node)) {
+    if ((0, index_js_1.isIdentifierNode)(node)) {
         const nodeSymbol = node.symbol;
         if (!nodeSymbol)
             throw "node.symbol is not bound";
@@ -34,7 +34,7 @@ function findReferences(doc, sourceFile, position, context) {
                 ];
             }
         }
-        const ranges = (0, util_1.syntaxNodesToRanges)(doc, sourceFile, symbolRefs);
+        const ranges = (0, util_js_1.syntaxNodesToRanges)(doc, sourceFile, symbolRefs);
         const uri = doc.uri;
         return ranges.map(range => {
             return { uri, range };
@@ -51,19 +51,17 @@ function findDefinition(doc, sourceFile, position) {
     if (!g)
         return undefined;
     const offset = doc.offsetAt(position);
-    const node = (0, checker_1.findNodeAtOffset)(g, offset);
+    const node = (0, checker_js_1.findNodeAtOffset)(g, offset);
     if (!node)
         return undefined;
-    if ((0, __1.isIdentifierNode)(node)) {
+    if ((0, index_js_1.isIdentifierNode)(node)) {
         const nodeSymbol = node.symbol;
         if (!nodeSymbol)
             throw "node.symbol is not bound";
-        const refs = nodeSymbol.references || [];
-        let symbolRefs;
         const firstMention = nodeSymbol.firstMention;
         if (!firstMention)
             return undefined;
-        const range = (0, util_1.syntaxNodeToRange)(doc, sourceFile, firstMention);
+        const range = (0, util_js_1.syntaxNodeToRange)(doc, sourceFile, firstMention);
         return { uri: doc.uri, range };
     }
     debugger;

package/lib/{service → cjs/service}/rename.d.ts

@@ -1,4 +1,4 @@
 import { Position, WorkspaceEdit } from "vscode-languageserver-types";
-import { SourceFile } from "../types";
-import { DocumentLike } from "../";
+import { SourceFile } from "../types.js";
+import { DocumentLike } from "../index.js";
 export declare function renameSymbol(doc: DocumentLike, sourceFile: SourceFile, position: Position, newName: string): WorkspaceEdit | undefined;

package/lib/{service → cjs/service}/rename.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renameSymbol = void 0;
 const vscode_languageserver_types_1 = require("vscode-languageserver-types");
-const types_1 = require("../types");
-const checker_1 = require("../checker");
-const __1 = require("../");
-const util_1 = require("./util");
+const types_js_1 = require("../types.js");
+const checker_js_1 = require("../checker.js");
+const index_js_1 = require("../index.js");
+const util_js_1 = require("./util.js");
 function renameSymbol(doc, sourceFile, position, newName) {
     if (!sourceFile.symbols)
         throw "sourceFile is not bound";
@@ -15,17 +15,17 @@ function renameSymbol(doc, sourceFile, position, newName) {
     if (!g)
         return undefined;
     const offset = doc.offsetAt(position);
-    const node = (0, checker_1.findNodeAtOffset)(g, offset);
+    const node = (0, checker_js_1.findNodeAtOffset)(g, offset);
     if (!node)
         return undefined;
     const parent = node.parent;
-    if ((0, __1.isIdentifierNode)(node) && isRenamableIdentifier(node) && !!parent && isRenameableNode(parent)) {
+    if ((0, index_js_1.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 = (0, util_1.syntaxNodesToRanges)(doc, sourceFile, refs);
+        const ranges = (0, util_js_1.syntaxNodesToRanges)(doc, sourceFile, refs);
         const uri = doc.uri;
         const res = {
             changes: {
@@ -39,11 +39,11 @@ function renameSymbol(doc, sourceFile, position, newName) {
 }
 exports.renameSymbol = renameSymbol;
 function isRenameableNode(node) {
-    return node.kind === types_1.SyntaxKind.NodeId
-        || node.kind === types_1.SyntaxKind.DirectedGraph
-        || node.kind === types_1.SyntaxKind.UndirectedGraph;
+    return node.kind === types_js_1.SyntaxKind.NodeId
+        || node.kind === types_js_1.SyntaxKind.DirectedGraph
+        || node.kind === types_js_1.SyntaxKind.UndirectedGraph;
 }
 function isRenamableIdentifier(node) {
-    return node.kind !== types_1.SyntaxKind.QuotedTextIdentifier;
+    return node.kind !== types_js_1.SyntaxKind.QuotedTextIdentifier;
 }
 //# sourceMappingURL=rename.js.map

package/lib/{service → cjs/service}/service.d.ts

@@ -1,7 +1,7 @@
 import type * as lst from "vscode-languageserver-types";
+import type { ColorInformation, Color, ColorPresentation } from "vscode-languageserver-types";
 import type { TextDocument } from "vscode-languageserver-textdocument";
-import { ColorInformation, Color, ColorPresentation } from "./polyfill";
-import { SourceFile, Omit } from "../types";
+import { SourceFile, Omit } from "../types.js";
 export interface DocumentLike {
     positionAt(offset: number): lst.Position;
     offsetAt(position: lst.Position): number;

package/lib/cjs/service/service.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createService = void 0;
+const index_js_1 = require("../index.js");
+const binder_js_1 = require("../binder.js");
+const hover_js_1 = require("./hover.js");
+const validation_js_1 = require("./validation.js");
+const reference_js_1 = require("./reference.js");
+const rename_js_1 = require("./rename.js");
+const completion_js_1 = require("./completion.js");
+const checker_js_1 = require("../checker.js");
+const codeAction_js_1 = require("./codeAction.js");
+const colorProvider_js_1 = require("./colorProvider.js");
+function parseDocument(doc) {
+    const parser = new index_js_1.Parser();
+    const content = typeof doc === "string" ? doc : doc.getText();
+    const sourceFile = parser.parse(content);
+    (0, binder_js_1.bindSourceFile)(sourceFile);
+    (0, checker_js_1.checkSourceFile)(sourceFile);
+    return sourceFile;
+}
+function createService() {
+    return {
+        parseDocument,
+        validateDocument: validation_js_1.validateDocument,
+        hover: hover_js_1.hover,
+        findReferences: reference_js_1.findReferences,
+        findDefinition: reference_js_1.findDefinition,
+        renameSymbol: rename_js_1.renameSymbol,
+        getCompletions: completion_js_1.getCompletions,
+        getDocumentColors: colorProvider_js_1.getDocumentColors,
+        getColorRepresentations: colorProvider_js_1.getColorRepresentations,
+        getCodeActions: codeAction_js_1.getCodeActions,
+        executeCommand: codeAction_js_1.executeCommand,
+        getAvailableCommands: codeAction_js_1.getAvailableCommands,
+    };
+}
+exports.createService = createService;
+//# sourceMappingURL=service.js.map

package/lib/cjs/service/util.d.ts

@@ -0,0 +1,11 @@
+import type { Range } from "vscode-languageserver-types";
+import { SourceFile, SyntaxNode } from "../types.js";
+import type { DocumentLike } from "../index.js";
+export declare function getStart(sourceFile: SourceFile, node: SyntaxNode): number;
+export declare function syntaxNodesToRanges(doc: DocumentLike, sourceFile: SourceFile, nodes: SyntaxNode[]): Range[];
+export declare function syntaxNodeToRange(doc: DocumentLike, sourceFile: SourceFile, node: SyntaxNode): {
+    start: import("vscode-languageserver-types").Position;
+    end: import("vscode-languageserver-types").Position;
+};
+export declare function escapeIdentifierText(text: string): string;
+export declare function assertNever(v: never): never;

package/lib/{service → cjs/service}/util.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertNever = exports.escapeIdentifierText = exports.syntaxNodeToRange = exports.syntaxNodesToRanges = exports.getStart = void 0;
-const types_1 = require("../types");
-const scanner_1 = require("../scanner");
+const types_js_1 = require("../types.js");
+const scanner_js_1 = require("../scanner.js");
 function getStart(sourceFile, node) {
     return getTokenPosOfNode(sourceFile, node);
 }
@@ -10,12 +10,12 @@ exports.getStart = getStart;
 function getTokenPosOfNode(sourceFile, node) {
     if (nodeIsMissing(node))
         return node.pos;
-    return (0, scanner_1.skipTrivia)(sourceFile.content, node.pos);
+    return (0, scanner_js_1.skipTrivia)(sourceFile.content, node.pos);
 }
 function nodeIsMissing(node) {
     return node === undefined
         ? true
-        : node.pos === node.end && node.pos >= 0 && node.kind !== types_1.SyntaxKind.EndOfFileToken;
+        : node.pos === node.end && node.pos >= 0 && node.kind !== types_js_1.SyntaxKind.EndOfFileToken;
 }
 function syntaxNodesToRanges(doc, sourceFile, nodes) {
     return nodes.map(node => syntaxNodeToRange(doc, sourceFile, node));
@@ -39,14 +39,14 @@ function escapeIdentifierText(text) {
         return quote(esc);
     }
     const ch = text.charCodeAt(0);
-    if (!(0, scanner_1.isIdentifierStart)(ch) || text.includes(" "))
+    if (!(0, scanner_js_1.isIdentifierStart)(ch) || text.includes(" "))
         return quote(text);
     return text;
 }
 exports.escapeIdentifierText = escapeIdentifierText;
 const quote = (s) => "\"" + s + "\"";
-function assertNever(n) {
-    throw new Error("Never assertion");
+function assertNever(v) {
+    throw new Error("Should not have reached this. Value: " + (v !== null && v !== void 0 ? v : ""));
 }
 exports.assertNever = assertNever;
 //# sourceMappingURL=util.js.map

package/lib/{service → cjs/service}/validation.d.ts

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

package/lib/{service → cjs/service}/validation.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateDocument = void 0;
-const error_1 = require("../error");
+const error_js_1 = require("../error.js");
 function convertDiagnostic(document, source) {
     return {
         range: {
@@ -9,8 +9,8 @@ function convertDiagnostic(document, source) {
             end: document.positionAt(source.end),
         },
         severity: source.category,
-        code: (0, error_1.formatError)(source.code),
-        source: error_1.diagnosicSource,
+        code: (0, error_js_1.formatError)(source.code),
+        source: error_js_1.diagnosicSource,
         message: source.message,
     };
 }

package/lib/cjs/tester.d.ts

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

package/lib/cjs/tester.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const parser_js_1 = require("./parser.js");
+const binder_js_1 = require("./binder.js");
+const checker_js_1 = require("./checker.js");
+const completion_js_1 = require("./service/completion.js");
+const text = `graph {
+	node_name_a -- node_name_b [color=blue,
+	];
+}`;
+function main() {
+    const parser = new parser_js_1.Parser();
+    const sf = parser.parse(text);
+    (0, binder_js_1.bindSourceFile)(sf);
+    (0, checker_js_1.checkSourceFile)(sf);
+    const doc = vscode_languageserver_textdocument_1.TextDocument.create("inmemory://model.json", "DOT", 0, text);
+    const requestOffset = text.indexOf("color=blue,\n\t") + "color=blue,\n\t".length;
+    const completions = (0, completion_js_1.getCompletions)(doc, sf, doc.positionAt(requestOffset));
+    console.dir(completions);
+}
+main();
+//# sourceMappingURL=tester.js.map

package/lib/{visitor.d.ts → cjs/visitor.d.ts}

@@ -1,2 +1,2 @@
-import { SyntaxNode, SyntaxNodeArray } from "./types";
+import { SyntaxNode, SyntaxNodeArray } from "./types.js";
 export declare function forEachChild<TReturn>(node: SyntaxNode, cbNode: (node: SyntaxNode) => TReturn, cbNodes?: (nodes: SyntaxNodeArray<SyntaxNode>) => TReturn): TReturn | undefined;

package/lib/{visitor.js → cjs/visitor.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.forEachChild = void 0;
-const types_1 = require("./types");
+const types_js_1 = require("./types.js");
 function visitNode(cbNode, node) {
     return node && cbNode(node);
 }
@@ -18,56 +18,56 @@ function visitNodes(cbNode, cbNodes, nodes) {
     return undefined;
 }
 function forEachChild(node, cbNode, cbNodes) {
-    if (!node || node.kind <= types_1.SyntaxKind.LastKeyword)
+    if (!node || node.kind <= types_js_1.SyntaxKind.LastKeyword)
         return;
     switch (node.kind) {
-        case types_1.SyntaxKind.DirectedGraph:
-        case types_1.SyntaxKind.UndirectedGraph:
+        case types_js_1.SyntaxKind.DirectedGraph:
+        case types_js_1.SyntaxKind.UndirectedGraph:
             return visitNodes(cbNode, cbNodes, node.statements)
                 || visitNode(cbNode, node.strict)
                 || visitNode(cbNode, node.id);
-        case types_1.SyntaxKind.AttributeStatement:
+        case types_js_1.SyntaxKind.AttributeStatement:
             return visitNodes(cbNode, cbNodes, node.attributes)
                 || visitNode(cbNode, node.subject)
                 || visitNode(cbNode, node.terminator);
-        case types_1.SyntaxKind.EdgeStatement:
+        case types_js_1.SyntaxKind.EdgeStatement:
             return visitNodes(cbNode, cbNodes, node.attributes)
                 || visitNodes(cbNode, cbNodes, node.rhs)
                 || visitNode(cbNode, node.source)
                 || visitNode(cbNode, node.terminator);
-        case types_1.SyntaxKind.NodeStatement:
+        case types_js_1.SyntaxKind.NodeStatement:
             return visitNodes(cbNode, cbNodes, node.attributes)
                 || visitNode(cbNode, node.id)
                 || visitNode(cbNode, node.terminator);
-        case types_1.SyntaxKind.SubGraph:
+        case types_js_1.SyntaxKind.SubGraph:
             return visitNodes(cbNode, cbNodes, node.statements)
                 || visitNode(cbNode, node.id);
-        case types_1.SyntaxKind.SubGraphStatement:
+        case types_js_1.SyntaxKind.SubGraphStatement:
             return visitNode(cbNode, node.subgraph)
                 || visitNode(cbNode, node.terminator);
-        case types_1.SyntaxKind.IdEqualsIdStatement:
+        case types_js_1.SyntaxKind.IdEqualsIdStatement:
             return visitNode(cbNode, node.leftId)
                 || visitNode(cbNode, node.rightId)
                 || visitNode(cbNode, node.terminator);
-        case types_1.SyntaxKind.QuotedTextIdentifier:
+        case types_js_1.SyntaxKind.QuotedTextIdentifier:
             return visitNodes(cbNode, cbNodes, node.values);
-        case types_1.SyntaxKind.EdgeRhs:
+        case types_js_1.SyntaxKind.EdgeRhs:
             return visitNode(cbNode, node.operation)
                 || visitNode(cbNode, node.target);
-        case types_1.SyntaxKind.AttributeContainer:
+        case types_js_1.SyntaxKind.AttributeContainer:
             return visitNodes(cbNode, cbNodes, node.assignments);
-        case types_1.SyntaxKind.Assignment:
+        case types_js_1.SyntaxKind.Assignment:
             return visitNode(cbNode, node.leftId)
                 || visitNode(cbNode, node.rightId)
                 || visitNode(cbNode, node.terminator);
-        case types_1.SyntaxKind.NormalPortDeclaration:
+        case types_js_1.SyntaxKind.NormalPortDeclaration:
             return visitNode(cbNode, node.colon)
                 || visitNode(cbNode, node.id)
                 || visitNode(cbNode, node.compassPt);
-        case types_1.SyntaxKind.CompassPortDeclaration:
+        case types_js_1.SyntaxKind.CompassPortDeclaration:
             return visitNode(cbNode, node.colon)
                 || visitNode(cbNode, node.compassPt);
-        case types_1.SyntaxKind.NodeId:
+        case types_js_1.SyntaxKind.NodeId:
             return visitNode(cbNode, node.port)
                 || visitNode(cbNode, node.id);
         default:

package/lib/esm/binder.d.ts

@@ -0,0 +1,2 @@
+import { SourceFile } from "./types.js";
+export declare function bindSourceFile(file: SourceFile): void;

package/lib/esm/binder.js

@@ -0,0 +1,296 @@
+import { SyntaxKind, } from "./types.js";
+import { getIdentifierText, nodeContainsErrors } from "./checker.js";
+import { isIdentifierNode } from "./parser.js";
+const binder = createBinder();
+export function bindSourceFile(file) {
+    binder.bind(file);
+}
+function createBinder() {
+    let parent = undefined;
+    let symbolTable = undefined;
+    let colorTable = undefined;
+    let graphContext = 0;
+    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 SyntaxKind.DirectedGraph:
+            case SyntaxKind.UndirectedGraph:
+                return bindGraph(node);
+            case SyntaxKind.AttributeStatement:
+                return bindAttributeStatement(node);
+            case SyntaxKind.EdgeStatement:
+                return bindEdgeStatement(node);
+            case SyntaxKind.NodeStatement:
+                return bindNodeStatement(node);
+            case SyntaxKind.SubGraph:
+                return bindSubGraph(node);
+            case SyntaxKind.SubGraphStatement:
+                return bindSubGraphStatement(node);
+            case SyntaxKind.IdEqualsIdStatement:
+                return bindIdEqualsIdStatement(node);
+            case SyntaxKind.QuotedTextIdentifier:
+                return bindQuotedTextIdentifier(node);
+            case SyntaxKind.EdgeRhs:
+                return bindEdgeRhs(node);
+            case SyntaxKind.AttributeContainer:
+                return bindAttributeContainer(node);
+            case SyntaxKind.Assignment:
+                return bindAssignment(node);
+            case SyntaxKind.NormalPortDeclaration:
+                return bindNormalPortDeclaration(node);
+            case SyntaxKind.CompassPortDeclaration:
+                return bindCompassPortDeclaration(node);
+            case SyntaxKind.NodeId:
+                return bindNodeId(node);
+            default:
+                if (node.kind >= SyntaxKind.FirstNode)
+                    throw "TODO";
+        }
+    }
+    function bindGraph(node) {
+        if (node.strict) {
+            graphContext |= 2;
+        }
+        switch (node.kind) {
+            case SyntaxKind.DirectedGraph:
+                graphContext |= 4;
+                break;
+            case SyntaxKind.UndirectedGraph:
+                graphContext |= 8;
+                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 = undefined;
+        switch (superParentStatement.kind) {
+            case SyntaxKind.NodeStatement:
+                carrierIdentifier = superParentStatement.id.id;
+                break;
+            case SyntaxKind.EdgeStatement:
+                break;
+            case SyntaxKind.SubGraphStatement:
+                break;
+            case SyntaxKind.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 new Map();
+    }
+    function createColorTable() {
+        return new Map();
+    }
+    function ensureMemberSymbol(node, carrier) {
+        if (node && carrier && isIdentifierNode(node)) {
+            const name = getIdentifierText(node);
+            if (name === undefined)
+                return;
+            const carrierSymbol = carrier.symbol;
+            if (carrierSymbol === undefined)
+                throw "carrierSymbol is undefined";
+            let symbols = carrierSymbol.members;
+            if (symbols === undefined)
+                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 === undefined)
+                return;
+            if (symbols === undefined)
+                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 === undefined) {
+            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 colors = colorTable;
+            const name = getIdentifierText(node);
+            if (name === undefined)
+                return;
+            if (colors === undefined)
+                throw "symbolTable is undefined";
+            const color = createColor(node);
+            colors.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: undefined,
+        };
+    }
+    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;
+        },
+    };
+}
+//# sourceMappingURL=binder.js.map