diff --git a/lib/converted-esm/import-meta-resolve.js b/lib/converted-esm/import-meta-resolve.js index 6e12280d..d79301de 100644 --- a/lib/converted-esm/import-meta-resolve.js +++ b/lib/converted-esm/import-meta-resolve.js @@ -4,119 +4,204 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor; var __getOwnPropNames = Object.getOwnPropertyNames; var __getProtoOf = Object.getPrototypeOf; var __hasOwnProp = Object.prototype.hasOwnProperty; -var __markAsModule = (target) => __defProp(target, "__esModule", { value: true }); var __export = (target, all) => { for (var name in all) __defProp(target, name, { get: all[name], enumerable: true }); }; -var __reExport = (target, module2, copyDefault, desc) => { - if (module2 && typeof module2 === "object" || typeof module2 === "function") { - for (let key of __getOwnPropNames(module2)) - if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default")) - __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable }); +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); } - return target; + return to; }; -var __toESM = (module2, isNodeMode) => { - return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2); -}; -var __toCommonJS = /* @__PURE__ */ ((cache) => { - return (module2, temp) => { - return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp); - }; -})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0); +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); // node_modules/import-meta-resolve/lib/resolve.js var resolve_exports = {}; __export(resolve_exports, { defaultResolve: () => defaultResolve, - getPackageType: () => getPackageType, moduleResolve: () => moduleResolve }); -var import_url2 = require("url"); -var import_fs2 = require("fs"); -var import_path3 = __toESM(require("path"), 1); -var import_builtins = __toESM(require("builtins"), 1); - -// node_modules/import-meta-resolve/lib/package-json-reader.js -var import_fs = __toESM(require("fs"), 1); -var import_path = __toESM(require("path"), 1); -var reader = { read }; -var package_json_reader_default = reader; -function read(jsonPath) { - return find(import_path.default.dirname(jsonPath)); -} -function find(dir) { - try { - const string = import_fs.default.readFileSync(import_path.default.toNamespacedPath(import_path.default.join(dir, "package.json")), "utf8"); - return { string }; - } catch (error) { - if (error.code === "ENOENT") { - const parent = import_path.default.dirname(dir); - if (dir !== parent) - return find(parent); - return { string: void 0 }; - } - throw error; - } -} +module.exports = __toCommonJS(resolve_exports); +var import_node_assert2 = __toESM(require("node:assert"), 1); +var import_node_fs2 = require("node:fs"); +var import_node_process2 = __toESM(require("node:process"), 1); +var import_node_url3 = require("node:url"); +var import_node_path3 = __toESM(require("node:path"), 1); +var import_node_module = require("node:module"); // node_modules/import-meta-resolve/lib/get-format.js -var import_path2 = __toESM(require("path"), 1); -var import_url = require("url"); +var import_node_path2 = __toESM(require("node:path"), 1); +var import_node_url2 = require("node:url"); + +// node_modules/import-meta-resolve/lib/package-config.js +var import_node_url = require("node:url"); // node_modules/import-meta-resolve/lib/errors.js -var import_assert = __toESM(require("assert"), 1); -var import_util = require("util"); -var isWindows = process.platform === "win32"; +var import_node_v8 = __toESM(require("node:v8"), 1); +var import_node_process = __toESM(require("node:process"), 1); +var import_node_assert = __toESM(require("node:assert"), 1); +var import_node_util = require("node:util"); +var isWindows = import_node_process.default.platform === "win32"; var own = {}.hasOwnProperty; var codes = {}; +function formatList(array, type = "and") { + return array.length < 3 ? array.join(` ${type} `) : `${array.slice(0, -1).join(", ")}, ${type} ${array[array.length - 1]}`; +} var messages = /* @__PURE__ */ new Map(); var nodeInternalPrefix = "__node_internal_"; var userStackTraceLimit; -codes.ERR_INVALID_MODULE_SPECIFIER = createError("ERR_INVALID_MODULE_SPECIFIER", (request, reason, base = void 0) => { - return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`; -}, TypeError); -codes.ERR_INVALID_PACKAGE_CONFIG = createError("ERR_INVALID_PACKAGE_CONFIG", (path4, base, message) => { - return `Invalid package config ${path4}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`; -}, Error); -codes.ERR_INVALID_PACKAGE_TARGET = createError("ERR_INVALID_PACKAGE_TARGET", (pkgPath, key, target, isImport = false, base = void 0) => { - const relError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./"); - if (key === ".") { - (0, import_assert.default)(isImport === false); - return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`; - } - return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(target)} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`; -}, Error); -codes.ERR_MODULE_NOT_FOUND = createError("ERR_MODULE_NOT_FOUND", (path4, base, type = "package") => { - return `Cannot find ${type} '${path4}' imported from ${base}`; -}, Error); -codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError("ERR_PACKAGE_IMPORT_NOT_DEFINED", (specifier, packagePath, base) => { - return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`; -}, TypeError); -codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError("ERR_PACKAGE_PATH_NOT_EXPORTED", (pkgPath, subpath, base = void 0) => { - if (subpath === ".") - return `No "exports" main defined in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`; - return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`; -}, Error); -codes.ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported resolving ES modules imported from %s", Error); -codes.ERR_UNKNOWN_FILE_EXTENSION = createError("ERR_UNKNOWN_FILE_EXTENSION", 'Unknown file extension "%s" for %s', TypeError); -codes.ERR_INVALID_ARG_VALUE = createError("ERR_INVALID_ARG_VALUE", (name, value, reason = "is invalid") => { - let inspected = (0, import_util.inspect)(value); - if (inspected.length > 128) { - inspected = `${inspected.slice(0, 128)}...`; - } - const type = name.includes(".") ? "property" : "argument"; - return `The ${type} '${name}' ${reason}. Received ${inspected}`; -}, TypeError); -codes.ERR_UNSUPPORTED_ESM_URL_SCHEME = createError("ERR_UNSUPPORTED_ESM_URL_SCHEME", (url) => { - let message = "Only file and data URLs are supported by the default ESM loader"; - if (isWindows && url.protocol.length === 2) { - message += ". On Windows, absolute paths must be valid file:// URLs"; - } - message += `. Received protocol '${url.protocol}'`; - return message; -}, Error); +codes.ERR_INVALID_MODULE_SPECIFIER = createError( + "ERR_INVALID_MODULE_SPECIFIER", + /** + * @param {string} request + * @param {string} reason + * @param {string} [base] + */ + (request, reason, base = void 0) => { + return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`; + }, + TypeError +); +codes.ERR_INVALID_PACKAGE_CONFIG = createError( + "ERR_INVALID_PACKAGE_CONFIG", + /** + * @param {string} path + * @param {string} [base] + * @param {string} [message] + */ + (path4, base, message) => { + return `Invalid package config ${path4}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`; + }, + Error +); +codes.ERR_INVALID_PACKAGE_TARGET = createError( + "ERR_INVALID_PACKAGE_TARGET", + /** + * @param {string} pkgPath + * @param {string} key + * @param {unknown} target + * @param {boolean} [isImport=false] + * @param {string} [base] + */ + (pkgPath, key, target, isImport = false, base = void 0) => { + const relError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./"); + if (key === ".") { + (0, import_node_assert.default)(isImport === false); + return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`; + } + return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify( + target + )} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ""}${relError ? '; targets must start with "./"' : ""}`; + }, + Error +); +codes.ERR_MODULE_NOT_FOUND = createError( + "ERR_MODULE_NOT_FOUND", + /** + * @param {string} path + * @param {string} base + * @param {string} [type] + */ + (path4, base, type = "package") => { + return `Cannot find ${type} '${path4}' imported from ${base}`; + }, + Error +); +codes.ERR_NETWORK_IMPORT_DISALLOWED = createError( + "ERR_NETWORK_IMPORT_DISALLOWED", + "import of '%s' by %s is not supported: %s", + Error +); +codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError( + "ERR_PACKAGE_IMPORT_NOT_DEFINED", + /** + * @param {string} specifier + * @param {string} packagePath + * @param {string} base + */ + (specifier, packagePath, base) => { + return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`; + }, + TypeError +); +codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError( + "ERR_PACKAGE_PATH_NOT_EXPORTED", + /** + * @param {string} pkgPath + * @param {string} subpath + * @param {string} [base] + */ + (pkgPath, subpath, base = void 0) => { + if (subpath === ".") + return `No "exports" main defined in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`; + return `Package subpath '${subpath}' is not defined by "exports" in ${pkgPath}package.json${base ? ` imported from ${base}` : ""}`; + }, + Error +); +codes.ERR_UNSUPPORTED_DIR_IMPORT = createError( + "ERR_UNSUPPORTED_DIR_IMPORT", + "Directory import '%s' is not supported resolving ES modules imported from %s", + Error +); +codes.ERR_UNKNOWN_FILE_EXTENSION = createError( + "ERR_UNKNOWN_FILE_EXTENSION", + /** + * @param {string} ext + * @param {string} path + */ + (ext, path4) => { + return `Unknown file extension "${ext}" for ${path4}`; + }, + TypeError +); +codes.ERR_INVALID_ARG_VALUE = createError( + "ERR_INVALID_ARG_VALUE", + /** + * @param {string} name + * @param {unknown} value + * @param {string} [reason='is invalid'] + */ + (name, value, reason = "is invalid") => { + let inspected = (0, import_node_util.inspect)(value); + if (inspected.length > 128) { + inspected = `${inspected.slice(0, 128)}...`; + } + const type = name.includes(".") ? "property" : "argument"; + return `The ${type} '${name}' ${reason}. Received ${inspected}`; + }, + TypeError + // Note: extra classes have been shaken out. + // , RangeError +); +codes.ERR_UNSUPPORTED_ESM_URL_SCHEME = createError( + "ERR_UNSUPPORTED_ESM_URL_SCHEME", + /** + * @param {URL} url + * @param {Array} supported + */ + (url, supported) => { + let message = `Only URLs with a scheme in: ${formatList( + supported + )} are supported by the default ESM loader`; + if (isWindows && url.protocol.length === 2) { + message += ". On Windows, absolute paths must be valid file:// URLs"; + } + message += `. Received protocol '${url.protocol}'`; + return message; + }, + Error +); function createError(sym, value, def) { messages.set(sym, value); return makeNodeErrorWithCode(def, sym); @@ -131,170 +216,118 @@ function makeNodeErrorWithCode(Base, key) { if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit; const message = getMessage(key, args, error); - Object.defineProperty(error, "message", { - value: message, - enumerable: false, - writable: true, - configurable: true - }); - Object.defineProperty(error, "toString", { - value() { - return `${this.name} [${key}]: ${this.message}`; + Object.defineProperties(error, { + // Note: no need to implement `kIsNodeError` symbol, would be hard, + // probably. + message: { + value: message, + enumerable: false, + writable: true, + configurable: true }, - enumerable: false, - writable: true, - configurable: true + toString: { + /** @this {Error} */ + value() { + return `${this.name} [${key}]: ${this.message}`; + }, + enumerable: false, + writable: true, + configurable: true + } }); - addCodeToName(error, Base.name, key); + captureLargerStackTrace(error); error.code = key; return error; } } -var addCodeToName = hideStackFrames(function(error, name, code) { - error = captureLargerStackTrace(error); - error.name = `${name} [${code}]`; - error.stack; - if (name === "SystemError") { - Object.defineProperty(error, "name", { - value: name, - enumerable: false, - writable: true, - configurable: true - }); - } else { - delete error.name; - } -}); function isErrorStackTraceLimitWritable() { + try { + if (import_node_v8.default.startupSnapshot.isBuildingSnapshot()) { + return false; + } + } catch { + } const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit"); if (desc === void 0) { return Object.isExtensible(Error); } - return own.call(desc, "writable") ? desc.writable : desc.set !== void 0; + return own.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0; } function hideStackFrames(fn) { const hidden = nodeInternalPrefix + fn.name; Object.defineProperty(fn, "name", { value: hidden }); return fn; } -var captureLargerStackTrace = hideStackFrames(function(error) { - const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable(); - if (stackTraceLimitIsWritable) { - userStackTraceLimit = Error.stackTraceLimit; - Error.stackTraceLimit = Number.POSITIVE_INFINITY; +var captureLargerStackTrace = hideStackFrames( + /** + * @param {Error} error + * @returns {Error} + */ + // @ts-expect-error: fine + function(error) { + const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable(); + if (stackTraceLimitIsWritable) { + userStackTraceLimit = Error.stackTraceLimit; + Error.stackTraceLimit = Number.POSITIVE_INFINITY; + } + Error.captureStackTrace(error); + if (stackTraceLimitIsWritable) + Error.stackTraceLimit = userStackTraceLimit; + return error; } - Error.captureStackTrace(error); - if (stackTraceLimitIsWritable) - Error.stackTraceLimit = userStackTraceLimit; - return error; -}); +); function getMessage(key, args, self) { const message = messages.get(key); + (0, import_node_assert.default)(typeof message !== "undefined", "expected `message` to be found"); if (typeof message === "function") { - (0, import_assert.default)(message.length <= args.length, `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${message.length}).`); + (0, import_node_assert.default)( + message.length <= args.length, + // Default options do not count. + `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${message.length}).` + ); return Reflect.apply(message, self, args); } - const expectedLength = (message.match(/%[dfijoOs]/g) || []).length; - (0, import_assert.default)(expectedLength === args.length, `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`); + const regex = /%[dfijoOs]/g; + let expectedLength = 0; + while (regex.exec(message) !== null) + expectedLength++; + (0, import_node_assert.default)( + expectedLength === args.length, + `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).` + ); if (args.length === 0) return message; args.unshift(message); - return Reflect.apply(import_util.format, null, args); + return Reflect.apply(import_node_util.format, null, args); } -// node_modules/import-meta-resolve/lib/get-format.js -var { ERR_UNKNOWN_FILE_EXTENSION } = codes; -var extensionFormatMap = { - __proto__: null, - ".cjs": "commonjs", - ".js": "module", - ".mjs": "module" -}; -function defaultGetFormat(url) { - if (url.startsWith("node:")) { - return { format: "builtin" }; - } - const parsed = new import_url.URL(url); - if (parsed.protocol === "data:") { - const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(parsed.pathname) || [null, null]; - const format2 = mime === "text/javascript" ? "module" : null; - return { format: format2 }; - } - if (parsed.protocol === "file:") { - const ext = import_path2.default.extname(parsed.pathname); - let format2; - if (ext === ".js") { - format2 = getPackageType(parsed.href) === "module" ? "module" : "commonjs"; - } else { - format2 = extensionFormatMap[ext]; - } - if (!format2) { - throw new ERR_UNKNOWN_FILE_EXTENSION(ext, (0, import_url.fileURLToPath)(url)); +// node_modules/import-meta-resolve/lib/package-json-reader.js +var import_node_fs = __toESM(require("node:fs"), 1); +var import_node_path = __toESM(require("node:path"), 1); +var reader = { read }; +var package_json_reader_default = reader; +function read(jsonPath) { + try { + const string = import_node_fs.default.readFileSync( + import_node_path.default.toNamespacedPath(import_node_path.default.join(import_node_path.default.dirname(jsonPath), "package.json")), + "utf8" + ); + return { string }; + } catch (error) { + const exception = ( + /** @type {ErrnoException} */ + error + ); + if (exception.code === "ENOENT") { + return { string: void 0 }; } - return { format: format2 || null }; + throw exception; } - return { format: null }; } -// node_modules/import-meta-resolve/lib/resolve.js -var listOfBuiltins = (0, import_builtins.default)(); -var { - ERR_INVALID_MODULE_SPECIFIER, - ERR_INVALID_PACKAGE_CONFIG, - ERR_INVALID_PACKAGE_TARGET, - ERR_MODULE_NOT_FOUND, - ERR_PACKAGE_IMPORT_NOT_DEFINED, - ERR_PACKAGE_PATH_NOT_EXPORTED, - ERR_UNSUPPORTED_DIR_IMPORT, - ERR_UNSUPPORTED_ESM_URL_SCHEME, - ERR_INVALID_ARG_VALUE -} = codes; -var own2 = {}.hasOwnProperty; -var DEFAULT_CONDITIONS = Object.freeze(["node", "import"]); -var DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS); -var invalidSegmentRegEx = /(^|\\|\/)(\.\.?|node_modules)(\\|\/|$)/; -var patternRegEx = /\*/g; -var encodedSepRegEx = /%2f|%2c/i; -var emittedPackageWarnings = /* @__PURE__ */ new Set(); +// node_modules/import-meta-resolve/lib/package-config.js +var { ERR_INVALID_PACKAGE_CONFIG } = codes; var packageJsonCache = /* @__PURE__ */ new Map(); -function emitFolderMapDeprecation(match, pjsonUrl, isExports, base) { - const pjsonPath = (0, import_url2.fileURLToPath)(pjsonUrl); - if (emittedPackageWarnings.has(pjsonPath + "|" + match)) - return; - emittedPackageWarnings.add(pjsonPath + "|" + match); - process.emitWarning(`Use of deprecated folder mapping "${match}" in the ${isExports ? '"exports"' : '"imports"'} field module resolution of the package at ${pjsonPath}${base ? ` imported from ${(0, import_url2.fileURLToPath)(base)}` : ""}. -Update this package.json to use a subpath pattern like "${match}*".`, "DeprecationWarning", "DEP0148"); -} -function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) { - const { format: format2 } = defaultGetFormat(url.href); - if (format2 !== "module") - return; - const path4 = (0, import_url2.fileURLToPath)(url.href); - const pkgPath = (0, import_url2.fileURLToPath)(new import_url2.URL(".", packageJsonUrl)); - const basePath = (0, import_url2.fileURLToPath)(base); - if (main) - process.emitWarning(`Package ${pkgPath} has a "main" field set to ${JSON.stringify(main)}, excluding the full filename and extension to the resolved file at "${path4.slice(pkgPath.length)}", imported from ${basePath}. - Automatic extension resolution of the "main" field isdeprecated for ES modules.`, "DeprecationWarning", "DEP0151"); - else - process.emitWarning(`No "main" or "exports" field defined in the package.json for ${pkgPath} resolving the main entry point "${path4.slice(pkgPath.length)}", imported from ${basePath}. -Default "index" lookups for the main are deprecated for ES modules.`, "DeprecationWarning", "DEP0151"); -} -function getConditionsSet(conditions) { - if (conditions !== void 0 && conditions !== DEFAULT_CONDITIONS) { - if (!Array.isArray(conditions)) { - throw new ERR_INVALID_ARG_VALUE("conditions", conditions, "expected an array"); - } - return new Set(conditions); - } - return DEFAULT_CONDITIONS_SET; -} -function tryStatSync(path4) { - try { - return (0, import_fs2.statSync)(path4); - } catch { - return new import_fs2.Stats(); - } -} function getPackageConfig(path4, specifier, base) { const existing = packageJsonCache.get(path4); if (existing !== void 0) { @@ -318,7 +351,15 @@ function getPackageConfig(path4, specifier, base) { try { packageJson = JSON.parse(source); } catch (error) { - throw new ERR_INVALID_PACKAGE_CONFIG(path4, (base ? `"${specifier}" from ` : "") + (0, import_url2.fileURLToPath)(base || specifier), error.message); + const exception = ( + /** @type {ErrnoException} */ + error + ); + throw new ERR_INVALID_PACKAGE_CONFIG( + path4, + (base ? `"${specifier}" from ` : "") + (0, import_node_url.fileURLToPath)(base || specifier), + exception.message + ); } const { exports, imports, main, name, type } = packageJson; const packageConfig = { @@ -327,27 +368,32 @@ function getPackageConfig(path4, specifier, base) { main: typeof main === "string" ? main : void 0, name: typeof name === "string" ? name : void 0, type: type === "module" || type === "commonjs" ? type : "none", + // @ts-expect-error Assume `Record`. exports, + // @ts-expect-error Assume `Record`. imports: imports && typeof imports === "object" ? imports : void 0 }; packageJsonCache.set(path4, packageConfig); return packageConfig; } function getPackageScopeConfig(resolved) { - let packageJsonUrl = new import_url2.URL("./package.json", resolved); + let packageJsonUrl = new import_node_url.URL("package.json", resolved); while (true) { const packageJsonPath2 = packageJsonUrl.pathname; if (packageJsonPath2.endsWith("node_modules/package.json")) break; - const packageConfig2 = getPackageConfig((0, import_url2.fileURLToPath)(packageJsonUrl), resolved); + const packageConfig2 = getPackageConfig( + (0, import_node_url.fileURLToPath)(packageJsonUrl), + resolved + ); if (packageConfig2.exists) return packageConfig2; const lastPackageJsonUrl = packageJsonUrl; - packageJsonUrl = new import_url2.URL("../package.json", packageJsonUrl); + packageJsonUrl = new import_node_url.URL("../package.json", packageJsonUrl); if (packageJsonUrl.pathname === lastPackageJsonUrl.pathname) break; } - const packageJsonPath = (0, import_url2.fileURLToPath)(packageJsonUrl); + const packageJsonPath = (0, import_node_url.fileURLToPath)(packageJsonUrl); const packageConfig = { pjsonPath: packageJsonPath, exists: false, @@ -360,13 +406,168 @@ function getPackageScopeConfig(resolved) { packageJsonCache.set(packageJsonPath, packageConfig); return packageConfig; } + +// node_modules/import-meta-resolve/lib/resolve-get-package-type.js +function getPackageType(url) { + const packageConfig = getPackageScopeConfig(url); + return packageConfig.type; +} + +// node_modules/import-meta-resolve/lib/get-format.js +var { ERR_UNKNOWN_FILE_EXTENSION } = codes; +var hasOwnProperty = {}.hasOwnProperty; +var extensionFormatMap = { + // @ts-expect-error: hush. + __proto__: null, + ".cjs": "commonjs", + ".js": "module", + ".json": "json", + ".mjs": "module" +}; +function mimeToFormat(mime) { + if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime)) + return "module"; + if (mime === "application/json") + return "json"; + return null; +} +var protocolHandlers = { + // @ts-expect-error: hush. + __proto__: null, + "data:": getDataProtocolModuleFormat, + "file:": getFileProtocolModuleFormat, + "http:": getHttpProtocolModuleFormat, + "https:": getHttpProtocolModuleFormat, + "node:"() { + return "builtin"; + } +}; +function getDataProtocolModuleFormat(parsed) { + const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec( + parsed.pathname + ) || [null, null, null]; + return mimeToFormat(mime); +} +function getFileProtocolModuleFormat(url, _context, ignoreErrors) { + const filepath = (0, import_node_url2.fileURLToPath)(url); + const ext = import_node_path2.default.extname(filepath); + if (ext === ".js") { + return getPackageType(url) === "module" ? "module" : "commonjs"; + } + const format2 = extensionFormatMap[ext]; + if (format2) + return format2; + if (ignoreErrors) { + return void 0; + } + throw new ERR_UNKNOWN_FILE_EXTENSION(ext, filepath); +} +function getHttpProtocolModuleFormat() { +} +function defaultGetFormatWithoutErrors(url, context) { + if (!hasOwnProperty.call(protocolHandlers, url.protocol)) { + return null; + } + return protocolHandlers[url.protocol](url, context, true) || null; +} + +// node_modules/import-meta-resolve/lib/utils.js +var { ERR_INVALID_ARG_VALUE } = codes; +var DEFAULT_CONDITIONS = Object.freeze(["node", "import"]); +var DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS); +function getDefaultConditions() { + return DEFAULT_CONDITIONS; +} +function getDefaultConditionsSet() { + return DEFAULT_CONDITIONS_SET; +} +function getConditionsSet(conditions) { + if (conditions !== void 0 && conditions !== getDefaultConditions()) { + if (!Array.isArray(conditions)) { + throw new ERR_INVALID_ARG_VALUE( + "conditions", + conditions, + "expected an array" + ); + } + return new Set(conditions); + } + return getDefaultConditionsSet(); +} + +// node_modules/import-meta-resolve/lib/resolve.js +var RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace]; +var experimentalNetworkImports = false; +var { + ERR_NETWORK_IMPORT_DISALLOWED, + ERR_INVALID_MODULE_SPECIFIER, + ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG2, + ERR_INVALID_PACKAGE_TARGET, + ERR_MODULE_NOT_FOUND, + ERR_PACKAGE_IMPORT_NOT_DEFINED, + ERR_PACKAGE_PATH_NOT_EXPORTED, + ERR_UNSUPPORTED_DIR_IMPORT, + ERR_UNSUPPORTED_ESM_URL_SCHEME +} = codes; +var own2 = {}.hasOwnProperty; +var invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i; +var deprecatedInvalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i; +var invalidPackageNameRegEx = /^\.|%|\\/; +var patternRegEx = /\*/g; +var encodedSepRegEx = /%2f|%5c/i; +var emittedPackageWarnings = /* @__PURE__ */ new Set(); +var doubleSlashRegEx = /[/\\]{2}/; +function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, internal, base, isTarget) { + const pjsonPath = (0, import_node_url3.fileURLToPath)(packageJsonUrl); + const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null; + import_node_process2.default.emitWarning( + `Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target}" for module request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${(0, import_node_url3.fileURLToPath)(base)}` : ""}.`, + "DeprecationWarning", + "DEP0166" + ); +} +function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) { + const format2 = defaultGetFormatWithoutErrors(url, { parentURL: base.href }); + if (format2 !== "module") + return; + const path4 = (0, import_node_url3.fileURLToPath)(url.href); + const pkgPath = (0, import_node_url3.fileURLToPath)(new import_node_url3.URL(".", packageJsonUrl)); + const basePath = (0, import_node_url3.fileURLToPath)(base); + if (main) + import_node_process2.default.emitWarning( + `Package ${pkgPath} has a "main" field set to ${JSON.stringify(main)}, excluding the full filename and extension to the resolved file at "${path4.slice( + pkgPath.length + )}", imported from ${basePath}. + Automatic extension resolution of the "main" field isdeprecated for ES modules.`, + "DeprecationWarning", + "DEP0151" + ); + else + import_node_process2.default.emitWarning( + `No "main" or "exports" field defined in the package.json for ${pkgPath} resolving the main entry point "${path4.slice( + pkgPath.length + )}", imported from ${basePath}. +Default "index" lookups for the main are deprecated for ES modules.`, + "DeprecationWarning", + "DEP0151" + ); +} +function tryStatSync(path4) { + try { + return (0, import_node_fs2.statSync)(path4); + } catch { + return new import_node_fs2.Stats(); + } +} function fileExists(url) { - return tryStatSync((0, import_url2.fileURLToPath)(url)).isFile(); + const stats = (0, import_node_fs2.statSync)(url, { throwIfNoEntry: false }); + const isFile = stats ? stats.isFile() : void 0; + return isFile === null || isFile === void 0 ? false : isFile; } function legacyMainResolve(packageJsonUrl, packageConfig, base) { let guess; if (packageConfig.main !== void 0) { - guess = new import_url2.URL(`./${packageConfig.main}`, packageJsonUrl); + guess = new import_node_url3.URL(packageConfig.main, packageJsonUrl); if (fileExists(guess)) return guess; const tries2 = [ @@ -379,20 +580,25 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) { ]; let i2 = -1; while (++i2 < tries2.length) { - guess = new import_url2.URL(tries2[i2], packageJsonUrl); + guess = new import_node_url3.URL(tries2[i2], packageJsonUrl); if (fileExists(guess)) break; guess = void 0; } if (guess) { - emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main); + emitLegacyIndexDeprecation( + guess, + packageJsonUrl, + base, + packageConfig.main + ); return guess; } } const tries = ["./index.js", "./index.json", "./index.node"]; let i = -1; while (++i < tries.length) { - guess = new import_url2.URL(tries[i], packageJsonUrl); + guess = new import_node_url3.URL(tries[i], packageJsonUrl); if (fileExists(guess)) break; guess = void 0; @@ -401,69 +607,160 @@ function legacyMainResolve(packageJsonUrl, packageConfig, base) { emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main); return guess; } - throw new ERR_MODULE_NOT_FOUND((0, import_url2.fileURLToPath)(new import_url2.URL(".", packageJsonUrl)), (0, import_url2.fileURLToPath)(base)); + throw new ERR_MODULE_NOT_FOUND( + (0, import_node_url3.fileURLToPath)(new import_node_url3.URL(".", packageJsonUrl)), + (0, import_node_url3.fileURLToPath)(base) + ); } -function finalizeResolution(resolved, base) { - if (encodedSepRegEx.test(resolved.pathname)) - throw new ERR_INVALID_MODULE_SPECIFIER(resolved.pathname, 'must not include encoded "/" or "\\" characters', (0, import_url2.fileURLToPath)(base)); - const path4 = (0, import_url2.fileURLToPath)(resolved); - const stats = tryStatSync(path4.endsWith("/") ? path4.slice(-1) : path4); +function finalizeResolution(resolved, base, preserveSymlinks) { + if (encodedSepRegEx.exec(resolved.pathname) !== null) + throw new ERR_INVALID_MODULE_SPECIFIER( + resolved.pathname, + 'must not include encoded "/" or "\\" characters', + (0, import_node_url3.fileURLToPath)(base) + ); + const filePath = (0, import_node_url3.fileURLToPath)(resolved); + const stats = tryStatSync( + filePath.endsWith("/") ? filePath.slice(-1) : filePath + ); if (stats.isDirectory()) { - const error = new ERR_UNSUPPORTED_DIR_IMPORT(path4, (0, import_url2.fileURLToPath)(base)); + const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, (0, import_node_url3.fileURLToPath)(base)); error.url = String(resolved); throw error; } if (!stats.isFile()) { - throw new ERR_MODULE_NOT_FOUND(path4 || resolved.pathname, base && (0, import_url2.fileURLToPath)(base), "module"); + throw new ERR_MODULE_NOT_FOUND( + filePath || resolved.pathname, + base && (0, import_node_url3.fileURLToPath)(base), + "module" + ); + } + if (!preserveSymlinks) { + const real = (0, import_node_fs2.realpathSync)(filePath); + const { search, hash } = resolved; + resolved = (0, import_node_url3.pathToFileURL)(real + (filePath.endsWith(import_node_path3.default.sep) ? "/" : "")); + resolved.search = search; + resolved.hash = hash; } return resolved; } -function throwImportNotDefined(specifier, packageJsonUrl, base) { - throw new ERR_PACKAGE_IMPORT_NOT_DEFINED(specifier, packageJsonUrl && (0, import_url2.fileURLToPath)(new import_url2.URL(".", packageJsonUrl)), (0, import_url2.fileURLToPath)(base)); +function importNotDefined(specifier, packageJsonUrl, base) { + return new ERR_PACKAGE_IMPORT_NOT_DEFINED( + specifier, + packageJsonUrl && (0, import_node_url3.fileURLToPath)(new import_node_url3.URL(".", packageJsonUrl)), + (0, import_node_url3.fileURLToPath)(base) + ); } -function throwExportsNotFound(subpath, packageJsonUrl, base) { - throw new ERR_PACKAGE_PATH_NOT_EXPORTED((0, import_url2.fileURLToPath)(new import_url2.URL(".", packageJsonUrl)), subpath, base && (0, import_url2.fileURLToPath)(base)); +function exportsNotFound(subpath, packageJsonUrl, base) { + return new ERR_PACKAGE_PATH_NOT_EXPORTED( + (0, import_node_url3.fileURLToPath)(new import_node_url3.URL(".", packageJsonUrl)), + subpath, + base && (0, import_node_url3.fileURLToPath)(base) + ); } -function throwInvalidSubpath(subpath, packageJsonUrl, internal, base) { - const reason = `request is not a valid subpath for the "${internal ? "imports" : "exports"}" resolution of ${(0, import_url2.fileURLToPath)(packageJsonUrl)}`; - throw new ERR_INVALID_MODULE_SPECIFIER(subpath, reason, base && (0, import_url2.fileURLToPath)(base)); +function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) { + const reason = `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${(0, import_node_url3.fileURLToPath)(packageJsonUrl)}`; + throw new ERR_INVALID_MODULE_SPECIFIER( + request, + reason, + base && (0, import_node_url3.fileURLToPath)(base) + ); } -function throwInvalidPackageTarget(subpath, target, packageJsonUrl, internal, base) { +function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) { target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`; - throw new ERR_INVALID_PACKAGE_TARGET((0, import_url2.fileURLToPath)(new import_url2.URL(".", packageJsonUrl)), subpath, target, internal, base && (0, import_url2.fileURLToPath)(base)); + return new ERR_INVALID_PACKAGE_TARGET( + (0, import_node_url3.fileURLToPath)(new import_node_url3.URL(".", packageJsonUrl)), + subpath, + target, + internal, + base && (0, import_node_url3.fileURLToPath)(base) + ); } -function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base, pattern, internal, conditions) { +function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base, pattern, internal, isPathMap, conditions) { if (subpath !== "" && !pattern && target[target.length - 1] !== "/") - throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base); + throw invalidPackageTarget(match, target, packageJsonUrl, internal, base); if (!target.startsWith("./")) { if (internal && !target.startsWith("../") && !target.startsWith("/")) { let isURL = false; try { - new import_url2.URL(target); + new import_node_url3.URL(target); isURL = true; } catch { } if (!isURL) { - const exportTarget = pattern ? target.replace(patternRegEx, subpath) : target + subpath; + const exportTarget = pattern ? RegExpPrototypeSymbolReplace.call( + patternRegEx, + target, + () => subpath + ) : target + subpath; return packageResolve(exportTarget, packageJsonUrl, conditions); } } - throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base); + throw invalidPackageTarget(match, target, packageJsonUrl, internal, base); } - if (invalidSegmentRegEx.test(target.slice(2))) - throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base); - const resolved = new import_url2.URL(target, packageJsonUrl); + if (invalidSegmentRegEx.exec(target.slice(2)) !== null) { + if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) { + if (!isPathMap) { + const request = pattern ? match.replace("*", () => subpath) : match + subpath; + const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call( + patternRegEx, + target, + () => subpath + ) : target; + emitInvalidSegmentDeprecation( + resolvedTarget, + request, + match, + packageJsonUrl, + internal, + base, + true + ); + } + } else { + throw invalidPackageTarget(match, target, packageJsonUrl, internal, base); + } + } + const resolved = new import_node_url3.URL(target, packageJsonUrl); const resolvedPath = resolved.pathname; - const packagePath = new import_url2.URL(".", packageJsonUrl).pathname; + const packagePath = new import_node_url3.URL(".", packageJsonUrl).pathname; if (!resolvedPath.startsWith(packagePath)) - throwInvalidPackageTarget(match, target, packageJsonUrl, internal, base); + throw invalidPackageTarget(match, target, packageJsonUrl, internal, base); if (subpath === "") return resolved; - if (invalidSegmentRegEx.test(subpath)) - throwInvalidSubpath(match + subpath, packageJsonUrl, internal, base); - if (pattern) - return new import_url2.URL(resolved.href.replace(patternRegEx, subpath)); - return new import_url2.URL(subpath, resolved); + if (invalidSegmentRegEx.exec(subpath) !== null) { + const request = pattern ? match.replace("*", () => subpath) : match + subpath; + if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) { + if (!isPathMap) { + const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call( + patternRegEx, + target, + () => subpath + ) : target; + emitInvalidSegmentDeprecation( + resolvedTarget, + request, + match, + packageJsonUrl, + internal, + base, + false + ); + } + } else { + throwInvalidSubpath(request, match, packageJsonUrl, internal, base); + } + } + if (pattern) { + return new import_node_url3.URL( + RegExpPrototypeSymbolReplace.call( + patternRegEx, + resolved.href, + () => subpath + ) + ); + } + return new import_node_url3.URL(subpath, resolved); } function isArrayIndex(key) { const keyNumber = Number(key); @@ -471,9 +768,19 @@ function isArrayIndex(key) { return false; return keyNumber >= 0 && keyNumber < 4294967295; } -function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base, pattern, internal, conditions) { +function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions) { if (typeof target === "string") { - return resolvePackageTargetString(target, subpath, packageSubpath, packageJsonUrl, base, pattern, internal, conditions); + return resolvePackageTargetString( + target, + subpath, + packageSubpath, + packageJsonUrl, + base, + pattern, + internal, + isPathMap, + conditions + ); } if (Array.isArray(target)) { const targetList = target; @@ -483,25 +790,39 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b let i = -1; while (++i < targetList.length) { const targetItem = targetList[i]; - let resolved; + let resolveResult; try { - resolved = resolvePackageTarget(packageJsonUrl, targetItem, subpath, packageSubpath, base, pattern, internal, conditions); + resolveResult = resolvePackageTarget( + packageJsonUrl, + targetItem, + subpath, + packageSubpath, + base, + pattern, + internal, + isPathMap, + conditions + ); } catch (error) { - lastException = error; - if (error.code === "ERR_INVALID_PACKAGE_TARGET") + const exception = ( + /** @type {ErrnoException} */ + error + ); + lastException = exception; + if (exception.code === "ERR_INVALID_PACKAGE_TARGET") continue; throw error; } - if (resolved === void 0) + if (resolveResult === void 0) continue; - if (resolved === null) { + if (resolveResult === null) { lastException = null; continue; } - return resolved; + return resolveResult; } if (lastException === void 0 || lastException === null) { - return lastException; + return null; } throw lastException; } @@ -511,26 +832,49 @@ function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, b while (++i < keys.length) { const key = keys[i]; if (isArrayIndex(key)) { - throw new ERR_INVALID_PACKAGE_CONFIG((0, import_url2.fileURLToPath)(packageJsonUrl), base, '"exports" cannot contain numeric property keys.'); + throw new ERR_INVALID_PACKAGE_CONFIG2( + (0, import_node_url3.fileURLToPath)(packageJsonUrl), + base, + '"exports" cannot contain numeric property keys.' + ); } } i = -1; while (++i < keys.length) { const key = keys[i]; if (key === "default" || conditions && conditions.has(key)) { - const conditionalTarget = target[key]; - const resolved = resolvePackageTarget(packageJsonUrl, conditionalTarget, subpath, packageSubpath, base, pattern, internal, conditions); - if (resolved === void 0) + const conditionalTarget = ( + /** @type {unknown} */ + target[key] + ); + const resolveResult = resolvePackageTarget( + packageJsonUrl, + conditionalTarget, + subpath, + packageSubpath, + base, + pattern, + internal, + isPathMap, + conditions + ); + if (resolveResult === void 0) continue; - return resolved; + return resolveResult; } } - return void 0; + return null; } if (target === null) { return null; } - throwInvalidPackageTarget(packageSubpath, target, packageJsonUrl, internal, base); + throw invalidPackageTarget( + packageSubpath, + target, + packageJsonUrl, + internal, + base + ); } function isConditionalExportsMainSugar(exports, packageJsonUrl, base) { if (typeof exports === "string" || Array.isArray(exports)) @@ -547,92 +891,182 @@ function isConditionalExportsMainSugar(exports, packageJsonUrl, base) { if (i++ === 0) { isConditionalSugar = curIsConditionalSugar; } else if (isConditionalSugar !== curIsConditionalSugar) { - throw new ERR_INVALID_PACKAGE_CONFIG((0, import_url2.fileURLToPath)(packageJsonUrl), base, `"exports" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.`); + throw new ERR_INVALID_PACKAGE_CONFIG2( + (0, import_node_url3.fileURLToPath)(packageJsonUrl), + base, + `"exports" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.` + ); } } return isConditionalSugar; } +function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) { + const pjsonPath = (0, import_node_url3.fileURLToPath)(pjsonUrl); + if (emittedPackageWarnings.has(pjsonPath + "|" + match)) + return; + emittedPackageWarnings.add(pjsonPath + "|" + match); + import_node_process2.default.emitWarning( + `Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${(0, import_node_url3.fileURLToPath)(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`, + "DeprecationWarning", + "DEP0155" + ); +} function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) { let exports = packageConfig.exports; - if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) + if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) { exports = { ".": exports }; - if (own2.call(exports, packageSubpath)) { + } + if (own2.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) { const target = exports[packageSubpath]; - const resolved = resolvePackageTarget(packageJsonUrl, target, "", packageSubpath, base, false, false, conditions); - if (resolved === null || resolved === void 0) - throwExportsNotFound(packageSubpath, packageJsonUrl, base); - return { resolved, exact: true }; + const resolveResult = resolvePackageTarget( + packageJsonUrl, + target, + "", + packageSubpath, + base, + false, + false, + false, + conditions + ); + if (resolveResult === null || resolveResult === void 0) { + throw exportsNotFound(packageSubpath, packageJsonUrl, base); + } + return resolveResult; } let bestMatch = ""; + let bestMatchSubpath = ""; const keys = Object.getOwnPropertyNames(exports); let i = -1; while (++i < keys.length) { const key = keys[i]; - if (key[key.length - 1] === "*" && packageSubpath.startsWith(key.slice(0, -1)) && packageSubpath.length >= key.length && key.length > bestMatch.length) { - bestMatch = key; - } else if (key[key.length - 1] === "/" && packageSubpath.startsWith(key) && key.length > bestMatch.length) { - bestMatch = key; + const patternIndex = key.indexOf("*"); + if (patternIndex !== -1 && packageSubpath.startsWith(key.slice(0, patternIndex))) { + if (packageSubpath.endsWith("/")) { + emitTrailingSlashPatternDeprecation( + packageSubpath, + packageJsonUrl, + base + ); + } + const patternTrailer = key.slice(patternIndex + 1); + if (packageSubpath.length >= key.length && packageSubpath.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) { + bestMatch = key; + bestMatchSubpath = packageSubpath.slice( + patternIndex, + packageSubpath.length - patternTrailer.length + ); + } } } if (bestMatch) { - const target = exports[bestMatch]; - const pattern = bestMatch[bestMatch.length - 1] === "*"; - const subpath = packageSubpath.slice(bestMatch.length - (pattern ? 1 : 0)); - const resolved = resolvePackageTarget(packageJsonUrl, target, subpath, bestMatch, base, pattern, false, conditions); - if (resolved === null || resolved === void 0) - throwExportsNotFound(packageSubpath, packageJsonUrl, base); - if (!pattern) - emitFolderMapDeprecation(bestMatch, packageJsonUrl, true, base); - return { resolved, exact: pattern }; - } - throwExportsNotFound(packageSubpath, packageJsonUrl, base); + const target = ( + /** @type {unknown} */ + exports[bestMatch] + ); + const resolveResult = resolvePackageTarget( + packageJsonUrl, + target, + bestMatchSubpath, + bestMatch, + base, + true, + false, + packageSubpath.endsWith("/"), + conditions + ); + if (resolveResult === null || resolveResult === void 0) { + throw exportsNotFound(packageSubpath, packageJsonUrl, base); + } + return resolveResult; + } + throw exportsNotFound(packageSubpath, packageJsonUrl, base); +} +function patternKeyCompare(a, b) { + const aPatternIndex = a.indexOf("*"); + const bPatternIndex = b.indexOf("*"); + const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1; + const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1; + if (baseLengthA > baseLengthB) + return -1; + if (baseLengthB > baseLengthA) + return 1; + if (aPatternIndex === -1) + return 1; + if (bPatternIndex === -1) + return -1; + if (a.length > b.length) + return -1; + if (b.length > a.length) + return 1; + return 0; } function packageImportsResolve(name, base, conditions) { - if (name === "#" || name.startsWith("#/")) { + if (name === "#" || name.startsWith("#/") || name.endsWith("/")) { const reason = "is not a valid internal imports specifier name"; - throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, (0, import_url2.fileURLToPath)(base)); + throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, (0, import_node_url3.fileURLToPath)(base)); } let packageJsonUrl; const packageConfig = getPackageScopeConfig(base); if (packageConfig.exists) { - packageJsonUrl = (0, import_url2.pathToFileURL)(packageConfig.pjsonPath); + packageJsonUrl = (0, import_node_url3.pathToFileURL)(packageConfig.pjsonPath); const imports = packageConfig.imports; if (imports) { - if (own2.call(imports, name)) { - const resolved = resolvePackageTarget(packageJsonUrl, imports[name], "", name, base, false, true, conditions); - if (resolved !== null) - return { resolved, exact: true }; + if (own2.call(imports, name) && !name.includes("*")) { + const resolveResult = resolvePackageTarget( + packageJsonUrl, + imports[name], + "", + name, + base, + false, + true, + false, + conditions + ); + if (resolveResult !== null && resolveResult !== void 0) { + return resolveResult; + } } else { let bestMatch = ""; + let bestMatchSubpath = ""; const keys = Object.getOwnPropertyNames(imports); let i = -1; while (++i < keys.length) { const key = keys[i]; - if (key[key.length - 1] === "*" && name.startsWith(key.slice(0, -1)) && name.length >= key.length && key.length > bestMatch.length) { - bestMatch = key; - } else if (key[key.length - 1] === "/" && name.startsWith(key) && key.length > bestMatch.length) { - bestMatch = key; + const patternIndex = key.indexOf("*"); + if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) { + const patternTrailer = key.slice(patternIndex + 1); + if (name.length >= key.length && name.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) { + bestMatch = key; + bestMatchSubpath = name.slice( + patternIndex, + name.length - patternTrailer.length + ); + } } } if (bestMatch) { const target = imports[bestMatch]; - const pattern = bestMatch[bestMatch.length - 1] === "*"; - const subpath = name.slice(bestMatch.length - (pattern ? 1 : 0)); - const resolved = resolvePackageTarget(packageJsonUrl, target, subpath, bestMatch, base, pattern, true, conditions); - if (resolved !== null) { - if (!pattern) - emitFolderMapDeprecation(bestMatch, packageJsonUrl, false, base); - return { resolved, exact: pattern }; + const resolveResult = resolvePackageTarget( + packageJsonUrl, + target, + bestMatchSubpath, + bestMatch, + base, + true, + true, + false, + conditions + ); + if (resolveResult !== null && resolveResult !== void 0) { + return resolveResult; } } } } } - throwImportNotDefined(name, packageJsonUrl, base); -} -function getPackageType(url) { - const packageConfig = getPackageScopeConfig(url); - return packageConfig.type; + throw importNotDefined(name, packageJsonUrl, base); } function parsePackageName(specifier, base) { let separatorIndex = specifier.indexOf("/"); @@ -647,47 +1081,73 @@ function parsePackageName(specifier, base) { } } const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex); - let i = -1; - while (++i < packageName.length) { - if (packageName[i] === "%" || packageName[i] === "\\") { - validPackageName = false; - break; - } + if (invalidPackageNameRegEx.exec(packageName) !== null) { + validPackageName = false; } if (!validPackageName) { - throw new ERR_INVALID_MODULE_SPECIFIER(specifier, "is not a valid package name", (0, import_url2.fileURLToPath)(base)); + throw new ERR_INVALID_MODULE_SPECIFIER( + specifier, + "is not a valid package name", + (0, import_node_url3.fileURLToPath)(base) + ); } const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex)); return { packageName, packageSubpath, isScoped }; } function packageResolve(specifier, base, conditions) { - const { packageName, packageSubpath, isScoped } = parsePackageName(specifier, base); + if (import_node_module.builtinModules.includes(specifier)) { + return new import_node_url3.URL("node:" + specifier); + } + const { packageName, packageSubpath, isScoped } = parsePackageName( + specifier, + base + ); const packageConfig = getPackageScopeConfig(base); if (packageConfig.exists) { - const packageJsonUrl2 = (0, import_url2.pathToFileURL)(packageConfig.pjsonPath); + const packageJsonUrl2 = (0, import_node_url3.pathToFileURL)(packageConfig.pjsonPath); if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) { - return packageExportsResolve(packageJsonUrl2, packageSubpath, packageConfig, base, conditions).resolved; + return packageExportsResolve( + packageJsonUrl2, + packageSubpath, + packageConfig, + base, + conditions + ); } } - let packageJsonUrl = new import_url2.URL("./node_modules/" + packageName + "/package.json", base); - let packageJsonPath = (0, import_url2.fileURLToPath)(packageJsonUrl); + let packageJsonUrl = new import_node_url3.URL( + "./node_modules/" + packageName + "/package.json", + base + ); + let packageJsonPath = (0, import_node_url3.fileURLToPath)(packageJsonUrl); let lastPath; do { const stat = tryStatSync(packageJsonPath.slice(0, -13)); if (!stat.isDirectory()) { lastPath = packageJsonPath; - packageJsonUrl = new import_url2.URL((isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json", packageJsonUrl); - packageJsonPath = (0, import_url2.fileURLToPath)(packageJsonUrl); + packageJsonUrl = new import_node_url3.URL( + (isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json", + packageJsonUrl + ); + packageJsonPath = (0, import_node_url3.fileURLToPath)(packageJsonUrl); continue; } const packageConfig2 = getPackageConfig(packageJsonPath, specifier, base); - if (packageConfig2.exports !== void 0 && packageConfig2.exports !== null) - return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig2, base, conditions).resolved; - if (packageSubpath === ".") + if (packageConfig2.exports !== void 0 && packageConfig2.exports !== null) { + return packageExportsResolve( + packageJsonUrl, + packageSubpath, + packageConfig2, + base, + conditions + ); + } + if (packageSubpath === ".") { return legacyMainResolve(packageJsonUrl, packageConfig2, base); - return new import_url2.URL(packageSubpath, packageJsonUrl); + } + return new import_node_url3.URL(packageSubpath, packageJsonUrl); } while (packageJsonPath.length !== lastPath.length); - throw new ERR_MODULE_NOT_FOUND(packageName, (0, import_url2.fileURLToPath)(base)); + throw new ERR_MODULE_NOT_FOUND(packageName, (0, import_node_url3.fileURLToPath)(base)); } function isRelativeSpecifier(specifier) { if (specifier[0] === ".") { @@ -706,56 +1166,109 @@ function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) { return true; return isRelativeSpecifier(specifier); } -function moduleResolve(specifier, base, conditions) { +function moduleResolve(specifier, base, conditions, preserveSymlinks) { + const isRemote = base.protocol === "http:" || base.protocol === "https:"; let resolved; if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) { - resolved = new import_url2.URL(specifier, base); - } else if (specifier[0] === "#") { - ; - ({ resolved } = packageImportsResolve(specifier, base, conditions)); + resolved = new import_node_url3.URL(specifier, base); + } else if (!isRemote && specifier[0] === "#") { + resolved = packageImportsResolve(specifier, base, conditions); } else { try { - resolved = new import_url2.URL(specifier); + resolved = new import_node_url3.URL(specifier); } catch { - resolved = packageResolve(specifier, base, conditions); + if (!isRemote) { + resolved = packageResolve(specifier, base, conditions); + } + } + } + (0, import_node_assert2.default)(typeof resolved !== "undefined", "expected to be defined"); + if (resolved.protocol !== "file:") { + return resolved; + } + return finalizeResolution(resolved, base, preserveSymlinks); +} +function checkIfDisallowedImport(specifier, parsed, parsedParentURL) { + if (parsed && parsedParentURL && (parsedParentURL.protocol === "http:" || parsedParentURL.protocol === "https:")) { + if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) { + if (parsed && parsed.protocol !== "https:" && parsed.protocol !== "http:") { + throw new ERR_NETWORK_IMPORT_DISALLOWED( + specifier, + parsedParentURL, + "remote imports cannot import from a local location." + ); + } + return { url: parsed.href }; } + if (import_node_module.builtinModules.includes(specifier)) { + throw new ERR_NETWORK_IMPORT_DISALLOWED( + specifier, + parsedParentURL, + "remote imports cannot import from a local location." + ); + } + throw new ERR_NETWORK_IMPORT_DISALLOWED( + specifier, + parsedParentURL, + "only relative and absolute specifiers are supported." + ); + } +} +function throwIfUnsupportedURLProtocol(url) { + if (url.protocol !== "file:" && url.protocol !== "data:" && url.protocol !== "node:") { + throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(url); + } +} +function throwIfUnsupportedURLScheme(parsed, experimentalNetworkImports2) { + if (parsed && parsed.protocol !== "file:" && parsed.protocol !== "data:" && (!experimentalNetworkImports2 || parsed.protocol !== "https:" && parsed.protocol !== "http:")) { + throw new ERR_UNSUPPORTED_ESM_URL_SCHEME( + parsed, + ["file", "data"].concat( + experimentalNetworkImports2 ? ["https", "http"] : [] + ) + ); } - return finalizeResolution(resolved, base); } function defaultResolve(specifier, context = {}) { const { parentURL } = context; + (0, import_node_assert2.default)(typeof parentURL !== "undefined", "expected `parentURL` to be defined"); + let parsedParentURL; + if (parentURL) { + try { + parsedParentURL = new import_node_url3.URL(parentURL); + } catch { + } + } let parsed; try { - parsed = new import_url2.URL(specifier); - if (parsed.protocol === "data:") { - return { url: specifier }; + parsed = shouldBeTreatedAsRelativeOrAbsolutePath(specifier) ? new import_node_url3.URL(specifier, parsedParentURL) : new import_node_url3.URL(specifier); + if (parsed.protocol === "data:" || experimentalNetworkImports && (parsed.protocol === "https:" || parsed.protocol === "http:")) { + return { url: parsed.href, format: null }; } } catch { } + const maybeReturn = checkIfDisallowedImport( + specifier, + parsed, + parsedParentURL + ); + if (maybeReturn) + return maybeReturn; if (parsed && parsed.protocol === "node:") return { url: specifier }; - if (parsed && parsed.protocol !== "file:" && parsed.protocol !== "data:") - throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(parsed); - if (listOfBuiltins.includes(specifier)) { - return { url: "node:" + specifier }; - } - if (parentURL.startsWith("data:")) { - new import_url2.URL(specifier, parentURL); - } + throwIfUnsupportedURLScheme(parsed, experimentalNetworkImports); const conditions = getConditionsSet(context.conditions); - let url = moduleResolve(specifier, new import_url2.URL(parentURL), conditions); - const urlPath = (0, import_url2.fileURLToPath)(url); - const real = (0, import_fs2.realpathSync)(urlPath); - const old = url; - url = (0, import_url2.pathToFileURL)(real + (urlPath.endsWith(import_path3.default.sep) ? "/" : "")); - url.search = old.search; - url.hash = old.hash; - return { url: `${url}` }; + const url = moduleResolve(specifier, new import_node_url3.URL(parentURL), conditions, false); + throwIfUnsupportedURLProtocol(url); + return { + // Do NOT cast `url` to a string: that will work even when there are real + // problems, silencing them + url: url.href, + format: defaultGetFormatWithoutErrors(url, { parentURL }) + }; } -module.exports = __toCommonJS(resolve_exports); // Annotate the CommonJS export names for ESM import in node: 0 && (module.exports = { defaultResolve, - getPackageType, moduleResolve }); diff --git a/lib/rules/no-deprecated-api.js b/lib/rules/no-deprecated-api.js index 4cc5194a..a80b77e1 100644 --- a/lib/rules/no-deprecated-api.js +++ b/lib/rules/no-deprecated-api.js @@ -4,7 +4,12 @@ */ "use strict" -const { CALL, CONSTRUCT, READ, ReferenceTracker } = require("eslint-utils") +const { + CALL, + CONSTRUCT, + READ, + ReferenceTracker, +} = require("@eslint-community/eslint-utils") const enumeratePropertyNames = require("../util/enumerate-property-names") const getConfiguredNodeVersion = require("../util/get-configured-node-version") const getSemverRange = require("../util/get-semver-range") diff --git a/lib/rules/no-exports-assign.js b/lib/rules/no-exports-assign.js index d533f16c..1378c1be 100644 --- a/lib/rules/no-exports-assign.js +++ b/lib/rules/no-exports-assign.js @@ -4,7 +4,7 @@ */ "use strict" -const { findVariable } = require("eslint-utils") +const { findVariable } = require("@eslint-community/eslint-utils") function isExports(node, scope) { let variable = null diff --git a/lib/rules/no-path-concat.js b/lib/rules/no-path-concat.js index 99810d77..98f7957f 100644 --- a/lib/rules/no-path-concat.js +++ b/lib/rules/no-path-concat.js @@ -5,7 +5,11 @@ "use strict" const path = require("path") -const { READ, ReferenceTracker, getStringIfConstant } = require("eslint-utils") +const { + READ, + ReferenceTracker, + getStringIfConstant, +} = require("@eslint-community/eslint-utils") /** * Get the first char of the specified template element. diff --git a/lib/rules/no-unsupported-features.js b/lib/rules/no-unsupported-features.js index b3de1f17..ebdaaa6a 100644 --- a/lib/rules/no-unsupported-features.js +++ b/lib/rules/no-unsupported-features.js @@ -5,7 +5,10 @@ "use strict" const semver = require("semver") -const { getInnermostScope, getPropertyName } = require("eslint-utils") +const { + getInnermostScope, + getPropertyName, +} = require("@eslint-community/eslint-utils") const getPackageJson = require("../util/get-package-json") const VERSION_MAP = new Map([ diff --git a/lib/rules/no-unsupported-features/es-builtins.js b/lib/rules/no-unsupported-features/es-builtins.js index f69151b4..f54a2831 100644 --- a/lib/rules/no-unsupported-features/es-builtins.js +++ b/lib/rules/no-unsupported-features/es-builtins.js @@ -4,7 +4,7 @@ */ "use strict" -const { READ } = require("eslint-utils") +const { READ } = require("@eslint-community/eslint-utils") const { checkUnsupportedBuiltins, messages, diff --git a/lib/rules/no-unsupported-features/es-syntax.js b/lib/rules/no-unsupported-features/es-syntax.js index 1a093e30..6745cecf 100644 --- a/lib/rules/no-unsupported-features/es-syntax.js +++ b/lib/rules/no-unsupported-features/es-syntax.js @@ -4,8 +4,8 @@ */ "use strict" -const { rules: esRules } = require("eslint-plugin-es") -const { getInnermostScope } = require("eslint-utils") +const { rules: esRules } = require("eslint-plugin-es-x") +const { getInnermostScope } = require("@eslint-community/eslint-utils") const { Range } = require("semver") const rangeSubset = require("semver/ranges/subset") const getConfiguredNodeVersion = require("../../util/get-configured-node-version") @@ -435,7 +435,7 @@ function normalizeScope(initialScope, node) { } /** - * Define the visitor object as merging the rules of eslint-plugin-es. + * Define the visitor object as merging the rules of eslint-plugin-es-x. * @param {RuleContext} context The rule context. * @param {{version:Range,ignores:Set}} options The options. * @returns {object} The defined visitor. diff --git a/lib/rules/no-unsupported-features/node-builtins.js b/lib/rules/no-unsupported-features/node-builtins.js index e82827da..5c4bb06c 100644 --- a/lib/rules/no-unsupported-features/node-builtins.js +++ b/lib/rules/no-unsupported-features/node-builtins.js @@ -4,7 +4,7 @@ */ "use strict" -const { READ } = require("eslint-utils") +const { READ } = require("@eslint-community/eslint-utils") const { checkUnsupportedBuiltins, messages, diff --git a/lib/rules/prefer-global/buffer.js b/lib/rules/prefer-global/buffer.js index f45bd1c3..bdd37323 100644 --- a/lib/rules/prefer-global/buffer.js +++ b/lib/rules/prefer-global/buffer.js @@ -4,7 +4,7 @@ */ "use strict" -const { READ } = require("eslint-utils") +const { READ } = require("@eslint-community/eslint-utils") const checkForPreferGlobal = require("../../util/check-prefer-global") const trackMap = { diff --git a/lib/rules/prefer-global/console.js b/lib/rules/prefer-global/console.js index a78b6bdf..70ee348a 100644 --- a/lib/rules/prefer-global/console.js +++ b/lib/rules/prefer-global/console.js @@ -4,7 +4,7 @@ */ "use strict" -const { READ } = require("eslint-utils") +const { READ } = require("@eslint-community/eslint-utils") const checkForPreferGlobal = require("../../util/check-prefer-global") const trackMap = { diff --git a/lib/rules/prefer-global/process.js b/lib/rules/prefer-global/process.js index be512ce1..36abb2b5 100644 --- a/lib/rules/prefer-global/process.js +++ b/lib/rules/prefer-global/process.js @@ -4,7 +4,7 @@ */ "use strict" -const { READ } = require("eslint-utils") +const { READ } = require("@eslint-community/eslint-utils") const checkForPreferGlobal = require("../../util/check-prefer-global") const trackMap = { diff --git a/lib/rules/prefer-global/text-decoder.js b/lib/rules/prefer-global/text-decoder.js index a1f6942d..4ce186c5 100644 --- a/lib/rules/prefer-global/text-decoder.js +++ b/lib/rules/prefer-global/text-decoder.js @@ -4,7 +4,7 @@ */ "use strict" -const { READ } = require("eslint-utils") +const { READ } = require("@eslint-community/eslint-utils") const checkForPreferGlobal = require("../../util/check-prefer-global") const trackMap = { diff --git a/lib/rules/prefer-global/text-encoder.js b/lib/rules/prefer-global/text-encoder.js index 48c2b6ba..392f1703 100644 --- a/lib/rules/prefer-global/text-encoder.js +++ b/lib/rules/prefer-global/text-encoder.js @@ -4,7 +4,7 @@ */ "use strict" -const { READ } = require("eslint-utils") +const { READ } = require("@eslint-community/eslint-utils") const checkForPreferGlobal = require("../../util/check-prefer-global") const trackMap = { diff --git a/lib/rules/prefer-global/url-search-params.js b/lib/rules/prefer-global/url-search-params.js index 998d321e..a147055c 100644 --- a/lib/rules/prefer-global/url-search-params.js +++ b/lib/rules/prefer-global/url-search-params.js @@ -4,7 +4,7 @@ */ "use strict" -const { READ } = require("eslint-utils") +const { READ } = require("@eslint-community/eslint-utils") const checkForPreferGlobal = require("../../util/check-prefer-global") const trackMap = { diff --git a/lib/rules/prefer-global/url.js b/lib/rules/prefer-global/url.js index 70c8a5f2..09c544c4 100644 --- a/lib/rules/prefer-global/url.js +++ b/lib/rules/prefer-global/url.js @@ -4,7 +4,7 @@ */ "use strict" -const { READ } = require("eslint-utils") +const { READ } = require("@eslint-community/eslint-utils") const checkForPreferGlobal = require("../../util/check-prefer-global") const trackMap = { diff --git a/lib/rules/prefer-promises/dns.js b/lib/rules/prefer-promises/dns.js index 752025a7..17ef24d4 100644 --- a/lib/rules/prefer-promises/dns.js +++ b/lib/rules/prefer-promises/dns.js @@ -4,7 +4,11 @@ */ "use strict" -const { CALL, CONSTRUCT, ReferenceTracker } = require("eslint-utils") +const { + CALL, + CONSTRUCT, + ReferenceTracker, +} = require("@eslint-community/eslint-utils") const trackMap = { dns: { diff --git a/lib/rules/prefer-promises/fs.js b/lib/rules/prefer-promises/fs.js index 96c88011..70b26138 100644 --- a/lib/rules/prefer-promises/fs.js +++ b/lib/rules/prefer-promises/fs.js @@ -4,7 +4,7 @@ */ "use strict" -const { CALL, ReferenceTracker } = require("eslint-utils") +const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils") const trackMap = { fs: { diff --git a/lib/util/check-prefer-global.js b/lib/util/check-prefer-global.js index 279ca2fa..cf1d67b6 100644 --- a/lib/util/check-prefer-global.js +++ b/lib/util/check-prefer-global.js @@ -4,7 +4,7 @@ */ "use strict" -const { ReferenceTracker } = require("eslint-utils") +const { ReferenceTracker } = require("@eslint-community/eslint-utils") /** * Verifier for `prefer-global/*` rules. diff --git a/lib/util/check-unsupported-builtins.js b/lib/util/check-unsupported-builtins.js index 8fd1d262..7e0c0009 100644 --- a/lib/util/check-unsupported-builtins.js +++ b/lib/util/check-unsupported-builtins.js @@ -5,7 +5,7 @@ "use strict" const { Range, lt, major } = require("semver") //eslint-disable-line no-unused-vars -const { ReferenceTracker } = require("eslint-utils") +const { ReferenceTracker } = require("@eslint-community/eslint-utils") const getConfiguredNodeVersion = require("./get-configured-node-version") const getSemverRange = require("./get-semver-range") diff --git a/lib/util/enumerate-property-names.js b/lib/util/enumerate-property-names.js index 1d87e1c0..2dfccb74 100644 --- a/lib/util/enumerate-property-names.js +++ b/lib/util/enumerate-property-names.js @@ -4,7 +4,7 @@ */ "use strict" -const { CALL, CONSTRUCT, READ } = require("eslint-utils") +const { CALL, CONSTRUCT, READ } = require("@eslint-community/eslint-utils") /** * Enumerate property names of a given object recursively. diff --git a/lib/util/visit-require.js b/lib/util/visit-require.js index 8b310775..fcdeb0b3 100644 --- a/lib/util/visit-require.js +++ b/lib/util/visit-require.js @@ -5,7 +5,11 @@ "use strict" const path = require("path") -const { CALL, ReferenceTracker, getStringIfConstant } = require("eslint-utils") +const { + CALL, + ReferenceTracker, + getStringIfConstant, +} = require("@eslint-community/eslint-utils") const isCoreModule = require("is-core-module") const getResolvePaths = require("./get-resolve-paths") const getTryExtensions = require("./get-try-extensions") diff --git a/package.json b/package.json index bf71ae06..166592ce 100644 --- a/package.json +++ b/package.json @@ -14,38 +14,38 @@ }, "dependencies": { "builtins": "^5.0.1", - "eslint-plugin-es": "^4.1.0", - "eslint-utils": "^3.0.0", + "eslint-plugin-es-x": "^6.1.0", + "@eslint-community/eslint-utils": "^4.4.0", "ignore": "^5.1.1", - "is-core-module": "^2.11.0", + "is-core-module": "^2.12.0", "minimatch": "^3.1.2", - "resolve": "^1.22.1", - "semver": "^7.3.8" + "resolve": "^1.22.2", + "semver": "^7.5.0" }, "devDependencies": { - "@typescript-eslint/parser": "^5.51.0", + "@typescript-eslint/parser": "^5.59.0", "codecov": "^3.3.0", - "esbuild": "^0.14.39", - "eslint": "^8.27.0", - "eslint-config-prettier": "^8.5.0", - "eslint-doc-generator": "^1.4.2", - "eslint-plugin-eslint-plugin": "^5.0.6", + "esbuild": "^0.17.17", + "eslint": "^8.38.0", + "eslint-config-prettier": "^8.8.0", + "eslint-doc-generator": "^1.4.3", + "eslint-plugin-eslint-plugin": "^5.0.8", "eslint-plugin-n": "file:.", "fast-glob": "^3.2.12", - "globals": "^13.17.0", + "globals": "^13.20.0", "husky": "^8.0.2", - "import-meta-resolve": "^1.1.1", - "lint-staged": "^12.4.1", - "markdownlint-cli": "^0.32.2", + "import-meta-resolve": "^2.2.2", + "lint-staged": "^13.2.1", + "markdownlint-cli": "^0.33.0", "mocha": "^10.1.0", "npm-run-all": "^4.1.5", "nyc": "^15.1.0", "opener": "^1.5.1", - "prettier": "^2.7.1", - "punycode": "^2.1.1", - "release-it": "^15.5.0", - "rimraf": "^3.0.2", - "typescript": "^4.9.5" + "prettier": "^2.8.7", + "punycode": "^2.3.0", + "release-it": "^15.10.1", + "rimraf": "^5.0.0", + "typescript": "^5.0.4" }, "scripts": { "build": "node scripts/update", diff --git a/scripts/convert-pure-esm-to-cjs.js b/scripts/convert-pure-esm-to-cjs.js index 796e1fb4..bbd859b4 100644 --- a/scripts/convert-pure-esm-to-cjs.js +++ b/scripts/convert-pure-esm-to-cjs.js @@ -1,6 +1,6 @@ const { execSync } = require("child_process") execSync( - "esbuild --platform=node --external:builtins --bundle node_modules/import-meta-resolve/lib/resolve.js > lib/converted-esm/import-meta-resolve.js", + "./node_modules/.bin/esbuild --platform=node --external:builtins --bundle node_modules/import-meta-resolve/lib/resolve.js > lib/converted-esm/import-meta-resolve.js", { shell: true } )