playwright-core
Version:
A high-level API to automate web browsers
1,940 lines • 57 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// packages/playwright-core/src/serverRegistry.ts
var serverRegistry_exports = {};
__export(serverRegistry_exports, {
serverRegistry: () => serverRegistry
});
module.exports = __toCommonJS(serverRegistry_exports);
var import_events2 = require("events");
var import_fs3 = __toESM(require("fs"));
var import_net = __toESM(require("net"));
var import_path2 = __toESM(require("path"));
var import_os2 = __toESM(require("os"));
// node_modules/chokidar/esm/index.js
var import_fs2 = require("fs");
var import_promises3 = require("fs/promises");
var import_events = require("events");
var sysPath2 = __toESM(require("path"), 1);
// node_modules/readdirp/esm/index.js
var import_promises = require("node:fs/promises");
var import_node_stream = require("node:stream");
var import_node_path = require("node:path");
var EntryTypes = {
FILE_TYPE: "files",
DIR_TYPE: "directories",
FILE_DIR_TYPE: "files_directories",
EVERYTHING_TYPE: "all"
};
var defaultOptions = {
root: ".",
fileFilter: (_entryInfo) => true,
directoryFilter: (_entryInfo) => true,
type: EntryTypes.FILE_TYPE,
lstat: false,
depth: 2147483648,
alwaysStat: false,
highWaterMark: 4096
};
Object.freeze(defaultOptions);
var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
var ALL_TYPES = [
EntryTypes.DIR_TYPE,
EntryTypes.EVERYTHING_TYPE,
EntryTypes.FILE_DIR_TYPE,
EntryTypes.FILE_TYPE
];
var DIR_TYPES = /* @__PURE__ */ new Set([
EntryTypes.DIR_TYPE,
EntryTypes.EVERYTHING_TYPE,
EntryTypes.FILE_DIR_TYPE
]);
var FILE_TYPES = /* @__PURE__ */ new Set([
EntryTypes.EVERYTHING_TYPE,
EntryTypes.FILE_DIR_TYPE,
EntryTypes.FILE_TYPE
]);
var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
var wantBigintFsStats = process.platform === "win32";
var emptyFn = (_entryInfo) => true;
var normalizeFilter = (filter) => {
if (filter === void 0)
return emptyFn;
if (typeof filter === "function")
return filter;
if (typeof filter === "string") {
const fl = filter.trim();
return (entry) => entry.basename === fl;
}
if (Array.isArray(filter)) {
const trItems = filter.map((item) => item.trim());
return (entry) => trItems.some((f) => entry.basename === f);
}
return emptyFn;
};
var ReaddirpStream = class extends import_node_stream.Readable {
constructor(options = {}) {
super({
objectMode: true,
autoDestroy: true,
highWaterMark: options.highWaterMark
});
const opts = { ...defaultOptions, ...options };
const { root, type } = opts;
this._fileFilter = normalizeFilter(opts.fileFilter);
this._directoryFilter = normalizeFilter(opts.directoryFilter);
const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
if (wantBigintFsStats) {
this._stat = (path3) => statMethod(path3, { bigint: true });
} else {
this._stat = statMethod;
}
this._maxDepth = opts.depth ?? defaultOptions.depth;
this._wantsDir = type ? DIR_TYPES.has(type) : false;
this._wantsFile = type ? FILE_TYPES.has(type) : false;
this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
this._root = (0, import_node_path.resolve)(root);
this._isDirent = !opts.alwaysStat;
this._statsProp = this._isDirent ? "dirent" : "stats";
this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
this.parents = [this._exploreDir(root, 1)];
this.reading = false;
this.parent = void 0;
}
async _read(batch) {
if (this.reading)
return;
this.reading = true;
try {
while (!this.destroyed && batch > 0) {
const par = this.parent;
const fil = par && par.files;
if (fil && fil.length > 0) {
const { path: path3, depth } = par;
const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path3));
const awaited = await Promise.all(slice);
for (const entry of awaited) {
if (!entry)
continue;
if (this.destroyed)
return;
const entryType = await this._getEntryType(entry);
if (entryType === "directory" && this._directoryFilter(entry)) {
if (depth <= this._maxDepth) {
this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
}
if (this._wantsDir) {
this.push(entry);
batch--;
}
} else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
if (this._wantsFile) {
this.push(entry);
batch--;
}
}
}
} else {
const parent = this.parents.pop();
if (!parent) {
this.push(null);
break;
}
this.parent = await parent;
if (this.destroyed)
return;
}
}
} catch (error) {
this.destroy(error);
} finally {
this.reading = false;
}
}
async _exploreDir(path3, depth) {
let files;
try {
files = await (0, import_promises.readdir)(path3, this._rdOptions);
} catch (error) {
this._onError(error);
}
return { files, depth, path: path3 };
}
async _formatEntry(dirent, path3) {
let entry;
const basename3 = this._isDirent ? dirent.name : dirent;
try {
const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path3, basename3));
entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename3 };
entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
} catch (err) {
this._onError(err);
return;
}
return entry;
}
_onError(err) {
if (isNormalFlowError(err) && !this.destroyed) {
this.emit("warn", err);
} else {
this.destroy(err);
}
}
async _getEntryType(entry) {
if (!entry && this._statsProp in entry) {
return "";
}
const stats = entry[this._statsProp];
if (stats.isFile())
return "file";
if (stats.isDirectory())
return "directory";
if (stats && stats.isSymbolicLink()) {
const full = entry.fullPath;
try {
const entryRealPath = await (0, import_promises.realpath)(full);
const entryRealPathStats = await (0, import_promises.lstat)(entryRealPath);
if (entryRealPathStats.isFile()) {
return "file";
}
if (entryRealPathStats.isDirectory()) {
const len = entryRealPath.length;
if (full.startsWith(entryRealPath) && full.substr(len, 1) === import_node_path.sep) {
const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
recursiveError.code = RECURSIVE_ERROR_CODE;
return this._onError(recursiveError);
}
return "directory";
}
} catch (error) {
this._onError(error);
return "";
}
}
}
_includeAsFile(entry) {
const stats = entry && entry[this._statsProp];
return stats && this._wantsEverything && !stats.isDirectory();
}
};
function readdirp(root, options = {}) {
let type = options.entryType || options.type;
if (type === "both")
type = EntryTypes.FILE_DIR_TYPE;
if (type)
options.type = type;
if (!root) {
throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
} else if (typeof root !== "string") {
throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
} else if (type && !ALL_TYPES.includes(type)) {
throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
}
options.root = root;
return new ReaddirpStream(options);
}
// node_modules/chokidar/esm/handler.js
var import_fs = require("fs");
var import_promises2 = require("fs/promises");
var sysPath = __toESM(require("path"), 1);
var import_os = require("os");
var STR_DATA = "data";
var STR_END = "end";
var STR_CLOSE = "close";
var EMPTY_FN = () => {
};
var pl = process.platform;
var isWindows = pl === "win32";
var isMacos = pl === "darwin";
var isLinux = pl === "linux";
var isFreeBSD = pl === "freebsd";
var isIBMi = (0, import_os.type)() === "OS400";
var EVENTS = {
ALL: "all",
READY: "ready",
ADD: "add",
CHANGE: "change",
ADD_DIR: "addDir",
UNLINK: "unlink",
UNLINK_DIR: "unlinkDir",
RAW: "raw",
ERROR: "error"
};
var EV = EVENTS;
var THROTTLE_MODE_WATCH = "watch";
var statMethods = { lstat: import_promises2.lstat, stat: import_promises2.stat };
var KEY_LISTENERS = "listeners";
var KEY_ERR = "errHandlers";
var KEY_RAW = "rawEmitters";
var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
var binaryExtensions = /* @__PURE__ */ new Set([
"3dm",
"3ds",
"3g2",
"3gp",
"7z",
"a",
"aac",
"adp",
"afdesign",
"afphoto",
"afpub",
"ai",
"aif",
"aiff",
"alz",
"ape",
"apk",
"appimage",
"ar",
"arj",
"asf",
"au",
"avi",
"bak",
"baml",
"bh",
"bin",
"bk",
"bmp",
"btif",
"bz2",
"bzip2",
"cab",
"caf",
"cgm",
"class",
"cmx",
"cpio",
"cr2",
"cur",
"dat",
"dcm",
"deb",
"dex",
"djvu",
"dll",
"dmg",
"dng",
"doc",
"docm",
"docx",
"dot",
"dotm",
"dra",
"DS_Store",
"dsk",
"dts",
"dtshd",
"dvb",
"dwg",
"dxf",
"ecelp4800",
"ecelp7470",
"ecelp9600",
"egg",
"eol",
"eot",
"epub",
"exe",
"f4v",
"fbs",
"fh",
"fla",
"flac",
"flatpak",
"fli",
"flv",
"fpx",
"fst",
"fvt",
"g3",
"gh",
"gif",
"graffle",
"gz",
"gzip",
"h261",
"h263",
"h264",
"icns",
"ico",
"ief",
"img",
"ipa",
"iso",
"jar",
"jpeg",
"jpg",
"jpgv",
"jpm",
"jxr",
"key",
"ktx",
"lha",
"lib",
"lvp",
"lz",
"lzh",
"lzma",
"lzo",
"m3u",
"m4a",
"m4v",
"mar",
"mdi",
"mht",
"mid",
"midi",
"mj2",
"mka",
"mkv",
"mmr",
"mng",
"mobi",
"mov",
"movie",
"mp3",
"mp4",
"mp4a",
"mpeg",
"mpg",
"mpga",
"mxu",
"nef",
"npx",
"numbers",
"nupkg",
"o",
"odp",
"ods",
"odt",
"oga",
"ogg",
"ogv",
"otf",
"ott",
"pages",
"pbm",
"pcx",
"pdb",
"pdf",
"pea",
"pgm",
"pic",
"png",
"pnm",
"pot",
"potm",
"potx",
"ppa",
"ppam",
"ppm",
"pps",
"ppsm",
"ppsx",
"ppt",
"pptm",
"pptx",
"psd",
"pya",
"pyc",
"pyo",
"pyv",
"qt",
"rar",
"ras",
"raw",
"resources",
"rgb",
"rip",
"rlc",
"rmf",
"rmvb",
"rpm",
"rtf",
"rz",
"s3m",
"s7z",
"scpt",
"sgi",
"shar",
"snap",
"sil",
"sketch",
"slk",
"smv",
"snk",
"so",
"stl",
"suo",
"sub",
"swf",
"tar",
"tbz",
"tbz2",
"tga",
"tgz",
"thmx",
"tif",
"tiff",
"tlz",
"ttc",
"ttf",
"txz",
"udf",
"uvh",
"uvi",
"uvm",
"uvp",
"uvs",
"uvu",
"viv",
"vob",
"war",
"wav",
"wax",
"wbmp",
"wdp",
"weba",
"webm",
"webp",
"whl",
"wim",
"wm",
"wma",
"wmv",
"wmx",
"woff",
"woff2",
"wrm",
"wvx",
"xbm",
"xif",
"xla",
"xlam",
"xls",
"xlsb",
"xlsm",
"xlsx",
"xlt",
"xltm",
"xltx",
"xm",
"xmind",
"xpi",
"xpm",
"xwd",
"xz",
"z",
"zip",
"zipx"
]);
var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
var foreach = (val, fn) => {
if (val instanceof Set) {
val.forEach(fn);
} else {
fn(val);
}
};
var addAndConvert = (main, prop, item) => {
let container = main[prop];
if (!(container instanceof Set)) {
main[prop] = container = /* @__PURE__ */ new Set([container]);
}
container.add(item);
};
var clearItem = (cont) => (key) => {
const set = cont[key];
if (set instanceof Set) {
set.clear();
} else {
delete cont[key];
}
};
var delFromSet = (main, prop, item) => {
const container = main[prop];
if (container instanceof Set) {
container.delete(item);
} else if (container === item) {
delete main[prop];
}
};
var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
var FsWatchInstances = /* @__PURE__ */ new Map();
function createFsWatchInstance(path3, options, listener, errHandler, emitRaw) {
const handleEvent = (rawEvent, evPath) => {
listener(path3);
emitRaw(rawEvent, evPath, { watchedPath: path3 });
if (evPath && path3 !== evPath) {
fsWatchBroadcast(sysPath.resolve(path3, evPath), KEY_LISTENERS, sysPath.join(path3, evPath));
}
};
try {
return (0, import_fs.watch)(path3, {
persistent: options.persistent
}, handleEvent);
} catch (error) {
errHandler(error);
return void 0;
}
}
var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
const cont = FsWatchInstances.get(fullPath);
if (!cont)
return;
foreach(cont[listenerType], (listener) => {
listener(val1, val2, val3);
});
};
var setFsWatchListener = (path3, fullPath, options, handlers) => {
const { listener, errHandler, rawEmitter } = handlers;
let cont = FsWatchInstances.get(fullPath);
let watcher;
if (!options.persistent) {
watcher = createFsWatchInstance(path3, options, listener, errHandler, rawEmitter);
if (!watcher)
return;
return watcher.close.bind(watcher);
}
if (cont) {
addAndConvert(cont, KEY_LISTENERS, listener);
addAndConvert(cont, KEY_ERR, errHandler);
addAndConvert(cont, KEY_RAW, rawEmitter);
} else {
watcher = createFsWatchInstance(
path3,
options,
fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
errHandler,
// no need to use broadcast here
fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
);
if (!watcher)
return;
watcher.on(EV.ERROR, async (error) => {
const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
if (cont)
cont.watcherUnusable = true;
if (isWindows && error.code === "EPERM") {
try {
const fd = await (0, import_promises2.open)(path3, "r");
await fd.close();
broadcastErr(error);
} catch (err) {
}
} else {
broadcastErr(error);
}
});
cont = {
listeners: listener,
errHandlers: errHandler,
rawEmitters: rawEmitter,
watcher
};
FsWatchInstances.set(fullPath, cont);
}
return () => {
delFromSet(cont, KEY_LISTENERS, listener);
delFromSet(cont, KEY_ERR, errHandler);
delFromSet(cont, KEY_RAW, rawEmitter);
if (isEmptySet(cont.listeners)) {
cont.watcher.close();
FsWatchInstances.delete(fullPath);
HANDLER_KEYS.forEach(clearItem(cont));
cont.watcher = void 0;
Object.freeze(cont);
}
};
};
var FsWatchFileInstances = /* @__PURE__ */ new Map();
var setFsWatchFileListener = (path3, fullPath, options, handlers) => {
const { listener, rawEmitter } = handlers;
let cont = FsWatchFileInstances.get(fullPath);
const copts = cont && cont.options;
if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
(0, import_fs.unwatchFile)(fullPath);
cont = void 0;
}
if (cont) {
addAndConvert(cont, KEY_LISTENERS, listener);
addAndConvert(cont, KEY_RAW, rawEmitter);
} else {
cont = {
listeners: listener,
rawEmitters: rawEmitter,
options,
watcher: (0, import_fs.watchFile)(fullPath, options, (curr, prev) => {
foreach(cont.rawEmitters, (rawEmitter2) => {
rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
});
const currmtime = curr.mtimeMs;
if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
foreach(cont.listeners, (listener2) => listener2(path3, curr));
}
})
};
FsWatchFileInstances.set(fullPath, cont);
}
return () => {
delFromSet(cont, KEY_LISTENERS, listener);
delFromSet(cont, KEY_RAW, rawEmitter);
if (isEmptySet(cont.listeners)) {
FsWatchFileInstances.delete(fullPath);
(0, import_fs.unwatchFile)(fullPath);
cont.options = cont.watcher = void 0;
Object.freeze(cont);
}
};
};
var NodeFsHandler = class {
constructor(fsW) {
this.fsw = fsW;
this._boundHandleError = (error) => fsW._handleError(error);
}
/**
* Watch file for changes with fs_watchFile or fs_watch.
* @param path to file or dir
* @param listener on fs change
* @returns closer for the watcher instance
*/
_watchWithNodeFs(path3, listener) {
const opts = this.fsw.options;
const directory = sysPath.dirname(path3);
const basename3 = sysPath.basename(path3);
const parent = this.fsw._getWatchedDir(directory);
parent.add(basename3);
const absolutePath = sysPath.resolve(path3);
const options = {
persistent: opts.persistent
};
if (!listener)
listener = EMPTY_FN;
let closer;
if (opts.usePolling) {
const enableBin = opts.interval !== opts.binaryInterval;
options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
closer = setFsWatchFileListener(path3, absolutePath, options, {
listener,
rawEmitter: this.fsw._emitRaw
});
} else {
closer = setFsWatchListener(path3, absolutePath, options, {
listener,
errHandler: this._boundHandleError,
rawEmitter: this.fsw._emitRaw
});
}
return closer;
}
/**
* Watch a file and emit add event if warranted.
* @returns closer for the watcher instance
*/
_handleFile(file, stats, initialAdd) {
if (this.fsw.closed) {
return;
}
const dirname3 = sysPath.dirname(file);
const basename3 = sysPath.basename(file);
const parent = this.fsw._getWatchedDir(dirname3);
let prevStats = stats;
if (parent.has(basename3))
return;
const listener = async (path3, newStats) => {
if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
return;
if (!newStats || newStats.mtimeMs === 0) {
try {
const newStats2 = await (0, import_promises2.stat)(file);
if (this.fsw.closed)
return;
const at = newStats2.atimeMs;
const mt = newStats2.mtimeMs;
if (!at || at <= mt || mt !== prevStats.mtimeMs) {
this.fsw._emit(EV.CHANGE, file, newStats2);
}
if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
this.fsw._closeFile(path3);
prevStats = newStats2;
const closer2 = this._watchWithNodeFs(file, listener);
if (closer2)
this.fsw._addPathCloser(path3, closer2);
} else {
prevStats = newStats2;
}
} catch (error) {
this.fsw._remove(dirname3, basename3);
}
} else if (parent.has(basename3)) {
const at = newStats.atimeMs;
const mt = newStats.mtimeMs;
if (!at || at <= mt || mt !== prevStats.mtimeMs) {
this.fsw._emit(EV.CHANGE, file, newStats);
}
prevStats = newStats;
}
};
const closer = this._watchWithNodeFs(file, listener);
if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
if (!this.fsw._throttle(EV.ADD, file, 0))
return;
this.fsw._emit(EV.ADD, file, stats);
}
return closer;
}
/**
* Handle symlinks encountered while reading a dir.
* @param entry returned by readdirp
* @param directory path of dir being read
* @param path of this item
* @param item basename of this item
* @returns true if no more processing is needed for this entry.
*/
async _handleSymlink(entry, directory, path3, item) {
if (this.fsw.closed) {
return;
}
const full = entry.fullPath;
const dir = this.fsw._getWatchedDir(directory);
if (!this.fsw.options.followSymlinks) {
this.fsw._incrReadyCount();
let linkPath;
try {
linkPath = await (0, import_promises2.realpath)(path3);
} catch (e) {
this.fsw._emitReady();
return true;
}
if (this.fsw.closed)
return;
if (dir.has(item)) {
if (this.fsw._symlinkPaths.get(full) !== linkPath) {
this.fsw._symlinkPaths.set(full, linkPath);
this.fsw._emit(EV.CHANGE, path3, entry.stats);
}
} else {
dir.add(item);
this.fsw._symlinkPaths.set(full, linkPath);
this.fsw._emit(EV.ADD, path3, entry.stats);
}
this.fsw._emitReady();
return true;
}
if (this.fsw._symlinkPaths.has(full)) {
return true;
}
this.fsw._symlinkPaths.set(full, true);
}
_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
directory = sysPath.join(directory, "");
throttler = this.fsw._throttle("readdir", directory, 1e3);
if (!throttler)
return;
const previous = this.fsw._getWatchedDir(wh.path);
const current = /* @__PURE__ */ new Set();
let stream = this.fsw._readdirp(directory, {
fileFilter: (entry) => wh.filterPath(entry),
directoryFilter: (entry) => wh.filterDir(entry)
});
if (!stream)
return;
stream.on(STR_DATA, async (entry) => {
if (this.fsw.closed) {
stream = void 0;
return;
}
const item = entry.path;
let path3 = sysPath.join(directory, item);
current.add(item);
if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path3, item)) {
return;
}
if (this.fsw.closed) {
stream = void 0;
return;
}
if (item === target || !target && !previous.has(item)) {
this.fsw._incrReadyCount();
path3 = sysPath.join(dir, sysPath.relative(dir, path3));
this._addToNodeFs(path3, initialAdd, wh, depth + 1);
}
}).on(EV.ERROR, this._boundHandleError);
return new Promise((resolve3, reject) => {
if (!stream)
return reject();
stream.once(STR_END, () => {
if (this.fsw.closed) {
stream = void 0;
return;
}
const wasThrottled = throttler ? throttler.clear() : false;
resolve3(void 0);
previous.getChildren().filter((item) => {
return item !== directory && !current.has(item);
}).forEach((item) => {
this.fsw._remove(directory, item);
});
stream = void 0;
if (wasThrottled)
this._handleRead(directory, false, wh, target, dir, depth, throttler);
});
});
}
/**
* Read directory to add / remove files from `@watched` list and re-read it on change.
* @param dir fs path
* @param stats
* @param initialAdd
* @param depth relative to user-supplied path
* @param target child path targeted for watch
* @param wh Common watch helpers for this path
* @param realpath
* @returns closer for the watcher instance.
*/
async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
const tracked = parentDir.has(sysPath.basename(dir));
if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
this.fsw._emit(EV.ADD_DIR, dir, stats);
}
parentDir.add(sysPath.basename(dir));
this.fsw._getWatchedDir(dir);
let throttler;
let closer;
const oDepth = this.fsw.options.depth;
if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
if (!target) {
await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
if (this.fsw.closed)
return;
}
closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
if (stats2 && stats2.mtimeMs === 0)
return;
this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
});
}
return closer;
}
/**
* Handle added file, directory, or glob pattern.
* Delegates call to _handleFile / _handleDir after checks.
* @param path to file or ir
* @param initialAdd was the file added at watch instantiation?
* @param priorWh depth relative to user-supplied path
* @param depth Child path actually targeted for watch
* @param target Child path actually targeted for watch
*/
async _addToNodeFs(path3, initialAdd, priorWh, depth, target) {
const ready = this.fsw._emitReady;
if (this.fsw._isIgnored(path3) || this.fsw.closed) {
ready();
return false;
}
const wh = this.fsw._getWatchHelpers(path3);
if (priorWh) {
wh.filterPath = (entry) => priorWh.filterPath(entry);
wh.filterDir = (entry) => priorWh.filterDir(entry);
}
try {
const stats = await statMethods[wh.statMethod](wh.watchPath);
if (this.fsw.closed)
return;
if (this.fsw._isIgnored(wh.watchPath, stats)) {
ready();
return false;
}
const follow = this.fsw.options.followSymlinks;
let closer;
if (stats.isDirectory()) {
const absPath = sysPath.resolve(path3);
const targetPath = follow ? await (0, import_promises2.realpath)(path3) : path3;
if (this.fsw.closed)
return;
closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
if (this.fsw.closed)
return;
if (absPath !== targetPath && targetPath !== void 0) {
this.fsw._symlinkPaths.set(absPath, targetPath);
}
} else if (stats.isSymbolicLink()) {
const targetPath = follow ? await (0, import_promises2.realpath)(path3) : path3;
if (this.fsw.closed)
return;
const parent = sysPath.dirname(wh.watchPath);
this.fsw._getWatchedDir(parent).add(wh.watchPath);
this.fsw._emit(EV.ADD, wh.watchPath, stats);
closer = await this._handleDir(parent, stats, initialAdd, depth, path3, wh, targetPath);
if (this.fsw.closed)
return;
if (targetPath !== void 0) {
this.fsw._symlinkPaths.set(sysPath.resolve(path3), targetPath);
}
} else {
closer = this._handleFile(wh.watchPath, stats, initialAdd);
}
ready();
if (closer)
this.fsw._addPathCloser(path3, closer);
return false;
} catch (error) {
if (this.fsw._handleError(error)) {
ready();
return path3;
}
}
}
};
// node_modules/chokidar/esm/index.js
var SLASH = "/";
var SLASH_SLASH = "//";
var ONE_DOT = ".";
var TWO_DOTS = "..";
var STRING_TYPE = "string";
var BACK_SLASH_RE = /\\/g;
var DOUBLE_SLASH_RE = /\/\//;
var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
var REPLACER_RE = /^\.[/\\]/;
function arrify(item) {
return Array.isArray(item) ? item : [item];
}
var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
function createPattern(matcher) {
if (typeof matcher === "function")
return matcher;
if (typeof matcher === "string")
return (string) => matcher === string;
if (matcher instanceof RegExp)
return (string) => matcher.test(string);
if (typeof matcher === "object" && matcher !== null) {
return (string) => {
if (matcher.path === string)
return true;
if (matcher.recursive) {
const relative3 = sysPath2.relative(matcher.path, string);
if (!relative3) {
return false;
}
return !relative3.startsWith("..") && !sysPath2.isAbsolute(relative3);
}
return false;
};
}
return () => false;
}
function normalizePath(path3) {
if (typeof path3 !== "string")
throw new Error("string expected");
path3 = sysPath2.normalize(path3);
path3 = path3.replace(/\\/g, "/");
let prepend = false;
if (path3.startsWith("//"))
prepend = true;
const DOUBLE_SLASH_RE2 = /\/\//;
while (path3.match(DOUBLE_SLASH_RE2))
path3 = path3.replace(DOUBLE_SLASH_RE2, "/");
if (prepend)
path3 = "/" + path3;
return path3;
}
function matchPatterns(patterns, testString, stats) {
const path3 = normalizePath(testString);
for (let index = 0; index < patterns.length; index++) {
const pattern = patterns[index];
if (pattern(path3, stats)) {
return true;
}
}
return false;
}
function anymatch(matchers, testString) {
if (matchers == null) {
throw new TypeError("anymatch: specify first argument");
}
const matchersArray = arrify(matchers);
const patterns = matchersArray.map((matcher) => createPattern(matcher));
if (testString == null) {
return (testString2, stats) => {
return matchPatterns(patterns, testString2, stats);
};
}
return matchPatterns(patterns, testString);
}
var unifyPaths = (paths_) => {
const paths = arrify(paths_).flat();
if (!paths.every((p) => typeof p === STRING_TYPE)) {
throw new TypeError(`Non-string provided as watch path: ${paths}`);
}
return paths.map(normalizePathToUnix);
};
var toUnix = (string) => {
let str = string.replace(BACK_SLASH_RE, SLASH);
let prepend = false;
if (str.startsWith(SLASH_SLASH)) {
prepend = true;
}
while (str.match(DOUBLE_SLASH_RE)) {
str = str.replace(DOUBLE_SLASH_RE, SLASH);
}
if (prepend) {
str = SLASH + str;
}
return str;
};
var normalizePathToUnix = (path3) => toUnix(sysPath2.normalize(toUnix(path3)));
var normalizeIgnored = (cwd = "") => (path3) => {
if (typeof path3 === "string") {
return normalizePathToUnix(sysPath2.isAbsolute(path3) ? path3 : sysPath2.join(cwd, path3));
} else {
return path3;
}
};
var getAbsolutePath = (path3, cwd) => {
if (sysPath2.isAbsolute(path3)) {
return path3;
}
return sysPath2.join(cwd, path3);
};
var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
var DirEntry = class {
constructor(dir, removeWatcher) {
this.path = dir;
this._removeWatcher = removeWatcher;
this.items = /* @__PURE__ */ new Set();
}
add(item) {
const { items } = this;
if (!items)
return;
if (item !== ONE_DOT && item !== TWO_DOTS)
items.add(item);
}
async remove(item) {
const { items } = this;
if (!items)
return;
items.delete(item);
if (items.size > 0)
return;
const dir = this.path;
try {
await (0, import_promises3.readdir)(dir);
} catch (err) {
if (this._removeWatcher) {
this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
}
}
}
has(item) {
const { items } = this;
if (!items)
return;
return items.has(item);
}
getChildren() {
const { items } = this;
if (!items)
return [];
return [...items.values()];
}
dispose() {
this.items.clear();
this.path = "";
this._removeWatcher = EMPTY_FN;
this.items = EMPTY_SET;
Object.freeze(this);
}
};
var STAT_METHOD_F = "stat";
var STAT_METHOD_L = "lstat";
var WatchHelper = class {
constructor(path3, follow, fsw) {
this.fsw = fsw;
const watchPath = path3;
this.path = path3 = path3.replace(REPLACER_RE, "");
this.watchPath = watchPath;
this.fullWatchPath = sysPath2.resolve(watchPath);
this.dirParts = [];
this.dirParts.forEach((parts) => {
if (parts.length > 1)
parts.pop();
});
this.followSymlinks = follow;
this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
}
entryPath(entry) {
return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
}
filterPath(entry) {
const { stats } = entry;
if (stats && stats.isSymbolicLink())
return this.filterDir(entry);
const resolvedPath = this.entryPath(entry);
return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
}
filterDir(entry) {
return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
}
};
var FSWatcher = class extends import_events.EventEmitter {
// Not indenting methods for history sake; for now.
constructor(_opts = {}) {
super();
this.closed = false;
this._closers = /* @__PURE__ */ new Map();
this._ignoredPaths = /* @__PURE__ */ new Set();
this._throttled = /* @__PURE__ */ new Map();
this._streams = /* @__PURE__ */ new Set();
this._symlinkPaths = /* @__PURE__ */ new Map();
this._watched = /* @__PURE__ */ new Map();
this._pendingWrites = /* @__PURE__ */ new Map();
this._pendingUnlinks = /* @__PURE__ */ new Map();
this._readyCount = 0;
this._readyEmitted = false;
const awf = _opts.awaitWriteFinish;
const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
const opts = {
// Defaults
persistent: true,
ignoreInitial: false,
ignorePermissionErrors: false,
interval: 100,
binaryInterval: 300,
followSymlinks: true,
usePolling: false,
// useAsync: false,
atomic: true,
// NOTE: overwritten later (depends on usePolling)
..._opts,
// Change format
ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
};
if (isIBMi)
opts.usePolling = true;
if (opts.atomic === void 0)
opts.atomic = !opts.usePolling;
const envPoll = process.env.CHOKIDAR_USEPOLLING;
if (envPoll !== void 0) {
const envLower = envPoll.toLowerCase();
if (envLower === "false" || envLower === "0")
opts.usePolling = false;
else if (envLower === "true" || envLower === "1")
opts.usePolling = true;
else
opts.usePolling = !!envLower;
}
const envInterval = process.env.CHOKIDAR_INTERVAL;
if (envInterval)
opts.interval = Number.parseInt(envInterval, 10);
let readyCalls = 0;
this._emitReady = () => {
readyCalls++;
if (readyCalls >= this._readyCount) {
this._emitReady = EMPTY_FN;
this._readyEmitted = true;
process.nextTick(() => this.emit(EVENTS.READY));
}
};
this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
this._boundRemove = this._remove.bind(this);
this.options = opts;
this._nodeFsHandler = new NodeFsHandler(this);
Object.freeze(opts);
}
_addIgnoredPath(matcher) {
if (isMatcherObject(matcher)) {
for (const ignored of this._ignoredPaths) {
if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
return;
}
}
}
this._ignoredPaths.add(matcher);
}
_removeIgnoredPath(matcher) {
this._ignoredPaths.delete(matcher);
if (typeof matcher === "string") {
for (const ignored of this._ignoredPaths) {
if (isMatcherObject(ignored) && ignored.path === matcher) {
this._ignoredPaths.delete(ignored);
}
}
}
}
// Public methods
/**
* Adds paths to be watched on an existing FSWatcher instance.
* @param paths_ file or file list. Other arguments are unused
*/
add(paths_, _origAdd, _internal) {
const { cwd } = this.options;
this.closed = false;
this._closePromise = void 0;
let paths = unifyPaths(paths_);
if (cwd) {
paths = paths.map((path3) => {
const absPath = getAbsolutePath(path3, cwd);
return absPath;
});
}
paths.forEach((path3) => {
this._removeIgnoredPath(path3);
});
this._userIgnored = void 0;
if (!this._readyCount)
this._readyCount = 0;
this._readyCount += paths.length;
Promise.all(paths.map(async (path3) => {
const res = await this._nodeFsHandler._addToNodeFs(path3, !_internal, void 0, 0, _origAdd);
if (res)
this._emitReady();
return res;
})).then((results) => {
if (this.closed)
return;
results.forEach((item) => {
if (item)
this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
});
});
return this;
}
/**
* Close watchers or start ignoring events from specified paths.
*/
unwatch(paths_) {
if (this.closed)
return this;
const paths = unifyPaths(paths_);
const { cwd } = this.options;
paths.forEach((path3) => {
if (!sysPath2.isAbsolute(path3) && !this._closers.has(path3)) {
if (cwd)
path3 = sysPath2.join(cwd, path3);
path3 = sysPath2.resolve(path3);
}
this._closePath(path3);
this._addIgnoredPath(path3);
if (this._watched.has(path3)) {
this._addIgnoredPath({
path: path3,
recursive: true
});
}
this._userIgnored = void 0;
});
return this;
}
/**
* Close watchers and remove all listeners from watched paths.
*/
close() {
if (this._closePromise) {
return this._closePromise;
}
this.closed = true;
this.removeAllListeners();
const closers = [];
this._closers.forEach((closerList) => closerList.forEach((closer) => {
const promise = closer();
if (promise instanceof Promise)
closers.push(promise);
}));
this._streams.forEach((stream) => stream.destroy());
this._userIgnored = void 0;
this._readyCount = 0;
this._readyEmitted = false;
this._watched.forEach((dirent) => dirent.dispose());
this._closers.clear();
this._watched.clear();
this._streams.clear();
this._symlinkPaths.clear();
this._throttled.clear();
this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
return this._closePromise;
}
/**
* Expose list of watched paths
* @returns for chaining
*/
getWatched() {
const watchList = {};
this._watched.forEach((entry, dir) => {
const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
const index = key || ONE_DOT;
watchList[index] = entry.getChildren().sort();
});
return watchList;
}
emitWithAll(event, args) {
this.emit(event, ...args);
if (event !== EVENTS.ERROR)
this.emit(EVENTS.ALL, event, ...args);
}
// Common helpers
// --------------
/**
* Normalize and emit events.
* Calling _emit DOES NOT MEAN emit() would be called!
* @param event Type of event
* @param path File or directory path
* @param stats arguments to be passed with event
* @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
*/
async _emit(event, path3, stats) {
if (this.closed)
return;
const opts = this.options;
if (isWindows)
path3 = sysPath2.normalize(path3);
if (opts.cwd)
path3 = sysPath2.relative(opts.cwd, path3);
const args = [path3];
if (stats != null)
args.push(stats);
const awf = opts.awaitWriteFinish;
let pw;
if (awf && (pw = this._pendingWrites.get(path3))) {
pw.lastChange = /* @__PURE__ */ new Date();
return this;
}
if (opts.atomic) {
if (event === EVENTS.UNLINK) {
this._pendingUnlinks.set(path3, [event, ...args]);
setTimeout(() => {
this._pendingUnlinks.forEach((entry, path4) => {
this.emit(...entry);
this.emit(EVENTS.ALL, ...entry);
this._pendingUnlinks.delete(path4);
});
}, typeof opts.atomic === "number" ? opts.atomic : 100);
return this;
}
if (event === EVENTS.ADD && this._pendingUnlinks.has(path3)) {
event = EVENTS.CHANGE;
this._pendingUnlinks.delete(path3);
}
}
if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
const awfEmit = (err, stats2) => {
if (err) {
event = EVENTS.ERROR;
args[0] = err;
this.emitWithAll(event, args);
} else if (stats2) {
if (args.length > 1) {
args[1] = stats2;
} else {
args.push(stats2);
}
this.emitWithAll(event, args);
}
};
this._awaitWriteFinish(path3, awf.stabilityThreshold, event, awfEmit);
return this;
}
if (event === EVENTS.CHANGE) {
const isThrottled = !this._throttle(EVENTS.CHANGE, path3, 50);
if (isThrottled)
return this;
}
if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path3) : path3;
let stats2;
try {
stats2 = await (0, import_promises3.stat)(fullPath);
} catch (err) {
}
if (!stats2 || this.closed)
return;
args.push(stats2);
}
this.emitWithAll(event, args);
return this;
}
/**
* Common handler for errors
* @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
*/
_handleError(error) {
const code = error && error.code;
if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
this.emit(EVENTS.ERROR, error);
}
return error || this.closed;
}
/**
* Helper utility for throttling
* @param actionType type being throttled
* @param path being acted upon
* @param timeout duration of time to suppress duplicate actions
* @returns tracking object or false if action should be suppressed
*/
_throttle(actionType, path3, timeout) {
if (!this._throttled.has(actionType)) {
this._throttled.set(actionType, /* @__PURE__ */ new Map());
}
const action = this._throttled.get(actionType);
if (!action)
throw new Error("invalid throttle");
const actionPath = action.get(path3);
if (actionPath) {
actionPath.count++;
return false;
}
let timeoutObject;
const clear = () => {
const item = action.get(path3);
const count = item ? item.count : 0;
action.delete(path3);
clearTimeout(timeoutObject);
if (item)
clearTimeout(item.timeoutObject);
return count;
};
timeoutObject = setTimeout(clear, timeout);
const thr = { timeoutObject, clear, count: 0 };
action.set(path3, thr);
return thr;
}
_incrReadyCount() {
return this._readyCount++;
}
/**
* Awaits write operation to finish.
* Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
* @param path being acted upon
* @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
* @param event
* @param awfEmit Callback to be called when ready for event to be emitted.
*/
_awaitWriteFinish(path3, threshold, event, awfEmit) {
const awf = this.options.awaitWriteFinish;
if (typeof awf !== "object")
return;
const pollInterval = awf.pollInterval;
let timeoutHandler;
let fullPath = path3;
if (this.options.cwd && !sysPath2.isAbsolute(path3)) {
fullPath = sysPath2.join(this.options.cwd, path3);
}
const now = /* @__PURE__ */ new Date();
const writes = this._pendingWrites;
function awaitWriteFinishFn(prevStat) {
(0, import_fs2.stat)(fullPath, (err, curStat) => {
if (err || !writes.has(path3)) {
if (err && err.code !== "ENOENT")
awfEmit(err);
return;
}
const now2 = Number(/* @__PURE__ */ new Date());
if (prevStat && curStat.size !== prevStat.size) {
writes.get(path3).lastChange = now2;
}
const pw = writes.get(path3);
const df = now2 - pw.lastChange;
if (df >= threshold) {
writes.delete(path3);
awfEmit(void 0, curStat);
} else {
timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
}
});
}
if (!writes.has(path3)) {
writes.set(path3, {
lastChange: now,
cancelWait: () => {
writes.delete(path3);
clearTimeout(timeoutHandler);
return event;
}
});
timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
}
}
/**
* Determines whether user has asked to ignore this path.
*/
_isIgnored(path3, stats) {
if (this.options.atomic && DOT_RE.test(path3))
return true;
if (!this._userIgnored) {
const { cwd } = this.options;
const ign = this.options.ignored;
const ignored = (ign || []).map(normalizeIgnored(cwd));
const ignoredPaths = [...this._ignoredPaths];
const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
this._userIgnored = anymatch(list, void 0);
}
return this._userIgnored(path3, stats);
}
_isntIgnored(path3, stat4) {
return !this._isIgnored(path3, stat4);
}
/**
* Provides a set of common helpers and properties relating to symlink handling.
* @param path file or directory pattern being watched
*/
_getWatchHelpers(path3) {
return new WatchHelper(path3, this.options.followSymlinks, this);
}
// Directory helpers
// -----------------
/**
* Provides directory tracking objects
* @param directory path of the directory
*/
_getWatchedDir(directory) {
const dir = sysPath2.resolve(directory);
if (!this._watched.has(dir))
this._watched.set(dir, new DirEntry(dir, this._boundRemove));
return this._watched.get(dir);
}
// File helpers
// ------------
/**
* Check for read permissions: https://stackoverflow.com/a/11781404/1358405
*/
_hasReadPermissions(stats) {
if (this.options.ignorePermissionErrors)
return true;
return Boolean(Number(stats.mode) & 256);
}
/**
* Handles emitting unlink events for
* files and directories, and via recursion, for
* files and directories within directories that are unlinked
* @param directory within which the following item is located
* @param item base path of item/directory
*/
_remove(directory, item, isDirectory) {
const path3 = sysPath2.join(directory, item);
const fullPath = sysPath2.resolve(path3);
isDirectory = isDirectory != null ? isDirectory : this._watched.has(path3) || this._watched.has(fullPath);
if (!this._throttle("remove", path3, 100))
return;
if (!isDirectory && this._watched.size === 1) {
this.add(directory, item, true);
}
const wp = this._getWatchedDir(path3);
const nestedDirectoryChildren = wp.getChildren();
nestedDirectoryChildren.forEach((nested) => this._remove(path3, nested));
const parent = this._getWatchedDir(directory);
const wasTracked = parent.has(item);
parent.remove(item);
if (this._symlinkPaths.has(fullPath)) {
this._symlinkPaths.delete(fullPath);
}
let relPath = path3;
if (this.options.cwd)
relPath = sysPath2.relative(this.options.cwd, path3);
if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
const event = this._pendingWrites.get(relPath).cancelWait();
if (event === EVENTS.ADD)
return;
}
this._watched.delete(path3);
this._watched.delete(fullPath);
const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
if (wasTracked && !this._isIgnored(path3))
this._emit(eventName, path3);
this._closePath(path3);
}
/**
* Closes all watchers for a path
*/
_closePath(path3) {
this._closeFile(path3);
const dir = sysPath2.dirname(path3);
this._getWatchedDir(dir).remove(sysPath2.basename(path3));
}
/**
* Closes only file-specific watchers
*/
_closeFile(path3) {
const closers = this._closers.get(path3);
if (!closers)
return;
closers.forEach((closer) => closer());
this._closers.delete(path3);
}
_addPathCloser(path3, closer) {
if (!closer)
return;
let list = this._closers.get(path3);
if (!list) {
list = [];
this._closers.set(path3, list);
}
list.push(closer);
}
_readdirp(root, opts) {
if (this.closed)
return;
const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
let stream = readdirp(root, options);
this._streams.add(stream);
stream.once(STR_CLOSE, () => {
stream = void 0;
});
stream.once(STR_END, () => {
if (stream) {
this._streams.delete(stream);
stream = void 0;
}
});
return stream;
}
};
function watch(paths, options = {}) {
const watcher = new FSWatcher(options);
watcher.add(paths);
return watcher;
}
var esm_default = { watch, FSWatcher };
// packages/playwright-core/src/package.ts
var import_path = __toESM(require("path"));
var packageRoot = import_path.default.join(__dirname, "..");
var packageJSON = require(import_path.default.join(packageRoot, "package.json"));
var binPath = import_path.default.join(packageRoot, "bin");
// packages/playwright-core/src/serverRegistry.ts
var packageVersion = packageJSON.version;
var ServerRegistry = class extends import_events2.EventEmitter {
constructor() {
super(...arguments);
this._descriptors = /* @__PURE__ */ new Map();
this._watcherRefs = 0;
}
on(event, listener) {
return super.on(event, listener);
}
off(event, listener) {
return super.off(event, listener);
}
watch() {
this._watcherRefs++;
if (!this._watcher)
this._startWatcher();
let disposed = false;
return () => {
if (disposed)
return;
disposed = true;
this._watcherRefs--;
if (this._watcherRefs === 0)
this._stopWatcher();
};
}
ready() {
return this._ready ?? Promise.resolve();
}
async list() {
const ownWatcher = !this._watcher;
let dispose;
if (ownWatcher)
dispose = this.watch();
try {
await this._ready;
const statuses = await Promise.all(
[...this._descriptors.values()].map(async (descriptor) => {
const canConnect = await canConnectTo(descriptor);
return { descriptor, canConnect };
})
);
const result = /* @__PURE__ */ new Map();
for (const { descriptor, canConnect } of statuses) {
if (!canConnect) {
await import_fs3.default.promises.unlink(import_path2.default.join(this._browsersDir(), descriptor.browser.guid)).catch(() => {
});
continue;
}
const key = descriptor.workspaceDir ?? "";
let list = result.get(key);
if (!list) {
list = [];
result.set(key, list);
}
list.push(descriptor);
}
return result;
} finally {
dispose?.();
}
}
async create(browser, endpoint) {
const file = import_path2.default.join(this._browsersDir(), browser.guid);
await import_fs3.default.promises.mkdir(this._browsersDir(), { recursive: true });
const descriptor = {
playwrightVersion: packageVersion,
playwrightLib: packageRoot,
title: endpoint.title,
browser,
endpoint: endpoint.endpoint,
workspaceDir: endpoint.workspaceDir
};
await import_fs3.default.promises.writeFile(file, JSON.stringify(descriptor, null, 2), "utf-8");
}
async delete(guid) {
const file = import_path2.default.join(this._browsersDir(), guid);
await import_fs3.default.promises.unlink(file).catch(() => {
});
}
async deleteUserData(guid) {
const filePath = import_path2.default.join(this._browsersDir(), guid);
const content = await import_fs3.default.promises.readFile(filePath, "utf-8");
const descriptor = JSON.parse(content);
if (descriptor.browser.userDataDir)
await import_fs3.default.promises.rm(descriptor.browser.userDataDir, { recursive: true, force: true });
await import_fs3.default.promises.unlink(filePath);
}
readDescriptor(guid) {
const cached = this._descriptors.get(guid);
if (cached)
return cached;
const filePath = import_path2.default.join(this._browsersDir(), guid);
const content = import_fs3.default.readFileSync(filePath, "utf-8");
return JSON.parse(content);
}
async find(name) {
const entries = await this.list();
for (const [, browsers] of entries) {
for (const browser of browsers) {
if (browser.title === name)
return browser;
}
}
return null;
}
_browsersDir() {
return process.env.PWTEST_SERVER_REGISTRY || registryDirectory();
}
_startWatcher() {
const dir = this._browsersDir();
try {
import_fs3.default.mkdirSync(dir, { recursive: true });
} catch {
}
const watcher = esm_default.watch(dir, {
ignoreInitial: false,
depth: 0,
awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 20 }
});
this._watcher = watcher;
this._ready = new Promise((resolve3, reject) => {
watcher.once("ready", () => resolve3());
watcher.once("error", reject);
});
watcher.on("add", (file) => this._onAddOrChange(file, "added"));
watcher.on("change", (file) => this._onAddOrChange(file, "changed"));
watcher.on("unlink", (file) => {
const guid = import_path2.default.basename(file);
if (this._descriptors.delete(guid))
this.emit("removed", guid);
});
}
_onAddOrChange(file, event) {
const guid = import_path2.default.basename(file);
let descriptor;
try {
descriptor = JSON.parse(import_fs3.default.readFileSync(file, "utf-8"));
} catch {
return;
}
this._descriptors.set(guid, descriptor);
this.emit(event, descriptor);
}
_stopWatcher() {
const watcher = this._watcher;
this._watcher = void 0;
this._ready = void 0;
this._descriptors.clear();
void watcher?.close();
}
};
async function canConnectTo(descriptor) {
if (!descriptor.endpoint)
return false;
if (descriptor.endpoint.startsWith("ws://") || descriptor.endpoint.startsWith("wss://")) {
return await new Promise((resolve3) => {
const url = new URL(descriptor.endpoint);
const socket = import_net.default.createConnection(Number(url.port), url.hostname, () => {
socket.destroy();
resolve3(true);
});
socket.on("error", () => resolve3(false));
});
}
return await new Promise((resolve3) => {
const socket = import_net.default.createConnection(descriptor.endpoint ?? descriptor.pipeName, () => {
socket.destroy();
resolve3(true);
});
socket.on("error", () => resolve3(false));
});
}
function computeDefaultCacheDirectory() {
if (process.platform === "linux")
return process.env.XDG_CACHE_HOME || import_path2.default.join(import_os2.default.homedir(), ".cache");
if (process.platform === "darwin")
return import_path2.default.join(import_os2.default.homedir(), "Library", "Caches");
if (process.platform === "win32")
return process.env.LOCALAPPDATA || import_path2.default.join(import_os2.default.homedir(), "AppData", "Local");
throw new Error("Unsupported platform: " + process.platform);
}
var _defaultCacheDirectory;
function defaultCacheDirectory() {
return _defaultCacheDirectory ??= computeDefaultCacheDirectory();
}
function registryDirectory() {
return import_path2.default.join(defaultCacheDirectory(), "ms-playwright", "b");
}
var serverRegistry = new ServerRegistry();
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
serverRegistry
});
/*! Bundled license information:
chokidar/esm/index.js:
(*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
*/