@rsdoctor/utils 1.2.2 → 1.2.4-beta.0

package/dist/ruleUtils.js

@@ -0,0 +1,256 @@
+import { LinesAndColumns } from "lines-and-columns";
+import { Parser, parse } from "acorn";
+import { importAttributes } from "acorn-import-attributes";
+import * as __WEBPACK_EXTERNAL_MODULE_acorn_walk_9c3ac672__ from "acorn-walk";
+var ECMAVersion, __webpack_require__ = {};
+__webpack_require__.d = (exports, definition)=>{
+    for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key) && Object.defineProperty(exports, key, {
+        enumerable: !0,
+        get: definition[key]
+    });
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = (exports)=>{
+    'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports, Symbol.toStringTag, {
+        value: 'Module'
+    }), Object.defineProperty(exports, '__esModule', {
+        value: !0
+    });
+};
+var utils_namespaceObject = {};
+function isUndefined(value) {
+    return void 0 === value;
+}
+function isNumber(value) {
+    return 'number' == typeof value && !Number.isNaN(value);
+}
+__webpack_require__.r(utils_namespaceObject), __webpack_require__.d(utils_namespaceObject, {
+    canParse: ()=>canParse,
+    detectECMAVersion: ()=>detectECMAVersion,
+    getDefaultImports: ()=>getDefaultImports,
+    getIdentifierInDeclaration: ()=>getIdentifierInDeclaration,
+    getIdentifierInExport: ()=>getIdentifierInExport,
+    getIdentifierInImport: ()=>getIdentifierInImport,
+    getIdentifierInPattern: ()=>getIdentifierInPattern,
+    isES5: ()=>isES5,
+    isES6: ()=>isES6,
+    isSameSemantics: ()=>isSameSemantics
+});
+class Document {
+    _text = '';
+    positionAt;
+    offsetAt;
+    constructor(content){
+        this._text, this._text = content, this.createFinder();
+    }
+    createFinder() {
+        let find = new LinesAndColumns(this._text);
+        this.positionAt = (offset)=>{
+            offset >= this._text.length && (offset = this._text.length - 1), offset < 0 && (offset = 0);
+            let result = find.locationForIndex(offset);
+            if (result) return {
+                line: result.line + 1,
+                column: result.column
+            };
+        }, this.offsetAt = (position)=>find.indexForLocation({
+                line: position.line - 1,
+                column: position.column
+            }) ?? void 0;
+    }
+    getText(range) {
+        if (!range) return this._text;
+        let start = 'number' == typeof range.start ? range.start : this.offsetAt(range.start), end = 'number' == typeof range.end ? range.end : this.offsetAt(range.end);
+        if (isUndefined(start)) throw Error(`Location ${JSON.stringify(start)} is illegal`);
+        if (isUndefined(end)) throw Error(`Location ${JSON.stringify(end)} is illegal`);
+        return this._text.slice(start, end);
+    }
+    edit(data) {
+        let { _text: content } = this, startOffset = isNumber(data.start) ? data.start : this.offsetAt(data.start), endOffset = isNumber(data.end) ? data.end : this.offsetAt(data.end);
+        if (isUndefined(startOffset) || isUndefined(endOffset)) return;
+        let startTxt = content.substring(0, startOffset), endTxt = content.substring(endOffset, content.length);
+        return startTxt + data.newText + endTxt;
+    }
+}
+let store = new Map();
+function getDocument(content) {
+    if (store.has(content)) return store.get(content);
+    let doc = new Document(content);
+    return store.set(content, doc), doc;
+}
+function clearDocument() {
+    store.clear();
+}
+function isSyntaxNode(node) {
+    return 'object' == typeof node && null !== node && 'type' in node;
+}
+function assertCreator(type) {
+    return (node)=>isSyntaxNode(node) && node.type === type;
+}
+let asserts = {
+    isProgram: assertCreator('Program'),
+    isEmptyStatement: assertCreator('EmptyStatement'),
+    isBlockStatement: assertCreator('BlockStatement'),
+    isStaticBlock: assertCreator('StaticBlock'),
+    isExpressionStatement: assertCreator('ExpressionStatement'),
+    isIfStatement: assertCreator('IfStatement'),
+    isLabeledStatement: assertCreator('LabeledStatement'),
+    isBreakStatement: assertCreator('BreakStatement'),
+    isContinueStatement: assertCreator('ContinueStatement'),
+    isWithStatement: assertCreator('WithStatement'),
+    isSwitchStatement: assertCreator('SwitchStatement'),
+    isReturnStatement: assertCreator('ReturnStatement'),
+    isThrowStatement: assertCreator('ThrowStatement'),
+    isTryStatement: assertCreator('TryStatement'),
+    isWhileStatement: assertCreator('WhileStatement'),
+    isDoWhileStatement: assertCreator('DoWhileStatement'),
+    isForStatement: assertCreator('ForStatement'),
+    isForInStatement: assertCreator('ForInStatement'),
+    isForOfStatement: assertCreator('ForOfStatement'),
+    isDebuggerStatement: assertCreator('DebuggerStatement'),
+    isFunctionDeclaration: assertCreator('FunctionDeclaration'),
+    isVariableDeclaration: assertCreator('VariableDeclaration'),
+    isVariableDeclarator: assertCreator('VariableDeclarator'),
+    isChainExpression: assertCreator('ChainExpression'),
+    isThisExpression: assertCreator('ThisExpression'),
+    isArrayExpression: assertCreator('ArrayExpression'),
+    isObjectExpression: assertCreator('ObjectExpression'),
+    isPrivateIdentifier: assertCreator('PrivateIdentifier'),
+    isProperty: assertCreator('Property'),
+    isPropertyDefinition: assertCreator('PropertyDefinition'),
+    isFunctionExpression: assertCreator('FunctionExpression'),
+    isSequenceExpression: assertCreator('SequenceExpression'),
+    isUnaryExpression: assertCreator('UnaryExpression'),
+    isBinaryExpression: assertCreator('BinaryExpression'),
+    isAssignmentExpression: assertCreator('AssignmentExpression'),
+    isUpdateExpression: assertCreator('UpdateExpression'),
+    isLogicalExpression: assertCreator('LogicalExpression'),
+    isConditionalExpression: assertCreator('ConditionalExpression'),
+    isNewExpression: assertCreator('NewExpression'),
+    isSwitchCase: assertCreator('SwitchCase'),
+    isCatchClause: assertCreator('CatchClause'),
+    isIdentifier: assertCreator('Identifier'),
+    isLiteral: assertCreator('Literal'),
+    isSuper: assertCreator('Super'),
+    isSpreadElement: assertCreator('SpreadElement'),
+    isArrowFunctionExpression: assertCreator('ArrowFunctionExpression'),
+    isYieldExpression: assertCreator('YieldExpression'),
+    isTemplateLiteral: assertCreator('TemplateLiteral'),
+    isTaggedTemplateExpression: assertCreator('TaggedTemplateExpression'),
+    isTemplateElement: assertCreator('TemplateElement'),
+    isObjectPattern: assertCreator('ObjectPattern'),
+    isArrayPattern: assertCreator('ArrayPattern'),
+    isRestElement: assertCreator('RestElement'),
+    isAssignmentPattern: assertCreator('AssignmentPattern'),
+    isClassBody: assertCreator('ClassBody'),
+    isClassDeclaration: assertCreator('ClassDeclaration'),
+    isClassExpression: assertCreator('ClassExpression'),
+    isMetaProperty: assertCreator('MetaProperty'),
+    isImportDeclaration: assertCreator('ImportDeclaration'),
+    isImportSpecifier: assertCreator('ImportSpecifier'),
+    isImportExpression: assertCreator('ImportExpression'),
+    isImportDefaultSpecifier: assertCreator('ImportDefaultSpecifier'),
+    isImportNamespaceSpecifier: assertCreator('ImportNamespaceSpecifier'),
+    isExportNamedDeclaration: assertCreator('ExportNamedDeclaration'),
+    isExportSpecifier: assertCreator('ExportSpecifier'),
+    isExportDefaultDeclaration: assertCreator('ExportDefaultDeclaration'),
+    isExportAllDeclaration: assertCreator('ExportAllDeclaration'),
+    isAwaitExpression: assertCreator('AwaitExpression'),
+    isMethodDefinition: assertCreator('MethodDefinition'),
+    isMemberExpression: assertCreator('MemberExpression'),
+    isComment: (node)=>isSyntaxNode(node) && ('Line' === node.type || 'Block' === node.type),
+    isDirective: (node)=>asserts.isExpressionStatement(node) && 'directive' in node,
+    isSimpleCallExpression: (node)=>isSyntaxNode(node) && 'CallExpression' === node.type,
+    isAssignmentProperty: (node)=>asserts.isProperty(node) && 'init' === node.kind,
+    isSimpleLiteral: (node)=>asserts.isLiteral(node) && !asserts.isRegExpLiteral(node) && !asserts.isBigIntLiteral(node),
+    isRegExpLiteral: (node)=>asserts.isLiteral(node) && 'regex' in node,
+    isBigIntLiteral: (node)=>asserts.isLiteral(node) && 'bigint' in node,
+    isExportStatement: (node)=>asserts.isExportAllDeclaration(node) || asserts.isExportDefaultDeclaration(node) || asserts.isExportNamedDeclaration(node)
+};
+var types_ECMAVersion = ((ECMAVersion = {}).ES5 = "ES5", ECMAVersion.ES6 = "ES6", ECMAVersion.ES7P = "ES7+", ECMAVersion);
+function isSameSemantics(node1, node2) {
+    if (node1.type !== node2.type) return !1;
+    switch(node1.type){
+        case 'CallExpression':
+            return node1.arguments.length === node2.arguments.length && !!node1.optional == !!node2.optional && isSameSemantics(node1.callee, node2.callee) && node1.arguments.every((node, i)=>isSameSemantics(node, node2.arguments[i]));
+        case 'MemberExpression':
+            return node1.computed === node2.computed && !!node1.optional == !!node2.optional && isSameSemantics(node1.object, node2.object) && isSameSemantics(node1.property, node2.property);
+        case 'Identifier':
+            return node1.name === node2.name;
+        case 'Literal':
+            if (asserts.isSimpleLiteral(node1) && asserts.isSimpleLiteral(node2)) return node1.value === node2.value;
+            return node1.raw === node2.raw;
+        case 'ObjectExpression':
+            return node1.properties.length === node2.properties.length && node1.properties.every((prop, i)=>isSameSemantics(prop, node2.properties[i]));
+        case 'Property':
+            return node1.computed === node2.computed && node1.kind === node2.kind && node1.method === node2.method && isSameSemantics(node1.key, node2.key) && isSameSemantics(node1.value, node2.value);
+        default:
+            throw Error(`Unknown node type: ${node1.type}`);
+    }
+}
+function getDefaultImports(node) {
+    return node.body.filter((statement)=>{
+        if ('ImportDeclaration' !== statement.type) return !1;
+        let specifier = statement?.specifiers?.[0];
+        return specifier?.type === 'ImportDefaultSpecifier';
+    });
+}
+function getIdentifierInPattern(name, node) {
+    if (asserts.isIdentifier(node) && node.name === name) return node;
+    if (asserts.isObjectPattern(node)) for (let prop of node.properties){
+        if (asserts.isAssignmentProperty(prop)) return getIdentifierInPattern(name, prop.value);
+        if (asserts.isRestElement(prop)) return getIdentifierInPattern(name, prop);
+    }
+    if (asserts.isArrayPattern(node)) {
+        for (let el of node.elements)if (el) {
+            let result = getIdentifierInPattern(name, el);
+            if (result) return result;
+        }
+    }
+    return asserts.isRestElement(node) ? getIdentifierInPattern(name, node.argument) : asserts.isAssignmentPattern(node) ? getIdentifierInPattern(name, node.left) : void 0;
+}
+function getIdentifierInDeclaration(name, node) {
+    var node1;
+    return asserts.isFunctionDeclaration(node) || asserts.isClassDeclaration(node) ? (node1 = node, asserts.isIdentifier(node1.id) && node1.id.name === name ? node1.id : void 0) : asserts.isVariableDeclaration(node) ? node.declarations.find((item)=>getIdentifierInPattern(name, item.id))?.id : void 0;
+}
+function getIdentifierInImport(name, node) {
+    if (asserts.isImportDeclaration(node)) {
+        for (let specifier of node.specifiers ?? [])if (specifier.local.name === name) return specifier.local;
+    }
+}
+function getIdentifierInExport(name, node) {
+    if (asserts.isExportNamedDeclaration(node)) {
+        if (node.declaration) return getIdentifierInDeclaration(name, node.declaration);
+        for (let specifier of node.specifiers ?? [])if (specifier.exported.name === name) return specifier.exported;
+    }
+    if (asserts.isExportAllDeclaration(node) && node.exported && node.exported.name === name) return node.exported;
+}
+function canParse(code, ecmaVersion) {
+    try {
+        return parse(code, {
+            ecmaVersion,
+            sourceType: 'number' == typeof ecmaVersion && ecmaVersion <= 5 ? "script" : 'module'
+        }), !0;
+    } catch (err) {
+        return !1;
+    }
+}
+function isES5(code) {
+    return canParse(code, 5);
+}
+function isES6(code) {
+    return canParse(code, 6);
+}
+function detectECMAVersion(code) {
+    return isES6(code) ? isES5(code) ? types_ECMAVersion.ES5 : types_ECMAVersion.ES6 : types_ECMAVersion.ES7P;
+}
+let acornParserInternal = Parser.extend(importAttributes), acornParserExport = Parser.extend(importAttributes), parser = {
+    walk: __WEBPACK_EXTERNAL_MODULE_acorn_walk_9c3ac672__,
+    parse: (input, options)=>acornParserExport.parse(input, options),
+    parseExpressionAt: (input, pos, options)=>acornParserExport.parseExpressionAt(input, pos, options),
+    extend: (...args)=>acornParserExport = acornParserExport.extend(...args),
+    asserts: asserts,
+    utils: utils_namespaceObject,
+    internal: {
+        parse: (input, options)=>acornParserInternal.parse(input, options),
+        parseExpressionAt: (input, pos, options)=>acornParserInternal.parseExpressionAt(input, pos, options)
+    }
+};
+export { Document, types_ECMAVersion as ECMAVersion, asserts, canParse, clearDocument, detectECMAVersion, getDefaultImports, getDocument, getIdentifierInDeclaration, getIdentifierInExport, getIdentifierInImport, getIdentifierInPattern, isES5, isES6, isSameSemantics, parser };

package/package.json

@@ -1,70 +1,65 @@
 {
   "name": "@rsdoctor/utils",
-  "version": "1.2.2",
+  "version": "1.2.4-beta.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/web-infra-dev/rsdoctor",
     "directory": "packages/utils"
   },
+  "type": "module",
   "license": "MIT",
   "exports": {
-    ".": {
-      "types": "./dist/type/index.d.ts",
-      "require": "./dist/cjs/index.js",
-      "import": "./dist/esm/index.mjs"
-    },
     "./common": {
-      "types": "./dist/type/common/index.d.ts",
-      "require": "./dist/cjs/common/index.js",
-      "import": "./dist/esm/common/index.mjs"
+      "types": "./dist/common/index.d.ts",
+      "import": "./dist/common.js",
+      "default": "./dist/common.cjs"
     },
     "./build": {
-      "types": "./dist/type/build/index.d.ts",
-      "require": "./dist/cjs/build/index.js",
-      "import": "./dist/esm/build/index.mjs"
+      "types": "./dist/build/index.d.ts",
+      "import": "./dist/build.js",
+      "default": "./dist/build.cjs"
     },
     "./error": {
-      "types": "./dist/type/error/index.d.ts",
-      "require": "./dist/cjs/error/index.js",
-      "import": "./dist/esm/error/index.mjs"
+      "types": "./dist/error/index.d.ts",
+      "import": "./dist/error.js",
+      "default": "./dist/error.cjs"
     },
     "./ruleUtils": {
-      "types": "./dist/type/rule-utils/index.d.ts",
-      "require": "./dist/cjs/rule-utils/index.js",
-      "import": "./dist/esm/rule-utils/index.mjs"
+      "types": "./dist/rule-utils/index.d.ts",
+      "import": "./dist/ruleUtils.js",
+      "default": "./dist/ruleUtils.cjs"
     },
     "./logger": {
-      "types": "./dist/type/logger.d.ts",
-      "require": "./dist/cjs/logger.js",
-      "import": "./dist/esm/logger.mjs"
+      "types": "./dist/logger.d.ts",
+      "import": "./dist/logger.js",
+      "default": "./dist/logger.cjs"
     }
   },
   "typesVersions": {
     "*": {
-      ".": [
-        "./dist/type/index.d.ts"
-      ],
       "common": [
-        "./dist/type/common/index.d.ts"
+        "./dist/common/index.d.ts"
       ],
       "build": [
-        "./dist/type/build/index.d.ts"
+        "./dist/build/index.d.ts"
       ],
       "error": [
-        "./dist/type/error/index.d.ts"
+        "./dist/error/index.d.ts"
       ],
       "ruleUtils": [
-        "./dist/type/rule-utils/index.d.ts"
+        "./dist/rule-utils/index.d.ts"
       ],
       "logger": [
-        "./dist/type/logger.d.ts"
+        "./dist/logger.d.ts"
       ]
     }
   },
-  "main": "dist/index.js",
-  "types": "dist/type/index.d.ts",
+  "main": "dist/build.cjs",
+  "module": "dist/build.js",
+  "types": "dist/build/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "compiled"
   ],
   "dependencies": {
     "@babel/code-frame": "7.26.2",
@@ -72,10 +67,8 @@
     "acorn": "^8.10.0",
     "acorn-import-attributes": "^1.9.5",
     "acorn-walk": "8.3.4",
-    "connect": "3.7.0",
     "deep-eql": "4.1.4",
     "envinfo": "7.14.0",
-    "filesize": "^10.1.6",
     "fs-extra": "^11.1.1",
     "get-port": "5.1.1",
     "json-stream-stringify": "3.0.1",
@@ -83,27 +76,30 @@
     "picocolors": "^1.1.1",
     "rslog": "^1.2.9",
     "strip-ansi": "^6.0.1",
-    "@rsdoctor/types": "1.2.2"
+    "@rsdoctor/types": "1.2.4-beta.0"
   },
   "devDependencies": {
-    "@rslib/core": "^0.11.0",
     "@types/babel__code-frame": "7.0.6",
     "@types/connect": "3.4.38",
     "@types/deep-eql": "4.0.2",
     "@types/envinfo": "7.8.4",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^22.8.1",
+    "prebundle": "1.4.1",
+    "filesize": "^10.1.6",
+    "connect": "3.7.0",
     "tslib": "2.8.1",
-    "typescript": "^5.2.2"
+    "typescript": "^5.9.2"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "rslib build",
+    "build": "npm run prebundle && rslib build",
     "dev": "npm run start",
     "start": "rslib build -w",
-    "test": "rstest run"
+    "test": "rstest run",
+    "prebundle": "prebundle"
   }
 }

package/dist/cjs/build/envinfo.js

@@ -1,121 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    getYarnVersion: ()=>getYarnVersion,
-    getNpmVersion: ()=>getNpmVersion,
-    getMemoryInfo: ()=>getMemoryInfo,
-    getNodeVersion: ()=>getNodeVersion,
-    getNpmPackageVersion: ()=>getNpmPackageVersion,
-    getGlobalNpmPackageVersion: ()=>getGlobalNpmPackageVersion,
-    getOSInfo: ()=>getOSInfo,
-    getPnpmVersion: ()=>getPnpmVersion,
-    getGitBranch: ()=>getGitBranch,
-    getGitRepo: ()=>getGitRepo,
-    getCPUInfo: ()=>getCPUInfo
-});
-const external_envinfo_namespaceObject = require("envinfo");
-const external_child_process_namespaceObject = require("child_process");
-const getCPUInfo = ()=>external_envinfo_namespaceObject.helpers.getCPUInfo().then((res)=>res[1]);
-const getOSInfo = ()=>external_envinfo_namespaceObject.helpers.getOSInfo().then((res)=>res[1]);
-const getMemoryInfo = ()=>external_envinfo_namespaceObject.helpers.getMemoryInfo().then((res)=>res[1]);
-const getNodeVersion = ()=>external_envinfo_namespaceObject.helpers.getNodeInfo().then((res)=>res[1]);
-const getYarnVersion = ()=>external_envinfo_namespaceObject.helpers.getYarnInfo().then((res)=>res[1]);
-const getNpmVersion = ()=>external_envinfo_namespaceObject.helpers.getnpmInfo().then((res)=>res[1]);
-const getPnpmVersion = ()=>external_envinfo_namespaceObject.helpers.getpnpmInfo().then((res)=>res[1]);
-function getNpmPackageVersion(pkg) {
-    const isArray = Array.isArray(pkg);
-    return (0, external_envinfo_namespaceObject.run)({
-        npmPackages: isArray ? pkg : [
-            pkg
-        ]
-    }, {
-        json: true,
-        showNotFound: true
-    }).then((res)=>{
-        const { npmPackages = {} } = JSON.parse(res) || {};
-        return isArray ? pkg.map((e)=>npmPackages[e] || 'Not Found') : npmPackages[pkg];
-    });
-}
-function getGlobalNpmPackageVersion(pkg) {
-    const isArray = Array.isArray(pkg);
-    return (0, external_envinfo_namespaceObject.run)({
-        npmGlobalPackages: isArray ? pkg : [
-            pkg
-        ]
-    }, {
-        json: true,
-        showNotFound: true
-    }).then((res)=>{
-        const { npmGlobalPackages = {} } = JSON.parse(res) || {};
-        return isArray ? pkg.map((e)=>npmGlobalPackages[e] || 'Not Found') : npmGlobalPackages[pkg];
-    });
-}
-function getGitBranch() {
-    return new Promise((resolve, reject)=>{
-        (0, external_child_process_namespaceObject.exec)('git branch --show-current', (err, stdout)=>{
-            if (err) (0, external_child_process_namespaceObject.exec)('git branch', (err, stdout)=>{
-                if (err) reject(err);
-                else resolve(stdout.split('\n').map((e)=>e.replace('* ', '')).join('').trim());
-            });
-            else resolve(stdout.trim());
-        });
-    });
-}
-function getGitRepo() {
-    return new Promise((resolve, reject)=>{
-        (0, external_child_process_namespaceObject.exec)('git config --get remote.origin.url', (err, stdout)=>{
-            if (err) reject(err);
-            else resolve(stdout.trim());
-        });
-    });
-}
-exports.getCPUInfo = __webpack_exports__.getCPUInfo;
-exports.getGitBranch = __webpack_exports__.getGitBranch;
-exports.getGitRepo = __webpack_exports__.getGitRepo;
-exports.getGlobalNpmPackageVersion = __webpack_exports__.getGlobalNpmPackageVersion;
-exports.getMemoryInfo = __webpack_exports__.getMemoryInfo;
-exports.getNodeVersion = __webpack_exports__.getNodeVersion;
-exports.getNpmPackageVersion = __webpack_exports__.getNpmPackageVersion;
-exports.getNpmVersion = __webpack_exports__.getNpmVersion;
-exports.getOSInfo = __webpack_exports__.getOSInfo;
-exports.getPnpmVersion = __webpack_exports__.getPnpmVersion;
-exports.getYarnVersion = __webpack_exports__.getYarnVersion;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "getCPUInfo",
-    "getGitBranch",
-    "getGitRepo",
-    "getGlobalNpmPackageVersion",
-    "getMemoryInfo",
-    "getNodeVersion",
-    "getNpmPackageVersion",
-    "getNpmVersion",
-    "getOSInfo",
-    "getPnpmVersion",
-    "getYarnVersion"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/build/file/cache.js

@@ -1,76 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    readJSONSync: ()=>readJSONSync,
-    readFile: ()=>readFile,
-    readFileSync: ()=>readFileSync,
-    readJSON: ()=>readJSON
-});
-const external_fs_extra_namespaceObject = require("fs-extra");
-var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_namespaceObject);
-const cache = new Map();
-async function readFile(path) {
-    if (cache.has(path)) return cache.get(path);
-    const res = await external_fs_extra_default().readFile(path, 'utf-8');
-    cache.set(path, res);
-    return res;
-}
-function readFileSync(path) {
-    if (cache.has(path)) return cache.get(path);
-    const res = external_fs_extra_default().readFileSync(path, 'utf-8');
-    cache.set(path, res);
-    return res;
-}
-async function readJSON(path) {
-    const str = await readFile(path);
-    return JSON.parse(str);
-}
-function readJSONSync(path) {
-    const str = readFileSync(path);
-    return JSON.parse(str);
-}
-exports.readFile = __webpack_exports__.readFile;
-exports.readFileSync = __webpack_exports__.readFileSync;
-exports.readJSON = __webpack_exports__.readJSON;
-exports.readJSONSync = __webpack_exports__.readJSONSync;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "readFile",
-    "readFileSync",
-    "readJSON",
-    "readJSONSync"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});