1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246
// 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 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));
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);  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;