@bratel/dgit 0.0.13

package/lib/cmd/prompt.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordPrompt = exports.DownloadPrompt = exports.CreatePrompt = void 0;
+const tslib_1 = require("tslib");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+exports.CreatePrompt = (questions) => inquirer_1.default.prompt(questions);
+exports.DownloadPrompt = (currentInfo) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (currentInfo.owner &&
+        currentInfo.repoName &&
+        currentInfo.ref &&
+        currentInfo.relativePath &&
+        currentInfo.dest)
+        return currentInfo;
+    const questions = [
+        {
+            type: 'input',
+            name: 'owner',
+            when() {
+                return !currentInfo.owner;
+            },
+            validate(input) {
+                return input && input.length > 0;
+            },
+            message: 'input github ownername.',
+        },
+        {
+            type: 'input',
+            name: 'repoName',
+            when() {
+                return !currentInfo.repoName;
+            },
+            validate(input) {
+                return input && input.length > 0;
+            },
+            message: 'input github repoName.',
+        },
+        {
+            type: 'input',
+            name: 'ref',
+            when() {
+                return !currentInfo.ref;
+            },
+            validate(input) {
+                return input && input.length > 0;
+            },
+            'default': 'master',
+            message: 'input github branch or commit hash or tagname.',
+        },
+        {
+            type: 'input',
+            name: 'relativePath',
+            when() {
+                return !currentInfo.relativePath;
+            },
+            validate(input) {
+                return input && input.length > 0;
+            },
+            'default': '.',
+            message: 'input github relative path.',
+        },
+        {
+            type: 'input',
+            name: 'dest',
+            when() {
+                return !currentInfo.dest;
+            },
+            validate(input) {
+                return input && input.length > 0;
+            },
+            'default': '.',
+            message: 'input template output dest path.',
+        },
+    ];
+    const answer = yield exports.CreatePrompt(questions);
+    return {
+        owner: answer.owner || currentInfo.owner,
+        dest: answer.dest || currentInfo.dest,
+        repoName: answer.repoName || currentInfo.repoName,
+        relativePath: answer.relativePath || currentInfo.relativePath,
+        ref: answer.ref || currentInfo.ref,
+    };
+});
+exports.PasswordPrompt = () => {
+    const question = {
+        type: 'password',
+        name: 'password',
+        validate(input) {
+            return input && input.length > 0;
+        },
+        message: 'input github account password.',
+    };
+    return exports.CreatePrompt([question]);
+};

package/lib/cmd/type.d.ts

@@ -0,0 +1,37 @@
+export interface PackageInfo {
+    version: string;
+    name: string;
+}
+export interface CommandInfo {
+    dest?: string;
+    owner?: string;
+    repoName?: string;
+    ref?: string;
+    relativePath?: string;
+    parallelLimit?: string;
+    username?: string;
+    password?: string;
+    token?: string;
+    exclude?: string;
+    include?: string;
+    log?: boolean;
+    logPrefix?: string;
+    proxy?: string;
+}
+export interface DownloadPromptInfo {
+    dest: string;
+    owner: string;
+    repoName: string;
+    ref: string;
+    relativePath: string;
+}
+export interface GithubLinkInfo {
+    owner: string;
+    repoName: string;
+    ref: string;
+    relativePath: string;
+    type: string;
+}
+export interface PasswordPromptInfo {
+    password: string;
+}

package/lib/cmd/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cmd/utils.d.ts

@@ -0,0 +1,8 @@
+import { PackageInfo, GithubLinkInfo } from './type';
+export declare const GetPackageInfo: () => PackageInfo;
+export declare const GITHUB_ADDRESS = "https://github.com/";
+export declare const isHttpsLink: (link: string) => boolean;
+export declare const ParseGithubHttpsLink: (httpsLink: string) => GithubLinkInfo;
+export declare const TextEllipsis: (text: string, maxLen: number) => string;
+export declare const MakeDirs: (dirs: string) => void;
+export declare const AddExtraRandomQs: (origin: string) => string;

package/lib/cmd/utils.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddExtraRandomQs = exports.MakeDirs = exports.TextEllipsis = exports.ParseGithubHttpsLink = exports.isHttpsLink = exports.GITHUB_ADDRESS = exports.GetPackageInfo = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+exports.GetPackageInfo = () => {
+    const buffer = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../package.json'));
+    return JSON.parse(buffer.toString());
+};
+exports.GITHUB_ADDRESS = 'https://github.com/';
+exports.isHttpsLink = (link) => link.trim().startsWith(exports.GITHUB_ADDRESS);
+exports.ParseGithubHttpsLink = (httpsLink) => {
+    let nextLink = httpsLink.trim().slice(exports.GITHUB_ADDRESS.length);
+    let index = nextLink.indexOf('/');
+    if (index === -1)
+        throw new Error('invalid github address.');
+    const owner = nextLink.slice(0, index);
+    nextLink = nextLink.slice(owner.length + 1);
+    index = nextLink.indexOf('/');
+    let repoName;
+    if (index === -1) {
+        repoName = nextLink.slice(0);
+        if (!repoName)
+            throw new Error('invalid github address.');
+        return {
+            owner,
+            repoName,
+            ref: 'master',
+            relativePath: '',
+            type: 'tree',
+        };
+    }
+    repoName = nextLink.slice(0, index);
+    nextLink = nextLink.slice(repoName.length + 1);
+    index = nextLink.indexOf('/');
+    let ref = 'master';
+    let relativePath = '';
+    let type = 'tree';
+    if (index === -1) {
+        if (repoName.endsWith('.git')) {
+            const lastIndex = -4;
+            repoName = repoName.slice(0, lastIndex);
+        }
+    }
+    else {
+        type = nextLink.slice(0, index);
+        nextLink = nextLink.slice(type.length + 1);
+        index = nextLink.indexOf('/');
+        if (index === -1) {
+            ref = nextLink.slice(0) || 'master';
+        }
+        else {
+            ref = nextLink.slice(0, index);
+            relativePath = nextLink.slice(ref.length + 1);
+        }
+    }
+    return {
+        owner,
+        repoName,
+        ref,
+        relativePath,
+        type,
+    };
+};
+exports.TextEllipsis = (text, maxLen) => (text.length >= maxLen ? `${text.slice(0, maxLen)}...` : text);
+exports.MakeDirs = (dirs) => {
+    const mkdirs = (dir, callback) => {
+        if (fs_1.default.existsSync(dir)) {
+            callback && callback();
+            return;
+        }
+        mkdirs(path_1.default.dirname(dir), () => {
+            fs_1.default.mkdirSync(dir);
+            callback && callback();
+        });
+    };
+    if (fs_1.default.existsSync(dirs))
+        return;
+    mkdirs(dirs);
+};
+exports.AddExtraRandomQs = (origin) => {
+    if (origin.indexOf('?') !== -1) {
+        return `${origin}&_t=${Math.random()}`;
+    }
+    return `${origin}?_t=${Math.random()}`;
+};

package/lib/dgit.d.ts

@@ -0,0 +1,3 @@
+import { DgitGlobalOption, RepoOptionType, DgitLifeCycle, DgitLoadGitTree } from './type';
+declare const dgit: (repoOption: RepoOptionType, dPath: string, dgitOptions?: DgitGlobalOption | undefined, hooks?: (DgitLifeCycle & DgitLoadGitTree) | undefined) => Promise<void>;
+export default dgit;

package/lib/dgit.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const async_1 = tslib_1.__importDefault(require("async"));
+const repo_1 = tslib_1.__importDefault(require("./repo"));
+const log_1 = require("./log");
+const request_1 = require("./request");
+const utils_1 = require("./cmd/utils");
+const UserAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36';
+const DEFAULT_PARALLEL_LIMIT = 10;
+const MAX_PARALLEL_LIMIT = 100;
+const JSON_STRINGIFY_PADDING = 2;
+const dgit = (repoOption, dPath, dgitOptions, hooks) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { username, password, token, githubLink, proxy = '', } = repoOption;
+    let { owner, repoName, ref = 'master', relativePath = '.', } = repoOption;
+    if (githubLink && utils_1.isHttpsLink(githubLink)) {
+        const parseResult = utils_1.ParseGithubHttpsLink(githubLink);
+        owner = parseResult.owner;
+        repoName = parseResult.repoName;
+        ref = parseResult.ref;
+        relativePath = parseResult.relativePath;
+    }
+    if (!owner || !repoName) {
+        throw new Error('invalid repo option.');
+    }
+    const logger = log_1.createLogger(dgitOptions);
+    const { exclude = [], include = [] } = dgitOptions || {};
+    let { parallelLimit = DEFAULT_PARALLEL_LIMIT } = dgitOptions || {};
+    if (!parallelLimit || parallelLimit <= 0) {
+        logger('parallelLimit value is invalid.');
+        parallelLimit = DEFAULT_PARALLEL_LIMIT;
+    }
+    parallelLimit > MAX_PARALLEL_LIMIT && (parallelLimit = MAX_PARALLEL_LIMIT);
+    const { onSuccess, onError, onProgress, onFinish, onRetry, onResolved, beforeLoadTree, afterLoadTree, } = hooks || {};
+    let onSuccessResolve = () => { };
+    let onErrorReject = () => { };
+    const prom = new Promise((resolve, reject) => {
+        onSuccessResolve = resolve;
+        onErrorReject = reject;
+    });
+    const { getRepoTreeUrl, getDownloadUrl } = repo_1.default(owner, repoName, ref, proxy);
+    const url = getRepoTreeUrl();
+    const headers = {
+        'User-Agent': UserAgent,
+        Authorization: token ? `token ${token}` : undefined,
+    };
+    const auth = username && password ?
+        {
+            user: username,
+            pass: password,
+            sendImmediately: true,
+        } :
+        undefined;
+    const options = {
+        url, headers, auth,
+    };
+    const destPath = path_1.default.isAbsolute(dPath) ? dPath : path_1.default.resolve(process.cwd(), dPath);
+    logger(' request repo tree options.');
+    logger(JSON.stringify(options, null, JSON_STRINGIFY_PADDING));
+    try {
+        logger(' loading remote repo tree...');
+        beforeLoadTree && beforeLoadTree();
+        const body = yield request_1.requestGetPromise(options, dgitOptions || {}, {
+            onRetry() {
+                logger(` request ${url} failed. Retrying...`);
+                onRetry && onRetry();
+            },
+        });
+        logger(' loading remote repo tree succeed.');
+        afterLoadTree && afterLoadTree();
+        const result = JSON.parse(body);
+        if (!result.tree || result.tree.length <= 0) {
+            throw new Error('404 repo not found!');
+        }
+        const treeNodeList = result.tree;
+        const includeTreeNodeList = treeNodeList.filter(node => {
+            const nPath = path_1.default.resolve(__dirname, node.path);
+            const rPath = path_1.default.resolve(__dirname, relativePath);
+            if (!nPath.startsWith(rPath) || node.type !== 'blob') {
+                return false;
+            }
+            if (exclude.some(v => nPath.startsWith(path_1.default.resolve(rPath, v))) &&
+                include.every(v => !nPath.startsWith(path_1.default.resolve(rPath, v)))) {
+                return false;
+            }
+            return true;
+        });
+        if (includeTreeNodeList.length <= 0) {
+            throw new Error(`404 repo ${relativePath} not found!`);
+        }
+        const totalStatus = includeTreeNodeList.reduce((prev, cur) => {
+            if (cur.type === 'blob') {
+                prev.size += cur.size;
+                prev.count++;
+            }
+            return prev;
+        }, { size: 0, count: 0 });
+        let currentSize = 0;
+        let currentCount = 0;
+        onResolved &&
+            onResolved({
+                currentSize,
+                currentCount,
+                totalSize: totalStatus.size,
+                totalCount: totalStatus.count,
+            });
+        logger(' include files resolved.');
+        logger('', JSON.stringify({
+            currentSize,
+            currentCount,
+            totalSize: totalStatus.size,
+            totalCount: totalStatus.count,
+        }));
+        async_1.default.eachLimit(includeTreeNodeList, parallelLimit, (node, callback) => {
+            const downloadUrl = getDownloadUrl(node.path);
+            const rPath = path_1.default.resolve(destPath, relativePath);
+            const tPath = path_1.default.resolve(destPath, node.path);
+            const root = path_1.default.resolve(destPath, '.');
+            let targetPath;
+            if (rPath === tPath) {
+                targetPath = path_1.default.resolve(destPath, path_1.default.basename(tPath));
+            }
+            else {
+                targetPath = tPath.replace(rPath, root);
+            }
+            logger('', node.path, relativePath, targetPath);
+            if (!fs_1.default.existsSync(path_1.default.dirname(targetPath))) {
+                utils_1.MakeDirs(path_1.default.dirname(targetPath));
+            }
+            const ws = fs_1.default.createWriteStream(targetPath);
+            logger(` downloading from ${downloadUrl}...`);
+            request_1.requestOnStream(downloadUrl, ws, dgitOptions || {}, {
+                onSuccess() {
+                    currentCount++;
+                    currentSize += node.size;
+                    logger(` write file ${node.path} succeed. 
+                            size: [${currentSize}/${totalStatus.size}], 
+                            count: [${currentCount}/${totalStatus.count}]`);
+                    onProgress &&
+                        onProgress({
+                            totalCount: totalStatus.count,
+                            totalSize: totalStatus.size,
+                            currentSize,
+                            currentCount,
+                        }, node);
+                    callback();
+                },
+                onError(err) {
+                    logger('', err);
+                    callback(new Error(` request ${downloadUrl} failed.`));
+                },
+                onRetry() {
+                    logger(` request ${downloadUrl} failed. Retrying...`);
+                    onRetry && onRetry();
+                },
+            });
+        }, err => {
+            if (err) {
+                onError && onError(err);
+                onFinish && onFinish();
+                onErrorReject(err);
+            }
+            else {
+                onSuccess && onSuccess();
+                onFinish && onFinish();
+                onSuccessResolve();
+            }
+        });
+    }
+    catch (error) {
+        onError && onError(error);
+        onFinish && onFinish();
+        onErrorReject(error);
+    }
+    return prom;
+});
+exports.default = dgit;

package/lib/log.d.ts

@@ -0,0 +1,2 @@
+import { DgitGlobalOption } from './type';
+export declare const createLogger: (option?: DgitGlobalOption | undefined) => (...message: any[]) => void;

package/lib/log.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = void 0;
+const DEFAULT_PREFIX = '[dgit-logger]';
+exports.createLogger = (option) => (...message) => {
+    if (option && option.log) {
+        const prefix = option ?
+            option.logPrefix || DEFAULT_PREFIX :
+            DEFAULT_PREFIX;
+        console.log(prefix, ...message, '\n');
+    }
+};

package/lib/repo.d.ts

@@ -0,0 +1,5 @@
+declare const repoUtils: (owner: string, repoName: string, ref: string, proxy: string) => {
+    getRepoTreeUrl: () => string;
+    getDownloadUrl: (path: string) => string;
+};
+export default repoUtils;

package/lib/repo.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const repoUtils = (owner, repoName, ref, proxy) => ({
+    getRepoTreeUrl: () => `https://api.github.com/repos/${owner}/${repoName}/git/trees/${ref}?recursive=1`,
+    getDownloadUrl: (path) => `${proxy ? `${proxy}/` : ''}https://raw.githubusercontent.com/${owner}/${repoName}/${ref}/${path}`,
+});
+exports.default = repoUtils;

package/lib/request.d.ts

@@ -0,0 +1,7 @@
+import fs from 'fs';
+import { UrlOptions, CoreOptions } from 'request';
+import { DgitGlobalOption, DgitLifeCycle } from './type';
+declare type RequestOption = UrlOptions & CoreOptions;
+export declare const requestGetPromise: (options: RequestOption, dgitOptions: DgitGlobalOption, hooks?: DgitLifeCycle | undefined) => Promise<any>;
+export declare const requestOnStream: (url: string, ws: fs.WriteStream, dgitOptions: DgitGlobalOption, hooks?: DgitLifeCycle | undefined) => void;
+export {};

package/lib/request.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestOnStream = exports.requestGetPromise = void 0;
+const tslib_1 = require("tslib");
+const request_1 = tslib_1.__importDefault(require("request"));
+const utils_1 = require("./cmd/utils");
+const log_1 = require("./log");
+const REQUEST_RETRY_DELAY = 1500;
+const DEFAULT_MAX_RETRY_COUNT = 5;
+const requestGet = (options, maxRetryCount, hooks) => {
+    const { onSuccess, onError, onFinish, onRetry, } = hooks || {};
+    request_1.default.get(options, (err, _, body) => {
+        if (err) {
+            if (maxRetryCount < 1) {
+                onError && onError(err);
+                onFinish && onFinish();
+                return;
+            }
+            setTimeout(() => {
+                onRetry && onRetry();
+                requestGet(options, maxRetryCount - 1, hooks);
+            }, REQUEST_RETRY_DELAY);
+            return;
+        }
+        onSuccess && onSuccess(body);
+        onFinish && onFinish();
+    });
+};
+exports.requestGetPromise = (options, dgitOptions, hooks) => new Promise((resolve, reject) => {
+    const { maxRetryCount = DEFAULT_MAX_RETRY_COUNT } = dgitOptions;
+    const { onSuccess, onError, onFinish, onRetry, } = hooks || {};
+    const newHooks = {
+        onSuccess(data) {
+            resolve(data);
+            onSuccess && onSuccess(data);
+        },
+        onError(err) {
+            reject(err);
+            onError && onError(err);
+        },
+        onFinish,
+        onRetry,
+    };
+    requestGet(options, maxRetryCount, newHooks);
+});
+exports.requestOnStream = (url, ws, dgitOptions, hooks) => {
+    const { maxRetryCount = DEFAULT_MAX_RETRY_COUNT } = dgitOptions;
+    const logger = log_1.createLogger(dgitOptions);
+    const { onSuccess, onError, onFinish, onRetry, } = hooks || {};
+    const fn = (retryCount) => {
+        const downloadUrl = utils_1.AddExtraRandomQs(url);
+        logger(` dowloading from ${downloadUrl}...`);
+        request_1.default(encodeURI(downloadUrl))
+            .on('error', err => {
+            if (retryCount <= 0) {
+                onError && onError(err);
+                onFinish && onFinish();
+                return;
+            }
+            setTimeout(() => {
+                onRetry && onRetry();
+                fn(retryCount - 1);
+            }, REQUEST_RETRY_DELAY);
+        })
+            .pipe(ws);
+    };
+    ws.on('finish', () => {
+        onSuccess && onSuccess();
+        onFinish && onFinish();
+    });
+    ws.on('error', () => {
+        logger(` ${url}, write stream failed.`);
+    });
+    fn(maxRetryCount);
+};

package/lib/type.d.ts

@@ -0,0 +1,53 @@
+export declare type GithubRelativePath = string;
+export interface DgitGlobalOption {
+    maxRetryCount?: number;
+    parallelLimit?: number;
+    log?: boolean;
+    logPrefix?: string;
+    exclude?: GithubRelativePath[];
+    include?: GithubRelativePath[];
+}
+export interface PrivateOption {
+    username?: string;
+    password?: string;
+    token?: string;
+}
+export interface RepoOptionType extends PrivateOption {
+    owner?: string;
+    repoName?: string;
+    ref?: string;
+    relativePath?: string;
+    githubLink?: string;
+    proxy?: string;
+}
+export interface RepoTreeNode {
+    path: string;
+    type: 'blob' | 'tree';
+    size: number;
+    url: string;
+}
+export interface DgitLifeCycle {
+    onSuccess?: (data?: any) => void;
+    onError?: (err?: any) => void;
+    onFinish?: () => void;
+    onRetry?: () => void;
+    onProgress?: (status: ProgressStatus, node: RepoTreeNode) => void;
+    onResolved?: (status: ProgressStatus) => void;
+}
+export interface DgitLoadGitTree {
+    beforeLoadTree?: () => void;
+    afterLoadTree?: () => void;
+}
+export interface ProgressStatus {
+    currentSize: number;
+    currentCount: number;
+    totalCount: number;
+    totalSize: number;
+}
+export interface GithubLinkInfo {
+    owner: string;
+    repoName: string;
+    ref: string;
+    relativePath: string;
+    type: string;
+}

package/lib/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@bratel/dgit",
+  "version": "0.0.13",
+  "description": "@dking/hasaki-cli init application",
+  "bin": {
+    "dgit": "./bin/cmd.js"
+  },
+  "main": "./lib/dgit.js",
+  "types": "./lib/dgit.d.ts",
+  "keywords": [
+    "dgit",
+    "github download tool"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lsq/dgit"
+  },
+   "publishConfig": {
+    "access": "public"
+  },
+ "author": "JohnApache",
+  "license": "MIT",
+  "scripts": {
+    "build:ts": "tsc --build",
+    "lint": "eslint src --ext .jsx --ext .js --ext .tsx --ext .ts --cache --fix",
+    "test:mocha": "nyc --reporter=text mocha --require ts-node/register 'test/**/*.{ts,tsx}' -t 60000",
+    "test:mocha:reporter": "nyc --reporter=lcov --reporter=text mocha --require ts-node/register 'test/**/*.{ts,tsx}' -t 60000 --reporter=mochawesome",
+    "watch:ts": "tsc --watch",
+    "prepublishOnly": "npm run test:mocha && npm run lint && npm run build:ts"
+  },
+  "lint-staged": {
+    "**/*.{jsx,js}": [
+      "npm run lint",
+      "git add"
+    ]
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "devDependencies": {
+    "@dking/eslint-config-typescript": "^0.0.4",
+    "@types/chai": "^4.2.0",
+    "@types/mocha": "^5.2.7",
+    "@types/node": "^12.7.5",
+    "@typescript-eslint/eslint-plugin": "^2.13.0",
+    "@typescript-eslint/parser": "^2.13.0",
+    "chai": "^4.2.0",
+    "eslint": "^6.8.0",
+    "eslint-import-resolver-typescript": "^2.0.0",
+    "eslint-plugin-import": "^2.19.1",
+    "eslint-plugin-promise": "^4.1.1",
+    "husky": "^2.3.0",
+    "lint-staged": "^8.1.7",
+    "mocha": "^6.2.0",
+    "mochawesome": "^4.1.0",
+    "nyc": "^14.1.1",
+    "ts-node": "^8.3.0",
+    "typescript": "^3.7.4"
+  },
+  "dependencies": {
+    "@types/async": "^3.0.3",
+    "@types/commander": "^2.12.2",
+    "@types/inquirer": "^6.5.0",
+    "@types/ora": "^3.2.0",
+    "@types/progress": "^2.0.3",
+    "@types/request": "^2.48.3",
+    "async": "^3.1.0",
+    "chalk": "^3.0.0",
+    "commander": "^4.0.1",
+    "inquirer": "^7.0.0",
+    "ora": "^4.0.3",
+    "progress": "^2.0.3",
+    "request": "^2.88.0"
+  }
+}