dot-language-support 1.5.4

package/.github/workflows/CD.yml

@@ -0,0 +1,36 @@
+name: Node.js CD
+
+on:
+  push:
+    branches:
+    - "!*"
+    tags:
+    - "v*"
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Use Node.js 16.x
+      uses: actions/setup-node@v1
+      with:
+        node-version: 16.x
+
+    - uses: actions/cache@v2
+      with:
+        path: ~/.npm
+        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+        restore-keys: |
+          ${{ runner.os }}-node-
+
+    - run: npm ci
+    - run: npm run compile
+    - run: npm test
+      env:
+        CI: true
+    - run: npm config set "//registry.npmjs.org/:_authToken" "${{ secrets.NPM_TOKEN }}"
+    - run: npm publish

package/.github/workflows/CI.yml

@@ -0,0 +1,33 @@
+name: Node.js CI
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.x, 16.x]
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+
+    - uses: actions/cache@v2
+      with:
+        path: ~/.npm
+        key: ${{ runner.os }}-node-${{ matrix.node-version }}-${{ hashFiles('**/package-lock.json') }}
+        restore-keys: |
+          ${{ runner.os }}-node-${{ matrix.node-version }}-
+
+    - run: npm ci
+    - run: npm run compile
+    - run: npm test
+      env:
+        CI: true

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Niklas Mollenhauer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# dot-language-support
+> [![Build Status](https://travis-ci.com/nikeee/dot-language-support.svg?branch=master)](https://travis-ci.com/nikeee/dot-language-support) ![Dependency Status](https://david-dm.org/nikeee/dot-language-support.svg) [![npm version](https://badge.fury.io/js/dot-language-support.svg)](https://www.npmjs.com/package/dot-language-support)
+
+A language service library, written in TypeScript. Used by [dot-language-server](https://github.com/nikeee/dot-language-server) and [edotor.net](https://edotor.net).
+
+## Features
+- Hightlight semantic and syntactic errors
+- Auto completion for colors and shapes
+- Code Actions:
+    - Refactoring Graphs to Digraphs and vice-versa
+    - Fix wrong graph edges
+    - Refactor edges to sub graphs
+
+## Installation
+```Shell
+npm -S i dot-language-support
+```

package/lib/binder.d.ts

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

package/lib/binder.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindSourceFile = void 0;
+const types_1 = require("./types");
+const checker_1 = require("./checker");
+const parser_1 = require("./parser");
+const binder = createBinder();
+function bindSourceFile(file) {
+    binder.bind(file);
+}
+exports.bindSourceFile = bindSourceFile;
+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 types_1.SyntaxKind.DirectedGraph:
+            case types_1.SyntaxKind.UndirectedGraph:
+                return bindGraph(node);
+            case types_1.SyntaxKind.AttributeStatement:
+                return bindAttributeStatement(node);
+            case types_1.SyntaxKind.EdgeStatement:
+                return bindEdgeStatement(node);
+            case types_1.SyntaxKind.NodeStatement:
+                return bindNodeStatement(node);
+            case types_1.SyntaxKind.SubGraph:
+                return bindSubGraph(node);
+            case types_1.SyntaxKind.SubGraphStatement:
+                return bindSubGraphStatement(node);
+            case types_1.SyntaxKind.IdEqualsIdStatement:
+                return bindIdEqualsIdStatement(node);
+            case types_1.SyntaxKind.QuotedTextIdentifier:
+                return bindQuotedTextIdentifier(node);
+            case types_1.SyntaxKind.EdgeRhs:
+                return bindEdgeRhs(node);
+            case types_1.SyntaxKind.AttributeContainer:
+                return bindAttributeContainer(node);
+            case types_1.SyntaxKind.Assignment:
+                return bindAssignment(node);
+            case types_1.SyntaxKind.NormalPortDeclaration:
+                return bindNormalPortDeclaration(node);
+            case types_1.SyntaxKind.CompassPortDeclaration:
+                return bindCompassPortDeclaration(node);
+            case types_1.SyntaxKind.NodeId:
+                return bindNodeId(node);
+            default:
+                if (node.kind >= types_1.SyntaxKind.FirstNode)
+                    throw "TODO";
+        }
+    }
+    function bindGraph(node) {
+        if (node.strict) {
+            graphContext |= 2;
+        }
+        switch (node.kind) {
+            case types_1.SyntaxKind.DirectedGraph:
+                graphContext |= 4;
+                break;
+            case types_1.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 && !(0, checker_1.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 types_1.SyntaxKind.NodeStatement:
+                carrierIdentifier = superParentStatement.id.id;
+                break;
+            case types_1.SyntaxKind.EdgeStatement:
+                break;
+            case types_1.SyntaxKind.SubGraphStatement:
+                break;
+            case types_1.SyntaxKind.AttributeStatement:
+                break;
+        }
+        if (carrierIdentifier)
+            ensureMemberSymbol(node.leftId, carrierIdentifier);
+        bind(node.rightId);
+        if (node.rightId && !(0, checker_1.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 && (0, parser_1.isIdentifierNode)(node)) {
+            const name = (0, checker_1.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 && (0, parser_1.isIdentifierNode)(node)) {
+            const symbols = symbolTable;
+            const name = (0, checker_1.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 && (0, parser_1.isIdentifierNode)(node)) {
+            const colors = colorTable;
+            const name = (0, checker_1.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 ? (0, checker_1.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

package/lib/checker.d.ts

@@ -0,0 +1,14 @@
+import { SyntaxNode, Identifier, SyntaxKind, Graph, EdgeStatement, EdgeRhs, SourceFile, SubGraphStatement, NodeId, AttributeStatement, Statement, StatementOf, Token } from "./types";
+export declare function checkSourceFile(file: SourceFile): void;
+export declare function findNodeAtOffset(root: SyntaxNode, offset: number, inclusiveEnd?: boolean): SyntaxNode | undefined;
+export declare function getAllowedEdgeOperation(graph: Graph): SyntaxKind.DirectedEdgeOp | SyntaxKind.UndirectedEdgeOp;
+export declare function findAllEdges(node: SyntaxNode): EdgeRhs[];
+export declare function findOptionalSemicolons(node: SyntaxNode): Token<SyntaxKind.SemicolonToken>[];
+export declare function findAllStatements<T extends Statement["kind"]>(node: SyntaxNode, kind?: T): StatementOf<T>[];
+export declare function isAttrStatement(node: SyntaxNode): node is AttributeStatement;
+export declare function isEdgeStatement(node: SyntaxNode): node is EdgeStatement;
+export declare function isSubGraphStatement(node: SyntaxNode): node is SubGraphStatement;
+export declare function isNodeId(node: SyntaxNode): node is NodeId;
+export declare function edgeStatementHasAttributes(es: EdgeStatement): boolean;
+export declare function getIdentifierText(n: Identifier): string;
+export declare function nodeContainsErrors(node: SyntaxNode): boolean;

package/lib/checker.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeContainsErrors = exports.getIdentifierText = exports.edgeStatementHasAttributes = exports.isNodeId = exports.isSubGraphStatement = exports.isEdgeStatement = exports.isAttrStatement = exports.findAllStatements = exports.findOptionalSemicolons = exports.findAllEdges = exports.getAllowedEdgeOperation = exports.findNodeAtOffset = exports.checkSourceFile = void 0;
+const types_1 = require("./types");
+const util_1 = require("./service/util");
+const visitor_1 = require("./visitor");
+function checkSourceFile(file) {
+    const g = file.graph;
+    if (g) {
+        const messages = checkGraphSemantics(file, g);
+        if (messages) {
+            file.diagnostics.push.apply(file.diagnostics, messages);
+        }
+    }
+}
+exports.checkSourceFile = checkSourceFile;
+function getNarrowerNode(offset, prev, toCheck) {
+    const prevRange = prev.end - prev.pos;
+    if (toCheck.pos <= offset && offset <= toCheck.end) {
+        let nrange = toCheck.end - toCheck.pos;
+        if (nrange < prevRange) {
+            return toCheck;
+        }
+    }
+    return prev;
+}
+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 = (0, visitor_1.forEachChild)(root, child => findNodeAtOffset(child, offset, inclusiveEnd));
+        return narrowerChild ? narrowerChild : root;
+    }
+    return undefined;
+}
+exports.findNodeAtOffset = findNodeAtOffset;
+function getAllowedEdgeOperation(graph) {
+    return graph.kind === types_1.SyntaxKind.DirectedGraph
+        ? types_1.SyntaxKind.DirectedEdgeOp
+        : types_1.SyntaxKind.UndirectedEdgeOp;
+}
+exports.getAllowedEdgeOperation = getAllowedEdgeOperation;
+function checkGraphSemantics(file, root) {
+    const expectedEdgeOp = getAllowedEdgeOperation(root);
+    const invalidEdgeRhses = findEdgeErrors(expectedEdgeOp, root);
+    return invalidEdgeRhses == undefined || invalidEdgeRhses.length === 0
+        ? undefined
+        : createEdgeViolationDiagnostics(file, expectedEdgeOp, invalidEdgeRhses);
+}
+function findAllEdges(node) {
+    const allEdges = [];
+    (0, visitor_1.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;
+}
+exports.findAllEdges = findAllEdges;
+function findOptionalSemicolons(node) {
+    const statements = findAllStatements(node);
+    const terminators = statements.map(p => p.terminator);
+    return terminators.filter(t => !!t);
+}
+exports.findOptionalSemicolons = findOptionalSemicolons;
+function isStatement(node) {
+    return node.kind === types_1.SyntaxKind.SubGraphStatement
+        || node.kind === types_1.SyntaxKind.EdgeStatement
+        || node.kind === types_1.SyntaxKind.NodeStatement
+        || node.kind === types_1.SyntaxKind.IdEqualsIdStatement
+        || node.kind === types_1.SyntaxKind.AttributeStatement;
+}
+function findAllStatements(node, kind) {
+    const allStatements = [];
+    (0, visitor_1.forEachChild)(node, child => {
+        if ((kind === undefined && 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;
+}
+exports.findAllStatements = findAllStatements;
+function findEdgeErrors(expectedEdgeOp, node) {
+    const edges = findAllEdges(node);
+    const wrongEdges = edges && edges.length > 0
+        ? edges.filter(e => e.operation.kind !== expectedEdgeOp)
+        : undefined;
+    if (wrongEdges && wrongEdges.length > 0) {
+        wrongEdges.forEach(e => e.operation.flags |= 2);
+        return wrongEdges;
+    }
+    return undefined;
+}
+function createEdgeViolationDiagnostics(file, expectedEdgeOp, violators) {
+    const op = expectedEdgeOp === types_1.SyntaxKind.UndirectedEdgeOp ? "--" : "->";
+    const graphType = expectedEdgeOp === types_1.SyntaxKind.UndirectedEdgeOp ? "undirected" : "directed";
+    const message = `Invalid edge operation, use "${op}" in ${graphType} graph`;
+    const code = createCheckerError(0);
+    const category = types_1.DiagnosticCategory.Error;
+    violators.forEach(edge => edge.operation.flags |= 2);
+    return violators.map(edge => {
+        const start = (0, util_1.getStart)(file, edge.operation);
+        const end = edge.operation.end;
+        return {
+            message,
+            code,
+            category,
+            start,
+            end,
+        };
+    });
+}
+function getInvalidEdgeRhs(allowedOp, edges) {
+    const res = [];
+    for (const e of edges) {
+        if (e.operation.kind !== allowedOp)
+            res.push(e);
+    }
+    return res;
+}
+function isAttrStatement(node) {
+    return node.kind === types_1.SyntaxKind.AttributeStatement;
+}
+exports.isAttrStatement = isAttrStatement;
+function isEdgeStatement(node) {
+    return node.kind === types_1.SyntaxKind.EdgeStatement;
+}
+exports.isEdgeStatement = isEdgeStatement;
+function isSubGraphStatement(node) {
+    return node.kind === types_1.SyntaxKind.SubGraphStatement;
+}
+exports.isSubGraphStatement = isSubGraphStatement;
+function isGraph(node) {
+    return node.kind === types_1.SyntaxKind.DirectedGraph || node.kind === types_1.SyntaxKind.UndirectedGraph;
+}
+function isNodeId(node) {
+    return node.kind === types_1.SyntaxKind.NodeId;
+}
+exports.isNodeId = isNodeId;
+function edgeStatementHasAttributes(es) {
+    return es.attributes
+        && es.attributes.length > 0
+        && es.attributes.some(a => a.assignments && a.assignments.length > 0);
+}
+exports.edgeStatementHasAttributes = edgeStatementHasAttributes;
+function getIdentifierText(n) {
+    switch (n.kind) {
+        case types_1.SyntaxKind.HtmlIdentifier:
+            return n.htmlContent;
+        case types_1.SyntaxKind.TextIdentifier:
+            return n.text;
+        case types_1.SyntaxKind.NumericIdentifier:
+            return n.text;
+        case types_1.SyntaxKind.QuotedTextIdentifier:
+            return n.concatenation;
+        default:
+            return (0, util_1.assertNever)(n);
+    }
+}
+exports.getIdentifierText = getIdentifierText;
+function createCheckerError(sub) {
+    return {
+        source: 4,
+        sub,
+    };
+}
+function nodeContainsErrors(node) {
+    return (node.flags & 2) === 2;
+}
+exports.nodeContainsErrors = nodeContainsErrors;
+//# sourceMappingURL=checker.js.map

package/lib/core.d.ts

@@ -0,0 +1 @@
+export declare function createMapFromTemplate<T>(template: Record<string, T>): Map<string, T>;

package/lib/core.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMapFromTemplate = void 0;
+function createMapFromTemplate(template) {
+    const map = new Map();
+    for (const key in template) {
+        if (template.hasOwnProperty(key)) {
+            map.set(key, template[key]);
+        }
+    }
+    return map;
+}
+exports.createMapFromTemplate = createMapFromTemplate;
+//# sourceMappingURL=core.js.map

package/lib/error.d.ts

@@ -0,0 +1,3 @@
+import { ErrorCode } from "./types";
+export declare const diagnosicSource = "DOT";
+export declare function formatError(error: ErrorCode): string;

package/lib/error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatError = exports.diagnosicSource = void 0;
+exports.diagnosicSource = "DOT";
+const errorCodeLength = 4;
+const subErrorCodeLength = errorCodeLength - 1;
+function formatError(error) {
+    const subCode = (error.sub | 0)
+        .toString()
+        .padStart(subErrorCodeLength, "0");
+    return exports.diagnosicSource + error.source + subCode;
+}
+exports.formatError = formatError;
+//# sourceMappingURL=error.js.map

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./scanner";
+export * from "./parser";
+export * from "./visitor";
+export * from "./service/service";
+export * from "./service/interop";

package/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./scanner"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./visitor"), exports);
+__exportStar(require("./service/service"), exports);
+__exportStar(require("./service/interop"), exports);
+//# sourceMappingURL=index.js.map