@smoothdeploy/playwright 1.57.1 → 1.58.1-beta-1770383926000

package/lib/transform/compilationCache.js

@@ -67,6 +67,8 @@ function installSourceMapSupport() {
     environment: "node",
     handleUncaughtExceptions: false,
     retrieveSourceMap(source) {
+      if (source.startsWith("file://") && !sourceMaps.has(source))
+        source = source.substring("file://".length);
       if (!sourceMaps.has(source))
         return null;
       const sourceMapPath = sourceMaps.get(source);

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 { calculateSha1 } from 'playwright-core/lib/utils';\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, contentHash: 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 filePathHash = calculateFilePathHash(filename);\n  const hashPrefix = filePathHash + '_' + contentHash.substring(0, 7);\n  const cacheFolderName = filePathHash.substring(0, 2);\n  const cachePath = calculateCachePath(filename, cacheFolderName, hashPrefix);\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      // Trim cache. This won't help with deleted files, but it will remove storing multiple copies of the same file\n      clearOldCacheEntries(cacheFolderName, filePathHash);\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 calculateFilePathHash(filePath: string): string {\n  // Larger file path hash allows for fewer collisions compared to content, as we only check file path collision for deleting files\n  return calculateSha1(filePath).substring(0, 10);\n}\n\nfunction calculateCachePath(filePath: string, cacheFolderName: string, hashPrefix: string): string {\n  const fileName = hashPrefix + '_' + path.basename(filePath, path.extname(filePath)).replace(/\\W/g, '');\n  return path.join(cacheDir, cacheFolderName, fileName);\n}\n\nfunction clearOldCacheEntries(cacheFolderName: string, filePathHash: string) {\n  const cachePath = path.join(cacheDir, cacheFolderName);\n  try {\n    const cachedRelevantFiles = fs.readdirSync(cachePath).filter(file => file.startsWith(filePathHash));\n    for (const file of cachedRelevantFiles)\n      fs.rmSync(path.join(cachePath, file), { force: true });\n  } catch {\n  }\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

@@ -27,7 +27,9 @@ 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) {
+const esmPreflightExtension = ".esm.preflight";
+async function resolve(originalSpecifier, context, defaultResolve) {
+  let specifier = originalSpecifier.replace(esmPreflightExtension, "");
   if (context.parentURL && context.parentURL.startsWith("file://")) {
     const filename = import_url.default.fileURLToPath(context.parentURL);
     const resolved = (0, import_transform.resolveHook)(filename, specifier);
@@ -37,6 +39,8 @@ async function resolve(specifier, context, defaultResolve) {
   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));
+  if (originalSpecifier.endsWith(esmPreflightExtension))
+    result.url = result.url + esmPreflightExtension;
   return result;
 }
 const kSupportedFormats = /* @__PURE__ */ new Map([
@@ -47,7 +51,8 @@ const kSupportedFormats = /* @__PURE__ */ new Map([
   [null, null],
   [void 0, void 0]
 ]);
-async function load(moduleUrl, context, defaultLoad) {
+async function load(originalModuleUrl, context, defaultLoad) {
+  const moduleUrl = originalModuleUrl.replace(esmPreflightExtension, "");
   if (!kSupportedFormats.has(context.format))
     return defaultLoad(moduleUrl, context, defaultLoad);
   if (!moduleUrl.startsWith("file://"))
@@ -57,23 +62,17 @@ async function load(moduleUrl, context, defaultLoad) {
     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 });
-  }
+  if (transformed.serializedCache)
+    transport?.post("pushToCompilationCache", { cache: transformed.serializedCache });
   return {
     format: kSupportedFormats.get(context.format) || ((0, import_util.fileIsModule)(filename) ? "module" : "commonjs"),
-    source: transformed.code,
+    source: originalModuleUrl.endsWith(esmPreflightExtension) ? `void 0;` : 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) => {

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/md.js

@@ -0,0 +1,221 @@
+"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 md_exports = {};
+__export(md_exports, {
+  transformMDToTS: () => transformMDToTS
+});
+module.exports = __toCommonJS(md_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utilsBundle = require("../utilsBundle");
+var import_babelBundle = require("./babelBundle");
+function transformMDToTS(code, filename) {
+  const parsed = parseSpec(code, filename);
+  let fixtures = resolveFixtures(filename, parsed.props.find((prop) => prop[0] === "fixtures")?.[1]);
+  const seed = parsed.props.find((prop) => prop[0] === "seed")?.[1];
+  if (seed) {
+    const seedFile = import_path.default.resolve(import_path.default.dirname(filename), seed.text);
+    const seedContents = import_fs.default.readFileSync(seedFile, "utf-8");
+    const parsedSeed = parseSpec(seedContents, seedFile);
+    if (parsedSeed.tests.length !== 1)
+      throw new Error(`while parsing ${seedFile}: seed file must contain exactly one test`);
+    if (parsedSeed.tests[0].props.length)
+      throw new Error(`while parsing ${seedFile}: seed test must not have properties`);
+    for (const test of parsed.tests)
+      test.lines = parsedSeed.tests[0].lines.concat(test.lines);
+    const seedFixtures = resolveFixtures(seedFile, parsedSeed.props.find((prop) => prop[0] === "fixtures")?.[1]);
+    if (seedFixtures && fixtures)
+      throw new Error(`while parsing ${filename}: either seed or test can specify fixtures, but not both`);
+    fixtures ??= seedFixtures;
+  }
+  const map = new import_babelBundle.genMapping.GenMapping({});
+  const lines = [];
+  const addLine = (line) => {
+    lines.push(line.text);
+    if (line.source) {
+      import_babelBundle.genMapping.addMapping(map, {
+        generated: { line: lines.length, column: 0 },
+        source: line.source.filename,
+        original: { line: line.source.line, column: line.source.column - 1 }
+      });
+    }
+  };
+  if (fixtures)
+    addLine({ text: `import { test, expect } from ${escapeString(import_path.default.relative(import_path.default.dirname(filename), fixtures.text))};`, source: fixtures.source });
+  else
+    addLine({ text: `import { test, expect } from '@playwright/test';` });
+  addLine({ text: `test.describe(${escapeString(parsed.describe.text)}, () => {`, source: parsed.describe.source });
+  for (const test of parsed.tests) {
+    const tags = [];
+    const annotations = [];
+    for (const [key, value] of test.props) {
+      if (key === "tag") {
+        tags.push(...value.text.split(" ").map((s) => s.trim()).filter((s) => !!s));
+      } else if (key === "annotation") {
+        if (!value.text.includes("="))
+          throw new Error(`while parsing ${filename}: annotation must be in format "type=description", found "${value}"`);
+        const [type, description] = value.text.split("=").map((s) => s.trim());
+        annotations.push({ type, description });
+      }
+    }
+    let props = "";
+    if (tags.length || annotations.length) {
+      props = "{ ";
+      if (tags.length)
+        props += `tag: [${tags.map((tag) => escapeString(tag)).join(", ")}], `;
+      if (annotations.length)
+        props += `annotation: [${annotations.map((a) => `{ type: ${escapeString(a.type)}, description: ${escapeString(a.description)} }`).join(", ")}], `;
+      props += "}, ";
+    }
+    addLine({ text: `  test(${escapeString(test.title.text)}, ${props}async ({ page, agent }) => {`, source: test.title.source });
+    for (const line of test.lines)
+      addLine({ text: "    " + line.text, source: line.source });
+    addLine({ text: `  });`, source: test.title.source });
+  }
+  addLine({ text: `});`, source: parsed.describe.source });
+  addLine({ text: `` });
+  const encodedMap = import_babelBundle.genMapping.toEncodedMap(map);
+  const result = lines.join("\n");
+  return { code: result, map: encodedMap };
+}
+function resolveFixtures(filename, prop) {
+  if (!prop)
+    return;
+  return { text: import_path.default.resolve(import_path.default.dirname(filename), prop.text), source: prop.source };
+}
+function escapeString(s) {
+  return `'` + s.replace(/\n/g, " ").replace(/'/g, `\\'`) + `'`;
+}
+function parsingError(filename, node, message) {
+  const position = node?.position?.start ? ` at ${node.position.start.line}:${node.position.start.column}` : "";
+  return new Error(`while parsing ${filename}${position}: ${message}`);
+}
+function asText(filename, node, errorMessage, skipChild) {
+  let children = node.children.filter((child) => child !== skipChild);
+  while (children.length === 1 && children[0].type === "paragraph")
+    children = children[0].children;
+  if (children.length !== 1 || children[0].type !== "text")
+    throw parsingError(filename, node, errorMessage);
+  return { text: children[0].value, source: node.position ? { filename, line: node.position.start.line, column: node.position.start.column } : void 0 };
+}
+function parseSpec(content, filename) {
+  const root = (0, import_utilsBundle.parseMarkdown)(content);
+  const props = [];
+  const children = [...root.children];
+  const describeNode = children[0];
+  children.shift();
+  if (describeNode?.type !== "heading" || describeNode.depth !== 2)
+    throw parsingError(filename, describeNode, `describe title must be ##`);
+  const describe = asText(filename, describeNode, `describe title must be ##`);
+  if (children[0]?.type === "list") {
+    parseProps(filename, children[0], props);
+    children.shift();
+  }
+  const tests = [];
+  while (children.length) {
+    let nextIndex = children.findIndex((n, i) => i > 0 && n.type === "heading" && n.depth === 3);
+    if (nextIndex === -1)
+      nextIndex = children.length;
+    const testNodes = children.splice(0, nextIndex);
+    tests.push(parseTest(filename, testNodes));
+  }
+  return { describe, tests, props };
+}
+function parseProp(filename, node, props) {
+  const propText = asText(filename, node, `property must be a list item without children`);
+  const match = propText.text.match(/^([^:]+):(.*)$/);
+  if (!match)
+    throw parsingError(filename, node, `property must be in format "key: value"`);
+  props.push([match[1].trim(), { text: match[2].trim(), source: propText.source }]);
+}
+function parseProps(filename, node, props) {
+  for (const prop of node.children || []) {
+    if (prop.type !== "listItem")
+      throw parsingError(filename, prop, `property must be a list item without children`);
+    parseProp(filename, prop, props);
+  }
+}
+function parseTest(filename, nodes) {
+  const titleNode = nodes[0];
+  nodes.shift();
+  if (titleNode.type !== "heading" || titleNode.depth !== 3)
+    throw parsingError(filename, titleNode, `test title must be ###`);
+  const title = asText(filename, titleNode, `test title must be ###`);
+  const props = [];
+  let handlingProps = true;
+  const lines = [];
+  const visit = (node, indent) => {
+    if (node.type === "list") {
+      for (const child of node.children)
+        visit(child, indent);
+      return;
+    }
+    if (node.type === "listItem") {
+      const listItem = node;
+      const lastChild = listItem.children[listItem.children.length - 1];
+      if (lastChild?.type === "code") {
+        handlingProps = false;
+        const { text, source } = asText(filename, listItem, `code step must be a list item with a single code block`, lastChild);
+        lines.push({ text: `${indent}await test.step(${escapeString(text)}, async () => {`, source });
+        for (const [index, code] of lastChild.value.split("\n").entries())
+          lines.push({ text: indent + "  " + code, source: lastChild.position ? { filename, line: lastChild.position.start.line + 1 + index, column: lastChild.position.start.column } : void 0 });
+        lines.push({ text: `${indent}});`, source });
+      } else {
+        const { text, source } = asText(filename, listItem, `step must contain a single instruction`, lastChild?.type === "list" ? lastChild : void 0);
+        let isGroup = false;
+        if (handlingProps && lastChild?.type !== "list" && ["tag:", "annotation:"].some((prefix) => text.startsWith(prefix))) {
+          parseProp(filename, listItem, props);
+        } else if (text.startsWith("group:")) {
+          isGroup = true;
+          lines.push({ text: `${indent}await test.step(${escapeString(text.substring("group:".length).trim())}, async () => {`, source });
+        } else if (text.startsWith("expect:")) {
+          handlingProps = false;
+          const assertion = text.substring("expect:".length).trim();
+          lines.push({ text: `${indent}await agent.expect(${escapeString(assertion)});`, source });
+        } else if (!text.startsWith("//")) {
+          handlingProps = false;
+          lines.push({ text: `${indent}await agent.perform(${escapeString(text)});`, source });
+        }
+        if (lastChild?.type === "list")
+          visit(lastChild, indent + (isGroup ? "  " : ""));
+        if (isGroup)
+          lines.push({ text: `${indent}});`, source });
+      }
+    } else {
+      throw parsingError(filename, node, `test step must be a markdown list item`);
+    }
+  };
+  for (const node of nodes)
+    visit(node, "");
+  return { title, lines, props };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformMDToTS
+});

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": []
+}

package/lib/transform/transform.js

@@ -50,6 +50,7 @@ var import_util = require("../util");
 var import_utilsBundle = require("../utilsBundle");
 var import_compilationCache = require("./compilationCache");
 var import_pirates = require("../third_party/pirates");
+var import_md = require("./md");
 const version = require("../../package.json").version;
 const cachedTSConfigs = /* @__PURE__ */ new Map();
 let _transformConfig = {
@@ -185,6 +186,12 @@ function setTransformData(pluginName, value) {
   transformData.set(pluginName, value);
 }
 function transformHook(originalCode, filename, moduleUrl) {
+  let inputSourceMap;
+  if (filename.endsWith(".md") && false) {
+    const transformed = transformMDToTS(originalCode, filename);
+    originalCode = transformed.code;
+    inputSourceMap = transformed.map;
+  }
   const hasPreprocessor = process.env.PW_TEST_SOURCE_TRANSFORM && process.env.PW_TEST_SOURCE_TRANSFORM_SCOPE && process.env.PW_TEST_SOURCE_TRANSFORM_SCOPE.split(pathSeparator).some((f) => filename.startsWith(f));
   const pluginsPrologue = _transformConfig.babelPlugins;
   const pluginsEpilogue = hasPreprocessor ? [[process.env.PW_TEST_SOURCE_TRANSFORM]] : [];
@@ -195,7 +202,7 @@ function transformHook(originalCode, filename, moduleUrl) {
   process.env.BROWSERSLIST_IGNORE_OLD_DATA = "true";
   const { babelTransform } = require("./babelBundle");
   transformData = /* @__PURE__ */ new Map();
-  const babelResult = babelTransform(originalCode, filename, !!moduleUrl, pluginsPrologue, pluginsEpilogue);
+  const babelResult = babelTransform(originalCode, filename, !!moduleUrl, pluginsPrologue, pluginsEpilogue, inputSourceMap);
   if (!babelResult?.code)
     return { code: originalCode, serializedCache };
   const { code, map } = babelResult;
@@ -209,11 +216,11 @@ function calculateHash(content, filePath, isModule2, pluginsPrologue, pluginsEpi
 async function requireOrImport(file) {
   installTransformIfNeeded();
   const isModule = (0, import_util.fileIsModule)(file);
-  const esmImport = () => eval(`import(${JSON.stringify(import_url.default.pathToFileURL(file))})`);
   if (isModule) {
-    return await esmImport().finally(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 0));
-    });
+    const fileName = import_url.default.pathToFileURL(file);
+    const esmImport = () => eval(`import(${JSON.stringify(fileName)})`);
+    await eval(`import(${JSON.stringify(fileName + ".esm.preflight")})`).finally(nextTask);
+    return await esmImport().finally(nextTask);
   }
   const result = require(file);
   const depsCollector = (0, import_compilationCache.currentFileDepsCollector)();
@@ -242,7 +249,7 @@ function installTransformIfNeeded() {
   import_module.default._resolveFilename = resolveFilename;
   (0, import_pirates.addHook)((code, filename) => {
     return transformHook(code, filename).code;
-  }, shouldTransform, [".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts", ".cjs", ".cts"]);
+  }, shouldTransform, [".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts", ".cjs", ".cts", ".md"]);
 }
 const collectCJSDependencies = (module2, dependencies) => {
   module2.children.forEach((child) => {
@@ -257,8 +264,8 @@ function wrapFunctionWithLocation(func) {
     const oldPrepareStackTrace = Error.prepareStackTrace;
     Error.prepareStackTrace = (error, stackFrames) => {
       const frame = import_utilsBundle.sourceMapSupport.wrapCallSite(stackFrames[1]);
-      const fileName = frame.getFileName();
-      const file2 = fileName && fileName.startsWith("file://") ? import_url.default.fileURLToPath(fileName) : fileName;
+      const fileName2 = frame.getFileName();
+      const file2 = fileName2 && fileName2.startsWith("file://") ? import_url.default.fileURLToPath(fileName2) : fileName2;
       return {
         file: file2,
         line: frame.getLineNumber(),
@@ -278,6 +285,9 @@ function wrapFunctionWithLocation(func) {
 function isRelativeSpecifier(specifier) {
   return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
 }
+async function nextTask() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   requireOrImport,

package/lib/transform/transform.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/transform/transform.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 Module from 'module';\nimport path from 'path';\nimport url from 'url';\n\nimport crypto from 'crypto';\n\nimport { loadTsConfig } from '../third_party/tsconfig-loader';\nimport { createFileMatcher, fileIsModule, resolveImportSpecifierAfterMapping } from '../util';\nimport { sourceMapSupport } from '../utilsBundle';\nimport { belongsToNodeModules, currentFileDepsCollector, getFromCompilationCache, installSourceMapSupport } from './compilationCache';\nimport { addHook } from '../third_party/pirates';\n\nimport type { BabelPlugin, BabelTransformFunction } from './babelBundle';\nimport type { Location } from '../../types/testReporter';\nimport type { LoadedTsConfig } from '../third_party/tsconfig-loader';\nimport type { Matcher } from '../util';\n\n\nconst version = require('../../package.json').version;\n\ntype ParsedTsConfigData = {\n  pathsBase?: string;\n  paths: { key: string, values: string[] }[];\n  allowJs: boolean;\n};\nconst cachedTSConfigs = new Map<string, ParsedTsConfigData[]>();\n\nexport type TransformConfig = {\n  babelPlugins: [string, any?][];\n  external: string[];\n};\n\nlet _transformConfig: TransformConfig = {\n  babelPlugins: [],\n  external: [],\n};\n\nlet _externalMatcher: Matcher = () => false;\n\nexport function setTransformConfig(config: TransformConfig) {\n  _transformConfig = config;\n  _externalMatcher = createFileMatcher(_transformConfig.external);\n}\n\nexport function transformConfig(): TransformConfig {\n  return _transformConfig;\n}\n\nlet _singleTSConfigPath: string | undefined;\nlet _singleTSConfig: ParsedTsConfigData[] | undefined;\n\nexport function setSingleTSConfig(value: string | undefined) {\n  _singleTSConfigPath = value;\n}\n\nexport function singleTSConfig(): string | undefined {\n  return _singleTSConfigPath;\n}\n\nfunction validateTsConfig(tsconfig: LoadedTsConfig): ParsedTsConfigData {\n  // When no explicit baseUrl is set, resolve paths relative to the tsconfig file.\n  // See https://www.typescriptlang.org/tsconfig#paths\n  const pathsBase = tsconfig.absoluteBaseUrl ?? tsconfig.paths?.pathsBasePath;\n  // Only add the catch-all mapping when baseUrl is specified\n  const pathsFallback = tsconfig.absoluteBaseUrl ? [{ key: '*', values: ['*'] }] : [];\n  return {\n    allowJs: !!tsconfig.allowJs,\n    pathsBase,\n    paths: Object.entries(tsconfig.paths?.mapping || {}).map(([key, values]) => ({ key, values })).concat(pathsFallback)\n  };\n}\n\nfunction loadAndValidateTsconfigsForFile(file: string): ParsedTsConfigData[] {\n  if (_singleTSConfigPath && !_singleTSConfig)\n    _singleTSConfig = loadTsConfig(_singleTSConfigPath).map(validateTsConfig);\n  if (_singleTSConfig)\n    return _singleTSConfig;\n  return loadAndValidateTsconfigsForFolder(path.dirname(file));\n}\n\nfunction loadAndValidateTsconfigsForFolder(folder: string): ParsedTsConfigData[] {\n  const foldersWithConfig: string[] = [];\n  let currentFolder = path.resolve(folder);\n  let result: ParsedTsConfigData[] | undefined;\n  while (true) {\n    const cached = cachedTSConfigs.get(currentFolder);\n    if (cached) {\n      result = cached;\n      break;\n    }\n\n    foldersWithConfig.push(currentFolder);\n\n    for (const name of ['tsconfig.json', 'jsconfig.json']) {\n      const configPath = path.join(currentFolder, name);\n      if (fs.existsSync(configPath)) {\n        const loaded = loadTsConfig(configPath);\n        result = loaded.map(validateTsConfig);\n        break;\n      }\n    }\n    if (result)\n      break;\n\n    const parentFolder = path.resolve(currentFolder, '../');\n    if (currentFolder === parentFolder)\n      break;\n    currentFolder = parentFolder;\n  }\n\n  result = result || [];\n  for (const folder of foldersWithConfig)\n    cachedTSConfigs.set(folder, result);\n  return result;\n}\n\nconst pathSeparator = process.platform === 'win32' ? ';' : ':';\nconst builtins = new Set(Module.builtinModules);\n\nexport function resolveHook(filename: string, specifier: string): string | undefined {\n  if (specifier.startsWith('node:') || builtins.has(specifier))\n    return;\n  if (!shouldTransform(filename))\n    return;\n\n  if (isRelativeSpecifier(specifier))\n    return resolveImportSpecifierAfterMapping(path.resolve(path.dirname(filename), specifier), false);\n\n  /**\n   * TypeScript discourages path-mapping into node_modules:\n   * https://www.typescriptlang.org/docs/handbook/modules/reference.html#paths-should-not-point-to-monorepo-packages-or-node_modules-packages\n   * However, if path-mapping doesn't yield a result, TypeScript falls back to the default resolution through node_modules.\n   */\n  const isTypeScript = filename.endsWith('.ts') || filename.endsWith('.tsx');\n  const tsconfigs = loadAndValidateTsconfigsForFile(filename);\n  for (const tsconfig of tsconfigs) {\n    if (!isTypeScript && !tsconfig.allowJs)\n      continue;\n    let longestPrefixLength = -1;\n    let pathMatchedByLongestPrefix: string | undefined;\n\n    for (const { key, values } of tsconfig.paths) {\n      let matchedPartOfSpecifier = specifier;\n\n      const [keyPrefix, keySuffix] = key.split('*');\n      if (key.includes('*')) {\n        // * If pattern contains '*' then to match pattern \"<prefix>*<suffix>\" module name must start with the <prefix> and end with <suffix>.\n        // * <MatchedStar> denotes part of the module name between <prefix> and <suffix>.\n        // * If module name can be matches with multiple patterns then pattern with the longest prefix will be picked.\n        // https://github.com/microsoft/TypeScript/blob/f82d0cb3299c04093e3835bc7e29f5b40475f586/src/compiler/moduleNameResolver.ts#L1049\n        if (keyPrefix) {\n          if (!specifier.startsWith(keyPrefix))\n            continue;\n          matchedPartOfSpecifier = matchedPartOfSpecifier.substring(keyPrefix.length, matchedPartOfSpecifier.length);\n        }\n        if (keySuffix) {\n          if (!specifier.endsWith(keySuffix))\n            continue;\n          matchedPartOfSpecifier = matchedPartOfSpecifier.substring(0, matchedPartOfSpecifier.length - keySuffix.length);\n        }\n      } else {\n        if (specifier !== key)\n          continue;\n        matchedPartOfSpecifier = specifier;\n      }\n\n      if (keyPrefix.length <= longestPrefixLength)\n        continue;\n\n      for (const value of values) {\n        let candidate = value;\n        if (value.includes('*'))\n          candidate = candidate.replace('*', matchedPartOfSpecifier);\n        candidate = path.resolve(tsconfig.pathsBase!, candidate);\n        const existing = resolveImportSpecifierAfterMapping(candidate, true);\n        if (existing) {\n          longestPrefixLength = keyPrefix.length;\n          pathMatchedByLongestPrefix = existing;\n        }\n      }\n    }\n    if (pathMatchedByLongestPrefix)\n      return pathMatchedByLongestPrefix;\n  }\n\n  if (path.isAbsolute(specifier)) {\n    // Handle absolute file paths like `import '/path/to/file'`\n    // Do not handle module imports like `import 'fs'`\n    return resolveImportSpecifierAfterMapping(specifier, false);\n  }\n}\n\nexport function shouldTransform(filename: string): boolean {\n  if (_externalMatcher(filename))\n    return false;\n  return !belongsToNodeModules(filename);\n}\n\nlet transformData: Map<string, any>;\n\nexport function setTransformData(pluginName: string, value: any) {\n  transformData.set(pluginName, value);\n}\n\nexport function transformHook(originalCode: string, filename: string, moduleUrl?: string): { code: string, serializedCache?: any } {\n  const hasPreprocessor =\n    process.env.PW_TEST_SOURCE_TRANSFORM &&\n    process.env.PW_TEST_SOURCE_TRANSFORM_SCOPE &&\n    process.env.PW_TEST_SOURCE_TRANSFORM_SCOPE.split(pathSeparator).some(f => filename.startsWith(f));\n  const pluginsPrologue = _transformConfig.babelPlugins;\n  const pluginsEpilogue = hasPreprocessor ? [[process.env.PW_TEST_SOURCE_TRANSFORM!]] as BabelPlugin[] : [];\n  const hash = calculateHash(originalCode, filename, !!moduleUrl, pluginsPrologue, pluginsEpilogue);\n  const { cachedCode, addToCache, serializedCache } = getFromCompilationCache(filename, hash, moduleUrl);\n  if (cachedCode !== undefined)\n    return { code: cachedCode, serializedCache };\n\n  // We don't use any browserslist data, but babel checks it anyway.\n  // Silence the annoying warning.\n  process.env.BROWSERSLIST_IGNORE_OLD_DATA = 'true';\n\n  const { babelTransform }: { babelTransform: BabelTransformFunction } = require('./babelBundle');\n  transformData = new Map<string, any>();\n  const babelResult = babelTransform(originalCode, filename, !!moduleUrl, pluginsPrologue, pluginsEpilogue);\n  if (!babelResult?.code)\n    return { code: originalCode, serializedCache };\n  const { code, map } = babelResult;\n  const added = addToCache!(code, map, transformData);\n  return { code, serializedCache: added.serializedCache };\n}\n\nfunction calculateHash(content: string, filePath: string, isModule: boolean, pluginsPrologue: BabelPlugin[], pluginsEpilogue: BabelPlugin[]): string {\n  const hash = crypto.createHash('sha1')\n      .update(isModule ? 'esm' : 'no_esm')\n      .update(content)\n      .update(filePath)\n      .update(version)\n      .update(pluginsPrologue.map(p => p[0]).join(','))\n      .update(pluginsEpilogue.map(p => p[0]).join(','))\n      .digest('hex');\n  return hash;\n}\n\nexport async function requireOrImport(file: string) {\n  installTransformIfNeeded();\n  const isModule = fileIsModule(file);\n  const esmImport = () => eval(`import(${JSON.stringify(url.pathToFileURL(file))})`);\n  if (isModule) {\n    return await esmImport().finally(async () => {\n      // Compilation cache, which includes source maps, is populated in a post task.\n      // When importing a module results in an error, the very next access to `error.stack`\n      // will need source maps. To make sure source maps have arrived, we insert a task\n      // that will be processed after compilation cache and guarantee that\n      // source maps are available, before `error.stack` is accessed.\n      await new Promise(resolve => setTimeout(resolve, 0));\n    });\n  }\n  const result = require(file);\n  const depsCollector = currentFileDepsCollector();\n  if (depsCollector) {\n    const module = require.cache[file];\n    if (module)\n      collectCJSDependencies(module, depsCollector);\n  }\n  return result;\n}\n\nlet transformInstalled = false;\n\nfunction installTransformIfNeeded() {\n  if (transformInstalled)\n    return;\n  transformInstalled = true;\n\n  installSourceMapSupport();\n\n  const originalResolveFilename = (Module as any)._resolveFilename;\n  function resolveFilename(this: any, specifier: string, parent: Module, ...rest: any[]) {\n    if (parent) {\n      const resolved = resolveHook(parent.filename, specifier);\n      if (resolved !== undefined)\n        specifier = resolved;\n    }\n    return originalResolveFilename.call(this, specifier, parent, ...rest);\n  }\n  (Module as any)._resolveFilename = resolveFilename;\n\n  // Hopefully, one day we can migrate to synchronous loader hooks instead, similar to our esmLoader...\n  addHook((code, filename) => {\n    return transformHook(code, filename).code;\n  }, shouldTransform, ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.mts', '.cjs', '.cts']);\n}\n\nconst collectCJSDependencies = (module: Module, dependencies: Set<string>) => {\n  module.children.forEach(child => {\n    if (!belongsToNodeModules(child.filename) && !dependencies.has(child.filename)) {\n      dependencies.add(child.filename);\n      collectCJSDependencies(child, dependencies);\n    }\n  });\n};\n\nexport function wrapFunctionWithLocation<A extends any[], R>(func: (location: Location, ...args: A) => R): (...args: A) => R {\n  return (...args) => {\n    const oldPrepareStackTrace = Error.prepareStackTrace;\n    Error.prepareStackTrace = (error, stackFrames) => {\n      const frame: NodeJS.CallSite = sourceMapSupport.wrapCallSite(stackFrames[1]);\n      const fileName = frame.getFileName();\n      // Node error stacks for modules use file:// urls instead of paths.\n      const file = (fileName && fileName.startsWith('file://')) ? url.fileURLToPath(fileName) : fileName;\n      return {\n        file,\n        line: frame.getLineNumber(),\n        column: frame.getColumnNumber(),\n      };\n    };\n    const oldStackTraceLimit = Error.stackTraceLimit;\n    Error.stackTraceLimit = 2;\n    const obj: { stack: Location } = {} as any;\n    Error.captureStackTrace(obj);\n    const location = obj.stack;\n    Error.stackTraceLimit = oldStackTraceLimit;\n    Error.prepareStackTrace = oldPrepareStackTrace;\n    return func(location, ...args);\n  };\n}\n\nfunction isRelativeSpecifier(specifier: string) {\n  return specifier === '.' || specifier === '..' || specifier.startsWith('./') || specifier.startsWith('../');\n}\n"],
+  "mappings": "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",
+  "names": ["file", "path", "result", "fs", "folder", "Module", "isModule", "crypto", "url", "module"]
+}

package/lib/util.js

@@ -29,7 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var util_exports = {};
 __export(util_exports, {
   addSuffixToFilePath: () => addSuffixToFilePath,
-  ansiRegex: () => ansiRegex,
+  ansiRegex: () => import_utils2.ansiRegex,
   createFileFiltersFromArguments: () => createFileFiltersFromArguments,
   createFileMatcher: () => createFileMatcher,
   createFileMatcherFromArguments: () => createFileMatcherFromArguments,
@@ -55,7 +55,7 @@ __export(util_exports, {
   resolveReporterOutputPath: () => resolveReporterOutputPath,
   sanitizeFilePathBeforeExtension: () => sanitizeFilePathBeforeExtension,
   serializeError: () => serializeError,
-  stripAnsiEscapes: () => stripAnsiEscapes,
+  stripAnsiEscapes: () => import_utils2.stripAnsiEscapes,
   trimLongString: () => trimLongString,
   windowsFilesystemFriendlyLength: () => windowsFilesystemFriendlyLength
 });
@@ -66,6 +66,7 @@ var import_url = __toESM(require("url"));
 var import_util = __toESM(require("util"));
 var import_utils = require("playwright-core/lib/utils");
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_utils2 = require("playwright-core/lib/utils");
 const PLAYWRIGHT_TEST_PATH = import_path.default.join(__dirname, "..");
 const PLAYWRIGHT_CORE_PATH = import_path.default.dirname(require.resolve("playwright-core/package.json"));
 function filterStackTrace(e) {
@@ -364,10 +365,6 @@ async function removeDirAndLogToConsole(dir) {
   } catch {
   }
 }
-const ansiRegex = new RegExp("([\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~])))", "g");
-function stripAnsiEscapes(str) {
-  return str.replace(ansiRegex, "");
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addSuffixToFilePath,

package/lib/util.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/util.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 path from 'path';\nimport url from 'url';\nimport util from 'util';\n\nimport { parseStackFrame, sanitizeForFilePath, calculateSha1, isRegExp, isString, stringifyStackFrames } from 'playwright-core/lib/utils';\nimport { debug, mime, minimatch } from 'playwright-core/lib/utilsBundle';\n\nimport type { Location } from './../types/testReporter';\nimport type { TestInfoErrorImpl } from './common/ipc';\nimport type { StackFrame } from '@protocol/channels';\nimport type { RawStack } from 'playwright-core/lib/utils';\nimport type { TestCase } from './common/test';\n\nconst PLAYWRIGHT_TEST_PATH = path.join(__dirname, '..');\nconst PLAYWRIGHT_CORE_PATH = path.dirname(require.resolve('playwright-core/package.json'));\n\nexport function filterStackTrace(e: Error): { message: string, stack: string, cause?: ReturnType<typeof filterStackTrace> } {\n  const name = e.name ? e.name + ': ' : '';\n  const cause = e.cause instanceof Error ? filterStackTrace(e.cause) : undefined;\n  if (process.env.PWDEBUGIMPL)\n    return { message: name + e.message, stack: e.stack || '', cause };\n\n  const stackLines = stringifyStackFrames(filteredStackTrace(e.stack?.split('\\n') || []));\n  return {\n    message: name + e.message,\n    stack: `${name}${e.message}${stackLines.map(line => '\\n' + line).join('')}`,\n    cause,\n  };\n}\n\nexport function filterStackFile(file: string) {\n  if (!process.env.PWDEBUGIMPL && file.startsWith(PLAYWRIGHT_TEST_PATH))\n    return false;\n  if (!process.env.PWDEBUGIMPL && file.startsWith(PLAYWRIGHT_CORE_PATH))\n    return false;\n  return true;\n}\n\nexport function filteredStackTrace(rawStack: RawStack): StackFrame[] {\n  const frames: StackFrame[] = [];\n  for (const line of rawStack) {\n    const frame = parseStackFrame(line, path.sep, !!process.env.PWDEBUGIMPL);\n    if (!frame || !frame.file)\n      continue;\n    if (!filterStackFile(frame.file))\n      continue;\n    frames.push(frame);\n  }\n  return frames;\n}\n\nexport function serializeError(error: Error | any): TestInfoErrorImpl {\n  if (error instanceof Error)\n    return filterStackTrace(error);\n  return {\n    value: util.inspect(error)\n  };\n}\n\nexport type Matcher = (value: string) => boolean;\n\nexport type TestFileFilter = {\n  re?: RegExp;\n  exact?: string;\n  line: number | null;\n  column: number | null;\n};\n\nexport type TestCaseFilter = (test: TestCase) => boolean;\n\nexport function parseLocationArg(arg: string): { file: string, line: number | null, column: number | null } {\n  const match = /^(.*?):(\\d+):?(\\d+)?$/.exec(arg);\n  return {\n    file: match ? match[1] : arg,\n    line: match ? parseInt(match[2], 10) : null,\n    column: match?.[3] ? parseInt(match[3], 10) : null,\n  };\n}\n\nexport function createFileFiltersFromArguments(args: string[]): TestFileFilter[] {\n  return args.map(arg => {\n    const parsed = parseLocationArg(arg);\n    return { re: forceRegExp(parsed.file), line: parsed.line, column: parsed.column };\n  });\n}\n\nexport function createFileMatcherFromArguments(args: string[]): Matcher {\n  const filters = createFileFiltersFromArguments(args);\n  return createFileMatcher(filters.map(filter => filter.re || filter.exact || ''));\n}\n\nexport function createFileMatcher(patterns: string | RegExp | (string | RegExp)[]): Matcher {\n  const reList: RegExp[] = [];\n  const filePatterns: string[] = [];\n  for (const pattern of Array.isArray(patterns) ? patterns : [patterns]) {\n    if (isRegExp(pattern)) {\n      reList.push(pattern);\n    } else {\n      if (!pattern.startsWith('**/'))\n        filePatterns.push('**/' + pattern);\n      else\n        filePatterns.push(pattern);\n    }\n  }\n  return (filePath: string) => {\n    for (const re of reList) {\n      re.lastIndex = 0;\n      if (re.test(filePath))\n        return true;\n    }\n    // Windows might still receive unix style paths from Cygwin or Git Bash.\n    // Check against the file url as well.\n    if (path.sep === '\\\\') {\n      const fileURL = url.pathToFileURL(filePath).href;\n      for (const re of reList) {\n        re.lastIndex = 0;\n        if (re.test(fileURL))\n          return true;\n      }\n    }\n    for (const pattern of filePatterns) {\n      if (minimatch(filePath, pattern, { nocase: true, dot: true }))\n        return true;\n    }\n    return false;\n  };\n}\n\nexport function createTitleMatcher(patterns: RegExp | RegExp[]): Matcher {\n  const reList = Array.isArray(patterns) ? patterns : [patterns];\n  return (value: string) => {\n    for (const re of reList) {\n      re.lastIndex = 0;\n      if (re.test(value))\n        return true;\n    }\n    return false;\n  };\n}\n\nexport function mergeObjects<A extends object, B extends object, C extends object>(a: A | undefined | void, b: B | undefined | void, c: C | undefined | void): A & B & C {\n  const result = { ...a } as any;\n  for (const x of [b, c].filter(Boolean)) {\n    for (const [name, value] of Object.entries(x as any)) {\n      if (!Object.is(value, undefined))\n        result[name] = value;\n    }\n  }\n  return result as any;\n}\n\nexport function forceRegExp(pattern: string): RegExp {\n  const match = pattern.match(/^\\/(.*)\\/([gi]*)$/);\n  if (match)\n    return new RegExp(match[1], match[2]);\n  return new RegExp(pattern, 'gi');\n}\n\nexport function relativeFilePath(file: string): string {\n  if (!path.isAbsolute(file))\n    return file;\n  return path.relative(process.cwd(), file);\n}\n\nexport function formatLocation(location: Location) {\n  return relativeFilePath(location.file) + ':' + location.line + ':' + location.column;\n}\n\nexport function errorWithFile(file: string, message: string) {\n  return new Error(`${relativeFilePath(file)}: ${message}`);\n}\n\nexport function expectTypes(receiver: any, types: string[], matcherName: string) {\n  if (typeof receiver !== 'object' || !types.includes(receiver.constructor.name)) {\n    const commaSeparated = types.slice();\n    const lastType = commaSeparated.pop();\n    const typesString = commaSeparated.length ? commaSeparated.join(', ') + ' or ' + lastType : lastType;\n    throw new Error(`${matcherName} can be only used with ${typesString} object${types.length > 1 ? 's' : ''}`);\n  }\n}\n\nexport const windowsFilesystemFriendlyLength = 60;\n\nexport function trimLongString(s: string, length = 100) {\n  if (s.length <= length)\n    return s;\n  const hash = calculateSha1(s);\n  const middle = `-${hash.substring(0, 5)}-`;\n  const start = Math.floor((length - middle.length) / 2);\n  const end = length - middle.length - start;\n  return s.substring(0, start) + middle + s.slice(-end);\n}\n\nexport function addSuffixToFilePath(filePath: string, suffix: string): string {\n  const ext = path.extname(filePath);\n  const base = filePath.substring(0, filePath.length - ext.length);\n  return base + suffix + ext;\n}\n\nexport function sanitizeFilePathBeforeExtension(filePath: string, ext?: string): string {\n  ext ??= path.extname(filePath);\n  const base = filePath.substring(0, filePath.length - ext.length);\n  return sanitizeForFilePath(base) + ext;\n}\n\n/**\n * Returns absolute path contained within parent directory.\n */\nexport function getContainedPath(parentPath: string, subPath: string = ''): string | null {\n  const resolvedPath = path.resolve(parentPath, subPath);\n  if (resolvedPath === parentPath || resolvedPath.startsWith(parentPath + path.sep))\n    return resolvedPath;\n  return null;\n}\n\nexport const debugTest = debug('pw:test');\n\nconst folderToPackageJsonPath = new Map<string, string>();\n\nexport function getPackageJsonPath(folderPath: string): string {\n  const cached = folderToPackageJsonPath.get(folderPath);\n  if (cached !== undefined)\n    return cached;\n\n  const packageJsonPath = path.join(folderPath, 'package.json');\n  if (fs.existsSync(packageJsonPath)) {\n    folderToPackageJsonPath.set(folderPath, packageJsonPath);\n    return packageJsonPath;\n  }\n\n  const parentFolder = path.dirname(folderPath);\n  if (folderPath === parentFolder) {\n    folderToPackageJsonPath.set(folderPath, '');\n    return '';\n  }\n\n  const result = getPackageJsonPath(parentFolder);\n  folderToPackageJsonPath.set(folderPath, result);\n  return result;\n}\n\nexport function resolveReporterOutputPath(defaultValue: string, configDir: string, configValue: string | undefined) {\n  if (configValue)\n    return path.resolve(configDir, configValue);\n  let basePath = getPackageJsonPath(configDir);\n  basePath = basePath ? path.dirname(basePath) : process.cwd();\n  return path.resolve(basePath, defaultValue);\n}\n\nexport async function normalizeAndSaveAttachment(outputPath: string, name: string, options: { path?: string, body?: string | Buffer, contentType?: string } = {}): Promise<{ name: string; path?: string; body?: Buffer; contentType: string; }> {\n  if (options.path === undefined && options.body === undefined)\n    return { name, contentType: 'text/plain' };\n  if ((options.path !== undefined ? 1 : 0) + (options.body !== undefined ? 1 : 0) !== 1)\n    throw new Error(`Exactly one of \"path\" and \"body\" must be specified`);\n  if (options.path !== undefined) {\n    const hash = calculateSha1(options.path);\n\n    if (!isString(name))\n      throw new Error('\"name\" should be string.');\n\n    const sanitizedNamePrefix = sanitizeForFilePath(name) + '-';\n    const dest = path.join(outputPath, 'attachments', sanitizedNamePrefix + hash + path.extname(options.path));\n    await fs.promises.mkdir(path.dirname(dest), { recursive: true });\n    await fs.promises.copyFile(options.path, dest);\n    const contentType = options.contentType ?? (mime.getType(path.basename(options.path)) || 'application/octet-stream');\n    return { name, contentType, path: dest };\n  } else {\n    const contentType = options.contentType ?? (typeof options.body === 'string' ? 'text/plain' : 'application/octet-stream');\n    return { name, contentType, body: typeof options.body === 'string' ? Buffer.from(options.body) : options.body };\n  }\n}\n\nexport function fileIsModule(file: string): boolean {\n  if (file.endsWith('.mjs') || file.endsWith('.mts'))\n    return true;\n  if (file.endsWith('.cjs') || file.endsWith('.cts'))\n    return false;\n  const folder = path.dirname(file);\n  return folderIsModule(folder);\n}\n\nfunction folderIsModule(folder: string): boolean {\n  const packageJsonPath = getPackageJsonPath(folder);\n  if (!packageJsonPath)\n    return false;\n  // Rely on `require` internal caching logic.\n  return require(packageJsonPath).type === 'module';\n}\n\nconst packageJsonMainFieldCache = new Map<string, string | undefined>();\n\nfunction getMainFieldFromPackageJson(packageJsonPath: string) {\n  if (!packageJsonMainFieldCache.has(packageJsonPath)) {\n    let mainField: string | undefined;\n    try {\n      mainField = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).main;\n    } catch {\n    }\n    packageJsonMainFieldCache.set(packageJsonPath, mainField);\n  }\n  return packageJsonMainFieldCache.get(packageJsonPath);\n}\n\n// This method performs \"file extension subsitution\" to find the ts, js or similar source file\n// based on the import specifier, which might or might not have an extension. See TypeScript docs:\n// https://www.typescriptlang.org/docs/handbook/modules/reference.html#file-extension-substitution.\nconst kExtLookups = new Map([\n  ['.js', ['.jsx', '.ts', '.tsx']],\n  ['.jsx', ['.tsx']],\n  ['.cjs', ['.cts']],\n  ['.mjs', ['.mts']],\n  ['', ['.js', '.ts', '.jsx', '.tsx', '.cjs', '.mjs', '.cts', '.mts']],\n]);\nfunction resolveImportSpecifierExtension(resolved: string): string | undefined {\n  if (fileExists(resolved))\n    return resolved;\n\n  for (const [ext, others] of kExtLookups) {\n    if (!resolved.endsWith(ext))\n      continue;\n    for (const other of others) {\n      const modified = resolved.substring(0, resolved.length - ext.length) + other;\n      if (fileExists(modified))\n        return modified;\n    }\n    break;  // Do not try '' when a more specific extension like '.jsx' matched.\n  }\n}\n\n// This method resolves directory imports and performs \"file extension subsitution\".\n// It is intended to be called after the path mapping resolution.\n//\n// Directory imports follow the --moduleResolution=bundler strategy from tsc.\n// https://www.typescriptlang.org/docs/handbook/modules/reference.html#directory-modules-index-file-resolution\n// https://www.typescriptlang.org/docs/handbook/modules/reference.html#bundler\n//\n// See also Node.js \"folder as module\" behavior:\n// https://nodejs.org/dist/latest-v20.x/docs/api/modules.html#folders-as-modules.\nexport function resolveImportSpecifierAfterMapping(resolved: string, afterPathMapping: boolean): string | undefined {\n  const resolvedFile = resolveImportSpecifierExtension(resolved);\n  if (resolvedFile)\n    return resolvedFile;\n\n  if (dirExists(resolved)) {\n    const packageJsonPath = path.join(resolved, 'package.json');\n\n    if (afterPathMapping) {\n      // Most notably, the module resolution algorithm is not performed after the path mapping.\n      // This means no node_modules lookup or package.json#exports.\n      //\n      // Only the \"folder as module\" Node.js behavior is respected:\n      //  - consult `package.json#main`;\n      //  - look for `index.js` or similar.\n      const mainField = getMainFieldFromPackageJson(packageJsonPath);\n      const mainFieldResolved = mainField ? resolveImportSpecifierExtension(path.resolve(resolved, mainField)) : undefined;\n      return mainFieldResolved || resolveImportSpecifierExtension(path.join(resolved, 'index'));\n    }\n\n    // If we import a package, let Node.js figure out the correct import based on package.json.\n    // This also covers the \"main\" field for \"folder as module\".\n    if (fileExists(packageJsonPath))\n      return resolved;\n\n    // Implement the \"folder as module\" Node.js behavior.\n    // Note that we do not delegate to Node.js, because we support this for ESM as well,\n    // following the TypeScript \"bundler\" mode.\n    const dirImport = path.join(resolved, 'index');\n    return resolveImportSpecifierExtension(dirImport);\n  }\n}\n\nfunction fileExists(resolved: string) {\n  return fs.statSync(resolved, { throwIfNoEntry: false })?.isFile();\n}\n\nexport async function fileExistsAsync(resolved: string) {\n  try {\n    const stat = await fs.promises.stat(resolved);\n    return stat.isFile();\n  } catch {\n    return false;\n  }\n}\n\nfunction dirExists(resolved: string) {\n  return fs.statSync(resolved, { throwIfNoEntry: false })?.isDirectory();\n}\n\nexport async function removeDirAndLogToConsole(dir: string) {\n  try {\n    if (!fs.existsSync(dir))\n      return;\n    // eslint-disable-next-line no-console\n    console.log(`Removing ${await fs.promises.realpath(dir)}`);\n    await fs.promises.rm(dir, { recursive: true, force: true });\n  } catch {\n  }\n}\n\nexport const ansiRegex = new RegExp('([\\\\u001B\\\\u009B][[\\\\]()#;?]*(?:(?:(?:[a-zA-Z\\\\d]*(?:;[-a-zA-Z\\\\d\\\\/#&.:=?%@~_]*)*)?\\\\u0007)|(?:(?:\\\\d{1,4}(?:;\\\\d{0,4})*)?[\\\\dA-PR-TZcf-ntqry=><~])))', 'g');\nexport function stripAnsiEscapes(str: string): string {\n  return str.replace(ansiRegex, '');\n}\n"],
+  "mappings": "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",
+  "names": ["path", "util", "url", "fs"]
+}

package/lib/utilsBundle.js

@@ -22,6 +22,7 @@ __export(utilsBundle_exports, {
   enquirer: () => enquirer,
   getEastAsianWidth: () => getEastAsianWidth,
   json5: () => json5,
+  parseMarkdown: () => parseMarkdown,
   sourceMapSupport: () => sourceMapSupport,
   stoppable: () => stoppable
 });
@@ -32,12 +33,18 @@ const stoppable = require("./utilsBundleImpl").stoppable;
 const enquirer = require("./utilsBundleImpl").enquirer;
 const chokidar = require("./utilsBundleImpl").chokidar;
 const getEastAsianWidth = require("./utilsBundleImpl").getEastAsianWidth;
+const { unified } = require("./utilsBundleImpl").unified;
+const remarkParse = require("./utilsBundleImpl").remarkParse;
+function parseMarkdown(content) {
+  return unified().use(remarkParse).parse(content);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   chokidar,
   enquirer,
   getEastAsianWidth,
   json5,
+  parseMarkdown,
   sourceMapSupport,
   stoppable
 });