2618 lines
72 KiB
JavaScript
2618 lines
72 KiB
JavaScript
/* 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 moduleExports, { 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 (e) {
|
|
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 {
|
|
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 (error) {}
|
|
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 (error) {}
|
|
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 (error) {}
|
|
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 (error) {}
|
|
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 (error) {
|
|
return Date.now() - startTime < 500
|
|
}
|
|
try {
|
|
process.kill(pid, 0)
|
|
return true
|
|
} catch (error) {
|
|
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 (error2) {}
|
|
}
|
|
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 (error) {}
|
|
}
|
|
}
|
|
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), a, b)
|
|
}
|
|
watchFile(p, a, b) {
|
|
return this.baseFs.watchFile(this.mapToBase(p), 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 {
|
|
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), a, b)
|
|
}
|
|
watchFile(p, a, b) {
|
|
return this.realFs.watchFile(npath.fromPortablePath(p), 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 {
|
|
constructor({ baseFs = new NodeFS() } = {}) {
|
|
super(ppath)
|
|
this.baseFs = 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))
|
|
}
|
|
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)
|
|
}
|
|
|
|
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) {
|
|
const { findPnpApi } = moduleExports
|
|
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),
|
|
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`,
|
|
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,
|
|
])
|
|
} catch {}
|
|
}
|
|
return originalfstat.apply(this, args)
|
|
}
|
|
}
|
|
}
|
|
|
|
const resolve = resolve$1
|
|
const load = load$1
|
|
|
|
export { load, resolve }
|