isolated-deps 0.1.0

package/dist/index.js

@@ -0,0 +1,954 @@
+import * as __WEBPACK_EXTERNAL_MODULE_pintor__ from "pintor";
+import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
+import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+import * as __WEBPACK_EXTERNAL_MODULE_child_process__ from "child_process";
+import * as __WEBPACK_EXTERNAL_MODULE_module__ from "module";
+import * as __WEBPACK_EXTERNAL_MODULE_url__ from "url";
+import * as __WEBPACK_EXTERNAL_MODULE_os__ from "os";
+function optionalToolingSetup(integrations, fallback, isAuthor) {
+    const list = integrations && integrations.length > 0 ? integrations : [
+        fallback
+    ];
+    const prefix = isAuthor ? __WEBPACK_EXTERNAL_MODULE_pintor__["default"].brightMagenta("\u25BA\u25BA\u25BA Author says") : __WEBPACK_EXTERNAL_MODULE_pintor__["default"].gray("\u25BA\u25BA\u25BA");
+    const suffix = 'true' === process.env.EXTENSION_ONE_TIME_INSTALL_HINT ? ' (this is a one time operation)' : '';
+    return list.map((integration)=>`${prefix} Installing specialized dependencies for ${integration}...${suffix}`);
+}
+function optionalToolingRootInstall(integration) {
+    return `${__WEBPACK_EXTERNAL_MODULE_pintor__["default"].brightMagenta("\u25BA\u25BA\u25BA Author says")} [${integration}] Installing root dependencies for dev...`;
+}
+function optionalToolingReady(integration) {
+    return `${__WEBPACK_EXTERNAL_MODULE_pintor__["default"].brightMagenta("\u25BA\u25BA\u25BA Author says")} ${integration} tooling ready.`;
+}
+function optionalInstallFailed(integration, error, isAuthor) {
+    const prefix = isAuthor ? __WEBPACK_EXTERNAL_MODULE_pintor__["default"].brightMagenta('ERROR Author says') : __WEBPACK_EXTERNAL_MODULE_pintor__["default"].red('ERROR');
+    return `${prefix} [${integration}] Failed to install dependencies.\n${__WEBPACK_EXTERNAL_MODULE_pintor__["default"].red(String((null == error ? void 0 : error.message) || error))}`;
+}
+function optionalInstallManagerMissing(integration) {
+    const prefix = __WEBPACK_EXTERNAL_MODULE_pintor__["default"].red('ERROR');
+    return [
+        `${prefix} [${integration}] No supported package manager found in PATH.`,
+        'Install pnpm, npm, yarn, or bun and retry.',
+        'If you use pnpm, ensure it is available in your environment (e.g. corepack or PATH).',
+        'Override detection with:',
+        `  ${__WEBPACK_EXTERNAL_MODULE_pintor__["default"].gray('EXTENSION_JS_PACKAGE_MANAGER=pnpm|npm|yarn|bun')}`,
+        `  ${__WEBPACK_EXTERNAL_MODULE_pintor__["default"].gray('EXTENSION_JS_PM_EXEC_PATH=/path/to/npm-cli.js')}`,
+        'If you are on WSL, run the CLI inside a WSL shell so PATH is consistent.'
+    ].join('\n');
+}
+function parseOptionalDependencySpec(spec) {
+    const normalized = String(spec || '').trim();
+    const versionSeparator = normalized.lastIndexOf('@');
+    if (versionSeparator <= 0) throw new Error(`Expected an exact dependency spec like "postcss@8.5.6" or "@scope/pkg@1.2.3", received "${spec}".`);
+    const packageId = normalized.slice(0, versionSeparator);
+    const versionSpecifier = normalized.slice(versionSeparator + 1);
+    if (!packageId || !versionSpecifier) throw new Error(`Expected an exact dependency spec like "postcss@8.5.6" or "@scope/pkg@1.2.3", received "${spec}".`);
+    return {
+        packageId,
+        versionSpecifier
+    };
+}
+function getPackageIdFromSpec(spec) {
+    return parseOptionalDependencySpec(spec).packageId;
+}
+function getVersionSpecifierFromSpec(spec) {
+    return parseOptionalDependencySpec(spec).versionSpecifier;
+}
+const package_manager_require = (0, __WEBPACK_EXTERNAL_MODULE_module__.createRequire)(import.meta.url);
+const package_manager_currentDir = __WEBPACK_EXTERNAL_MODULE_path__.dirname((0, __WEBPACK_EXTERNAL_MODULE_url__.fileURLToPath)(import.meta.url));
+function getRuntimeRequire() {
+    return globalThis.__OPTIONAL_DEPS_REQUIRE__ || package_manager_require;
+}
+function normalizePackageManager(value) {
+    if (!value) return;
+    const lower = value.toLowerCase().trim();
+    if ('pnpm' === lower) return 'pnpm';
+    if ('yarn' === lower) return 'yarn';
+    if ('bun' === lower) return 'bun';
+    if ('npm' === lower) return 'npm';
+}
+function inferPackageManagerFromPath(value) {
+    if (!value) return;
+    const lower = value.toLowerCase();
+    if (lower.includes('pnpm')) return 'pnpm';
+    if (lower.includes('yarn')) return 'yarn';
+    if (lower.includes('bun')) return 'bun';
+    if (lower.includes('npm')) return 'npm';
+}
+function getPackageManagerOverride() {
+    const name = normalizePackageManager(process.env.EXTENSION_JS_PACKAGE_MANAGER);
+    const explicitExecPath = process.env.EXTENSION_JS_PM_EXEC_PATH;
+    const inheritedExecPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || void 0;
+    const execPath = explicitExecPath || (name ? void 0 : inheritedExecPath);
+    if (!name && !execPath) return;
+    const inferredName = name || inferPackageManagerFromPath(execPath) || 'npm';
+    return {
+        name: inferredName,
+        execPath
+    };
+}
+function detectPackageManagerFromEnv() {
+    const userAgent = process.env.npm_config_user_agent || '';
+    const execPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || '';
+    if (userAgent.includes('pnpm')) return {
+        name: 'pnpm',
+        execPath: execPath || void 0
+    };
+    if (userAgent.includes('yarn')) return {
+        name: 'yarn',
+        execPath: execPath || void 0
+    };
+    if (userAgent.includes('bun')) return {
+        name: 'bun',
+        execPath: execPath || void 0
+    };
+    if (userAgent.includes('npm')) return {
+        name: 'npm',
+        execPath: execPath || void 0
+    };
+    if (execPath) {
+        const inferred = inferPackageManagerFromPath(execPath) || 'npm';
+        return {
+            name: inferred,
+            execPath
+        };
+    }
+}
+function resolveNpmCliFromNode(execPath) {
+    const execDir = __WEBPACK_EXTERNAL_MODULE_path__.dirname(execPath);
+    const candidates = [
+        __WEBPACK_EXTERNAL_MODULE_path__.join(execDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+        __WEBPACK_EXTERNAL_MODULE_path__.join(execDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+        __WEBPACK_EXTERNAL_MODULE_path__.join(execDir, '..', 'node_modules', 'npm', 'bin', 'npm-cli.js')
+    ];
+    for (const candidate of candidates)if (__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(candidate)) return candidate;
+}
+function resolveBundledNpmCliPath() {
+    if (process.env.EXTENSION_JS_PM_EXEC_PATH) {
+        const overridePath = process.env.EXTENSION_JS_PM_EXEC_PATH;
+        if (overridePath && __WEBPACK_EXTERNAL_MODULE_fs__.existsSync(overridePath)) return overridePath;
+    }
+    try {
+        const resolved = getRuntimeRequire().resolve('npm/bin/npm-cli.js', {
+            paths: [
+                process.cwd(),
+                package_manager_currentDir
+            ]
+        });
+        if (resolved && __WEBPACK_EXTERNAL_MODULE_fs__.existsSync(resolved)) return resolved;
+    } catch  {}
+    return resolveNpmCliFromNode(process.execPath);
+}
+function isWindowsExecutablePath(value) {
+    if (!value || 'win32' !== process.platform) return false;
+    return /\.(cmd|bat|exe)$/i.test(value);
+}
+function isNodeScriptPath(value) {
+    if (!value) return false;
+    return /\.(mjs|cjs|js)$/i.test(value);
+}
+function resolveWindowsCommandPath(command) {
+    if ('win32' !== process.platform) return;
+    try {
+        const systemRoot = process.env.SystemRoot || 'C:\\Windows';
+        const whereExe = __WEBPACK_EXTERNAL_MODULE_path__.join(systemRoot, 'System32', 'where.exe');
+        const whereCommand = __WEBPACK_EXTERNAL_MODULE_fs__.existsSync(whereExe) ? whereExe : 'where';
+        const output = (0, __WEBPACK_EXTERNAL_MODULE_child_process__.execFileSync)(whereCommand, [
+            command
+        ], {
+            encoding: 'utf8',
+            stdio: [
+                'ignore',
+                'pipe',
+                'ignore'
+            ],
+            windowsHide: true
+        });
+        const candidates = String(output).split(/\r?\n/).map((line)=>line.trim()).filter(Boolean);
+        const cmdMatch = candidates.find((line)=>/\.cmd$/i.test(line));
+        return cmdMatch || candidates[0];
+    } catch  {
+        return;
+    }
+}
+function resolveUnixCommandPath(command) {
+    if ('win32' === process.platform) return;
+    try {
+        const output = (0, __WEBPACK_EXTERNAL_MODULE_child_process__.execFileSync)('which', [
+            command
+        ], {
+            encoding: 'utf8',
+            stdio: [
+                'ignore',
+                'pipe',
+                'ignore'
+            ]
+        });
+        const candidate = String(output).trim();
+        return candidate || void 0;
+    } catch  {
+        return;
+    }
+}
+function resolveCommandOnPath(command) {
+    return resolveWindowsCommandPath(command) || resolveUnixCommandPath(command) || void 0;
+}
+function canRunCorepack() {
+    try {
+        const fallback = getRuntimeRequire()('child_process');
+        const spawnSync = (null === __WEBPACK_EXTERNAL_MODULE_child_process__.spawnSync || void 0 === __WEBPACK_EXTERNAL_MODULE_child_process__.spawnSync ? void 0 : __WEBPACK_EXTERNAL_MODULE_child_process__.spawnSync.mock) !== void 0 ? __WEBPACK_EXTERNAL_MODULE_child_process__.spawnSync : fallback.spawnSync || __WEBPACK_EXTERNAL_MODULE_child_process__.spawnSync;
+        const result = spawnSync('corepack', [
+            '--version'
+        ], {
+            stdio: 'ignore',
+            windowsHide: true
+        });
+        return (null == result ? void 0 : result.status) === 0;
+    } catch  {
+        return false;
+    }
+}
+function detectByLockfile(cwd) {
+    if (!cwd) return;
+    const hasPnpmLock = __WEBPACK_EXTERNAL_MODULE_fs__.existsSync(__WEBPACK_EXTERNAL_MODULE_path__.join(cwd, 'pnpm-lock.yaml'));
+    const hasYarnLock = __WEBPACK_EXTERNAL_MODULE_fs__.existsSync(__WEBPACK_EXTERNAL_MODULE_path__.join(cwd, 'yarn.lock'));
+    const hasNpmLock = __WEBPACK_EXTERNAL_MODULE_fs__.existsSync(__WEBPACK_EXTERNAL_MODULE_path__.join(cwd, 'package-lock.json'));
+    if (hasPnpmLock) return 'pnpm';
+    if (hasYarnLock) return 'yarn';
+    if (hasNpmLock) return 'npm';
+}
+function hydrateResolvedPackageManager(name) {
+    const resolvedCommand = resolveCommandOnPath(name);
+    if (resolvedCommand) return {
+        name,
+        execPath: resolvedCommand
+    };
+    if ('npm' === name) {
+        const bundledNpmCli = resolveBundledNpmCliPath();
+        if (bundledNpmCli) return {
+            name: 'npm',
+            execPath: bundledNpmCli,
+            runnerCommand: process.execPath,
+            runnerArgs: [
+                bundledNpmCli
+            ]
+        };
+    }
+}
+function resolvePackageManager(opts) {
+    const lockPm = detectByLockfile(null == opts ? void 0 : opts.cwd);
+    if (lockPm) {
+        const hydrated = hydrateResolvedPackageManager(lockPm);
+        if (hydrated) return hydrated;
+        return {
+            name: lockPm
+        };
+    }
+    const override = getPackageManagerOverride();
+    if (override) return override;
+    const envPm = detectPackageManagerFromEnv();
+    if (envPm) return envPm;
+    const candidates = [
+        'pnpm',
+        'yarn',
+        'bun'
+    ];
+    for (const candidate of candidates){
+        const resolved = resolveCommandOnPath(candidate);
+        if (resolved) return {
+            name: candidate,
+            execPath: resolved
+        };
+    }
+    const corepackPath = resolveCommandOnPath('corepack');
+    if (corepackPath || canRunCorepack()) return {
+        name: 'pnpm',
+        runnerCommand: corepackPath || 'corepack',
+        runnerArgs: [
+            'pnpm'
+        ]
+    };
+    const bundledNpmCli = resolveBundledNpmCliPath();
+    if (bundledNpmCli) return {
+        name: 'npm',
+        execPath: bundledNpmCli,
+        runnerCommand: process.execPath,
+        runnerArgs: [
+            bundledNpmCli
+        ]
+    };
+    return {
+        name: 'npm'
+    };
+}
+function buildExecEnv() {
+    if ('win32' !== process.platform) return;
+    const nodeDir = __WEBPACK_EXTERNAL_MODULE_path__.dirname(process.execPath);
+    const pathSep = __WEBPACK_EXTERNAL_MODULE_path__.delimiter;
+    const existing = process.env.PATH || process.env.Path || '';
+    if (existing.includes(nodeDir)) return;
+    return {
+        ...process.env,
+        PATH: `${nodeDir}${pathSep}${existing}`.trim(),
+        Path: `${nodeDir}${pathSep}${existing}`.trim()
+    };
+}
+function buildInstallCommand(pm, args) {
+    if (pm.runnerCommand) return {
+        command: pm.runnerCommand,
+        args: [
+            ...pm.runnerArgs || [],
+            ...args
+        ]
+    };
+    if (pm.execPath) {
+        if (isWindowsExecutablePath(pm.execPath)) return {
+            command: pm.execPath,
+            args
+        };
+        if (isNodeScriptPath(pm.execPath)) return {
+            command: process.execPath,
+            args: [
+                pm.execPath,
+                ...args
+            ]
+        };
+        return {
+            command: pm.execPath,
+            args
+        };
+    }
+    return {
+        command: pm.name,
+        args
+    };
+}
+function buildNpmCliFallback(args) {
+    const npmCli = resolveBundledNpmCliPath();
+    if (!npmCli) return;
+    return {
+        command: process.execPath,
+        args: [
+            npmCli,
+            ...args
+        ]
+    };
+}
+function buildSpawnInvocation(command, args) {
+    return {
+        command,
+        args
+    };
+}
+function execInstallCommand(command, args, options) {
+    const invocation = buildSpawnInvocation(command, args);
+    const env = buildExecEnv();
+    const stdio = (null == options ? void 0 : options.stdio) ?? 'ignore';
+    const useShell = 'win32' === process.platform && /\.(cmd|bat)$/i.test(invocation.command);
+    return new Promise((resolve, reject)=>{
+        const child = (0, __WEBPACK_EXTERNAL_MODULE_child_process__.spawn)(invocation.command, invocation.args, {
+            cwd: null == options ? void 0 : options.cwd,
+            stdio,
+            env: (null == options ? void 0 : options.env) || env || process.env,
+            ...useShell ? {
+                shell: true
+            } : {}
+        });
+        child.on('close', (code)=>{
+            if (0 !== code) reject(new Error(`Install failed with exit code ${code}`));
+            else resolve();
+        });
+        child.on('error', (error)=>reject(error));
+    });
+}
+var package_namespaceObject = {
+    i8: "0.1.0"
+};
+function parseJsonSafe(text) {
+    const raw = 'string' == typeof text ? text : String(text || '');
+    const s = raw && 0xfeff === raw.charCodeAt(0) ? raw.slice(1) : raw;
+    return JSON.parse(s || '{}');
+}
+function ensureOptionalInstallBaseDir(installBaseDir) {
+    __WEBPACK_EXTERNAL_MODULE_fs__.mkdirSync(installBaseDir, {
+        recursive: true
+    });
+    const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_path__.join(installBaseDir, 'package.json');
+    if (!__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(packageJsonPath)) __WEBPACK_EXTERNAL_MODULE_fs__.writeFileSync(packageJsonPath, JSON.stringify({
+        name: `extensionjs-optional-deps-${package_namespaceObject.i8}`,
+        private: true,
+        version: package_namespaceObject.i8
+    }, null, 2) + '\n');
+}
+function removePathIfExists(targetPath) {
+    if (!__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(targetPath)) return;
+    __WEBPACK_EXTERNAL_MODULE_fs__.rmSync(targetPath, {
+        recursive: true,
+        force: true
+    });
+}
+function resetOptionalInstallRoot(installBaseDir) {
+    removePathIfExists(__WEBPACK_EXTERNAL_MODULE_path__.join(installBaseDir, 'node_modules'));
+    removePathIfExists(__WEBPACK_EXTERNAL_MODULE_path__.join(installBaseDir, 'package-lock.json'));
+    removePathIfExists(__WEBPACK_EXTERNAL_MODULE_path__.join(installBaseDir, 'npm-shrinkwrap.json'));
+    removePathIfExists(__WEBPACK_EXTERNAL_MODULE_path__.join(installBaseDir, 'pnpm-lock.yaml'));
+    removePathIfExists(__WEBPACK_EXTERNAL_MODULE_path__.join(installBaseDir, 'yarn.lock'));
+    removePathIfExists(__WEBPACK_EXTERNAL_MODULE_path__.join(installBaseDir, 'bun.lock'));
+}
+function getOptionalDependencyMap(dependencySpecs) {
+    const dependencyMap = {};
+    for (const spec of dependencySpecs){
+        const dependencyId = getPackageIdFromSpec(spec);
+        dependencyMap[dependencyId] = getVersionSpecifierFromSpec(spec);
+    }
+    return dependencyMap;
+}
+function ensureOptionalDependenciesManifest(installBaseDir, dependencySpecs) {
+    if (!dependencySpecs.length) return;
+    const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_path__.join(installBaseDir, 'package.json');
+    const current = parseJsonSafe(__WEBPACK_EXTERNAL_MODULE_fs__.readFileSync(packageJsonPath, 'utf8'));
+    const nextOptionalDependencies = {
+        ...current.optionalDependencies || {},
+        ...getOptionalDependencyMap(dependencySpecs)
+    };
+    const didChange = dependencySpecs.some((spec)=>{
+        var _current_optionalDependencies;
+        return (null == (_current_optionalDependencies = current.optionalDependencies) ? void 0 : _current_optionalDependencies[getPackageIdFromSpec(spec)]) !== nextOptionalDependencies[getPackageIdFromSpec(spec)];
+    });
+    if (!didChange) return;
+    __WEBPACK_EXTERNAL_MODULE_fs__.writeFileSync(packageJsonPath, JSON.stringify({
+        ...current,
+        private: true,
+        optionalDependencies: nextOptionalDependencies
+    }, null, 2) + '\n');
+}
+function prepareOptionalInstallState(input) {
+    if (input.forceRecreateInstallRoot) resetOptionalInstallRoot(input.installBaseDir);
+    ensureOptionalInstallBaseDir(input.installBaseDir);
+    ensureOptionalDependenciesManifest(input.installBaseDir, input.dependencySpecs);
+}
+function isPackageEntry(entry) {
+    return entry.isDirectory() || entry.isSymbolicLink();
+}
+function getDirectPackageDir(dependencyId, installRoot) {
+    return __WEBPACK_EXTERNAL_MODULE_path__.join(installRoot, 'node_modules', ...dependencyId.split('/'));
+}
+function listInstalledPackageDirs(nodeModulesDir) {
+    if (!__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(nodeModulesDir)) return [];
+    try {
+        const entries = __WEBPACK_EXTERNAL_MODULE_fs__.readdirSync(nodeModulesDir, {
+            withFileTypes: true
+        });
+        const packageDirs = [];
+        for (const entry of entries){
+            if (!isPackageEntry(entry) || '.bin' === entry.name) continue;
+            const entryPath = __WEBPACK_EXTERNAL_MODULE_path__.join(nodeModulesDir, entry.name);
+            if (!entry.name.startsWith('@')) {
+                packageDirs.push(entryPath);
+                continue;
+            }
+            const scopedEntries = __WEBPACK_EXTERNAL_MODULE_fs__.readdirSync(entryPath, {
+                withFileTypes: true
+            });
+            for (const scopedEntry of scopedEntries)if (isPackageEntry(scopedEntry)) packageDirs.push(__WEBPACK_EXTERNAL_MODULE_path__.join(entryPath, scopedEntry.name));
+        }
+        return packageDirs;
+    } catch  {
+        return [];
+    }
+}
+function findPackageDirInPnpmStore(dependencyId, installRoot) {
+    const pnpmStoreDir = __WEBPACK_EXTERNAL_MODULE_path__.join(installRoot, 'node_modules', '.pnpm');
+    if (!__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(pnpmStoreDir)) return;
+    try {
+        const storeEntries = __WEBPACK_EXTERNAL_MODULE_fs__.readdirSync(pnpmStoreDir, {
+            withFileTypes: true
+        });
+        for (const entry of storeEntries){
+            if (!isPackageEntry(entry) || 'node_modules' === entry.name) continue;
+            const candidatePackageJson = __WEBPACK_EXTERNAL_MODULE_path__.join(pnpmStoreDir, entry.name, 'node_modules', ...dependencyId.split('/'), 'package.json');
+            if (__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(candidatePackageJson)) return __WEBPACK_EXTERNAL_MODULE_path__.dirname(candidatePackageJson);
+        }
+    } catch  {}
+}
+function findNestedPackageDir(dependencyId, installRoot) {
+    const directPackageJson = __WEBPACK_EXTERNAL_MODULE_path__.join(getDirectPackageDir(dependencyId, installRoot), 'package.json');
+    if (__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(directPackageJson)) return __WEBPACK_EXTERNAL_MODULE_path__.dirname(directPackageJson);
+    const fromPnpmStore = findPackageDirInPnpmStore(dependencyId, installRoot);
+    if (fromPnpmStore) return fromPnpmStore;
+    const visited = new Set();
+    const queue = [
+        {
+            nodeModulesDir: __WEBPACK_EXTERNAL_MODULE_path__.join(installRoot, 'node_modules'),
+            depth: 0
+        }
+    ];
+    const maxDepth = 4;
+    while(queue.length > 0){
+        const current = queue.shift();
+        if (visited.has(current.nodeModulesDir)) continue;
+        visited.add(current.nodeModulesDir);
+        const candidatePackageJson = __WEBPACK_EXTERNAL_MODULE_path__.join(current.nodeModulesDir, ...dependencyId.split('/'), 'package.json');
+        if (__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(candidatePackageJson)) return __WEBPACK_EXTERNAL_MODULE_path__.dirname(candidatePackageJson);
+        if (current.depth >= maxDepth) continue;
+        for (const packageDir of listInstalledPackageDirs(current.nodeModulesDir)){
+            const nestedNodeModulesDir = __WEBPACK_EXTERNAL_MODULE_path__.join(packageDir, 'node_modules');
+            if (__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(nestedNodeModulesDir)) queue.push({
+                nodeModulesDir: nestedNodeModulesDir,
+                depth: current.depth + 1
+            });
+        }
+    }
+}
+function readPackageJsonFromDir(packageDir) {
+    const manifestPath = __WEBPACK_EXTERNAL_MODULE_path__.join(packageDir, 'package.json');
+    if (!__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(manifestPath)) return;
+    try {
+        return JSON.parse(__WEBPACK_EXTERNAL_MODULE_fs__.readFileSync(manifestPath, 'utf8') || '{}');
+    } catch  {
+        return;
+    }
+}
+function getPackageEntryCandidates(pkg) {
+    var _pkg_exports;
+    const candidateEntries = [];
+    if ('string' == typeof (null == pkg ? void 0 : pkg.main)) candidateEntries.push(pkg.main);
+    if ('string' == typeof (null == pkg ? void 0 : pkg.module)) candidateEntries.push(pkg.module);
+    if ('string' == typeof (null == pkg ? void 0 : pkg.exports)) candidateEntries.push(pkg.exports);
+    const dotExport = null == pkg ? void 0 : null == (_pkg_exports = pkg.exports) ? void 0 : _pkg_exports['.'];
+    if ('string' == typeof dotExport) candidateEntries.push(dotExport);
+    if (dotExport && 'object' == typeof dotExport) {
+        if ('string' == typeof dotExport.require) candidateEntries.push(dotExport.require);
+        if ('string' == typeof dotExport.default) candidateEntries.push(dotExport.default);
+        if ('string' == typeof dotExport.import) candidateEntries.push(dotExport.import);
+    }
+    candidateEntries.push('index.js', 'index.cjs', 'index.mjs');
+    return candidateEntries;
+}
+function resolveFromPackageDir(packageDir) {
+    if (!__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(packageDir)) return;
+    const pkg = readPackageJsonFromDir(packageDir);
+    if (!pkg) return;
+    for (const relativeEntry of getPackageEntryCandidates(pkg)){
+        const absoluteEntry = __WEBPACK_EXTERNAL_MODULE_path__.resolve(packageDir, relativeEntry);
+        if (__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(absoluteEntry)) return absoluteEntry;
+    }
+}
+function resolvePackageFromInstallRoot(dependencyId, installRoot) {
+    const packageDir = findNestedPackageDir(dependencyId, installRoot);
+    if (!packageDir) return;
+    return resolveFromPackageDir(packageDir);
+}
+const runtime_context_require = (0, __WEBPACK_EXTERNAL_MODULE_module__.createRequire)(import.meta.url);
+const runtime_context_currentDir = __WEBPACK_EXTERNAL_MODULE_path__.dirname((0, __WEBPACK_EXTERNAL_MODULE_url__.fileURLToPath)(import.meta.url));
+function runtime_context_getRuntimeRequire() {
+    return globalThis.__OPTIONAL_DEPS_REQUIRE__ || runtime_context_require;
+}
+function runtime_context_parseJsonSafe(text) {
+    const raw = 'string' == typeof text ? text : String(text || '');
+    const s = raw && 0xfeff === raw.charCodeAt(0) ? raw.slice(1) : raw;
+    return JSON.parse(s || '{}');
+}
+function resolveDevelopRootFromDir(dir) {
+    try {
+        const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_path__.join(dir, 'package.json');
+        if (!__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(packageJsonPath)) return;
+        const pkg = runtime_context_parseJsonSafe(__WEBPACK_EXTERNAL_MODULE_fs__.readFileSync(packageJsonPath, 'utf8'));
+        if ((null == pkg ? void 0 : pkg.name) === 'extension-develop') return dir;
+    } catch  {}
+}
+function findDevelopRootFrom(startDir) {
+    let currentDir = startDir;
+    const maxDepth = 6;
+    for(let i = 0; i < maxDepth; i++){
+        const root = resolveDevelopRootFromDir(currentDir);
+        if (root) return root;
+        const parent = __WEBPACK_EXTERNAL_MODULE_path__.dirname(currentDir);
+        if (parent === currentDir) break;
+        currentDir = parent;
+    }
+}
+function resolveDevelopInstallRoot() {
+    const directRoot = findExtensionDevelopRoot();
+    if (directRoot) return directRoot;
+    try {
+        const candidateRoot = findDevelopRootFrom(runtime_context_currentDir);
+        if (candidateRoot) return candidateRoot;
+    } catch  {}
+    try {
+        const pkgPath = runtime_context_getRuntimeRequire().resolve('extension-develop/package.json', {
+            paths: [
+                runtime_context_currentDir
+            ]
+        });
+        return resolveDevelopRootFromDir(__WEBPACK_EXTERNAL_MODULE_path__.dirname(pkgPath));
+    } catch  {
+        return;
+    }
+}
+function findExtensionDevelopRoot() {
+    const webpackDir = __WEBPACK_EXTERNAL_MODULE_path__.resolve(runtime_context_currentDir, '..');
+    const packageRoot = __WEBPACK_EXTERNAL_MODULE_path__.resolve(webpackDir, '..');
+    const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_path__.join(packageRoot, 'package.json');
+    if (!__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(packageJsonPath)) return null;
+    try {
+        const pkg = JSON.parse(__WEBPACK_EXTERNAL_MODULE_fs__.readFileSync(packageJsonPath, 'utf8'));
+        if ('extension-develop' === pkg.name) return packageRoot;
+    } catch  {}
+    return null;
+}
+function getExtensionJsCacheBaseDir() {
+    const override = process.env.EXTENSION_JS_CACHE_DIR;
+    if (override) return __WEBPACK_EXTERNAL_MODULE_path__.resolve(override);
+    if ('win32' === process.platform && process.env.LOCALAPPDATA) return __WEBPACK_EXTERNAL_MODULE_path__.join(process.env.LOCALAPPDATA, 'extensionjs');
+    if (process.env.XDG_CACHE_HOME) return __WEBPACK_EXTERNAL_MODULE_path__.join(process.env.XDG_CACHE_HOME, 'extensionjs');
+    return __WEBPACK_EXTERNAL_MODULE_path__.join(__WEBPACK_EXTERNAL_MODULE_os__.homedir(), '.cache', 'extensionjs');
+}
+function resolveOptionalInstallRoot() {
+    const version = process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION || package_namespaceObject.i8;
+    return __WEBPACK_EXTERNAL_MODULE_path__.join(getExtensionJsCacheBaseDir(), 'optional-deps', version);
+}
+function hasDependency(projectPath, dependency) {
+    const findNearestPackageJsonDirectory = (startPath)=>{
+        let currentDirectory = startPath;
+        const maxDepth = 4;
+        for(let i = 0; i < maxDepth; i++){
+            const candidate = __WEBPACK_EXTERNAL_MODULE_path__.join(currentDirectory, 'package.json');
+            if (__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(candidate)) return currentDirectory;
+            const parentDirectory = __WEBPACK_EXTERNAL_MODULE_path__.dirname(currentDirectory);
+            if (parentDirectory === currentDirectory) break;
+            currentDirectory = parentDirectory;
+        }
+    };
+    const packageJsonDirectory = findNearestPackageJsonDirectory(projectPath);
+    if (!packageJsonDirectory) return false;
+    const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_path__.join(packageJsonDirectory, 'package.json');
+    if (!__WEBPACK_EXTERNAL_MODULE_fs__.existsSync(packageJsonPath)) return false;
+    const parsed = runtime_context_parseJsonSafe(__WEBPACK_EXTERNAL_MODULE_fs__.readFileSync(packageJsonPath, 'utf8'));
+    const dependencies = parsed.dependencies || {};
+    const devDependencies = parsed.devDependencies || {};
+    return !!dependencies[dependency] || !!devDependencies[dependency];
+}
+function getMissingDependenciesAtInstallRoot(dependencyIds, installBaseDir) {
+    return dependencyIds.filter((dependencyId)=>!resolvePackageFromInstallRoot(dependencyId, installBaseDir));
+}
+function filterSpecsByPackageIds(dependencySpecs, dependencyIds) {
+    const wantedIds = new Set(dependencyIds);
+    return dependencySpecs.filter((spec)=>wantedIds.has(getPackageIdFromSpec(spec)));
+}
+function parseWslUncPath(value) {
+    const match = /^\\\\wsl(?:\.localhost)?\\([^\\]+)\\(.+)$/.exec(value);
+    if (!match) return null;
+    const distro = match[1];
+    const rel = match[2].replace(/\\/g, '/').replace(/^\/+/, '');
+    return {
+        distro,
+        path: `/${rel}`
+    };
+}
+function isWslMountPath(value) {
+    return /^\/mnt\/[a-z]\//i.test(value);
+}
+function resolveWslContext(installBaseDir) {
+    if ('win32' !== process.platform) return {
+        useWsl: false
+    };
+    const trimmed = String(installBaseDir || '').trim();
+    if (!trimmed) return {
+        useWsl: false
+    };
+    const unc = parseWslUncPath(trimmed);
+    if (unc) return {
+        useWsl: true,
+        distro: unc.distro,
+        installDir: unc.path
+    };
+    if (isWslMountPath(trimmed)) return {
+        useWsl: true,
+        installDir: trimmed
+    };
+    return {
+        useWsl: false
+    };
+}
+function wrapCommandForWsl(command, context) {
+    if (!context.useWsl) return command;
+    const args = [
+        ...context.distro ? [
+            '-d',
+            context.distro
+        ] : [],
+        '--'
+    ];
+    args.push(command.command, ...command.args);
+    return {
+        command: 'wsl.exe',
+        args
+    };
+}
+function isMissingManagerError(error) {
+    const err = error;
+    return (null == err ? void 0 : err.code) === 'ENOENT' || String((null == err ? void 0 : err.message) || '').includes('ENOENT') || String((null == err ? void 0 : err.message) || '').includes('not found');
+}
+function isInstallExitFailure(error) {
+    return /Install failed with exit code \d+/.test(String((null == error ? void 0 : error.message) || error || ''));
+}
+async function execInstallWithFallback(command, options) {
+    try {
+        await execInstallCommand(command.command, command.args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: 'inherit'
+        });
+        return;
+    } catch (error) {
+        if (options.fallbackNpmCommand && (isMissingManagerError(error) || options.allowFallbackOnFailure && isInstallExitFailure(error))) return void await execInstallCommand(options.fallbackNpmCommand.command, options.fallbackNpmCommand.args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: 'inherit'
+        });
+        throw error;
+    }
+}
+async function preferCorepackFallback(pm) {
+    if ('npm' !== pm.name || pm.execPath || pm.runnerCommand) return pm;
+    const npmUserAgent = process.env.npm_config_user_agent || '';
+    const npmExecPath = process.env.npm_execpath || process.env.NPM_EXEC_PATH || '';
+    if (npmUserAgent.includes('npm') || npmExecPath) return pm;
+    try {
+        const { spawnSync } = await import("child_process");
+        const result = spawnSync('corepack', [
+            '--version'
+        ], {
+            stdio: 'ignore',
+            windowsHide: true
+        });
+        if ((null == result ? void 0 : result.status) === 0) return {
+            name: 'pnpm',
+            runnerCommand: 'corepack',
+            runnerArgs: [
+                'pnpm'
+            ]
+        };
+    } catch  {}
+    return pm;
+}
+function getOptionalInstallCommand(pm, dependencySpecs, installBaseDir) {
+    const pmName = pm.name;
+    if ('yarn' === pmName) return buildInstallCommand(pm, [
+        '--cwd',
+        installBaseDir,
+        'add',
+        ...dependencySpecs,
+        '--optional'
+    ]);
+    if ('npm' === pmName) return getRootInstallCommand(pm, installBaseDir);
+    if ('pnpm' === pmName) return buildInstallCommand(pm, [
+        'install',
+        '--dir',
+        installBaseDir,
+        '--ignore-workspace',
+        '--lockfile=false',
+        '--silent'
+    ]);
+    if ('bun' === pmName) return buildInstallCommand(pm, [
+        'add',
+        ...dependencySpecs,
+        '--cwd',
+        installBaseDir,
+        '--optional'
+    ]);
+    return buildInstallCommand(pm, [
+        '--silent',
+        'install',
+        ...dependencySpecs,
+        '--cwd',
+        installBaseDir,
+        '--optional'
+    ]);
+}
+function getRootInstallCommand(pm, installBaseDir) {
+    const pmName = pm.name;
+    const dirArgs = installBaseDir ? 'yarn' === pmName ? [
+        '--cwd',
+        installBaseDir
+    ] : 'pnpm' === pmName ? [
+        '--dir',
+        installBaseDir
+    ] : 'bun' === pmName ? [
+        '--cwd',
+        installBaseDir
+    ] : [
+        '--prefix',
+        installBaseDir
+    ] : [];
+    if ('yarn' === pmName) return buildInstallCommand(pm, [
+        ...dirArgs,
+        'install'
+    ]);
+    if ('npm' === pmName) return buildInstallCommand(pm, [
+        'install',
+        '--silent',
+        ...dirArgs
+    ]);
+    if ('pnpm' === pmName) return buildInstallCommand(pm, [
+        'install',
+        '--silent',
+        ...dirArgs,
+        '--ignore-workspace',
+        '--lockfile=false'
+    ]);
+    if ('bun' === pmName) return buildInstallCommand(pm, [
+        'install',
+        ...dirArgs
+    ]);
+    return buildInstallCommand(pm, [
+        'install',
+        '--silent',
+        ...dirArgs
+    ]);
+}
+async function runInstallAttempt(input) {
+    const env = 'yarn' === input.pm.name ? {
+        ...process.env,
+        YARN_ENABLE_IMMUTABLE_INSTALLS: 'false',
+        YARN_NODE_LINKER: 'node-modules'
+    } : process.env;
+    const installCommand = getOptionalInstallCommand(input.pm, input.dependencySpecs, input.wslContext.installDir || input.installBaseDir);
+    const execCommand = wrapCommandForWsl(installCommand, input.wslContext);
+    const fallbackNpmCommand = input.wslContext.useWsl ? void 0 : buildNpmCliFallback([
+        '--silent',
+        'install',
+        ...input.dependencySpecs,
+        '--prefix',
+        input.installBaseDir,
+        '--save-optional'
+    ]);
+    await execInstallWithFallback(execCommand, {
+        cwd: input.wslContext.useWsl ? void 0 : input.installBaseDir,
+        env,
+        fallbackNpmCommand,
+        allowFallbackOnFailure: !input.wslContext.useWsl && 'npm' !== input.pm.name && void 0 !== fallbackNpmCommand
+    });
+    await new Promise((resolve)=>setTimeout(resolve, 500));
+    const needsRootRelink = 'npm' !== input.pm.name && (input.isAuthor || input.dependencySpecs.length > 1);
+    if (!needsRootRelink) return;
+    if (input.isAuthor) console.log(optionalToolingRootInstall(input.integration));
+    const rootInstall = getRootInstallCommand(input.pm, input.wslContext.useWsl ? input.wslContext.installDir : void 0);
+    const rootCommand = wrapCommandForWsl(rootInstall, input.wslContext);
+    const rootFallbackCommand = input.wslContext.useWsl ? void 0 : buildNpmCliFallback([
+        '--silent',
+        'install',
+        '--prefix',
+        input.installBaseDir
+    ]);
+    await execInstallWithFallback(rootCommand, {
+        cwd: input.wslContext.useWsl ? void 0 : input.installBaseDir,
+        env,
+        fallbackNpmCommand: rootFallbackCommand,
+        allowFallbackOnFailure: !input.wslContext.useWsl && 'npm' !== input.pm.name && void 0 !== rootFallbackCommand
+    });
+    if (input.isAuthor) console.log(optionalToolingReady(input.integration));
+}
+async function installOptionalDependencies(integration, dependencySpecs, options) {
+    if (!dependencySpecs.length) return;
+    let pm;
+    let wslContext;
+    let installBaseDir;
+    const dependencyIds = dependencySpecs.map((spec)=>getPackageIdFromSpec(spec));
+    try {
+        installBaseDir = resolveOptionalInstallRoot();
+        prepareOptionalInstallState({
+            installBaseDir,
+            dependencySpecs,
+            forceRecreateInstallRoot: null == options ? void 0 : options.forceRecreateInstallRoot
+        });
+        pm = resolvePackageManager({
+            cwd: installBaseDir
+        });
+        wslContext = resolveWslContext(installBaseDir);
+        if (!wslContext.useWsl) pm = await preferCorepackFallback(pm);
+        const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+        const setupMessages = optionalToolingSetup([
+            integration
+        ], integration, isAuthor);
+        const setupMessage = setupMessages[0];
+        const hasIndex = Boolean((null == options ? void 0 : options.index) && (null == options ? void 0 : options.total));
+        const setupMessageWithIndex = hasIndex ? setupMessage.replace("\u25BA\u25BA\u25BA ", `\u{25BA}\u{25BA}\u{25BA} [${null == options ? void 0 : options.index}/${null == options ? void 0 : options.total}] `) : setupMessage;
+        if (isAuthor) console.warn(setupMessageWithIndex);
+        else console.log(setupMessageWithIndex);
+        await runInstallAttempt({
+            pm,
+            wslContext,
+            installBaseDir,
+            dependencySpecs,
+            isAuthor,
+            integration
+        });
+        let missingDependencies = getMissingDependenciesAtInstallRoot(dependencyIds, installBaseDir);
+        if (missingDependencies.length > 0 && 'npm' !== pm.name) {
+            await runInstallAttempt({
+                pm,
+                wslContext,
+                installBaseDir,
+                dependencySpecs: filterSpecsByPackageIds(dependencySpecs, missingDependencies),
+                isAuthor,
+                integration
+            });
+            missingDependencies = getMissingDependenciesAtInstallRoot(dependencyIds, installBaseDir);
+        }
+        if (missingDependencies.length > 0) {
+            prepareOptionalInstallState({
+                installBaseDir,
+                dependencySpecs,
+                forceRecreateInstallRoot: true
+            });
+            await runInstallAttempt({
+                pm,
+                wslContext,
+                installBaseDir,
+                dependencySpecs,
+                isAuthor,
+                integration
+            });
+            missingDependencies = getMissingDependenciesAtInstallRoot(dependencyIds, installBaseDir);
+        }
+        if (missingDependencies.length > 0) throw new Error(`[${integration}] Optional dependency install reported success but packages are missing: ${missingDependencies.join(', ')}`);
+        return true;
+    } catch (error) {
+        console.error('[extension.js][optional-deps] debug', {
+            platform: process.platform,
+            execPath: process.execPath,
+            cwd: process.cwd(),
+            path: process.env.PATH || process.env.Path,
+            comspec: process.env.ComSpec,
+            systemRoot: process.env.SystemRoot,
+            npm_execpath: process.env.npm_execpath,
+            npm_config_user_agent: process.env.npm_config_user_agent,
+            npm_config_prefix: process.env.npm_config_prefix,
+            npm_config_cache: process.env.npm_config_cache,
+            npm_config_userconfig: process.env.npm_config_userconfig,
+            installBaseDir,
+            wslContext,
+            pm,
+            errorCode: null == error ? void 0 : error.code,
+            errorMessage: error instanceof Error ? error.message : String(error || 'unknown error')
+        });
+        const isAuthor = 'true' === process.env.EXTENSION_AUTHOR_MODE;
+        if (isMissingManagerError(error)) console.error(optionalInstallManagerMissing(integration));
+        else console.error(optionalInstallFailed(integration, error, isAuthor));
+        return false;
+    }
+}
+async function installOptionalDependenciesBatch(plans) {
+    if (!plans.length) return;
+    console.log(`${__WEBPACK_EXTERNAL_MODULE_pintor__["default"].gray("\u25BA\u25BA\u25BA")} Found ${__WEBPACK_EXTERNAL_MODULE_pintor__["default"].yellow(String(plans.length))} specialized integration${1 === plans.length ? '' : 's'} needing installation...`);
+    for (const [index, plan] of plans.entries()){
+        const didInstall = await installOptionalDependencies(plan.integration, plan.dependencySpecs, {
+            index: index + 1,
+            total: plans.length
+        });
+        if (!didInstall) return false;
+    }
+    return true;
+}
+export { hasDependency, installOptionalDependencies, installOptionalDependenciesBatch, resolveDevelopInstallRoot, resolveOptionalInstallRoot, resolvePackageFromInstallRoot };