volar-service-typescript 0.0.0

package/out/services/signatureHelp.js

@@ -0,0 +1,87 @@
+"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) {
+    const { ts } = ctx;
+    return (uri, position, context) => {
+        const document = ctx.getTextDocument(uri);
+        if (!document)
+            return;
+        const options = {};
+        if (context?.triggerKind === vscode.SignatureHelpTriggerKind.Invoked) {
+            options.triggerReason = {
+                kind: 'invoked'
+            };
+        }
+        else if (context?.triggerKind === vscode.SignatureHelpTriggerKind.TriggerCharacter) {
+            options.triggerReason = {
+                kind: 'characterTyped',
+                triggerCharacter: context.triggerCharacter,
+            };
+        }
+        else if (context?.triggerKind === vscode.SignatureHelpTriggerKind.ContentChange) {
+            options.triggerReason = {
+                kind: 'retrigger',
+                triggerCharacter: context.triggerCharacter,
+            };
+        }
+        const fileName = ctx.env.uriToFileName(document.uri);
+        const offset = document.offsetAt(position);
+        const helpItems = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getSignatureHelpItems(fileName, offset, options));
+        if (!helpItems)
+            return;
+        return {
+            activeSignature: helpItems.selectedItemIndex,
+            activeParameter: helpItems.argumentIndex,
+            signatures: helpItems.items.map(item => {
+                const signature = {
+                    label: '',
+                    documentation: undefined,
+                    parameters: []
+                };
+                signature.label += ts.displayPartsToString(item.prefixDisplayParts);
+                item.parameters.forEach((p, i, a) => {
+                    const label = ts.displayPartsToString(p.displayParts);
+                    const parameter = {
+                        label,
+                        documentation: ts.displayPartsToString(p.documentation)
+                    };
+                    signature.label += label;
+                    signature.parameters.push(parameter);
+                    if (i < a.length - 1) {
+                        signature.label += ts.displayPartsToString(item.separatorDisplayParts);
+                    }
+                });
+                signature.label += ts.displayPartsToString(item.suffixDisplayParts);
+                return signature;
+            }),
+        };
+    };
+}
+exports.register = register;
+//# sourceMappingURL=signatureHelp.js.map

package/out/services/tsconfig.d.ts

@@ -0,0 +1,6 @@
+import * as vscode from '@volar/language-service';
+import { SharedContext } from '../types';
+export declare function register(ctx: SharedContext): {
+    provideDocumentLinks: (document: vscode.TextDocument, _token: vscode.CancellationToken) => vscode.DocumentLink[];
+    resolve(link: vscode.DocumentLink, _token: vscode.CancellationToken): Promise<vscode.DocumentLink>;
+};

package/out/services/tsconfig.js

@@ -0,0 +1,199 @@
+"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 jsonc = __importStar(require("jsonc-parser"));
+const minimatch_1 = require("minimatch");
+const vscode = __importStar(require("@volar/language-service"));
+const vscode_uri_1 = require("vscode-uri");
+function mapChildren(node, f) {
+    return node && node.type === 'array' && node.children
+        ? node.children.map(f)
+        : [];
+}
+function register(ctx) {
+    const patterns = [
+        '**/[jt]sconfig.json',
+        '**/[jt]sconfig.*.json',
+    ];
+    const languages = ['json', 'jsonc'];
+    return {
+        provideDocumentLinks,
+        async resolve(link, _token) {
+            const data = link.data;
+            if (data) {
+                const tsconfigPath = await getTsconfigPath(vscode_uri_1.Utils.dirname(vscode_uri_1.URI.parse(data.resourceUri)), data.extendsValue);
+                if (tsconfigPath === undefined) {
+                    // console.error(vscode.l10n.t("Failed to resolve {0} as module", data.extendsValue));
+                }
+                link.target = tsconfigPath?.toString();
+            }
+            return link;
+        },
+    };
+    function provideDocumentLinks(document, _token) {
+        const match = languages.includes(document.languageId) && patterns.some(pattern => (0, minimatch_1.minimatch)(document.uri, pattern));
+        if (!match) {
+            return [];
+        }
+        const root = jsonc.parseTree(document.getText());
+        if (!root) {
+            return [];
+        }
+        const links = [
+            getExtendsLink(document, root),
+            ...getFilesLinks(document, root),
+            ...getReferencesLinks(document, root)
+        ];
+        return links.filter(link => !!link);
+    }
+    function getExtendsLink(document, root) {
+        const extendsNode = jsonc.findNodeAtLocation(root, ['extends']);
+        if (!isPathValue(extendsNode)) {
+            return undefined;
+        }
+        const extendsValue = extendsNode.value;
+        if (extendsValue.startsWith('/')) {
+            return undefined;
+        }
+        const args = {
+            resourceUri: document.uri,
+            extendsValue: extendsValue
+        };
+        const link = vscode.DocumentLink.create(getRange(document, extendsNode), undefined, args);
+        // link.tooltip = vscode.l10n.t("Follow link");
+        link.tooltip = "Follow link";
+        return link;
+    }
+    function getFilesLinks(document, root) {
+        return mapChildren(jsonc.findNodeAtLocation(root, ['files']), child => pathNodeToLink(document, child));
+    }
+    function getReferencesLinks(document, root) {
+        return mapChildren(jsonc.findNodeAtLocation(root, ['references']), child => {
+            const pathNode = jsonc.findNodeAtLocation(child, ['path']);
+            if (!isPathValue(pathNode)) {
+                return undefined;
+            }
+            return vscode.DocumentLink.create(getRange(document, pathNode), pathNode.value.endsWith('.json')
+                ? getFileTarget(document, pathNode)
+                : getFolderTarget(document, pathNode));
+        });
+    }
+    function pathNodeToLink(document, node) {
+        return isPathValue(node)
+            ? vscode.DocumentLink.create(getRange(document, node), getFileTarget(document, node))
+            : undefined;
+    }
+    function isPathValue(extendsNode) {
+        return extendsNode
+            && extendsNode.type === 'string'
+            && extendsNode.value
+            && !extendsNode.value.includes('*'); // don't treat globs as links.
+    }
+    function getFileTarget(document, node) {
+        return vscode_uri_1.Utils.joinPath(vscode_uri_1.Utils.dirname(vscode_uri_1.URI.parse(document.uri)), node.value).toString();
+    }
+    function getFolderTarget(document, node) {
+        return vscode_uri_1.Utils.joinPath(vscode_uri_1.Utils.dirname(vscode_uri_1.URI.parse(document.uri)), node.value, 'tsconfig.json').toString();
+    }
+    function getRange(document, node) {
+        const offset = node.offset;
+        const start = document.positionAt(offset + 1);
+        const end = document.positionAt(offset + (node.length - 1));
+        return vscode.Range.create(start, end);
+    }
+    async function resolveNodeModulesPath(baseDirUri, pathCandidates) {
+        let currentUri = baseDirUri;
+        const baseCandidate = pathCandidates[0];
+        const sepIndex = baseCandidate.startsWith('@') ? 2 : 1;
+        const moduleBasePath = baseCandidate.split('/').slice(0, sepIndex).join('/');
+        while (true) {
+            const moduleAbsoluteUrl = vscode_uri_1.Utils.joinPath(currentUri, 'node_modules', moduleBasePath);
+            let moduleStat;
+            try {
+                moduleStat = await ctx.env.fileSystemProvider?.stat(moduleAbsoluteUrl.toString());
+            }
+            catch (err) {
+                // noop
+            }
+            if (moduleStat && moduleStat.type === 2 /* Directory */) {
+                for (const uriCandidate of pathCandidates
+                    .map((relativePath) => relativePath.split('/').slice(sepIndex).join('/'))
+                    // skip empty paths within module
+                    .filter(Boolean)
+                    .map((relativeModulePath) => vscode_uri_1.Utils.joinPath(moduleAbsoluteUrl, relativeModulePath))) {
+                    if (await exists(uriCandidate)) {
+                        return uriCandidate;
+                    }
+                }
+                // Continue to looking for potentially another version
+            }
+            const oldUri = currentUri;
+            currentUri = vscode_uri_1.Utils.joinPath(currentUri, '..');
+            // Can't go next. Reached the system root
+            if (oldUri.path === currentUri.path) {
+                return;
+            }
+        }
+    }
+    // Reference: https://github.com/microsoft/TypeScript/blob/febfd442cdba343771f478cf433b0892f213ad2f/src/compiler/commandLineParser.ts#L3005
+    /**
+    * @returns Returns undefined in case of lack of result while trying to resolve from node_modules
+    */
+    async function getTsconfigPath(baseDirUri, extendsValue) {
+        // Don't take into account a case, where tsconfig might be resolved from the root (see the reference)
+        // e.g. C:/projects/shared-tsconfig/tsconfig.json (note that C: prefix is optional)
+        const isRelativePath = ['./', '../'].some(str => extendsValue.startsWith(str));
+        if (isRelativePath) {
+            const absolutePath = vscode_uri_1.Utils.joinPath(baseDirUri, extendsValue);
+            if (await exists(absolutePath) || absolutePath.path.endsWith('.json')) {
+                return absolutePath;
+            }
+            return absolutePath.with({
+                path: `${absolutePath.path}.json`
+            });
+        }
+        // Otherwise resolve like a module
+        return resolveNodeModulesPath(baseDirUri, [
+            extendsValue,
+            ...extendsValue.endsWith('.json') ? [] : [
+                `${extendsValue}.json`,
+                `${extendsValue}/tsconfig.json`,
+            ]
+        ]);
+    }
+    async function exists(resource) {
+        try {
+            const stat = await ctx.env.fileSystemProvider?.stat(resource.toString());
+            // stat.type is an enum flag
+            return !!(stat?.type === 1);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.register = register;
+//# sourceMappingURL=tsconfig.js.map

package/out/services/typeDefinition.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/typeDefinition.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.getTypeDefinitionAtPosition(fileName, offset));
+        if (!entries)
+            return [];
+        return (0, transforms_1.entriesToLocationLinks)([...entries], ctx);
+    };
+}
+exports.register = register;
+//# sourceMappingURL=typeDefinition.js.map

package/out/services/workspaceSymbol.d.ts

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

package/out/services/workspaceSymbol.js

@@ -0,0 +1,80 @@
+"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 PConst = __importStar(require("../protocol.const"));
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const modifiers_1 = require("../utils/modifiers");
+const shared_1 = require("../shared");
+function getSymbolKind(item) {
+    switch (item.kind) {
+        case PConst.Kind.method: return vscode.SymbolKind.Method;
+        case PConst.Kind.enum: return vscode.SymbolKind.Enum;
+        case PConst.Kind.enumMember: return vscode.SymbolKind.EnumMember;
+        case PConst.Kind.function: return vscode.SymbolKind.Function;
+        case PConst.Kind.class: return vscode.SymbolKind.Class;
+        case PConst.Kind.interface: return vscode.SymbolKind.Interface;
+        case PConst.Kind.type: return vscode.SymbolKind.Class;
+        case PConst.Kind.memberVariable: return vscode.SymbolKind.Field;
+        case PConst.Kind.memberGetAccessor: return vscode.SymbolKind.Field;
+        case PConst.Kind.memberSetAccessor: return vscode.SymbolKind.Field;
+        case PConst.Kind.variable: return vscode.SymbolKind.Variable;
+        default: return vscode.SymbolKind.Variable;
+    }
+}
+function register(ctx) {
+    return (query) => {
+        const items = (0, shared_1.safeCall)(() => ctx.typescript.languageService.getNavigateToItems(query));
+        if (!items)
+            return [];
+        return items
+            .filter(item => item.containerName || item.kind !== 'alias')
+            .map(toWorkspaceSymbol)
+            .filter((v) => !!v);
+        function toWorkspaceSymbol(item) {
+            const label = getLabel(item);
+            const uri = ctx.env.fileNameToUri(item.fileName);
+            const document = ctx.getTextDocument(uri);
+            if (document) {
+                const range = vscode.Range.create(document.positionAt(item.textSpan.start), document.positionAt(item.textSpan.start + item.textSpan.length));
+                const info = vscode.WorkspaceSymbol.create(label, getSymbolKind(item), uri, range);
+                const kindModifiers = item.kindModifiers ? (0, modifiers_1.parseKindModifier)(item.kindModifiers) : undefined;
+                if (kindModifiers?.has(PConst.KindModifiers.deprecated)) {
+                    info.tags = [vscode.SymbolTag.Deprecated];
+                }
+                return info;
+            }
+        }
+        function getLabel(item) {
+            const label = item.name;
+            if (item.kind === 'method' || item.kind === 'function') {
+                return label + '()';
+            }
+            return label;
+        }
+    };
+}
+exports.register = register;
+//# sourceMappingURL=workspaceSymbol.js.map

package/out/shared.d.ts

@@ -0,0 +1,5 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export declare function getConfigTitle(document: TextDocument): string;
+export declare function isTsDocument(document: TextDocument): boolean;
+export declare function isJsonDocument(document: TextDocument): boolean;
+export declare function safeCall<T>(cb: () => T): T | undefined;

package/out/shared.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeCall = exports.isJsonDocument = exports.isTsDocument = exports.getConfigTitle = void 0;
+function getConfigTitle(document) {
+    if (document.languageId === 'javascriptreact') {
+        return 'javascript';
+    }
+    if (document.languageId === 'typescriptreact') {
+        return 'typescript';
+    }
+    return document.languageId;
+}
+exports.getConfigTitle = getConfigTitle;
+function isTsDocument(document) {
+    return document.languageId === 'javascript' ||
+        document.languageId === 'typescript' ||
+        document.languageId === 'javascriptreact' ||
+        document.languageId === 'typescriptreact';
+}
+exports.isTsDocument = isTsDocument;
+function isJsonDocument(document) {
+    return document.languageId === 'json' ||
+        document.languageId === 'jsonc';
+}
+exports.isJsonDocument = isJsonDocument;
+function safeCall(cb) {
+    try {
+        return cb();
+    }
+    catch { }
+}
+exports.safeCall = safeCall;
+//# sourceMappingURL=shared.js.map

package/out/types.d.ts

@@ -0,0 +1,5 @@
+import { ServiceContext } from "@volar/language-service";
+export type SharedContext = ServiceContext & {
+    typescript: NonNullable<ServiceContext['typescript']>;
+    ts: typeof import('typescript/lib/tsserverlibrary');
+};

package/out/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/out/utils/errorCodes.d.ts

@@ -0,0 +1,11 @@
+export declare const variableDeclaredButNeverUsed: Set<number>;
+export declare const propertyDeclaretedButNeverUsed: Set<number>;
+export declare const allImportsAreUnused: Set<number>;
+export declare const unreachableCode: Set<number>;
+export declare const unusedLabel: Set<number>;
+export declare const fallThroughCaseInSwitch: Set<number>;
+export declare const notAllCodePathsReturnAValue: Set<number>;
+export declare const incorrectlyImplementsInterface: Set<number>;
+export declare const cannotFindName: Set<number>;
+export declare const extendsShouldBeImplements: Set<number>;
+export declare const asyncOnlyAllowedInAsyncFunctions: Set<number>;

package/out/utils/errorCodes.js

@@ -0,0 +1,19 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncOnlyAllowedInAsyncFunctions = exports.extendsShouldBeImplements = exports.cannotFindName = exports.incorrectlyImplementsInterface = exports.notAllCodePathsReturnAValue = exports.fallThroughCaseInSwitch = exports.unusedLabel = exports.unreachableCode = exports.allImportsAreUnused = exports.propertyDeclaretedButNeverUsed = exports.variableDeclaredButNeverUsed = void 0;
+exports.variableDeclaredButNeverUsed = new Set([6196, 6133]);
+exports.propertyDeclaretedButNeverUsed = new Set([6138]);
+exports.allImportsAreUnused = new Set([6192]);
+exports.unreachableCode = new Set([7027]);
+exports.unusedLabel = new Set([7028]);
+exports.fallThroughCaseInSwitch = new Set([7029]);
+exports.notAllCodePathsReturnAValue = new Set([7030]);
+exports.incorrectlyImplementsInterface = new Set([2420]);
+exports.cannotFindName = new Set([2552, 2304]);
+exports.extendsShouldBeImplements = new Set([2689]);
+exports.asyncOnlyAllowedInAsyncFunctions = new Set([1308]);
+//# sourceMappingURL=errorCodes.js.map

package/out/utils/fixNames.d.ts

@@ -0,0 +1,13 @@
+export declare const annotateWithTypeFromJSDoc = "annotateWithTypeFromJSDoc";
+export declare const constructorForDerivedNeedSuperCall = "constructorForDerivedNeedSuperCall";
+export declare const extendsInterfaceBecomesImplements = "extendsInterfaceBecomesImplements";
+export declare const awaitInSyncFunction = "fixAwaitInSyncFunction";
+export declare const classIncorrectlyImplementsInterface = "fixClassIncorrectlyImplementsInterface";
+export declare const classDoesntImplementInheritedAbstractMember = "fixClassDoesntImplementInheritedAbstractMember";
+export declare const unreachableCode = "fixUnreachableCode";
+export declare const unusedIdentifier = "unusedIdentifier";
+export declare const forgottenThisPropertyAccess = "forgottenThisPropertyAccess";
+export declare const spelling = "spelling";
+export declare const fixImport = "import";
+export declare const addMissingAwait = "addMissingAwait";
+export declare const addMissingOverride = "fixOverrideModifier";

package/out/utils/fixNames.js

@@ -0,0 +1,21 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMissingOverride = exports.addMissingAwait = exports.fixImport = exports.spelling = exports.forgottenThisPropertyAccess = exports.unusedIdentifier = exports.unreachableCode = exports.classDoesntImplementInheritedAbstractMember = exports.classIncorrectlyImplementsInterface = exports.awaitInSyncFunction = exports.extendsInterfaceBecomesImplements = exports.constructorForDerivedNeedSuperCall = exports.annotateWithTypeFromJSDoc = void 0;
+exports.annotateWithTypeFromJSDoc = 'annotateWithTypeFromJSDoc';
+exports.constructorForDerivedNeedSuperCall = 'constructorForDerivedNeedSuperCall';
+exports.extendsInterfaceBecomesImplements = 'extendsInterfaceBecomesImplements';
+exports.awaitInSyncFunction = 'fixAwaitInSyncFunction';
+exports.classIncorrectlyImplementsInterface = 'fixClassIncorrectlyImplementsInterface';
+exports.classDoesntImplementInheritedAbstractMember = 'fixClassDoesntImplementInheritedAbstractMember';
+exports.unreachableCode = 'fixUnreachableCode';
+exports.unusedIdentifier = 'unusedIdentifier';
+exports.forgottenThisPropertyAccess = 'forgottenThisPropertyAccess';
+exports.spelling = 'spelling';
+exports.fixImport = 'import';
+exports.addMissingAwait = 'addMissingAwait';
+exports.addMissingOverride = 'fixOverrideModifier';
+//# sourceMappingURL=fixNames.js.map

package/out/utils/modifiers.d.ts

@@ -0,0 +1 @@
+export declare function parseKindModifier(kindModifiers: string): Set<string>;

package/out/utils/modifiers.js

@@ -0,0 +1,12 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKindModifier = void 0;
+function parseKindModifier(kindModifiers) {
+    return new Set(kindModifiers.split(/,|\s+/g));
+}
+exports.parseKindModifier = parseKindModifier;
+//# sourceMappingURL=modifiers.js.map

package/out/utils/previewer.d.ts

@@ -0,0 +1,13 @@
+import { SharedContext } from '../types';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type * as Proto from '../protocol';
+export interface IFilePathToResourceConverter {
+    /**
+     * Convert a typescript filepath to a VS Code resource.
+     */
+    toResource(filepath: string): string;
+}
+export declare function plainWithLinks(parts: readonly Proto.SymbolDisplayPart[] | string, filePathConverter: IFilePathToResourceConverter, ctx: SharedContext): string;
+export declare function tagsMarkdownPreview(tags: readonly ts.JSDocTagInfo[], filePathConverter: IFilePathToResourceConverter, ctx: SharedContext): string;
+export declare function markdownDocumentation(documentation: Proto.SymbolDisplayPart[] | string | undefined, tags: ts.JSDocTagInfo[] | undefined, filePathConverter: IFilePathToResourceConverter, ctx: SharedContext): string;
+export declare function addMarkdownDocumentation(out: string, documentation: Proto.SymbolDisplayPart[] | string | undefined, tags: ts.JSDocTagInfo[] | undefined, converter: IFilePathToResourceConverter, ctx: SharedContext): string;