nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_chunks/_deps/resolve.mjs

@@ -0,0 +1,1260 @@
+import { b as getAugmentedNamespace, a as getDefaultExportFromCjs } from './commondir.mjs';
+import V__default from 'fs';
+import require$$2 from 'os';
+import sysPath__default from 'path';
+import { r as requirePathParse } from './path-parse.mjs';
+import { r as requireIsCoreModule } from './is-core-module.mjs';
+
+var homedir;
+var hasRequiredHomedir;
+
+function requireHomedir () {
+	if (hasRequiredHomedir) return homedir;
+	hasRequiredHomedir = 1;
+
+	var os = require$$2;
+
+	// adapted from https://github.com/sindresorhus/os-homedir/blob/11e089f4754db38bb535e5a8416320c4446e8cfd/index.js
+
+	homedir = os.homedir || function homedir() {
+	    var home = process.env.HOME;
+	    var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
+
+	    if (process.platform === 'win32') {
+	        return process.env.USERPROFILE || process.env.HOMEDRIVE + process.env.HOMEPATH || home || null;
+	    }
+
+	    if (process.platform === 'darwin') {
+	        return home || (user ? '/Users/' + user : null);
+	    }
+
+	    if (process.platform === 'linux') {
+	        return home || (process.getuid() === 0 ? '/root' : (user ? '/home/' + user : null)); // eslint-disable-line no-extra-parens
+	    }
+
+	    return home || null;
+	};
+	return homedir;
+}
+
+var caller;
+var hasRequiredCaller;
+
+function requireCaller () {
+	if (hasRequiredCaller) return caller;
+	hasRequiredCaller = 1;
+	caller = function () {
+	    // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+	    var origPrepareStackTrace = Error.prepareStackTrace;
+	    Error.prepareStackTrace = function (_, stack) { return stack; };
+	    var stack = (new Error()).stack;
+	    Error.prepareStackTrace = origPrepareStackTrace;
+	    return stack[2].getFileName();
+	};
+	return caller;
+}
+
+var nodeModulesPaths;
+var hasRequiredNodeModulesPaths;
+
+function requireNodeModulesPaths () {
+	if (hasRequiredNodeModulesPaths) return nodeModulesPaths;
+	hasRequiredNodeModulesPaths = 1;
+	var path = sysPath__default;
+	var parse = path.parse || requirePathParse(); // eslint-disable-line global-require
+
+	var driveLetterRegex = /^([A-Za-z]:)/;
+	var uncPathRegex = /^\\\\/;
+
+	var getNodeModulesDirs = function getNodeModulesDirs(absoluteStart, modules) {
+	    var prefix = '/';
+	    if (driveLetterRegex.test(absoluteStart)) {
+	        prefix = '';
+	    } else if (uncPathRegex.test(absoluteStart)) {
+	        prefix = '\\\\';
+	    }
+
+	    var paths = [absoluteStart];
+	    var parsed = parse(absoluteStart);
+	    while (parsed.dir !== paths[paths.length - 1]) {
+	        paths.push(parsed.dir);
+	        parsed = parse(parsed.dir);
+	    }
+
+	    return paths.reduce(function (dirs, aPath) {
+	        return dirs.concat(modules.map(function (moduleDir) {
+	            return path.resolve(prefix, aPath, moduleDir);
+	        }));
+	    }, []);
+	};
+
+	nodeModulesPaths = function nodeModulesPaths(start, opts, request) {
+	    var modules = opts && opts.moduleDirectory
+	        ? [].concat(opts.moduleDirectory)
+	        : ['node_modules'];
+
+	    if (opts && typeof opts.paths === 'function') {
+	        return opts.paths(
+	            request,
+	            start,
+	            function () { return getNodeModulesDirs(start, modules); },
+	            opts
+	        );
+	    }
+
+	    var dirs = getNodeModulesDirs(start, modules);
+	    return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+	};
+	return nodeModulesPaths;
+}
+
+var normalizeOptions;
+var hasRequiredNormalizeOptions;
+
+function requireNormalizeOptions () {
+	if (hasRequiredNormalizeOptions) return normalizeOptions;
+	hasRequiredNormalizeOptions = 1;
+	normalizeOptions = function (x, opts) {
+	    /**
+	     * This file is purposefully a passthrough. It's expected that third-party
+	     * environments will override it at runtime in order to inject special logic
+	     * into `resolve` (by manipulating the options). One such example is the PnP
+	     * code path in Yarn.
+	     */
+
+	    return opts || {};
+	};
+	return normalizeOptions;
+}
+
+var async;
+var hasRequiredAsync;
+
+function requireAsync () {
+	if (hasRequiredAsync) return async;
+	hasRequiredAsync = 1;
+	var fs = V__default;
+	var getHomedir = requireHomedir();
+	var path = sysPath__default;
+	var caller = requireCaller();
+	var nodeModulesPaths = requireNodeModulesPaths();
+	var normalizeOptions = requireNormalizeOptions();
+	var isCore = /*@__PURE__*/ requireIsCoreModule();
+
+	var realpathFS = process.platform !== 'win32' && fs.realpath && typeof fs.realpath.native === 'function' ? fs.realpath.native : fs.realpath;
+
+	var relativePathRegex = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+	var windowsDriveRegex = /^\w:[/\\]*$/;
+	var nodeModulesRegex = /[/\\]node_modules[/\\]*$/;
+
+	var homedir = getHomedir();
+	var defaultPaths = function () {
+	    return [
+	        path.join(homedir, '.node_modules'),
+	        path.join(homedir, '.node_libraries')
+	    ];
+	};
+
+	var defaultIsFile = function isFile(file, cb) {
+	    fs.stat(file, function (err, stat) {
+	        if (!err) {
+	            return cb(null, stat.isFile() || stat.isFIFO());
+	        }
+	        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+	        return cb(err);
+	    });
+	};
+
+	var defaultIsDir = function isDirectory(dir, cb) {
+	    fs.stat(dir, function (err, stat) {
+	        if (!err) {
+	            return cb(null, stat.isDirectory());
+	        }
+	        if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+	        return cb(err);
+	    });
+	};
+
+	var defaultRealpath = function realpath(x, cb) {
+	    realpathFS(x, function (realpathErr, realPath) {
+	        if (realpathErr && realpathErr.code !== 'ENOENT') cb(realpathErr);
+	        else cb(null, realpathErr ? x : realPath);
+	    });
+	};
+
+	var maybeRealpath = function maybeRealpath(realpath, x, opts, cb) {
+	    if (opts && opts.preserveSymlinks === false) {
+	        realpath(x, cb);
+	    } else {
+	        cb(null, x);
+	    }
+	};
+
+	var defaultReadPackage = function defaultReadPackage(readFile, pkgfile, cb) {
+	    readFile(pkgfile, function (readFileErr, body) {
+	        if (readFileErr) cb(readFileErr);
+	        else {
+	            try {
+	                var pkg = JSON.parse(body);
+	                cb(null, pkg);
+	            } catch (jsonErr) {
+	                cb(null);
+	            }
+	        }
+	    });
+	};
+
+	var getPackageCandidates = function getPackageCandidates(x, start, opts) {
+	    var dirs = nodeModulesPaths(start, opts, x);
+	    for (var i = 0; i < dirs.length; i++) {
+	        dirs[i] = path.join(dirs[i], x);
+	    }
+	    return dirs;
+	};
+
+	async = function resolve(x, options, callback) {
+	    var cb = callback;
+	    var opts = options;
+	    if (typeof options === 'function') {
+	        cb = opts;
+	        opts = {};
+	    }
+	    if (typeof x !== 'string') {
+	        var err = new TypeError('Path must be a string.');
+	        return process.nextTick(function () {
+	            cb(err);
+	        });
+	    }
+
+	    opts = normalizeOptions(x, opts);
+
+	    var isFile = opts.isFile || defaultIsFile;
+	    var isDirectory = opts.isDirectory || defaultIsDir;
+	    var readFile = opts.readFile || fs.readFile;
+	    var realpath = opts.realpath || defaultRealpath;
+	    var readPackage = opts.readPackage || defaultReadPackage;
+	    if (opts.readFile && opts.readPackage) {
+	        var conflictErr = new TypeError('`readFile` and `readPackage` are mutually exclusive.');
+	        return process.nextTick(function () {
+	            cb(conflictErr);
+	        });
+	    }
+	    var packageIterator = opts.packageIterator;
+
+	    var extensions = opts.extensions || ['.js'];
+	    var includeCoreModules = opts.includeCoreModules !== false;
+	    var basedir = opts.basedir || path.dirname(caller());
+	    var parent = opts.filename || basedir;
+
+	    opts.paths = opts.paths || defaultPaths();
+
+	    // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+	    var absoluteStart = path.resolve(basedir);
+
+	    maybeRealpath(
+	        realpath,
+	        absoluteStart,
+	        opts,
+	        function (err, realStart) {
+	            if (err) cb(err);
+	            else init(realStart);
+	        }
+	    );
+
+	    var res;
+	    function init(basedir) {
+	        if (relativePathRegex.test(x)) {
+	            res = path.resolve(basedir, x);
+	            if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+	            if (x.slice(-1) === '/' && res === basedir) {
+	                loadAsDirectory(res, opts.package, onfile);
+	            } else loadAsFile(res, opts.package, onfile);
+	        } else if (includeCoreModules && isCore(x)) {
+	            return cb(null, x);
+	        } else loadNodeModules(x, basedir, function (err, n, pkg) {
+	            if (err) cb(err);
+	            else if (n) {
+	                return maybeRealpath(realpath, n, opts, function (err, realN) {
+	                    if (err) {
+	                        cb(err);
+	                    } else {
+	                        cb(null, realN, pkg);
+	                    }
+	                });
+	            } else {
+	                var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+	                moduleError.code = 'MODULE_NOT_FOUND';
+	                cb(moduleError);
+	            }
+	        });
+	    }
+
+	    function onfile(err, m, pkg) {
+	        if (err) cb(err);
+	        else if (m) cb(null, m, pkg);
+	        else loadAsDirectory(res, function (err, d, pkg) {
+	            if (err) cb(err);
+	            else if (d) {
+	                maybeRealpath(realpath, d, opts, function (err, realD) {
+	                    if (err) {
+	                        cb(err);
+	                    } else {
+	                        cb(null, realD, pkg);
+	                    }
+	                });
+	            } else {
+	                var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+	                moduleError.code = 'MODULE_NOT_FOUND';
+	                cb(moduleError);
+	            }
+	        });
+	    }
+
+	    function loadAsFile(x, thePackage, callback) {
+	        var loadAsFilePackage = thePackage;
+	        var cb = callback;
+	        if (typeof loadAsFilePackage === 'function') {
+	            cb = loadAsFilePackage;
+	            loadAsFilePackage = undefined;
+	        }
+
+	        var exts = [''].concat(extensions);
+	        load(exts, x, loadAsFilePackage);
+
+	        function load(exts, x, loadPackage) {
+	            if (exts.length === 0) return cb(null, undefined, loadPackage);
+	            var file = x + exts[0];
+
+	            var pkg = loadPackage;
+	            if (pkg) onpkg(null, pkg);
+	            else loadpkg(path.dirname(file), onpkg);
+
+	            function onpkg(err, pkg_, dir) {
+	                pkg = pkg_;
+	                if (err) return cb(err);
+	                if (dir && pkg && opts.pathFilter) {
+	                    var rfile = path.relative(dir, file);
+	                    var rel = rfile.slice(0, rfile.length - exts[0].length);
+	                    var r = opts.pathFilter(pkg, x, rel);
+	                    if (r) return load(
+	                        [''].concat(extensions.slice()),
+	                        path.resolve(dir, r),
+	                        pkg
+	                    );
+	                }
+	                isFile(file, onex);
+	            }
+	            function onex(err, ex) {
+	                if (err) return cb(err);
+	                if (ex) return cb(null, file, pkg);
+	                load(exts.slice(1), x, pkg);
+	            }
+	        }
+	    }
+
+	    function loadpkg(dir, cb) {
+	        if (dir === '' || dir === '/') return cb(null);
+	        if (process.platform === 'win32' && windowsDriveRegex.test(dir)) {
+	            return cb(null);
+	        }
+	        if (nodeModulesRegex.test(dir)) return cb(null);
+
+	        maybeRealpath(realpath, dir, opts, function (unwrapErr, pkgdir) {
+	            if (unwrapErr) return loadpkg(path.dirname(dir), cb);
+	            var pkgfile = path.join(pkgdir, 'package.json');
+	            isFile(pkgfile, function (err, ex) {
+	                // on err, ex is false
+	                if (!ex) return loadpkg(path.dirname(dir), cb);
+
+	                readPackage(readFile, pkgfile, function (err, pkgParam) {
+	                    if (err) cb(err);
+
+	                    var pkg = pkgParam;
+
+	                    if (pkg && opts.packageFilter) {
+	                        pkg = opts.packageFilter(pkg, pkgfile);
+	                    }
+	                    cb(null, pkg, dir);
+	                });
+	            });
+	        });
+	    }
+
+	    function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
+	        var cb = callback;
+	        var fpkg = loadAsDirectoryPackage;
+	        if (typeof fpkg === 'function') {
+	            cb = fpkg;
+	            fpkg = opts.package;
+	        }
+
+	        maybeRealpath(realpath, x, opts, function (unwrapErr, pkgdir) {
+	            if (unwrapErr) return cb(unwrapErr);
+	            var pkgfile = path.join(pkgdir, 'package.json');
+	            isFile(pkgfile, function (err, ex) {
+	                if (err) return cb(err);
+	                if (!ex) return loadAsFile(path.join(x, 'index'), fpkg, cb);
+
+	                readPackage(readFile, pkgfile, function (err, pkgParam) {
+	                    if (err) return cb(err);
+
+	                    var pkg = pkgParam;
+
+	                    if (pkg && opts.packageFilter) {
+	                        pkg = opts.packageFilter(pkg, pkgfile);
+	                    }
+
+	                    if (pkg && pkg.main) {
+	                        if (typeof pkg.main !== 'string') {
+	                            var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+	                            mainError.code = 'INVALID_PACKAGE_MAIN';
+	                            return cb(mainError);
+	                        }
+	                        if (pkg.main === '.' || pkg.main === './') {
+	                            pkg.main = 'index';
+	                        }
+	                        loadAsFile(path.resolve(x, pkg.main), pkg, function (err, m, pkg) {
+	                            if (err) return cb(err);
+	                            if (m) return cb(null, m, pkg);
+	                            if (!pkg) return loadAsFile(path.join(x, 'index'), pkg, cb);
+
+	                            var dir = path.resolve(x, pkg.main);
+	                            loadAsDirectory(dir, pkg, function (err, n, pkg) {
+	                                if (err) return cb(err);
+	                                if (n) return cb(null, n, pkg);
+	                                loadAsFile(path.join(x, 'index'), pkg, cb);
+	                            });
+	                        });
+	                        return;
+	                    }
+
+	                    loadAsFile(path.join(x, '/index'), pkg, cb);
+	                });
+	            });
+	        });
+	    }
+
+	    function processDirs(cb, dirs) {
+	        if (dirs.length === 0) return cb(null, undefined);
+	        var dir = dirs[0];
+
+	        isDirectory(path.dirname(dir), isdir);
+
+	        function isdir(err, isdir) {
+	            if (err) return cb(err);
+	            if (!isdir) return processDirs(cb, dirs.slice(1));
+	            loadAsFile(dir, opts.package, onfile);
+	        }
+
+	        function onfile(err, m, pkg) {
+	            if (err) return cb(err);
+	            if (m) return cb(null, m, pkg);
+	            loadAsDirectory(dir, opts.package, ondir);
+	        }
+
+	        function ondir(err, n, pkg) {
+	            if (err) return cb(err);
+	            if (n) return cb(null, n, pkg);
+	            processDirs(cb, dirs.slice(1));
+	        }
+	    }
+	    function loadNodeModules(x, start, cb) {
+	        var thunk = function () { return getPackageCandidates(x, start, opts); };
+	        processDirs(
+	            cb,
+	            packageIterator ? packageIterator(x, start, thunk, opts) : thunk()
+	        );
+	    }
+	};
+	return async;
+}
+
+const assert = true;
+const async_hooks = ">= 8";
+const buffer_ieee754 = ">= 0.5 && < 0.9.7";
+const buffer = true;
+const child_process = true;
+const cluster = ">= 0.5";
+const console = true;
+const constants = true;
+const crypto = true;
+const _debug_agent = ">= 1 && < 8";
+const _debugger = "< 8";
+const dgram = true;
+const diagnostics_channel = [
+	">= 14.17 && < 15",
+	">= 15.1"
+];
+const dns = true;
+const domain = ">= 0.7.12";
+const events = true;
+const freelist = "< 6";
+const fs = true;
+const _http_agent = ">= 0.11.1";
+const _http_client = ">= 0.11.1";
+const _http_common = ">= 0.11.1";
+const _http_incoming = ">= 0.11.1";
+const _http_outgoing = ">= 0.11.1";
+const _http_server = ">= 0.11.1";
+const http = true;
+const http2 = ">= 8.8";
+const https = true;
+const inspector = ">= 8";
+const _linklist = "< 8";
+const module = true;
+const net = true;
+const os = true;
+const path = true;
+const perf_hooks = ">= 8.5";
+const process$1 = ">= 1";
+const punycode = ">= 0.5";
+const querystring = true;
+const readline = true;
+const repl = true;
+const smalloc = ">= 0.11.5 && < 3";
+const _stream_duplex = ">= 0.9.4";
+const _stream_transform = ">= 0.9.4";
+const _stream_wrap = ">= 1.4.1";
+const _stream_passthrough = ">= 0.9.4";
+const _stream_readable = ">= 0.9.4";
+const _stream_writable = ">= 0.9.4";
+const stream = true;
+const string_decoder = true;
+const sys = [
+	">= 0.4 && < 0.7",
+	">= 0.8"
+];
+const timers = true;
+const _tls_common = ">= 0.11.13";
+const _tls_legacy = ">= 0.11.3 && < 10";
+const _tls_wrap = ">= 0.11.3";
+const tls = true;
+const trace_events = ">= 10";
+const tty = true;
+const url = true;
+const util = true;
+const v8 = ">= 1";
+const vm = true;
+const wasi = [
+	">= 13.4 && < 13.5",
+	">= 18.17 && < 19",
+	">= 20"
+];
+const worker_threads = ">= 11.7";
+const zlib = ">= 0.5";
+const core = {
+	assert: assert,
+	"node:assert": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"assert/strict": ">= 15",
+	"node:assert/strict": ">= 16",
+	async_hooks: async_hooks,
+	"node:async_hooks": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	buffer_ieee754: buffer_ieee754,
+	buffer: buffer,
+	"node:buffer": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	child_process: child_process,
+	"node:child_process": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	cluster: cluster,
+	"node:cluster": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	console: console,
+	"node:console": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	constants: constants,
+	"node:constants": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	crypto: crypto,
+	"node:crypto": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_debug_agent: _debug_agent,
+	_debugger: _debugger,
+	dgram: dgram,
+	"node:dgram": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	diagnostics_channel: diagnostics_channel,
+	"node:diagnostics_channel": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	dns: dns,
+	"node:dns": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"dns/promises": ">= 15",
+	"node:dns/promises": ">= 16",
+	domain: domain,
+	"node:domain": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	events: events,
+	"node:events": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	freelist: freelist,
+	fs: fs,
+	"node:fs": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"fs/promises": [
+	">= 10 && < 10.1",
+	">= 14"
+],
+	"node:fs/promises": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_agent: _http_agent,
+	"node:_http_agent": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_client: _http_client,
+	"node:_http_client": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_common: _http_common,
+	"node:_http_common": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_incoming: _http_incoming,
+	"node:_http_incoming": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_outgoing: _http_outgoing,
+	"node:_http_outgoing": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_http_server: _http_server,
+	"node:_http_server": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	http: http,
+	"node:http": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	http2: http2,
+	"node:http2": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	https: https,
+	"node:https": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	inspector: inspector,
+	"node:inspector": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"inspector/promises": [
+	">= 19"
+],
+	"node:inspector/promises": [
+	">= 19"
+],
+	_linklist: _linklist,
+	module: module,
+	"node:module": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	net: net,
+	"node:net": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"node-inspect/lib/_inspect": ">= 7.6 && < 12",
+	"node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
+	"node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
+	os: os,
+	"node:os": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	path: path,
+	"node:path": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"path/posix": ">= 15.3",
+	"node:path/posix": ">= 16",
+	"path/win32": ">= 15.3",
+	"node:path/win32": ">= 16",
+	perf_hooks: perf_hooks,
+	"node:perf_hooks": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	process: process$1,
+	"node:process": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	punycode: punycode,
+	"node:punycode": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	querystring: querystring,
+	"node:querystring": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	readline: readline,
+	"node:readline": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"readline/promises": ">= 17",
+	"node:readline/promises": ">= 17",
+	repl: repl,
+	"node:repl": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"node:sea": [
+	">= 20.12 && < 21",
+	">= 21.7"
+],
+	smalloc: smalloc,
+	"node:sqlite": [
+	">= 22.13 && < 23",
+	">= 23.4"
+],
+	_stream_duplex: _stream_duplex,
+	"node:_stream_duplex": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_transform: _stream_transform,
+	"node:_stream_transform": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_wrap: _stream_wrap,
+	"node:_stream_wrap": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_passthrough: _stream_passthrough,
+	"node:_stream_passthrough": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_readable: _stream_readable,
+	"node:_stream_readable": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_stream_writable: _stream_writable,
+	"node:_stream_writable": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	stream: stream,
+	"node:stream": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"stream/consumers": ">= 16.7",
+	"node:stream/consumers": ">= 16.7",
+	"stream/promises": ">= 15",
+	"node:stream/promises": ">= 16",
+	"stream/web": ">= 16.5",
+	"node:stream/web": ">= 16.5",
+	string_decoder: string_decoder,
+	"node:string_decoder": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	sys: sys,
+	"node:sys": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"test/reporters": ">= 19.9 && < 20.2",
+	"node:test/reporters": [
+	">= 18.17 && < 19",
+	">= 19.9",
+	">= 20"
+],
+	"test/mock_loader": ">= 22.3 && < 22.7",
+	"node:test/mock_loader": ">= 22.3 && < 22.7",
+	"node:test": [
+	">= 16.17 && < 17",
+	">= 18"
+],
+	timers: timers,
+	"node:timers": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"timers/promises": ">= 15",
+	"node:timers/promises": ">= 16",
+	_tls_common: _tls_common,
+	"node:_tls_common": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	_tls_legacy: _tls_legacy,
+	_tls_wrap: _tls_wrap,
+	"node:_tls_wrap": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	tls: tls,
+	"node:tls": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	trace_events: trace_events,
+	"node:trace_events": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	tty: tty,
+	"node:tty": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	url: url,
+	"node:url": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	util: util,
+	"node:util": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	"util/types": ">= 15.3",
+	"node:util/types": ">= 16",
+	"v8/tools/arguments": ">= 10 && < 12",
+	"v8/tools/codemap": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/consarray": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/csvparser": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/logreader": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/profile_view": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	"v8/tools/splaytree": [
+	">= 4.4 && < 5",
+	">= 5.2 && < 12"
+],
+	v8: v8,
+	"node:v8": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	vm: vm,
+	"node:vm": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	wasi: wasi,
+	"node:wasi": [
+	">= 18.17 && < 19",
+	">= 20"
+],
+	worker_threads: worker_threads,
+	"node:worker_threads": [
+	">= 14.18 && < 15",
+	">= 16"
+],
+	zlib: zlib,
+	"node:zlib": [
+	">= 14.18 && < 15",
+	">= 16"
+]
+};
+
+const core$1 = {
+    __proto__: null,
+    _debug_agent: _debug_agent,
+    _debugger: _debugger,
+    _http_agent: _http_agent,
+    _http_client: _http_client,
+    _http_common: _http_common,
+    _http_incoming: _http_incoming,
+    _http_outgoing: _http_outgoing,
+    _http_server: _http_server,
+    _linklist: _linklist,
+    _stream_duplex: _stream_duplex,
+    _stream_passthrough: _stream_passthrough,
+    _stream_readable: _stream_readable,
+    _stream_transform: _stream_transform,
+    _stream_wrap: _stream_wrap,
+    _stream_writable: _stream_writable,
+    _tls_common: _tls_common,
+    _tls_legacy: _tls_legacy,
+    _tls_wrap: _tls_wrap,
+    assert: assert,
+    async_hooks: async_hooks,
+    buffer: buffer,
+    buffer_ieee754: buffer_ieee754,
+    child_process: child_process,
+    cluster: cluster,
+    console: console,
+    constants: constants,
+    crypto: crypto,
+    default: core,
+    dgram: dgram,
+    diagnostics_channel: diagnostics_channel,
+    dns: dns,
+    domain: domain,
+    events: events,
+    freelist: freelist,
+    fs: fs,
+    http: http,
+    http2: http2,
+    https: https,
+    inspector: inspector,
+    module: module,
+    net: net,
+    os: os,
+    path: path,
+    perf_hooks: perf_hooks,
+    process: process$1,
+    punycode: punycode,
+    querystring: querystring,
+    readline: readline,
+    repl: repl,
+    smalloc: smalloc,
+    stream: stream,
+    string_decoder: string_decoder,
+    sys: sys,
+    timers: timers,
+    tls: tls,
+    trace_events: trace_events,
+    tty: tty,
+    url: url,
+    util: util,
+    v8: v8,
+    vm: vm,
+    wasi: wasi,
+    worker_threads: worker_threads,
+    zlib: zlib
+};
+
+const require$$1 = /*@__PURE__*/getAugmentedNamespace(core$1);
+
+var core_1;
+var hasRequiredCore;
+
+function requireCore () {
+	if (hasRequiredCore) return core_1;
+	hasRequiredCore = 1;
+
+	var isCoreModule = /*@__PURE__*/ requireIsCoreModule();
+	var data = require$$1;
+
+	var core = {};
+	for (var mod in data) { // eslint-disable-line no-restricted-syntax
+	    if (Object.prototype.hasOwnProperty.call(data, mod)) {
+	        core[mod] = isCoreModule(mod);
+	    }
+	}
+	core_1 = core;
+	return core_1;
+}
+
+var isCore;
+var hasRequiredIsCore;
+
+function requireIsCore () {
+	if (hasRequiredIsCore) return isCore;
+	hasRequiredIsCore = 1;
+	var isCoreModule = /*@__PURE__*/ requireIsCoreModule();
+
+	isCore = function isCore(x) {
+	    return isCoreModule(x);
+	};
+	return isCore;
+}
+
+var sync;
+var hasRequiredSync;
+
+function requireSync () {
+	if (hasRequiredSync) return sync;
+	hasRequiredSync = 1;
+	var isCore = /*@__PURE__*/ requireIsCoreModule();
+	var fs = V__default;
+	var path = sysPath__default;
+	var getHomedir = requireHomedir();
+	var caller = requireCaller();
+	var nodeModulesPaths = requireNodeModulesPaths();
+	var normalizeOptions = requireNormalizeOptions();
+
+	var realpathFS = process.platform !== 'win32' && fs.realpathSync && typeof fs.realpathSync.native === 'function' ? fs.realpathSync.native : fs.realpathSync;
+
+	var relativePathRegex = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/;
+	var windowsDriveRegex = /^\w:[/\\]*$/;
+	var nodeModulesRegex = /[/\\]node_modules[/\\]*$/;
+
+	var homedir = getHomedir();
+	var defaultPaths = function () {
+	    return [
+	        path.join(homedir, '.node_modules'),
+	        path.join(homedir, '.node_libraries')
+	    ];
+	};
+
+	var defaultIsFile = function isFile(file) {
+	    try {
+	        var stat = fs.statSync(file, { throwIfNoEntry: false });
+	    } catch (e) {
+	        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+	        throw e;
+	    }
+	    return !!stat && (stat.isFile() || stat.isFIFO());
+	};
+
+	var defaultIsDir = function isDirectory(dir) {
+	    try {
+	        var stat = fs.statSync(dir, { throwIfNoEntry: false });
+	    } catch (e) {
+	        if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+	        throw e;
+	    }
+	    return !!stat && stat.isDirectory();
+	};
+
+	var defaultRealpathSync = function realpathSync(x) {
+	    try {
+	        return realpathFS(x);
+	    } catch (realpathErr) {
+	        if (realpathErr.code !== 'ENOENT') {
+	            throw realpathErr;
+	        }
+	    }
+	    return x;
+	};
+
+	var maybeRealpathSync = function maybeRealpathSync(realpathSync, x, opts) {
+	    if (opts && opts.preserveSymlinks === false) {
+	        return realpathSync(x);
+	    }
+	    return x;
+	};
+
+	var defaultReadPackageSync = function defaultReadPackageSync(readFileSync, pkgfile) {
+	    var body = readFileSync(pkgfile);
+	    try {
+	        var pkg = JSON.parse(body);
+	        return pkg;
+	    } catch (jsonErr) {}
+	};
+
+	var getPackageCandidates = function getPackageCandidates(x, start, opts) {
+	    var dirs = nodeModulesPaths(start, opts, x);
+	    for (var i = 0; i < dirs.length; i++) {
+	        dirs[i] = path.join(dirs[i], x);
+	    }
+	    return dirs;
+	};
+
+	sync = function resolveSync(x, options) {
+	    if (typeof x !== 'string') {
+	        throw new TypeError('Path must be a string.');
+	    }
+	    var opts = normalizeOptions(x, options);
+
+	    var isFile = opts.isFile || defaultIsFile;
+	    var readFileSync = opts.readFileSync || fs.readFileSync;
+	    var isDirectory = opts.isDirectory || defaultIsDir;
+	    var realpathSync = opts.realpathSync || defaultRealpathSync;
+	    var readPackageSync = opts.readPackageSync || defaultReadPackageSync;
+	    if (opts.readFileSync && opts.readPackageSync) {
+	        throw new TypeError('`readFileSync` and `readPackageSync` are mutually exclusive.');
+	    }
+	    var packageIterator = opts.packageIterator;
+
+	    var extensions = opts.extensions || ['.js'];
+	    var includeCoreModules = opts.includeCoreModules !== false;
+	    var basedir = opts.basedir || path.dirname(caller());
+	    var parent = opts.filename || basedir;
+
+	    opts.paths = opts.paths || defaultPaths();
+
+	    // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+	    var absoluteStart = maybeRealpathSync(realpathSync, path.resolve(basedir), opts);
+
+	    if (relativePathRegex.test(x)) {
+	        var res = path.resolve(absoluteStart, x);
+	        if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+	        var m = loadAsFileSync(res) || loadAsDirectorySync(res);
+	        if (m) return maybeRealpathSync(realpathSync, m, opts);
+	    } else if (includeCoreModules && isCore(x)) {
+	        return x;
+	    } else {
+	        var n = loadNodeModulesSync(x, absoluteStart);
+	        if (n) return maybeRealpathSync(realpathSync, n, opts);
+	    }
+
+	    var err = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+	    err.code = 'MODULE_NOT_FOUND';
+	    throw err;
+
+	    function loadAsFileSync(x) {
+	        var pkg = loadpkg(path.dirname(x));
+
+	        if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
+	            var rfile = path.relative(pkg.dir, x);
+	            var r = opts.pathFilter(pkg.pkg, x, rfile);
+	            if (r) {
+	                x = path.resolve(pkg.dir, r); // eslint-disable-line no-param-reassign
+	            }
+	        }
+
+	        if (isFile(x)) {
+	            return x;
+	        }
+
+	        for (var i = 0; i < extensions.length; i++) {
+	            var file = x + extensions[i];
+	            if (isFile(file)) {
+	                return file;
+	            }
+	        }
+	    }
+
+	    function loadpkg(dir) {
+	        if (dir === '' || dir === '/') return;
+	        if (process.platform === 'win32' && windowsDriveRegex.test(dir)) {
+	            return;
+	        }
+	        if (nodeModulesRegex.test(dir)) return;
+
+	        var pkgfile = path.join(maybeRealpathSync(realpathSync, dir, opts), 'package.json');
+
+	        if (!isFile(pkgfile)) {
+	            return loadpkg(path.dirname(dir));
+	        }
+
+	        var pkg = readPackageSync(readFileSync, pkgfile);
+
+	        if (pkg && opts.packageFilter) {
+	            // v2 will pass pkgfile
+	            pkg = opts.packageFilter(pkg, /*pkgfile,*/ dir); // eslint-disable-line spaced-comment
+	        }
+
+	        return { pkg: pkg, dir: dir };
+	    }
+
+	    function loadAsDirectorySync(x) {
+	        var pkgfile = path.join(maybeRealpathSync(realpathSync, x, opts), '/package.json');
+	        if (isFile(pkgfile)) {
+	            try {
+	                var pkg = readPackageSync(readFileSync, pkgfile);
+	            } catch (e) {}
+
+	            if (pkg && opts.packageFilter) {
+	                // v2 will pass pkgfile
+	                pkg = opts.packageFilter(pkg, /*pkgfile,*/ x); // eslint-disable-line spaced-comment
+	            }
+
+	            if (pkg && pkg.main) {
+	                if (typeof pkg.main !== 'string') {
+	                    var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+	                    mainError.code = 'INVALID_PACKAGE_MAIN';
+	                    throw mainError;
+	                }
+	                if (pkg.main === '.' || pkg.main === './') {
+	                    pkg.main = 'index';
+	                }
+	                try {
+	                    var m = loadAsFileSync(path.resolve(x, pkg.main));
+	                    if (m) return m;
+	                    var n = loadAsDirectorySync(path.resolve(x, pkg.main));
+	                    if (n) return n;
+	                } catch (e) {}
+	            }
+	        }
+
+	        return loadAsFileSync(path.join(x, '/index'));
+	    }
+
+	    function loadNodeModulesSync(x, start) {
+	        var thunk = function () { return getPackageCandidates(x, start, opts); };
+	        var dirs = packageIterator ? packageIterator(x, start, thunk, opts) : thunk();
+
+	        for (var i = 0; i < dirs.length; i++) {
+	            var dir = dirs[i];
+	            if (isDirectory(path.dirname(dir))) {
+	                var m = loadAsFileSync(dir);
+	                if (m) return m;
+	                var n = loadAsDirectorySync(dir);
+	                if (n) return n;
+	            }
+	        }
+	    }
+	};
+	return sync;
+}
+
+var resolve;
+var hasRequiredResolve;
+
+function requireResolve () {
+	if (hasRequiredResolve) return resolve;
+	hasRequiredResolve = 1;
+	var async = requireAsync();
+	async.core = requireCore();
+	async.isCore = requireIsCore();
+	async.sync = requireSync();
+
+	resolve = async;
+	return resolve;
+}
+
+var resolveExports = requireResolve();
+const resolve$1 = /*@__PURE__*/getDefaultExportFromCjs(resolveExports);
+
+export { resolve$1 as r };