pokeedex 0.1.0

data/node_modules/playwright/lib/isomorphic/teleSuiteUpdater.js

@@ -0,0 +1,149 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TeleSuiteUpdater = void 0;
+var _teleReceiver = require("./teleReceiver");
+var _testTree = require("./testTree");
+/**
+ * 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.
+ */
+
+class TeleSuiteUpdater {
+  constructor(options) {
+    this.rootSuite = void 0;
+    this.config = void 0;
+    this.loadErrors = [];
+    this.progress = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      skipped: 0
+    };
+    this._receiver = void 0;
+    this._lastRunReceiver = void 0;
+    this._lastRunTestCount = 0;
+    this._options = void 0;
+    this._testResultsSnapshot = void 0;
+    this._receiver = new _teleReceiver.TeleReporterReceiver(this._createReporter(), {
+      mergeProjects: true,
+      mergeTestCases: true,
+      resolvePath: (rootDir, relativePath) => rootDir + options.pathSeparator + relativePath,
+      clearPreviousResultsWhenTestBegins: true
+    });
+    this._options = options;
+  }
+  _createReporter() {
+    return {
+      version: () => 'v2',
+      onConfigure: c => {
+        this.config = c;
+        // TeleReportReceiver is merging everything into a single suite, so when we
+        // run one test, we still get many tests via rootSuite.allTests().length.
+        // To work around that, have a dedicated per-run receiver that will only have
+        // suite for a single test run, and hence will have correct total.
+        this._lastRunReceiver = new _teleReceiver.TeleReporterReceiver({
+          onBegin: suite => {
+            this._lastRunTestCount = suite.allTests().length;
+            this._lastRunReceiver = undefined;
+          }
+        }, {
+          mergeProjects: true,
+          mergeTestCases: false,
+          resolvePath: (rootDir, relativePath) => rootDir + this._options.pathSeparator + relativePath
+        });
+      },
+      onBegin: suite => {
+        if (!this.rootSuite) this.rootSuite = suite;
+        // As soon as new test tree is built add previous results, before calling onUpdate
+        // to avoid flashing empty results in the UI.
+        if (this._testResultsSnapshot) {
+          for (const test of this.rootSuite.allTests()) {
+            var _this$_testResultsSna;
+            test.results = ((_this$_testResultsSna = this._testResultsSnapshot) === null || _this$_testResultsSna === void 0 ? void 0 : _this$_testResultsSna.get(test.id)) || test.results;
+          }
+          this._testResultsSnapshot = undefined;
+        }
+        this.progress.total = this._lastRunTestCount;
+        this.progress.passed = 0;
+        this.progress.failed = 0;
+        this.progress.skipped = 0;
+        this._options.onUpdate(true);
+      },
+      onEnd: () => {
+        this._options.onUpdate(true);
+      },
+      onTestBegin: (test, testResult) => {
+        testResult[_testTree.statusEx] = 'running';
+        this._options.onUpdate();
+      },
+      onTestEnd: (test, testResult) => {
+        if (test.outcome() === 'skipped') ++this.progress.skipped;else if (test.outcome() === 'unexpected') ++this.progress.failed;else ++this.progress.passed;
+        testResult[_testTree.statusEx] = testResult.status;
+        this._options.onUpdate();
+      },
+      onError: error => this._handleOnError(error),
+      printsToStdio: () => {
+        return false;
+      },
+      onStdOut: () => {},
+      onStdErr: () => {},
+      onExit: () => {},
+      onStepBegin: () => {},
+      onStepEnd: () => {}
+    };
+  }
+  processGlobalReport(report) {
+    const receiver = new _teleReceiver.TeleReporterReceiver({
+      onConfigure: c => {
+        this.config = c;
+      },
+      onError: error => this._handleOnError(error)
+    });
+    for (const message of report) void receiver.dispatch(message);
+  }
+  processListReport(report) {
+    var _this$rootSuite;
+    // Save test results and reset all projects, the results will be restored after
+    // new project structure is built.
+    const tests = ((_this$rootSuite = this.rootSuite) === null || _this$rootSuite === void 0 ? void 0 : _this$rootSuite.allTests()) || [];
+    this._testResultsSnapshot = new Map(tests.map(test => [test.id, test.results]));
+    this._receiver.reset();
+    for (const message of report) void this._receiver.dispatch(message);
+  }
+  processTestReportEvent(message) {
+    var _this$_lastRunReceive, _this$_receiver$dispa;
+    // The order of receiver dispatches matters here, we want to assign `lastRunTestCount`
+    // before we use it.
+    (_this$_lastRunReceive = this._lastRunReceiver) === null || _this$_lastRunReceive === void 0 || (_this$_lastRunReceive = _this$_lastRunReceive.dispatch(message)) === null || _this$_lastRunReceive === void 0 || _this$_lastRunReceive.catch(() => {});
+    (_this$_receiver$dispa = this._receiver.dispatch(message)) === null || _this$_receiver$dispa === void 0 || _this$_receiver$dispa.catch(() => {});
+  }
+  _handleOnError(error) {
+    var _this$_options$onErro, _this$_options;
+    this.loadErrors.push(error);
+    (_this$_options$onErro = (_this$_options = this._options).onError) === null || _this$_options$onErro === void 0 || _this$_options$onErro.call(_this$_options, error);
+    this._options.onUpdate();
+  }
+  asModel() {
+    return {
+      rootSuite: this.rootSuite || new _teleReceiver.TeleSuite('', 'root'),
+      config: this.config,
+      loadErrors: this.loadErrors,
+      progress: this.progress
+    };
+  }
+}
+exports.TeleSuiteUpdater = TeleSuiteUpdater;

data/node_modules/playwright/lib/isomorphic/testServerConnection.js

@@ -0,0 +1,210 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WebSocketTestServerTransport = exports.TestServerConnection = void 0;
+var events = _interopRequireWildcard(require("./events"));
+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; }
+/**
+ * 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.
+ */
+
+// -- Reuse boundary -- Everything below this line is reused in the vscode extension.
+
+class WebSocketTestServerTransport {
+  constructor(url) {
+    this._ws = void 0;
+    this._ws = new WebSocket(url);
+  }
+  onmessage(listener) {
+    this._ws.addEventListener('message', event => listener(event.data));
+  }
+  onopen(listener) {
+    this._ws.addEventListener('open', listener);
+  }
+  onerror(listener) {
+    this._ws.addEventListener('error', listener);
+  }
+  onclose(listener) {
+    this._ws.addEventListener('close', listener);
+  }
+  send(data) {
+    this._ws.send(data);
+  }
+  close() {
+    this._ws.close();
+  }
+}
+exports.WebSocketTestServerTransport = WebSocketTestServerTransport;
+class TestServerConnection {
+  constructor(transport) {
+    this.onClose = void 0;
+    this.onReport = void 0;
+    this.onStdio = void 0;
+    this.onTestFilesChanged = void 0;
+    this.onLoadTraceRequested = void 0;
+    this._onCloseEmitter = new events.EventEmitter();
+    this._onReportEmitter = new events.EventEmitter();
+    this._onStdioEmitter = new events.EventEmitter();
+    this._onTestFilesChangedEmitter = new events.EventEmitter();
+    this._onLoadTraceRequestedEmitter = new events.EventEmitter();
+    this._lastId = 0;
+    this._transport = void 0;
+    this._callbacks = new Map();
+    this._connectedPromise = void 0;
+    this._isClosed = false;
+    this.onClose = this._onCloseEmitter.event;
+    this.onReport = this._onReportEmitter.event;
+    this.onStdio = this._onStdioEmitter.event;
+    this.onTestFilesChanged = this._onTestFilesChangedEmitter.event;
+    this.onLoadTraceRequested = this._onLoadTraceRequestedEmitter.event;
+    this._transport = transport;
+    this._transport.onmessage(data => {
+      const message = JSON.parse(data);
+      const {
+        id,
+        result,
+        error,
+        method,
+        params
+      } = message;
+      if (id) {
+        const callback = this._callbacks.get(id);
+        if (!callback) return;
+        this._callbacks.delete(id);
+        if (error) callback.reject(new Error(error));else callback.resolve(result);
+      } else {
+        this._dispatchEvent(method, params);
+      }
+    });
+    const pingInterval = setInterval(() => this._sendMessage('ping').catch(() => {}), 30000);
+    this._connectedPromise = new Promise((f, r) => {
+      this._transport.onopen(f);
+      this._transport.onerror(r);
+    });
+    this._transport.onclose(() => {
+      this._isClosed = true;
+      this._onCloseEmitter.fire();
+      clearInterval(pingInterval);
+    });
+  }
+  isClosed() {
+    return this._isClosed;
+  }
+  async _sendMessage(method, params) {
+    const logForTest = globalThis.__logForTest;
+    logForTest === null || logForTest === void 0 || logForTest({
+      method,
+      params
+    });
+    await this._connectedPromise;
+    const id = ++this._lastId;
+    const message = {
+      id,
+      method,
+      params
+    };
+    this._transport.send(JSON.stringify(message));
+    return new Promise((resolve, reject) => {
+      this._callbacks.set(id, {
+        resolve,
+        reject
+      });
+    });
+  }
+  _sendMessageNoReply(method, params) {
+    this._sendMessage(method, params).catch(() => {});
+  }
+  _dispatchEvent(method, params) {
+    if (method === 'report') this._onReportEmitter.fire(params);else if (method === 'stdio') this._onStdioEmitter.fire(params);else if (method === 'testFilesChanged') this._onTestFilesChangedEmitter.fire(params);else if (method === 'loadTraceRequested') this._onLoadTraceRequestedEmitter.fire(params);
+  }
+  async initialize(params) {
+    await this._sendMessage('initialize', params);
+  }
+  async ping(params) {
+    await this._sendMessage('ping', params);
+  }
+  async pingNoReply(params) {
+    this._sendMessageNoReply('ping', params);
+  }
+  async watch(params) {
+    await this._sendMessage('watch', params);
+  }
+  watchNoReply(params) {
+    this._sendMessageNoReply('watch', params);
+  }
+  async open(params) {
+    await this._sendMessage('open', params);
+  }
+  openNoReply(params) {
+    this._sendMessageNoReply('open', params);
+  }
+  async resizeTerminal(params) {
+    await this._sendMessage('resizeTerminal', params);
+  }
+  resizeTerminalNoReply(params) {
+    this._sendMessageNoReply('resizeTerminal', params);
+  }
+  async checkBrowsers(params) {
+    return await this._sendMessage('checkBrowsers', params);
+  }
+  async installBrowsers(params) {
+    await this._sendMessage('installBrowsers', params);
+  }
+  async runGlobalSetup(params) {
+    return await this._sendMessage('runGlobalSetup', params);
+  }
+  async runGlobalTeardown(params) {
+    return await this._sendMessage('runGlobalTeardown', params);
+  }
+  async startDevServer(params) {
+    return await this._sendMessage('startDevServer', params);
+  }
+  async stopDevServer(params) {
+    return await this._sendMessage('stopDevServer', params);
+  }
+  async clearCache(params) {
+    return await this._sendMessage('clearCache', params);
+  }
+  async listFiles(params) {
+    return await this._sendMessage('listFiles', params);
+  }
+  async listTests(params) {
+    return await this._sendMessage('listTests', params);
+  }
+  async runTests(params) {
+    return await this._sendMessage('runTests', params);
+  }
+  async findRelatedTestFiles(params) {
+    return await this._sendMessage('findRelatedTestFiles', params);
+  }
+  async stopTests(params) {
+    await this._sendMessage('stopTests', params);
+  }
+  stopTestsNoReply(params) {
+    this._sendMessageNoReply('stopTests', params);
+  }
+  async closeGracefully(params) {
+    await this._sendMessage('closeGracefully', params);
+  }
+  close() {
+    try {
+      this._transport.close();
+    } catch {}
+  }
+}
+exports.TestServerConnection = TestServerConnection;

data/node_modules/playwright/lib/isomorphic/testServerInterface.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

data/node_modules/playwright/lib/isomorphic/testTree.js

@@ -0,0 +1,272 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestTree = void 0;
+exports.collectTestIds = collectTestIds;
+exports.sortAndPropagateStatus = sortAndPropagateStatus;
+exports.statusEx = 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.
+ */
+
+// -- Reuse boundary -- Everything below this line is reused in the vscode extension.
+
+class TestTree {
+  constructor(rootFolder, rootSuite, loadErrors, projectFilters, pathSeparator) {
+    this.rootItem = void 0;
+    this._treeItemById = new Map();
+    this._treeItemByTestId = new Map();
+    this.pathSeparator = void 0;
+    const filterProjects = projectFilters && [...projectFilters.values()].some(Boolean);
+    this.pathSeparator = pathSeparator;
+    this.rootItem = {
+      kind: 'group',
+      subKind: 'folder',
+      id: rootFolder,
+      title: '',
+      location: {
+        file: '',
+        line: 0,
+        column: 0
+      },
+      duration: 0,
+      parent: undefined,
+      children: [],
+      status: 'none',
+      hasLoadErrors: false
+    };
+    this._treeItemById.set(rootFolder, this.rootItem);
+    const visitSuite = (project, parentSuite, parentGroup) => {
+      for (const suite of parentSuite.suites) {
+        const title = suite.title || '<anonymous>';
+        let group = parentGroup.children.find(item => item.kind === 'group' && item.title === title);
+        if (!group) {
+          group = {
+            kind: 'group',
+            subKind: 'describe',
+            id: 'suite:' + parentSuite.titlePath().join('\x1e') + '\x1e' + title,
+            // account for anonymous suites
+            title,
+            location: suite.location,
+            duration: 0,
+            parent: parentGroup,
+            children: [],
+            status: 'none',
+            hasLoadErrors: false
+          };
+          this._addChild(parentGroup, group);
+        }
+        visitSuite(project, suite, group);
+      }
+      for (const test of parentSuite.tests) {
+        const title = test.title;
+        let testCaseItem = parentGroup.children.find(t => t.kind !== 'group' && t.title === title);
+        if (!testCaseItem) {
+          testCaseItem = {
+            kind: 'case',
+            id: 'test:' + test.titlePath().join('\x1e'),
+            title,
+            parent: parentGroup,
+            children: [],
+            tests: [],
+            location: test.location,
+            duration: 0,
+            status: 'none',
+            project: undefined,
+            test: undefined,
+            tags: test.tags
+          };
+          this._addChild(parentGroup, testCaseItem);
+        }
+        const result = test.results[0];
+        let status = 'none';
+        if ((result === null || result === void 0 ? void 0 : result[statusEx]) === 'scheduled') status = 'scheduled';else if ((result === null || result === void 0 ? void 0 : result[statusEx]) === 'running') status = 'running';else if ((result === null || result === void 0 ? void 0 : result.status) === 'skipped') status = 'skipped';else if ((result === null || result === void 0 ? void 0 : result.status) === 'interrupted') status = 'none';else if (result && test.outcome() !== 'expected') status = 'failed';else if (result && test.outcome() === 'expected') status = 'passed';
+        testCaseItem.tests.push(test);
+        const testItem = {
+          kind: 'test',
+          id: test.id,
+          title: project.name,
+          location: test.location,
+          test,
+          parent: testCaseItem,
+          children: [],
+          status,
+          duration: test.results.length ? Math.max(0, test.results[0].duration) : 0,
+          project
+        };
+        this._addChild(testCaseItem, testItem);
+        this._treeItemByTestId.set(test.id, testItem);
+        testCaseItem.duration = testCaseItem.children.reduce((a, b) => a + b.duration, 0);
+      }
+    };
+    for (const projectSuite of (rootSuite === null || rootSuite === void 0 ? void 0 : rootSuite.suites) || []) {
+      if (filterProjects && !projectFilters.get(projectSuite.title)) continue;
+      for (const fileSuite of projectSuite.suites) {
+        const fileItem = this._fileItem(fileSuite.location.file.split(pathSeparator), true);
+        visitSuite(projectSuite.project(), fileSuite, fileItem);
+      }
+    }
+    for (const loadError of loadErrors) {
+      if (!loadError.location) continue;
+      const fileItem = this._fileItem(loadError.location.file.split(pathSeparator), true);
+      fileItem.hasLoadErrors = true;
+    }
+  }
+  _addChild(parent, child) {
+    parent.children.push(child);
+    child.parent = parent;
+    this._treeItemById.set(child.id, child);
+  }
+  filterTree(filterText, statusFilters, runningTestIds) {
+    const tokens = filterText.trim().toLowerCase().split(' ');
+    const filtersStatuses = [...statusFilters.values()].some(Boolean);
+    const filter = testCase => {
+      const titleWithTags = [...testCase.tests[0].titlePath(), ...testCase.tests[0].tags].join(' ').toLowerCase();
+      if (!tokens.every(token => titleWithTags.includes(token)) && !testCase.tests.some(t => runningTestIds === null || runningTestIds === void 0 ? void 0 : runningTestIds.has(t.id))) return false;
+      testCase.children = testCase.children.filter(test => {
+        return !filtersStatuses || (runningTestIds === null || runningTestIds === void 0 ? void 0 : runningTestIds.has(test.test.id)) || statusFilters.get(test.status);
+      });
+      testCase.tests = testCase.children.map(c => c.test);
+      return !!testCase.children.length;
+    };
+    const visit = treeItem => {
+      const newChildren = [];
+      for (const child of treeItem.children) {
+        if (child.kind === 'case') {
+          if (filter(child)) newChildren.push(child);
+        } else {
+          visit(child);
+          if (child.children.length || child.hasLoadErrors) newChildren.push(child);
+        }
+      }
+      treeItem.children = newChildren;
+    };
+    visit(this.rootItem);
+  }
+  _fileItem(filePath, isFile) {
+    if (filePath.length === 0) return this.rootItem;
+    const fileName = filePath.join(this.pathSeparator);
+    const existingFileItem = this._treeItemById.get(fileName);
+    if (existingFileItem) return existingFileItem;
+    const parentFileItem = this._fileItem(filePath.slice(0, filePath.length - 1), false);
+    const fileItem = {
+      kind: 'group',
+      subKind: isFile ? 'file' : 'folder',
+      id: fileName,
+      title: filePath[filePath.length - 1],
+      location: {
+        file: fileName,
+        line: 0,
+        column: 0
+      },
+      duration: 0,
+      parent: parentFileItem,
+      children: [],
+      status: 'none',
+      hasLoadErrors: false
+    };
+    this._addChild(parentFileItem, fileItem);
+    return fileItem;
+  }
+  sortAndPropagateStatus() {
+    sortAndPropagateStatus(this.rootItem);
+  }
+  flattenForSingleProject() {
+    const visit = treeItem => {
+      if (treeItem.kind === 'case' && treeItem.children.length === 1) {
+        treeItem.project = treeItem.children[0].project;
+        treeItem.test = treeItem.children[0].test;
+        treeItem.children = [];
+        this._treeItemByTestId.set(treeItem.test.id, treeItem);
+      } else {
+        treeItem.children.forEach(visit);
+      }
+    };
+    visit(this.rootItem);
+  }
+  shortenRoot() {
+    let shortRoot = this.rootItem;
+    while (shortRoot.children.length === 1 && shortRoot.children[0].kind === 'group' && shortRoot.children[0].subKind === 'folder') shortRoot = shortRoot.children[0];
+    shortRoot.location = this.rootItem.location;
+    this.rootItem = shortRoot;
+  }
+  testIds() {
+    const result = new Set();
+    const visit = treeItem => {
+      if (treeItem.kind === 'case') treeItem.tests.forEach(t => result.add(t.id));
+      treeItem.children.forEach(visit);
+    };
+    visit(this.rootItem);
+    return result;
+  }
+  fileNames() {
+    const result = new Set();
+    const visit = treeItem => {
+      if (treeItem.kind === 'group' && treeItem.subKind === 'file') result.add(treeItem.id);else treeItem.children.forEach(visit);
+    };
+    visit(this.rootItem);
+    return [...result];
+  }
+  flatTreeItems() {
+    const result = [];
+    const visit = treeItem => {
+      result.push(treeItem);
+      treeItem.children.forEach(visit);
+    };
+    visit(this.rootItem);
+    return result;
+  }
+  treeItemById(id) {
+    return this._treeItemById.get(id);
+  }
+  collectTestIds(treeItem) {
+    return treeItem ? collectTestIds(treeItem) : new Set();
+  }
+}
+exports.TestTree = TestTree;
+function sortAndPropagateStatus(treeItem) {
+  for (const child of treeItem.children) sortAndPropagateStatus(child);
+  if (treeItem.kind === 'group') {
+    treeItem.children.sort((a, b) => {
+      const fc = a.location.file.localeCompare(b.location.file);
+      return fc || a.location.line - b.location.line;
+    });
+  }
+  let allPassed = treeItem.children.length > 0;
+  let allSkipped = treeItem.children.length > 0;
+  let hasFailed = false;
+  let hasRunning = false;
+  let hasScheduled = false;
+  for (const child of treeItem.children) {
+    allSkipped = allSkipped && child.status === 'skipped';
+    allPassed = allPassed && (child.status === 'passed' || child.status === 'skipped');
+    hasFailed = hasFailed || child.status === 'failed';
+    hasRunning = hasRunning || child.status === 'running';
+    hasScheduled = hasScheduled || child.status === 'scheduled';
+  }
+  if (hasRunning) treeItem.status = 'running';else if (hasScheduled) treeItem.status = 'scheduled';else if (hasFailed) treeItem.status = 'failed';else if (allSkipped) treeItem.status = 'skipped';else if (allPassed) treeItem.status = 'passed';
+}
+function collectTestIds(treeItem) {
+  const testIds = new Set();
+  const visit = treeItem => {
+    var _treeItem$children;
+    if (treeItem.kind === 'case') treeItem.tests.map(t => t.id).forEach(id => testIds.add(id));else if (treeItem.kind === 'test') testIds.add(treeItem.id);else (_treeItem$children = treeItem.children) === null || _treeItem$children === void 0 || _treeItem$children.forEach(visit);
+  };
+  visit(treeItem);
+  return testIds;
+}
+const statusEx = exports.statusEx = Symbol('statusEx');

data/node_modules/playwright/lib/loader/loaderMain.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.create = exports.LoaderMain = void 0;
+var _configLoader = require("../common/configLoader");
+var _process = require("../common/process");
+var _testLoader = require("../common/testLoader");
+var _compilationCache = require("../transform/compilationCache");
+var _poolBuilder = require("../common/poolBuilder");
+var _esmLoaderHost = require("../common/esmLoaderHost");
+/**
+ * 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 LoaderMain extends _process.ProcessRunner {
+  constructor(serializedConfig) {
+    super();
+    this._serializedConfig = void 0;
+    this._configPromise = void 0;
+    this._poolBuilder = _poolBuilder.PoolBuilder.createForLoader();
+    this._serializedConfig = serializedConfig;
+  }
+  _config() {
+    if (!this._configPromise) this._configPromise = (0, _configLoader.deserializeConfig)(this._serializedConfig);
+    return this._configPromise;
+  }
+  async loadTestFile(params) {
+    const testErrors = [];
+    const config = await this._config();
+    const fileSuite = await (0, _testLoader.loadTestFile)(params.file, config.config.rootDir, testErrors);
+    this._poolBuilder.buildPools(fileSuite);
+    return {
+      fileSuite: fileSuite._deepSerialize(),
+      testErrors
+    };
+  }
+  async getCompilationCacheFromLoader() {
+    await (0, _esmLoaderHost.incorporateCompilationCache)();
+    return (0, _compilationCache.serializeCompilationCache)();
+  }
+}
+exports.LoaderMain = LoaderMain;
+const create = config => new LoaderMain(config);
+exports.create = create;