@nasl/cli 0.1.17 → 0.1.19

package/dist/bin/nasl.mjs

@@ -3,8 +3,8 @@
 import require$$0$1, { EventEmitter } from 'events';
 import require$$1, { spawn, spawnSync } from 'child_process';
 import * as sysPath from 'path';
-import sysPath__default from 'path';
-import require$$0$2, { unwatchFile, watchFile, watch as watch$1, stat as stat$3 } from 'fs';
+import sysPath__default, { join } from 'path';
+import require$$0$2, { promises, unwatchFile, watchFile, watch as watch$1, stat as stat$3 } from 'fs';
 import require$$4 from 'process';
 import require$$0$3 from 'constants';
 import stream$4, { Readable } from 'stream';
@@ -15,14 +15,14 @@ import require$$1$1 from 'tty';
 import require$$3 from 'http';
 import require$$4$1 from 'https';
 import require$$0$6 from 'url';
-import crypto$1 from 'crypto';
+import crypto$1, { createHash } from 'crypto';
 import http2 from 'http2';
 import zlib from 'zlib';
 import * as readline from 'readline';
 import { realpath as realpath$1, stat as stat$2, lstat as lstat$1, open, readdir as readdir$1 } from 'fs/promises';
 import { lstat, stat as stat$1, readdir, realpath } from 'node:fs/promises';
 import { Readable as Readable$1 } from 'node:stream';
-import { resolve, join, relative, sep } from 'node:path';
+import { resolve, join as join$1, relative, sep } from 'node:path';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -8338,10 +8338,42 @@ function loadConfig(configDir) {
         const content = libExports.readFileSync(configPath, 'utf-8');
         const config = JSON.parse(content);
         // 验证必需字段
-        if (!config.serverBaseURL || !config.ideVersion || !config.srcDir || !config.outDir) {
-            defaultLogger.error('配置文件格式不正确，缺少必需字段');
+        if (!config.srcDir || !config.outDir) {
+            defaultLogger.error('配置文件格式不正确，缺少必需的 srcDir 或 outDir 字段');
             return defaultLogger.exit(1);
         }
+        // 环境变量优先级高于配置文件
+        // ideVersion: 环境变量优先，如果都没有则报错
+        if (process.env.NASL_IDE_VERSION)
+            config.ideVersion = process.env.NASL_IDE_VERSION;
+        if (!config.ideVersion) {
+            defaultLogger.error('缺少配置 ideVersion，请在配置文件中添加，或在环境变量中配置 NASL_IDE_VERSION');
+            return defaultLogger.exit(1);
+        }
+        // serverBaseURL: 环境变量优先，如果都没有则报错
+        if (process.env.NASL_SERVER_BASE_URL)
+            config.serverBaseURL = process.env.NASL_SERVER_BASE_URL;
+        if (!config.serverBaseURL) {
+            defaultLogger.error('缺少配置 serverBaseURL，请在配置文件中添加，或在环境变量中配置 NASL_SERVER_BASE_URL');
+            return defaultLogger.exit(1);
+        }
+        // 环境变量优先
+        if (process.env.USE_LCAP_OPENAPI !== undefined)
+            config.useOPENAPI = process.env.USE_LCAP_OPENAPI === 'true';
+        if (process.env.LCAP_OPENAPI_AK)
+            config.OPENAPI_AK = process.env.LCAP_OPENAPI_AK;
+        if (process.env.LCAP_OPENAPI_SK)
+            config.OPENAPI_SK = process.env.LCAP_OPENAPI_SK;
+        // 如果启用了 OpenAPI，验证必需的 AK 和 SK
+        if (config.useOPENAPI) {
+            if (!config.OPENAPI_AK || !config.OPENAPI_SK) {
+                defaultLogger.error(`配置了 useOPENAPI，但缺少配置 OPENAPI_AK 和 OPENAPI_SK:
+- 在 nasl.config.json 中配置 OPENAPI_AK 和 OPENAPI_SK，或者在环境变量中配置 LCAP_OPENAPI_AK 和 LCAP_OPENAPI_SK
+- 或将 useOPENAPI 配置为 false
+`);
+                return defaultLogger.exit(1);
+            }
+        }
         return config;
     }
     catch (error) {
@@ -8387,6 +8419,23 @@ function writeFileWithLog(filePath, content, logger) {
         throw error;
     }
 }
+/**
+ * 判断文件路径是否为已知的 NASL 文件类型
+ * 支持的类型：
+ * - 枚举 (enums)
+ * - 实体 (entities)
+ * - 数据结构 (structures)
+ * - 逻辑 (logics)
+ * - 页面 (views)
+ * - 前端/服务端全局变量 (variables)
+ * - 依赖库 (extensions)
+ */
+function isKnownFileType(filePath) {
+    return (/\.(enums|entities|structures|logics|views)\.\w+\.(ts|tsx)$/.test(filePath) || // 枚举、实体、数据结构、逻辑、页面
+        /^app\..*\.variables\.ts$/.test(filePath) || // 前端/服务端全局变量 (以app开头，以variables.ts结尾)
+        /^extensions\.\w+\.(ts|tsx)$/.test(filePath) // 依赖库
+    );
+}
 
 /**
  * 初始化命令 - 创建配置文件
@@ -28895,18 +28944,99 @@ function v4(options, buf, offset) {
   return unsafeStringify(rnds);
 }
 
+function generateHash(params) {
+    const hash = createHash('sha256');
+    hash.update(JSON.stringify(params));
+    return hash.digest('hex');
+}
+async function getCachePathWithTimestamp(hash) {
+    const cacheDir = join(process.cwd(), '.cache');
+    await promises.mkdir(cacheDir, { recursive: true });
+    return join(cacheDir, `${hash}_${Date.now()}.json`);
+}
 /**
- * 构建签名字符串
+ * 查找指定 hash 的有效缓存文件
+ * @param hash 缓存标识
+ * @param ttl 缓存有效期（毫秒）
+ * @returns 缓存文件路径和缓存内容，如果没有有效缓存则返回 null
  */
-function buildStringToSign(appKey, nonce, timestamp, secretKey) {
-    return `${appKey}&${nonce}&${timestamp}&${secretKey}`;
+async function findValidCache(hash, ttl) {
+    const cacheDir = join(process.cwd(), '.cache');
+    try {
+        await promises.mkdir(cacheDir, { recursive: true });
+        const files = await promises.readdir(cacheDir);
+        const now = Date.now();
+        // 查找所有匹配的缓存文件
+        const matchingFiles = files
+            .filter((file) => file.startsWith(`${hash}_`) && file.endsWith('.json'))
+            .map((file) => {
+            const match = file.match(/_(\d+)\.json$/);
+            if (!match)
+                return null;
+            const timestamp = parseInt(match[1], 10);
+            return {
+                path: join(cacheDir, file),
+                timestamp,
+                isExpired: now - timestamp > ttl,
+            };
+        })
+            .filter((item) => item !== null);
+        // 删除过期的缓存文件
+        const expiredFiles = matchingFiles.filter((item) => item.isExpired);
+        await Promise.all(expiredFiles.map((item) => promises.unlink(item.path).catch(() => { })));
+        // 查找有效的缓存文件（按时间戳降序排序，获取最新的）
+        const validFiles = matchingFiles.filter((item) => !item.isExpired).sort((a, b) => b.timestamp - a.timestamp);
+        if (validFiles.length > 0) {
+            const cacheFile = validFiles[0];
+            const cacheContent = await promises.readFile(cacheFile.path, 'utf-8');
+            const cachedResult = JSON.parse(cacheContent);
+            return { path: cacheFile.path, data: cachedResult };
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
 }
 /**
- * 生成 MD5 签名
+ * 高阶函数，为异步函数添加带时间戳的缓存功能
+ * @param fn 需要添加缓存的函数
+ * @param ttl 缓存有效期（毫秒），默认 1 小时
+ * @param getCacheKey 可选的自定义缓存 key 生成函数，如果不提供则使用整个 params
+ * @returns 带缓存的函数版本
  */
-function generateSignature(plainText) {
-    return crypto$1.createHash('md5').update(plainText).digest('hex');
+function cachableWithTTL(fn, ttl = 3600 * 1000, // 默认 1 小时
+getCacheKey) {
+    return async (params, extraParams) => {
+        const functionName = fn.name;
+        const logPrefix = functionName ? `[${functionName}]` : '[cachableWithTTL]';
+        // 检查是否启用缓存
+        if (process.env.NO_AI_CACHE) {
+            return fn(params, extraParams);
+        }
+        // 使用自定义的 getCacheKey 或默认使用整个 params
+        const cacheKey = getCacheKey ? getCacheKey(params) : params;
+        const hash = generateHash(cacheKey);
+        // 查找有效的缓存
+        const validCache = await findValidCache(hash, ttl);
+        if (validCache) {
+            console.log(`${logPrefix} ✓ 使用缓存`);
+            return validCache.data;
+        }
+        // 调用原函数
+        const result = await fn(params, extraParams);
+        // 保存结果到缓存（带时间戳）
+        try {
+            const cachePath = await getCachePathWithTimestamp(hash);
+            await promises.writeFile(cachePath, JSON.stringify(result, null, 2), 'utf-8');
+        }
+        catch (error) {
+            // 缓存写入失败，但不影响返回结果
+        }
+        return result;
+    };
 }
+
 /**
  * 生成客户端签名信息
  * @param appKey AppKey
@@ -28916,8 +29046,8 @@ function generateSignature(plainText) {
 function generateClientSignature(appKey, secretKey) {
     const timestamp = Math.floor(Date.now() / 1000).toString();
     const nonce = v4();
-    const plainText = buildStringToSign(appKey, nonce, timestamp, secretKey);
-    const signature = generateSignature(plainText);
+    const plainText = `${appKey}&${nonce}&${timestamp}&${secretKey}`;
+    const signature = crypto$1.createHash('md5').update(plainText).digest('hex');
     return {
         appKey,
         timestamp,
@@ -28942,12 +29072,12 @@ function generateBaseHeaders(ak, sk) {
     };
 }
 /**
- * 获取租户的 signInfo
+ * 获取租户的 signInfo（内部实现）
  * @param options 服务器选项
  * @param baseHeaders 基础认证头
  * @returns x-signInfo 值
  */
-async function fetchSignInfo(options, baseHeaders) {
+async function _fetchSignInfo({ options, baseHeaders }) {
     const tenantName = options.tenantName || 'defaulttenant';
     const userName = tenantName === 'defaulttenant' ? 'admin' : `${tenantName}-admin`;
     const data = {
@@ -28969,6 +29099,14 @@ async function fetchSignInfo(options, baseHeaders) {
         return null;
     }
 }
+/**
+ * 获取租户的 signInfo（带缓存，1 小时过期）
+ * @param options 服务器选项
+ * @param baseHeaders 基础认证头
+ * @returns x-signInfo 值
+ */
+const fetchSignInfo = cachableWithTTL(_fetchSignInfo, 3600 * 1000, // 1 小时
+(params) => params.options);
 /**
  * 生成完整的认证头（包含 x-signInfo）
  * @param options 服务器选项
@@ -28978,19 +29116,18 @@ async function generateCompleteHeaders(options) {
     const headers = {
         'Content-Type': 'application/json',
     };
-    const OPENAPI_AK = options.OPENAPI_AK || process.env.LCAP_OPENAPI_AK;
-    const OPENAPI_SK = options.OPENAPI_SK || process.env.LCAP_OPENAPI_SK;
     // 如果没有提供 ak 和 sk，返回基础 headers
-    if (!OPENAPI_AK || !OPENAPI_SK) {
-        throw new Error(`配置了 useOPENAPI，但没有提供 OPENAPI_AK 和 OPENAPI_SK:
-- 可取消配置 useOPENAPI
-- 在 nasl.config.json 中配置 OPENAPI_AK 和 OPENAPI_SK，或者在环境变量中配置 LCAP_OPENAPI_AK 和 LCAP_OPENAPI_SK`);
+    if (!options.OPENAPI_AK || !options.OPENAPI_SK) {
+        throw new Error(`配置了 useOPENAPI，但缺少配置 OPENAPI_AK 和 OPENAPI_SK:
+- 在 nasl.config.json 中配置 OPENAPI_AK 和 OPENAPI_SK，或者在环境变量中配置 LCAP_OPENAPI_AK 和 LCAP_OPENAPI_SK
+- 或将 useOPENAPI 配置为 false
+`);
     }
     // 生成基础认证头
-    const baseHeaders = generateBaseHeaders(OPENAPI_AK, OPENAPI_SK);
+    const baseHeaders = generateBaseHeaders(options.OPENAPI_AK, options.OPENAPI_SK);
     Object.assign(headers, baseHeaders);
     // 获取 signInfo
-    const signInfo = await fetchSignInfo(options, headers);
+    const signInfo = await fetchSignInfo({ options, baseHeaders: headers });
     if (signInfo) {
         headers['x-signInfo'] = signInfo;
     }
@@ -29005,10 +29142,9 @@ async function generateCompleteHeaders(options) {
 async function createAxios(options) {
     // 如果需要鉴权，拼接 /openapi/v3/nasl；否则使用原始 URL
     const serverBaseURL = new URL(options.serverBaseURL).origin;
-    const useOPENAPI = options.useOPENAPI || process.env.USE_LCAP_OPENAPI === 'true';
-    const baseURL = useOPENAPI ? `${serverBaseURL}/openapi/v3/nasl` : `${serverBaseURL}/api/v1/nasl`;
+    const baseURL = options.useOPENAPI ? `${serverBaseURL}/openapi/v3/nasl` : `${serverBaseURL}/api/v1/nasl`;
     // 如果需要鉴权，生成完整的认证头；否则只使用基础 headers
-    const headers = useOPENAPI ? await generateCompleteHeaders(options) : { 'Content-Type': 'application/json' };
+    const headers = options.useOPENAPI ? await generateCompleteHeaders(options) : { 'Content-Type': 'application/json' };
     console.log('本次服务调用方为:', baseURL);
     const instance = axios.create({
         baseURL,
@@ -29096,7 +29232,7 @@ async function checkApi(fullNaturalTS, options) {
 async function createAppSyncApi(fullNaturalTS, options) {
     const url = new URL(options.serverBaseURL);
     const origin = url.origin + '/app-ai-creator';
-    const axios = await createAxios({ serverBaseURL: origin});
+    const axios = await createAxios({ serverBaseURL: origin, ideVersion: options.ideVersion });
     try {
         const res = await axios.post('/api/createAppSync', {
             fullNaturalTS,
@@ -29153,6 +29289,56 @@ function createSorter() {
     };
 }
 const sorter = createSorter();
+/**
+ * 验证 variables 文件
+ */
+function validateVariablesFile(file, errors) {
+    const matchArr = Array.from(file.content.matchAll(/^(export\s+)(declare\s+)?(const|let)\s+(\w+)/gm));
+    if (matchArr.length === 0) {
+        errors.push(`${file.path} (variables文件) 必须包含至少一个 export const 或 export let 声明`);
+    }
+    for (const match of matchArr) {
+        const [, isExport] = match;
+        if (!isExport)
+            errors.push(`${file.path} 所有声明必须使用 export，错误代码：${match[0]}`);
+    }
+}
+/**
+ * 验证 extensions 文件
+ */
+function validateExtensionsFile(file, errors) {
+    const matchArr = Array.from(file.content.matchAll(/^(export\s+)(namespace)\s+(\w+)/gm));
+    if (matchArr.length === 0) {
+        errors.push(`${file.path} (extensions文件) 必须包含至少一个 export namespace 声明`);
+    }
+    for (const match of matchArr) {
+        const [, isExport] = match;
+        if (!isExport)
+            errors.push(`${file.path} 所有 namespace 必须使用 export，错误代码：${match[0]}`);
+    }
+}
+/**
+ * 验证普通文件（枚举、实体、数据结构、逻辑、页面）
+ */
+function validateNormalFile(file, nameFromPath, namespace, errors) {
+    const matchArr = Array.from(file.content.matchAll(/^(export\s+)?(declare\s+)?(function|class|interface)\s+(\w+)/gm));
+    if (matchArr.length === 0)
+        errors.push(`${file.path} 必须有一个函数或类，错误代码：${file.content}`);
+    else if (matchArr.length > 1)
+        errors.push(`${file.path} 只能有一个函数或类，错误代码：${matchArr.map((match) => match[0]).join('\n')}
+你可以将该文件中所有函数合并，或者将其他函数拆到多个文件中。`);
+    for (const match of matchArr) {
+        const [, isExport, isDeclare, type, name] = match;
+        if (!isExport)
+            errors.push(`${file.path} 必须使用 export，错误代码：${match[0]}`);
+        if (name !== nameFromPath)
+            errors.push(`${file.path} 的函数或类名必须与文件名一致，错误代码：${match[0]}`);
+        if (/\.(entities|enums|structures)/.test(namespace) && type !== 'class')
+            errors.push(`${file.path} 实体、数据结构和枚举只能使用 class 定义，错误代码：${match[0]}`);
+        if (/\.(logics|views)/.test(namespace) && type !== 'function')
+            errors.push(`${file.path} 逻辑和页面只能使用 function 定义，错误代码：${match[0]}`);
+    }
+}
 function composeToString(files) {
     files.sort((a, b) => sorter(a.path, b.path));
     const errors = [];
@@ -29160,28 +29346,26 @@ function composeToString(files) {
         const arr = file.path.split('.');
         const ext = arr.pop();
         const nameFromPath = arr.pop();
-        const namespace = arr.join('.');
+        // 判断是否是特殊文件类型（variables 或 extensions）
+        const isVariablesFile = nameFromPath === 'variables';
+        const isExtensionsFile = arr[0] === 'extensions';
+        const isSpecialFile = isVariablesFile || isExtensionsFile;
+        // 特殊文件的 namespace 包含文件名，普通文件不包含
+        const namespace = isSpecialFile ? [...arr, nameFromPath].join('.') : arr.join('.');
         if (['ts', 'tsx'].includes(ext)) {
-            const matchArr = Array.from(file.content.matchAll(/^(export\s+)?(declare\s+)?(function|class|interface)\s+(\w+)/gm));
-            if (matchArr.length === 0)
-                errors.push(`${file.path} 必须有一个函数或类，错误代码：${file.content}`);
-            else if (matchArr.length > 1)
-                errors.push(`${file.path} 只能有一个函数或类，错误代码：${matchArr.map((match) => match[0]).join('\n')}
-你可以将该文件中所有函数合并，或者将其他函数拆到多个文件中。`);
-            for (const match of matchArr) {
-                const [, isExport, isDeclare, type, name] = match;
-                if (!isExport)
-                    errors.push(`${file.path} 必须使用 export，错误代码：${match[0]}`);
-                if (name !== nameFromPath)
-                    errors.push(`${file.path} 的函数或类名必须与文件名一致，错误代码：${match[0]}`);
-                if (/\.(entities|enums|structures)/.test(namespace) && type !== 'class')
-                    errors.push(`${file.path} 实体、数据结构和枚举只能使用 class 定义，错误代码：${match[0]}`);
-                if (/\.(logics|views)/.test(namespace) && type !== 'function')
-                    errors.push(`${file.path} 逻辑和页面只能使用 function 定义，错误代码：${match[0]}`);
+            if (isVariablesFile) {
+                validateVariablesFile(file, errors);
+            }
+            else if (isExtensionsFile) {
+                validateExtensionsFile(file, errors);
+            }
+            else {
+                validateNormalFile(file, nameFromPath, namespace, errors);
             }
         }
         return `namespace ${namespace} {\n${file.content}\n}\n`;
-    }).join('\n');
+    })
+        .join('\n');
     if (errors.length > 0) {
         throw new Error(errors.join('\n============\n'));
     }
@@ -37742,11 +37926,13 @@ async function scanEntryFiles(projectRoot, patterns, logger) {
  */
 function extractDeps(content) {
     const deps = new Set();
-    // 预处理：移除注释，避免注释影响依赖分析
+    // 预处理：移除注释和字符串字面量，避免它们影响依赖分析
     let processedContent = content
         .replace(/\/\/.*$/gm, '') // 移除单行注释 // ...
-        .replace(/\/\*[\s\S]*?\*\//g, ''); // 移除多行注释 /* ... */
-    const allMatches = processedContent.matchAll(/app\.\w+\.[\w.]+/g); // 起码要2个点
+        .replace(/\/\*[\s\S]*?\*\//g, '') // 移除多行注释 /* ... */
+        .replace(/'(?:[^'\\]|\\.)*'/g, '') // 移除单引号字符串 'xxx'
+        .replace(/"(?:[^"\\]|\\.)*"/g, ''); // 移除双引号字符串 "xxx"
+    const allMatches = processedContent.matchAll(/(app|extensions)\.\w+\.[\w.]+/g); // 起码要2个点，支持 app.* 和 extensions.*
     for (const match of allMatches) {
         let dep = match[0];
         if (/Entity$|Entity\./.test(dep)) {
@@ -37755,6 +37941,14 @@ function extractDeps(content) {
         else if (/\.enums\.(\w+)\.(\w+)/.test(dep)) {
             dep = dep.replace(/\.enums\.(\w+).+$/, '.enums.$1');
         }
+        else if (/\.variables\.(\w+)/.test(dep)) {
+            // 处理 variables 依赖：app.backend.variables.xxx -> app.backend.variables
+            dep = dep.replace(/\.variables\..+$/, '.variables');
+        }
+        else if (/^extensions\.\w+\.\w+/.test(dep)) {
+            // 处理 extensions 依赖：extensions.lcap_auth.xxx -> extensions.lcap_auth
+            dep = dep.replace(/^(extensions\.\w+)\..+$/, '$1');
+        }
         else if (/app\.dataSources\.\w+\.entities\.\w+\.\w+$/.test(dep)) {
             continue; // 应该是写法有问题，跳过让后面的 checker 做检查
         }
@@ -37876,7 +38070,12 @@ async function collectDeps(patterns, projectRoot, srcDir, logger, verbose) {
     while (filesToProcess.length > 0) {
         const pathRelativeToSrc = filesToProcess.shift();
         if (processedFileMap.has(pathRelativeToSrc))
-            continue; // 跳过已处理的文件        
+            continue; // 跳过已处理的文件
+        // 检查文件类型是否支持
+        if (!isKnownFileType(pathRelativeToSrc)) {
+            logger.warn(`跳过不支持的文件类型: ${pathRelativeToSrc}`);
+            continue;
+        }
         try {
             const { fileInfo, newDeps } = processFileDeps(pathRelativeToSrc, srcDir, matchedFileSet, processedFileMap, depNotFoundList, logger, verbose);
             result.push(fileInfo);
@@ -37956,8 +38155,18 @@ async function resolveNASLFiles(entry, logger, depMode, verbose) {
         }
         logger.info(`找到 ${collectedFiles.length} 个 NASL 文件`);
     }
+    // 统一过滤掉不支持的文件类型
+    const filteredFiles = [];
+    collectedFiles.forEach((file) => {
+        if (isKnownFileType(file.path)) {
+            filteredFiles.push(file);
+        }
+        else {
+            logger.warn(`跳过不支持的文件类型: ${file.path}`);
+        }
+    });
     return {
-        collectedFiles,
+        collectedFiles: filteredFiles,
         config,
         projectRoot,
         srcDir,
@@ -38305,6 +38514,10 @@ async function createAppInIde(entry, options) {
     logger.info('开始创建应用在 IDE 中...');
     // 收集需要处理的文件
     const { collectedFiles, config } = await resolveNASLFiles(entry, logger, false, options?.verbose);
+    if (config.useOPENAPI) {
+        logger.error('create-app-in-ide 暂不支持 useOPENAPI 模式');
+        logger.exit(1);
+    }
     // 生成 fullNaturalTS
     logger.newLine();
     logger.info('正在生成 NaturalTS 代码...');
@@ -38424,10 +38637,7 @@ const transformFns = {
             jsonContent = libExports.readFileSync(entry, 'utf-8');
             logger.info(`读取到 JSON 文件: ${entry}`);
         }
-        const files = await transformJson2FilesApi(jsonContent ? JSON.parse(jsonContent) : {}, {
-            serverBaseURL: config.serverBaseURL,
-            ideVersion: config.ideVersion,
-        });
+        const files = await transformJson2FilesApi(jsonContent ? JSON.parse(jsonContent) : {}, config);
         await Promise.all(files.map(async (file) => {
             const outputPath = sysPath.join(projectRoot, config.srcDir, file.path);
             await libExports.writeFile(outputPath, file.content);
@@ -38456,7 +38666,7 @@ async function transform(transformType, entry, options) {
     await transformFn(entry, options);
 }
 
-var version = "0.1.17";
+var version = "0.1.19";
 var pkg = {
 	version: version};
 
@@ -38760,7 +38970,7 @@ class ReaddirpStream extends Readable$1 {
         let entry;
         const basename = this._isDirent ? dirent.name : dirent;
         try {
-            const fullPath = resolve(join(path, basename));
+            const fullPath = resolve(join$1(path, basename));
             entry = { path: relative(this._root, fullPath), fullPath, basename };
             entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         }