volar-service-typescript 0.0.0

package/out/services/formatting.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const getFormatCodeSettings_1 = require("../configs/getFormatCodeSettings");
+const shared_1 = require("../shared");
+function register(ctx) {
+    return {
+        onRange: async (uri, range, options) => {
+            const document = ctx.getTextDocument(uri);
+            if (!document)
+                return [];
+            const fileName = ctx.env.uriToFileName(document.uri);
+            const tsOptions = await (0, getFormatCodeSettings_1.getFormatCodeSettings)(ctx, document, options);
+            if (typeof (tsOptions.indentSize) === "boolean" || typeof (tsOptions.indentSize) === "string") {
+                tsOptions.indentSize = undefined;
+            }
+            const scriptEdits = range
+                ? (0, shared_1.safeCall)(() => ctx.typescript.languageService.getFormattingEditsForRange(fileName, document.offsetAt(range.start), document.offsetAt(range.end), tsOptions))
+                : (0, shared_1.safeCall)(() => ctx.typescript.languageService.getFormattingEditsForDocument(fileName, tsOptions));
+            if (!scriptEdits)
+                return [];
+            const result = [];
+            for (const textEdit of scriptEdits) {
+                result.push({
+                    range: {
+                        start: document.positionAt(textEdit.span.start),
+                        end: document.positionAt(textEdit.span.start + textEdit.span.length),
+                    },
+                    newText: textEdit.newText,
+                });
+            }
+            return result;
+        },
+        onType: async (uri, options, position, key) => {
+            const document = ctx.getTextDocument(uri);
+            if (!document)
+                return [];
+            const fileName = ctx.env.uriToFileName(document.uri);
+            const tsOptions = await (0, getFormatCodeSettings_1.getFormatCodeSettings)(ctx, document, options);
+            const scriptEdits = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getFormattingEditsAfterKeystroke(fileName, document.offsetAt(position), key, tsOptions));
+            if (!scriptEdits)
+                return [];
+            const result = [];
+            for (const textEdit of scriptEdits) {
+                result.push({
+                    range: {
+                        start: document.positionAt(textEdit.span.start),
+                        end: document.positionAt(textEdit.span.start + textEdit.span.length),
+                    },
+                    newText: textEdit.newText,
+                });
+            }
+            return result;
+        },
+    };
+}
+exports.register = register;
+//# sourceMappingURL=formatting.js.map

package/out/services/hover.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (uri: string, position: vscode.Position, documentOnly?: boolean) => vscode.Hover | undefined;

package/out/services/hover.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const previewer = __importStar(require("../utils/previewer"));
+const shared_1 = require("../shared");
+function register(ctx) {
+    const { ts } = ctx;
+    return (uri, position, documentOnly = false) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return;
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const offset = document.offsetAt(position);
+        const info = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getQuickInfoAtPosition(fileName, offset));
+        if (!info)
+            return;
+        const parts = [];
+        const displayString = ts.displayPartsToString(info.displayParts);
+        const documentation = previewer.markdownDocumentation(info.documentation ?? [], info.tags, { toResource }, ctx);
+        if (displayString && !documentOnly) {
+            parts.push(['```typescript', displayString, '```'].join('\n'));
+        }
+        if (documentation) {
+            parts.push(documentation);
+        }
+        const markdown = {
+            kind: vscode.MarkupKind.Markdown,
+            value: parts.join('\n\n'),
+        };
+        return {
+            contents: markdown,
+            range: vscode.Range.create(document.positionAt(info.textSpan.start), document.positionAt(info.textSpan.start + info.textSpan.length)),
+        };
+        function toResource(path) {
+            return ctx.env.fileNameToUri(path);
+        }
+    };
+}
+exports.register = register;
+//# sourceMappingURL=hover.js.map

package/out/services/implementation.d.ts

@@ -0,0 +1,3 @@
+import type * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (uri: string, position: vscode.Position) => vscode.LocationLink[];

package/out/services/implementation.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const transforms_1 = require("../utils/transforms");
+const shared_1 = require("../shared");
+function register(ctx) {
+    return (uri, position) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const offset = document.offsetAt(position);
+        const entries = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getImplementationAtPosition(fileName, offset));
+        if (!entries)
+            return [];
+        return (0, transforms_1.entriesToLocationLinks)([...entries], ctx);
+    };
+}
+exports.register = register;
+//# sourceMappingURL=implementation.js.map

package/out/services/inlayHints.d.ts

@@ -0,0 +1,3 @@
+import { SharedContext } from '../types';
+import * as vscode from 'vscode-languageserver-protocol';
+export declare function register(ctx: SharedContext): (uri: string, range: vscode.Range) => Promise<vscode.InlayHint[] | undefined>;

package/out/services/inlayHints.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const getUserPreferences_1 = require("../configs/getUserPreferences");
+const shared_1 = require("../shared");
+function register(ctx) {
+    const { ts } = ctx;
+    return async (uri, range) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return;
+        const preferences = await (0, getUserPreferences_1.getUserPreferences)(ctx, document);
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const start = document.offsetAt(range.start);
+        const end = document.offsetAt(range.end);
+        const inlayHints = (0, shared_1.safeCall)(() => 'provideInlayHints' in ctx.typescript.languageService
+            ? ctx.typescript.languageService.provideInlayHints(fileName, { start, length: end - start }, preferences)
+            : []) ?? [];
+        return inlayHints.map(inlayHint => {
+            const result = vscode.InlayHint.create(document.positionAt(inlayHint.position), inlayHint.text, inlayHint.kind === ts.InlayHintKind.Type ? vscode.InlayHintKind.Type
+                : inlayHint.kind === ts.InlayHintKind.Parameter ? vscode.InlayHintKind.Parameter
+                    : undefined);
+            result.paddingLeft = inlayHint.whitespaceBefore;
+            result.paddingRight = inlayHint.whitespaceAfter;
+            return result;
+        });
+    };
+}
+exports.register = register;
+//# sourceMappingURL=inlayHints.js.map

package/out/services/prepareRename.d.ts

@@ -0,0 +1,6 @@
+import { SharedContext } from '../types';
+import * as vscode from 'vscode-languageserver-protocol';
+export declare const renameInfoOptions: {
+    allowRenameOfImportPath: boolean;
+};
+export declare function register(ctx: SharedContext): (uri: string, position: vscode.Position) => vscode.Range | undefined | vscode.ResponseError<void>;

package/out/services/prepareRename.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = exports.renameInfoOptions = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const shared_1 = require("../shared");
+/* typescript-language-features is hardcode true */
+exports.renameInfoOptions = { allowRenameOfImportPath: true };
+function register(ctx) {
+    return (uri, position) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return;
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const offset = document.offsetAt(position);
+        const renameInfo = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getRenameInfo(fileName, offset, exports.renameInfoOptions));
+        if (!renameInfo)
+            return;
+        if (!renameInfo.canRename) {
+            return new vscode.ResponseError(0, renameInfo.localizedErrorMessage);
+        }
+        return {
+            start: document.positionAt(renameInfo.triggerSpan.start),
+            end: document.positionAt(renameInfo.triggerSpan.start + renameInfo.triggerSpan.length),
+        };
+    };
+}
+exports.register = register;
+//# sourceMappingURL=prepareRename.js.map

package/out/services/references.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (uri: string, position: vscode.Position) => vscode.Location[];

package/out/services/references.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const transforms_1 = require("../utils/transforms");
+const shared_1 = require("../shared");
+function register(ctx) {
+    return (uri, position) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return [];
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const offset = document.offsetAt(position);
+        const entries = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getReferencesAtPosition(fileName, offset));
+        if (!entries)
+            return [];
+        return (0, transforms_1.entriesToLocations)([...entries], ctx);
+    };
+}
+exports.register = register;
+//# sourceMappingURL=references.js.map

package/out/services/rename.d.ts

@@ -0,0 +1,5 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (uri: string, position: vscode.Position, newName: string) => Promise<vscode.WorkspaceEdit | undefined>;
+export declare function fileTextChangesToWorkspaceEdit(changes: readonly ts.FileTextChanges[], ctx: SharedContext): vscode.WorkspaceEdit;

package/out/services/rename.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileTextChangesToWorkspaceEdit = exports.register = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const path_1 = require("path");
+const prepareRename_1 = require("./prepareRename");
+const getFormatCodeSettings_1 = require("../configs/getFormatCodeSettings");
+const getUserPreferences_1 = require("../configs/getUserPreferences");
+const shared_1 = require("../shared");
+function register(ctx) {
+    return async (uri, position, newName) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return;
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const offset = document.offsetAt(position);
+        const renameInfo = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getRenameInfo(fileName, offset, prepareRename_1.renameInfoOptions));
+        if (!renameInfo?.canRename)
+            return;
+        if (renameInfo.fileToRename) {
+            const [formatOptions, preferences] = await Promise.all([
+                (0, getFormatCodeSettings_1.getFormatCodeSettings)(ctx, document),
+                (0, getUserPreferences_1.getUserPreferences)(ctx, document),
+            ]);
+            return renameFile(renameInfo.fileToRename, newName, formatOptions, preferences);
+        }
+        const { providePrefixAndSuffixTextForRename } = await (0, getUserPreferences_1.getUserPreferences)(ctx, document);
+        const entries = ctx.typescript.languageService.findRenameLocations(fileName, offset, false, false, providePrefixAndSuffixTextForRename);
+        if (!entries)
+            return;
+        const locations = locationsToWorkspaceEdit(newName, entries, ctx);
+        return locations;
+    };
+    function renameFile(fileToRename, newName, formatOptions, preferences) {
+        // Make sure we preserve file extension if none provided
+        if (!path_1.posix.extname(newName)) {
+            newName += path_1.posix.extname(fileToRename);
+        }
+        const dirname = path_1.posix.dirname(fileToRename);
+        const newFilePath = path_1.posix.join(dirname, newName);
+        const response = ctx.typescript.languageService.getEditsForFileRename(fileToRename, newFilePath, formatOptions, preferences);
+        const edits = fileTextChangesToWorkspaceEdit(response, ctx);
+        if (!edits.documentChanges) {
+            edits.documentChanges = [];
+        }
+        edits.documentChanges.push(vscode.RenameFile.create(ctx.env.fileNameToUri(fileToRename), ctx.env.fileNameToUri(newFilePath)));
+        return edits;
+    }
+}
+exports.register = register;
+function fileTextChangesToWorkspaceEdit(changes, ctx) {
+    const workspaceEdit = {};
+    for (const change of changes) {
+        if (!workspaceEdit.documentChanges) {
+            workspaceEdit.documentChanges = [];
+        }
+        const uri = ctx.env.fileNameToUri(change.fileName);
+        let doc = ctx.getTextDocument(uri);
+        if (change.isNewFile) {
+            workspaceEdit.documentChanges.push(vscode.CreateFile.create(uri));
+            doc = vscode_languageserver_textdocument_1.TextDocument.create(uri, 'typescript', 0, '');
+        }
+        if (!doc)
+            continue;
+        const docEdit = vscode.TextDocumentEdit.create({
+            uri,
+            version: null, // fix https://github.com/johnsoncodehk/volar/issues/2025
+        }, []);
+        for (const textChange of change.textChanges) {
+            docEdit.edits.push({
+                newText: textChange.newText,
+                range: {
+                    start: doc.positionAt(textChange.span.start),
+                    end: doc.positionAt(textChange.span.start + textChange.span.length),
+                },
+            });
+        }
+        workspaceEdit.documentChanges.push(docEdit);
+    }
+    return workspaceEdit;
+}
+exports.fileTextChangesToWorkspaceEdit = fileTextChangesToWorkspaceEdit;
+function locationsToWorkspaceEdit(newText, locations, ctx) {
+    const workspaceEdit = {};
+    for (const location of locations) {
+        if (!workspaceEdit.changes) {
+            workspaceEdit.changes = {};
+        }
+        const uri = ctx.env.fileNameToUri(location.fileName);
+        const doc = ctx.getTextDocument(uri);
+        if (!doc)
+            continue;
+        if (!workspaceEdit.changes[uri]) {
+            workspaceEdit.changes[uri] = [];
+        }
+        let _newText = newText;
+        if (location.prefixText)
+            _newText = location.prefixText + _newText;
+        if (location.suffixText)
+            _newText = _newText + location.suffixText;
+        workspaceEdit.changes[uri].push({
+            newText: _newText,
+            range: {
+                start: doc.positionAt(location.textSpan.start),
+                end: doc.positionAt(location.textSpan.start + location.textSpan.length),
+            },
+        });
+    }
+    return workspaceEdit;
+}
+//# sourceMappingURL=rename.js.map

package/out/services/selectionRanges.d.ts

@@ -0,0 +1,3 @@
+import { SharedContext } from '../types';
+import * as vscode from 'vscode-languageserver-protocol';
+export declare function register(ctx: SharedContext): (uri: string, positions: vscode.Position[]) => vscode.SelectionRange[];

package/out/services/selectionRanges.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const shared_1 = require("../shared");
+function register(ctx) {
+    return (uri, positions) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return [];
+        const result = [];
+        for (const position of positions) {
+            const fileName = ctx.env.uriToFileName(document.uri);
+            const offset = document.offsetAt(position);
+            const range = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getSmartSelectionRange(fileName, offset));
+            if (!range)
+                continue;
+            result.push(transformSelectionRange(range, document));
+        }
+        return result;
+    };
+}
+exports.register = register;
+function transformSelectionRange(range, document) {
+    return {
+        range: vscode.Range.create(document.positionAt(range.textSpan.start), document.positionAt(range.textSpan.start + range.textSpan.length)),
+        parent: range.parent ? transformSelectionRange(range.parent, document) : undefined,
+    };
+}
+//# sourceMappingURL=selectionRanges.js.map

package/out/services/semanticTokens.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode-languageserver-protocol';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): (uri: string, range: vscode.Range, legend: vscode.SemanticTokensLegend) => [number, number, number, number, number][] | undefined;

package/out/services/semanticTokens.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const shared_1 = require("../shared");
+function register(ctx) {
+    const { ts } = ctx;
+    return (uri, range, legend) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return;
+        const file = ctx.env.uriToFileName(uri);
+        const start = range ? document.offsetAt(range.start) : 0;
+        const length = range ? (document.offsetAt(range.end) - start) : document.getText().length;
+        if (ctx.typescript?.languageServiceHost.getCancellationToken?.().isCancellationRequested())
+            return;
+        const response2 = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getEncodedSyntacticClassifications(file, { start, length }));
+        if (!response2)
+            return;
+        if (ctx.typescript?.languageServiceHost.getCancellationToken?.().isCancellationRequested())
+            return;
+        const response1 = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getEncodedSemanticClassifications(file, { start, length }, ts.SemanticClassificationFormat.TwentyTwenty));
+        if (!response1)
+            return;
+        let tokenModifiersTable = [];
+        tokenModifiersTable[2 /* TokenModifier.async */] = 1 << legend.tokenModifiers.indexOf('async');
+        tokenModifiersTable[0 /* TokenModifier.declaration */] = 1 << legend.tokenModifiers.indexOf('declaration');
+        tokenModifiersTable[3 /* TokenModifier.readonly */] = 1 << legend.tokenModifiers.indexOf('readonly');
+        tokenModifiersTable[1 /* TokenModifier.static */] = 1 << legend.tokenModifiers.indexOf('static');
+        tokenModifiersTable[5 /* TokenModifier.local */] = 1 << legend.tokenModifiers.indexOf('local'); // missing in server tokenModifiers
+        tokenModifiersTable[4 /* TokenModifier.defaultLibrary */] = 1 << legend.tokenModifiers.indexOf('defaultLibrary');
+        tokenModifiersTable = tokenModifiersTable.map(mod => Math.max(mod, 0));
+        const tokenSpan = [...response1.spans, ...response2.spans];
+        const tokens = [];
+        let i = 0;
+        while (i < tokenSpan.length) {
+            const offset = tokenSpan[i++];
+            const length = tokenSpan[i++];
+            const tsClassification = tokenSpan[i++];
+            let tokenModifiers = 0;
+            let tokenType = getTokenTypeFromClassification(tsClassification);
+            if (tokenType !== undefined) {
+                // it's a classification as returned by the typescript-vscode-sh-plugin
+                tokenModifiers = getTokenModifierFromClassification(tsClassification);
+            }
+            else {
+                // typescript-vscode-sh-plugin is not present
+                tokenType = tokenTypeMap[tsClassification];
+                if (tokenType === undefined) {
+                    continue;
+                }
+            }
+            const serverToken = tsTokenTypeToServerTokenType(tokenType);
+            if (serverToken === undefined) {
+                continue;
+            }
+            const serverTokenModifiers = tsTokenModifierToServerTokenModifier(tokenModifiers);
+            // we can use the document's range conversion methods because the result is at the same version as the document
+            const startPos = document.positionAt(offset);
+            const endPos = document.positionAt(offset + length);
+            for (let line = startPos.line; line <= endPos.line; line++) {
+                const startCharacter = (line === startPos.line ? startPos.character : 0);
+                const endCharacter = (line === endPos.line ? endPos.character : docLineLength(document, line));
+                tokens.push([line, startCharacter, endCharacter - startCharacter, serverToken, serverTokenModifiers]);
+            }
+        }
+        return tokens;
+        function tsTokenTypeToServerTokenType(tokenType) {
+            return legend.tokenTypes.indexOf(tokenTypes[tokenType]);
+        }
+        function tsTokenModifierToServerTokenModifier(input) {
+            let m = 0;
+            let i = 0;
+            while (input) {
+                if (input & 1) {
+                    m |= tokenModifiersTable[i];
+                }
+                input = input >> 1;
+                i++;
+            }
+            return m;
+        }
+    };
+}
+exports.register = register;
+function docLineLength(document, line) {
+    const currentLineOffset = document.offsetAt({ line, character: 0 });
+    const nextLineOffset = document.offsetAt({ line: line + 1, character: 0 });
+    return nextLineOffset - currentLineOffset;
+}
+function getTokenTypeFromClassification(tsClassification) {
+    if (tsClassification > 255 /* TokenEncodingConsts.modifierMask */) {
+        return (tsClassification >> 8 /* TokenEncodingConsts.typeOffset */) - 1;
+    }
+    return undefined;
+}
+function getTokenModifierFromClassification(tsClassification) {
+    return tsClassification & 255 /* TokenEncodingConsts.modifierMask */;
+}
+const tokenTypes = [];
+tokenTypes[0 /* TokenType.class */] = 'class';
+tokenTypes[1 /* TokenType.enum */] = 'enum';
+tokenTypes[2 /* TokenType.interface */] = 'interface';
+tokenTypes[3 /* TokenType.namespace */] = 'namespace';
+tokenTypes[4 /* TokenType.typeParameter */] = 'typeParameter';
+tokenTypes[5 /* TokenType.type */] = 'type';
+tokenTypes[6 /* TokenType.parameter */] = 'parameter';
+tokenTypes[7 /* TokenType.variable */] = 'variable';
+tokenTypes[8 /* TokenType.enumMember */] = 'enumMember';
+tokenTypes[9 /* TokenType.property */] = 'property';
+tokenTypes[10 /* TokenType.function */] = 'function';
+tokenTypes[11 /* TokenType.method */] = 'method';
+const tokenModifiers = [];
+tokenModifiers[2 /* TokenModifier.async */] = 'async';
+tokenModifiers[0 /* TokenModifier.declaration */] = 'declaration';
+tokenModifiers[3 /* TokenModifier.readonly */] = 'readonly';
+tokenModifiers[1 /* TokenModifier.static */] = 'static';
+tokenModifiers[5 /* TokenModifier.local */] = 'local'; // missing in server tokenModifiers
+tokenModifiers[4 /* TokenModifier.defaultLibrary */] = 'defaultLibrary';
+// mapping for the original ExperimentalProtocol.ClassificationType from TypeScript (only used when plugin is not available)
+const tokenTypeMap = [];
+tokenTypeMap[11 /* ExperimentalProtocol.ClassificationType.className */] = 0 /* TokenType.class */;
+tokenTypeMap[12 /* ExperimentalProtocol.ClassificationType.enumName */] = 1 /* TokenType.enum */;
+tokenTypeMap[13 /* ExperimentalProtocol.ClassificationType.interfaceName */] = 2 /* TokenType.interface */;
+tokenTypeMap[14 /* ExperimentalProtocol.ClassificationType.moduleName */] = 3 /* TokenType.namespace */;
+tokenTypeMap[15 /* ExperimentalProtocol.ClassificationType.typeParameterName */] = 4 /* TokenType.typeParameter */;
+tokenTypeMap[16 /* ExperimentalProtocol.ClassificationType.typeAliasName */] = 5 /* TokenType.type */;
+tokenTypeMap[17 /* ExperimentalProtocol.ClassificationType.parameterName */] = 6 /* TokenType.parameter */;
+//# sourceMappingURL=semanticTokens.js.map

package/out/services/signatureHelp.d.ts

@@ -0,0 +1,3 @@
+import { SharedContext } from '../types';
+import * as vscode from 'vscode-languageserver-protocol';
+export declare function register(ctx: SharedContext): (uri: string, position: vscode.Position, context?: vscode.SignatureHelpContext) => vscode.SignatureHelp | undefined;