isolated-deps 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1034 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_modules__ = {
+    child_process: function(module) {
+        module.exports = import("child_process").then(function(module) {
+            return module;
+        });
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__, {
+        resolveDevelopInstallRoot: ()=>resolveDevelopInstallRoot,
+        resolvePackageFromInstallRoot: ()=>resolvePackageFromInstallRoot,
+        hasDependency: ()=>hasDependency,
+        resolveOptionalInstallRoot: ()=>resolveOptionalInstallRoot,
+        installOptionalDependenciesBatch: ()=>installOptionalDependenciesBatch,
+        installOptionalDependencies: ()=>installOptionalDependencies
+    });
+    const external_pintor_namespaceObject = require("pintor");
+    var external_pintor_default = /*#__PURE__*/ __webpack_require__.n(external_pintor_namespaceObject);
+    function optionalToolingSetup(integrations, fallback, isAuthor) {
+        const list = integrations && integrations.length > 0 ? integrations : [
+            fallback
+        ];
+        const prefix = isAuthor ? external_pintor_default().brightMagenta("\u25BA\u25BA\u25BA Author says") : external_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 `${external_pintor_default().brightMagenta("\u25BA\u25BA\u25BA Author says")} [${integration}] Installing root dependencies for dev...`;
+    }
+    function optionalToolingReady(integration) {
+        return `${external_pintor_default().brightMagenta("\u25BA\u25BA\u25BA Author says")} ${integration} tooling ready.`;
+    }
+    function optionalInstallFailed(integration, error, isAuthor) {
+        const prefix = isAuthor ? external_pintor_default().brightMagenta('ERROR Author says') : external_pintor_default().red('ERROR');
+        return `${prefix} [${integration}] Failed to install dependencies.\n${external_pintor_default().red(String((null == error ? void 0 : error.message) || error))}`;
+    }
+    function optionalInstallManagerMissing(integration) {
+        const prefix = external_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:',
+            `  ${external_pintor_default().gray('EXTENSION_JS_PACKAGE_MANAGER=pnpm|npm|yarn|bun')}`,
+            `  ${external_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 external_fs_namespaceObject = require("fs");
+    const external_path_namespaceObject = require("path");
+    const external_child_process_namespaceObject = require("child_process");
+    const external_module_namespaceObject = require("module");
+    const external_url_namespaceObject = require("url");
+    const package_manager_require = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+    const package_manager_currentDir = external_path_namespaceObject.dirname((0, external_url_namespaceObject.fileURLToPath)(__rslib_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 = external_path_namespaceObject.dirname(execPath);
+        const candidates = [
+            external_path_namespaceObject.join(execDir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+            external_path_namespaceObject.join(execDir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+            external_path_namespaceObject.join(execDir, '..', 'node_modules', 'npm', 'bin', 'npm-cli.js')
+        ];
+        for (const candidate of candidates)if (external_fs_namespaceObject.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 && external_fs_namespaceObject.existsSync(overridePath)) return overridePath;
+        }
+        try {
+            const resolved = getRuntimeRequire().resolve('npm/bin/npm-cli.js', {
+                paths: [
+                    process.cwd(),
+                    package_manager_currentDir
+                ]
+            });
+            if (resolved && external_fs_namespaceObject.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 = external_path_namespaceObject.join(systemRoot, 'System32', 'where.exe');
+            const whereCommand = external_fs_namespaceObject.existsSync(whereExe) ? whereExe : 'where';
+            const output = (0, external_child_process_namespaceObject.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, external_child_process_namespaceObject.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 === external_child_process_namespaceObject.spawnSync || void 0 === external_child_process_namespaceObject.spawnSync ? void 0 : external_child_process_namespaceObject.spawnSync.mock) !== void 0 ? external_child_process_namespaceObject.spawnSync : fallback.spawnSync || external_child_process_namespaceObject.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 = external_fs_namespaceObject.existsSync(external_path_namespaceObject.join(cwd, 'pnpm-lock.yaml'));
+        const hasYarnLock = external_fs_namespaceObject.existsSync(external_path_namespaceObject.join(cwd, 'yarn.lock'));
+        const hasNpmLock = external_fs_namespaceObject.existsSync(external_path_namespaceObject.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 = external_path_namespaceObject.dirname(process.execPath);
+        const pathSep = external_path_namespaceObject.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, external_child_process_namespaceObject.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) {
+        external_fs_namespaceObject.mkdirSync(installBaseDir, {
+            recursive: true
+        });
+        const packageJsonPath = external_path_namespaceObject.join(installBaseDir, 'package.json');
+        if (!external_fs_namespaceObject.existsSync(packageJsonPath)) external_fs_namespaceObject.writeFileSync(packageJsonPath, JSON.stringify({
+            name: `extensionjs-optional-deps-${package_namespaceObject.i8}`,
+            private: true,
+            version: package_namespaceObject.i8
+        }, null, 2) + '\n');
+    }
+    function removePathIfExists(targetPath) {
+        if (!external_fs_namespaceObject.existsSync(targetPath)) return;
+        external_fs_namespaceObject.rmSync(targetPath, {
+            recursive: true,
+            force: true
+        });
+    }
+    function resetOptionalInstallRoot(installBaseDir) {
+        removePathIfExists(external_path_namespaceObject.join(installBaseDir, 'node_modules'));
+        removePathIfExists(external_path_namespaceObject.join(installBaseDir, 'package-lock.json'));
+        removePathIfExists(external_path_namespaceObject.join(installBaseDir, 'npm-shrinkwrap.json'));
+        removePathIfExists(external_path_namespaceObject.join(installBaseDir, 'pnpm-lock.yaml'));
+        removePathIfExists(external_path_namespaceObject.join(installBaseDir, 'yarn.lock'));
+        removePathIfExists(external_path_namespaceObject.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 = external_path_namespaceObject.join(installBaseDir, 'package.json');
+        const current = parseJsonSafe(external_fs_namespaceObject.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;
+        external_fs_namespaceObject.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 external_path_namespaceObject.join(installRoot, 'node_modules', ...dependencyId.split('/'));
+    }
+    function listInstalledPackageDirs(nodeModulesDir) {
+        if (!external_fs_namespaceObject.existsSync(nodeModulesDir)) return [];
+        try {
+            const entries = external_fs_namespaceObject.readdirSync(nodeModulesDir, {
+                withFileTypes: true
+            });
+            const packageDirs = [];
+            for (const entry of entries){
+                if (!isPackageEntry(entry) || '.bin' === entry.name) continue;
+                const entryPath = external_path_namespaceObject.join(nodeModulesDir, entry.name);
+                if (!entry.name.startsWith('@')) {
+                    packageDirs.push(entryPath);
+                    continue;
+                }
+                const scopedEntries = external_fs_namespaceObject.readdirSync(entryPath, {
+                    withFileTypes: true
+                });
+                for (const scopedEntry of scopedEntries)if (isPackageEntry(scopedEntry)) packageDirs.push(external_path_namespaceObject.join(entryPath, scopedEntry.name));
+            }
+            return packageDirs;
+        } catch  {
+            return [];
+        }
+    }
+    function findPackageDirInPnpmStore(dependencyId, installRoot) {
+        const pnpmStoreDir = external_path_namespaceObject.join(installRoot, 'node_modules', '.pnpm');
+        if (!external_fs_namespaceObject.existsSync(pnpmStoreDir)) return;
+        try {
+            const storeEntries = external_fs_namespaceObject.readdirSync(pnpmStoreDir, {
+                withFileTypes: true
+            });
+            for (const entry of storeEntries){
+                if (!isPackageEntry(entry) || 'node_modules' === entry.name) continue;
+                const candidatePackageJson = external_path_namespaceObject.join(pnpmStoreDir, entry.name, 'node_modules', ...dependencyId.split('/'), 'package.json');
+                if (external_fs_namespaceObject.existsSync(candidatePackageJson)) return external_path_namespaceObject.dirname(candidatePackageJson);
+            }
+        } catch  {}
+    }
+    function findNestedPackageDir(dependencyId, installRoot) {
+        const directPackageJson = external_path_namespaceObject.join(getDirectPackageDir(dependencyId, installRoot), 'package.json');
+        if (external_fs_namespaceObject.existsSync(directPackageJson)) return external_path_namespaceObject.dirname(directPackageJson);
+        const fromPnpmStore = findPackageDirInPnpmStore(dependencyId, installRoot);
+        if (fromPnpmStore) return fromPnpmStore;
+        const visited = new Set();
+        const queue = [
+            {
+                nodeModulesDir: external_path_namespaceObject.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 = external_path_namespaceObject.join(current.nodeModulesDir, ...dependencyId.split('/'), 'package.json');
+            if (external_fs_namespaceObject.existsSync(candidatePackageJson)) return external_path_namespaceObject.dirname(candidatePackageJson);
+            if (current.depth >= maxDepth) continue;
+            for (const packageDir of listInstalledPackageDirs(current.nodeModulesDir)){
+                const nestedNodeModulesDir = external_path_namespaceObject.join(packageDir, 'node_modules');
+                if (external_fs_namespaceObject.existsSync(nestedNodeModulesDir)) queue.push({
+                    nodeModulesDir: nestedNodeModulesDir,
+                    depth: current.depth + 1
+                });
+            }
+        }
+    }
+    function readPackageJsonFromDir(packageDir) {
+        const manifestPath = external_path_namespaceObject.join(packageDir, 'package.json');
+        if (!external_fs_namespaceObject.existsSync(manifestPath)) return;
+        try {
+            return JSON.parse(external_fs_namespaceObject.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 (!external_fs_namespaceObject.existsSync(packageDir)) return;
+        const pkg = readPackageJsonFromDir(packageDir);
+        if (!pkg) return;
+        for (const relativeEntry of getPackageEntryCandidates(pkg)){
+            const absoluteEntry = external_path_namespaceObject.resolve(packageDir, relativeEntry);
+            if (external_fs_namespaceObject.existsSync(absoluteEntry)) return absoluteEntry;
+        }
+    }
+    function resolvePackageFromInstallRoot(dependencyId, installRoot) {
+        const packageDir = findNestedPackageDir(dependencyId, installRoot);
+        if (!packageDir) return;
+        return resolveFromPackageDir(packageDir);
+    }
+    const external_os_namespaceObject = require("os");
+    const runtime_context_require = (0, external_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+    const runtime_context_currentDir = external_path_namespaceObject.dirname((0, external_url_namespaceObject.fileURLToPath)(__rslib_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 = external_path_namespaceObject.join(dir, 'package.json');
+            if (!external_fs_namespaceObject.existsSync(packageJsonPath)) return;
+            const pkg = runtime_context_parseJsonSafe(external_fs_namespaceObject.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 = external_path_namespaceObject.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(external_path_namespaceObject.dirname(pkgPath));
+        } catch  {
+            return;
+        }
+    }
+    function findExtensionDevelopRoot() {
+        const webpackDir = external_path_namespaceObject.resolve(runtime_context_currentDir, '..');
+        const packageRoot = external_path_namespaceObject.resolve(webpackDir, '..');
+        const packageJsonPath = external_path_namespaceObject.join(packageRoot, 'package.json');
+        if (!external_fs_namespaceObject.existsSync(packageJsonPath)) return null;
+        try {
+            const pkg = JSON.parse(external_fs_namespaceObject.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 external_path_namespaceObject.resolve(override);
+        if ('win32' === process.platform && process.env.LOCALAPPDATA) return external_path_namespaceObject.join(process.env.LOCALAPPDATA, 'extensionjs');
+        if (process.env.XDG_CACHE_HOME) return external_path_namespaceObject.join(process.env.XDG_CACHE_HOME, 'extensionjs');
+        return external_path_namespaceObject.join(external_os_namespaceObject.homedir(), '.cache', 'extensionjs');
+    }
+    function resolveOptionalInstallRoot() {
+        const version = process.env.EXTENSION_JS_OPTIONAL_DEPS_VERSION || package_namespaceObject.i8;
+        return external_path_namespaceObject.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 = external_path_namespaceObject.join(currentDirectory, 'package.json');
+                if (external_fs_namespaceObject.existsSync(candidate)) return currentDirectory;
+                const parentDirectory = external_path_namespaceObject.dirname(currentDirectory);
+                if (parentDirectory === currentDirectory) break;
+                currentDirectory = parentDirectory;
+            }
+        };
+        const packageJsonDirectory = findNearestPackageJsonDirectory(projectPath);
+        if (!packageJsonDirectory) return false;
+        const packageJsonPath = external_path_namespaceObject.join(packageJsonDirectory, 'package.json');
+        if (!external_fs_namespaceObject.existsSync(packageJsonPath)) return false;
+        const parsed = runtime_context_parseJsonSafe(external_fs_namespaceObject.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 Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "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(`${external_pintor_default().gray("\u25BA\u25BA\u25BA")} Found ${external_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;
+    }
+})();
+exports.hasDependency = __webpack_exports__.hasDependency;
+exports.installOptionalDependencies = __webpack_exports__.installOptionalDependencies;
+exports.installOptionalDependenciesBatch = __webpack_exports__.installOptionalDependenciesBatch;
+exports.resolveDevelopInstallRoot = __webpack_exports__.resolveDevelopInstallRoot;
+exports.resolveOptionalInstallRoot = __webpack_exports__.resolveOptionalInstallRoot;
+exports.resolvePackageFromInstallRoot = __webpack_exports__.resolvePackageFromInstallRoot;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "hasDependency",
+    "installOptionalDependencies",
+    "installOptionalDependenciesBatch",
+    "resolveDevelopInstallRoot",
+    "resolveOptionalInstallRoot",
+    "resolvePackageFromInstallRoot"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});