@plusplusoneplusplus/coc 1.0.5 → 1.0.6

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

@@ -1,36 +0,0 @@
-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

@@ -1,147 +0,0 @@
-"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

@@ -1,11 +0,0 @@
-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

@@ -1,32 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

@@ -1,31 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,139 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

@@ -1,31 +0,0 @@
-"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

@@ -1,5 +0,0 @@
-### 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

@@ -1,61 +0,0 @@
-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;