@stablyai/internal-playwright 0.1.0

package/lib/transform/compilationCache.js

@@ -0,0 +1,272 @@
+"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);
+var compilationCache_exports = {};
+__export(compilationCache_exports, {
+  addToCompilationCache: () => addToCompilationCache,
+  affectedTestFiles: () => affectedTestFiles,
+  belongsToNodeModules: () => belongsToNodeModules,
+  cacheDir: () => cacheDir,
+  collectAffectedTestFiles: () => collectAffectedTestFiles,
+  currentFileDepsCollector: () => currentFileDepsCollector,
+  dependenciesForTestFile: () => dependenciesForTestFile,
+  fileDependenciesForTest: () => fileDependenciesForTest,
+  getFromCompilationCache: () => getFromCompilationCache,
+  getUserData: () => getUserData,
+  installSourceMapSupport: () => installSourceMapSupport,
+  internalDependenciesForTestFile: () => internalDependenciesForTestFile,
+  serializeCompilationCache: () => serializeCompilationCache,
+  setExternalDependencies: () => setExternalDependencies,
+  startCollectingFileDeps: () => startCollectingFileDeps,
+  stopCollectingFileDeps: () => stopCollectingFileDeps
+});
+module.exports = __toCommonJS(compilationCache_exports);
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_utils = require("playwright-core/lib/utils");
+var import_globals = require("../common/globals");
+var import_utilsBundle = require("../utilsBundle");
+const cacheDir = process.env.PWTEST_CACHE_DIR || (() => {
+  if (process.platform === "win32")
+    return import_path.default.join(import_os.default.tmpdir(), `playwright-transform-cache`);
+  return import_path.default.join(import_os.default.tmpdir(), `playwright-transform-cache-` + process.geteuid?.());
+})();
+const sourceMaps = /* @__PURE__ */ new Map();
+const memoryCache = /* @__PURE__ */ new Map();
+const fileDependencies = /* @__PURE__ */ new Map();
+const externalDependencies = /* @__PURE__ */ new Map();
+function installSourceMapSupport() {
+  Error.stackTraceLimit = 200;
+  import_utilsBundle.sourceMapSupport.install({
+    environment: "node",
+    handleUncaughtExceptions: false,
+    retrieveSourceMap(source) {
+      if (!sourceMaps.has(source))
+        return null;
+      const sourceMapPath = sourceMaps.get(source);
+      try {
+        return {
+          map: JSON.parse(import_fs.default.readFileSync(sourceMapPath, "utf-8")),
+          url: source
+        };
+      } catch {
+        return null;
+      }
+    }
+  });
+}
+function _innerAddToCompilationCacheAndSerialize(filename, entry) {
+  sourceMaps.set(entry.moduleUrl || filename, entry.sourceMapPath);
+  memoryCache.set(filename, entry);
+  return {
+    sourceMaps: [[entry.moduleUrl || filename, entry.sourceMapPath]],
+    memoryCache: [[filename, entry]],
+    fileDependencies: [],
+    externalDependencies: []
+  };
+}
+function getFromCompilationCache(filename, contentHash, moduleUrl) {
+  const cache = memoryCache.get(filename);
+  if (cache?.codePath) {
+    try {
+      return { cachedCode: import_fs.default.readFileSync(cache.codePath, "utf-8") };
+    } catch {
+    }
+  }
+  const filePathHash = calculateFilePathHash(filename);
+  const hashPrefix = filePathHash + "_" + contentHash.substring(0, 7);
+  const cacheFolderName = filePathHash.substring(0, 2);
+  const cachePath = calculateCachePath(filename, cacheFolderName, hashPrefix);
+  const codePath = cachePath + ".js";
+  const sourceMapPath = cachePath + ".map";
+  const dataPath = cachePath + ".data";
+  try {
+    const cachedCode = import_fs.default.readFileSync(codePath, "utf8");
+    const serializedCache = _innerAddToCompilationCacheAndSerialize(filename, { codePath, sourceMapPath, dataPath, moduleUrl });
+    return { cachedCode, serializedCache };
+  } catch {
+  }
+  return {
+    addToCache: (code, map, data) => {
+      if ((0, import_globals.isWorkerProcess)())
+        return {};
+      clearOldCacheEntries(cacheFolderName, filePathHash);
+      import_fs.default.mkdirSync(import_path.default.dirname(cachePath), { recursive: true });
+      if (map)
+        import_fs.default.writeFileSync(sourceMapPath, JSON.stringify(map), "utf8");
+      if (data.size)
+        import_fs.default.writeFileSync(dataPath, JSON.stringify(Object.fromEntries(data.entries()), void 0, 2), "utf8");
+      import_fs.default.writeFileSync(codePath, code, "utf8");
+      const serializedCache = _innerAddToCompilationCacheAndSerialize(filename, { codePath, sourceMapPath, dataPath, moduleUrl });
+      return { serializedCache };
+    }
+  };
+}
+function serializeCompilationCache() {
+  return {
+    sourceMaps: [...sourceMaps.entries()],
+    memoryCache: [...memoryCache.entries()],
+    fileDependencies: [...fileDependencies.entries()].map(([filename, deps]) => [filename, [...deps]]),
+    externalDependencies: [...externalDependencies.entries()].map(([filename, deps]) => [filename, [...deps]])
+  };
+}
+function addToCompilationCache(payload) {
+  for (const entry of payload.sourceMaps)
+    sourceMaps.set(entry[0], entry[1]);
+  for (const entry of payload.memoryCache)
+    memoryCache.set(entry[0], entry[1]);
+  for (const entry of payload.fileDependencies) {
+    const existing = fileDependencies.get(entry[0]) || [];
+    fileDependencies.set(entry[0], /* @__PURE__ */ new Set([...entry[1], ...existing]));
+  }
+  for (const entry of payload.externalDependencies) {
+    const existing = externalDependencies.get(entry[0]) || [];
+    externalDependencies.set(entry[0], /* @__PURE__ */ new Set([...entry[1], ...existing]));
+  }
+}
+function calculateFilePathHash(filePath) {
+  return (0, import_utils.calculateSha1)(filePath).substring(0, 10);
+}
+function calculateCachePath(filePath, cacheFolderName, hashPrefix) {
+  const fileName = hashPrefix + "_" + import_path.default.basename(filePath, import_path.default.extname(filePath)).replace(/\W/g, "");
+  return import_path.default.join(cacheDir, cacheFolderName, fileName);
+}
+function clearOldCacheEntries(cacheFolderName, filePathHash) {
+  const cachePath = import_path.default.join(cacheDir, cacheFolderName);
+  try {
+    const cachedRelevantFiles = import_fs.default.readdirSync(cachePath).filter((file) => file.startsWith(filePathHash));
+    for (const file of cachedRelevantFiles)
+      import_fs.default.rmSync(import_path.default.join(cachePath, file), { force: true });
+  } catch {
+  }
+}
+let depsCollector;
+function startCollectingFileDeps() {
+  depsCollector = /* @__PURE__ */ new Set();
+}
+function stopCollectingFileDeps(filename) {
+  if (!depsCollector)
+    return;
+  depsCollector.delete(filename);
+  for (const dep of depsCollector) {
+    if (belongsToNodeModules(dep))
+      depsCollector.delete(dep);
+  }
+  fileDependencies.set(filename, depsCollector);
+  depsCollector = void 0;
+}
+function currentFileDepsCollector() {
+  return depsCollector;
+}
+function setExternalDependencies(filename, deps) {
+  const depsSet = new Set(deps.filter((dep) => !belongsToNodeModules(dep) && dep !== filename));
+  externalDependencies.set(filename, depsSet);
+}
+function fileDependenciesForTest() {
+  return fileDependencies;
+}
+function collectAffectedTestFiles(changedFile, testFileCollector) {
+  const isTestFile = (file) => fileDependencies.has(file);
+  if (isTestFile(changedFile))
+    testFileCollector.add(changedFile);
+  for (const [testFile, deps] of fileDependencies) {
+    if (deps.has(changedFile))
+      testFileCollector.add(testFile);
+  }
+  for (const [importingFile, depsOfImportingFile] of externalDependencies) {
+    if (depsOfImportingFile.has(changedFile)) {
+      if (isTestFile(importingFile))
+        testFileCollector.add(importingFile);
+      for (const [testFile, depsOfTestFile] of fileDependencies) {
+        if (depsOfTestFile.has(importingFile))
+          testFileCollector.add(testFile);
+      }
+    }
+  }
+}
+function affectedTestFiles(changes) {
+  const result = /* @__PURE__ */ new Set();
+  for (const change of changes)
+    collectAffectedTestFiles(change, result);
+  return [...result];
+}
+function internalDependenciesForTestFile(filename) {
+  return fileDependencies.get(filename);
+}
+function dependenciesForTestFile(filename) {
+  const result = /* @__PURE__ */ new Set();
+  for (const testDependency of fileDependencies.get(filename) || []) {
+    result.add(testDependency);
+    for (const externalDependency of externalDependencies.get(testDependency) || [])
+      result.add(externalDependency);
+  }
+  for (const dep of externalDependencies.get(filename) || [])
+    result.add(dep);
+  return result;
+}
+const kPlaywrightInternalPrefix = import_path.default.resolve(__dirname, "../../../playwright");
+function belongsToNodeModules(file) {
+  if (file.includes(`${import_path.default.sep}node_modules${import_path.default.sep}`))
+    return true;
+  if (file.startsWith(kPlaywrightInternalPrefix) && (file.endsWith(".js") || file.endsWith(".mjs")))
+    return true;
+  return false;
+}
+async function getUserData(pluginName) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [fileName, cache] of memoryCache) {
+    if (!cache.dataPath)
+      continue;
+    if (!import_fs.default.existsSync(cache.dataPath))
+      continue;
+    const data = JSON.parse(await import_fs.default.promises.readFile(cache.dataPath, "utf8"));
+    if (data[pluginName])
+      result.set(fileName, data[pluginName]);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addToCompilationCache,
+  affectedTestFiles,
+  belongsToNodeModules,
+  cacheDir,
+  collectAffectedTestFiles,
+  currentFileDepsCollector,
+  dependenciesForTestFile,
+  fileDependenciesForTest,
+  getFromCompilationCache,
+  getUserData,
+  installSourceMapSupport,
+  internalDependenciesForTestFile,
+  serializeCompilationCache,
+  setExternalDependencies,
+  startCollectingFileDeps,
+  stopCollectingFileDeps
+});

package/lib/transform/compilationCache.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/transform/compilationCache.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport fs from 'fs';\nimport os from 'os';\nimport path from 'path';\n\nimport { isWorkerProcess } from '../common/globals';\nimport { sourceMapSupport } from '../utilsBundle';\n\nexport type MemoryCache = {\n  codePath: string;\n  sourceMapPath: string;\n  dataPath: string;\n  moduleUrl?: string;\n};\n\nexport type SerializedCompilationCache = {\n  sourceMaps: [string, string][],\n  memoryCache: [string, MemoryCache][],\n  fileDependencies: [string, string[]][],\n  externalDependencies: [string, string[]][],\n};\n\n// Assumptions for the compilation cache:\n// - Files in the temp directory we work with can disappear at any moment, either some of them or all together.\n// - Multiple workers can be trying to read from the compilation cache at the same time.\n// - There is a single invocation of the test runner at a time.\n//\n// Therefore, we implement the following logic:\n// - Never assume that file is present, always try to read it to determine whether it's actually present.\n// - Never write to the cache from worker processes to avoid \"multiple writers\" races.\n// - Since we perform all static imports in the runner beforehand, most of the time\n//   workers should be able to read from the cache.\n// - For workers-only dynamic imports or some cache problems, we will re-transpile files in\n//   each worker anew.\n\nexport const cacheDir = process.env.PWTEST_CACHE_DIR || (() => {\n  if (process.platform === 'win32')\n    return path.join(os.tmpdir(), `playwright-transform-cache`);\n  // Use `geteuid()` instead of more natural `os.userInfo().username`\n  // since `os.userInfo()` is not always available.\n  // Note: `process.geteuid()` is not available on windows.\n  // See https://github.com/microsoft/playwright/issues/22721\n  return path.join(os.tmpdir(), `playwright-transform-cache-` + process.geteuid?.());\n})();\n\nconst sourceMaps: Map<string, string> = new Map();\nconst memoryCache = new Map<string, MemoryCache>();\n// Dependencies resolved by the loader.\nconst fileDependencies = new Map<string, Set<string>>();\n// Dependencies resolved by the external bundler.\nconst externalDependencies = new Map<string, Set<string>>();\n\nexport function installSourceMapSupport() {\n  Error.stackTraceLimit = 200;\n\n  sourceMapSupport.install({\n    environment: 'node',\n    handleUncaughtExceptions: false,\n    retrieveSourceMap(source) {\n      if (!sourceMaps.has(source))\n        return null;\n      const sourceMapPath = sourceMaps.get(source)!;\n      try {\n        return {\n          map: JSON.parse(fs.readFileSync(sourceMapPath, 'utf-8')),\n          url: source,\n        };\n      } catch {\n        return null;\n      }\n    }\n  });\n}\n\nfunction _innerAddToCompilationCacheAndSerialize(filename: string, entry: MemoryCache) {\n  sourceMaps.set(entry.moduleUrl || filename, entry.sourceMapPath);\n  memoryCache.set(filename, entry);\n  return {\n    sourceMaps: [[entry.moduleUrl || filename, entry.sourceMapPath]],\n    memoryCache: [[filename, entry]],\n    fileDependencies: [],\n    externalDependencies: [],\n  };\n}\n\ntype CompilationCacheLookupResult = {\n  serializedCache?: any;\n  cachedCode?: string;\n  addToCache?: (code: string, map: any | undefined | null, data: Map<string, any>) => { serializedCache?: any };\n};\n\nexport function getFromCompilationCache(filename: string, hash: string, moduleUrl?: string): CompilationCacheLookupResult {\n  // First check the memory cache by filename, this cache will always work in the worker,\n  // because we just compiled this file in the loader.\n  const cache = memoryCache.get(filename);\n  if (cache?.codePath) {\n    try {\n      return { cachedCode: fs.readFileSync(cache.codePath, 'utf-8') };\n    } catch {\n      // Not able to read the file - fall through.\n    }\n  }\n\n  // Then do the disk cache, this cache works between the Playwright Test runs.\n  const cachePath = calculateCachePath(filename, hash);\n  const codePath = cachePath + '.js';\n  const sourceMapPath = cachePath + '.map';\n  const dataPath = cachePath + '.data';\n  try {\n    const cachedCode = fs.readFileSync(codePath, 'utf8');\n    const serializedCache = _innerAddToCompilationCacheAndSerialize(filename, { codePath, sourceMapPath, dataPath, moduleUrl });\n    return { cachedCode, serializedCache };\n  } catch {\n  }\n\n  return {\n    addToCache: (code: string, map: any | undefined | null, data: Map<string, any>) => {\n      if (isWorkerProcess())\n        return {};\n      fs.mkdirSync(path.dirname(cachePath), { recursive: true });\n      if (map)\n        fs.writeFileSync(sourceMapPath, JSON.stringify(map), 'utf8');\n      if (data.size)\n        fs.writeFileSync(dataPath, JSON.stringify(Object.fromEntries(data.entries()), undefined, 2), 'utf8');\n      fs.writeFileSync(codePath, code, 'utf8');\n      const serializedCache = _innerAddToCompilationCacheAndSerialize(filename, { codePath, sourceMapPath, dataPath, moduleUrl });\n      return { serializedCache };\n    }\n  };\n}\n\nexport function serializeCompilationCache(): SerializedCompilationCache {\n  return {\n    sourceMaps: [...sourceMaps.entries()],\n    memoryCache: [...memoryCache.entries()],\n    fileDependencies: [...fileDependencies.entries()].map(([filename, deps]) => ([filename, [...deps]])),\n    externalDependencies: [...externalDependencies.entries()].map(([filename, deps]) => ([filename, [...deps]])),\n  };\n}\n\nexport function addToCompilationCache(payload: SerializedCompilationCache) {\n  for (const entry of payload.sourceMaps)\n    sourceMaps.set(entry[0], entry[1]);\n  for (const entry of payload.memoryCache)\n    memoryCache.set(entry[0], entry[1]);\n  for (const entry of payload.fileDependencies) {\n    const existing = fileDependencies.get(entry[0]) || [];\n    fileDependencies.set(entry[0], new Set([...entry[1], ...existing]));\n  }\n  for (const entry of payload.externalDependencies) {\n    const existing = externalDependencies.get(entry[0]) || [];\n    externalDependencies.set(entry[0], new Set([...entry[1], ...existing]));\n  }\n}\n\nfunction calculateCachePath(filePath: string, hash: string): string {\n  const fileName = path.basename(filePath, path.extname(filePath)).replace(/\\W/g, '') + '_' + hash;\n  return path.join(cacheDir, hash[0] + hash[1], fileName);\n}\n\n// Since ESM and CJS collect dependencies differently,\n// we go via the global state to collect them.\nlet depsCollector: Set<string> | undefined;\n\nexport function startCollectingFileDeps() {\n  depsCollector = new Set();\n}\n\nexport function stopCollectingFileDeps(filename: string) {\n  if (!depsCollector)\n    return;\n  depsCollector.delete(filename);\n  for (const dep of depsCollector) {\n    if (belongsToNodeModules(dep))\n      depsCollector.delete(dep);\n  }\n  fileDependencies.set(filename, depsCollector);\n  depsCollector = undefined;\n}\n\nexport function currentFileDepsCollector(): Set<string> | undefined {\n  return depsCollector;\n}\n\nexport function setExternalDependencies(filename: string, deps: string[]) {\n  const depsSet = new Set(deps.filter(dep => !belongsToNodeModules(dep) && dep !== filename));\n  externalDependencies.set(filename, depsSet);\n}\n\nexport function fileDependenciesForTest() {\n  return fileDependencies;\n}\n\nexport function collectAffectedTestFiles(changedFile: string, testFileCollector: Set<string>) {\n  const isTestFile = (file: string) => fileDependencies.has(file);\n\n  if (isTestFile(changedFile))\n    testFileCollector.add(changedFile);\n\n  for (const [testFile, deps] of fileDependencies) {\n    if (deps.has(changedFile))\n      testFileCollector.add(testFile);\n  }\n\n  for (const [importingFile, depsOfImportingFile] of externalDependencies) {\n    if (depsOfImportingFile.has(changedFile)) {\n      if (isTestFile(importingFile))\n        testFileCollector.add(importingFile);\n\n      for (const [testFile, depsOfTestFile] of fileDependencies) {\n        if (depsOfTestFile.has(importingFile))\n          testFileCollector.add(testFile);\n      }\n    }\n  }\n}\n\nexport function affectedTestFiles(changes: string[]): string[] {\n  const result = new Set<string>();\n  for (const change of changes)\n    collectAffectedTestFiles(change, result);\n  return [...result];\n}\n\nexport function internalDependenciesForTestFile(filename: string): Set<string> | undefined{\n  return fileDependencies.get(filename);\n}\n\nexport function dependenciesForTestFile(filename: string): Set<string> {\n  const result = new Set<string>();\n  for (const testDependency of fileDependencies.get(filename) || []) {\n    result.add(testDependency);\n    for (const externalDependency of externalDependencies.get(testDependency) || [])\n      result.add(externalDependency);\n  }\n  for (const dep of externalDependencies.get(filename) || [])\n    result.add(dep);\n  return result;\n}\n\n// This is only used in the dev mode, specifically excluding\n// files from packages/playwright*. In production mode, node_modules covers\n// that.\nconst kPlaywrightInternalPrefix = path.resolve(__dirname, '../../../playwright');\n\nexport function belongsToNodeModules(file: string) {\n  if (file.includes(`${path.sep}node_modules${path.sep}`))\n    return true;\n  if (file.startsWith(kPlaywrightInternalPrefix) && (file.endsWith('.js') || file.endsWith('.mjs')))\n    return true;\n  return false;\n}\n\nexport async function getUserData(pluginName: string): Promise<Map<string, any>> {\n  const result = new Map<string, any>();\n  for (const [fileName, cache] of memoryCache) {\n    if (!cache.dataPath)\n      continue;\n    if (!fs.existsSync(cache.dataPath))\n      continue;\n    const data = JSON.parse(await fs.promises.readFile(cache.dataPath, 'utf8'));\n    if (data[pluginName])\n      result.set(fileName, data[pluginName]);\n  }\n  return result;\n}\n"],
+  "mappings": "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",
+  "names": ["path", "os", "fs"]
+}

package/lib/transform/esmLoader.js

@@ -0,0 +1,104 @@
+"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 __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 import_fs = __toESM(require("fs"));
+var import_url = __toESM(require("url"));
+var import_compilationCache = require("./compilationCache");
+var import_portTransport = require("./portTransport");
+var import_transform = require("./transform");
+var import_util = require("../util");
+async function resolve(specifier, context, defaultResolve) {
+  if (context.parentURL && context.parentURL.startsWith("file://")) {
+    const filename = import_url.default.fileURLToPath(context.parentURL);
+    const resolved = (0, import_transform.resolveHook)(filename, specifier);
+    if (resolved !== void 0)
+      specifier = import_url.default.pathToFileURL(resolved).toString();
+  }
+  const result = await defaultResolve(specifier, context, defaultResolve);
+  if (result?.url && result.url.startsWith("file://"))
+    (0, import_compilationCache.currentFileDepsCollector)()?.add(import_url.default.fileURLToPath(result.url));
+  return result;
+}
+const kSupportedFormats = /* @__PURE__ */ new Map([
+  ["commonjs", "commonjs"],
+  ["module", "module"],
+  ["commonjs-typescript", "commonjs"],
+  ["module-typescript", "module"],
+  [null, null],
+  [void 0, void 0]
+]);
+async function load(moduleUrl, context, defaultLoad) {
+  if (!kSupportedFormats.has(context.format))
+    return defaultLoad(moduleUrl, context, defaultLoad);
+  if (!moduleUrl.startsWith("file://"))
+    return defaultLoad(moduleUrl, context, defaultLoad);
+  const filename = import_url.default.fileURLToPath(moduleUrl);
+  if (!(0, import_transform.shouldTransform)(filename))
+    return defaultLoad(moduleUrl, context, defaultLoad);
+  const code = import_fs.default.readFileSync(filename, "utf-8");
+  const transformed = (0, import_transform.transformHook)(code, filename, moduleUrl);
+  if (transformed.serializedCache) {
+    if (legacyWaitForSourceMaps)
+      await transport?.send("pushToCompilationCache", { cache: transformed.serializedCache });
+    else
+      transport?.post("pushToCompilationCache", { cache: transformed.serializedCache });
+  }
+  return {
+    format: kSupportedFormats.get(context.format) || ((0, import_util.fileIsModule)(filename) ? "module" : "commonjs"),
+    source: transformed.code,
+    shortCircuit: true
+  };
+}
+let transport;
+let legacyWaitForSourceMaps = false;
+function initialize(data) {
+  transport = createTransport(data?.port);
+  legacyWaitForSourceMaps = !!process.env.PLAYWRIGHT_WAIT_FOR_SOURCE_MAPS;
+}
+function createTransport(port) {
+  return new import_portTransport.PortTransport(port, async (method, params) => {
+    if (method === "setSingleTSConfig") {
+      (0, import_transform.setSingleTSConfig)(params.tsconfig);
+      return;
+    }
+    if (method === "setTransformConfig") {
+      (0, import_transform.setTransformConfig)(params.config);
+      return;
+    }
+    if (method === "addToCompilationCache") {
+      (0, import_compilationCache.addToCompilationCache)(params.cache);
+      return;
+    }
+    if (method === "getCompilationCache")
+      return { cache: (0, import_compilationCache.serializeCompilationCache)() };
+    if (method === "startCollectingFileDeps") {
+      (0, import_compilationCache.startCollectingFileDeps)();
+      return;
+    }
+    if (method === "stopCollectingFileDeps") {
+      (0, import_compilationCache.stopCollectingFileDeps)(params.file);
+      return;
+    }
+  });
+}
+module.exports = { initialize, load, resolve };

package/lib/transform/esmLoader.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/transform/esmLoader.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport fs from 'fs';\nimport url from 'url';\n\nimport { addToCompilationCache, currentFileDepsCollector, serializeCompilationCache, startCollectingFileDeps, stopCollectingFileDeps } from './compilationCache';\nimport { PortTransport } from './portTransport';\nimport { resolveHook, setSingleTSConfig, setTransformConfig, shouldTransform, transformHook } from './transform';\nimport { fileIsModule } from '../util';\n\n// Node < 18.6: defaultResolve takes 3 arguments.\n// Node >= 18.6: nextResolve from the chain takes 2 arguments.\nasync function resolve(specifier: string, context: { parentURL?: string }, defaultResolve: Function) {\n  if (context.parentURL && context.parentURL.startsWith('file://')) {\n    const filename = url.fileURLToPath(context.parentURL);\n    const resolved = resolveHook(filename, specifier);\n    if (resolved !== undefined)\n      specifier = url.pathToFileURL(resolved).toString();\n  }\n  const result = await defaultResolve(specifier, context, defaultResolve);\n  // Note: we collect dependencies here that will be sent to the main thread\n  // (and optionally runner process) after the loading finishes.\n  if (result?.url && result.url.startsWith('file://'))\n    currentFileDepsCollector()?.add(url.fileURLToPath(result.url));\n\n  return result;\n}\n\n// non-js files have undefined\n// some js files have null\n// {module/commonjs}-typescript are changed to {module,commonjs} because we handle typescript ourselves\nconst kSupportedFormats = new Map([\n  ['commonjs', 'commonjs'],\n  ['module', 'module'],\n  ['commonjs-typescript', 'commonjs'],\n  ['module-typescript', 'module'],\n  [null, null],\n  [undefined, undefined]\n]);\n\n// Node < 18.6: defaultLoad takes 3 arguments.\n// Node >= 18.6: nextLoad from the chain takes 2 arguments.\nasync function load(moduleUrl: string, context: { format?: string }, defaultLoad: Function) {\n  // Bail out for wasm, json, etc.\n  if (!kSupportedFormats.has(context.format))\n    return defaultLoad(moduleUrl, context, defaultLoad);\n\n  // Bail for built-in modules.\n  if (!moduleUrl.startsWith('file://'))\n    return defaultLoad(moduleUrl, context, defaultLoad);\n\n  const filename = url.fileURLToPath(moduleUrl);\n  // Bail for node_modules.\n  if (!shouldTransform(filename))\n    return defaultLoad(moduleUrl, context, defaultLoad);\n\n  const code = fs.readFileSync(filename, 'utf-8');\n  const transformed = transformHook(code, filename, moduleUrl);\n\n  // Flush the source maps to the main thread, so that errors during import() are source-mapped.\n  if (transformed.serializedCache) {\n    if (legacyWaitForSourceMaps)\n      await transport?.send('pushToCompilationCache', { cache: transformed.serializedCache });\n    else\n      transport?.post('pushToCompilationCache', { cache: transformed.serializedCache });\n  }\n\n  // Output format is required, so we determine it manually when unknown.\n  // shortCircuit is required by Node >= 18.6 to designate no more loaders should be called.\n  return {\n    format: kSupportedFormats.get(context.format) || (fileIsModule(filename) ? 'module' : 'commonjs'),\n    source: transformed.code,\n    shortCircuit: true,\n  };\n}\n\nlet transport: PortTransport | undefined;\nlet legacyWaitForSourceMaps = false;\n\nfunction initialize(data: { port: MessagePort }) {\n  transport = createTransport(data?.port);\n  legacyWaitForSourceMaps = !!process.env.PLAYWRIGHT_WAIT_FOR_SOURCE_MAPS;\n}\n\nfunction createTransport(port: MessagePort) {\n  return new PortTransport(port, async (method, params) => {\n    if (method === 'setSingleTSConfig') {\n      setSingleTSConfig(params.tsconfig);\n      return;\n    }\n\n    if (method === 'setTransformConfig') {\n      setTransformConfig(params.config);\n      return;\n    }\n\n    if (method === 'addToCompilationCache') {\n      addToCompilationCache(params.cache);\n      return;\n    }\n\n    if (method === 'getCompilationCache')\n      return { cache: serializeCompilationCache() };\n\n    if (method === 'startCollectingFileDeps') {\n      startCollectingFileDeps();\n      return;\n    }\n\n    if (method === 'stopCollectingFileDeps') {\n      stopCollectingFileDeps(params.file);\n      return;\n    }\n  });\n}\n\n\nmodule.exports = { initialize, load, resolve };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAgBA,gBAAe;AACf,iBAAgB;AAEhB,8BAA4I;AAC5I,2BAA8B;AAC9B,uBAAmG;AACnG,kBAA6B;AAI7B,eAAe,QAAQ,WAAmB,SAAiC,gBAA0B;AACnG,MAAI,QAAQ,aAAa,QAAQ,UAAU,WAAW,SAAS,GAAG;AAChE,UAAM,WAAW,WAAAA,QAAI,cAAc,QAAQ,SAAS;AACpD,UAAM,eAAW,8BAAY,UAAU,SAAS;AAChD,QAAI,aAAa;AACf,kBAAY,WAAAA,QAAI,cAAc,QAAQ,EAAE,SAAS;AAAA,EACrD;AACA,QAAM,SAAS,MAAM,eAAe,WAAW,SAAS,cAAc;AAGtE,MAAI,QAAQ,OAAO,OAAO,IAAI,WAAW,SAAS;AAChD,0DAAyB,GAAG,IAAI,WAAAA,QAAI,cAAc,OAAO,GAAG,CAAC;AAE/D,SAAO;AACT;AAKA,MAAM,oBAAoB,oBAAI,IAAI;AAAA,EAChC,CAAC,YAAY,UAAU;AAAA,EACvB,CAAC,UAAU,QAAQ;AAAA,EACnB,CAAC,uBAAuB,UAAU;AAAA,EAClC,CAAC,qBAAqB,QAAQ;AAAA,EAC9B,CAAC,MAAM,IAAI;AAAA,EACX,CAAC,QAAW,MAAS;AACvB,CAAC;AAID,eAAe,KAAK,WAAmB,SAA8B,aAAuB;AAE1F,MAAI,CAAC,kBAAkB,IAAI,QAAQ,MAAM;AACvC,WAAO,YAAY,WAAW,SAAS,WAAW;AAGpD,MAAI,CAAC,UAAU,WAAW,SAAS;AACjC,WAAO,YAAY,WAAW,SAAS,WAAW;AAEpD,QAAM,WAAW,WAAAA,QAAI,cAAc,SAAS;AAE5C,MAAI,KAAC,kCAAgB,QAAQ;AAC3B,WAAO,YAAY,WAAW,SAAS,WAAW;AAEpD,QAAM,OAAO,UAAAC,QAAG,aAAa,UAAU,OAAO;AAC9C,QAAM,kBAAc,gCAAc,MAAM,UAAU,SAAS;AAG3D,MAAI,YAAY,iBAAiB;AAC/B,QAAI;AACF,YAAM,WAAW,KAAK,0BAA0B,EAAE,OAAO,YAAY,gBAAgB,CAAC;AAAA;AAEtF,iBAAW,KAAK,0BAA0B,EAAE,OAAO,YAAY,gBAAgB,CAAC;AAAA,EACpF;AAIA,SAAO;AAAA,IACL,QAAQ,kBAAkB,IAAI,QAAQ,MAAM,UAAM,0BAAa,QAAQ,IAAI,WAAW;AAAA,IACtF,QAAQ,YAAY;AAAA,IACpB,cAAc;AAAA,EAChB;AACF;AAEA,IAAI;AACJ,IAAI,0BAA0B;AAE9B,SAAS,WAAW,MAA6B;AAC/C,cAAY,gBAAgB,MAAM,IAAI;AACtC,4BAA0B,CAAC,CAAC,QAAQ,IAAI;AAC1C;AAEA,SAAS,gBAAgB,MAAmB;AAC1C,SAAO,IAAI,mCAAc,MAAM,OAAO,QAAQ,WAAW;AACvD,QAAI,WAAW,qBAAqB;AAClC,8CAAkB,OAAO,QAAQ;AACjC;AAAA,IACF;AAEA,QAAI,WAAW,sBAAsB;AACnC,+CAAmB,OAAO,MAAM;AAChC;AAAA,IACF;AAEA,QAAI,WAAW,yBAAyB;AACtC,yDAAsB,OAAO,KAAK;AAClC;AAAA,IACF;AAEA,QAAI,WAAW;AACb,aAAO,EAAE,WAAO,mDAA0B,EAAE;AAE9C,QAAI,WAAW,2BAA2B;AACxC,2DAAwB;AACxB;AAAA,IACF;AAEA,QAAI,WAAW,0BAA0B;AACvC,0DAAuB,OAAO,IAAI;AAClC;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAGA,OAAO,UAAU,EAAE,YAAY,MAAM,QAAQ;",
+  "names": ["url", "fs"]
+}

package/lib/transform/esmUtils.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.execArgvWithExperimentalLoaderOptions = execArgvWithExperimentalLoaderOptions;
+exports.execArgvWithoutExperimentalLoaderOptions = execArgvWithoutExperimentalLoaderOptions;
+var _url = _interopRequireDefault(require("url"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const kExperimentalLoaderOptions = ['--no-warnings', `--experimental-loader=${_url.default.pathToFileURL(require.resolve('playwright/lib/transform/esmLoader')).toString()}`];
+function execArgvWithExperimentalLoaderOptions() {
+  return [...process.execArgv, ...kExperimentalLoaderOptions];
+}
+function execArgvWithoutExperimentalLoaderOptions() {
+  return process.execArgv.filter(arg => !kExperimentalLoaderOptions.includes(arg));
+}

package/lib/transform/portTransport.js

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var portTransport_exports = {};
+__export(portTransport_exports, {
+  PortTransport: () => PortTransport
+});
+module.exports = __toCommonJS(portTransport_exports);
+class PortTransport {
+  constructor(port, handler) {
+    this._lastId = 0;
+    this._callbacks = /* @__PURE__ */ new Map();
+    this._port = port;
+    port.addEventListener("message", async (event) => {
+      const message = event.data;
+      const { id, ackId, method, params, result } = message;
+      if (ackId) {
+        const callback = this._callbacks.get(ackId);
+        this._callbacks.delete(ackId);
+        this._resetRef();
+        callback?.(result);
+        return;
+      }
+      const handlerResult = await handler(method, params);
+      if (id)
+        this._port.postMessage({ ackId: id, result: handlerResult });
+    });
+    this._resetRef();
+  }
+  post(method, params) {
+    this._port.postMessage({ method, params });
+  }
+  async send(method, params) {
+    return await new Promise((f) => {
+      const id = ++this._lastId;
+      this._callbacks.set(id, f);
+      this._resetRef();
+      this._port.postMessage({ id, method, params });
+    });
+  }
+  _resetRef() {
+    if (this._callbacks.size) {
+      this._port.ref();
+    } else {
+      this._port.unref();
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PortTransport
+});

package/lib/transform/portTransport.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/transform/portTransport.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport class PortTransport {\n  private _lastId = 0;\n  private _port: MessagePort;\n  private _callbacks = new Map<number, (result: any) => void>();\n\n  constructor(port: MessagePort, handler: (method: string, params: any) => Promise<any>) {\n    this._port = port;\n    port.addEventListener('message', async event => {\n      const message = event.data;\n      const { id, ackId, method, params, result } = message;\n\n      if (ackId) {\n        const callback = this._callbacks.get(ackId);\n        this._callbacks.delete(ackId);\n        this._resetRef();\n        callback?.(result);\n        return;\n      }\n\n      const handlerResult = await handler(method, params);\n      if (id)\n        this._port.postMessage({ ackId: id, result: handlerResult });\n    });\n    // Make sure to unref **after** adding a 'message' event listener.\n    // https://nodejs.org/api/worker_threads.html#portref\n    this._resetRef();\n  }\n\n  post(method: string, params: any) {\n    this._port.postMessage({ method, params });\n  }\n\n  async send(method: string, params: any) {\n    return await new Promise<any>(f => {\n      const id = ++this._lastId;\n      this._callbacks.set(id, f);\n      this._resetRef();\n      this._port.postMessage({ id, method, params });\n    });\n  }\n\n  private _resetRef() {\n    if (this._callbacks.size) {\n      // When we are waiting for a response, ref the port to prevent this process from exiting.\n      (this._port as any).ref();\n    } else {\n      // When we are not waiting for a response, unref the port to prevent this process\n      // from hanging forever.\n      (this._port as any).unref();\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,MAAM,cAAc;AAAA,EAKzB,YAAY,MAAmB,SAAwD;AAJvF,SAAQ,UAAU;AAElB,SAAQ,aAAa,oBAAI,IAAmC;AAG1D,SAAK,QAAQ;AACb,SAAK,iBAAiB,WAAW,OAAM,UAAS;AAC9C,YAAM,UAAU,MAAM;AACtB,YAAM,EAAE,IAAI,OAAO,QAAQ,QAAQ,OAAO,IAAI;AAE9C,UAAI,OAAO;AACT,cAAM,WAAW,KAAK,WAAW,IAAI,KAAK;AAC1C,aAAK,WAAW,OAAO,KAAK;AAC5B,aAAK,UAAU;AACf,mBAAW,MAAM;AACjB;AAAA,MACF;AAEA,YAAM,gBAAgB,MAAM,QAAQ,QAAQ,MAAM;AAClD,UAAI;AACF,aAAK,MAAM,YAAY,EAAE,OAAO,IAAI,QAAQ,cAAc,CAAC;AAAA,IAC/D,CAAC;AAGD,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,KAAK,QAAgB,QAAa;AAChC,SAAK,MAAM,YAAY,EAAE,QAAQ,OAAO,CAAC;AAAA,EAC3C;AAAA,EAEA,MAAM,KAAK,QAAgB,QAAa;AACtC,WAAO,MAAM,IAAI,QAAa,OAAK;AACjC,YAAM,KAAK,EAAE,KAAK;AAClB,WAAK,WAAW,IAAI,IAAI,CAAC;AACzB,WAAK,UAAU;AACf,WAAK,MAAM,YAAY,EAAE,IAAI,QAAQ,OAAO,CAAC;AAAA,IAC/C,CAAC;AAAA,EACH;AAAA,EAEQ,YAAY;AAClB,QAAI,KAAK,WAAW,MAAM;AAExB,MAAC,KAAK,MAAc,IAAI;AAAA,IAC1B,OAAO;AAGL,MAAC,KAAK,MAAc,MAAM;AAAA,IAC5B;AAAA,EACF;AACF;",
+  "names": []
+}