Skip to main content
Module

std/node/module.ts

Deno standard library
Go to Latest
File
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265
// Copyright Joyent, Inc. and other Node contributors.//// Permission is hereby granted, free of charge, to any person obtaining a// copy of this software and associated documentation files (the// "Software"), to deal in the Software without restriction, including// without limitation the rights to use, copy, modify, merge, publish,// distribute, sublicense, and/or sell copies of the Software, and to permit// persons to whom the Software is furnished to do so, subject to the// following conditions://// The above copyright notice and this permission notice shall be included// in all copies or substantial portions of the Software.//// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE// USE OR OTHER DEALINGS IN THE SOFTWARE.
import "./global.ts";
import * as nodeFS from "./fs.ts";import * as nodeUtil from "./util.ts";import * as nodePath from "./path.ts";import * as nodeTimers from "./timers.ts";import * as nodeOs from "./os.ts";import * as nodeEvents from "./events.ts";import * as nodeQueryString from "./querystring.ts";
import * as path from "../path/mod.ts";import { assert } from "../testing/asserts.ts";
const CHAR_FORWARD_SLASH = "/".charCodeAt(0);const CHAR_BACKWARD_SLASH = "\\".charCodeAt(0);const CHAR_COLON = ":".charCodeAt(0);
const isWindows = path.isWindows;
const relativeResolveCache = Object.create(null);
let requireDepth = 0;let statCache: Map<string, StatResult> | null = null;
type StatResult = -1 | 0 | 1;// Returns 0 if the path refers to// a file, 1 when it's a directory or < 0 on error.function stat(filename: string): StatResult { filename = path.toNamespacedPath(filename); if (statCache !== null) { const result = statCache.get(filename); if (result !== undefined) return result; } try { const info = Deno.statSync(filename); const result = info.isFile ? 0 : 1; if (statCache !== null) statCache.set(filename, result); return result; } catch (e) { if (e instanceof Deno.errors.PermissionDenied) { throw new Error("CJS loader requires --allow-read."); } return -1; }}
function updateChildren( parent: Module | null, child: Module, scan: boolean): void { const children = parent && parent.children; if (children && !(scan && children.includes(child))) { children.push(child); }}
class Module { id: string; // eslint-disable-next-line @typescript-eslint/no-explicit-any exports: any; parent: Module | null; filename: string | null; loaded: boolean; children: Module[]; paths: string[]; path: string; constructor(id = "", parent?: Module | null) { this.id = id; this.exports = {}; this.parent = parent || null; updateChildren(parent || null, this, false); this.filename = null; this.loaded = false; this.children = []; this.paths = []; this.path = path.dirname(id); } static builtinModules: string[] = []; static _extensions: { // eslint-disable-next-line @typescript-eslint/no-explicit-any [key: string]: (module: Module, filename: string) => any; } = Object.create(null); static _cache: { [key: string]: Module } = Object.create(null); static _pathCache = Object.create(null); static globalPaths: string[] = []; // Proxy related code removed. static wrapper = [ "(function (exports, require, module, __filename, __dirname) { ", "\n});", ];
// Loads a module at the given file path. Returns that module's // `exports` property. // eslint-disable-next-line @typescript-eslint/no-explicit-any require(id: string): any { if (id === "") { throw new Error(`id '${id}' must be a non-empty string`); } requireDepth++; try { return Module._load(id, this, /* isMain */ false); } finally { requireDepth--; } }
// Given a file name, pass it to the proper extension handler. load(filename: string): void { assert(!this.loaded); this.filename = filename; this.paths = Module._nodeModulePaths(path.dirname(filename));
const extension = findLongestRegisteredExtension(filename); // Removed ESM code Module._extensions[extension](this, filename); this.loaded = true; // Removed ESM code }
// Run the file contents in the correct scope or sandbox. Expose // the correct helper variables (require, module, exports) to // the file. // Returns exception, if any. // eslint-disable-next-line @typescript-eslint/no-explicit-any _compile(content: string, filename: string): any { // manifest code removed const compiledWrapper = wrapSafe(filename, content); // inspector code remove const dirname = path.dirname(filename); const require = makeRequireFunction(this); const exports = this.exports; const thisValue = exports; if (requireDepth === 0) { statCache = new Map(); } const result = compiledWrapper.call( thisValue, exports, require, this, filename, dirname ); if (requireDepth === 0) { statCache = null; } return result; }
static _resolveLookupPaths( request: string, parent: Module | null ): string[] | null { // Check for node modules paths. if ( request.charAt(0) !== "." || (request.length > 1 && request.charAt(1) !== "." && request.charAt(1) !== "/" && (!isWindows || request.charAt(1) !== "\\")) ) { let paths = modulePaths; if (parent !== null && parent.paths && parent.paths.length) { paths = parent.paths.concat(paths); }
return paths.length > 0 ? paths : null; }
// With --eval, parent.id is not set and parent.filename is null. if (!parent || !parent.id || !parent.filename) { // Make require('./path/to/foo') work - normally the path is taken // from realpath(__filename) but with eval there is no filename const mainPaths = ["."].concat(Module._nodeModulePaths("."), modulePaths); return mainPaths; }
const parentDir = [path.dirname(parent.filename)]; return parentDir; }
static _resolveFilename( request: string, parent: Module, isMain: boolean, options?: { paths: string[] } ): string { // Polyfills. if (nativeModuleCanBeRequiredByUsers(request)) { return request; }
let paths: string[];
if (typeof options === "object" && options !== null) { if (Array.isArray(options.paths)) { const isRelative = request.startsWith("./") || request.startsWith("../") || (isWindows && request.startsWith(".\\")) || request.startsWith("..\\");
if (isRelative) { paths = options.paths; } else { const fakeParent = new Module("", null);
paths = [];
for (let i = 0; i < options.paths.length; i++) { const path = options.paths[i]; fakeParent.paths = Module._nodeModulePaths(path); const lookupPaths = Module._resolveLookupPaths(request, fakeParent);
for (let j = 0; j < lookupPaths!.length; j++) { if (!paths.includes(lookupPaths![j])) { paths.push(lookupPaths![j]); } } } } } else if (options.paths === undefined) { paths = Module._resolveLookupPaths(request, parent)!; } else { throw new Error("options.paths is invalid"); } } else { paths = Module._resolveLookupPaths(request, parent)!; }
// Look up the filename first, since that's the cache key. const filename = Module._findPath(request, paths, isMain); if (!filename) { const requireStack = []; for (let cursor: Module | null = parent; cursor; cursor = cursor.parent) { requireStack.push(cursor.filename || cursor.id); } let message = `Cannot find module '${request}'`; if (requireStack.length > 0) { message = message + "\nRequire stack:\n- " + requireStack.join("\n- "); } const err = new Error(message); // @ts-ignore err.code = "MODULE_NOT_FOUND"; // @ts-ignore err.requireStack = requireStack; throw err; } return filename as string; }
static _findPath( request: string, paths: string[], isMain: boolean ): string | boolean { const absoluteRequest = path.isAbsolute(request); if (absoluteRequest) { paths = [""]; } else if (!paths || paths.length === 0) { return false; }
const cacheKey = request + "\x00" + (paths.length === 1 ? paths[0] : paths.join("\x00")); const entry = Module._pathCache[cacheKey]; if (entry) { return entry; }
let exts; let trailingSlash = request.length > 0 && request.charCodeAt(request.length - 1) === CHAR_FORWARD_SLASH; if (!trailingSlash) { trailingSlash = /(?:^|\/)\.?\.$/.test(request); }
// For each path for (let i = 0; i < paths.length; i++) { // Don't search further if path doesn't exist const curPath = paths[i];
if (curPath && stat(curPath) < 1) continue; const basePath = resolveExports(curPath, request, absoluteRequest); let filename;
const rc = stat(basePath); if (!trailingSlash) { if (rc === 0) { // File. // preserveSymlinks removed filename = toRealPath(basePath); }
if (!filename) { // Try it with each of the extensions if (exts === undefined) exts = Object.keys(Module._extensions); filename = tryExtensions(basePath, exts, isMain); } }
if (!filename && rc === 1) { // Directory. // try it with each of the extensions at "index" if (exts === undefined) exts = Object.keys(Module._extensions); filename = tryPackage(basePath, exts, isMain, request); }
if (filename) { Module._pathCache[cacheKey] = filename; return filename; } } // trySelf removed.
return false; }
// Check the cache for the requested file. // 1. If a module already exists in the cache: return its exports object. // 2. If the module is native: call // `NativeModule.prototype.compileForPublicLoader()` and return the exports. // 3. Otherwise, create a new module for the file and save it to the cache. // Then have it load the file contents before returning its exports // object. // eslint-disable-next-line @typescript-eslint/no-explicit-any static _load(request: string, parent: Module, isMain: boolean): any { let relResolveCacheIdentifier: string | undefined; if (parent) { // Fast path for (lazy loaded) modules in the same directory. The indirect // caching is required to allow cache invalidation without changing the old // cache key names. relResolveCacheIdentifier = `${parent.path}\x00${request}`; const filename = relativeResolveCache[relResolveCacheIdentifier]; if (filename !== undefined) { const cachedModule = Module._cache[filename]; if (cachedModule !== undefined) { updateChildren(parent, cachedModule, true); if (!cachedModule.loaded) { return getExportsForCircularRequire(cachedModule); } return cachedModule.exports; } delete relativeResolveCache[relResolveCacheIdentifier]; } }
const filename = Module._resolveFilename(request, parent, isMain);
const cachedModule = Module._cache[filename]; if (cachedModule !== undefined) { updateChildren(parent, cachedModule, true); if (!cachedModule.loaded) { return getExportsForCircularRequire(cachedModule); } return cachedModule.exports; }
// Native module polyfills const mod = loadNativeModule(filename, request); if (mod) return mod.exports;
// Don't call updateChildren(), Module constructor already does. const module = new Module(filename, parent);
if (isMain) { // TODO: set process info // process.mainModule = module; module.id = "."; }
Module._cache[filename] = module; if (parent !== undefined) { assert(relResolveCacheIdentifier); relativeResolveCache[relResolveCacheIdentifier] = filename; }
let threw = true; try { // Source map code removed module.load(filename); threw = false; } finally { if (threw) { delete Module._cache[filename]; if (parent !== undefined) { assert(relResolveCacheIdentifier); delete relativeResolveCache[relResolveCacheIdentifier]; } } else if ( module.exports && Object.getPrototypeOf(module.exports) === CircularRequirePrototypeWarningProxy ) { Object.setPrototypeOf(module.exports, PublicObjectPrototype); } }
return module.exports; }
static wrap(script: string): string { return `${Module.wrapper[0]}${script}${Module.wrapper[1]}`; }
static _nodeModulePaths(from: string): string[] { if (isWindows) { // Guarantee that 'from' is absolute. from = path.resolve(from);
// note: this approach *only* works when the path is guaranteed // to be absolute. Doing a fully-edge-case-correct path.split // that works on both Windows and Posix is non-trivial.
// return root node_modules when path is 'D:\\'. // path.resolve will make sure from.length >=3 in Windows. if ( from.charCodeAt(from.length - 1) === CHAR_BACKWARD_SLASH && from.charCodeAt(from.length - 2) === CHAR_COLON ) { return [from + "node_modules"]; }
const paths = []; for (let i = from.length - 1, p = 0, last = from.length; i >= 0; --i) { const code = from.charCodeAt(i); // The path segment separator check ('\' and '/') was used to get // node_modules path for every path segment. // Use colon as an extra condition since we can get node_modules // path for drive root like 'C:\node_modules' and don't need to // parse drive name. if ( code === CHAR_BACKWARD_SLASH || code === CHAR_FORWARD_SLASH || code === CHAR_COLON ) { if (p !== nmLen) paths.push(from.slice(0, last) + "\\node_modules"); last = i; p = 0; } else if (p !== -1) { if (nmChars[p] === code) { ++p; } else { p = -1; } } }
return paths; } else { // posix // Guarantee that 'from' is absolute. from = path.resolve(from); // Return early not only to avoid unnecessary work, but to *avoid* returning // an array of two items for a root: [ '//node_modules', '/node_modules' ] if (from === "/") return ["/node_modules"];
// note: this approach *only* works when the path is guaranteed // to be absolute. Doing a fully-edge-case-correct path.split // that works on both Windows and Posix is non-trivial. const paths = []; for (let i = from.length - 1, p = 0, last = from.length; i >= 0; --i) { const code = from.charCodeAt(i); if (code === CHAR_FORWARD_SLASH) { if (p !== nmLen) paths.push(from.slice(0, last) + "/node_modules"); last = i; p = 0; } else if (p !== -1) { if (nmChars[p] === code) { ++p; } else { p = -1; } } }
// Append /node_modules to handle root paths. paths.push("/node_modules");
return paths; } }
/** * Create a `require` function that can be used to import CJS modules. * Follows CommonJS resolution similar to that of Node.js, * with `node_modules` lookup and `index.js` lookup support. * Also injects available Node.js builtin module polyfills. * * const require_ = createRequire(import.meta.url); * const fs = require_("fs"); * const leftPad = require_("left-pad"); * const cjsModule = require_("./cjs_mod"); * * @param filename path or URL to current module * @return Require function to import CJS modules */ static createRequire(filename: string | URL): RequireFunction { let filepath: string; if ( filename instanceof URL || (typeof filename === "string" && !path.isAbsolute(filename)) ) { filepath = fileURLToPath(filename); } else if (typeof filename !== "string") { throw new Error("filename should be a string"); } else { filepath = filename; } return createRequireFromPath(filepath); }
static _initPaths(): void { const homeDir = Deno.env("HOME"); const nodePath = Deno.env("NODE_PATH");
// Removed $PREFIX/bin/node case
let paths = [];
if (homeDir) { paths.unshift(path.resolve(homeDir, ".node_libraries")); paths.unshift(path.resolve(homeDir, ".node_modules")); }
if (nodePath) { paths = nodePath .split(path.delimiter) .filter(function pathsFilterCB(path) { return !!path; }) .concat(paths); }
modulePaths = paths;
// Clone as a shallow copy, for introspection. Module.globalPaths = modulePaths.slice(0); }
static _preloadModules(requests: string[]): void { if (!Array.isArray(requests)) { return; }
// Preloaded modules have a dummy parent module which is deemed to exist // in the current working directory. This seeds the search path for // preloaded modules. const parent = new Module("internal/preload", null); try { parent.paths = Module._nodeModulePaths(Deno.cwd()); } catch (e) { if (e.code !== "ENOENT") { throw e; } } for (let n = 0; n < requests.length; n++) { parent.require(requests[n]); } }}
// Polyfills.const nativeModulePolyfill = new Map<string, Module>();// eslint-disable-next-line @typescript-eslint/no-explicit-anyfunction createNativeModule(id: string, exports: any): Module { const mod = new Module(id); mod.exports = exports; mod.loaded = true; return mod;}
nativeModulePolyfill.set("fs", createNativeModule("fs", nodeFS));nativeModulePolyfill.set("events", createNativeModule("events", nodeEvents));nativeModulePolyfill.set("os", createNativeModule("os", nodeOs));nativeModulePolyfill.set("path", createNativeModule("path", nodePath));nativeModulePolyfill.set("timers", createNativeModule("timers", nodeTimers));nativeModulePolyfill.set("util", createNativeModule("util", nodeUtil));nativeModulePolyfill.set( "querystring", createNativeModule("querystring", nodeQueryString));
function loadNativeModule( _filename: string, request: string): Module | undefined { return nativeModulePolyfill.get(request);}function nativeModuleCanBeRequiredByUsers(request: string): boolean { return nativeModulePolyfill.has(request);}// Populate with polyfill namesfor (const id of nativeModulePolyfill.keys()) { Module.builtinModules.push(id);}
let modulePaths: string[] = [];
// Given a module name, and a list of paths to test, returns the first// matching file in the following precedence.//// require("a.<ext>")// -> a.<ext>//// require("a")// -> a// -> a.<ext>// -> a/index.<ext>
const packageJsonCache = new Map<string, PackageInfo | null>();
interface PackageInfo { name?: string; main?: string; // eslint-disable-next-line @typescript-eslint/no-explicit-any exports?: any; // eslint-disable-next-line @typescript-eslint/no-explicit-any type?: any;}
function readPackage(requestPath: string): PackageInfo | null { const jsonPath = path.resolve(requestPath, "package.json");
const existing = packageJsonCache.get(jsonPath); if (existing !== undefined) { return existing; }
let json: string | undefined; try { json = new TextDecoder().decode( Deno.readFileSync(path.toNamespacedPath(jsonPath)) ); } catch {}
if (json === undefined) { packageJsonCache.set(jsonPath, null); return null; }
try { const parsed = JSON.parse(json); const filtered = { name: parsed.name, main: parsed.main, exports: parsed.exports, type: parsed.type, }; packageJsonCache.set(jsonPath, filtered); return filtered; } catch (e) { e.path = jsonPath; e.message = "Error parsing " + jsonPath + ": " + e.message; throw e; }}
function readPackageScope( checkPath: string): { path: string; data: PackageInfo } | false { const rootSeparatorIndex = checkPath.indexOf(path.sep); let separatorIndex; while ( (separatorIndex = checkPath.lastIndexOf(path.sep)) > rootSeparatorIndex ) { checkPath = checkPath.slice(0, separatorIndex); if (checkPath.endsWith(path.sep + "node_modules")) return false; const pjson = readPackage(checkPath); if (pjson) { return { path: checkPath, data: pjson, }; } } return false;}
function readPackageMain(requestPath: string): string | undefined { const pkg = readPackage(requestPath); return pkg ? pkg.main : undefined;}
// eslint-disable-next-line @typescript-eslint/no-explicit-anyfunction readPackageExports(requestPath: string): any | undefined { const pkg = readPackage(requestPath); return pkg ? pkg.exports : undefined;}
function tryPackage( requestPath: string, exts: string[], isMain: boolean, _originalPath: string): string | false { const pkg = readPackageMain(requestPath);
if (!pkg) { return tryExtensions(path.resolve(requestPath, "index"), exts, isMain); }
const filename = path.resolve(requestPath, pkg); let actual = tryFile(filename, isMain) || tryExtensions(filename, exts, isMain) || tryExtensions(path.resolve(filename, "index"), exts, isMain); if (actual === false) { actual = tryExtensions(path.resolve(requestPath, "index"), exts, isMain); if (!actual) { // eslint-disable-next-line no-restricted-syntax const err = new Error( `Cannot find module '${filename}'. ` + 'Please verify that the package.json has a valid "main" entry' ); // @ts-ignore err.code = "MODULE_NOT_FOUND"; throw err; } } return actual;}
// Check if the file exists and is not a directory// if using --preserve-symlinks and isMain is false,// keep symlinks intact, otherwise resolve to the// absolute realpath.function tryFile(requestPath: string, _isMain: boolean): string | false { const rc = stat(requestPath); return rc === 0 && toRealPath(requestPath);}
function toRealPath(requestPath: string): string { // Deno does not have realpath implemented yet. let fullPath = requestPath; while (true) { try { fullPath = Deno.readlinkSync(fullPath); } catch { break; } } return path.resolve(requestPath);}
// Given a path, check if the file exists with any of the set extensionsfunction tryExtensions( p: string, exts: string[], isMain: boolean): string | false { for (let i = 0; i < exts.length; i++) { const filename = tryFile(p + exts[i], isMain);
if (filename) { return filename; } } return false;}
// Find the longest (possibly multi-dot) extension registered in// Module._extensionsfunction findLongestRegisteredExtension(filename: string): string { const name = path.basename(filename); let currentExtension; let index; let startIndex = 0; while ((index = name.indexOf(".", startIndex)) !== -1) { startIndex = index + 1; if (index === 0) continue; // Skip dotfiles like .gitignore currentExtension = name.slice(index); if (Module._extensions[currentExtension]) return currentExtension; } return ".js";}
// --experimental-resolve-self trySelf() support removed.
// eslint-disable-next-line @typescript-eslint/no-explicit-anyfunction isConditionalDotExportSugar(exports: any, _basePath: string): boolean { if (typeof exports === "string") return true; if (Array.isArray(exports)) return true; if (typeof exports !== "object") return false; let isConditional = false; let firstCheck = true; for (const key of Object.keys(exports)) { const curIsConditional = key[0] !== "."; if (firstCheck) { firstCheck = false; isConditional = curIsConditional; } else if (isConditional !== curIsConditional) { throw new Error( '"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 isConditional;}
function applyExports(basePath: string, expansion: string): string { const mappingKey = `.${expansion}`;
let pkgExports = readPackageExports(basePath); if (pkgExports === undefined || pkgExports === null) { return path.resolve(basePath, mappingKey); }
if (isConditionalDotExportSugar(pkgExports, basePath)) { pkgExports = { ".": pkgExports }; }
if (typeof pkgExports === "object") { if (pkgExports.hasOwnProperty(mappingKey)) { const mapping = pkgExports[mappingKey]; return resolveExportsTarget( pathToFileURL(basePath + "/"), mapping, "", basePath, mappingKey ); }
// Fallback to CJS main lookup when no main export is defined if (mappingKey === ".") return basePath;
let dirMatch = ""; for (const candidateKey of Object.keys(pkgExports)) { if (candidateKey[candidateKey.length - 1] !== "/") continue; if ( candidateKey.length > dirMatch.length && mappingKey.startsWith(candidateKey) ) { dirMatch = candidateKey; } }
if (dirMatch !== "") { const mapping = pkgExports[dirMatch]; const subpath = mappingKey.slice(dirMatch.length); return resolveExportsTarget( pathToFileURL(basePath + "/"), mapping, subpath, basePath, mappingKey ); } } // Fallback to CJS main lookup when no main export is defined if (mappingKey === ".") return basePath;
const e = new Error( `Package exports for '${basePath}' do not define ` + `a '${mappingKey}' subpath` ); // @ts-ignore e.code = "MODULE_NOT_FOUND"; throw e;}
// This only applies to requests of a specific form:// 1. name/.*// 2. @scope/name/.*const EXPORTS_PATTERN = /^((?:@[^/\\%]+\/)?[^./\\%][^/\\%]*)(\/.*)?$/;function resolveExports( nmPath: string, request: string, absoluteRequest: boolean): string { // The implementation's behavior is meant to mirror resolution in ESM. if (!absoluteRequest) { const [, name, expansion = ""] = request.match(EXPORTS_PATTERN) || []; if (!name) { return path.resolve(nmPath, request); }
const basePath = path.resolve(nmPath, name); return applyExports(basePath, expansion); }
return path.resolve(nmPath, request);}
// eslint-disable-next-line @typescript-eslint/no-explicit-anyfunction resolveExportsTarget( pkgPath: URL, // eslint-disable-next-line @typescript-eslint/no-explicit-any target: any, subpath: string, basePath: string, mappingKey: string): string { if (typeof target === "string") { if ( target.startsWith("./") && (subpath.length === 0 || target.endsWith("/")) ) { const resolvedTarget = new URL(target, pkgPath); const pkgPathPath = pkgPath.pathname; const resolvedTargetPath = resolvedTarget.pathname; if ( resolvedTargetPath.startsWith(pkgPathPath) && resolvedTargetPath.indexOf("/node_modules/", pkgPathPath.length - 1) === -1 ) { const resolved = new URL(subpath, resolvedTarget); const resolvedPath = resolved.pathname; if ( resolvedPath.startsWith(resolvedTargetPath) && resolvedPath.indexOf("/node_modules/", pkgPathPath.length - 1) === -1 ) { return fileURLToPath(resolved); } } } } else if (Array.isArray(target)) { for (const targetValue of target) { if (Array.isArray(targetValue)) continue; try { return resolveExportsTarget( pkgPath, targetValue, subpath, basePath, mappingKey ); } catch (e) { if (e.code !== "MODULE_NOT_FOUND") throw e; } } } else if (typeof target === "object" && target !== null) { // removed experimentalConditionalExports if (target.hasOwnProperty("default")) { try { return resolveExportsTarget( pkgPath, target.default, subpath, basePath, mappingKey ); } catch (e) { if (e.code !== "MODULE_NOT_FOUND") throw e; } } } let e: Error; if (mappingKey !== ".") { e = new Error( `Package exports for '${basePath}' do not define a ` + `valid '${mappingKey}' target${subpath ? " for " + subpath : ""}` ); } else { e = new Error(`No valid exports main found for '${basePath}'`); } // @ts-ignore e.code = "MODULE_NOT_FOUND"; throw e;}
// 'node_modules' character codes reversedconst nmChars = [115, 101, 108, 117, 100, 111, 109, 95, 101, 100, 111, 110];const nmLen = nmChars.length;
// eslint-disable-next-line @typescript-eslint/no-explicit-anyfunction emitCircularRequireWarning(prop: any): void { console.error( `Accessing non-existent property '${String( prop )}' of module exports inside circular dependency` );}
// A Proxy that can be used as the prototype of a module.exports object and// warns when non-existend properties are accessed.const CircularRequirePrototypeWarningProxy = new Proxy( {}, { // eslint-disable-next-line @typescript-eslint/no-explicit-any get(target, prop): any { // @ts-ignore if (prop in target) return target[prop]; emitCircularRequireWarning(prop); return undefined; },
getOwnPropertyDescriptor(target, prop): PropertyDescriptor | undefined { if (target.hasOwnProperty(prop)) { return Object.getOwnPropertyDescriptor(target, prop); } emitCircularRequireWarning(prop); return undefined; }, });
// Object.prototype and ObjectProtoype refer to our 'primordials' versions// and are not identical to the versions on the global object.const PublicObjectPrototype = window.Object.prototype;
// eslint-disable-next-line @typescript-eslint/no-explicit-anyfunction getExportsForCircularRequire(module: Module): any { if ( module.exports && Object.getPrototypeOf(module.exports) === PublicObjectPrototype && // Exclude transpiled ES6 modules / TypeScript code because those may // employ unusual patterns for accessing 'module.exports'. That should be // okay because ES6 modules have a different approach to circular // dependencies anyway. !module.exports.__esModule ) { // This is later unset once the module is done loading. Object.setPrototypeOf(module.exports, CircularRequirePrototypeWarningProxy); }
return module.exports;}
type RequireWrapper = ( // eslint-disable-next-line @typescript-eslint/no-explicit-any exports: any, // eslint-disable-next-line @typescript-eslint/no-explicit-any require: any, module: Module, __filename: string, __dirname: string) => void;
function wrapSafe(filename: string, content: string): RequireWrapper { // TODO: fix this const wrapper = Module.wrap(content); // @ts-ignore const [f, err] = Deno.core.evalContext(wrapper, filename); if (err) { throw err; } return f; // ESM code removed.}
// Native extension for .jsModule._extensions[".js"] = (module: Module, filename: string): void => { if (filename.endsWith(".js")) { const pkg = readPackageScope(filename); if (pkg !== false && pkg.data && pkg.data.type === "module") { throw new Error("Importing ESM module"); } } const content = new TextDecoder().decode(Deno.readFileSync(filename)); module._compile(content, filename);};
// Native extension for .jsonModule._extensions[".json"] = (module: Module, filename: string): void => { const content = new TextDecoder().decode(Deno.readFileSync(filename)); // manifest code removed try { module.exports = JSON.parse(stripBOM(content)); } catch (err) { err.message = filename + ": " + err.message; throw err; }};
// .node extension is not supported
function createRequireFromPath(filename: string): RequireFunction { // Allow a directory to be passed as the filename const trailingSlash = filename.endsWith("/") || (isWindows && filename.endsWith("\\"));
const proxyPath = trailingSlash ? path.join(filename, "noop.js") : filename;
const m = new Module(proxyPath); m.filename = proxyPath;
m.paths = Module._nodeModulePaths(m.path); return makeRequireFunction(m);}
// eslint-disable-next-line @typescript-eslint/no-explicit-anytype Require = (id: string) => any;// eslint-disable-next-line @typescript-eslint/no-explicit-anytype RequireResolve = (request: string, options: any) => string;interface RequireResolveFunction extends RequireResolve { paths: (request: string) => string[] | null;}
interface RequireFunction extends Require { // eslint-disable-next-line @typescript-eslint/no-explicit-any resolve: RequireResolveFunction; // eslint-disable-next-line @typescript-eslint/no-explicit-any extensions: { [key: string]: (module: Module, filename: string) => any }; cache: { [key: string]: Module };}
function makeRequireFunction(mod: Module): RequireFunction { // eslint-disable-next-line @typescript-eslint/no-explicit-any const require = function require(path: string): any { return mod.require(path); };
function resolve(request: string, options?: { paths: string[] }): string { return Module._resolveFilename(request, mod, false, options); }
require.resolve = resolve;
function paths(request: string): string[] | null { return Module._resolveLookupPaths(request, mod); }
resolve.paths = paths; // TODO: set main // require.main = process.mainModule;
// Enable support to add extra extension types. require.extensions = Module._extensions;
require.cache = Module._cache;
return require;}
/** * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM) * because the buffer-to-string conversion in `fs.readFileSync()` * translates it to FEFF, the UTF-16 BOM. */function stripBOM(content: string): string { if (content.charCodeAt(0) === 0xfeff) { content = content.slice(1); } return content;}
const forwardSlashRegEx = /\//g;const CHAR_LOWERCASE_A = "a".charCodeAt(0);const CHAR_LOWERCASE_Z = "z".charCodeAt(0);
function getPathFromURLWin32(url: URL): string { // const hostname = url.hostname; let pathname = url.pathname; for (let n = 0; n < pathname.length; n++) { if (pathname[n] === "%") { const third = pathname.codePointAt(n + 2)! | 0x20; if ( (pathname[n + 1] === "2" && third === 102) || // 2f 2F / (pathname[n + 1] === "5" && third === 99) ) { // 5c 5C \ throw new Error( "Invalid file url path: must not include encoded \\ or / characters" ); } } } pathname = pathname.replace(forwardSlashRegEx, "\\"); pathname = decodeURIComponent(pathname); // TODO: handle windows hostname case (needs bindings) const letter = pathname.codePointAt(1)! | 0x20; const sep = pathname[2]; if ( letter < CHAR_LOWERCASE_A || letter > CHAR_LOWERCASE_Z || // a..z A..Z sep !== ":" ) { throw new Error("Invalid file URL path: must be absolute"); } return pathname.slice(1);}
function getPathFromURLPosix(url: URL): string { if (url.hostname !== "") { throw new Error("Invalid file URL host"); } const pathname = url.pathname; for (let n = 0; n < pathname.length; n++) { if (pathname[n] === "%") { const third = pathname.codePointAt(n + 2)! | 0x20; if (pathname[n + 1] === "2" && third === 102) { throw new Error( "Invalid file URL path: must not include encoded / characters" ); } } } return decodeURIComponent(pathname);}
function fileURLToPath(path: string | URL): string { if (typeof path === "string") { path = new URL(path); } if (path.protocol !== "file:") { throw new Error("Protocol has to be file://"); } return isWindows ? getPathFromURLWin32(path) : getPathFromURLPosix(path);}
const percentRegEx = /%/g;const backslashRegEx = /\\/g;const newlineRegEx = /\n/g;const carriageReturnRegEx = /\r/g;const tabRegEx = /\t/g;function pathToFileURL(filepath: string): URL { let resolved = path.resolve(filepath); // path.resolve strips trailing slashes so we must add them back const filePathLast = filepath.charCodeAt(filepath.length - 1); if ( (filePathLast === CHAR_FORWARD_SLASH || (isWindows && filePathLast === CHAR_BACKWARD_SLASH)) && resolved[resolved.length - 1] !== path.sep ) { resolved += "/"; } const outURL = new URL("file://"); if (resolved.includes("%")) resolved = resolved.replace(percentRegEx, "%25"); // In posix, "/" is a valid character in paths if (!isWindows && resolved.includes("\\")) { resolved = resolved.replace(backslashRegEx, "%5C"); } if (resolved.includes("\n")) { resolved = resolved.replace(newlineRegEx, "%0A"); } if (resolved.includes("\r")) { resolved = resolved.replace(carriageReturnRegEx, "%0D"); } if (resolved.includes("\t")) resolved = resolved.replace(tabRegEx, "%09"); outURL.pathname = resolved; return outURL;}
export const builtinModules = Module.builtinModules;export const createRequire = Module.createRequire;export default Module;