pokeedex 0.1.0

data/node_modules/playwright/lib/runner/watchMode.js

@@ -0,0 +1,398 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runWatchModeLoop = runWatchModeLoop;
+var _readline = _interopRequireDefault(require("readline"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("playwright-core/lib/utils");
+var _utilsBundle = require("playwright-core/lib/utilsBundle");
+var _utilsBundle2 = require("../utilsBundle");
+var _base = require("../reporters/base");
+var _playwrightServer = require("playwright-core/lib/remote/playwrightServer");
+var _testServer = require("./testServer");
+var _stream = require("stream");
+var _testServerConnection = require("../isomorphic/testServerConnection");
+var _teleSuiteUpdater = require("../isomorphic/teleSuiteUpdater");
+var _configLoader = require("../common/configLoader");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * 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.
+ */
+
+class InMemoryTransport extends _stream.EventEmitter {
+  constructor(send) {
+    super();
+    this._send = void 0;
+    this._send = send;
+  }
+  close() {
+    this.emit('close');
+  }
+  onclose(listener) {
+    this.on('close', listener);
+  }
+  onerror(listener) {
+    // no-op to fulfil the interface, the user of InMemoryTransport doesn't emit any errors.
+  }
+  onmessage(listener) {
+    this.on('message', listener);
+  }
+  onopen(listener) {
+    this.on('open', listener);
+  }
+  send(data) {
+    this._send(data);
+  }
+}
+async function runWatchModeLoop(configLocation, initialOptions) {
+  if ((0, _configLoader.restartWithExperimentalTsEsm)(undefined, true)) return 'restarted';
+  const options = {
+    ...initialOptions
+  };
+  const testServerDispatcher = new _testServer.TestServerDispatcher(configLocation);
+  const transport = new InMemoryTransport(async data => {
+    const {
+      id,
+      method,
+      params
+    } = JSON.parse(data);
+    try {
+      const result = await testServerDispatcher.transport.dispatch(method, params);
+      transport.emit('message', JSON.stringify({
+        id,
+        result
+      }));
+    } catch (e) {
+      transport.emit('message', JSON.stringify({
+        id,
+        error: String(e)
+      }));
+    }
+  });
+  testServerDispatcher.transport.sendEvent = (method, params) => {
+    transport.emit('message', JSON.stringify({
+      method,
+      params
+    }));
+  };
+  const testServerConnection = new _testServerConnection.TestServerConnection(transport);
+  transport.emit('open');
+  const teleSuiteUpdater = new _teleSuiteUpdater.TeleSuiteUpdater({
+    pathSeparator: _path.default.sep,
+    onUpdate() {}
+  });
+  const dirtyTestIds = new Set();
+  let onDirtyTests = new _utils.ManualPromise();
+  let queue = Promise.resolve();
+  const changedFiles = new Set();
+  testServerConnection.onTestFilesChanged(({
+    testFiles
+  }) => {
+    testFiles.forEach(file => changedFiles.add(file));
+    queue = queue.then(async () => {
+      var _onDirtyTests$resolve, _onDirtyTests;
+      if (changedFiles.size === 0) return;
+      const {
+        report
+      } = await testServerConnection.listTests({
+        locations: options.files,
+        projects: options.projects,
+        grep: options.grep
+      });
+      teleSuiteUpdater.processListReport(report);
+      for (const test of teleSuiteUpdater.rootSuite.allTests()) {
+        if (changedFiles.has(test.location.file)) dirtyTestIds.add(test.id);
+      }
+      changedFiles.clear();
+      if (dirtyTestIds.size > 0) (_onDirtyTests$resolve = (_onDirtyTests = onDirtyTests).resolve) === null || _onDirtyTests$resolve === void 0 || _onDirtyTests$resolve.call(_onDirtyTests);
+    });
+  });
+  testServerConnection.onReport(report => teleSuiteUpdater.processTestReportEvent(report));
+  await testServerConnection.initialize({
+    interceptStdio: false,
+    watchTestDirs: true
+  });
+  await testServerConnection.runGlobalSetup({});
+  const {
+    report
+  } = await testServerConnection.listTests({
+    locations: options.files,
+    projects: options.projects,
+    grep: options.grep
+  });
+  teleSuiteUpdater.processListReport(report);
+  let lastRun = {
+    type: 'regular'
+  };
+  let result = 'passed';
+
+  // Enter the watch loop.
+  await runTests(options, testServerConnection);
+  while (true) {
+    printPrompt();
+    const readCommandPromise = readCommand();
+    await Promise.race([onDirtyTests, readCommandPromise]);
+    if (!readCommandPromise.isDone()) readCommandPromise.resolve('changed');
+    const command = await readCommandPromise;
+    if (command === 'changed') {
+      onDirtyTests = new _utils.ManualPromise();
+      const testIds = [...dirtyTestIds];
+      dirtyTestIds.clear();
+      await runTests(options, testServerConnection, {
+        testIds,
+        title: 'files changed'
+      });
+      lastRun = {
+        type: 'changed',
+        dirtyTestIds: testIds
+      };
+      continue;
+    }
+    if (command === 'run') {
+      // All means reset filters.
+      await runTests(options, testServerConnection);
+      lastRun = {
+        type: 'regular'
+      };
+      continue;
+    }
+    if (command === 'project') {
+      const {
+        selectedProjects
+      } = await _utilsBundle2.enquirer.prompt({
+        type: 'multiselect',
+        name: 'selectedProjects',
+        message: 'Select projects',
+        choices: teleSuiteUpdater.rootSuite.suites.map(s => s.title)
+      }).catch(() => ({
+        selectedProjects: null
+      }));
+      if (!selectedProjects) continue;
+      options.projects = selectedProjects.length ? selectedProjects : undefined;
+      await runTests(options, testServerConnection);
+      lastRun = {
+        type: 'regular'
+      };
+      continue;
+    }
+    if (command === 'file') {
+      const {
+        filePattern
+      } = await _utilsBundle2.enquirer.prompt({
+        type: 'text',
+        name: 'filePattern',
+        message: 'Input filename pattern (regex)'
+      }).catch(() => ({
+        filePattern: null
+      }));
+      if (filePattern === null) continue;
+      if (filePattern.trim()) options.files = filePattern.split(' ');else options.files = undefined;
+      await runTests(options, testServerConnection);
+      lastRun = {
+        type: 'regular'
+      };
+      continue;
+    }
+    if (command === 'grep') {
+      const {
+        testPattern
+      } = await _utilsBundle2.enquirer.prompt({
+        type: 'text',
+        name: 'testPattern',
+        message: 'Input test name pattern (regex)'
+      }).catch(() => ({
+        testPattern: null
+      }));
+      if (testPattern === null) continue;
+      if (testPattern.trim()) options.grep = testPattern;else options.grep = undefined;
+      await runTests(options, testServerConnection);
+      lastRun = {
+        type: 'regular'
+      };
+      continue;
+    }
+    if (command === 'failed') {
+      const failedTestIds = teleSuiteUpdater.rootSuite.allTests().filter(t => !t.ok()).map(t => t.id);
+      await runTests({}, testServerConnection, {
+        title: 'running failed tests',
+        testIds: failedTestIds
+      });
+      lastRun = {
+        type: 'failed',
+        failedTestIds
+      };
+      continue;
+    }
+    if (command === 'repeat') {
+      if (lastRun.type === 'regular') {
+        await runTests(options, testServerConnection, {
+          title: 're-running tests'
+        });
+        continue;
+      } else if (lastRun.type === 'changed') {
+        await runTests(options, testServerConnection, {
+          title: 're-running tests',
+          testIds: lastRun.dirtyTestIds
+        });
+      } else if (lastRun.type === 'failed') {
+        await runTests({}, testServerConnection, {
+          title: 're-running tests',
+          testIds: lastRun.failedTestIds
+        });
+      }
+      continue;
+    }
+    if (command === 'toggle-show-browser') {
+      await toggleShowBrowser();
+      continue;
+    }
+    if (command === 'exit') break;
+    if (command === 'interrupted') {
+      result = 'interrupted';
+      break;
+    }
+  }
+  const teardown = await testServerConnection.runGlobalTeardown({});
+  return result === 'passed' ? teardown.status : result;
+}
+async function runTests(watchOptions, testServerConnection, options) {
+  printConfiguration(watchOptions, options === null || options === void 0 ? void 0 : options.title);
+  await testServerConnection.runTests({
+    grep: watchOptions.grep,
+    testIds: options === null || options === void 0 ? void 0 : options.testIds,
+    locations: watchOptions === null || watchOptions === void 0 ? void 0 : watchOptions.files,
+    projects: watchOptions.projects,
+    connectWsEndpoint,
+    reuseContext: connectWsEndpoint ? true : undefined,
+    workers: connectWsEndpoint ? 1 : undefined,
+    headed: connectWsEndpoint ? true : undefined
+  });
+}
+function readCommand() {
+  const result = new _utils.ManualPromise();
+  const rl = _readline.default.createInterface({
+    input: process.stdin,
+    escapeCodeTimeout: 50
+  });
+  _readline.default.emitKeypressEvents(process.stdin, rl);
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
+  const handler = (text, key) => {
+    if (text === '\x03' || text === '\x1B' || key && key.name === 'escape' || key && key.ctrl && key.name === 'c') {
+      result.resolve('interrupted');
+      return;
+    }
+    if (process.platform !== 'win32' && key && key.ctrl && key.name === 'z') {
+      process.kill(process.ppid, 'SIGTSTP');
+      process.kill(process.pid, 'SIGTSTP');
+    }
+    const name = key === null || key === void 0 ? void 0 : key.name;
+    if (name === 'q') {
+      result.resolve('exit');
+      return;
+    }
+    if (name === 'h') {
+      process.stdout.write(`${(0, _base.separator)()}
+Run tests
+  ${_utilsBundle.colors.bold('enter')}    ${_utilsBundle.colors.dim('run tests')}
+  ${_utilsBundle.colors.bold('f')}        ${_utilsBundle.colors.dim('run failed tests')}
+  ${_utilsBundle.colors.bold('r')}        ${_utilsBundle.colors.dim('repeat last run')}
+  ${_utilsBundle.colors.bold('q')}        ${_utilsBundle.colors.dim('quit')}
+
+Change settings
+  ${_utilsBundle.colors.bold('c')}        ${_utilsBundle.colors.dim('set project')}
+  ${_utilsBundle.colors.bold('p')}        ${_utilsBundle.colors.dim('set file filter')}
+  ${_utilsBundle.colors.bold('t')}        ${_utilsBundle.colors.dim('set title filter')}
+  ${_utilsBundle.colors.bold('s')}        ${_utilsBundle.colors.dim('toggle show & reuse the browser')}
+`);
+      return;
+    }
+    switch (name) {
+      case 'return':
+        result.resolve('run');
+        break;
+      case 'r':
+        result.resolve('repeat');
+        break;
+      case 'c':
+        result.resolve('project');
+        break;
+      case 'p':
+        result.resolve('file');
+        break;
+      case 't':
+        result.resolve('grep');
+        break;
+      case 'f':
+        result.resolve('failed');
+        break;
+      case 's':
+        result.resolve('toggle-show-browser');
+        break;
+    }
+  };
+  process.stdin.on('keypress', handler);
+  void result.finally(() => {
+    process.stdin.off('keypress', handler);
+    rl.close();
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  });
+  return result;
+}
+let showBrowserServer;
+let connectWsEndpoint = undefined;
+let seq = 0;
+function printConfiguration(options, title) {
+  const packageManagerCommand = (0, _utils.getPackageManagerExecCommand)();
+  const tokens = [];
+  tokens.push(`${packageManagerCommand} playwright test`);
+  if (options.projects) tokens.push(...options.projects.map(p => _utilsBundle.colors.blue(`--project ${p}`)));
+  if (options.grep) tokens.push(_utilsBundle.colors.red(`--grep ${options.grep}`));
+  if (options.files) tokens.push(...options.files.map(a => _utilsBundle.colors.bold(a)));
+  if (title) tokens.push(_utilsBundle.colors.dim(`(${title})`));
+  if (seq) tokens.push(_utilsBundle.colors.dim(`#${seq}`));
+  ++seq;
+  const lines = [];
+  const sep = (0, _base.separator)();
+  lines.push('\x1Bc' + sep);
+  lines.push(`${tokens.join(' ')}`);
+  lines.push(`${_utilsBundle.colors.dim('Show & reuse browser:')} ${_utilsBundle.colors.bold(showBrowserServer ? 'on' : 'off')}`);
+  process.stdout.write(lines.join('\n'));
+}
+function printPrompt() {
+  const sep = (0, _base.separator)();
+  process.stdout.write(`
+${sep}
+${_utilsBundle.colors.dim('Waiting for file changes. Press')} ${_utilsBundle.colors.bold('enter')} ${_utilsBundle.colors.dim('to run tests')}, ${_utilsBundle.colors.bold('q')} ${_utilsBundle.colors.dim('to quit or')} ${_utilsBundle.colors.bold('h')} ${_utilsBundle.colors.dim('for more options.')}
+`);
+}
+async function toggleShowBrowser() {
+  if (!showBrowserServer) {
+    showBrowserServer = new _playwrightServer.PlaywrightServer({
+      mode: 'extension',
+      path: '/' + (0, _utils.createGuid)(),
+      maxConnections: 1
+    });
+    connectWsEndpoint = await showBrowserServer.listen();
+    process.stdout.write(`${_utilsBundle.colors.dim('Show & reuse browser:')} ${_utilsBundle.colors.bold('on')}\n`);
+  } else {
+    var _showBrowserServer;
+    await ((_showBrowserServer = showBrowserServer) === null || _showBrowserServer === void 0 ? void 0 : _showBrowserServer.close());
+    showBrowserServer = undefined;
+    connectWsEndpoint = undefined;
+    process.stdout.write(`${_utilsBundle.colors.dim('Show & reuse browser:')} ${_utilsBundle.colors.bold('off')}\n`);
+  }
+}

data/node_modules/playwright/lib/runner/workerHost.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WorkerHost = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _ipc = require("../common/ipc");
+var _processHost = require("./processHost");
+var _folders = require("../isomorphic/folders");
+var _utils = require("playwright-core/lib/utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright Microsoft Corporation. All rights reserved.
+ *
+ * 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.
+ */
+
+let lastWorkerIndex = 0;
+class WorkerHost extends _processHost.ProcessHost {
+  constructor(testGroup, parallelIndex, config, extraEnv, outputDir) {
+    const workerIndex = lastWorkerIndex++;
+    super(require.resolve('../worker/workerMain.js'), `worker-${workerIndex}`, {
+      ...extraEnv,
+      FORCE_COLOR: '1',
+      DEBUG_COLORS: '1'
+    });
+    this.parallelIndex = void 0;
+    this.workerIndex = void 0;
+    this._hash = void 0;
+    this._params = void 0;
+    this._didFail = false;
+    this.workerIndex = workerIndex;
+    this.parallelIndex = parallelIndex;
+    this._hash = testGroup.workerHash;
+    this._params = {
+      workerIndex: this.workerIndex,
+      parallelIndex,
+      repeatEachIndex: testGroup.repeatEachIndex,
+      projectId: testGroup.projectId,
+      config,
+      artifactsDir: _path.default.join(outputDir, (0, _folders.artifactsFolderName)(workerIndex))
+    };
+  }
+  async start() {
+    await _fs.default.promises.mkdir(this._params.artifactsDir, {
+      recursive: true
+    });
+    return await this.startRunner(this._params, {
+      onStdOut: chunk => this.emit('stdOut', (0, _ipc.stdioChunkToParams)(chunk)),
+      onStdErr: chunk => this.emit('stdErr', (0, _ipc.stdioChunkToParams)(chunk))
+    });
+  }
+  async onExit() {
+    await (0, _utils.removeFolders)([this._params.artifactsDir]);
+  }
+  async stop(didFail) {
+    if (didFail) this._didFail = true;
+    await super.stop();
+  }
+  runTestGroup(runPayload) {
+    this.sendMessageNoReply({
+      method: 'runTestGroup',
+      params: runPayload
+    });
+  }
+  hash() {
+    return this._hash;
+  }
+  didFail() {
+    return this._didFail;
+  }
+}
+exports.WorkerHost = WorkerHost;

data/node_modules/playwright/lib/third_party/tsconfig-loader.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tsConfigLoader = tsConfigLoader;
+exports.walkForTsConfig = walkForTsConfig;
+var path = _interopRequireWildcard(require("path"));
+var fs = _interopRequireWildcard(require("fs"));
+var _utilsBundle = require("../utilsBundle");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Jonas Kello
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/* eslint-disable */
+
+/**
+ * Typing for the parts of tsconfig that we care about
+ */
+
+function tsConfigLoader(tsconfigPathOrDirecotry) {
+  const configPath = resolveConfigPath(tsconfigPathOrDirecotry);
+  if (!configPath) return [];
+  const references = [];
+  const config = loadTsConfig(configPath, references);
+  return [config, ...references];
+}
+function resolveConfigPath(tsconfigPathOrDirecotry) {
+  if (fs.statSync(tsconfigPathOrDirecotry).isFile()) {
+    return path.resolve(tsconfigPathOrDirecotry);
+  }
+  const configAbsolutePath = walkForTsConfig(tsconfigPathOrDirecotry);
+  return configAbsolutePath ? path.resolve(configAbsolutePath) : undefined;
+}
+function walkForTsConfig(directory, existsSync = fs.existsSync) {
+  const tsconfigPath = path.join(directory, "./tsconfig.json");
+  if (existsSync(tsconfigPath)) {
+    return tsconfigPath;
+  }
+  const jsconfigPath = path.join(directory, "./jsconfig.json");
+  if (existsSync(jsconfigPath)) {
+    return jsconfigPath;
+  }
+  const parentDirectory = path.join(directory, "../");
+
+  // If we reached the top
+  if (directory === parentDirectory) {
+    return undefined;
+  }
+  return walkForTsConfig(parentDirectory, existsSync);
+}
+function resolveConfigFile(baseConfigFile, referencedConfigFile) {
+  if (!referencedConfigFile.endsWith('.json')) referencedConfigFile += '.json';
+  const currentDir = path.dirname(baseConfigFile);
+  let resolvedConfigFile = path.resolve(currentDir, referencedConfigFile);
+  // TODO: I don't see how this makes sense, delete in the next minor release.
+  if (referencedConfigFile.includes('/') && referencedConfigFile.includes('.') && !fs.existsSync(resolvedConfigFile)) resolvedConfigFile = path.join(currentDir, 'node_modules', referencedConfigFile);
+  return resolvedConfigFile;
+}
+function loadTsConfig(configFilePath, references, visited = new Map()) {
+  var _parsedConfig$compile, _parsedConfig$compile2, _parsedConfig$compile3;
+  if (visited.has(configFilePath)) return visited.get(configFilePath);
+  let result = {
+    tsConfigPath: configFilePath
+  };
+  // Retain result instance below, so that caching works.
+  visited.set(configFilePath, result);
+  if (!fs.existsSync(configFilePath)) return result;
+  const configString = fs.readFileSync(configFilePath, 'utf-8');
+  const cleanedJson = StripBom(configString);
+  const parsedConfig = _utilsBundle.json5.parse(cleanedJson);
+  const extendsArray = Array.isArray(parsedConfig.extends) ? parsedConfig.extends : parsedConfig.extends ? [parsedConfig.extends] : [];
+  for (const extendedConfig of extendsArray) {
+    const extendedConfigPath = resolveConfigFile(configFilePath, extendedConfig);
+    const base = loadTsConfig(extendedConfigPath, references, visited);
+    // Retain result instance, so that caching works.
+    Object.assign(result, base, {
+      tsConfigPath: configFilePath
+    });
+  }
+  if (((_parsedConfig$compile = parsedConfig.compilerOptions) === null || _parsedConfig$compile === void 0 ? void 0 : _parsedConfig$compile.allowJs) !== undefined) result.allowJs = parsedConfig.compilerOptions.allowJs;
+  if (((_parsedConfig$compile2 = parsedConfig.compilerOptions) === null || _parsedConfig$compile2 === void 0 ? void 0 : _parsedConfig$compile2.paths) !== undefined) {
+    // We must store pathsBasePath from the config that defines "paths" and later resolve
+    // based on this absolute path, when no "baseUrl" is specified. See tsc for reference:
+    // https://github.com/microsoft/TypeScript/blob/353ccb7688351ae33ccf6e0acb913aa30621eaf4/src/compiler/commandLineParser.ts#L3129
+    // https://github.com/microsoft/TypeScript/blob/353ccb7688351ae33ccf6e0acb913aa30621eaf4/src/compiler/moduleSpecifiers.ts#L510
+    result.paths = {
+      mapping: parsedConfig.compilerOptions.paths,
+      pathsBasePath: path.dirname(configFilePath)
+    };
+  }
+  if (((_parsedConfig$compile3 = parsedConfig.compilerOptions) === null || _parsedConfig$compile3 === void 0 ? void 0 : _parsedConfig$compile3.baseUrl) !== undefined) {
+    // Follow tsc and resolve all relative file paths in the config right away.
+    // This way it is safe to inherit paths between the configs.
+    result.absoluteBaseUrl = path.resolve(path.dirname(configFilePath), parsedConfig.compilerOptions.baseUrl);
+  }
+  for (const ref of parsedConfig.references || []) references.push(loadTsConfig(resolveConfigFile(configFilePath, ref.path), references, visited));
+  if (path.basename(configFilePath) === 'jsconfig.json' && result.allowJs === undefined) result.allowJs = true;
+  return result;
+}
+function StripBom(string) {
+  if (typeof string !== 'string') {
+    throw new TypeError(`Expected a string, got ${typeof string}`);
+  }
+
+  // Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
+  // conversion translates it to FEFF (UTF-16 BOM).
+  if (string.charCodeAt(0) === 0xFEFF) {
+    return string.slice(1);
+  }
+  return string;
+}

data/node_modules/playwright/lib/transform/babelBundle.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.types = exports.traverse = exports.parse = exports.declare = exports.codeFrameColumns = exports.babelTransform = void 0;
+/**
+ * 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 codeFrameColumns = exports.codeFrameColumns = require('./babelBundleImpl').codeFrameColumns;
+const declare = exports.declare = require('./babelBundleImpl').declare;
+const types = exports.types = require('./babelBundleImpl').types;
+const parse = exports.parse = require('./babelBundleImpl').parse;
+const traverse = exports.traverse = require('./babelBundleImpl').traverse;
+const babelTransform = exports.babelTransform = require('./babelBundleImpl').babelTransform;