New Research: Supply Chain Attack on Axios Pulls Malicious Dependency from npm.Details →
Socket
Book a DemoSign in
Socket
Book a DemoSign in

vscode-cpptools

Package Overview
Dependencies
Maintainers
1
Versions
27
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

vscode-cpptools - npm Package Compare versions

Comparing version
6.3.0
 to
7.1.1
+8
-3
out/api.d.ts

@@ -13,4 +13,9 @@ import * as vscode from 'vscode';

v6 = 6,
latest = 6
v7 = 7,
latest = 7
}
export type CStandard = "c89" | "c99" | "c11" | "c17" | "c23";
export type GnuCStandard = "gnu89" | "gnu99" | "gnu11" | "gnu17" | "gnu23";
export type CppStandard = "c++98" | "c++03" | "c++11" | "c++14" | "c++17" | "c++20" | "c++23" | "c++26";
export type GnuCppStandard = "gnu++98" | "gnu++03" | "gnu++11" | "gnu++14" | "gnu++17" | "gnu++20" | "gnu++23" | "gnu++26";
/**

@@ -145,3 +150,3 @@ * An interface to allow VS Code extensions to communicate with the C/C++ extension.

*/
readonly standard?: "c89" | "c99" | "c11" | "c17" | "c++98" | "c++03" | "c++11" | "c++14" | "c++17" | "c++20" | "c++23" | "c++26" | "gnu89" | "gnu99" | "gnu11" | "gnu17" | "gnu++98" | "gnu++03" | "gnu++11" | "gnu++14" | "gnu++17" | "gnu++20" | "gnu++23" | "gnu++26";
readonly standard?: CStandard | GnuCStandard | CppStandard | GnuCppStandard;
/**

@@ -223,3 +228,3 @@ * Any files that need to be included before the source file is parsed.

*/
readonly standard?: "c89" | "c99" | "c11" | "c17" | "c++98" | "c++03" | "c++11" | "c++14" | "c++17" | "c++20" | "c++23" | "gnu89" | "gnu99" | "gnu11" | "gnu17" | "gnu++98" | "gnu++03" | "gnu++11" | "gnu++14" | "gnu++17" | "gnu++20" | "gnu++23";
readonly standard?: CStandard | GnuCStandard | CppStandard | GnuCppStandard;
/**

@@ -226,0 +231,0 @@ * The version of the Windows SDK that should be used. This field defaults to the latest Windows SDK

+2
-1
out/api.js

@@ -30,3 +30,4 @@ /* --------------------------------------------------------------------------------------------

Version[Version["v6"] = 6] = "v6";
Version[Version["latest"] = 6] = "latest";
Version[Version["v7"] = 7] = "v7";
Version[Version["latest"] = 7] = "latest";
})(Version = exports.Version || (exports.Version = {}));

@@ -33,0 +34,0 @@ /**

+1
-1
package.json
{
"name": "vscode-cpptools",
"version": "6.3.0",
"version": "7.1.1",
"description": "Public API for vscode-cpptools",

@@ -5,0 +5,0 @@ "typings": "./out/api.d.ts",

-377
api.ts
/* --------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT license.
* ------------------------------------------------------------------------------------------ */
'use strict';
import * as vscode from 'vscode';
/**
* API version information.
*/
export enum Version {
v0 = 0, // 0.x.x
v1 = 1, // 1.x.x
v2 = 2, // 2.x.x
v3 = 3, // 3.x.x
v4 = 4, // 4.x.x
v5 = 5, // 5.x.x
v6 = 6, // 6.x.x
latest = v6
}
/**
* An interface to allow VS Code extensions to communicate with the C/C++ extension.
* @see [CppToolsExtension](#CppToolsExtension) for a code example.
*/
export interface CppToolsApi extends vscode.Disposable {
/**
* The version of the API being used.
*/
getVersion(): Version;
/**
* Register a [CustomConfigurationProvider](#CustomConfigurationProvider).
* This should be called as soon as the provider extension has been activated and determines that
* it is capable of providing configurations for the workspace. The provider extension does not
* need to be ready to provide configurations when this is called. The C/C++ extension will not
* request configurations until the extension has signaled that it is ready to provide them.
* @see [](#)
* @param provider An instance of the [CustomConfigurationProvider](#CustomConfigurationProvider)
* instance representing the provider extension.
*/
registerCustomConfigurationProvider(provider: CustomConfigurationProvider): void;
/**
* Notify the C/C++ extension that the [CustomConfigurationProvider](#CustomConfigurationProvider)
* is ready to provide custom configurations.
* @param provider An instance of the [CustomConfigurationProvider](#CustomConfigurationProvider)
* instance representing the provider extension.
*/
notifyReady(provider: CustomConfigurationProvider): void;
/**
* Notify the C/C++ extension that the current configuration has changed. Upon receiving this
* notification, the C/C++ extension will request the new configurations.
* @param provider An instance of the [CustomConfigurationProvider](#CustomConfigurationProvider)
* instance representing the provider extension.
*/
didChangeCustomConfiguration(provider: CustomConfigurationProvider): void;
/**
* Notify the C/C++ extension that the code browsing configuration has changed. Upon receiving this
* notification, the C/C++ extension will request the new configuration.
* @param provider An instance of the [CustomConfigurationProvider](#CustomConfigurationProvider)
* instance representing the provider extension.
*/
didChangeCustomBrowseConfiguration(provider: CustomConfigurationProvider): void;
}
/**
* An interface to allow this extension to communicate with Custom Configuration Provider extensions.
*/
export interface CustomConfigurationProvider extends vscode.Disposable {
/**
* The friendly name of the Custom Configuration Provider extension.
*/
readonly name: string;
/**
* The id of the extension providing custom configurations. (e.g. `ms-vscode.cpptools`)
*/
readonly extensionId: string;
/**
* A request to determine whether this provider can provide IntelliSense configurations for the given document.
* @param uri The URI of the document.
* @param token (optional) The cancellation token.
* @returns 'true' if this provider can provide IntelliSense configurations for the given document.
*/
canProvideConfiguration(uri: vscode.Uri, token?: vscode.CancellationToken): Thenable<boolean>;
/**
* A request to get Intellisense configurations for the given files.
* @param uris A list of one of more URIs for the files to provide configurations for.
* @param token (optional) The cancellation token.
* @returns A list of [SourceFileConfigurationItem](#SourceFileConfigurationItem) for the documents that this provider
* is able to provide IntelliSense configurations for.
* Note: If this provider cannot provide configurations for any of the files in `uris`, the provider may omit the
* configuration for that file in the return value. An empty array may be returned if the provider cannot provide
* configurations for any of the files requested.
*/
provideConfigurations(uris: vscode.Uri[], token?: vscode.CancellationToken): Thenable<SourceFileConfigurationItem[]>;
/**
* A request to determine whether this provider can provide a code browsing configuration for the workspace folder.
* @param token (optional) The cancellation token.
* @returns 'true' if this provider can provide a code browsing configuration for the workspace folder.
*/
canProvideBrowseConfiguration(token?: vscode.CancellationToken): Thenable<boolean>;
/**
* A request to get the code browsing configuration for the workspace folder.
* @param token (optional) The cancellation token.
* @returns A [WorkspaceBrowseConfiguration](#WorkspaceBrowseConfiguration) with the information required to
* construct the equivalent of `browse.path` from `c_cpp_properties.json`. If there is no configuration to report, or
* the provider indicated that it cannot provide a [WorkspaceBrowseConfiguration](#WorkspaceBrowseConfiguration)
* then `null` should be returned.
*/
provideBrowseConfiguration(token?: vscode.CancellationToken): Thenable<WorkspaceBrowseConfiguration | null>;
/**
* A request to determine whether this provider can provide a code browsing configuration for each folder in a multi-root workspace.
* @param token (optional) The cancellation token.
* @returns 'true' if this provider can provide a code browsing configuration for each folder in a multi-root workspace.
*/
canProvideBrowseConfigurationsPerFolder(token?: vscode.CancellationToken): Thenable<boolean>;
/**
* A request to get the code browsing configuration for the workspace folder.
* @param uri The URI of the folder to provide a browse configuration for.
* @param token (optional) The cancellation token.
* @returns A [WorkspaceBrowseConfiguration](#WorkspaceBrowseConfiguration) with the information required to
* construct the equivalent of `browse.path` from `c_cpp_properties.json`. If there is no configuration for this folder, or
* the provider indicated that it cannot provide a [WorkspaceBrowseConfiguration](#WorkspaceBrowseConfiguration) per folder
* then `null` should be returned.
*/
provideFolderBrowseConfiguration(uri: vscode.Uri, token?: vscode.CancellationToken): Thenable<WorkspaceBrowseConfiguration | null>;
}
/**
* The model representing the custom IntelliSense configurations for a source file.
*/
export interface SourceFileConfiguration {
/**
* This must also include the system include path (compiler defaults) unless
* [compilerPath](#SourceFileConfiguration.compilerPath) is specified.
* Mac framework paths may also be added to this array.
*/
readonly includePath: string[];
/**
* This must also include the compiler default defines (__cplusplus, etc) unless
* [compilerPath](#SourceFileConfiguration.compilerPath) is specified.
*/
readonly defines: string[];
/**
* The platform, compiler, and architecture variant to emulate.
* IntelliSenseMode values without a platform variant will resolve to a value that matches
* the host platform. For example, if the host platform is Windows and the IntelliSenseMode
* is "clang-x64", then "clang-x64" will resolve to "windows-clang-x64".
*/
readonly intelliSenseMode?: "linux-clang-x86" | "linux-clang-x64" | "linux-clang-arm" | "linux-clang-arm64" |
"linux-gcc-x86" | "linux-gcc-x64" | "linux-gcc-arm" | "linux-gcc-arm64" |
"macos-clang-x86" | "macos-clang-x64" | "macos-clang-arm" | "macos-clang-arm64" |
"macos-gcc-x86" | "macos-gcc-x64" | "macos-gcc-arm" | "macos-gcc-arm64" |
"windows-clang-x86" | "windows-clang-x64" | "windows-clang-arm" | "windows-clang-arm64" |
"windows-gcc-x86" | "windows-gcc-x64" | "windows-gcc-arm" | "windows-gcc-arm64" |
"windows-msvc-x86" | "windows-msvc-x64" | "windows-msvc-arm" | "windows-msvc-arm64" |
"msvc-x86" | "msvc-x64" | "msvc-arm" | "msvc-arm64" |
"gcc-x86" | "gcc-x64" | "gcc-arm" | "gcc-arm64" |
"clang-x86" | "clang-x64" | "clang-arm" | "clang-arm64";
/**
* The C or C++ standard to emulate.
*/
readonly standard?: "c89" | "c99" | "c11" | "c17" | "c++98" | "c++03" | "c++11" | "c++14" | "c++17" | "c++20" | "c++23" | "c++26" |
"gnu89" | "gnu99" | "gnu11" | "gnu17" | "gnu++98" | "gnu++03" | "gnu++11" | "gnu++14" | "gnu++17" | "gnu++20" | "gnu++23" | "gnu++26";
/**
* Any files that need to be included before the source file is parsed.
*/
readonly forcedInclude?: string[];
/**
* The full path to the compiler. If specified, the extension will query it for system includes and defines and
* add them to [includePath](#SourceFileConfiguration.includePath) and [defines](#SourceFileConfiguration.defines).
*/
readonly compilerPath?: string;
/**
* Arguments for the compiler. These arguments will not be processed by the shell and should not include any
* shell variables, quoting or escaping.
*/
readonly compilerArgs?: string[];
/**
* Command line fragments for the compiler. These are similar to compiler arguments, but support shell parsed
* content such as shell quoting and escaping.
*/
readonly compilerFragments?: string[];
/**
* The version of the Windows SDK that should be used. This field will only be used if
* [compilerPath](#SourceFileConfiguration.compilerPath) is set and the compiler is capable of targeting Windows.
*/
readonly windowsSdkVersion?: string;
}
/**
* The model representing a source file and its corresponding configuration.
*/
export interface SourceFileConfigurationItem {
/**
* The URI of the source file. It should follow the file URI scheme and represent an absolute path to the file.
* @example
```
// When working with a file path,
// convert it to a vscode.Uri first.
let path: string = ...;
let item: SourceFileConfigurationItem = {
uri: vscode.Uri.file(path),
configuration: ...
};
```
*/
readonly uri: string | vscode.Uri;
/**
* The IntelliSense configuration for [uri](#SourceFileConfigurationItem.uri)
*/
readonly configuration: SourceFileConfiguration;
}
/**
* The model representing the source browsing configuration for a workspace folder.
*/
export interface WorkspaceBrowseConfiguration {
/**
* This must also include the system include path (compiler defaults) unless
* [compilerPath](#WorkspaceBrowseConfiguration.compilerPath) is specified.
*/
readonly browsePath: string[];
/**
* The full path to the compiler. If specified, the extension will query it for system includes and
* add them to [browsePath](#WorkspaceBrowseConfiguration.browsePath).
*/
readonly compilerPath?: string;
/**
* Arguments for the compiler. These arguments will not be processed by the shell and should not include any
* shell variables, quoting or escaping.
*/
readonly compilerArgs?: string[];
/**
* Command line fragments for the compiler. These are similar to compiler arguments, but support shell parsed
* content such as shell quoting and escaping.
*/
readonly compilerFragments?: string[];
/**
* The C or C++ standard to emulate. This field defaults to "c++17" and will only be used if
* [compilerPath](#WorkspaceBrowseConfiguration.compilerPath) is set.
*/
readonly standard?: "c89" | "c99" | "c11" | "c17" | "c++98" | "c++03" | "c++11" | "c++14" | "c++17" | "c++20" | "c++23" |
"gnu89" | "gnu99" | "gnu11" | "gnu17" | "gnu++98" | "gnu++03" | "gnu++11" | "gnu++14" | "gnu++17" | "gnu++20" | "gnu++23";
/**
* The version of the Windows SDK that should be used. This field defaults to the latest Windows SDK
* installed on the PC and will only be used if [compilerPath](#WorkspaceBrowseConfiguration.compilerPath)
* is set and the compiler is capable of targeting Windows.
*/
readonly windowsSdkVersion?: string;
}
/**
* The interface provided by the C/C++ extension during activation.
* It is recommended to use the helper function [getCppToolsApi](#getCppToolsApi) instead
* of querying the extension instance directly.
*/
export interface CppToolsExtension {
/**
* Get an API object.
* @param version The desired version.
*/
getApi(version: Version): CppToolsApi;
}
/**
* Check if an object satisfies the contract of the CppToolsExtension interface.
*/
function isCppToolsExtension(extension: any): extension is CppToolsExtension {
return extension && extension.getApi;
}
/**
* Check if an object satisfies the contract of the first version of the CppToolsApi.
* (The first release of the API only had two functions)
*/
function isLegacyCppToolsApi(api: any): api is CppToolsApi {
return api && api.registerCustomConfigurationProvider && api.didChangeCustomConfiguration
}
/**
* Helper function to get the CppToolsApi from the cpptools extension.
* @param version The desired API version
* @example
```
import {CppToolsApi, Version, CustomConfigurationProvider, getCppToolsApi} from 'vscode-cpptools';
let api: CppToolsApi|undefined = await getCppToolsApi(Version.v1);
if (api) {
// Inform cpptools that a custom config provider
// will be able to service the current workspace.
api.registerCustomConfigurationProvider(provider);
// Do any required setup that the provider needs.
// Notify cpptools that the provider is ready to
// provide IntelliSense configurations.
api.notifyReady(provider);
}
// Dispose of the 'api' in your extension's
// deactivate() method, or whenever you want to
// unregister the provider.
```
*/
export async function getCppToolsApi(version: Version): Promise<CppToolsApi | undefined> {
let cpptools: vscode.Extension<any> | undefined = vscode.extensions.getExtension("ms-vscode.cpptools");
let extension: CppToolsApi | CppToolsExtension | undefined = undefined;
let api: CppToolsApi | undefined = undefined;
if (cpptools) {
if (!cpptools.isActive) {
try {
// activate may throw if VS Code is shutting down.
extension = await cpptools.activate();
} catch {
}
} else {
extension = cpptools.exports;
}
if (isCppToolsExtension(extension)) {
// ms-vscode.cpptools > 0.17.5
try {
api = extension.getApi(version);
} catch (err) {
// Unfortunately, ms-vscode.cpptools [0.17.6, 0.18.1] throws a RangeError if you specify a version greater than v1.
// These versions of the extension will not be able to act on the newer interface and v2 is a superset of v1, so we can safely fall back to v1.
let e: RangeError = <RangeError>err;
if (e && e.message && e.message.startsWith("Invalid version")) {
api = extension.getApi(Version.v1);
}
}
if (version !== Version.v1) {
if (!api.getVersion) {
console.warn(`[vscode-cpptools-api] version ${version} requested, but is not available in the current version of the cpptools extension. Using version 1 instead.`);
} else if (version !== api.getVersion()) {
console.warn(`[vscode-cpptools-api] version ${version} requested, but is not available in the current version of the cpptools extension. Using version ${api.getVersion()} instead.`);
}
}
} else if (isLegacyCppToolsApi(extension)) {
// ms-vscode.cpptools version 0.17.5
api = extension;
if (version !== Version.v0) {
console.warn(`[vscode-cpptools-api] version ${version} requested, but is not available in version 0.17.5 of the cpptools extension. Using version 0 instead.`);
}
} else {
console.warn('[vscode-cpptools-api] No cpptools API was found.')
}
} else {
console.warn('[vscode-cpptools-api] C/C++ extension is not installed');
}
return api;
} 
CODEOWNERS

Sorry, the diff of this file is not supported yet

-73
jobs/cg.yml
name: $(date:yyyyMMdd)$(rev:.r)
trigger:
branches:
include:
- main
schedules:
- cron: 30 5 * * 0
branches:
include:
- main
always: true
resources:
repositories:
- repository: MicroBuildTemplate
type: git
name: 1ESPipelineTemplates/MicroBuildTemplate
ref: refs/tags/release
extends:
template: azure-pipelines/MicroBuild.1ES.Official.yml@MicroBuildTemplate
parameters:
pool:
name: AzurePipelines-EO
image: AzurePipelinesWindows2022compliantGPT
os: windows
sdl:
sourceAnalysisPool:
name: AzurePipelines-EO
image: AzurePipelinesWindows2022compliantGPT
os: windows
policheck:
enabled: true
tsa:
enabled: false
featureFlags:
autoBaseline: false
stages:
- stage: build
jobs:
- job: Phase_1
displayName: Build
timeoutInMinutes: 60
cancelTimeoutInMinutes: 1
templateContext:
outputs:
- output: pipelineArtifact
displayName: 'output'
condition: succeeded()
targetPath: out
artifactName: out
steps:
- checkout: self
- task: UseNode@1
displayName: Use Node 22.x
inputs:
version: 22.x
- script: IF EXIST %SYSTEMDRIVE%\Users\%USERNAME%\.npmrc del %SYSTEMDRIVE%\Users\%USERNAME%\.npmrc
displayName: Delete .npmrc if it exists
- task: Npm@1
displayName: 'npm install'
- task: Npm@1
displayName: 'npm run compile'
inputs:
command: custom
customCommand: 'run compile' 
-41
SECURITY.md
<!-- BEGIN MICROSOFT SECURITY.MD V0.0.7 BLOCK -->
## Security
Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
## Reporting Security Issues
**Please do not report security vulnerabilities through public GitHub issues.**
Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc).
Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
* Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
* Full paths of source file(s) related to the manifestation of the issue
* The location of the affected source code (tag/branch/commit or direct URL)
* Any special configuration required to reproduce the issue
* Step-by-step instructions to reproduce the issue
* Proof-of-concept or exploit code (if possible)
* Impact of the issue, including how an attacker might exploit the issue
This information will help us triage your report more quickly.
If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
## Preferred Languages
We prefer all communications to be in English.
## Policy
Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
<!-- END MICROSOFT SECURITY.MD BLOCK --> 
-115
testApi.ts
/* --------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT license.
* ------------------------------------------------------------------------------------------ */
'use strict';
import { CppToolsApi, CppToolsExtension, Version } from './api';
import * as vscode from 'vscode';
/**
* The interface provided by the C/C++ extension during activation. [CppToolsExtension](#CppToolsExtension)
* is also castable to [CppToolsTestExtension](#CppToolsTestExtension)
*/
export interface CppToolsTestExtension extends CppToolsExtension {
/**
* Get an API object.
* @param version The desired version.
*/
getTestApi(version: Version): CppToolsTestApi;
}
/**
* An interface to grant CustomConfigurationProvider extensions access to a test hook that
* lets tests synchronize with the C/C++ extension.
*/
export interface CppToolsTestApi extends CppToolsApi {
/**
* Get the test hook that will allow the test to register for notifications from the C/C++
* extension.
*/
getTestHook(): CppToolsTestHook;
}
/**
* An interface to allow tests to synchronize with the C/C++ extension
*/
export interface CppToolsTestHook extends vscode.Disposable {
/**
* [Deprecated] Fires when the Tag Parser or IntelliSense engine's status changes.
*/
readonly StatusChanged: vscode.Event<Status>;
/**
* Fires when the status of the Tag Parser or IntelliSense engine changes for an active document.
*/
readonly IntelliSenseStatusChanged: vscode.Event<IntelliSenseStatus>;
}
/**
* Tag Parser or IntelliSense status codes.
*/
export enum Status {
TagParsingBegun = 1,
TagParsingDone = 2,
IntelliSenseCompiling = 3,
IntelliSenseReady = 4,
Idle = 5
}
/**
* Information about the status of Tag Parser or IntelliSense for an active document.
*/
export interface IntelliSenseStatus {
status: Status;
filename?: string;
}
function isCppToolsTestExtension(extension: CppToolsTestApi | CppToolsTestExtension): extension is CppToolsTestExtension {
return (<CppToolsTestExtension>extension).getTestApi !== undefined;
}
export async function getCppToolsTestApi(version: Version): Promise<CppToolsTestApi | undefined> {
let cpptools: vscode.Extension<any> | undefined = vscode.extensions.getExtension("ms-vscode.cpptools");
let extension: CppToolsTestApi | CppToolsTestExtension;
let api: CppToolsTestApi | undefined;
if (cpptools) {
if (!cpptools.isActive) {
extension = await cpptools.activate();
} else {
extension = cpptools.exports;
}
if (isCppToolsTestExtension(extension)) {
// ms-vscode.cpptools > 0.17.5
try {
api = extension.getTestApi(version);
} catch (err) {
// Unfortunately, ms-vscode.cpptools [0.17.6, 0.18.1] throws a RangeError if you specify a version greater than v1.
// These versions of the extension will not be able to act on the newer interface and v2 is a superset of v1, so we can safely fall back to v1.
let e: RangeError = <RangeError>err;
if (e.message && e.message.startsWith("Invalid version")) {
api = extension.getTestApi(Version.v1);
}
}
if (version !== Version.v1) {
if (!api.getVersion) {
console.warn(`vscode-cpptools-api version ${version} requested, but is not available in the current version of the cpptools extension. Using version 1 instead.`);
} else if (version !== api.getVersion()) {
console.warn(`vscode-cpptools-api version ${version} requested, but is not available in the current version of the cpptools extension. Using version ${api.getVersion()} instead.`);
}
}
} else {
// ms-vscode.cpptools version 0.17.5
api = extension;
if (version !== Version.v0) {
console.warn(`vscode-cpptools-api version ${version} requested, but is not available in version 0.17.5 of the cpptools extension. Using version 0 instead.`);
}
}
} else {
console.warn("C/C++ extension is not installed");
}
return api;
} 
-14
tsconfig.json
{
"compilerOptions": {
"module": "commonjs",
"target": "es6",
"noImplicitAny": false,
"sourceMap": false,
"outDir": "out",
"declaration": true
},
"exclude": [
"node_modules",
"out"
]
}