@plusplusoneplusplus/coc 1.0.2 → 1.0.3

package/node_modules/typed-rest-client/Util.d.ts

@@ -0,0 +1,36 @@
+import { IRequestQueryParams, IHttpClientResponse } from './Interfaces';
+/**
+ * creates an url from a request url and optional base url (http://server:8080)
+ * @param {string} resource - a fully qualified url or relative path
+ * @param {string} baseUrl - an optional baseUrl (http://server:8080)
+ * @param {IRequestOptions} options - an optional options object, could include QueryParameters e.g.
+ * @return {string} - resultant url
+ */
+export declare function getUrl(resource: string, baseUrl?: string, queryParams?: IRequestQueryParams): string;
+/**
+ * Decompress/Decode gzip encoded JSON
+ * Using Node.js built-in zlib module
+ *
+ * @param {Buffer} buffer
+ * @param {string} charset? - optional; defaults to 'utf-8'
+ * @return {Promise<string>}
+ */
+export declare function decompressGzippedContent(buffer: Buffer, charset?: BufferEncoding): Promise<string>;
+/**
+ * Builds a RegExp to test urls against for deciding
+ * wether to bypass proxy from an entry of the
+ * environment variable setting NO_PROXY
+ *
+ * @param {string} bypass
+ * @return {RegExp}
+ */
+export declare function buildProxyBypassRegexFromEnv(bypass: string): RegExp;
+/**
+ * Obtain Response's Content Charset.
+ * Through inspecting `content-type` response header.
+ * It Returns 'utf-8' if NO charset specified/matched.
+ *
+ * @param {IHttpClientResponse} response
+ * @return {string} - Content Encoding Charset; Default=utf-8
+ */
+export declare function obtainContentCharset(response: IHttpClientResponse): BufferEncoding;

package/node_modules/typed-rest-client/Util.js

@@ -0,0 +1,147 @@
+"use strict";
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUrl = getUrl;
+exports.decompressGzippedContent = decompressGzippedContent;
+exports.buildProxyBypassRegexFromEnv = buildProxyBypassRegexFromEnv;
+exports.obtainContentCharset = obtainContentCharset;
+const qs = require("qs");
+const url = require("url");
+const path = require("path");
+const zlib = require("zlib");
+/**
+ * creates an url from a request url and optional base url (http://server:8080)
+ * @param {string} resource - a fully qualified url or relative path
+ * @param {string} baseUrl - an optional baseUrl (http://server:8080)
+ * @param {IRequestOptions} options - an optional options object, could include QueryParameters e.g.
+ * @return {string} - resultant url
+ */
+function getUrl(resource, baseUrl, queryParams) {
+    const pathApi = path.posix || path;
+    let requestUrl = '';
+    if (!baseUrl) {
+        requestUrl = resource;
+    }
+    else if (!resource) {
+        requestUrl = baseUrl;
+    }
+    else {
+        const base = url.parse(baseUrl);
+        const resultantUrl = url.parse(resource);
+        // resource (specific per request) elements take priority
+        resultantUrl.protocol = resultantUrl.protocol || base.protocol;
+        resultantUrl.auth = resultantUrl.auth || base.auth;
+        resultantUrl.host = resultantUrl.host || base.host;
+        resultantUrl.pathname = pathApi.resolve(base.pathname, resultantUrl.pathname);
+        if (!resultantUrl.pathname.endsWith('/') && resource.endsWith('/')) {
+            resultantUrl.pathname += '/';
+        }
+        requestUrl = url.format(resultantUrl);
+    }
+    return queryParams ?
+        getUrlWithParsedQueryParams(requestUrl, queryParams) :
+        requestUrl;
+}
+/**
+ *
+ * @param {string} requestUrl
+ * @param {IRequestQueryParams} queryParams
+ * @return {string} - Request's URL with Query Parameters appended/parsed.
+ */
+function getUrlWithParsedQueryParams(requestUrl, queryParams) {
+    const url = requestUrl.replace(/\?$/g, ''); // Clean any extra end-of-string "?" character
+    const parsedQueryParams = qs.stringify(queryParams.params, buildParamsStringifyOptions(queryParams));
+    return `${url}${parsedQueryParams}`;
+}
+/**
+ * Build options for QueryParams Stringifying.
+ *
+ * @param {IRequestQueryParams} queryParams
+ * @return {object}
+ */
+function buildParamsStringifyOptions(queryParams) {
+    let options = {
+        addQueryPrefix: true,
+        delimiter: (queryParams.options || {}).separator || '&',
+        allowDots: (queryParams.options || {}).shouldAllowDots || false,
+        arrayFormat: (queryParams.options || {}).arrayFormat || 'repeat',
+        encodeValuesOnly: (queryParams.options || {}).shouldOnlyEncodeValues || true
+    };
+    return options;
+}
+/**
+ * Decompress/Decode gzip encoded JSON
+ * Using Node.js built-in zlib module
+ *
+ * @param {Buffer} buffer
+ * @param {string} charset? - optional; defaults to 'utf-8'
+ * @return {Promise<string>}
+ */
+function decompressGzippedContent(buffer, charset) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            zlib.gunzip(buffer, function (error, buffer) {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(buffer.toString(charset || 'utf-8'));
+                }
+            });
+        }));
+    });
+}
+/**
+ * Builds a RegExp to test urls against for deciding
+ * wether to bypass proxy from an entry of the
+ * environment variable setting NO_PROXY
+ *
+ * @param {string} bypass
+ * @return {RegExp}
+ */
+function buildProxyBypassRegexFromEnv(bypass) {
+    try {
+        // We need to keep this around for back-compat purposes
+        return new RegExp(bypass, 'i');
+    }
+    catch (err) {
+        if (err instanceof SyntaxError && (bypass || "").startsWith("*")) {
+            let wildcardEscaped = bypass.replace('*', '(.*)');
+            return new RegExp(wildcardEscaped, 'i');
+        }
+        throw err;
+    }
+}
+/**
+ * Obtain Response's Content Charset.
+ * Through inspecting `content-type` response header.
+ * It Returns 'utf-8' if NO charset specified/matched.
+ *
+ * @param {IHttpClientResponse} response
+ * @return {string} - Content Encoding Charset; Default=utf-8
+ */
+function obtainContentCharset(response) {
+    // Find the charset, if specified.
+    // Search for the `charset=CHARSET` string, not including `;,\r\n`
+    // Example: content-type: 'application/json;charset=utf-8'
+    // |__ matches would be ['charset=utf-8', 'utf-8', index: 18, input: 'application/json; charset=utf-8']
+    // |_____ matches[1] would have the charset :tada: , in our example it's utf-8
+    // However, if the matches Array was empty or no charset found, 'utf-8' would be returned by default.
+    const nodeSupportedEncodings = ['ascii', 'utf8', 'utf16le', 'ucs2', 'base64', 'binary', 'hex'];
+    const contentType = response.message.headers['content-type'] || '';
+    const matches = contentType.match(/charset=([^;,\r\n]+)/i);
+    if (matches && matches[1] && nodeSupportedEncodings.indexOf(matches[1]) != -1) {
+        return matches[1];
+    }
+    return 'utf-8';
+}

package/node_modules/typed-rest-client/handlers/basiccreds.d.ts

@@ -0,0 +1,11 @@
+import ifm = require('../Interfaces');
+export declare class BasicCredentialHandler implements ifm.IRequestHandler {
+    username: string;
+    password: string;
+    allowCrossOriginAuthentication: boolean;
+    origin: string;
+    constructor(username: string, password: string, allowCrossOriginAuthentication?: boolean);
+    prepareRequest(options: any): void;
+    canHandleAuthentication(response: ifm.IHttpClientResponse): boolean;
+    handleAuthentication(httpClient: ifm.IHttpClient, requestInfo: ifm.IRequestInfo, objs: any): Promise<ifm.IHttpClientResponse>;
+}

package/node_modules/typed-rest-client/handlers/basiccreds.js

@@ -0,0 +1,32 @@
+"use strict";
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicCredentialHandler = void 0;
+class BasicCredentialHandler {
+    constructor(username, password, allowCrossOriginAuthentication) {
+        this.username = username;
+        this.password = password;
+        this.allowCrossOriginAuthentication = allowCrossOriginAuthentication;
+    }
+    // currently implements pre-authorization
+    // TODO: support preAuth = false where it hooks on 401
+    prepareRequest(options) {
+        if (!this.origin) {
+            this.origin = options.host;
+        }
+        // If this is a redirection, don't set the Authorization header
+        if (this.origin === options.host || this.allowCrossOriginAuthentication) {
+            options.headers['Authorization'] = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString('base64')}`;
+        }
+        options.headers['X-TFS-FedAuthRedirect'] = 'Suppress';
+    }
+    // This handler cannot handle 401
+    canHandleAuthentication(response) {
+        return false;
+    }
+    handleAuthentication(httpClient, requestInfo, objs) {
+        return null;
+    }
+}
+exports.BasicCredentialHandler = BasicCredentialHandler;

package/node_modules/typed-rest-client/handlers/bearertoken.d.ts

@@ -0,0 +1,10 @@
+import ifm = require('../Interfaces');
+export declare class BearerCredentialHandler implements ifm.IRequestHandler {
+    token: string;
+    allowCrossOriginAuthentication: boolean;
+    origin: string;
+    constructor(token: string, allowCrossOriginAuthentication?: boolean);
+    prepareRequest(options: any): void;
+    canHandleAuthentication(response: ifm.IHttpClientResponse): boolean;
+    handleAuthentication(httpClient: ifm.IHttpClient, requestInfo: ifm.IRequestInfo, objs: any): Promise<ifm.IHttpClientResponse>;
+}

package/node_modules/typed-rest-client/handlers/bearertoken.js

@@ -0,0 +1,31 @@
+"use strict";
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BearerCredentialHandler = void 0;
+class BearerCredentialHandler {
+    constructor(token, allowCrossOriginAuthentication) {
+        this.token = token;
+        this.allowCrossOriginAuthentication = allowCrossOriginAuthentication;
+    }
+    // currently implements pre-authorization
+    // TODO: support preAuth = false where it hooks on 401
+    prepareRequest(options) {
+        if (!this.origin) {
+            this.origin = options.host;
+        }
+        // If this is a redirection, don't set the Authorization header
+        if (this.origin === options.host || this.allowCrossOriginAuthentication) {
+            options.headers['Authorization'] = `Bearer ${this.token}`;
+        }
+        options.headers['X-TFS-FedAuthRedirect'] = 'Suppress';
+    }
+    // This handler cannot handle 401
+    canHandleAuthentication(response) {
+        return false;
+    }
+    handleAuthentication(httpClient, requestInfo, objs) {
+        return null;
+    }
+}
+exports.BearerCredentialHandler = BearerCredentialHandler;

package/node_modules/typed-rest-client/handlers/ntlm.d.ts

@@ -0,0 +1,12 @@
+import ifm = require('../Interfaces');
+import http = require("http");
+export declare class NtlmCredentialHandler implements ifm.IRequestHandler {
+    private _ntlmOptions;
+    constructor(username: string, password: string, workstation?: string, domain?: string);
+    prepareRequest(options: http.RequestOptions): void;
+    canHandleAuthentication(response: ifm.IHttpClientResponse): boolean;
+    handleAuthentication(httpClient: ifm.IHttpClient, requestInfo: ifm.IRequestInfo, objs: any): Promise<ifm.IHttpClientResponse>;
+    private handleAuthenticationPrivate;
+    private sendType1Message;
+    private sendType3Message;
+}

package/node_modules/typed-rest-client/handlers/ntlm.js

@@ -0,0 +1,139 @@
+"use strict";
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NtlmCredentialHandler = void 0;
+const http = require("http");
+const https = require("https");
+const _ = require("underscore");
+const ntlm = require("../opensource/Node-SMB/lib/ntlm");
+class NtlmCredentialHandler {
+    constructor(username, password, workstation, domain) {
+        this._ntlmOptions = {};
+        this._ntlmOptions.username = username;
+        this._ntlmOptions.password = password;
+        this._ntlmOptions.domain = domain || '';
+        this._ntlmOptions.workstation = workstation || '';
+    }
+    prepareRequest(options) {
+        // No headers or options need to be set.  We keep the credentials on the handler itself.
+        // If a (proxy) agent is set, remove it as we don't support proxy for NTLM at this time
+        if (options.agent) {
+            delete options.agent;
+        }
+    }
+    canHandleAuthentication(response) {
+        if (response && response.message && response.message.statusCode === 401) {
+            // Ensure that we're talking NTLM here
+            // Once we have the www-authenticate header, split it so we can ensure we can talk NTLM
+            const wwwAuthenticate = response.message.headers['www-authenticate'];
+            return wwwAuthenticate && (wwwAuthenticate.split(', ').indexOf("NTLM") >= 0);
+        }
+        return false;
+    }
+    handleAuthentication(httpClient, requestInfo, objs) {
+        return new Promise((resolve, reject) => {
+            const callbackForResult = function (err, res) {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                // We have to readbody on the response before continuing otherwise there is a hang.
+                res.readBody().then(() => {
+                    resolve(res);
+                });
+            };
+            this.handleAuthenticationPrivate(httpClient, requestInfo, objs, callbackForResult);
+        });
+    }
+    handleAuthenticationPrivate(httpClient, requestInfo, objs, finalCallback) {
+        // Set up the headers for NTLM authentication
+        requestInfo.options = _.extend(requestInfo.options, {
+            username: this._ntlmOptions.username,
+            password: this._ntlmOptions.password,
+            domain: this._ntlmOptions.domain,
+            workstation: this._ntlmOptions.workstation
+        });
+        requestInfo.options.agent = httpClient.isSsl ?
+            new https.Agent({ keepAlive: true }) :
+            new http.Agent({ keepAlive: true });
+        let self = this;
+        // The following pattern of sending the type1 message following immediately (in a setImmediate) is
+        // critical for the NTLM exchange to happen.  If we removed setImmediate (or call in a different manner)
+        // the NTLM exchange will always fail with a 401.
+        this.sendType1Message(httpClient, requestInfo, objs, function (err, res) {
+            if (err) {
+                return finalCallback(err, null, null);
+            }
+            /// We have to readbody on the response before continuing otherwise there is a hang.
+            res.readBody().then(() => {
+                // It is critical that we have setImmediate here due to how connection requests are queued.
+                // If setImmediate is removed then the NTLM handshake will not work.
+                // setImmediate allows us to queue a second request on the same connection. If this second
+                // request is not queued on the connection when the first request finishes then node closes
+                // the connection. NTLM requires both requests to be on the same connection so we need this.
+                setImmediate(function () {
+                    self.sendType3Message(httpClient, requestInfo, objs, res, finalCallback);
+                });
+            });
+        });
+    }
+    // The following method is an adaptation of code found at https://github.com/SamDecrock/node-http-ntlm/blob/master/httpntlm.js
+    sendType1Message(httpClient, requestInfo, objs, finalCallback) {
+        const type1HexBuffer = ntlm.encodeType1(this._ntlmOptions.workstation, this._ntlmOptions.domain);
+        const type1msg = `NTLM ${type1HexBuffer.toString('base64')}`;
+        const type1options = {
+            headers: {
+                'Connection': 'keep-alive',
+                'Authorization': type1msg
+            },
+            timeout: requestInfo.options.timeout || 0,
+            agent: requestInfo.httpModule,
+        };
+        const type1info = {};
+        type1info.httpModule = requestInfo.httpModule;
+        type1info.parsedUrl = requestInfo.parsedUrl;
+        type1info.options = _.extend(type1options, _.omit(requestInfo.options, 'headers'));
+        return httpClient.requestRawWithCallback(type1info, objs, finalCallback);
+    }
+    // The following method is an adaptation of code found at https://github.com/SamDecrock/node-http-ntlm/blob/master/httpntlm.js
+    sendType3Message(httpClient, requestInfo, objs, res, callback) {
+        if (!res.message.headers && !res.message.headers['www-authenticate']) {
+            throw new Error('www-authenticate not found on response of second request');
+        }
+        /**
+         * Server will respond with challenge/nonce
+         * assigned to response's "WWW-AUTHENTICATE" header
+         * and should adhere to RegExp /^NTLM\s+(.+?)(,|\s+|$)/
+         */
+        const serverNonceRegex = /^NTLM\s+(.+?)(,|\s+|$)/;
+        const serverNonce = Buffer.from((res.message.headers['www-authenticate'].match(serverNonceRegex) || [])[1], 'base64');
+        let type2msg;
+        /**
+         * Wrap decoding the Server's challenge/nonce in
+         * try-catch block to throw more comprehensive
+         * Error with clear message to consumer
+         */
+        try {
+            type2msg = ntlm.decodeType2(serverNonce);
+        }
+        catch (error) {
+            throw new Error(`Decoding Server's Challenge to Obtain Type2Message failed with error: ${error.message}`);
+        }
+        const type3msg = ntlm.encodeType3(this._ntlmOptions.username, this._ntlmOptions.workstation, this._ntlmOptions.domain, type2msg, this._ntlmOptions.password).toString('base64');
+        const type3options = {
+            headers: {
+                'Authorization': `NTLM ${type3msg}`,
+                'Connection': 'Close'
+            },
+            agent: requestInfo.httpModule,
+        };
+        const type3info = {};
+        type3info.httpModule = requestInfo.httpModule;
+        type3info.parsedUrl = requestInfo.parsedUrl;
+        type3options.headers = _.extend(type3options.headers, requestInfo.options.headers);
+        type3info.options = _.extend(type3options, _.omit(requestInfo.options, 'headers'));
+        return httpClient.requestRawWithCallback(type3info, objs, callback);
+    }
+}
+exports.NtlmCredentialHandler = NtlmCredentialHandler;

package/node_modules/typed-rest-client/handlers/personalaccesstoken.d.ts

@@ -0,0 +1,10 @@
+import ifm = require('../Interfaces');
+export declare class PersonalAccessTokenCredentialHandler implements ifm.IRequestHandler {
+    token: string;
+    allowCrossOriginAuthentication: boolean;
+    origin: string;
+    constructor(token: string, allowCrossOriginAuthentication?: boolean);
+    prepareRequest(options: any): void;
+    canHandleAuthentication(response: ifm.IHttpClientResponse): boolean;
+    handleAuthentication(httpClient: ifm.IHttpClient, requestInfo: ifm.IRequestInfo, objs: any): Promise<ifm.IHttpClientResponse>;
+}

package/node_modules/typed-rest-client/handlers/personalaccesstoken.js

@@ -0,0 +1,31 @@
+"use strict";
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersonalAccessTokenCredentialHandler = void 0;
+class PersonalAccessTokenCredentialHandler {
+    constructor(token, allowCrossOriginAuthentication) {
+        this.token = token;
+        this.allowCrossOriginAuthentication = allowCrossOriginAuthentication;
+    }
+    // currently implements pre-authorization
+    // TODO: support preAuth = false where it hooks on 401
+    prepareRequest(options) {
+        if (!this.origin) {
+            this.origin = options.host;
+        }
+        // If this is a redirection, don't set the Authorization header
+        if (this.origin === options.host || this.allowCrossOriginAuthentication) {
+            options.headers['Authorization'] = `Basic ${Buffer.from(`PAT:${this.token}`).toString('base64')}`;
+        }
+        options.headers['X-TFS-FedAuthRedirect'] = 'Suppress';
+    }
+    // This handler cannot handle 401
+    canHandleAuthentication(response) {
+        return false;
+    }
+    handleAuthentication(httpClient, requestInfo, objs) {
+        return null;
+    }
+}
+exports.PersonalAccessTokenCredentialHandler = PersonalAccessTokenCredentialHandler;

package/node_modules/typed-rest-client/opensource/Node-SMB/README.md

@@ -0,0 +1,5 @@
+### Reference:
+The modules (common.js, ntlm.js and smbhash.js) were copied from a file of the same name at https://github.com/Node-SMB/ntlm.
+
+The modules has been used for the purpose of encoding and decoding the headers used during NTLM HTTP Authentication and as of this writing, it is a part of the typed-rest-client module produced by Microsoft.
+

package/node_modules/typed-rest-client/opensource/Node-SMB/lib/common.js

@@ -0,0 +1,61 @@
+var crypto = require('crypto');
+
+function zeroextend(str, len)
+{
+  while (str.length < len)
+    str = '0' + str;
+  return (str);
+}
+
+/*
+ * Fix (odd) parity bits in a 64-bit DES key.
+ */
+function oddpar(buf)
+{
+  for (var j = 0; j < buf.length; j++) {
+    var par = 1;
+    for (var i = 1; i < 8; i++) {
+      par = (par + ((buf[j] >> i) & 1)) % 2;
+    }
+    buf[j] |= par & 1;
+  }
+  return buf;
+}
+
+/*
+ * Expand a 56-bit key buffer to the full 64-bits for DES.
+ *
+ * Based on code sample in:
+ *    http://www.innovation.ch/personal/ronald/ntlm.html
+ */
+function expandkey(key56)
+{
+  var key64 = Buffer.alloc(8);
+
+  key64[0] = key56[0] & 0xFE;
+  key64[1] = ((key56[0] << 7) & 0xFF) | (key56[1] >> 1);
+  key64[2] = ((key56[1] << 6) & 0xFF) | (key56[2] >> 2);
+  key64[3] = ((key56[2] << 5) & 0xFF) | (key56[3] >> 3);
+  key64[4] = ((key56[3] << 4) & 0xFF) | (key56[4] >> 4);
+  key64[5] = ((key56[4] << 3) & 0xFF) | (key56[5] >> 5);
+  key64[6] = ((key56[5] << 2) & 0xFF) | (key56[6] >> 6);
+  key64[7] =  (key56[6] << 1) & 0xFF;
+
+  return key64;
+}
+
+/*
+ * Convert a binary string to a hex string
+ */
+function bintohex(bin)
+{
+  var buf = (Buffer.isBuffer(buf) ? buf : Buffer.from(bin, 'binary'));
+  var str = buf.toString('hex').toUpperCase();
+  return zeroextend(str, 32);
+}
+
+
+module.exports.zeroextend = zeroextend;
+module.exports.oddpar = oddpar;
+module.exports.expandkey = expandkey;
+module.exports.bintohex = bintohex;