diff --git a/.github/workflows/integration-workflow.yml b/.github/workflows/integration-workflow.yml index bfd3f867d696..e23390433644 100644 --- a/.github/workflows/integration-workflow.yml +++ b/.github/workflows/integration-workflow.yml @@ -214,7 +214,7 @@ jobs: fail-fast: false matrix: # We run the ubuntu tests on multiple Node versions with 2 shards since they're the fastest. - node: [18, 19, 20, 21, 22] + node: [18, 19, 20, 21, 22, 23] platform: [[ubuntu, 20.04]] shard: ['1/2', '2/2'] include: @@ -229,13 +229,13 @@ jobs: - {node: 18, platform: [macos, latest], shard: 3/3} # We also run them on the maximum Node version we support, to catch potential regressions in Node.js. # Windows tests - - {node: 22, platform: [windows, latest], shard: 1/3} - - {node: 22, platform: [windows, latest], shard: 2/3} - - {node: 22, platform: [windows, latest], shard: 3/3} + - {node: 23, platform: [windows, latest], shard: 1/3} + - {node: 23, platform: [windows, latest], shard: 2/3} + - {node: 23, platform: [windows, latest], shard: 3/3} # macOS tests - - {node: 22, platform: [macos, latest], shard: 1/3} - - {node: 22, platform: [macos, latest], shard: 2/3} - - {node: 22, platform: [macos, latest], shard: 3/3} + - {node: 23, platform: [macos, latest], shard: 1/3} + - {node: 23, platform: [macos, latest], shard: 2/3} + - {node: 23, platform: [macos, latest], shard: 3/3} name: '${{matrix.platform[0]}}-latest w/ Node.js ${{matrix.node}}.x (${{matrix.shard}})' runs-on: ${{matrix.platform[0]}}-${{matrix.platform[1]}} diff --git a/.pnp.cjs b/.pnp.cjs index de9373a8d7f9..f029ad727147 100755 --- a/.pnp.cjs +++ b/.pnp.cjs @@ -43486,6 +43486,7 @@ function getPathForDisplay(p) { 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; +Boolean(process.features.typescript); function readPackageScope(checkPath) { const rootSeparatorIndex = checkPath.indexOf(npath.sep); diff --git a/.pnp.loader.mjs b/.pnp.loader.mjs index 9896cc716ffe..84edfd1d3f0c 100644 --- a/.pnp.loader.mjs +++ b/.pnp.loader.mjs @@ -1,1561 +1,14 @@ /* 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 fs from 'fs'; 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 - reason TBS - a, - b - ); - } - watchFile(p, a, b) { - return this.baseFs.watchFile( - this.mapToBase(p), - // @ts-expect-error - reason TBS - 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 - reason TBS - a, - b - ); - } - watchFile(p, a, b) { - return this.realFs.watchFile( - npath.fromPortablePath(p), - // @ts-expect-error - reason TBS - 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; - } -} +import 'path'; 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; @@ -1973,6 +426,29 @@ function packageImportsResolve({ name, base, conditions, readFileSyncFn }) { throwImportNotDefined(name, packageJSONUrl, base); } +const [major, minor] = process.versions.node.split(`.`).map((value) => parseInt(value, 10)); +const HAS_LAZY_LOADED_TRANSLATORS = major === 20 && minor < 6 || major === 19 && minor >= 3; +Boolean(process.features.typescript); + +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; + } +} +function setEntrypointPath(file) { +} + let findPnpApi = esmModule.findPnpApi; if (!findPnpApi) { const require = createRequire(import.meta.url); @@ -2121,6 +597,5 @@ if (!HAS_LAZY_LOADED_TRANSLATORS) { } const resolve = resolve$1; -const load = load$1; -export { load, resolve }; +export { resolve }; diff --git a/packages/acceptance-tests/pkg-tests-specs/sources/pnp-esm.test.ts b/packages/acceptance-tests/pkg-tests-specs/sources/pnp-esm.test.ts index 36f72ca97b5f..e8dfa458bd1e 100644 --- a/packages/acceptance-tests/pkg-tests-specs/sources/pnp-esm.test.ts +++ b/packages/acceptance-tests/pkg-tests-specs/sources/pnp-esm.test.ts @@ -1,6 +1,6 @@ -import {Filename, npath, ppath, xfs} from '@yarnpkg/fslib'; -import {ALLOWS_EXTENSIONLESS_FILES, HAS_LOADERS_AFFECTING_LOADERS, SUPPORTS_IMPORT_ATTRIBUTES, SUPPORTS_IMPORT_ATTRIBUTES_ONLY} from '@yarnpkg/pnp/sources/esm-loader/loaderFlags'; -import {pathToFileURL} from 'url'; +import {Filename, npath, ppath, xfs} from '@yarnpkg/fslib'; +import {ALLOWS_EXTENSIONLESS_FILES, HAS_LOADERS_AFFECTING_LOADERS, SUPPORTS_IMPORT_ATTRIBUTES, SUPPORTS_IMPORT_ATTRIBUTES_ONLY, SUPPORTS_TYPE_STRIPPING} from '@yarnpkg/pnp/sources/esm-loader/loaderFlags'; +import {pathToFileURL} from 'url'; describe(`Plug'n'Play - ESM`, () => { test( @@ -361,7 +361,7 @@ describe(`Plug'n'Play - ESM`, () => { test( `it should load extensionless commonjs files as an entrypoint`, makeTemporaryEnv( - { }, + {}, { pnpEnableEsmLoader: true, }, @@ -381,7 +381,7 @@ describe(`Plug'n'Play - ESM`, () => { test( `it should load symlinked extensionless commonjs files as an entrypoint`, makeTemporaryEnv( - { }, + {}, { pnpEnableEsmLoader: true, }, @@ -403,7 +403,7 @@ describe(`Plug'n'Play - ESM`, () => { (ALLOWS_EXTENSIONLESS_FILES ? it.skip : it)( `it should not allow extensionless commonjs imports`, makeTemporaryEnv( - { }, + {}, { pnpEnableEsmLoader: true, }, @@ -424,7 +424,7 @@ describe(`Plug'n'Play - ESM`, () => { (ALLOWS_EXTENSIONLESS_FILES ? it : it.skip)( `it should allow extensionless commonjs imports`, makeTemporaryEnv( - { }, + {}, { pnpEnableEsmLoader: true, }, @@ -1160,4 +1160,67 @@ describe(`Plug'n'Play - ESM`, () => { }, ), ); + (SUPPORTS_TYPE_STRIPPING ? describe : describe.skip)(`Node builtin type stripping`, () => { + for (const type of [`module`, `commonjs`, undefined]) { + test( + `${type}: it should import mts typescript`, + makeTemporaryEnv( + { + type, + dependencies: { + "no-deps": `1.0.0`, + }, + }, + { + pnpEnableEsmLoader: true, + }, + async ({path, run}) => { + await xfs.writeFilePromise(ppath.join(path, `mod.mts`), `export const foo = 42 as any;`); + + await xfs.writeFilePromise(ppath.join(path, `index.mts`), ` +import * as fs from 'node:fs'; +import * as asd from 'no-deps/index.js'; +import {foo} from './mod.mts'; +console.log(foo as any);`, + ); + await run(`install`); + await expect(run(`node`, `index.mts`)).resolves.toMatchObject({ + code: 0, + stdout: `42\n`, + }); + }, + ), + ); + test( + `${type}: it should import cts typescript`, + makeTemporaryEnv( + { + type, + dependencies: { + "no-deps": `1.0.0`, + }, + }, + { + pnpEnableEsmLoader: true, + }, + async ({path, run}) => { + await xfs.writeFilePromise(ppath.join(path, `mod.cts`), `module.exports.foo = 42 as any;`); + + await xfs.writeFilePromise(ppath.join(path, `index.cts`), ` +const fs = require('node:fs'); +const asd = require('no-deps/index.js'); +const {foo} = require('./mod.cts'); +console.log(foo as any);` + ); + + await run(`install`); + await expect(run(`node`, `index.cts`)).resolves.toMatchObject({ + code: 0, + stdout: `42\n`, + }); + }, + ), + ); + } + }); }); diff --git a/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js b/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js index e5840be1534d..5d53b378159b 100644 --- a/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js +++ b/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js @@ -2,7 +2,7 @@ let hook; module.exports = () => { if (typeof hook === `undefined`) - hook = require('zlib').brotliDecompressSync(Buffer.from('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', 'base64')).toString(); + hook = require('zlib').brotliDecompressSync(Buffer.from('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', 'base64')).toString(); return hook; }; diff --git a/packages/yarnpkg-pnp/sources/esm-loader/loader.ts b/packages/yarnpkg-pnp/sources/esm-loader/loader.ts index a025749e2b9d..d5ad6a933476 100644 --- a/packages/yarnpkg-pnp/sources/esm-loader/loader.ts +++ b/packages/yarnpkg-pnp/sources/esm-loader/loader.ts @@ -1,6 +1,6 @@ -import {load as loadHook} from './hooks/load'; +// import {load as loadHook} from './hooks/load'; import {resolve as resolveHook} from './hooks/resolve'; import './fspatch'; export const resolve = resolveHook; -export const load = loadHook; +// export const load = loadHook; diff --git a/packages/yarnpkg-pnp/sources/esm-loader/loaderFlags.ts b/packages/yarnpkg-pnp/sources/esm-loader/loaderFlags.ts index 1ea69f7c845f..3a216e2341ef 100644 --- a/packages/yarnpkg-pnp/sources/esm-loader/loaderFlags.ts +++ b/packages/yarnpkg-pnp/sources/esm-loader/loaderFlags.ts @@ -20,3 +20,7 @@ export const SUPPORTS_IMPORT_ATTRIBUTES = major >= 21 || (major === 20 && minor // https://github.com/nodejs/node/pull/52104 export const SUPPORTS_IMPORT_ATTRIBUTES_ONLY = major >= 22; + +// https://github.com/nodejs/node/pull/53725 +// https://nodejs.org/docs/v22.14.0/api/process.html#processfeaturestypescript +export const SUPPORTS_TYPE_STRIPPING = Boolean((process.features as any).typescript) diff --git a/packages/yarnpkg-pnp/sources/esm-loader/loaderUtils.ts b/packages/yarnpkg-pnp/sources/esm-loader/loaderUtils.ts index cdea66901092..b440e9093f45 100644 --- a/packages/yarnpkg-pnp/sources/esm-loader/loaderUtils.ts +++ b/packages/yarnpkg-pnp/sources/esm-loader/loaderUtils.ts @@ -39,6 +39,12 @@ export function getFileFormat(filepath: string): string | null { case `.cjs`: { return `commonjs`; } + case `.mts`: { + return `module`; + } + case `.cts`: { + return `commonjs`; + } case `.wasm`: { // TODO: Enable if --experimental-wasm-modules is present // Waiting on https://github.com/nodejs/node/issues/36935 diff --git a/packages/yarnpkg-pnp/sources/hook.js b/packages/yarnpkg-pnp/sources/hook.js index 47cfb58e9426..e4ac8f9159b5 100644 --- a/packages/yarnpkg-pnp/sources/hook.js +++ b/packages/yarnpkg-pnp/sources/hook.js @@ -2,7 +2,7 @@ let hook; module.exports = () => { if (typeof hook === `undefined`) - hook = require('zlib').brotliDecompressSync(Buffer.from('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', 'base64')).toString(); + hook = require('zlib').brotliDecompressSync(Buffer.from('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', 'base64')).toString(); return hook; };