@invariant--labs/foundation 1.1.2 → 1.1.5

package/.pnp.loader.mjs

@@ -1,2126 +0,0 @@
-/* eslint-disable */
-// @ts-nocheck
-
-import fs from 'fs';
-import { URL as URL$1, fileURLToPath, pathToFileURL } from 'url';
-import path from 'path';
-import { createHash } from 'crypto';
-import { EOL } from 'os';
-import esmModule, { createRequire, isBuiltin } from 'module';
-import assert from 'assert';
-
-const SAFE_TIME = 456789e3;
-
-const PortablePath = {
-  root: `/`,
-  dot: `.`,
-  parent: `..`
-};
-const npath = Object.create(path);
-const ppath = Object.create(path.posix);
-npath.cwd = () => process.cwd();
-ppath.cwd = process.platform === `win32` ? () => toPortablePath(process.cwd()) : process.cwd;
-if (process.platform === `win32`) {
-  ppath.resolve = (...segments) => {
-    if (segments.length > 0 && ppath.isAbsolute(segments[0])) {
-      return path.posix.resolve(...segments);
-    } else {
-      return path.posix.resolve(ppath.cwd(), ...segments);
-    }
-  };
-}
-const contains = function(pathUtils, from, to) {
-  from = pathUtils.normalize(from);
-  to = pathUtils.normalize(to);
-  if (from === to)
-    return `.`;
-  if (!from.endsWith(pathUtils.sep))
-    from = from + pathUtils.sep;
-  if (to.startsWith(from)) {
-    return to.slice(from.length);
-  } else {
-    return null;
-  }
-};
-npath.contains = (from, to) => contains(npath, from, to);
-ppath.contains = (from, to) => contains(ppath, from, to);
-const WINDOWS_PATH_REGEXP = /^([a-zA-Z]:.*)$/;
-const UNC_WINDOWS_PATH_REGEXP = /^\/\/(\.\/)?(.*)$/;
-const PORTABLE_PATH_REGEXP = /^\/([a-zA-Z]:.*)$/;
-const UNC_PORTABLE_PATH_REGEXP = /^\/unc\/(\.dot\/)?(.*)$/;
-function fromPortablePathWin32(p) {
-  let portablePathMatch, uncPortablePathMatch;
-  if (portablePathMatch = p.match(PORTABLE_PATH_REGEXP))
-    p = portablePathMatch[1];
-  else if (uncPortablePathMatch = p.match(UNC_PORTABLE_PATH_REGEXP))
-    p = `\\\\${uncPortablePathMatch[1] ? `.\\` : ``}${uncPortablePathMatch[2]}`;
-  else
-    return p;
-  return p.replace(/\//g, `\\`);
-}
-function toPortablePathWin32(p) {
-  p = p.replace(/\\/g, `/`);
-  let windowsPathMatch, uncWindowsPathMatch;
-  if (windowsPathMatch = p.match(WINDOWS_PATH_REGEXP))
-    p = `/${windowsPathMatch[1]}`;
-  else if (uncWindowsPathMatch = p.match(UNC_WINDOWS_PATH_REGEXP))
-    p = `/unc/${uncWindowsPathMatch[1] ? `.dot/` : ``}${uncWindowsPathMatch[2]}`;
-  return p;
-}
-const toPortablePath = process.platform === `win32` ? toPortablePathWin32 : (p) => p;
-const fromPortablePath = process.platform === `win32` ? fromPortablePathWin32 : (p) => p;
-npath.fromPortablePath = fromPortablePath;
-npath.toPortablePath = toPortablePath;
-function convertPath(targetPathUtils, sourcePath) {
-  return targetPathUtils === npath ? fromPortablePath(sourcePath) : toPortablePath(sourcePath);
-}
-
-const defaultTime = new Date(SAFE_TIME * 1e3);
-const defaultTimeMs = defaultTime.getTime();
-async function copyPromise(destinationFs, destination, sourceFs, source, opts) {
-  const normalizedDestination = destinationFs.pathUtils.normalize(destination);
-  const normalizedSource = sourceFs.pathUtils.normalize(source);
-  const prelayout = [];
-  const postlayout = [];
-  const { atime, mtime } = opts.stableTime ? { atime: defaultTime, mtime: defaultTime } : await sourceFs.lstatPromise(normalizedSource);
-  await destinationFs.mkdirpPromise(destinationFs.pathUtils.dirname(destination), { utimes: [atime, mtime] });
-  await copyImpl(prelayout, postlayout, destinationFs, normalizedDestination, sourceFs, normalizedSource, { ...opts, didParentExist: true });
-  for (const operation of prelayout)
-    await operation();
-  await Promise.all(postlayout.map((operation) => {
-    return operation();
-  }));
-}
-async function copyImpl(prelayout, postlayout, destinationFs, destination, sourceFs, source, opts) {
-  const destinationStat = opts.didParentExist ? await maybeLStat(destinationFs, destination) : null;
-  const sourceStat = await sourceFs.lstatPromise(source);
-  const { atime, mtime } = opts.stableTime ? { atime: defaultTime, mtime: defaultTime } : sourceStat;
-  let updated;
-  switch (true) {
-    case sourceStat.isDirectory():
-      {
-        updated = await copyFolder(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
-      }
-      break;
-    case sourceStat.isFile():
-      {
-        updated = await copyFile(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
-      }
-      break;
-    case sourceStat.isSymbolicLink():
-      {
-        updated = await copySymlink(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
-      }
-      break;
-    default: {
-      throw new Error(`Unsupported file type (${sourceStat.mode})`);
-    }
-  }
-  if (opts.linkStrategy?.type !== `HardlinkFromIndex` || !sourceStat.isFile()) {
-    if (updated || destinationStat?.mtime?.getTime() !== mtime.getTime() || destinationStat?.atime?.getTime() !== atime.getTime()) {
-      postlayout.push(() => destinationFs.lutimesPromise(destination, atime, mtime));
-      updated = true;
-    }
-    if (destinationStat === null || (destinationStat.mode & 511) !== (sourceStat.mode & 511)) {
-      postlayout.push(() => destinationFs.chmodPromise(destination, sourceStat.mode & 511));
-      updated = true;
-    }
-  }
-  return updated;
-}
-async function maybeLStat(baseFs, p) {
-  try {
-    return await baseFs.lstatPromise(p);
-  } catch {
-    return null;
-  }
-}
-async function copyFolder(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
-  if (destinationStat !== null && !destinationStat.isDirectory()) {
-    if (opts.overwrite) {
-      prelayout.push(async () => destinationFs.removePromise(destination));
-      destinationStat = null;
-    } else {
-      return false;
-    }
-  }
-  let updated = false;
-  if (destinationStat === null) {
-    prelayout.push(async () => {
-      try {
-        await destinationFs.mkdirPromise(destination, { mode: sourceStat.mode });
-      } catch (err) {
-        if (err.code !== `EEXIST`) {
-          throw err;
-        }
-      }
-    });
-    updated = true;
-  }
-  const entries = await sourceFs.readdirPromise(source);
-  const nextOpts = opts.didParentExist && !destinationStat ? { ...opts, didParentExist: false } : opts;
-  if (opts.stableSort) {
-    for (const entry of entries.sort()) {
-      if (await copyImpl(prelayout, postlayout, destinationFs, destinationFs.pathUtils.join(destination, entry), sourceFs, sourceFs.pathUtils.join(source, entry), nextOpts)) {
-        updated = true;
-      }
-    }
-  } else {
-    const entriesUpdateStatus = await Promise.all(entries.map(async (entry) => {
-      await copyImpl(prelayout, postlayout, destinationFs, destinationFs.pathUtils.join(destination, entry), sourceFs, sourceFs.pathUtils.join(source, entry), nextOpts);
-    }));
-    if (entriesUpdateStatus.some((status) => status)) {
-      updated = true;
-    }
-  }
-  return updated;
-}
-async function copyFileViaIndex(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts, linkStrategy) {
-  const sourceHash = await sourceFs.checksumFilePromise(source, { algorithm: `sha1` });
-  const defaultMode = 420;
-  const sourceMode = sourceStat.mode & 511;
-  const indexFileName = `${sourceHash}${sourceMode !== defaultMode ? sourceMode.toString(8) : ``}`;
-  const indexPath = destinationFs.pathUtils.join(linkStrategy.indexPath, sourceHash.slice(0, 2), `${indexFileName}.dat`);
-  let AtomicBehavior;
-  ((AtomicBehavior2) => {
-    AtomicBehavior2[AtomicBehavior2["Lock"] = 0] = "Lock";
-    AtomicBehavior2[AtomicBehavior2["Rename"] = 1] = "Rename";
-  })(AtomicBehavior || (AtomicBehavior = {}));
-  let atomicBehavior = 1 /* Rename */;
-  let indexStat = await maybeLStat(destinationFs, indexPath);
-  if (destinationStat) {
-    const isDestinationHardlinkedFromIndex = indexStat && destinationStat.dev === indexStat.dev && destinationStat.ino === indexStat.ino;
-    const isIndexModified = indexStat?.mtimeMs !== defaultTimeMs;
-    if (isDestinationHardlinkedFromIndex) {
-      if (isIndexModified && linkStrategy.autoRepair) {
-        atomicBehavior = 0 /* Lock */;
-        indexStat = null;
-      }
-    }
-    if (!isDestinationHardlinkedFromIndex) {
-      if (opts.overwrite) {
-        prelayout.push(async () => destinationFs.removePromise(destination));
-        destinationStat = null;
-      } else {
-        return false;
-      }
-    }
-  }
-  const tempPath = !indexStat && atomicBehavior === 1 /* Rename */ ? `${indexPath}.${Math.floor(Math.random() * 4294967296).toString(16).padStart(8, `0`)}` : null;
-  let tempPathCleaned = false;
-  prelayout.push(async () => {
-    if (!indexStat) {
-      if (atomicBehavior === 0 /* Lock */) {
-        await destinationFs.lockPromise(indexPath, async () => {
-          const content = await sourceFs.readFilePromise(source);
-          await destinationFs.writeFilePromise(indexPath, content);
-        });
-      }
-      if (atomicBehavior === 1 /* Rename */ && tempPath) {
-        const content = await sourceFs.readFilePromise(source);
-        await destinationFs.writeFilePromise(tempPath, content);
-        try {
-          await destinationFs.linkPromise(tempPath, indexPath);
-        } catch (err) {
-          if (err.code === `EEXIST`) {
-            tempPathCleaned = true;
-            await destinationFs.unlinkPromise(tempPath);
-          } else {
-            throw err;
-          }
-        }
-      }
-    }
-    if (!destinationStat) {
-      await destinationFs.linkPromise(indexPath, destination);
-    }
-  });
-  postlayout.push(async () => {
-    if (!indexStat) {
-      await destinationFs.lutimesPromise(indexPath, defaultTime, defaultTime);
-      if (sourceMode !== defaultMode) {
-        await destinationFs.chmodPromise(indexPath, sourceMode);
-      }
-    }
-    if (tempPath && !tempPathCleaned) {
-      await destinationFs.unlinkPromise(tempPath);
-    }
-  });
-  return false;
-}
-async function copyFileDirect(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
-  if (destinationStat !== null) {
-    if (opts.overwrite) {
-      prelayout.push(async () => destinationFs.removePromise(destination));
-      destinationStat = null;
-    } else {
-      return false;
-    }
-  }
-  prelayout.push(async () => {
-    const content = await sourceFs.readFilePromise(source);
-    await destinationFs.writeFilePromise(destination, content);
-  });
-  return true;
-}
-async function copyFile(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
-  if (opts.linkStrategy?.type === `HardlinkFromIndex`) {
-    return copyFileViaIndex(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts, opts.linkStrategy);
-  } else {
-    return copyFileDirect(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
-  }
-}
-async function copySymlink(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
-  if (destinationStat !== null) {
-    if (opts.overwrite) {
-      prelayout.push(async () => destinationFs.removePromise(destination));
-      destinationStat = null;
-    } else {
-      return false;
-    }
-  }
-  prelayout.push(async () => {
-    await destinationFs.symlinkPromise(convertPath(destinationFs.pathUtils, await sourceFs.readlinkPromise(source)), destination);
-  });
-  return true;
-}
-
-class FakeFS {
-  pathUtils;
-  constructor(pathUtils) {
-    this.pathUtils = pathUtils;
-  }
-  async *genTraversePromise(init, { stableSort = false } = {}) {
-    const stack = [init];
-    while (stack.length > 0) {
-      const p = stack.shift();
-      const entry = await this.lstatPromise(p);
-      if (entry.isDirectory()) {
-        const entries = await this.readdirPromise(p);
-        if (stableSort) {
-          for (const entry2 of entries.sort()) {
-            stack.push(this.pathUtils.join(p, entry2));
-          }
-        } else {
-          throw new Error(`Not supported`);
-        }
-      } else {
-        yield p;
-      }
-    }
-  }
-  async checksumFilePromise(path, { algorithm = `sha512` } = {}) {
-    const fd = await this.openPromise(path, `r`);
-    try {
-      const CHUNK_SIZE = 65536;
-      const chunk = Buffer.allocUnsafeSlow(CHUNK_SIZE);
-      const hash = createHash(algorithm);
-      let bytesRead = 0;
-      while ((bytesRead = await this.readPromise(fd, chunk, 0, CHUNK_SIZE)) !== 0)
-        hash.update(bytesRead === CHUNK_SIZE ? chunk : chunk.slice(0, bytesRead));
-      return hash.digest(`hex`);
-    } finally {
-      await this.closePromise(fd);
-    }
-  }
-  async removePromise(p, { recursive = true, maxRetries = 5 } = {}) {
-    let stat;
-    try {
-      stat = await this.lstatPromise(p);
-    } catch (error) {
-      if (error.code === `ENOENT`) {
-        return;
-      } else {
-        throw error;
-      }
-    }
-    if (stat.isDirectory()) {
-      if (recursive) {
-        const entries = await this.readdirPromise(p);
-        await Promise.all(entries.map((entry) => {
-          return this.removePromise(this.pathUtils.resolve(p, entry));
-        }));
-      }
-      for (let t = 0; t <= maxRetries; t++) {
-        try {
-          await this.rmdirPromise(p);
-          break;
-        } catch (error) {
-          if (error.code !== `EBUSY` && error.code !== `ENOTEMPTY`) {
-            throw error;
-          } else if (t < maxRetries) {
-            await new Promise((resolve) => setTimeout(resolve, t * 100));
-          }
-        }
-      }
-    } else {
-      await this.unlinkPromise(p);
-    }
-  }
-  removeSync(p, { recursive = true } = {}) {
-    let stat;
-    try {
-      stat = this.lstatSync(p);
-    } catch (error) {
-      if (error.code === `ENOENT`) {
-        return;
-      } else {
-        throw error;
-      }
-    }
-    if (stat.isDirectory()) {
-      if (recursive)
-        for (const entry of this.readdirSync(p))
-          this.removeSync(this.pathUtils.resolve(p, entry));
-      this.rmdirSync(p);
-    } else {
-      this.unlinkSync(p);
-    }
-  }
-  async mkdirpPromise(p, { chmod, utimes } = {}) {
-    p = this.resolve(p);
-    if (p === this.pathUtils.dirname(p))
-      return void 0;
-    const parts = p.split(this.pathUtils.sep);
-    let createdDirectory;
-    for (let u = 2; u <= parts.length; ++u) {
-      const subPath = parts.slice(0, u).join(this.pathUtils.sep);
-      if (!this.existsSync(subPath)) {
-        try {
-          await this.mkdirPromise(subPath);
-        } catch (error) {
-          if (error.code === `EEXIST`) {
-            continue;
-          } else {
-            throw error;
-          }
-        }
-        createdDirectory ??= subPath;
-        if (chmod != null)
-          await this.chmodPromise(subPath, chmod);
-        if (utimes != null) {
-          await this.utimesPromise(subPath, utimes[0], utimes[1]);
-        } else {
-          const parentStat = await this.statPromise(this.pathUtils.dirname(subPath));
-          await this.utimesPromise(subPath, parentStat.atime, parentStat.mtime);
-        }
-      }
-    }
-    return createdDirectory;
-  }
-  mkdirpSync(p, { chmod, utimes } = {}) {
-    p = this.resolve(p);
-    if (p === this.pathUtils.dirname(p))
-      return void 0;
-    const parts = p.split(this.pathUtils.sep);
-    let createdDirectory;
-    for (let u = 2; u <= parts.length; ++u) {
-      const subPath = parts.slice(0, u).join(this.pathUtils.sep);
-      if (!this.existsSync(subPath)) {
-        try {
-          this.mkdirSync(subPath);
-        } catch (error) {
-          if (error.code === `EEXIST`) {
-            continue;
-          } else {
-            throw error;
-          }
-        }
-        createdDirectory ??= subPath;
-        if (chmod != null)
-          this.chmodSync(subPath, chmod);
-        if (utimes != null) {
-          this.utimesSync(subPath, utimes[0], utimes[1]);
-        } else {
-          const parentStat = this.statSync(this.pathUtils.dirname(subPath));
-          this.utimesSync(subPath, parentStat.atime, parentStat.mtime);
-        }
-      }
-    }
-    return createdDirectory;
-  }
-  async copyPromise(destination, source, { baseFs = this, overwrite = true, stableSort = false, stableTime = false, linkStrategy = null } = {}) {
-    return await copyPromise(this, destination, baseFs, source, { overwrite, stableSort, stableTime, linkStrategy });
-  }
-  copySync(destination, source, { baseFs = this, overwrite = true } = {}) {
-    const stat = baseFs.lstatSync(source);
-    const exists = this.existsSync(destination);
-    if (stat.isDirectory()) {
-      this.mkdirpSync(destination);
-      const directoryListing = baseFs.readdirSync(source);
-      for (const entry of directoryListing) {
-        this.copySync(this.pathUtils.join(destination, entry), baseFs.pathUtils.join(source, entry), { baseFs, overwrite });
-      }
-    } else if (stat.isFile()) {
-      if (!exists || overwrite) {
-        if (exists)
-          this.removeSync(destination);
-        const content = baseFs.readFileSync(source);
-        this.writeFileSync(destination, content);
-      }
-    } else if (stat.isSymbolicLink()) {
-      if (!exists || overwrite) {
-        if (exists)
-          this.removeSync(destination);
-        const target = baseFs.readlinkSync(source);
-        this.symlinkSync(convertPath(this.pathUtils, target), destination);
-      }
-    } else {
-      throw new Error(`Unsupported file type (file: ${source}, mode: 0o${stat.mode.toString(8).padStart(6, `0`)})`);
-    }
-    const mode = stat.mode & 511;
-    this.chmodSync(destination, mode);
-  }
-  async changeFilePromise(p, content, opts = {}) {
-    if (Buffer.isBuffer(content)) {
-      return this.changeFileBufferPromise(p, content, opts);
-    } else {
-      return this.changeFileTextPromise(p, content, opts);
-    }
-  }
-  async changeFileBufferPromise(p, content, { mode } = {}) {
-    let current = Buffer.alloc(0);
-    try {
-      current = await this.readFilePromise(p);
-    } catch {
-    }
-    if (Buffer.compare(current, content) === 0)
-      return;
-    await this.writeFilePromise(p, content, { mode });
-  }
-  async changeFileTextPromise(p, content, { automaticNewlines, mode } = {}) {
-    let current = ``;
-    try {
-      current = await this.readFilePromise(p, `utf8`);
-    } catch {
-    }
-    const normalizedContent = automaticNewlines ? normalizeLineEndings(current, content) : content;
-    if (current === normalizedContent)
-      return;
-    await this.writeFilePromise(p, normalizedContent, { mode });
-  }
-  changeFileSync(p, content, opts = {}) {
-    if (Buffer.isBuffer(content)) {
-      return this.changeFileBufferSync(p, content, opts);
-    } else {
-      return this.changeFileTextSync(p, content, opts);
-    }
-  }
-  changeFileBufferSync(p, content, { mode } = {}) {
-    let current = Buffer.alloc(0);
-    try {
-      current = this.readFileSync(p);
-    } catch {
-    }
-    if (Buffer.compare(current, content) === 0)
-      return;
-    this.writeFileSync(p, content, { mode });
-  }
-  changeFileTextSync(p, content, { automaticNewlines = false, mode } = {}) {
-    let current = ``;
-    try {
-      current = this.readFileSync(p, `utf8`);
-    } catch {
-    }
-    const normalizedContent = automaticNewlines ? normalizeLineEndings(current, content) : content;
-    if (current === normalizedContent)
-      return;
-    this.writeFileSync(p, normalizedContent, { mode });
-  }
-  async movePromise(fromP, toP) {
-    try {
-      await this.renamePromise(fromP, toP);
-    } catch (error) {
-      if (error.code === `EXDEV`) {
-        await this.copyPromise(toP, fromP);
-        await this.removePromise(fromP);
-      } else {
-        throw error;
-      }
-    }
-  }
-  moveSync(fromP, toP) {
-    try {
-      this.renameSync(fromP, toP);
-    } catch (error) {
-      if (error.code === `EXDEV`) {
-        this.copySync(toP, fromP);
-        this.removeSync(fromP);
-      } else {
-        throw error;
-      }
-    }
-  }
-  async lockPromise(affectedPath, callback) {
-    const lockPath = `${affectedPath}.flock`;
-    const interval = 1e3 / 60;
-    const startTime = Date.now();
-    let fd = null;
-    const isAlive = async () => {
-      let pid;
-      try {
-        [pid] = await this.readJsonPromise(lockPath);
-      } catch {
-        return Date.now() - startTime < 500;
-      }
-      try {
-        process.kill(pid, 0);
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    while (fd === null) {
-      try {
-        fd = await this.openPromise(lockPath, `wx`);
-      } catch (error) {
-        if (error.code === `EEXIST`) {
-          if (!await isAlive()) {
-            try {
-              await this.unlinkPromise(lockPath);
-              continue;
-            } catch {
-            }
-          }
-          if (Date.now() - startTime < 60 * 1e3) {
-            await new Promise((resolve) => setTimeout(resolve, interval));
-          } else {
-            throw new Error(`Couldn't acquire a lock in a reasonable time (via ${lockPath})`);
-          }
-        } else {
-          throw error;
-        }
-      }
-    }
-    await this.writePromise(fd, JSON.stringify([process.pid]));
-    try {
-      return await callback();
-    } finally {
-      try {
-        await this.closePromise(fd);
-        await this.unlinkPromise(lockPath);
-      } catch {
-      }
-    }
-  }
-  async readJsonPromise(p) {
-    const content = await this.readFilePromise(p, `utf8`);
-    try {
-      return JSON.parse(content);
-    } catch (error) {
-      error.message += ` (in ${p})`;
-      throw error;
-    }
-  }
-  readJsonSync(p) {
-    const content = this.readFileSync(p, `utf8`);
-    try {
-      return JSON.parse(content);
-    } catch (error) {
-      error.message += ` (in ${p})`;
-      throw error;
-    }
-  }
-  async writeJsonPromise(p, data, { compact = false } = {}) {
-    const space = compact ? 0 : 2;
-    return await this.writeFilePromise(p, `${JSON.stringify(data, null, space)}
-`);
-  }
-  writeJsonSync(p, data, { compact = false } = {}) {
-    const space = compact ? 0 : 2;
-    return this.writeFileSync(p, `${JSON.stringify(data, null, space)}
-`);
-  }
-  async preserveTimePromise(p, cb) {
-    const stat = await this.lstatPromise(p);
-    const result = await cb();
-    if (typeof result !== `undefined`)
-      p = result;
-    await this.lutimesPromise(p, stat.atime, stat.mtime);
-  }
-  async preserveTimeSync(p, cb) {
-    const stat = this.lstatSync(p);
-    const result = cb();
-    if (typeof result !== `undefined`)
-      p = result;
-    this.lutimesSync(p, stat.atime, stat.mtime);
-  }
-}
-class BasePortableFakeFS extends FakeFS {
-  constructor() {
-    super(ppath);
-  }
-}
-function getEndOfLine(content) {
-  const matches = content.match(/\r?\n/g);
-  if (matches === null)
-    return EOL;
-  const crlf = matches.filter((nl) => nl === `\r
-`).length;
-  const lf = matches.length - crlf;
-  return crlf > lf ? `\r
-` : `
-`;
-}
-function normalizeLineEndings(originalContent, newContent) {
-  return newContent.replace(/\r?\n/g, getEndOfLine(originalContent));
-}
-
-class ProxiedFS extends FakeFS {
-  getExtractHint(hints) {
-    return this.baseFs.getExtractHint(hints);
-  }
-  resolve(path) {
-    return this.mapFromBase(this.baseFs.resolve(this.mapToBase(path)));
-  }
-  getRealPath() {
-    return this.mapFromBase(this.baseFs.getRealPath());
-  }
-  async openPromise(p, flags, mode) {
-    return this.baseFs.openPromise(this.mapToBase(p), flags, mode);
-  }
-  openSync(p, flags, mode) {
-    return this.baseFs.openSync(this.mapToBase(p), flags, mode);
-  }
-  async opendirPromise(p, opts) {
-    return Object.assign(await this.baseFs.opendirPromise(this.mapToBase(p), opts), { path: p });
-  }
-  opendirSync(p, opts) {
-    return Object.assign(this.baseFs.opendirSync(this.mapToBase(p), opts), { path: p });
-  }
-  async readPromise(fd, buffer, offset, length, position) {
-    return await this.baseFs.readPromise(fd, buffer, offset, length, position);
-  }
-  readSync(fd, buffer, offset, length, position) {
-    return this.baseFs.readSync(fd, buffer, offset, length, position);
-  }
-  async writePromise(fd, buffer, offset, length, position) {
-    if (typeof buffer === `string`) {
-      return await this.baseFs.writePromise(fd, buffer, offset);
-    } else {
-      return await this.baseFs.writePromise(fd, buffer, offset, length, position);
-    }
-  }
-  writeSync(fd, buffer, offset, length, position) {
-    if (typeof buffer === `string`) {
-      return this.baseFs.writeSync(fd, buffer, offset);
-    } else {
-      return this.baseFs.writeSync(fd, buffer, offset, length, position);
-    }
-  }
-  async closePromise(fd) {
-    return this.baseFs.closePromise(fd);
-  }
-  closeSync(fd) {
-    this.baseFs.closeSync(fd);
-  }
-  createReadStream(p, opts) {
-    return this.baseFs.createReadStream(p !== null ? this.mapToBase(p) : p, opts);
-  }
-  createWriteStream(p, opts) {
-    return this.baseFs.createWriteStream(p !== null ? this.mapToBase(p) : p, opts);
-  }
-  async realpathPromise(p) {
-    return this.mapFromBase(await this.baseFs.realpathPromise(this.mapToBase(p)));
-  }
-  realpathSync(p) {
-    return this.mapFromBase(this.baseFs.realpathSync(this.mapToBase(p)));
-  }
-  async existsPromise(p) {
-    return this.baseFs.existsPromise(this.mapToBase(p));
-  }
-  existsSync(p) {
-    return this.baseFs.existsSync(this.mapToBase(p));
-  }
-  accessSync(p, mode) {
-    return this.baseFs.accessSync(this.mapToBase(p), mode);
-  }
-  async accessPromise(p, mode) {
-    return this.baseFs.accessPromise(this.mapToBase(p), mode);
-  }
-  async statPromise(p, opts) {
-    return this.baseFs.statPromise(this.mapToBase(p), opts);
-  }
-  statSync(p, opts) {
-    return this.baseFs.statSync(this.mapToBase(p), opts);
-  }
-  async fstatPromise(fd, opts) {
-    return this.baseFs.fstatPromise(fd, opts);
-  }
-  fstatSync(fd, opts) {
-    return this.baseFs.fstatSync(fd, opts);
-  }
-  lstatPromise(p, opts) {
-    return this.baseFs.lstatPromise(this.mapToBase(p), opts);
-  }
-  lstatSync(p, opts) {
-    return this.baseFs.lstatSync(this.mapToBase(p), opts);
-  }
-  async fchmodPromise(fd, mask) {
-    return this.baseFs.fchmodPromise(fd, mask);
-  }
-  fchmodSync(fd, mask) {
-    return this.baseFs.fchmodSync(fd, mask);
-  }
-  async chmodPromise(p, mask) {
-    return this.baseFs.chmodPromise(this.mapToBase(p), mask);
-  }
-  chmodSync(p, mask) {
-    return this.baseFs.chmodSync(this.mapToBase(p), mask);
-  }
-  async fchownPromise(fd, uid, gid) {
-    return this.baseFs.fchownPromise(fd, uid, gid);
-  }
-  fchownSync(fd, uid, gid) {
-    return this.baseFs.fchownSync(fd, uid, gid);
-  }
-  async chownPromise(p, uid, gid) {
-    return this.baseFs.chownPromise(this.mapToBase(p), uid, gid);
-  }
-  chownSync(p, uid, gid) {
-    return this.baseFs.chownSync(this.mapToBase(p), uid, gid);
-  }
-  async renamePromise(oldP, newP) {
-    return this.baseFs.renamePromise(this.mapToBase(oldP), this.mapToBase(newP));
-  }
-  renameSync(oldP, newP) {
-    return this.baseFs.renameSync(this.mapToBase(oldP), this.mapToBase(newP));
-  }
-  async copyFilePromise(sourceP, destP, flags = 0) {
-    return this.baseFs.copyFilePromise(this.mapToBase(sourceP), this.mapToBase(destP), flags);
-  }
-  copyFileSync(sourceP, destP, flags = 0) {
-    return this.baseFs.copyFileSync(this.mapToBase(sourceP), this.mapToBase(destP), flags);
-  }
-  async appendFilePromise(p, content, opts) {
-    return this.baseFs.appendFilePromise(this.fsMapToBase(p), content, opts);
-  }
-  appendFileSync(p, content, opts) {
-    return this.baseFs.appendFileSync(this.fsMapToBase(p), content, opts);
-  }
-  async writeFilePromise(p, content, opts) {
-    return this.baseFs.writeFilePromise(this.fsMapToBase(p), content, opts);
-  }
-  writeFileSync(p, content, opts) {
-    return this.baseFs.writeFileSync(this.fsMapToBase(p), content, opts);
-  }
-  async unlinkPromise(p) {
-    return this.baseFs.unlinkPromise(this.mapToBase(p));
-  }
-  unlinkSync(p) {
-    return this.baseFs.unlinkSync(this.mapToBase(p));
-  }
-  async utimesPromise(p, atime, mtime) {
-    return this.baseFs.utimesPromise(this.mapToBase(p), atime, mtime);
-  }
-  utimesSync(p, atime, mtime) {
-    return this.baseFs.utimesSync(this.mapToBase(p), atime, mtime);
-  }
-  async lutimesPromise(p, atime, mtime) {
-    return this.baseFs.lutimesPromise(this.mapToBase(p), atime, mtime);
-  }
-  lutimesSync(p, atime, mtime) {
-    return this.baseFs.lutimesSync(this.mapToBase(p), atime, mtime);
-  }
-  async mkdirPromise(p, opts) {
-    return this.baseFs.mkdirPromise(this.mapToBase(p), opts);
-  }
-  mkdirSync(p, opts) {
-    return this.baseFs.mkdirSync(this.mapToBase(p), opts);
-  }
-  async rmdirPromise(p, opts) {
-    return this.baseFs.rmdirPromise(this.mapToBase(p), opts);
-  }
-  rmdirSync(p, opts) {
-    return this.baseFs.rmdirSync(this.mapToBase(p), opts);
-  }
-  async rmPromise(p, opts) {
-    return this.baseFs.rmPromise(this.mapToBase(p), opts);
-  }
-  rmSync(p, opts) {
-    return this.baseFs.rmSync(this.mapToBase(p), opts);
-  }
-  async linkPromise(existingP, newP) {
-    return this.baseFs.linkPromise(this.mapToBase(existingP), this.mapToBase(newP));
-  }
-  linkSync(existingP, newP) {
-    return this.baseFs.linkSync(this.mapToBase(existingP), this.mapToBase(newP));
-  }
-  async symlinkPromise(target, p, type) {
-    const mappedP = this.mapToBase(p);
-    if (this.pathUtils.isAbsolute(target))
-      return this.baseFs.symlinkPromise(this.mapToBase(target), mappedP, type);
-    const mappedAbsoluteTarget = this.mapToBase(this.pathUtils.join(this.pathUtils.dirname(p), target));
-    const mappedTarget = this.baseFs.pathUtils.relative(this.baseFs.pathUtils.dirname(mappedP), mappedAbsoluteTarget);
-    return this.baseFs.symlinkPromise(mappedTarget, mappedP, type);
-  }
-  symlinkSync(target, p, type) {
-    const mappedP = this.mapToBase(p);
-    if (this.pathUtils.isAbsolute(target))
-      return this.baseFs.symlinkSync(this.mapToBase(target), mappedP, type);
-    const mappedAbsoluteTarget = this.mapToBase(this.pathUtils.join(this.pathUtils.dirname(p), target));
-    const mappedTarget = this.baseFs.pathUtils.relative(this.baseFs.pathUtils.dirname(mappedP), mappedAbsoluteTarget);
-    return this.baseFs.symlinkSync(mappedTarget, mappedP, type);
-  }
-  async readFilePromise(p, encoding) {
-    return this.baseFs.readFilePromise(this.fsMapToBase(p), encoding);
-  }
-  readFileSync(p, encoding) {
-    return this.baseFs.readFileSync(this.fsMapToBase(p), encoding);
-  }
-  readdirPromise(p, opts) {
-    return this.baseFs.readdirPromise(this.mapToBase(p), opts);
-  }
-  readdirSync(p, opts) {
-    return this.baseFs.readdirSync(this.mapToBase(p), opts);
-  }
-  async readlinkPromise(p) {
-    return this.mapFromBase(await this.baseFs.readlinkPromise(this.mapToBase(p)));
-  }
-  readlinkSync(p) {
-    return this.mapFromBase(this.baseFs.readlinkSync(this.mapToBase(p)));
-  }
-  async truncatePromise(p, len) {
-    return this.baseFs.truncatePromise(this.mapToBase(p), len);
-  }
-  truncateSync(p, len) {
-    return this.baseFs.truncateSync(this.mapToBase(p), len);
-  }
-  async ftruncatePromise(fd, len) {
-    return this.baseFs.ftruncatePromise(fd, len);
-  }
-  ftruncateSync(fd, len) {
-    return this.baseFs.ftruncateSync(fd, len);
-  }
-  watch(p, a, b) {
-    return this.baseFs.watch(
-      this.mapToBase(p),
-      // @ts-expect-error
-      a,
-      b
-    );
-  }
-  watchFile(p, a, b) {
-    return this.baseFs.watchFile(
-      this.mapToBase(p),
-      // @ts-expect-error
-      a,
-      b
-    );
-  }
-  unwatchFile(p, cb) {
-    return this.baseFs.unwatchFile(this.mapToBase(p), cb);
-  }
-  fsMapToBase(p) {
-    if (typeof p === `number`) {
-      return p;
-    } else {
-      return this.mapToBase(p);
-    }
-  }
-}
-
-function direntToPortable(dirent) {
-  const portableDirent = dirent;
-  if (typeof dirent.path === `string`)
-    portableDirent.path = npath.toPortablePath(dirent.path);
-  return portableDirent;
-}
-class NodeFS extends BasePortableFakeFS {
-  realFs;
-  constructor(realFs = fs) {
-    super();
-    this.realFs = realFs;
-  }
-  getExtractHint() {
-    return false;
-  }
-  getRealPath() {
-    return PortablePath.root;
-  }
-  resolve(p) {
-    return ppath.resolve(p);
-  }
-  async openPromise(p, flags, mode) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.open(npath.fromPortablePath(p), flags, mode, this.makeCallback(resolve, reject));
-    });
-  }
-  openSync(p, flags, mode) {
-    return this.realFs.openSync(npath.fromPortablePath(p), flags, mode);
-  }
-  async opendirPromise(p, opts) {
-    return await new Promise((resolve, reject) => {
-      if (typeof opts !== `undefined`) {
-        this.realFs.opendir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
-      } else {
-        this.realFs.opendir(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
-      }
-    }).then((dir) => {
-      const dirWithFixedPath = dir;
-      Object.defineProperty(dirWithFixedPath, `path`, {
-        value: p,
-        configurable: true,
-        writable: true
-      });
-      return dirWithFixedPath;
-    });
-  }
-  opendirSync(p, opts) {
-    const dir = typeof opts !== `undefined` ? this.realFs.opendirSync(npath.fromPortablePath(p), opts) : this.realFs.opendirSync(npath.fromPortablePath(p));
-    const dirWithFixedPath = dir;
-    Object.defineProperty(dirWithFixedPath, `path`, {
-      value: p,
-      configurable: true,
-      writable: true
-    });
-    return dirWithFixedPath;
-  }
-  async readPromise(fd, buffer, offset = 0, length = 0, position = -1) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.read(fd, buffer, offset, length, position, (error, bytesRead) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(bytesRead);
-        }
-      });
-    });
-  }
-  readSync(fd, buffer, offset, length, position) {
-    return this.realFs.readSync(fd, buffer, offset, length, position);
-  }
-  async writePromise(fd, buffer, offset, length, position) {
-    return await new Promise((resolve, reject) => {
-      if (typeof buffer === `string`) {
-        return this.realFs.write(fd, buffer, offset, this.makeCallback(resolve, reject));
-      } else {
-        return this.realFs.write(fd, buffer, offset, length, position, this.makeCallback(resolve, reject));
-      }
-    });
-  }
-  writeSync(fd, buffer, offset, length, position) {
-    if (typeof buffer === `string`) {
-      return this.realFs.writeSync(fd, buffer, offset);
-    } else {
-      return this.realFs.writeSync(fd, buffer, offset, length, position);
-    }
-  }
-  async closePromise(fd) {
-    await new Promise((resolve, reject) => {
-      this.realFs.close(fd, this.makeCallback(resolve, reject));
-    });
-  }
-  closeSync(fd) {
-    this.realFs.closeSync(fd);
-  }
-  createReadStream(p, opts) {
-    const realPath = p !== null ? npath.fromPortablePath(p) : p;
-    return this.realFs.createReadStream(realPath, opts);
-  }
-  createWriteStream(p, opts) {
-    const realPath = p !== null ? npath.fromPortablePath(p) : p;
-    return this.realFs.createWriteStream(realPath, opts);
-  }
-  async realpathPromise(p) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.realpath(npath.fromPortablePath(p), {}, this.makeCallback(resolve, reject));
-    }).then((path) => {
-      return npath.toPortablePath(path);
-    });
-  }
-  realpathSync(p) {
-    return npath.toPortablePath(this.realFs.realpathSync(npath.fromPortablePath(p), {}));
-  }
-  async existsPromise(p) {
-    return await new Promise((resolve) => {
-      this.realFs.exists(npath.fromPortablePath(p), resolve);
-    });
-  }
-  accessSync(p, mode) {
-    return this.realFs.accessSync(npath.fromPortablePath(p), mode);
-  }
-  async accessPromise(p, mode) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.access(npath.fromPortablePath(p), mode, this.makeCallback(resolve, reject));
-    });
-  }
-  existsSync(p) {
-    return this.realFs.existsSync(npath.fromPortablePath(p));
-  }
-  async statPromise(p, opts) {
-    return await new Promise((resolve, reject) => {
-      if (opts) {
-        this.realFs.stat(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
-      } else {
-        this.realFs.stat(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
-      }
-    });
-  }
-  statSync(p, opts) {
-    if (opts) {
-      return this.realFs.statSync(npath.fromPortablePath(p), opts);
-    } else {
-      return this.realFs.statSync(npath.fromPortablePath(p));
-    }
-  }
-  async fstatPromise(fd, opts) {
-    return await new Promise((resolve, reject) => {
-      if (opts) {
-        this.realFs.fstat(fd, opts, this.makeCallback(resolve, reject));
-      } else {
-        this.realFs.fstat(fd, this.makeCallback(resolve, reject));
-      }
-    });
-  }
-  fstatSync(fd, opts) {
-    if (opts) {
-      return this.realFs.fstatSync(fd, opts);
-    } else {
-      return this.realFs.fstatSync(fd);
-    }
-  }
-  async lstatPromise(p, opts) {
-    return await new Promise((resolve, reject) => {
-      if (opts) {
-        this.realFs.lstat(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
-      } else {
-        this.realFs.lstat(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
-      }
-    });
-  }
-  lstatSync(p, opts) {
-    if (opts) {
-      return this.realFs.lstatSync(npath.fromPortablePath(p), opts);
-    } else {
-      return this.realFs.lstatSync(npath.fromPortablePath(p));
-    }
-  }
-  async fchmodPromise(fd, mask) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.fchmod(fd, mask, this.makeCallback(resolve, reject));
-    });
-  }
-  fchmodSync(fd, mask) {
-    return this.realFs.fchmodSync(fd, mask);
-  }
-  async chmodPromise(p, mask) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.chmod(npath.fromPortablePath(p), mask, this.makeCallback(resolve, reject));
-    });
-  }
-  chmodSync(p, mask) {
-    return this.realFs.chmodSync(npath.fromPortablePath(p), mask);
-  }
-  async fchownPromise(fd, uid, gid) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.fchown(fd, uid, gid, this.makeCallback(resolve, reject));
-    });
-  }
-  fchownSync(fd, uid, gid) {
-    return this.realFs.fchownSync(fd, uid, gid);
-  }
-  async chownPromise(p, uid, gid) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.chown(npath.fromPortablePath(p), uid, gid, this.makeCallback(resolve, reject));
-    });
-  }
-  chownSync(p, uid, gid) {
-    return this.realFs.chownSync(npath.fromPortablePath(p), uid, gid);
-  }
-  async renamePromise(oldP, newP) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.rename(npath.fromPortablePath(oldP), npath.fromPortablePath(newP), this.makeCallback(resolve, reject));
-    });
-  }
-  renameSync(oldP, newP) {
-    return this.realFs.renameSync(npath.fromPortablePath(oldP), npath.fromPortablePath(newP));
-  }
-  async copyFilePromise(sourceP, destP, flags = 0) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.copyFile(npath.fromPortablePath(sourceP), npath.fromPortablePath(destP), flags, this.makeCallback(resolve, reject));
-    });
-  }
-  copyFileSync(sourceP, destP, flags = 0) {
-    return this.realFs.copyFileSync(npath.fromPortablePath(sourceP), npath.fromPortablePath(destP), flags);
-  }
-  async appendFilePromise(p, content, opts) {
-    return await new Promise((resolve, reject) => {
-      const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
-      if (opts) {
-        this.realFs.appendFile(fsNativePath, content, opts, this.makeCallback(resolve, reject));
-      } else {
-        this.realFs.appendFile(fsNativePath, content, this.makeCallback(resolve, reject));
-      }
-    });
-  }
-  appendFileSync(p, content, opts) {
-    const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
-    if (opts) {
-      this.realFs.appendFileSync(fsNativePath, content, opts);
-    } else {
-      this.realFs.appendFileSync(fsNativePath, content);
-    }
-  }
-  async writeFilePromise(p, content, opts) {
-    return await new Promise((resolve, reject) => {
-      const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
-      if (opts) {
-        this.realFs.writeFile(fsNativePath, content, opts, this.makeCallback(resolve, reject));
-      } else {
-        this.realFs.writeFile(fsNativePath, content, this.makeCallback(resolve, reject));
-      }
-    });
-  }
-  writeFileSync(p, content, opts) {
-    const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
-    if (opts) {
-      this.realFs.writeFileSync(fsNativePath, content, opts);
-    } else {
-      this.realFs.writeFileSync(fsNativePath, content);
-    }
-  }
-  async unlinkPromise(p) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.unlink(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
-    });
-  }
-  unlinkSync(p) {
-    return this.realFs.unlinkSync(npath.fromPortablePath(p));
-  }
-  async utimesPromise(p, atime, mtime) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.utimes(npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve, reject));
-    });
-  }
-  utimesSync(p, atime, mtime) {
-    this.realFs.utimesSync(npath.fromPortablePath(p), atime, mtime);
-  }
-  async lutimesPromise(p, atime, mtime) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.lutimes(npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve, reject));
-    });
-  }
-  lutimesSync(p, atime, mtime) {
-    this.realFs.lutimesSync(npath.fromPortablePath(p), atime, mtime);
-  }
-  async mkdirPromise(p, opts) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.mkdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
-    });
-  }
-  mkdirSync(p, opts) {
-    return this.realFs.mkdirSync(npath.fromPortablePath(p), opts);
-  }
-  async rmdirPromise(p, opts) {
-    return await new Promise((resolve, reject) => {
-      if (opts) {
-        this.realFs.rmdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
-      } else {
-        this.realFs.rmdir(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
-      }
-    });
-  }
-  rmdirSync(p, opts) {
-    return this.realFs.rmdirSync(npath.fromPortablePath(p), opts);
-  }
-  async rmPromise(p, opts) {
-    return await new Promise((resolve, reject) => {
-      if (opts) {
-        this.realFs.rm(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
-      } else {
-        this.realFs.rm(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
-      }
-    });
-  }
-  rmSync(p, opts) {
-    return this.realFs.rmSync(npath.fromPortablePath(p), opts);
-  }
-  async linkPromise(existingP, newP) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.link(npath.fromPortablePath(existingP), npath.fromPortablePath(newP), this.makeCallback(resolve, reject));
-    });
-  }
-  linkSync(existingP, newP) {
-    return this.realFs.linkSync(npath.fromPortablePath(existingP), npath.fromPortablePath(newP));
-  }
-  async symlinkPromise(target, p, type) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.symlink(npath.fromPortablePath(target.replace(/\/+$/, ``)), npath.fromPortablePath(p), type, this.makeCallback(resolve, reject));
-    });
-  }
-  symlinkSync(target, p, type) {
-    return this.realFs.symlinkSync(npath.fromPortablePath(target.replace(/\/+$/, ``)), npath.fromPortablePath(p), type);
-  }
-  async readFilePromise(p, encoding) {
-    return await new Promise((resolve, reject) => {
-      const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
-      this.realFs.readFile(fsNativePath, encoding, this.makeCallback(resolve, reject));
-    });
-  }
-  readFileSync(p, encoding) {
-    const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
-    return this.realFs.readFileSync(fsNativePath, encoding);
-  }
-  async readdirPromise(p, opts) {
-    return await new Promise((resolve, reject) => {
-      if (opts) {
-        if (opts.recursive && process.platform === `win32`) {
-          if (opts.withFileTypes) {
-            this.realFs.readdir(npath.fromPortablePath(p), opts, this.makeCallback((results) => resolve(results.map(direntToPortable)), reject));
-          } else {
-            this.realFs.readdir(npath.fromPortablePath(p), opts, this.makeCallback((results) => resolve(results.map(npath.toPortablePath)), reject));
-          }
-        } else {
-          this.realFs.readdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
-        }
-      } else {
-        this.realFs.readdir(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
-      }
-    });
-  }
-  readdirSync(p, opts) {
-    if (opts) {
-      if (opts.recursive && process.platform === `win32`) {
-        if (opts.withFileTypes) {
-          return this.realFs.readdirSync(npath.fromPortablePath(p), opts).map(direntToPortable);
-        } else {
-          return this.realFs.readdirSync(npath.fromPortablePath(p), opts).map(npath.toPortablePath);
-        }
-      } else {
-        return this.realFs.readdirSync(npath.fromPortablePath(p), opts);
-      }
-    } else {
-      return this.realFs.readdirSync(npath.fromPortablePath(p));
-    }
-  }
-  async readlinkPromise(p) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.readlink(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
-    }).then((path) => {
-      return npath.toPortablePath(path);
-    });
-  }
-  readlinkSync(p) {
-    return npath.toPortablePath(this.realFs.readlinkSync(npath.fromPortablePath(p)));
-  }
-  async truncatePromise(p, len) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.truncate(npath.fromPortablePath(p), len, this.makeCallback(resolve, reject));
-    });
-  }
-  truncateSync(p, len) {
-    return this.realFs.truncateSync(npath.fromPortablePath(p), len);
-  }
-  async ftruncatePromise(fd, len) {
-    return await new Promise((resolve, reject) => {
-      this.realFs.ftruncate(fd, len, this.makeCallback(resolve, reject));
-    });
-  }
-  ftruncateSync(fd, len) {
-    return this.realFs.ftruncateSync(fd, len);
-  }
-  watch(p, a, b) {
-    return this.realFs.watch(
-      npath.fromPortablePath(p),
-      // @ts-expect-error
-      a,
-      b
-    );
-  }
-  watchFile(p, a, b) {
-    return this.realFs.watchFile(
-      npath.fromPortablePath(p),
-      // @ts-expect-error
-      a,
-      b
-    );
-  }
-  unwatchFile(p, cb) {
-    return this.realFs.unwatchFile(npath.fromPortablePath(p), cb);
-  }
-  makeCallback(resolve, reject) {
-    return (err, result) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(result);
-      }
-    };
-  }
-}
-
-const NUMBER_REGEXP = /^[0-9]+$/;
-const VIRTUAL_REGEXP = /^(\/(?:[^/]+\/)*?(?:\$\$virtual|__virtual__))((?:\/((?:[^/]+-)?[a-f0-9]+)(?:\/([^/]+))?)?((?:\/.*)?))$/;
-const VALID_COMPONENT = /^([^/]+-)?[a-f0-9]+$/;
-class VirtualFS extends ProxiedFS {
-  baseFs;
-  static makeVirtualPath(base, component, to) {
-    if (ppath.basename(base) !== `__virtual__`)
-      throw new Error(`Assertion failed: Virtual folders must be named "__virtual__"`);
-    if (!ppath.basename(component).match(VALID_COMPONENT))
-      throw new Error(`Assertion failed: Virtual components must be ended by an hexadecimal hash`);
-    const target = ppath.relative(ppath.dirname(base), to);
-    const segments = target.split(`/`);
-    let depth = 0;
-    while (depth < segments.length && segments[depth] === `..`)
-      depth += 1;
-    const finalSegments = segments.slice(depth);
-    const fullVirtualPath = ppath.join(base, component, String(depth), ...finalSegments);
-    return fullVirtualPath;
-  }
-  static resolveVirtual(p) {
-    const match = p.match(VIRTUAL_REGEXP);
-    if (!match || !match[3] && match[5])
-      return p;
-    const target = ppath.dirname(match[1]);
-    if (!match[3] || !match[4])
-      return target;
-    const isnum = NUMBER_REGEXP.test(match[4]);
-    if (!isnum)
-      return p;
-    const depth = Number(match[4]);
-    const backstep = `../`.repeat(depth);
-    const subpath = match[5] || `.`;
-    return VirtualFS.resolveVirtual(ppath.join(target, backstep, subpath));
-  }
-  constructor({ baseFs = new NodeFS() } = {}) {
-    super(ppath);
-    this.baseFs = baseFs;
-  }
-  getExtractHint(hints) {
-    return this.baseFs.getExtractHint(hints);
-  }
-  getRealPath() {
-    return this.baseFs.getRealPath();
-  }
-  realpathSync(p) {
-    const match = p.match(VIRTUAL_REGEXP);
-    if (!match)
-      return this.baseFs.realpathSync(p);
-    if (!match[5])
-      return p;
-    const realpath = this.baseFs.realpathSync(this.mapToBase(p));
-    return VirtualFS.makeVirtualPath(match[1], match[3], realpath);
-  }
-  async realpathPromise(p) {
-    const match = p.match(VIRTUAL_REGEXP);
-    if (!match)
-      return await this.baseFs.realpathPromise(p);
-    if (!match[5])
-      return p;
-    const realpath = await this.baseFs.realpathPromise(this.mapToBase(p));
-    return VirtualFS.makeVirtualPath(match[1], match[3], realpath);
-  }
-  mapToBase(p) {
-    if (p === ``)
-      return p;
-    if (this.pathUtils.isAbsolute(p))
-      return VirtualFS.resolveVirtual(p);
-    const resolvedRoot = VirtualFS.resolveVirtual(this.baseFs.resolve(PortablePath.dot));
-    const resolvedP = VirtualFS.resolveVirtual(this.baseFs.resolve(p));
-    return ppath.relative(resolvedRoot, resolvedP) || PortablePath.dot;
-  }
-  mapFromBase(p) {
-    return p;
-  }
-}
-
-const URL = Number(process.versions.node.split('.', 1)[0]) < 20 ? URL$1 : globalThis.URL;
-
-const [major, minor] = process.versions.node.split(`.`).map((value) => parseInt(value, 10));
-const WATCH_MODE_MESSAGE_USES_ARRAYS = major > 19 || major === 19 && minor >= 2 || major === 18 && minor >= 13;
-const HAS_LAZY_LOADED_TRANSLATORS = major === 20 && minor < 6 || major === 19 && minor >= 3;
-const SUPPORTS_IMPORT_ATTRIBUTES = major >= 21 || major === 20 && minor >= 10 || major === 18 && minor >= 20;
-const SUPPORTS_IMPORT_ATTRIBUTES_ONLY = major >= 22;
-
-function readPackageScope(checkPath) {
-  const rootSeparatorIndex = checkPath.indexOf(npath.sep);
-  let separatorIndex;
-  do {
-    separatorIndex = checkPath.lastIndexOf(npath.sep);
-    checkPath = checkPath.slice(0, separatorIndex);
-    if (checkPath.endsWith(`${npath.sep}node_modules`))
-      return false;
-    const pjson = readPackage(checkPath + npath.sep);
-    if (pjson) {
-      return {
-        data: pjson,
-        path: checkPath
-      };
-    }
-  } while (separatorIndex > rootSeparatorIndex);
-  return false;
-}
-function readPackage(requestPath) {
-  const jsonPath = npath.resolve(requestPath, `package.json`);
-  if (!fs.existsSync(jsonPath))
-    return null;
-  return JSON.parse(fs.readFileSync(jsonPath, `utf8`));
-}
-
-async function tryReadFile$1(path2) {
-  try {
-    return await fs.promises.readFile(path2, `utf8`);
-  } catch (error) {
-    if (error.code === `ENOENT`)
-      return null;
-    throw error;
-  }
-}
-function tryParseURL(str, base) {
-  try {
-    return new URL(str, base);
-  } catch {
-    return null;
-  }
-}
-let entrypointPath = null;
-function setEntrypointPath(file) {
-  entrypointPath = file;
-}
-function getFileFormat(filepath) {
-  const ext = path.extname(filepath);
-  switch (ext) {
-    case `.mjs`: {
-      return `module`;
-    }
-    case `.cjs`: {
-      return `commonjs`;
-    }
-    case `.wasm`: {
-      throw new Error(
-        `Unknown file extension ".wasm" for ${filepath}`
-      );
-    }
-    case `.json`: {
-      return `json`;
-    }
-    case `.js`: {
-      const pkg = readPackageScope(filepath);
-      if (!pkg)
-        return `commonjs`;
-      return pkg.data.type ?? `commonjs`;
-    }
-    default: {
-      if (entrypointPath !== filepath)
-        return null;
-      const pkg = readPackageScope(filepath);
-      if (!pkg)
-        return `commonjs`;
-      if (pkg.data.type === `module`)
-        return null;
-      return pkg.data.type ?? `commonjs`;
-    }
-  }
-}
-
-async function load$1(urlString, context, nextLoad) {
-  const url = tryParseURL(urlString);
-  if (url?.protocol !== `file:`)
-    return nextLoad(urlString, context, nextLoad);
-  const filePath = fileURLToPath(url);
-  const format = getFileFormat(filePath);
-  if (!format)
-    return nextLoad(urlString, context, nextLoad);
-  if (format === `json`) {
-    if (SUPPORTS_IMPORT_ATTRIBUTES_ONLY) {
-      if (context.importAttributes?.type !== `json`) {
-        const err = new TypeError(`[ERR_IMPORT_ATTRIBUTE_MISSING]: Module "${urlString}" needs an import attribute of "type: json"`);
-        err.code = `ERR_IMPORT_ATTRIBUTE_MISSING`;
-        throw err;
-      }
-    } else {
-      const type = `importAttributes` in context ? context.importAttributes?.type : context.importAssertions?.type;
-      if (type !== `json`) {
-        const err = new TypeError(`[ERR_IMPORT_ASSERTION_TYPE_MISSING]: Module "${urlString}" needs an import ${SUPPORTS_IMPORT_ATTRIBUTES ? `attribute` : `assertion`} of type "json"`);
-        err.code = `ERR_IMPORT_ASSERTION_TYPE_MISSING`;
-        throw err;
-      }
-    }
-  }
-  if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {
-    const pathToSend = pathToFileURL(
-      npath.fromPortablePath(
-        VirtualFS.resolveVirtual(npath.toPortablePath(filePath))
-      )
-    ).href;
-    process.send({
-      "watch:import": WATCH_MODE_MESSAGE_USES_ARRAYS ? [pathToSend] : pathToSend
-    });
-  }
-  return {
-    format,
-    source: format === `commonjs` ? void 0 : await fs.promises.readFile(filePath, `utf8`),
-    shortCircuit: true
-  };
-}
-
-const ArrayIsArray = Array.isArray;
-const JSONStringify = JSON.stringify;
-const ObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
-const ObjectPrototypeHasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
-const RegExpPrototypeExec = (obj, string) => RegExp.prototype.exec.call(obj, string);
-const RegExpPrototypeSymbolReplace = (obj, ...rest) => RegExp.prototype[Symbol.replace].apply(obj, rest);
-const StringPrototypeEndsWith = (str, ...rest) => String.prototype.endsWith.apply(str, rest);
-const StringPrototypeIncludes = (str, ...rest) => String.prototype.includes.apply(str, rest);
-const StringPrototypeLastIndexOf = (str, ...rest) => String.prototype.lastIndexOf.apply(str, rest);
-const StringPrototypeIndexOf = (str, ...rest) => String.prototype.indexOf.apply(str, rest);
-const StringPrototypeReplace = (str, ...rest) => String.prototype.replace.apply(str, rest);
-const StringPrototypeSlice = (str, ...rest) => String.prototype.slice.apply(str, rest);
-const StringPrototypeStartsWith = (str, ...rest) => String.prototype.startsWith.apply(str, rest);
-const SafeMap = Map;
-const JSONParse = JSON.parse;
-
-function createErrorType(code, messageCreator, errorType) {
-  return class extends errorType {
-    constructor(...args) {
-      super(messageCreator(...args));
-      this.code = code;
-      this.name = `${errorType.name} [${code}]`;
-    }
-  };
-}
-const ERR_PACKAGE_IMPORT_NOT_DEFINED = createErrorType(
-  `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
-);
-const ERR_INVALID_MODULE_SPECIFIER = createErrorType(
-  `ERR_INVALID_MODULE_SPECIFIER`,
-  (request, reason, base = void 0) => {
-    return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ``}`;
-  },
-  TypeError
-);
-const ERR_INVALID_PACKAGE_TARGET = createErrorType(
-  `ERR_INVALID_PACKAGE_TARGET`,
-  (pkgPath, key, target, isImport = false, base = void 0) => {
-    const relError = typeof target === `string` && !isImport && target.length && !StringPrototypeStartsWith(target, `./`);
-    if (key === `.`) {
-      assert(isImport === false);
-      return `Invalid "exports" main target ${JSONStringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ``}${relError ? `; targets must start with "./"` : ``}`;
-    }
-    return `Invalid "${isImport ? `imports` : `exports`}" target ${JSONStringify(
-      target
-    )} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ``}${relError ? `; targets must start with "./"` : ``}`;
-  },
-  Error
-);
-const ERR_INVALID_PACKAGE_CONFIG = createErrorType(
-  `ERR_INVALID_PACKAGE_CONFIG`,
-  (path, base, message) => {
-    return `Invalid package config ${path}${base ? ` while importing ${base}` : ``}${message ? `. ${message}` : ``}`;
-  },
-  Error
-);
-
-function filterOwnProperties(source, keys) {
-  const filtered = /* @__PURE__ */ Object.create(null);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    if (ObjectPrototypeHasOwnProperty(source, key)) {
-      filtered[key] = source[key];
-    }
-  }
-  return filtered;
-}
-
-const packageJSONCache = new SafeMap();
-function getPackageConfig(path, specifier, base, readFileSyncFn) {
-  const existing = packageJSONCache.get(path);
-  if (existing !== void 0) {
-    return existing;
-  }
-  const source = readFileSyncFn(path);
-  if (source === void 0) {
-    const packageConfig2 = {
-      pjsonPath: path,
-      exists: false,
-      main: void 0,
-      name: void 0,
-      type: "none",
-      exports: void 0,
-      imports: void 0
-    };
-    packageJSONCache.set(path, packageConfig2);
-    return packageConfig2;
-  }
-  let packageJSON;
-  try {
-    packageJSON = JSONParse(source);
-  } catch (error) {
-    throw new ERR_INVALID_PACKAGE_CONFIG(
-      path,
-      (base ? `"${specifier}" from ` : "") + fileURLToPath(base || specifier),
-      error.message
-    );
-  }
-  let { imports, main, name, type } = filterOwnProperties(packageJSON, [
-    "imports",
-    "main",
-    "name",
-    "type"
-  ]);
-  const exports = ObjectPrototypeHasOwnProperty(packageJSON, "exports") ? packageJSON.exports : void 0;
-  if (typeof imports !== "object" || imports === null) {
-    imports = void 0;
-  }
-  if (typeof main !== "string") {
-    main = void 0;
-  }
-  if (typeof name !== "string") {
-    name = void 0;
-  }
-  if (type !== "module" && type !== "commonjs") {
-    type = "none";
-  }
-  const packageConfig = {
-    pjsonPath: path,
-    exists: true,
-    main,
-    name,
-    type,
-    exports,
-    imports
-  };
-  packageJSONCache.set(path, packageConfig);
-  return packageConfig;
-}
-function getPackageScopeConfig(resolved, readFileSyncFn) {
-  let packageJSONUrl = new URL("./package.json", resolved);
-  while (true) {
-    const packageJSONPath2 = packageJSONUrl.pathname;
-    if (StringPrototypeEndsWith(packageJSONPath2, "node_modules/package.json")) {
-      break;
-    }
-    const packageConfig2 = getPackageConfig(
-      fileURLToPath(packageJSONUrl),
-      resolved,
-      void 0,
-      readFileSyncFn
-    );
-    if (packageConfig2.exists) {
-      return packageConfig2;
-    }
-    const lastPackageJSONUrl = packageJSONUrl;
-    packageJSONUrl = new URL("../package.json", packageJSONUrl);
-    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
-      break;
-    }
-  }
-  const packageJSONPath = fileURLToPath(packageJSONUrl);
-  const packageConfig = {
-    pjsonPath: packageJSONPath,
-    exists: false,
-    main: void 0,
-    name: void 0,
-    type: "none",
-    exports: void 0,
-    imports: void 0
-  };
-  packageJSONCache.set(packageJSONPath, packageConfig);
-  return packageConfig;
-}
-
-function throwImportNotDefined(specifier, packageJSONUrl, base) {
-  throw new ERR_PACKAGE_IMPORT_NOT_DEFINED(
-    specifier,
-    packageJSONUrl && fileURLToPath(new URL(".", packageJSONUrl)),
-    fileURLToPath(base)
-  );
-}
-function throwInvalidSubpath(subpath, packageJSONUrl, internal, base) {
-  const reason = `request is not a valid subpath for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath(packageJSONUrl)}`;
-  throw new ERR_INVALID_MODULE_SPECIFIER(
-    subpath,
-    reason,
-    base && fileURLToPath(base)
-  );
-}
-function throwInvalidPackageTarget(subpath, target, packageJSONUrl, internal, base) {
-  if (typeof target === "object" && target !== null) {
-    target = JSONStringify(target, null, "");
-  } else {
-    target = `${target}`;
-  }
-  throw new ERR_INVALID_PACKAGE_TARGET(
-    fileURLToPath(new URL(".", packageJSONUrl)),
-    subpath,
-    target,
-    internal,
-    base && fileURLToPath(base)
-  );
-}
-const 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;
-const patternRegEx = /\*/g;
-function resolvePackageTargetString(target, subpath, match, packageJSONUrl, base, pattern, internal, conditions) {
-  if (subpath !== "" && !pattern && target[target.length - 1] !== "/")
-    throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
-  if (!StringPrototypeStartsWith(target, "./")) {
-    if (internal && !StringPrototypeStartsWith(target, "../") && !StringPrototypeStartsWith(target, "/")) {
-      let isURL = false;
-      try {
-        new URL(target);
-        isURL = true;
-      } catch {
-      }
-      if (!isURL) {
-        const exportTarget = pattern ? RegExpPrototypeSymbolReplace(patternRegEx, target, () => subpath) : target + subpath;
-        return exportTarget;
-      }
-    }
-    throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
-  }
-  if (RegExpPrototypeExec(
-    invalidSegmentRegEx,
-    StringPrototypeSlice(target, 2)
-  ) !== null)
-    throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
-  const resolved = new URL(target, packageJSONUrl);
-  const resolvedPath = resolved.pathname;
-  const packagePath = new URL(".", packageJSONUrl).pathname;
-  if (!StringPrototypeStartsWith(resolvedPath, packagePath))
-    throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
-  if (subpath === "") return resolved;
-  if (RegExpPrototypeExec(invalidSegmentRegEx, subpath) !== null) {
-    const request = pattern ? StringPrototypeReplace(match, "*", () => subpath) : match + subpath;
-    throwInvalidSubpath(request, packageJSONUrl, internal, base);
-  }
-  if (pattern) {
-    return new URL(
-      RegExpPrototypeSymbolReplace(patternRegEx, resolved.href, () => subpath)
-    );
-  }
-  return new URL(subpath, resolved);
-}
-function isArrayIndex(key) {
-  const keyNum = +key;
-  if (`${keyNum}` !== key) return false;
-  return keyNum >= 0 && keyNum < 4294967295;
-}
-function resolvePackageTarget(packageJSONUrl, target, subpath, packageSubpath, base, pattern, internal, conditions) {
-  if (typeof target === "string") {
-    return resolvePackageTargetString(
-      target,
-      subpath,
-      packageSubpath,
-      packageJSONUrl,
-      base,
-      pattern,
-      internal);
-  } else if (ArrayIsArray(target)) {
-    if (target.length === 0) {
-      return null;
-    }
-    let lastException;
-    for (let i = 0; i < target.length; i++) {
-      const targetItem = target[i];
-      let resolveResult;
-      try {
-        resolveResult = resolvePackageTarget(
-          packageJSONUrl,
-          targetItem,
-          subpath,
-          packageSubpath,
-          base,
-          pattern,
-          internal,
-          conditions
-        );
-      } catch (e) {
-        lastException = e;
-        if (e.code === "ERR_INVALID_PACKAGE_TARGET") {
-          continue;
-        }
-        throw e;
-      }
-      if (resolveResult === void 0) {
-        continue;
-      }
-      if (resolveResult === null) {
-        lastException = null;
-        continue;
-      }
-      return resolveResult;
-    }
-    if (lastException === void 0 || lastException === null)
-      return lastException;
-    throw lastException;
-  } else if (typeof target === "object" && target !== null) {
-    const keys = ObjectGetOwnPropertyNames(target);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      if (isArrayIndex(key)) {
-        throw new ERR_INVALID_PACKAGE_CONFIG(
-          fileURLToPath(packageJSONUrl),
-          base,
-          '"exports" cannot contain numeric property keys.'
-        );
-      }
-    }
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      if (key === "default" || conditions.has(key)) {
-        const conditionalTarget = target[key];
-        const resolveResult = resolvePackageTarget(
-          packageJSONUrl,
-          conditionalTarget,
-          subpath,
-          packageSubpath,
-          base,
-          pattern,
-          internal,
-          conditions
-        );
-        if (resolveResult === void 0) continue;
-        return resolveResult;
-      }
-    }
-    return void 0;
-  } else if (target === null) {
-    return null;
-  }
-  throwInvalidPackageTarget(
-    packageSubpath,
-    target,
-    packageJSONUrl,
-    internal,
-    base
-  );
-}
-function patternKeyCompare(a, b) {
-  const aPatternIndex = StringPrototypeIndexOf(a, "*");
-  const bPatternIndex = StringPrototypeIndexOf(b, "*");
-  const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
-  const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
-  if (baseLenA > baseLenB) return -1;
-  if (baseLenB > baseLenA) 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, readFileSyncFn }) {
-  if (name === "#" || StringPrototypeStartsWith(name, "#/") || StringPrototypeEndsWith(name, "/")) {
-    const reason = "is not a valid internal imports specifier name";
-    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath(base));
-  }
-  let packageJSONUrl;
-  const packageConfig = getPackageScopeConfig(base, readFileSyncFn);
-  if (packageConfig.exists) {
-    packageJSONUrl = pathToFileURL(packageConfig.pjsonPath);
-    const imports = packageConfig.imports;
-    if (imports) {
-      if (ObjectPrototypeHasOwnProperty(imports, name) && !StringPrototypeIncludes(name, "*")) {
-        const resolveResult = resolvePackageTarget(
-          packageJSONUrl,
-          imports[name],
-          "",
-          name,
-          base,
-          false,
-          true,
-          conditions
-        );
-        if (resolveResult != null) {
-          return resolveResult;
-        }
-      } else {
-        let bestMatch = "";
-        let bestMatchSubpath;
-        const keys = ObjectGetOwnPropertyNames(imports);
-        for (let i = 0; i < keys.length; i++) {
-          const key = keys[i];
-          const patternIndex = StringPrototypeIndexOf(key, "*");
-          if (patternIndex !== -1 && StringPrototypeStartsWith(
-            name,
-            StringPrototypeSlice(key, 0, patternIndex)
-          )) {
-            const patternTrailer = StringPrototypeSlice(key, patternIndex + 1);
-            if (name.length >= key.length && StringPrototypeEndsWith(name, patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && StringPrototypeLastIndexOf(key, "*") === patternIndex) {
-              bestMatch = key;
-              bestMatchSubpath = StringPrototypeSlice(
-                name,
-                patternIndex,
-                name.length - patternTrailer.length
-              );
-            }
-          }
-        }
-        if (bestMatch) {
-          const target = imports[bestMatch];
-          const resolveResult = resolvePackageTarget(
-            packageJSONUrl,
-            target,
-            bestMatchSubpath,
-            bestMatch,
-            base,
-            true,
-            true,
-            conditions
-          );
-          if (resolveResult != null) {
-            return resolveResult;
-          }
-        }
-      }
-    }
-  }
-  throwImportNotDefined(name, packageJSONUrl, base);
-}
-
-let findPnpApi = esmModule.findPnpApi;
-if (!findPnpApi) {
-  const require = createRequire(import.meta.url);
-  const pnpApi = require(`./.pnp.cjs`);
-  pnpApi.setup();
-  findPnpApi = esmModule.findPnpApi;
-}
-const pathRegExp = /^(?![a-zA-Z]:[\\/]|\\\\|\.{0,2}(?:\/|$))((?:node:)?(?:@[^/]+\/)?[^/]+)\/*(.*|)$/;
-const isRelativeRegexp = /^\.{0,2}\//;
-function tryReadFile(filePath) {
-  try {
-    return fs.readFileSync(filePath, `utf8`);
-  } catch (err) {
-    if (err.code === `ENOENT`)
-      return void 0;
-    throw err;
-  }
-}
-async function resolvePrivateRequest(specifier, issuer, context, nextResolve) {
-  const resolved = packageImportsResolve({
-    name: specifier,
-    base: pathToFileURL(issuer),
-    conditions: new Set(context.conditions),
-    readFileSyncFn: tryReadFile
-  });
-  if (resolved instanceof URL) {
-    return { url: resolved.href, shortCircuit: true };
-  } else {
-    if (resolved.startsWith(`#`))
-      throw new Error(`Mapping from one private import to another isn't allowed`);
-    return resolve$1(resolved, context, nextResolve);
-  }
-}
-async function resolve$1(originalSpecifier, context, nextResolve) {
-  if (!findPnpApi || isBuiltin(originalSpecifier))
-    return nextResolve(originalSpecifier, context, nextResolve);
-  let specifier = originalSpecifier;
-  const url = tryParseURL(specifier, isRelativeRegexp.test(specifier) ? context.parentURL : void 0);
-  if (url) {
-    if (url.protocol !== `file:`)
-      return nextResolve(originalSpecifier, context, nextResolve);
-    specifier = fileURLToPath(url);
-  }
-  const { parentURL, conditions = [] } = context;
-  const issuer = parentURL && tryParseURL(parentURL)?.protocol === `file:` ? fileURLToPath(parentURL) : process.cwd();
-  const pnpapi = findPnpApi(issuer) ?? (url ? findPnpApi(specifier) : null);
-  if (!pnpapi)
-    return nextResolve(originalSpecifier, context, nextResolve);
-  if (specifier.startsWith(`#`))
-    return resolvePrivateRequest(specifier, issuer, context, nextResolve);
-  const dependencyNameMatch = specifier.match(pathRegExp);
-  let allowLegacyResolve = false;
-  if (dependencyNameMatch) {
-    const [, dependencyName, subPath] = dependencyNameMatch;
-    if (subPath === `` && dependencyName !== `pnpapi`) {
-      const resolved = pnpapi.resolveToUnqualified(`${dependencyName}/package.json`, issuer);
-      if (resolved) {
-        const content = await tryReadFile$1(resolved);
-        if (content) {
-          const pkg = JSON.parse(content);
-          allowLegacyResolve = pkg.exports == null;
-        }
-      }
-    }
-  }
-  let result;
-  try {
-    result = pnpapi.resolveRequest(specifier, issuer, {
-      conditions: new Set(conditions),
-      // TODO: Handle --experimental-specifier-resolution=node
-      extensions: allowLegacyResolve ? void 0 : []
-    });
-  } catch (err) {
-    if (err instanceof Error && `code` in err && err.code === `MODULE_NOT_FOUND`)
-      err.code = `ERR_MODULE_NOT_FOUND`;
-    throw err;
-  }
-  if (!result)
-    throw new Error(`Resolving '${specifier}' from '${issuer}' failed`);
-  const resultURL = pathToFileURL(result);
-  if (url) {
-    resultURL.search = url.search;
-    resultURL.hash = url.hash;
-  }
-  if (!parentURL)
-    setEntrypointPath(fileURLToPath(resultURL));
-  return {
-    url: resultURL.href,
-    shortCircuit: true
-  };
-}
-
-if (!HAS_LAZY_LOADED_TRANSLATORS) {
-  const binding = process.binding(`fs`);
-  const originalReadFile = binding.readFileUtf8 || binding.readFileSync;
-  if (originalReadFile) {
-    binding[originalReadFile.name] = function(...args) {
-      try {
-        return fs.readFileSync(args[0], {
-          encoding: `utf8`,
-          // @ts-expect-error - The docs says it needs to be a string but
-          // links to https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#file-system-flags
-          // which says it can be a number which matches the implementation.
-          flag: args[1]
-        });
-      } catch {
-      }
-      return originalReadFile.apply(this, args);
-    };
-  } else {
-    const binding2 = process.binding(`fs`);
-    const originalfstat = binding2.fstat;
-    const ZIP_MASK = 4278190080;
-    const ZIP_MAGIC = 704643072;
-    binding2.fstat = function(...args) {
-      const [fd, useBigint, req] = args;
-      if ((fd & ZIP_MASK) === ZIP_MAGIC && useBigint === false && req === void 0) {
-        try {
-          const stats = fs.fstatSync(fd);
-          return new Float64Array([
-            stats.dev,
-            stats.mode,
-            stats.nlink,
-            stats.uid,
-            stats.gid,
-            stats.rdev,
-            stats.blksize,
-            stats.ino,
-            stats.size,
-            stats.blocks
-            // atime sec
-            // atime ns
-            // mtime sec
-            // mtime ns
-            // ctime sec
-            // ctime ns
-            // birthtime sec
-            // birthtime ns
-          ]);
-        } catch {
-        }
-      }
-      return originalfstat.apply(this, args);
-    };
-  }
-}
-
-const resolve = resolve$1;
-const load = load$1;
-
-export { load, resolve };