@smoothdeploy/playwright-core 1.57.1 → 1.58.1-beta-1770452953000

package/lib/vite/traceViewer/uiMode.Wi-DvIEY.js

@@ -0,0 +1,1829 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["./assets/xtermModule-DDw6eROI.js","./xtermModule.BKlWQB97.css"])))=>i.map(i=>d[i]);
+import { u as useMeasure, r as reactExports, f as currentTheme, _ as __vitePreload, g as addThemeListener, h as removeThemeListener, j as jsxRuntimeExports, R as React, E as Expandable, s as settings, i as clsx, k as TreeView, t as testStatusIcon, m as msToString, l as Toolbar, n as ToolbarButton, M as MultiTraceModel, b as Workbench, o as useSetting, T as TestServerConnection, W as WebSocketTestServerTransport, S as SplitView, p as SettingsView, a as DefaultSettingsView, d as applyTheme, e as clientExports } from "./assets/defaultSettingsView-JtyB0yzL.js";
+var define_process_env_default = {};
+class TeleReporterReceiver {
+  constructor(reporter, options = {}) {
+    this.isListing = false;
+    this._tests = /* @__PURE__ */ new Map();
+    this._rootSuite = new TeleSuite("", "root");
+    this._options = options;
+    this._reporter = reporter;
+  }
+  reset() {
+    this._rootSuite._entries = [];
+    this._tests.clear();
+  }
+  dispatch(message) {
+    const { method, params } = message;
+    if (method === "onConfigure") {
+      this._onConfigure(params.config);
+      return;
+    }
+    if (method === "onProject") {
+      this._onProject(params.project);
+      return;
+    }
+    if (method === "onBegin") {
+      this._onBegin();
+      return;
+    }
+    if (method === "onTestBegin") {
+      this._onTestBegin(params.testId, params.result);
+      return;
+    }
+    if (method === "onTestEnd") {
+      this._onTestEnd(params.test, params.result);
+      return;
+    }
+    if (method === "onStepBegin") {
+      this._onStepBegin(params.testId, params.resultId, params.step);
+      return;
+    }
+    if (method === "onAttach") {
+      this._onAttach(params.testId, params.resultId, params.attachments);
+      return;
+    }
+    if (method === "onStepEnd") {
+      this._onStepEnd(params.testId, params.resultId, params.step);
+      return;
+    }
+    if (method === "onError") {
+      this._onError(params.error);
+      return;
+    }
+    if (method === "onStdIO") {
+      this._onStdIO(params.type, params.testId, params.resultId, params.data, params.isBase64);
+      return;
+    }
+    if (method === "onEnd")
+      return this._onEnd(params.result);
+    if (method === "onExit")
+      return this._onExit();
+  }
+  _onConfigure(config) {
+    var _a, _b;
+    this._rootDir = config.rootDir;
+    this._config = this._parseConfig(config);
+    (_b = (_a = this._reporter).onConfigure) == null ? void 0 : _b.call(_a, this._config);
+  }
+  _onProject(project) {
+    let projectSuite = this._options.mergeProjects ? this._rootSuite.suites.find((suite) => suite.project().name === project.name) : void 0;
+    if (!projectSuite) {
+      projectSuite = new TeleSuite(project.name, "project");
+      this._rootSuite._addSuite(projectSuite);
+    }
+    projectSuite._project = this._parseProject(project);
+    for (const suite of project.suites)
+      this._mergeSuiteInto(suite, projectSuite);
+  }
+  _onBegin() {
+    var _a, _b;
+    (_b = (_a = this._reporter).onBegin) == null ? void 0 : _b.call(_a, this._rootSuite);
+  }
+  _onTestBegin(testId, payload) {
+    var _a, _b;
+    const test = this._tests.get(testId);
+    if (this._options.clearPreviousResultsWhenTestBegins)
+      test.results = [];
+    const testResult = test._createTestResult(payload.id);
+    testResult.retry = payload.retry;
+    testResult.workerIndex = payload.workerIndex;
+    testResult.parallelIndex = payload.parallelIndex;
+    testResult.setStartTimeNumber(payload.startTime);
+    (_b = (_a = this._reporter).onTestBegin) == null ? void 0 : _b.call(_a, test, testResult);
+  }
+  _onTestEnd(testEndPayload, payload) {
+    var _a, _b, _c;
+    const test = this._tests.get(testEndPayload.testId);
+    test.timeout = testEndPayload.timeout;
+    test.expectedStatus = testEndPayload.expectedStatus;
+    const result = test.results.find((r) => r._id === payload.id);
+    result.duration = payload.duration;
+    result.status = payload.status;
+    result.errors = payload.errors;
+    result.error = (_a = result.errors) == null ? void 0 : _a[0];
+    if (!!payload.attachments)
+      result.attachments = this._parseAttachments(payload.attachments);
+    if (payload.annotations) {
+      this._absoluteAnnotationLocationsInplace(payload.annotations);
+      result.annotations = payload.annotations;
+      test.annotations = payload.annotations;
+    }
+    (_c = (_b = this._reporter).onTestEnd) == null ? void 0 : _c.call(_b, test, result);
+    result._stepMap = /* @__PURE__ */ new Map();
+  }
+  _onStepBegin(testId, resultId, payload) {
+    var _a, _b;
+    const test = this._tests.get(testId);
+    const result = test.results.find((r) => r._id === resultId);
+    const parentStep = payload.parentStepId ? result._stepMap.get(payload.parentStepId) : void 0;
+    const location = this._absoluteLocation(payload.location);
+    const step = new TeleTestStep(payload, parentStep, location, result);
+    if (parentStep)
+      parentStep.steps.push(step);
+    else
+      result.steps.push(step);
+    result._stepMap.set(payload.id, step);
+    (_b = (_a = this._reporter).onStepBegin) == null ? void 0 : _b.call(_a, test, result, step);
+  }
+  _onStepEnd(testId, resultId, payload) {
+    var _a, _b;
+    const test = this._tests.get(testId);
+    const result = test.results.find((r) => r._id === resultId);
+    const step = result._stepMap.get(payload.id);
+    step._endPayload = payload;
+    step.duration = payload.duration;
+    step.error = payload.error;
+    (_b = (_a = this._reporter).onStepEnd) == null ? void 0 : _b.call(_a, test, result, step);
+  }
+  _onAttach(testId, resultId, attachments) {
+    const test = this._tests.get(testId);
+    const result = test.results.find((r) => r._id === resultId);
+    result.attachments.push(...attachments.map((a) => ({
+      name: a.name,
+      contentType: a.contentType,
+      path: a.path,
+      body: a.base64 && globalThis.Buffer ? Buffer.from(a.base64, "base64") : void 0
+    })));
+  }
+  _onError(error) {
+    var _a, _b;
+    (_b = (_a = this._reporter).onError) == null ? void 0 : _b.call(_a, error);
+  }
+  _onStdIO(type, testId, resultId, data, isBase64) {
+    var _a, _b, _c, _d;
+    const chunk = isBase64 ? globalThis.Buffer ? Buffer.from(data, "base64") : atob(data) : data;
+    const test = testId ? this._tests.get(testId) : void 0;
+    const result = test && resultId ? test.results.find((r) => r._id === resultId) : void 0;
+    if (type === "stdout") {
+      result == null ? void 0 : result.stdout.push(chunk);
+      (_b = (_a = this._reporter).onStdOut) == null ? void 0 : _b.call(_a, chunk, test, result);
+    } else {
+      result == null ? void 0 : result.stderr.push(chunk);
+      (_d = (_c = this._reporter).onStdErr) == null ? void 0 : _d.call(_c, chunk, test, result);
+    }
+  }
+  async _onEnd(result) {
+    var _a, _b;
+    await ((_b = (_a = this._reporter).onEnd) == null ? void 0 : _b.call(_a, {
+      status: result.status,
+      startTime: new Date(result.startTime),
+      duration: result.duration
+    }));
+  }
+  _onExit() {
+    var _a, _b;
+    return (_b = (_a = this._reporter).onExit) == null ? void 0 : _b.call(_a);
+  }
+  _parseConfig(config) {
+    const result = { ...baseFullConfig, ...config };
+    if (this._options.configOverrides) {
+      result.configFile = this._options.configOverrides.configFile;
+      result.reportSlowTests = this._options.configOverrides.reportSlowTests;
+      result.quiet = this._options.configOverrides.quiet;
+      result.reporter = [...this._options.configOverrides.reporter];
+    }
+    return result;
+  }
+  _parseProject(project) {
+    return {
+      metadata: project.metadata,
+      name: project.name,
+      outputDir: this._absolutePath(project.outputDir),
+      repeatEach: project.repeatEach,
+      retries: project.retries,
+      testDir: this._absolutePath(project.testDir),
+      testIgnore: parseRegexPatterns(project.testIgnore),
+      testMatch: parseRegexPatterns(project.testMatch),
+      timeout: project.timeout,
+      grep: parseRegexPatterns(project.grep),
+      grepInvert: parseRegexPatterns(project.grepInvert),
+      dependencies: project.dependencies,
+      teardown: project.teardown,
+      snapshotDir: this._absolutePath(project.snapshotDir),
+      use: project.use
+    };
+  }
+  _parseAttachments(attachments) {
+    return attachments.map((a) => {
+      return {
+        ...a,
+        body: a.base64 && globalThis.Buffer ? Buffer.from(a.base64, "base64") : void 0
+      };
+    });
+  }
+  _mergeSuiteInto(jsonSuite, parent) {
+    let targetSuite = parent.suites.find((s) => s.title === jsonSuite.title);
+    if (!targetSuite) {
+      targetSuite = new TeleSuite(jsonSuite.title, parent.type === "project" ? "file" : "describe");
+      parent._addSuite(targetSuite);
+    }
+    targetSuite.location = this._absoluteLocation(jsonSuite.location);
+    jsonSuite.entries.forEach((e) => {
+      if ("testId" in e)
+        this._mergeTestInto(e, targetSuite);
+      else
+        this._mergeSuiteInto(e, targetSuite);
+    });
+  }
+  _mergeTestInto(jsonTest, parent) {
+    let targetTest = this._options.mergeTestCases ? parent.tests.find((s) => s.title === jsonTest.title && s.repeatEachIndex === jsonTest.repeatEachIndex) : void 0;
+    if (!targetTest) {
+      targetTest = new TeleTestCase(jsonTest.testId, jsonTest.title, this._absoluteLocation(jsonTest.location), jsonTest.repeatEachIndex);
+      parent._addTest(targetTest);
+      this._tests.set(targetTest.id, targetTest);
+    }
+    this._updateTest(jsonTest, targetTest);
+  }
+  _updateTest(payload, test) {
+    test.id = payload.testId;
+    test.location = this._absoluteLocation(payload.location);
+    test.retries = payload.retries;
+    test.tags = payload.tags ?? [];
+    test.annotations = payload.annotations ?? [];
+    this._absoluteAnnotationLocationsInplace(test.annotations);
+    return test;
+  }
+  _absoluteAnnotationLocationsInplace(annotations) {
+    for (const annotation of annotations) {
+      if (annotation.location)
+        annotation.location = this._absoluteLocation(annotation.location);
+    }
+  }
+  _absoluteLocation(location) {
+    if (!location)
+      return location;
+    return {
+      ...location,
+      file: this._absolutePath(location.file)
+    };
+  }
+  _absolutePath(relativePath) {
+    if (relativePath === void 0)
+      return;
+    return this._options.resolvePath ? this._options.resolvePath(this._rootDir, relativePath) : this._rootDir + "/" + relativePath;
+  }
+}
+class TeleSuite {
+  constructor(title, type) {
+    this._entries = [];
+    this._requireFile = "";
+    this._parallelMode = "none";
+    this.title = title;
+    this._type = type;
+  }
+  get type() {
+    return this._type;
+  }
+  get suites() {
+    return this._entries.filter((e) => e.type !== "test");
+  }
+  get tests() {
+    return this._entries.filter((e) => e.type === "test");
+  }
+  entries() {
+    return this._entries;
+  }
+  allTests() {
+    const result = [];
+    const visit = (suite) => {
+      for (const entry of suite.entries()) {
+        if (entry.type === "test")
+          result.push(entry);
+        else
+          visit(entry);
+      }
+    };
+    visit(this);
+    return result;
+  }
+  titlePath() {
+    const titlePath = this.parent ? this.parent.titlePath() : [];
+    if (this.title || this._type !== "describe")
+      titlePath.push(this.title);
+    return titlePath;
+  }
+  project() {
+    var _a;
+    return this._project ?? ((_a = this.parent) == null ? void 0 : _a.project());
+  }
+  _addTest(test) {
+    test.parent = this;
+    this._entries.push(test);
+  }
+  _addSuite(suite) {
+    suite.parent = this;
+    this._entries.push(suite);
+  }
+}
+class TeleTestCase {
+  constructor(id, title, location, repeatEachIndex) {
+    this.fn = () => {
+    };
+    this.results = [];
+    this.type = "test";
+    this.expectedStatus = "passed";
+    this.timeout = 0;
+    this.annotations = [];
+    this.retries = 0;
+    this.tags = [];
+    this.repeatEachIndex = 0;
+    this.id = id;
+    this.title = title;
+    this.location = location;
+    this.repeatEachIndex = repeatEachIndex;
+  }
+  titlePath() {
+    const titlePath = this.parent ? this.parent.titlePath() : [];
+    titlePath.push(this.title);
+    return titlePath;
+  }
+  outcome() {
+    return computeTestCaseOutcome(this);
+  }
+  ok() {
+    const status = this.outcome();
+    return status === "expected" || status === "flaky" || status === "skipped";
+  }
+  _createTestResult(id) {
+    const result = new TeleTestResult(this.results.length, id);
+    this.results.push(result);
+    return result;
+  }
+}
+class TeleTestStep {
+  constructor(payload, parentStep, location, result) {
+    this.duration = -1;
+    this.steps = [];
+    this._startTime = 0;
+    this.title = payload.title;
+    this.category = payload.category;
+    this.location = location;
+    this.parent = parentStep;
+    this._startTime = payload.startTime;
+    this._result = result;
+  }
+  titlePath() {
+    var _a;
+    const parentPath = ((_a = this.parent) == null ? void 0 : _a.titlePath()) || [];
+    return [...parentPath, this.title];
+  }
+  get startTime() {
+    return new Date(this._startTime);
+  }
+  set startTime(value) {
+    this._startTime = +value;
+  }
+  get attachments() {
+    var _a, _b;
+    return ((_b = (_a = this._endPayload) == null ? void 0 : _a.attachments) == null ? void 0 : _b.map((index) => this._result.attachments[index])) ?? [];
+  }
+  get annotations() {
+    var _a;
+    return ((_a = this._endPayload) == null ? void 0 : _a.annotations) ?? [];
+  }
+}
+class TeleTestResult {
+  constructor(retry, id) {
+    this.parallelIndex = -1;
+    this.workerIndex = -1;
+    this.duration = -1;
+    this.stdout = [];
+    this.stderr = [];
+    this.attachments = [];
+    this.annotations = [];
+    this.status = "skipped";
+    this.steps = [];
+    this.errors = [];
+    this._stepMap = /* @__PURE__ */ new Map();
+    this._startTime = 0;
+    this.retry = retry;
+    this._id = id;
+  }
+  setStartTimeNumber(startTime) {
+    this._startTime = startTime;
+  }
+  get startTime() {
+    return new Date(this._startTime);
+  }
+  set startTime(value) {
+    this._startTime = +value;
+  }
+}
+const baseFullConfig = {
+  forbidOnly: false,
+  fullyParallel: false,
+  globalSetup: null,
+  globalTeardown: null,
+  globalTimeout: 0,
+  grep: /.*/,
+  grepInvert: null,
+  maxFailures: 0,
+  metadata: {},
+  preserveOutput: "always",
+  projects: [],
+  reporter: [[define_process_env_default.CI ? "dot" : "list"]],
+  reportSlowTests: {
+    max: 5,
+    threshold: 3e5
+    /* 5 minutes */
+  },
+  configFile: "",
+  rootDir: "",
+  quiet: false,
+  shard: null,
+  tags: [],
+  updateSnapshots: "missing",
+  updateSourceMethod: "patch",
+  version: "",
+  workers: 0,
+  webServer: null
+};
+function parseRegexPatterns(patterns) {
+  return patterns.map((p) => {
+    if (p.s !== void 0)
+      return p.s;
+    return new RegExp(p.r.source, p.r.flags);
+  });
+}
+function computeTestCaseOutcome(test) {
+  let skipped = 0;
+  let expected = 0;
+  let unexpected = 0;
+  for (const result of test.results) {
+    if (result.status === "interrupted") ;
+    else if (result.status === "skipped" && test.expectedStatus === "skipped") {
+      ++skipped;
+    } else if (result.status === "skipped") ;
+    else if (result.status === test.expectedStatus) {
+      ++expected;
+    } else {
+      ++unexpected;
+    }
+  }
+  if (expected === 0 && unexpected === 0)
+    return "skipped";
+  if (unexpected === 0)
+    return "expected";
+  if (expected === 0 && skipped === 0)
+    return "unexpected";
+  return "flaky";
+}
+class TestTree {
+  constructor(rootFolder, rootSuite, loadErrors, projectFilters, pathSeparator, hideFiles) {
+    this._treeItemById = /* @__PURE__ */ new Map();
+    this._treeItemByTestId = /* @__PURE__ */ new Map();
+    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: void 0,
+      children: [],
+      status: "none",
+      hasLoadErrors: false
+    };
+    this._treeItemById.set(rootFolder, this.rootItem);
+    const visitSuite = (project, parentSuite, parentGroup, mode) => {
+      for (const suite of mode === "tests" ? [] : parentSuite.suites) {
+        if (!suite.title) {
+          visitSuite(project, suite, parentGroup, "all");
+          continue;
+        }
+        let group = parentGroup.children.find((item) => item.kind === "group" && item.title === suite.title);
+        if (!group) {
+          group = {
+            kind: "group",
+            subKind: "describe",
+            id: "suite:" + parentSuite.titlePath().join("") + "" + suite.title,
+            // account for anonymous suites
+            title: suite.title,
+            location: suite.location,
+            duration: 0,
+            parent: parentGroup,
+            children: [],
+            status: "none",
+            hasLoadErrors: false
+          };
+          this._addChild(parentGroup, group);
+        }
+        visitSuite(project, suite, group, "all");
+      }
+      for (const test of mode === "suites" ? [] : 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(""),
+            title,
+            parent: parentGroup,
+            children: [],
+            tests: [],
+            location: test.location,
+            duration: 0,
+            status: "none",
+            project: void 0,
+            test: void 0,
+            tags: test.tags
+          };
+          this._addChild(parentGroup, testCaseItem);
+        }
+        const result = test.results[0];
+        let status = "none";
+        if ((result == null ? void 0 : result[statusEx]) === "scheduled")
+          status = "scheduled";
+        else if ((result == null ? void 0 : result[statusEx]) === "running")
+          status = "running";
+        else if ((result == null ? void 0 : result.status) === "skipped")
+          status = "skipped";
+        else if ((result == null ? 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 ? void 0 : rootSuite.suites) || []) {
+      if (filterProjects && !projectFilters.get(projectSuite.title))
+        continue;
+      for (const fileSuite of projectSuite.suites) {
+        if (hideFiles) {
+          visitSuite(projectSuite.project(), fileSuite, this.rootItem, "suites");
+          if (fileSuite.tests.length) {
+            const defaultDescribeItem = this._defaultDescribeItem();
+            visitSuite(projectSuite.project(), fileSuite, defaultDescribeItem, "tests");
+          }
+        } else {
+          const fileItem = this._fileItem(fileSuite.location.file.split(pathSeparator), true);
+          visitSuite(projectSuite.project(), fileSuite, fileItem, "all");
+        }
+      }
+    }
+    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 ? void 0 : runningTestIds.has(t.id)))
+        return false;
+      testCase.children = testCase.children.filter((test) => {
+        return !filtersStatuses || (runningTestIds == null ? 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;
+  }
+  _defaultDescribeItem() {
+    let defaultDescribeItem = this._treeItemById.get("<anonymous>");
+    if (!defaultDescribeItem) {
+      defaultDescribeItem = {
+        kind: "group",
+        subKind: "describe",
+        id: "<anonymous>",
+        title: "<anonymous>",
+        location: { file: "", line: 0, column: 0 },
+        duration: 0,
+        parent: this.rootItem,
+        children: [],
+        status: "none",
+        hasLoadErrors: false
+      };
+      this._addChild(this.rootItem, defaultDescribeItem);
+    }
+    return defaultDescribeItem;
+  }
+  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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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) : /* @__PURE__ */ new Set();
+  }
+}
+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 = /* @__PURE__ */ new Set();
+  const visit = (treeItem2) => {
+    var _a;
+    if (treeItem2.kind === "case")
+      treeItem2.tests.map((t) => t.id).forEach((id) => testIds.add(id));
+    else if (treeItem2.kind === "test")
+      testIds.add(treeItem2.id);
+    else
+      (_a = treeItem2.children) == null ? void 0 : _a.forEach(visit);
+  };
+  visit(treeItem);
+  return testIds;
+}
+const statusEx = Symbol("statusEx");
+class TeleSuiteUpdater {
+  constructor(options) {
+    this.loadErrors = [];
+    this.progress = {
+      total: 0,
+      passed: 0,
+      failed: 0,
+      skipped: 0
+    };
+    this._lastRunTestCount = 0;
+    this._receiver = new 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;
+        this._lastRunReceiver = new TeleReporterReceiver({
+          version: () => "v2",
+          onBegin: (suite) => {
+            this._lastRunTestCount = suite.allTests().length;
+            this._lastRunReceiver = void 0;
+          }
+        }, {
+          mergeProjects: true,
+          mergeTestCases: false,
+          resolvePath: (rootDir, relativePath) => rootDir + this._options.pathSeparator + relativePath
+        });
+      },
+      onBegin: (suite) => {
+        var _a;
+        if (!this.rootSuite)
+          this.rootSuite = suite;
+        if (this._testResultsSnapshot) {
+          for (const test of this.rootSuite.allTests())
+            test.results = ((_a = this._testResultsSnapshot) == null ? void 0 : _a.get(test.id)) || test.results;
+          this._testResultsSnapshot = void 0;
+        }
+        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[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[statusEx] = testResult.status;
+        this._options.onUpdate();
+      },
+      onError: (error) => this._handleOnError(error),
+      printsToStdio: () => false
+    };
+  }
+  processGlobalReport(report) {
+    const receiver = new TeleReporterReceiver({
+      version: () => "v2",
+      onConfigure: (c) => {
+        this.config = c;
+      },
+      onError: (error) => this._handleOnError(error)
+    });
+    for (const message of report)
+      void receiver.dispatch(message);
+  }
+  processListReport(report) {
+    var _a;
+    const tests = ((_a = this.rootSuite) == null ? void 0 : _a.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 _a, _b, _c;
+    (_b = (_a = this._lastRunReceiver) == null ? void 0 : _a.dispatch(message)) == null ? void 0 : _b.catch(() => {
+    });
+    (_c = this._receiver.dispatch(message)) == null ? void 0 : _c.catch(() => {
+    });
+  }
+  _handleOnError(error) {
+    var _a, _b;
+    this.loadErrors.push(error);
+    (_b = (_a = this._options).onError) == null ? void 0 : _b.call(_a, error);
+    this._options.onUpdate();
+  }
+  asModel() {
+    return {
+      rootSuite: this.rootSuite || new TeleSuite("", "root"),
+      config: this.config,
+      loadErrors: this.loadErrors,
+      progress: this.progress
+    };
+  }
+}
+const XtermWrapper = ({
+  source
+}) => {
+  const [measure, xtermElement] = useMeasure();
+  const [theme, setTheme] = reactExports.useState(currentTheme());
+  const [modulePromise] = reactExports.useState(__vitePreload(() => import("./assets/xtermModule-DDw6eROI.js"), true ? __vite__mapDeps([0,1]) : void 0, import.meta.url).then((m) => m.default));
+  const terminal = reactExports.useRef(null);
+  reactExports.useEffect(() => {
+    addThemeListener(setTheme);
+    return () => removeThemeListener(setTheme);
+  }, []);
+  reactExports.useEffect(() => {
+    const oldSourceWrite = source.write;
+    const oldSourceClear = source.clear;
+    (async () => {
+      const { Terminal, FitAddon } = await modulePromise;
+      const element = xtermElement.current;
+      if (!element)
+        return;
+      const terminalTheme = theme === "dark-mode" ? darkTheme : lightTheme;
+      if (terminal.current && terminal.current.terminal.options.theme === terminalTheme)
+        return;
+      if (terminal.current)
+        element.textContent = "";
+      const newTerminal = new Terminal({
+        convertEol: true,
+        fontSize: 13,
+        scrollback: 1e4,
+        fontFamily: "monospace",
+        theme: terminalTheme
+      });
+      const fitAddon = new FitAddon();
+      newTerminal.loadAddon(fitAddon);
+      for (const p of source.pending)
+        newTerminal.write(p);
+      source.write = ((data) => {
+        source.pending.push(data);
+        newTerminal.write(data);
+      });
+      source.clear = () => {
+        source.pending = [];
+        newTerminal.clear();
+      };
+      newTerminal.open(element);
+      fitAddon.fit();
+      terminal.current = { terminal: newTerminal, fitAddon };
+    })();
+    return () => {
+      source.clear = oldSourceClear;
+      source.write = oldSourceWrite;
+    };
+  }, [modulePromise, terminal, xtermElement, source, theme]);
+  reactExports.useEffect(() => {
+    setTimeout(() => {
+      if (!terminal.current)
+        return;
+      terminal.current.fitAddon.fit();
+      source.resize(terminal.current.terminal.cols, terminal.current.terminal.rows);
+    }, 250);
+  }, [measure, source]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { "data-testid": "output", className: "xterm-wrapper", style: { flex: "auto" }, ref: xtermElement });
+};
+const lightTheme = {
+  foreground: "#383a42",
+  background: "#fafafa",
+  cursor: "#383a42",
+  black: "#000000",
+  red: "#e45649",
+  green: "#50a14f",
+  yellow: "#c18401",
+  blue: "#4078f2",
+  magenta: "#a626a4",
+  cyan: "#0184bc",
+  white: "#a0a0a0",
+  brightBlack: "#000000",
+  brightRed: "#e06c75",
+  brightGreen: "#98c379",
+  brightYellow: "#d19a66",
+  brightBlue: "#4078f2",
+  brightMagenta: "#a626a4",
+  brightCyan: "#0184bc",
+  brightWhite: "#383a42",
+  selectionBackground: "#d7d7d7",
+  selectionForeground: "#383a42"
+};
+const darkTheme = {
+  foreground: "#f8f8f2",
+  background: "#1e1e1e",
+  cursor: "#f8f8f0",
+  black: "#000000",
+  red: "#ff5555",
+  green: "#50fa7b",
+  yellow: "#f1fa8c",
+  blue: "#bd93f9",
+  magenta: "#ff79c6",
+  cyan: "#8be9fd",
+  white: "#bfbfbf",
+  brightBlack: "#4d4d4d",
+  brightRed: "#ff6e6e",
+  brightGreen: "#69ff94",
+  brightYellow: "#ffffa5",
+  brightBlue: "#d6acff",
+  brightMagenta: "#ff92df",
+  brightCyan: "#a4ffff",
+  brightWhite: "#e6e6e6",
+  selectionBackground: "#44475a",
+  selectionForeground: "#f8f8f2"
+};
+const FiltersView = ({ filterText, setFilterText, statusFilters, setStatusFilters, projectFilters, setProjectFilters, testModel, runTests }) => {
+  const [expanded, setExpanded] = React.useState(false);
+  const inputRef = React.useRef(null);
+  React.useEffect(() => {
+    var _a;
+    (_a = inputRef.current) == null ? void 0 : _a.focus();
+  }, []);
+  const statusLine = [...statusFilters.entries()].filter(([_, v]) => v).map(([s]) => s).join(" ") || "all";
+  const projectsLine = [...projectFilters.entries()].filter(([_, v]) => v).map(([p]) => p).join(" ") || "all";
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "filters", children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      Expandable,
+      {
+        expanded,
+        setExpanded,
+        title: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "input",
+          {
+            ref: inputRef,
+            type: "search",
+            placeholder: "Filter (e.g. text, @tag)",
+            spellCheck: false,
+            value: filterText,
+            onChange: (e) => {
+              setFilterText(e.target.value);
+            },
+            onKeyDown: (e) => {
+              if (e.key === "Enter")
+                runTests();
+            }
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "filter-summary", title: "Status: " + statusLine + "\nProjects: " + projectsLine, onClick: () => setExpanded(!expanded), children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "filter-label", children: "Status:" }),
+      " ",
+      statusLine,
+      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "filter-label", children: "Projects:" }),
+      " ",
+      projectsLine
+    ] }),
+    expanded && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "hbox", style: { marginLeft: 14, maxHeight: 200, overflowY: "auto" }, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "filter-list", role: "list", "data-testid": "status-filters", children: [...statusFilters.entries()].map(([status, value]) => {
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "filter-entry", role: "listitem", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx("input", { type: "checkbox", checked: value, onChange: () => {
+            const copy = new Map(statusFilters);
+            copy.set(status, !copy.get(status));
+            setStatusFilters(copy);
+          } }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: status })
+        ] }) }, status);
+      }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "filter-list", role: "list", "data-testid": "project-filters", children: [...projectFilters.entries()].map(([projectName, value]) => {
+        return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "filter-entry", role: "listitem", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("label", { children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsx("input", { type: "checkbox", checked: value, onChange: () => {
+            var _a;
+            const copy = new Map(projectFilters);
+            copy.set(projectName, !copy.get(projectName));
+            setProjectFilters(copy);
+            const configFile = (_a = testModel == null ? void 0 : testModel.config) == null ? void 0 : _a.configFile;
+            if (configFile)
+              settings.setObject(configFile + ":projects", [...copy.entries()].filter(([_, v]) => v).map(([k]) => k));
+          } }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: projectName || "untitled" })
+        ] }) }, projectName);
+      }) })
+    ] })
+  ] });
+};
+const TagView = ({ tag, style, onClick }) => {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "span",
+    {
+      className: clsx("tag", `tag-color-${tagNameToColor(tag)}`),
+      onClick,
+      style: { margin: "6px 0 0 6px", ...style },
+      title: `Click to filter by tag: ${tag}`,
+      children: tag
+    }
+  );
+};
+function tagNameToColor(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++)
+    hash = str.charCodeAt(i) + ((hash << 8) - hash);
+  return Math.abs(hash % 6);
+}
+const TestTreeView = TreeView;
+const TestListView = ({ filterText, testModel, testServerConnection, testTree, runTests, runningState, watchAll, watchedTreeIds, setWatchedTreeIds, isLoading, onItemSelected, requestedCollapseAllCount, requestedExpandAllCount, setFilterText, onRevealSource }) => {
+  const [treeState, setTreeState] = React.useState({ expandedItems: /* @__PURE__ */ new Map() });
+  const [selectedTreeItemId, setSelectedTreeItemId] = React.useState();
+  const [collapseAllCount, setCollapseAllCount] = React.useState(requestedCollapseAllCount);
+  const [expandAllCount, setExpandAllCount] = React.useState(requestedExpandAllCount);
+  React.useEffect(() => {
+    if (collapseAllCount !== requestedCollapseAllCount) {
+      treeState.expandedItems.clear();
+      for (const item of testTree.flatTreeItems())
+        treeState.expandedItems.set(item.id, false);
+      setCollapseAllCount(requestedCollapseAllCount);
+      setSelectedTreeItemId(void 0);
+      setTreeState({ ...treeState });
+      return;
+    }
+    if (expandAllCount !== requestedExpandAllCount) {
+      treeState.expandedItems.clear();
+      for (const item of testTree.flatTreeItems())
+        treeState.expandedItems.set(item.id, true);
+      setExpandAllCount(requestedExpandAllCount);
+      setSelectedTreeItemId(void 0);
+      setTreeState({ ...treeState });
+      return;
+    }
+    if (!runningState || runningState.itemSelectedByUser)
+      return;
+    let selectedTreeItem2;
+    const visit = (treeItem) => {
+      var _a;
+      treeItem.children.forEach(visit);
+      if (selectedTreeItem2)
+        return;
+      if (treeItem.status === "failed") {
+        if (treeItem.kind === "test" && runningState.testIds.has(treeItem.test.id))
+          selectedTreeItem2 = treeItem;
+        else if (treeItem.kind === "case" && runningState.testIds.has((_a = treeItem.tests[0]) == null ? void 0 : _a.id))
+          selectedTreeItem2 = treeItem;
+      }
+    };
+    visit(testTree.rootItem);
+    if (selectedTreeItem2)
+      setSelectedTreeItemId(selectedTreeItem2.id);
+  }, [runningState, setSelectedTreeItemId, testTree, collapseAllCount, setCollapseAllCount, requestedCollapseAllCount, expandAllCount, setExpandAllCount, requestedExpandAllCount, treeState, setTreeState]);
+  const selectedTreeItem = React.useMemo(() => {
+    if (!selectedTreeItemId)
+      return void 0;
+    return testTree.treeItemById(selectedTreeItemId);
+  }, [selectedTreeItemId, testTree]);
+  React.useEffect(() => {
+    if (!testModel)
+      return;
+    const testFile = itemLocation(selectedTreeItem, testModel);
+    let selectedTest;
+    if ((selectedTreeItem == null ? void 0 : selectedTreeItem.kind) === "test")
+      selectedTest = selectedTreeItem.test;
+    else if ((selectedTreeItem == null ? void 0 : selectedTreeItem.kind) === "case" && selectedTreeItem.tests.length === 1)
+      selectedTest = selectedTreeItem.tests[0];
+    onItemSelected({ treeItem: selectedTreeItem, testCase: selectedTest, testFile });
+  }, [testModel, selectedTreeItem, onItemSelected]);
+  React.useEffect(() => {
+    if (isLoading)
+      return;
+    if (watchAll) {
+      testServerConnection == null ? void 0 : testServerConnection.watchNoReply({ fileNames: testTree.fileNames() });
+    } else {
+      const fileNames = /* @__PURE__ */ new Set();
+      for (const itemId of watchedTreeIds.value) {
+        const treeItem = testTree.treeItemById(itemId);
+        const fileName = treeItem == null ? void 0 : treeItem.location.file;
+        if (fileName)
+          fileNames.add(fileName);
+      }
+      testServerConnection == null ? void 0 : testServerConnection.watchNoReply({ fileNames: [...fileNames] });
+    }
+  }, [isLoading, testTree, watchAll, watchedTreeIds, testServerConnection]);
+  const runTreeItem = (treeItem) => {
+    setSelectedTreeItemId(treeItem.id);
+    runTests("bounce-if-busy", testTree.collectTestIds(treeItem));
+  };
+  const handleTagClick = (e, tag) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (e.metaKey || e.ctrlKey) {
+      const parts = filterText.split(" ");
+      if (parts.includes(tag))
+        setFilterText(parts.filter((t) => t !== tag).join(" ").trim());
+      else
+        setFilterText((filterText + " " + tag).trim());
+    } else {
+      setFilterText((filterText.split(" ").filter((t) => !t.startsWith("@")).join(" ") + " " + tag).trim());
+    }
+  };
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    TestTreeView,
+    {
+      name: "tests",
+      treeState,
+      setTreeState,
+      rootItem: testTree.rootItem,
+      dataTestId: "test-tree",
+      render: (treeItem) => {
+        const prefixId = treeItem.id.replace(/[^\w\d-_]/g, "-");
+        const labelId = prefixId + "-label";
+        const timeId = prefixId + "-time";
+        return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "hbox ui-mode-tree-item", "aria-labelledby": `${labelId} ${timeId}`, children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { id: labelId, className: "ui-mode-tree-item-title", children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx("span", { children: treeItem.title }),
+            treeItem.kind === "case" ? treeItem.tags.map((tag) => /* @__PURE__ */ jsxRuntimeExports.jsx(TagView, { tag: tag.slice(1), onClick: (e) => handleTagClick(e, tag) }, tag)) : null
+          ] }),
+          !!treeItem.duration && treeItem.status !== "skipped" && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { id: timeId, className: "ui-mode-tree-item-time", children: msToString(treeItem.duration) }),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(Toolbar, { noMinHeight: true, noShadow: true, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "play", title: "Run", onClick: () => runTreeItem(treeItem), disabled: !!runningState && !runningState.completed }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "go-to-file", title: "Show source", onClick: onRevealSource, style: treeItem.kind === "group" && treeItem.subKind === "folder" ? { visibility: "hidden" } : {} }),
+            !watchAll && /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "eye", title: "Watch", onClick: () => {
+              if (watchedTreeIds.value.has(treeItem.id))
+                watchedTreeIds.value.delete(treeItem.id);
+              else
+                watchedTreeIds.value.add(treeItem.id);
+              setWatchedTreeIds({ ...watchedTreeIds });
+            }, toggled: watchedTreeIds.value.has(treeItem.id) })
+          ] })
+        ] });
+      },
+      icon: (treeItem) => testStatusIcon(treeItem.status),
+      title: (treeItem) => treeItem.title,
+      selectedItem: selectedTreeItem,
+      onAccepted: runTreeItem,
+      onSelected: (treeItem) => {
+        if (runningState)
+          runningState.itemSelectedByUser = true;
+        setSelectedTreeItemId(treeItem.id);
+      },
+      isError: (treeItem) => treeItem.kind === "group" ? treeItem.hasLoadErrors : false,
+      autoExpandDepth: filterText ? 5 : 1,
+      noItemsMessage: isLoading ? "Loading…" : "No tests"
+    }
+  );
+};
+function itemLocation(item, model) {
+  if (!item || !model)
+    return;
+  return {
+    file: item.location.file,
+    line: item.location.line,
+    column: item.location.column,
+    source: {
+      errors: model.loadErrors.filter((e) => {
+        var _a;
+        return ((_a = e.location) == null ? void 0 : _a.file) === item.location.file;
+      }).map((e) => ({ line: e.location.line, message: e.message })),
+      content: void 0
+    }
+  };
+}
+function artifactsFolderName(workerIndex) {
+  return `.playwright-artifacts-${workerIndex}`;
+}
+const TraceView = ({ item, rootDir, onOpenExternally, revealSource, pathSeparator }) => {
+  var _a, _b;
+  const [model, setModel] = React.useState(void 0);
+  const [counter, setCounter] = React.useState(0);
+  const pollTimer = React.useRef(null);
+  const { outputDir } = React.useMemo(() => {
+    const outputDir2 = item.testCase ? outputDirForTestCase(item.testCase) : void 0;
+    return { outputDir: outputDir2 };
+  }, [item]);
+  React.useEffect(() => {
+    var _a2, _b2;
+    if (pollTimer.current)
+      clearTimeout(pollTimer.current);
+    const result = (_a2 = item.testCase) == null ? void 0 : _a2.results[0];
+    if (!result) {
+      setModel(void 0);
+      return;
+    }
+    const attachment = result && result.duration >= 0 && result.attachments.find((a) => a.name === "trace");
+    if (attachment && attachment.path) {
+      loadSingleTraceFile(attachment.path).then((model2) => setModel({ model: model2, isLive: false }));
+      return;
+    }
+    if (!outputDir) {
+      setModel(void 0);
+      return;
+    }
+    const traceLocation = [
+      outputDir,
+      artifactsFolderName(result.workerIndex),
+      "traces",
+      `${(_b2 = item.testCase) == null ? void 0 : _b2.id}.json`
+    ].join(pathSeparator);
+    pollTimer.current = setTimeout(async () => {
+      try {
+        const model2 = await loadSingleTraceFile(traceLocation);
+        setModel({ model: model2, isLive: true });
+      } catch {
+        const model2 = new MultiTraceModel("", []);
+        model2.errorDescriptors.push(...result.errors.flatMap((error) => !!error.message ? [{ message: error.message }] : []));
+        setModel({ model: model2, isLive: false });
+      } finally {
+        setCounter(counter + 1);
+      }
+    }, 500);
+    return () => {
+      if (pollTimer.current)
+        clearTimeout(pollTimer.current);
+    };
+  }, [outputDir, item, setModel, counter, setCounter, pathSeparator]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    Workbench,
+    {
+      model: model == null ? void 0 : model.model,
+      showSourcesFirst: true,
+      rootDir,
+      fallbackLocation: item.testFile,
+      isLive: model == null ? void 0 : model.isLive,
+      status: (_a = item.treeItem) == null ? void 0 : _a.status,
+      annotations: ((_b = item.testCase) == null ? void 0 : _b.annotations) ?? [],
+      onOpenExternally,
+      revealSource
+    },
+    "workbench"
+  );
+};
+const outputDirForTestCase = (testCase) => {
+  var _a;
+  for (let suite = testCase.parent; suite; suite = suite.parent) {
+    if (suite.project())
+      return (_a = suite.project()) == null ? void 0 : _a.outputDir;
+  }
+  return void 0;
+};
+async function loadSingleTraceFile(url) {
+  const params = new URLSearchParams();
+  params.set("trace", url);
+  const response = await fetch(`contexts?${params.toString()}`);
+  const contextEntries = await response.json();
+  return new MultiTraceModel(url, contextEntries);
+}
+let xtermSize = { cols: 80 };
+const xtermDataSource = {
+  pending: [],
+  clear: () => {
+  },
+  write: (data) => xtermDataSource.pending.push(data),
+  resize: () => {
+  }
+};
+const searchParams = new URLSearchParams(window.location.search);
+const testServerBaseUrl = new URL(searchParams.get("server") ?? "../", window.location.href);
+const wsURL = new URL(searchParams.get("ws"), testServerBaseUrl);
+wsURL.protocol = wsURL.protocol === "https:" ? "wss:" : "ws:";
+const queryParams = {
+  args: searchParams.getAll("arg"),
+  grep: searchParams.get("grep") || void 0,
+  grepInvert: searchParams.get("grepInvert") || void 0,
+  projects: searchParams.getAll("project"),
+  workers: searchParams.get("workers") || void 0,
+  headed: searchParams.has("headed"),
+  updateSnapshots: searchParams.get("updateSnapshots") || void 0,
+  reporters: searchParams.has("reporter") ? searchParams.getAll("reporter") : void 0,
+  pathSeparator: searchParams.get("pathSeparator") || "/"
+};
+if (queryParams.updateSnapshots && !["all", "changed", "none", "missing"].includes(queryParams.updateSnapshots))
+  queryParams.updateSnapshots = void 0;
+const isMac = navigator.platform === "MacIntel";
+const UIModeView = ({}) => {
+  var _a;
+  const [filterText, setFilterText] = React.useState("");
+  const [isShowingOutput, setIsShowingOutput] = React.useState(false);
+  const [outputContainsError, setOutputContainsError] = React.useState(false);
+  const [statusFilters, setStatusFilters] = React.useState(/* @__PURE__ */ new Map([
+    ["passed", false],
+    ["failed", false],
+    ["skipped", false]
+  ]));
+  const [projectFilters, setProjectFilters] = React.useState(/* @__PURE__ */ new Map());
+  const [testModel, setTestModel] = React.useState();
+  const [progress, setProgress] = React.useState();
+  const [selectedItem, setSelectedItem] = React.useState({});
+  const [visibleTestIds, setVisibleTestIds] = React.useState(/* @__PURE__ */ new Set());
+  const [isLoading, setIsLoading] = React.useState(false);
+  const [runningState, setRunningState] = React.useState();
+  const isRunningTest = runningState && !runningState.completed;
+  const [watchAll, setWatchAll] = useSetting("watch-all", false);
+  const [watchedTreeIds, setWatchedTreeIds] = React.useState({ value: /* @__PURE__ */ new Set() });
+  const commandQueue = React.useRef(Promise.resolve());
+  const runTestBacklog = React.useRef(/* @__PURE__ */ new Set());
+  const [collapseAllCount, setCollapseAllCount] = React.useState(0);
+  const [expandAllCount, setExpandAllCount] = React.useState(0);
+  const [isDisconnected, setIsDisconnected] = React.useState(false);
+  const [hasBrowsers, setHasBrowsers] = React.useState(true);
+  const [testServerConnection, setTestServerConnection] = React.useState();
+  const [teleSuiteUpdater, setTeleSuiteUpdater] = React.useState();
+  const [settingsVisible, setSettingsVisible] = React.useState(false);
+  const [testingOptionsVisible, setTestingOptionsVisible] = React.useState(false);
+  const [revealSource, setRevealSource] = React.useState(false);
+  const onRevealSource = React.useCallback(() => setRevealSource(true), [setRevealSource]);
+  const [singleWorker, setSingleWorker] = useSetting("single-worker", false);
+  const [updateSnapshots, setUpdateSnapshots] = useSetting("updateSnapshots", "missing");
+  const [mergeFiles] = useSetting("mergeFiles", false);
+  const inputRef = React.useRef(null);
+  const reloadTests = React.useCallback(() => {
+    setTestServerConnection((prevConnection) => {
+      prevConnection == null ? void 0 : prevConnection.close();
+      return new TestServerConnection(new WebSocketTestServerTransport(wsURL));
+    });
+  }, []);
+  React.useEffect(() => {
+    var _a2;
+    (_a2 = inputRef.current) == null ? void 0 : _a2.focus();
+    setIsLoading(true);
+    reloadTests();
+  }, [reloadTests]);
+  React.useEffect(() => {
+    if (!testServerConnection)
+      return;
+    const disposables = [
+      testServerConnection.onStdio((params) => {
+        if (params.buffer) {
+          const data = atob(params.buffer);
+          xtermDataSource.write(data);
+        } else {
+          xtermDataSource.write(params.text);
+        }
+        if (params.type === "stderr")
+          setOutputContainsError(true);
+      }),
+      testServerConnection.onClose(() => setIsDisconnected(true))
+    ];
+    xtermDataSource.resize = (cols, rows) => {
+      xtermSize = { cols, rows };
+      testServerConnection.resizeTerminalNoReply({ cols, rows });
+    };
+    return () => {
+      for (const disposable of disposables)
+        disposable.dispose();
+    };
+  }, [testServerConnection]);
+  React.useEffect(() => {
+    if (!testServerConnection)
+      return;
+    let throttleTimer;
+    const teleSuiteUpdater2 = new TeleSuiteUpdater({
+      onUpdate: (immediate) => {
+        clearTimeout(throttleTimer);
+        throttleTimer = void 0;
+        if (immediate) {
+          setTestModel(teleSuiteUpdater2.asModel());
+        } else if (!throttleTimer) {
+          throttleTimer = setTimeout(() => {
+            setTestModel(teleSuiteUpdater2.asModel());
+          }, 250);
+        }
+      },
+      onError: (error) => {
+        xtermDataSource.write((error.stack || error.value || "") + "\n");
+        setOutputContainsError(true);
+      },
+      pathSeparator: queryParams.pathSeparator
+    });
+    setTeleSuiteUpdater(teleSuiteUpdater2);
+    setTestModel(void 0);
+    setIsLoading(true);
+    setWatchedTreeIds({ value: /* @__PURE__ */ new Set() });
+    (async () => {
+      try {
+        await testServerConnection.initialize({
+          interceptStdio: true,
+          watchTestDirs: true
+        });
+        const { status, report } = await testServerConnection.runGlobalSetup({});
+        teleSuiteUpdater2.processGlobalReport(report);
+        if (status !== "passed")
+          return;
+        const result = await testServerConnection.listTests({ projects: queryParams.projects, locations: queryParams.args, grep: queryParams.grep, grepInvert: queryParams.grepInvert });
+        teleSuiteUpdater2.processListReport(result.report);
+        testServerConnection.onReport((params) => {
+          teleSuiteUpdater2.processTestReportEvent(params);
+        });
+        const { hasBrowsers: hasBrowsers2 } = await testServerConnection.checkBrowsers({});
+        setHasBrowsers(hasBrowsers2);
+      } finally {
+        setIsLoading(false);
+      }
+    })();
+    return () => {
+      clearTimeout(throttleTimer);
+    };
+  }, [testServerConnection]);
+  React.useEffect(() => {
+    if (!testModel)
+      return;
+    const { config, rootSuite } = testModel;
+    const selectedProjects = config.configFile ? settings.getObject(config.configFile + ":projects", void 0) : void 0;
+    const newFilter = new Map(projectFilters);
+    for (const projectName of newFilter.keys()) {
+      if (!rootSuite.suites.find((s) => s.title === projectName))
+        newFilter.delete(projectName);
+    }
+    for (const projectSuite of rootSuite.suites) {
+      if (!newFilter.has(projectSuite.title))
+        newFilter.set(projectSuite.title, !!(selectedProjects == null ? void 0 : selectedProjects.includes(projectSuite.title)));
+    }
+    if (!selectedProjects && newFilter.size && ![...newFilter.values()].includes(true))
+      newFilter.set(newFilter.entries().next().value[0], true);
+    if (projectFilters.size !== newFilter.size || [...projectFilters].some(([k, v]) => newFilter.get(k) !== v))
+      setProjectFilters(newFilter);
+  }, [projectFilters, testModel]);
+  React.useEffect(() => {
+    if (isRunningTest && (testModel == null ? void 0 : testModel.progress))
+      setProgress(testModel.progress);
+    else if (!testModel)
+      setProgress(void 0);
+  }, [testModel, isRunningTest]);
+  const { testTree } = React.useMemo(() => {
+    if (!testModel)
+      return { testTree: new TestTree("", new TeleSuite("", "root"), [], projectFilters, queryParams.pathSeparator, mergeFiles) };
+    const testTree2 = new TestTree("", testModel.rootSuite, testModel.loadErrors, projectFilters, queryParams.pathSeparator, mergeFiles);
+    testTree2.filterTree(filterText, statusFilters, isRunningTest ? runningState == null ? void 0 : runningState.testIds : void 0);
+    testTree2.sortAndPropagateStatus();
+    testTree2.shortenRoot();
+    testTree2.flattenForSingleProject();
+    setVisibleTestIds(testTree2.testIds());
+    return { testTree: testTree2 };
+  }, [filterText, testModel, statusFilters, projectFilters, setVisibleTestIds, runningState, isRunningTest, mergeFiles]);
+  const runTests = React.useCallback((mode, testIds) => {
+    if (!testServerConnection || !testModel)
+      return;
+    if (mode === "bounce-if-busy" && isRunningTest)
+      return;
+    runTestBacklog.current = /* @__PURE__ */ new Set([...runTestBacklog.current, ...testIds]);
+    commandQueue.current = commandQueue.current.then(async () => {
+      var _a2, _b, _c;
+      const testIds2 = runTestBacklog.current;
+      runTestBacklog.current = /* @__PURE__ */ new Set();
+      if (!testIds2.size)
+        return;
+      {
+        for (const test of ((_a2 = testModel.rootSuite) == null ? void 0 : _a2.allTests()) || []) {
+          if (testIds2.has(test.id)) {
+            test.results = [];
+            const result = test._createTestResult("pending");
+            result[statusEx] = "scheduled";
+          }
+        }
+        setTestModel({ ...testModel });
+      }
+      const time = "  [" + (/* @__PURE__ */ new Date()).toLocaleTimeString() + "]";
+      xtermDataSource.write("\x1B[2m—".repeat(Math.max(0, xtermSize.cols - time.length)) + time + "\x1B[22m");
+      setProgress({ total: 0, passed: 0, failed: 0, skipped: 0 });
+      setRunningState({ testIds: testIds2 });
+      await testServerConnection.runTests({
+        locations: queryParams.args,
+        grep: queryParams.grep,
+        grepInvert: queryParams.grepInvert,
+        testIds: [...testIds2],
+        projects: [...projectFilters].filter(([_, v]) => v).map(([p]) => p),
+        updateSnapshots,
+        reporters: queryParams.reporters,
+        workers: singleWorker ? 1 : void 0,
+        trace: "on"
+      });
+      for (const test of ((_b = testModel.rootSuite) == null ? void 0 : _b.allTests()) || []) {
+        if (((_c = test.results[0]) == null ? void 0 : _c.duration) === -1)
+          test.results = [];
+      }
+      setTestModel({ ...testModel });
+      setRunningState((oldState) => oldState ? { ...oldState, completed: true } : void 0);
+    });
+  }, [projectFilters, isRunningTest, testModel, testServerConnection, updateSnapshots, singleWorker]);
+  React.useEffect(() => {
+    if (!testServerConnection || !teleSuiteUpdater)
+      return;
+    const disposable = testServerConnection.onTestFilesChanged(async (params) => {
+      commandQueue.current = commandQueue.current.then(async () => {
+        setIsLoading(true);
+        try {
+          const result = await testServerConnection.listTests({ projects: queryParams.projects, locations: queryParams.args, grep: queryParams.grep, grepInvert: queryParams.grepInvert });
+          teleSuiteUpdater.processListReport(result.report);
+        } catch (e) {
+          console.log(e);
+        } finally {
+          setIsLoading(false);
+        }
+      });
+      await commandQueue.current;
+      if (params.testFiles.length === 0)
+        return;
+      const testModel2 = teleSuiteUpdater.asModel();
+      const testTree2 = new TestTree("", testModel2.rootSuite, testModel2.loadErrors, projectFilters, queryParams.pathSeparator, mergeFiles);
+      const testIds = [];
+      const set = new Set(params.testFiles);
+      if (watchAll) {
+        const visit = (treeItem) => {
+          const fileName = treeItem.location.file;
+          if (fileName && set.has(fileName))
+            testIds.push(...testTree2.collectTestIds(treeItem));
+          if (treeItem.kind === "group" && treeItem.subKind === "folder")
+            treeItem.children.forEach(visit);
+        };
+        visit(testTree2.rootItem);
+      } else {
+        for (const treeId of watchedTreeIds.value) {
+          const treeItem = testTree2.treeItemById(treeId);
+          const fileName = treeItem == null ? void 0 : treeItem.location.file;
+          if (fileName && set.has(fileName))
+            testIds.push(...testTree2.collectTestIds(treeItem));
+        }
+      }
+      runTests("queue-if-busy", new Set(testIds));
+    });
+    return () => disposable.dispose();
+  }, [runTests, testServerConnection, watchAll, watchedTreeIds, teleSuiteUpdater, projectFilters, mergeFiles]);
+  React.useEffect(() => {
+    if (!testServerConnection)
+      return;
+    const onShortcutEvent = (e) => {
+      if (e.code === "Backquote" && e.ctrlKey) {
+        e.preventDefault();
+        setIsShowingOutput(!isShowingOutput);
+      } else if (e.code === "F5" && e.shiftKey) {
+        e.preventDefault();
+        testServerConnection == null ? void 0 : testServerConnection.stopTestsNoReply({});
+      } else if (e.code === "F5") {
+        e.preventDefault();
+        runTests("bounce-if-busy", visibleTestIds);
+      }
+    };
+    addEventListener("keydown", onShortcutEvent);
+    return () => {
+      removeEventListener("keydown", onShortcutEvent);
+    };
+  }, [runTests, reloadTests, testServerConnection, visibleTestIds, isShowingOutput]);
+  const dialogRef = React.useRef(null);
+  const openInstallDialog = React.useCallback((e) => {
+    var _a2;
+    e.preventDefault();
+    e.stopPropagation();
+    (_a2 = dialogRef.current) == null ? void 0 : _a2.showModal();
+  }, []);
+  const closeInstallDialog = React.useCallback((e) => {
+    var _a2;
+    e.preventDefault();
+    e.stopPropagation();
+    (_a2 = dialogRef.current) == null ? void 0 : _a2.close();
+  }, []);
+  const installBrowsers = React.useCallback((e) => {
+    closeInstallDialog(e);
+    setIsShowingOutput(true);
+    testServerConnection == null ? void 0 : testServerConnection.installBrowsers({}).then(async () => {
+      setIsShowingOutput(false);
+      const { hasBrowsers: hasBrowsers2 } = await (testServerConnection == null ? void 0 : testServerConnection.checkBrowsers({}));
+      setHasBrowsers(hasBrowsers2);
+    });
+  }, [closeInstallDialog, testServerConnection]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "vbox ui-mode", children: [
+    !hasBrowsers && /* @__PURE__ */ jsxRuntimeExports.jsxs("dialog", { ref: dialogRef, children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "title", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "codicon codicon-lightbulb" }),
+        "Install browsers"
+      ] }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "body", children: [
+        "Playwright did not find installed browsers.",
+        /* @__PURE__ */ jsxRuntimeExports.jsx("br", {}),
+        "Would you like to run `playwright install`?",
+        /* @__PURE__ */ jsxRuntimeExports.jsx("br", {}),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("button", { className: "button", onClick: installBrowsers, children: "Install" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx("button", { className: "button secondary", onClick: closeInstallDialog, children: "Dismiss" })
+      ] })
+    ] }),
+    isDisconnected && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "disconnected", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "title", children: "UI Mode disconnected" }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: "#", onClick: () => window.location.href = "/", children: "Reload the page" }),
+        " to reconnect"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(
+      SplitView,
+      {
+        sidebarSize: 250,
+        minSidebarSize: 150,
+        orientation: "horizontal",
+        sidebarIsFirst: true,
+        settingName: "testListSidebar",
+        main: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "vbox", children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: clsx("vbox", !isShowingOutput && "hidden"), children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsxs(Toolbar, { children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "section-title", style: { flex: "none" }, children: "Output" }),
+              /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "circle-slash", title: "Clear output", onClick: () => {
+                xtermDataSource.clear();
+                setOutputContainsError(false);
+              } }),
+              /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "spacer" }),
+              /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "close", title: "Close", onClick: () => setIsShowingOutput(false) })
+            ] }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(XtermWrapper, { source: xtermDataSource })
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: clsx("vbox", isShowingOutput && "hidden"), children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+            TraceView,
+            {
+              pathSeparator: queryParams.pathSeparator,
+              item: selectedItem,
+              rootDir: (_a = testModel == null ? void 0 : testModel.config) == null ? void 0 : _a.rootDir,
+              revealSource,
+              onOpenExternally: (location) => testServerConnection == null ? void 0 : testServerConnection.openNoReply({ location: { file: location.file, line: location.line, column: location.column } })
+            }
+          ) })
+        ] }),
+        sidebar: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "vbox ui-mode-sidebar", children: [
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(Toolbar, { noShadow: true, noMinHeight: true, children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx("img", { src: "playwright-logo.svg", alt: "Playwright logo" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "section-title", children: "Playwright" }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "refresh", title: "Reload", onClick: () => reloadTests(), disabled: isRunningTest || isLoading }),
+            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { position: "relative" }, children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "terminal", title: "Toggle output — " + (isMac ? "⌃`" : "Ctrl + `"), toggled: isShowingOutput, onClick: () => {
+                setIsShowingOutput(!isShowingOutput);
+              } }),
+              outputContainsError && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { title: "Output contains error", style: { position: "absolute", top: 2, right: 2, width: 7, height: 7, borderRadius: "50%", backgroundColor: "var(--vscode-notificationsErrorIcon-foreground)" } })
+            ] }),
+            !hasBrowsers && /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "lightbulb-autofix", style: { color: "var(--vscode-list-warningForeground)" }, title: "Playwright browsers are missing", onClick: openInstallDialog })
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            FiltersView,
+            {
+              filterText,
+              setFilterText,
+              statusFilters,
+              setStatusFilters,
+              projectFilters,
+              setProjectFilters,
+              testModel,
+              runTests: () => runTests("bounce-if-busy", visibleTestIds)
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(Toolbar, { className: "section-toolbar", noMinHeight: true, children: [
+            !isRunningTest && !progress && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "section-title", children: "Tests" }),
+            !isRunningTest && progress && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { "data-testid": "status-line", className: "status-line", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+              progress.passed,
+              "/",
+              progress.total,
+              " passed (",
+              progress.passed / progress.total * 100 | 0,
+              "%)"
+            ] }) }),
+            isRunningTest && progress && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { "data-testid": "status-line", className: "status-line", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { children: [
+              "Running ",
+              progress.passed,
+              "/",
+              runningState.testIds.size,
+              " passed (",
+              progress.passed / runningState.testIds.size * 100 | 0,
+              "%)"
+            ] }) }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "play", title: "Run all — F5", onClick: () => runTests("bounce-if-busy", visibleTestIds), disabled: isRunningTest || isLoading }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "debug-stop", title: "Stop — " + (isMac ? "⇧F5" : "Shift + F5"), onClick: () => testServerConnection == null ? void 0 : testServerConnection.stopTests({}), disabled: !isRunningTest || isLoading }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "eye", title: "Watch all", toggled: watchAll, onClick: () => {
+              setWatchedTreeIds({ value: /* @__PURE__ */ new Set() });
+              setWatchAll(!watchAll);
+            } }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "collapse-all", title: "Collapse all", onClick: () => {
+              setCollapseAllCount(collapseAllCount + 1);
+            } }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarButton, { icon: "expand-all", title: "Expand all", onClick: () => {
+              setExpandAllCount(expandAllCount + 1);
+            } })
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            TestListView,
+            {
+              filterText,
+              testModel,
+              testTree,
+              testServerConnection,
+              runningState,
+              runTests,
+              onItemSelected: setSelectedItem,
+              watchAll,
+              watchedTreeIds,
+              setWatchedTreeIds,
+              isLoading,
+              requestedCollapseAllCount: collapseAllCount,
+              requestedExpandAllCount: expandAllCount,
+              setFilterText,
+              onRevealSource
+            }
+          ),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(Toolbar, { noShadow: true, noMinHeight: true, className: "settings-toolbar", onClick: () => setTestingOptionsVisible(!testingOptionsVisible), children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "span",
+              {
+                className: `codicon codicon-${testingOptionsVisible ? "chevron-down" : "chevron-right"}`,
+                style: { marginLeft: 5 },
+                title: testingOptionsVisible ? "Hide Testing Options" : "Show Testing Options"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "section-title", children: "Testing Options" })
+          ] }),
+          testingOptionsVisible && /* @__PURE__ */ jsxRuntimeExports.jsx(SettingsView, { settings: [
+            { type: "check", value: singleWorker, set: setSingleWorker, name: "Single worker" },
+            { type: "select", options: [
+              { label: "All", value: "all" },
+              { label: "Changed", value: "changed" },
+              { label: "Missing", value: "missing" },
+              { label: "None", value: "none" }
+            ], value: updateSnapshots, set: setUpdateSnapshots, name: "Update snapshots" }
+          ] }),
+          /* @__PURE__ */ jsxRuntimeExports.jsxs(Toolbar, { noShadow: true, noMinHeight: true, className: "settings-toolbar", onClick: () => setSettingsVisible(!settingsVisible), children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "span",
+              {
+                className: `codicon codicon-${settingsVisible ? "chevron-down" : "chevron-right"}`,
+                style: { marginLeft: 5 },
+                title: settingsVisible ? "Hide Settings" : "Show Settings"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "section-title", children: "Settings" })
+          ] }),
+          settingsVisible && /* @__PURE__ */ jsxRuntimeExports.jsx(DefaultSettingsView, { location: "ui-mode" })
+        ] })
+      }
+    )
+  ] });
+};
+(async () => {
+  applyTheme();
+  if (window.location.protocol !== "file:") {
+    if (window.location.href.includes("isUnderTest=true"))
+      await new Promise((f) => setTimeout(f, 1e3));
+    if (!navigator.serviceWorker)
+      throw new Error(`Service workers are not supported.
+Make sure to serve the website (${window.location}) via HTTPS or localhost.`);
+    navigator.serviceWorker.register("sw.bundle.js");
+    if (!navigator.serviceWorker.controller) {
+      await new Promise((f) => {
+        navigator.serviceWorker.oncontrollerchange = () => f();
+      });
+    }
+    setInterval(function() {
+      fetch("ping");
+    }, 1e4);
+  }
+  clientExports.createRoot(document.querySelector("#root")).render(/* @__PURE__ */ jsxRuntimeExports.jsx(UIModeView, {}));
+})();
+
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"mappings":"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","names":["treeItem","React.useState","React.useRef","React.useEffect","jsx","jsxs","selectedTreeItem","outputDir","_a","model","_b","teleSuiteUpdater","hasBrowsers","testTree","testIds","testModel","ReactDOM.createRoot"],"ignoreList":[],"sources":["../../../../playwright/src/isomorphic/teleReceiver.ts","../../../../playwright/src/isomorphic/testTree.ts","../../../../playwright/src/isomorphic/teleSuiteUpdater.ts","../../../../web/src/components/xtermWrapper.tsx","../../../../trace-viewer/src/ui/uiModeFiltersView.tsx","../../../../trace-viewer/src/ui/tag.tsx","../../../../trace-viewer/src/ui/uiModeTestListView.tsx","../../../../playwright/src/isomorphic/folders.ts","../../../../trace-viewer/src/ui/uiModeTraceView.tsx","../../../../trace-viewer/src/ui/uiModeView.tsx","../../../../trace-viewer/src/uiMode.tsx"],"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 type { Metadata, TestAnnotation } from '../../types/test';\nimport type * as reporterTypes from '../../types/testReporter';\nimport type { ReporterV2 } from '../reporters/reporterV2';\n\nexport type StringIntern = (s: string) => string;\nexport type JsonLocation = reporterTypes.Location;\nexport type JsonError = string;\nexport type JsonStackFrame = { file: string, line: number, column: number };\n\nexport type JsonStdIOType = 'stdout' | 'stderr';\n\nexport type JsonConfig = Pick<reporterTypes.FullConfig, 'configFile' | 'globalTimeout' | 'maxFailures' | 'metadata' | 'rootDir' | 'version' | 'workers' | 'globalSetup' | 'globalTeardown'> & {\n  // optional for backwards compatibility\n  tags?: reporterTypes.FullConfig['tags'],\n  webServer?: reporterTypes.FullConfig['webServer'],\n};\n\nexport type JsonPattern = {\n  s?: string;\n  r?: { source: string, flags: string };\n};\n\nexport type JsonProject = {\n  grep: JsonPattern[];\n  grepInvert: JsonPattern[];\n  metadata: Metadata;\n  name: string;\n  dependencies: string[];\n  // This is relative to root dir.\n  snapshotDir: string;\n  // This is relative to root dir.\n  outputDir: string;\n  repeatEach: number;\n  retries: number;\n  suites: JsonSuite[];\n  teardown?: string;\n  // This is relative to root dir.\n  testDir: string;\n  testIgnore: JsonPattern[];\n  testMatch: JsonPattern[];\n  timeout: number;\n  use: { [key: string]: any };\n};\n\nexport type JsonSuite = {\n  title: string;\n  location?: JsonLocation;\n  entries: (JsonSuite | JsonTestCase)[];\n};\n\nexport type JsonTestCase = {\n  testId: string;\n  title: string;\n  location: JsonLocation;\n  retries: number;\n  tags?: string[];\n  repeatEachIndex: number;\n  annotations?: TestAnnotation[];\n};\n\nexport type JsonTestEnd = {\n  testId: string;\n  expectedStatus: reporterTypes.TestStatus;\n  timeout: number;\n  // Dropped in 1.52. Kept as empty array for backwards compatibility.\n  annotations: [];\n};\n\nexport type JsonTestResultStart = {\n  id: string;\n  retry: number;\n  workerIndex: number;\n  parallelIndex: number;\n  startTime: number;\n};\n\nexport type JsonAttachment = Omit<reporterTypes.TestResult['attachments'][0], 'body'> & { base64?: string; };\n\nexport type JsonTestResultEnd = {\n  id: string;\n  duration: number;\n  status: reporterTypes.TestStatus;\n  errors: reporterTypes.TestError[];\n  /** No longer emitted, but kept for backwards compatibility */\n  attachments?: JsonAttachment[];\n  annotations?: TestAnnotation[];\n};\n\nexport type JsonTestStepStart = {\n  id: string;\n  parentStepId?: string;\n  title: string;\n  category: string,\n  startTime: number;\n  location?: reporterTypes.Location;\n};\n\nexport type JsonTestStepEnd = {\n  id: string;\n  duration: number;\n  error?: reporterTypes.TestError;\n  attachments?: number[]; // index of JsonTestResultEnd.attachments\n  annotations?: TestAnnotation[];\n};\n\nexport type JsonTestResultOnAttach = {\n  testId: string;\n  resultId: string;\n  attachments: JsonAttachment[];\n};\n\nexport type JsonFullResult = {\n  status: reporterTypes.FullResult['status'];\n  startTime: number;\n  duration: number;\n};\n\nexport type JsonEvent = JsonOnConfigureEvent | JsonOnBlobReportMetadataEvent | JsonOnEndEvent | JsonOnExitEvent | JsonOnProjectEvent | JsonOnBeginEvent | JsonOnTestBeginEvent\n  | JsonOnTestEndEvent | JsonOnStepBeginEvent | JsonOnStepEndEvent | JsonOnAttachEvent | JsonOnErrorEvent | JsonOnStdIOEvent;\n\nexport type JsonOnConfigureEvent = {\n  method: 'onConfigure';\n  params: {\n    config: JsonConfig;\n  };\n};\n\nexport type JsonOnBlobReportMetadataEvent = {\n  method: 'onBlobReportMetadata';\n  params: BlobReportMetadata;\n};\n\nexport type JsonOnProjectEvent = {\n  method: 'onProject';\n  params: {\n    project: JsonProject;\n  };\n};\n\nexport type JsonOnBeginEvent = {\n  method: 'onBegin';\n  params: undefined;\n};\n\nexport type JsonOnTestBeginEvent = {\n  method: 'onTestBegin';\n  params: {\n    testId: string;\n    result: JsonTestResultStart;\n  };\n};\n\nexport type JsonOnTestEndEvent = {\n  method: 'onTestEnd';\n  params: {\n    test: JsonTestEnd;\n    testId?: string;\n    result: JsonTestResultEnd;\n  };\n};\n\nexport type JsonOnStepBeginEvent = {\n  method: 'onStepBegin';\n  params: {\n    testId: string;\n    resultId: string;\n    step: JsonTestStepStart;\n  };\n};\n\nexport type JsonOnStepEndEvent = {\n  method: 'onStepEnd';\n  params: {\n    testId: string;\n    resultId: string;\n    step: JsonTestStepEnd;\n  };\n};\n\nexport type JsonOnAttachEvent = {\n  method: 'onAttach';\n  params: JsonTestResultOnAttach;\n};\n\nexport type JsonOnErrorEvent = {\n  method: 'onError';\n  params: {\n    error: reporterTypes.TestError;\n  };\n};\n\nexport type JsonOnStdIOEvent = {\n  method: 'onStdIO';\n  params: {\n    type: JsonStdIOType;\n    testId?: string;\n    resultId?: string;\n    data: string;\n    isBase64: boolean;\n  };\n};\n\nexport type JsonOnEndEvent = {\n  method: 'onEnd';\n  params: {\n    result: JsonFullResult;\n  };\n};\n\nexport type JsonOnExitEvent = {\n  method: 'onExit';\n  params: undefined;\n};\n\nexport type BlobReportMetadata = {\n  version: number;\n  userAgent: string;\n  name?: string;\n  shard?: { total: number, current: number };\n  pathSeparator?: string;\n};\n\ntype TeleReporterReceiverOptions = {\n  mergeProjects?: boolean;\n  mergeTestCases?: boolean;\n  resolvePath?: (rootDir: string, relativePath: string) => string;\n  configOverrides?: Pick<reporterTypes.FullConfig, 'configFile' | 'quiet' | 'reportSlowTests' | 'reporter'>;\n  clearPreviousResultsWhenTestBegins?: boolean;\n};\n\nexport class TeleReporterReceiver {\n  public isListing = false;\n  private _rootSuite: TeleSuite;\n  private _options: TeleReporterReceiverOptions;\n  private _reporter: ReporterV2;\n  private _tests = new Map<string, TeleTestCase>();\n  private _rootDir!: string;\n  private _config!: reporterTypes.FullConfig;\n\n  constructor(reporter: ReporterV2, options: TeleReporterReceiverOptions = {}) {\n    this._rootSuite = new TeleSuite('', 'root');\n    this._options = options;\n    this._reporter = reporter;\n  }\n\n  reset() {\n    this._rootSuite._entries = [];\n    this._tests.clear();\n  }\n\n  dispatch(message: JsonEvent): Promise<void> | void {\n    const { method, params } = message;\n    if (method === 'onConfigure') {\n      this._onConfigure(params.config);\n      return;\n    }\n    if (method === 'onProject') {\n      this._onProject(params.project);\n      return;\n    }\n    if (method === 'onBegin') {\n      this._onBegin();\n      return;\n    }\n    if (method === 'onTestBegin') {\n      this._onTestBegin(params.testId, params.result);\n      return;\n    }\n    if (method === 'onTestEnd') {\n      this._onTestEnd(params.test, params.result);\n      return;\n    }\n    if (method === 'onStepBegin') {\n      this._onStepBegin(params.testId, params.resultId, params.step);\n      return;\n    }\n    if (method === 'onAttach') {\n      this._onAttach(params.testId, params.resultId, params.attachments);\n      return;\n    }\n    if (method === 'onStepEnd') {\n      this._onStepEnd(params.testId, params.resultId, params.step);\n      return;\n    }\n    if (method === 'onError') {\n      this._onError(params.error);\n      return;\n    }\n    if (method === 'onStdIO') {\n      this._onStdIO(params.type, params.testId, params.resultId, params.data, params.isBase64);\n      return;\n    }\n    if (method === 'onEnd')\n      return this._onEnd(params.result);\n    if (method === 'onExit')\n      return this._onExit();\n  }\n\n  private _onConfigure(config: JsonConfig) {\n    this._rootDir = config.rootDir;\n    this._config = this._parseConfig(config);\n    this._reporter.onConfigure?.(this._config);\n  }\n\n  private _onProject(project: JsonProject) {\n    let projectSuite = this._options.mergeProjects ? this._rootSuite.suites.find(suite => suite.project()!.name === project.name) : undefined;\n    if (!projectSuite) {\n      projectSuite = new TeleSuite(project.name, 'project');\n      this._rootSuite._addSuite(projectSuite);\n    }\n    // Always update project in watch mode.\n    projectSuite._project = this._parseProject(project);\n    for (const suite of project.suites)\n      this._mergeSuiteInto(suite, projectSuite);\n  }\n\n  private _onBegin() {\n    this._reporter.onBegin?.(this._rootSuite);\n  }\n\n  private _onTestBegin(testId: string, payload: JsonTestResultStart) {\n    const test = this._tests.get(testId)!;\n    if (this._options.clearPreviousResultsWhenTestBegins)\n      test.results = [];\n    const testResult = test._createTestResult(payload.id);\n    testResult.retry = payload.retry;\n    testResult.workerIndex = payload.workerIndex;\n    testResult.parallelIndex = payload.parallelIndex;\n    testResult.setStartTimeNumber(payload.startTime);\n    this._reporter.onTestBegin?.(test, testResult);\n  }\n\n  private _onTestEnd(testEndPayload: JsonTestEnd, payload: JsonTestResultEnd) {\n    const test = this._tests.get(testEndPayload.testId)!;\n    test.timeout = testEndPayload.timeout;\n    test.expectedStatus = testEndPayload.expectedStatus;\n    const result = test.results.find(r => r._id === payload.id)!;\n    result.duration = payload.duration;\n    result.status = payload.status;\n    result.errors = payload.errors;\n    result.error = result.errors?.[0];\n    // Attachments are only present here from legacy blobs. These override all _onAttach events\n    if (!!payload.attachments)\n      result.attachments = this._parseAttachments(payload.attachments);\n    if (payload.annotations) {\n      this._absoluteAnnotationLocationsInplace(payload.annotations);\n      result.annotations = payload.annotations;\n      test.annotations = payload.annotations;\n    }\n    this._reporter.onTestEnd?.(test, result);\n    // Free up the memory as won't see these step ids.\n    result._stepMap = new Map();\n  }\n\n  private _onStepBegin(testId: string, resultId: string, payload: JsonTestStepStart) {\n    const test = this._tests.get(testId)!;\n    const result = test.results.find(r => r._id === resultId)!;\n    const parentStep = payload.parentStepId ? result._stepMap.get(payload.parentStepId) : undefined;\n\n    const location = this._absoluteLocation(payload.location);\n    const step = new TeleTestStep(payload, parentStep, location, result);\n    if (parentStep)\n      parentStep.steps.push(step);\n    else\n      result.steps.push(step);\n    result._stepMap.set(payload.id, step);\n    this._reporter.onStepBegin?.(test, result, step);\n  }\n\n  private _onStepEnd(testId: string, resultId: string, payload: JsonTestStepEnd) {\n    const test = this._tests.get(testId)!;\n    const result = test.results.find(r => r._id === resultId)!;\n    const step = result._stepMap.get(payload.id)!;\n    step._endPayload = payload;\n    step.duration = payload.duration;\n    step.error = payload.error;\n    this._reporter.onStepEnd?.(test, result, step);\n  }\n\n  private _onAttach(testId: string, resultId: string, attachments: JsonAttachment[]) {\n    const test = this._tests.get(testId)!;\n    const result = test.results.find(r => r._id === resultId)!;\n    result.attachments.push(...attachments.map(a => ({\n      name: a.name,\n      contentType: a.contentType,\n      path: a.path,\n      body: a.base64 && (globalThis as any).Buffer ? Buffer.from(a.base64, 'base64') : undefined,\n    })));\n  }\n\n  private _onError(error: reporterTypes.TestError) {\n    this._reporter.onError?.(error);\n  }\n\n  private _onStdIO(type: JsonStdIOType, testId: string | undefined, resultId: string | undefined, data: string, isBase64: boolean) {\n    const chunk = isBase64 ? ((globalThis as any).Buffer ? Buffer.from(data, 'base64') : atob(data)) : data;\n    const test = testId ? this._tests.get(testId) : undefined;\n    const result = test && resultId ? test.results.find(r => r._id === resultId) : undefined;\n    if (type === 'stdout') {\n      result?.stdout.push(chunk);\n      this._reporter.onStdOut?.(chunk, test, result);\n    } else {\n      result?.stderr.push(chunk);\n      this._reporter.onStdErr?.(chunk, test, result);\n    }\n  }\n\n  private async _onEnd(result: JsonFullResult): Promise<void> {\n    await this._reporter.onEnd?.({\n      status: result.status,\n      startTime: new Date(result.startTime),\n      duration: result.duration,\n    });\n  }\n\n  private _onExit(): Promise<void> | void {\n    return this._reporter.onExit?.();\n  }\n\n  private _parseConfig(config: JsonConfig): reporterTypes.FullConfig {\n    const result = { ...baseFullConfig, ...config };\n    if (this._options.configOverrides) {\n      result.configFile = this._options.configOverrides.configFile;\n      result.reportSlowTests = this._options.configOverrides.reportSlowTests;\n      result.quiet = this._options.configOverrides.quiet;\n      result.reporter = [...this._options.configOverrides.reporter];\n    }\n    return result;\n  }\n\n  private _parseProject(project: JsonProject): TeleFullProject {\n    return {\n      metadata: project.metadata,\n      name: project.name,\n      outputDir: this._absolutePath(project.outputDir),\n      repeatEach: project.repeatEach,\n      retries: project.retries,\n      testDir: this._absolutePath(project.testDir),\n      testIgnore: parseRegexPatterns(project.testIgnore),\n      testMatch: parseRegexPatterns(project.testMatch),\n      timeout: project.timeout,\n      grep: parseRegexPatterns(project.grep) as RegExp[],\n      grepInvert: parseRegexPatterns(project.grepInvert) as RegExp[],\n      dependencies: project.dependencies,\n      teardown: project.teardown,\n      snapshotDir: this._absolutePath(project.snapshotDir),\n      use: project.use,\n    };\n  }\n\n  private _parseAttachments(attachments: JsonAttachment[]): reporterTypes.TestResult['attachments'] {\n    return attachments.map(a => {\n      return {\n        ...a,\n        body: a.base64 && (globalThis as any).Buffer ? Buffer.from(a.base64, 'base64') : undefined,\n      };\n    });\n  }\n\n  private _mergeSuiteInto(jsonSuite: JsonSuite, parent: TeleSuite): void {\n    let targetSuite = parent.suites.find(s => s.title === jsonSuite.title);\n    if (!targetSuite) {\n      targetSuite = new TeleSuite(jsonSuite.title, parent.type === 'project' ? 'file' : 'describe');\n      parent._addSuite(targetSuite);\n    }\n    targetSuite.location = this._absoluteLocation(jsonSuite.location);\n    jsonSuite.entries.forEach(e => {\n      if ('testId' in e)\n        this._mergeTestInto(e, targetSuite!);\n      else\n        this._mergeSuiteInto(e, targetSuite!);\n    });\n  }\n\n  private _mergeTestInto(jsonTest: JsonTestCase, parent: TeleSuite) {\n    let targetTest = this._options.mergeTestCases ? parent.tests.find(s => s.title === jsonTest.title && s.repeatEachIndex === jsonTest.repeatEachIndex) : undefined;\n    if (!targetTest) {\n      targetTest = new TeleTestCase(jsonTest.testId, jsonTest.title, this._absoluteLocation(jsonTest.location), jsonTest.repeatEachIndex);\n      parent._addTest(targetTest);\n      this._tests.set(targetTest.id, targetTest);\n    }\n    this._updateTest(jsonTest, targetTest);\n  }\n\n  private _updateTest(payload: JsonTestCase, test: TeleTestCase): TeleTestCase {\n    test.id = payload.testId;\n    test.location = this._absoluteLocation(payload.location);\n    test.retries = payload.retries;\n    test.tags = payload.tags ?? [];\n    test.annotations = payload.annotations ?? [];\n    this._absoluteAnnotationLocationsInplace(test.annotations);\n    return test;\n  }\n\n  private _absoluteAnnotationLocationsInplace(annotations: TestAnnotation[]) {\n    for (const annotation of annotations) {\n      if (annotation.location)\n        annotation.location = this._absoluteLocation(annotation.location);\n    }\n  }\n\n  private _absoluteLocation(location: reporterTypes.Location): reporterTypes.Location;\n  private _absoluteLocation(location?: reporterTypes.Location): reporterTypes.Location | undefined;\n  private _absoluteLocation(location: reporterTypes.Location | undefined): reporterTypes.Location | undefined {\n    if (!location)\n      return location;\n    return {\n      ...location,\n      file: this._absolutePath(location.file),\n    };\n  }\n\n  private _absolutePath(relativePath: string): string;\n  private _absolutePath(relativePath?: string): string | undefined;\n  private _absolutePath(relativePath?: string): string | undefined {\n    if (relativePath === undefined)\n      return;\n    return this._options.resolvePath ? this._options.resolvePath(this._rootDir, relativePath) : this._rootDir + '/' + relativePath;\n  }\n}\n\nexport class TeleSuite implements reporterTypes.Suite {\n  title: string;\n  location?: reporterTypes.Location;\n  parent?: TeleSuite;\n  _entries: (TeleSuite | TeleTestCase)[] = [];\n  _requireFile: string = '';\n  _timeout: number | undefined;\n  _retries: number | undefined;\n  _project: TeleFullProject | undefined;\n  _parallelMode: 'none' | 'default' | 'serial' | 'parallel' = 'none';\n  private readonly _type: 'root' | 'project' | 'file' | 'describe';\n\n  constructor(title: string, type: 'root' | 'project' | 'file' | 'describe') {\n    this.title = title;\n    this._type = type;\n  }\n\n  get type() {\n    return this._type;\n  }\n\n  get suites(): TeleSuite[] {\n    return this._entries.filter(e => e.type !== 'test') as TeleSuite[];\n  }\n\n  get tests(): TeleTestCase[] {\n    return this._entries.filter(e => e.type === 'test') as TeleTestCase[];\n  }\n\n  entries() {\n    return this._entries;\n  }\n\n  allTests(): reporterTypes.TestCase[] {\n    const result: reporterTypes.TestCase[] = [];\n    const visit = (suite: reporterTypes.Suite) => {\n      for (const entry of suite.entries()) {\n        if (entry.type === 'test')\n          result.push(entry);\n        else\n          visit(entry);\n      }\n    };\n    visit(this);\n    return result;\n  }\n\n  titlePath(): string[] {\n    const titlePath = this.parent ? this.parent.titlePath() : [];\n    // Ignore anonymous describe blocks.\n    if (this.title || this._type !== 'describe')\n      titlePath.push(this.title);\n    return titlePath;\n  }\n\n  project(): TeleFullProject | undefined {\n    return this._project ?? this.parent?.project();\n  }\n\n  _addTest(test: TeleTestCase) {\n    test.parent = this;\n    this._entries.push(test);\n  }\n\n  _addSuite(suite: TeleSuite) {\n    suite.parent = this;\n    this._entries.push(suite);\n  }\n}\n\nexport class TeleTestCase implements reporterTypes.TestCase {\n  title: string;\n  fn = () => {};\n  results: TeleTestResult[] = [];\n  location: reporterTypes.Location;\n  parent!: TeleSuite;\n  type: 'test' = 'test';\n\n  expectedStatus: reporterTypes.TestStatus = 'passed';\n  timeout = 0;\n  annotations: TestAnnotation[] = [];\n  retries = 0;\n  tags: string[] = [];\n  repeatEachIndex = 0;\n  id: string;\n\n  constructor(id: string, title: string, location: reporterTypes.Location, repeatEachIndex: number) {\n    this.id = id;\n    this.title = title;\n    this.location = location;\n    this.repeatEachIndex = repeatEachIndex;\n  }\n\n  titlePath(): string[] {\n    const titlePath = this.parent ? this.parent.titlePath() : [];\n    titlePath.push(this.title);\n    return titlePath;\n  }\n\n  outcome(): 'skipped' | 'expected' | 'unexpected' | 'flaky' {\n    return computeTestCaseOutcome(this);\n  }\n\n  ok(): boolean {\n    const status = this.outcome();\n    return status === 'expected' || status === 'flaky' || status === 'skipped';\n  }\n\n  _createTestResult(id: string): TeleTestResult {\n    const result = new TeleTestResult(this.results.length, id);\n    this.results.push(result);\n    return result;\n  }\n}\n\nclass TeleTestStep implements reporterTypes.TestStep {\n  title: string;\n  category: string;\n  location: reporterTypes.Location | undefined;\n  parent: reporterTypes.TestStep | undefined;\n  duration: number = -1;\n  steps: reporterTypes.TestStep[] = [];\n  error: reporterTypes.TestError | undefined;\n\n  private _result: TeleTestResult;\n  _endPayload?: JsonTestStepEnd;\n\n  private _startTime: number = 0;\n\n  constructor(payload: JsonTestStepStart, parentStep: reporterTypes.TestStep | undefined, location: reporterTypes.Location | undefined, result: TeleTestResult) {\n    this.title = payload.title;\n    this.category = payload.category;\n    this.location = location;\n    this.parent = parentStep;\n    this._startTime = payload.startTime;\n    this._result = result;\n  }\n\n  titlePath() {\n    const parentPath = this.parent?.titlePath() || [];\n    return [...parentPath, this.title];\n  }\n\n  get startTime(): Date {\n    return new Date(this._startTime);\n  }\n\n  set startTime(value: Date) {\n    this._startTime = +value;\n  }\n\n  get attachments() {\n    return this._endPayload?.attachments?.map(index => this._result.attachments[index]) ?? [];\n  }\n\n  get annotations() {\n    return this._endPayload?.annotations ?? [];\n  }\n}\n\nexport class TeleTestResult implements reporterTypes.TestResult {\n  retry: reporterTypes.TestResult['retry'];\n  parallelIndex: reporterTypes.TestResult['parallelIndex'] = -1;\n  workerIndex: reporterTypes.TestResult['workerIndex'] = -1;\n  duration: reporterTypes.TestResult['duration'] = -1;\n  stdout: reporterTypes.TestResult['stdout'] = [];\n  stderr: reporterTypes.TestResult['stderr'] = [];\n  attachments: reporterTypes.TestResult['attachments'] = [];\n  annotations: reporterTypes.TestResult['annotations'] = [];\n  status: reporterTypes.TestStatus = 'skipped';\n  steps: TeleTestStep[] = [];\n  errors: reporterTypes.TestResult['errors'] = [];\n  error: reporterTypes.TestResult['error'];\n\n  _stepMap = new Map<string, TeleTestStep>();\n  _id: string;\n\n  private _startTime: number = 0;\n\n  constructor(retry: number, id: string) {\n    this.retry = retry;\n    this._id = id;\n  }\n\n  setStartTimeNumber(startTime: number) {\n    this._startTime = startTime;\n  }\n\n  get startTime(): Date {\n    return new Date(this._startTime);\n  }\n\n  set startTime(value: Date) {\n    this._startTime = +value;\n  }\n}\n\nexport type TeleFullProject = reporterTypes.FullProject;\n\nexport const baseFullConfig: reporterTypes.FullConfig = {\n  forbidOnly: false,\n  fullyParallel: false,\n  globalSetup: null,\n  globalTeardown: null,\n  globalTimeout: 0,\n  grep: /.*/,\n  grepInvert: null,\n  maxFailures: 0,\n  metadata: {},\n  preserveOutput: 'always',\n  projects: [],\n  reporter: [[process.env.CI ? 'dot' : 'list']],\n  reportSlowTests: { max: 5, threshold: 300_000 /* 5 minutes */ },\n  configFile: '',\n  rootDir: '',\n  quiet: false,\n  shard: null,\n  tags: [],\n  updateSnapshots: 'missing',\n  updateSourceMethod: 'patch',\n  version: '',\n  workers: 0,\n  webServer: null,\n};\n\nexport function serializeRegexPatterns(patterns: string | RegExp | (string | RegExp)[]): JsonPattern[] {\n  if (!Array.isArray(patterns))\n    patterns = [patterns];\n  return patterns.map(s => {\n    if (typeof s === 'string')\n      return { s };\n    return { r: { source: s.source, flags: s.flags } };\n  });\n}\n\nexport function parseRegexPatterns(patterns: JsonPattern[]): (string | RegExp)[] {\n  return patterns.map(p => {\n    if (p.s !== undefined)\n      return p.s;\n    return new RegExp(p.r!.source, p.r!.flags);\n  });\n}\n\nexport function computeTestCaseOutcome(test: reporterTypes.TestCase) {\n  let skipped = 0;\n  let didNotRun = 0;\n  let expected = 0;\n  let interrupted = 0;\n  let unexpected = 0;\n  for (const result of test.results) {\n    if (result.status === 'interrupted') {\n      ++interrupted; // eslint-disable-line @typescript-eslint/no-unused-vars\n    } else if (result.status === 'skipped' && test.expectedStatus === 'skipped') {\n      // Only tests \"expected to be skipped\" are skipped. These were specifically\n      // marked with test.skip or test.fixme.\n      ++skipped;\n    } else if (result.status === 'skipped') {\n      // Tests that were expected to run, but were skipped are \"did not run\".\n      // This happens when:\n      // - testing finished early;\n      // - test failure prevented other tests in the serial suite to run;\n      // - probably more cases!\n      ++didNotRun; // eslint-disable-line @typescript-eslint/no-unused-vars\n    } else if (result.status === test.expectedStatus) {\n      // Either passed and expected to pass, or failed and expected to fail.\n      ++expected;\n    } else {\n      ++unexpected;\n    }\n  }\n\n  // Tests that were \"skipped as expected\" are considered equal to \"expected\" below,\n  // because that's the expected outcome.\n  //\n  // However, we specifically differentiate the case of \"only skipped\"\n  // and show it as \"skipped\" in all reporters.\n  //\n  // More exotic cases like \"failed on first run and skipped on retry\" are flaky.\n  if (expected === 0 && unexpected === 0)\n    return 'skipped';  // all results were skipped or interrupted\n  if (unexpected === 0)\n    return 'expected';  // no failures, just expected+skipped\n  if (expected === 0 && skipped === 0)\n    return 'unexpected';  // only failures\n  return 'flaky';  // expected+unexpected or skipped+unexpected\n}\n","/**\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 type TestItemStatus = 'none' | 'running' | 'scheduled' | 'passed' | 'failed' | 'skipped';\nimport type * as reporterTypes from '../../types/testReporter';\n\n// -- Reuse boundary -- Everything below this line is reused in the vscode extension.\n\nexport type TreeItemBase = {\n  kind: 'root' | 'group' | 'case' | 'test',\n  id: string;\n  title: string;\n  location: reporterTypes.Location,\n  duration: number;\n  parent: TreeItem | undefined;\n  children: TreeItem[];\n  status: TestItemStatus;\n};\n\nexport type GroupItem = TreeItemBase & {\n  kind: 'group';\n  subKind: 'folder' | 'file' | 'describe';\n  hasLoadErrors: boolean;\n  children: (TestCaseItem | GroupItem)[];\n};\n\nexport type TestCaseItem = TreeItemBase & {\n  kind: 'case',\n  tests: reporterTypes.TestCase[];\n  children: TestItem[];\n  test: reporterTypes.TestCase | undefined;\n  project: reporterTypes.FullProject | undefined;\n  tags: Array<string>;\n};\n\nexport type TestItem = TreeItemBase & {\n  kind: 'test',\n  test: reporterTypes.TestCase;\n  project: reporterTypes.FullProject;\n};\n\nexport type TreeItem = GroupItem | TestCaseItem | TestItem;\n\nexport class TestTree {\n  rootItem: GroupItem;\n  private _treeItemById = new Map<string, TreeItem>();\n  private _treeItemByTestId = new Map<string, TestItem | TestCaseItem>();\n  readonly pathSeparator: string;\n\n  constructor(rootFolder: string, rootSuite: reporterTypes.Suite | undefined, loadErrors: reporterTypes.TestError[], projectFilters: Map<string, boolean> | undefined, pathSeparator: string, hideFiles: boolean) {\n    const filterProjects = projectFilters && [...projectFilters.values()].some(Boolean);\n    this.pathSeparator = pathSeparator;\n    this.rootItem = {\n      kind: 'group',\n      subKind: 'folder',\n      id: rootFolder,\n      title: '',\n      location: { file: '', line: 0, column: 0 },\n      duration: 0,\n      parent: undefined,\n      children: [],\n      status: 'none',\n      hasLoadErrors: false,\n    };\n    this._treeItemById.set(rootFolder, this.rootItem);\n\n    const visitSuite = (project: reporterTypes.FullProject, parentSuite: reporterTypes.Suite, parentGroup: GroupItem, mode: 'tests' | 'suites' | 'all') => {\n      for (const suite of mode === 'tests' ? [] : parentSuite.suites) {\n        if (!suite.title) {\n          // Flatten anonymous describes.\n          visitSuite(project, suite, parentGroup, 'all');\n          continue;\n        }\n\n        let group = parentGroup.children.find(item => item.kind === 'group' && item.title === suite.title) as GroupItem | undefined;\n        if (!group) {\n          group = {\n            kind: 'group',\n            subKind: 'describe',\n            id: 'suite:' + parentSuite.titlePath().join('\\x1e') + '\\x1e' + suite.title,  // account for anonymous suites\n            title: suite.title,\n            location: suite.location!,\n            duration: 0,\n            parent: parentGroup,\n            children: [],\n            status: 'none',\n            hasLoadErrors: false,\n          };\n          this._addChild(parentGroup, group);\n        }\n        visitSuite(project, suite, group, 'all');\n      }\n\n      for (const test of mode === 'suites' ? [] : parentSuite.tests) {\n        const title = test.title;\n        let testCaseItem = parentGroup.children.find(t => t.kind !== 'group' && t.title === title) as TestCaseItem;\n        if (!testCaseItem) {\n          testCaseItem = {\n            kind: 'case',\n            id: 'test:' + test.titlePath().join('\\x1e'),\n            title,\n            parent: parentGroup,\n            children: [],\n            tests: [],\n            location: test.location,\n            duration: 0,\n            status: 'none',\n            project: undefined,\n            test: undefined,\n            tags: test.tags,\n          };\n          this._addChild(parentGroup, testCaseItem);\n        }\n\n        const result = test.results[0];\n        let status: 'none' | 'running' | 'scheduled' | 'passed' | 'failed' | 'skipped' = 'none';\n        if ((result as any)?.[statusEx] === 'scheduled')\n          status = 'scheduled';\n        else if ((result as any)?.[statusEx] === 'running')\n          status = 'running';\n        else if (result?.status === 'skipped')\n          status = 'skipped';\n        else if (result?.status === 'interrupted')\n          status = 'none';\n        else if (result && test.outcome() !== 'expected')\n          status = 'failed';\n        else if (result && test.outcome() === 'expected')\n          status = 'passed';\n\n        testCaseItem.tests.push(test);\n        const testItem: TestItem = {\n          kind: 'test',\n          id: test.id,\n          title: project.name,\n          location: test.location!,\n          test,\n          parent: testCaseItem,\n          children: [],\n          status,\n          duration: test.results.length ? Math.max(0, test.results[0].duration) : 0,\n          project,\n        };\n        this._addChild(testCaseItem, testItem);\n        this._treeItemByTestId.set(test.id, testItem);\n        testCaseItem.duration = (testCaseItem.children as TestItem[]).reduce((a, b) => a + b.duration, 0);\n      }\n    };\n\n    for (const projectSuite of rootSuite?.suites || []) {\n      if (filterProjects && !projectFilters.get(projectSuite.title))\n        continue;\n      for (const fileSuite of projectSuite.suites) {\n        if (hideFiles) {\n          visitSuite(projectSuite.project()!, fileSuite, this.rootItem, 'suites');\n          if (fileSuite.tests.length) {\n            const defaultDescribeItem = this._defaultDescribeItem();\n            visitSuite(projectSuite.project()!, fileSuite, defaultDescribeItem, 'tests');\n          }\n        } else {\n          const fileItem = this._fileItem(fileSuite.location!.file.split(pathSeparator), true);\n          visitSuite(projectSuite.project()!, fileSuite, fileItem, 'all');\n        }\n      }\n    }\n\n    for (const loadError of loadErrors) {\n      if (!loadError.location)\n        continue;\n      const fileItem = this._fileItem(loadError.location.file.split(pathSeparator), true);\n      fileItem.hasLoadErrors = true;\n    }\n  }\n\n  private _addChild(parent: TreeItem, child: TreeItem) {\n    parent.children.push(child);\n    child.parent = parent;\n    this._treeItemById.set(child.id, child);\n  }\n\n  filterTree(filterText: string, statusFilters: Map<string, boolean>, runningTestIds: Set<string> | undefined) {\n    const tokens = filterText.trim().toLowerCase().split(' ');\n    const filtersStatuses = [...statusFilters.values()].some(Boolean);\n\n    const filter = (testCase: TestCaseItem) => {\n      const titleWithTags = [...testCase.tests[0].titlePath(), ...testCase.tests[0].tags].join(' ').toLowerCase();\n      if (!tokens.every(token => titleWithTags.includes(token)) && !testCase.tests.some(t => runningTestIds?.has(t.id)))\n        return false;\n      testCase.children = (testCase.children as TestItem[]).filter(test => {\n        return !filtersStatuses || runningTestIds?.has(test.test.id) || statusFilters.get(test.status);\n      });\n      testCase.tests = (testCase.children as TestItem[]).map(c => c.test);\n      return !!testCase.children.length;\n    };\n\n    const visit = (treeItem: GroupItem) => {\n      const newChildren: (GroupItem | TestCaseItem)[] = [];\n      for (const child of treeItem.children) {\n        if (child.kind === 'case') {\n          if (filter(child))\n            newChildren.push(child);\n        } else {\n          visit(child);\n          if (child.children.length || child.hasLoadErrors)\n            newChildren.push(child);\n        }\n      }\n      treeItem.children = newChildren;\n    };\n    visit(this.rootItem);\n  }\n\n  private _fileItem(filePath: string[], isFile: boolean): GroupItem {\n    if (filePath.length === 0)\n      return this.rootItem;\n    const fileName = filePath.join(this.pathSeparator);\n    const existingFileItem = this._treeItemById.get(fileName);\n    if (existingFileItem)\n      return existingFileItem as GroupItem;\n    const parentFileItem = this._fileItem(filePath.slice(0, filePath.length - 1), false);\n    const fileItem: GroupItem = {\n      kind: 'group',\n      subKind: isFile ? 'file' : 'folder',\n      id: fileName,\n      title: filePath[filePath.length - 1],\n      location: { file: fileName, line: 0, column: 0 },\n      duration: 0,\n      parent: parentFileItem,\n      children: [],\n      status: 'none',\n      hasLoadErrors: false,\n    };\n    this._addChild(parentFileItem, fileItem);\n    return fileItem;\n  }\n\n  private _defaultDescribeItem(): GroupItem {\n    let defaultDescribeItem = this._treeItemById.get('<anonymous>') as GroupItem;\n    if (!defaultDescribeItem) {\n      defaultDescribeItem = {\n        kind: 'group',\n        subKind: 'describe',\n        id: '<anonymous>',\n        title: '<anonymous>',\n        location: { file: '', line: 0, column: 0 },\n        duration: 0,\n        parent: this.rootItem,\n        children: [],\n        status: 'none',\n        hasLoadErrors: false,\n      };\n      this._addChild(this.rootItem, defaultDescribeItem);\n    }\n    return defaultDescribeItem;\n  }\n\n  sortAndPropagateStatus() {\n    sortAndPropagateStatus(this.rootItem);\n  }\n\n  flattenForSingleProject() {\n    const visit = (treeItem: TreeItem) => {\n      if (treeItem.kind === 'case' && treeItem.children.length === 1) {\n        treeItem.project = treeItem.children[0].project;\n        treeItem.test = treeItem.children[0].test;\n        treeItem.children = [];\n        this._treeItemByTestId.set(treeItem.test.id, treeItem);\n      } else {\n        treeItem.children.forEach(visit);\n      }\n    };\n    visit(this.rootItem);\n  }\n\n  shortenRoot() {\n    let shortRoot = this.rootItem;\n    while (shortRoot.children.length === 1 && shortRoot.children[0].kind === 'group' && shortRoot.children[0].subKind === 'folder')\n      shortRoot = shortRoot.children[0];\n    shortRoot.location = this.rootItem.location;\n    this.rootItem = shortRoot;\n  }\n\n  testIds(): Set<string> {\n    const result = new Set<string>();\n    const visit = (treeItem: TreeItem) => {\n      if (treeItem.kind === 'case')\n        treeItem.tests.forEach(t => result.add(t.id));\n      treeItem.children.forEach(visit);\n    };\n    visit(this.rootItem);\n    return result;\n  }\n\n  fileNames(): string[] {\n    const result = new Set<string>();\n    const visit = (treeItem: TreeItem) => {\n      if (treeItem.kind === 'group' && treeItem.subKind === 'file')\n        result.add(treeItem.id);\n      else\n        treeItem.children.forEach(visit);\n    };\n    visit(this.rootItem);\n    return [...result];\n  }\n\n  flatTreeItems(): TreeItem[] {\n    const result: TreeItem[] = [];\n    const visit = (treeItem: TreeItem) => {\n      result.push(treeItem);\n      treeItem.children.forEach(visit);\n    };\n    visit(this.rootItem);\n    return result;\n  }\n\n  treeItemById(id: string): TreeItem | undefined {\n    return this._treeItemById.get(id);\n  }\n\n  collectTestIds(treeItem?: TreeItem): Set<string> {\n    return treeItem ? collectTestIds(treeItem) : new Set();\n  }\n}\n\nexport function sortAndPropagateStatus(treeItem: TreeItem) {\n  for (const child of treeItem.children)\n    sortAndPropagateStatus(child);\n\n  if (treeItem.kind === 'group') {\n    treeItem.children.sort((a, b) => {\n      const fc = a.location.file.localeCompare(b.location.file);\n      return fc || a.location.line - b.location.line;\n    });\n  }\n\n  let allPassed = treeItem.children.length > 0;\n  let allSkipped = treeItem.children.length > 0;\n  let hasFailed = false;\n  let hasRunning = false;\n  let hasScheduled = false;\n\n  for (const child of treeItem.children) {\n    allSkipped = allSkipped && child.status === 'skipped';\n    allPassed = allPassed && (child.status === 'passed' || child.status === 'skipped');\n    hasFailed = hasFailed || child.status === 'failed';\n    hasRunning = hasRunning || child.status === 'running';\n    hasScheduled = hasScheduled || child.status === 'scheduled';\n  }\n\n  if (hasRunning)\n    treeItem.status = 'running';\n  else if (hasScheduled)\n    treeItem.status = 'scheduled';\n  else if (hasFailed)\n    treeItem.status = 'failed';\n  else if (allSkipped)\n    treeItem.status = 'skipped';\n  else if (allPassed)\n    treeItem.status = 'passed';\n}\n\nexport function collectTestIds(treeItem: TreeItem): Set<string> {\n  const testIds = new Set<string>();\n  const visit = (treeItem: TreeItem) => {\n    if (treeItem.kind === 'case')\n      treeItem.tests.map(t => t.id).forEach(id => testIds.add(id));\n    else if (treeItem.kind === 'test')\n      testIds.add(treeItem.id);\n    else\n      treeItem.children?.forEach(visit);\n  };\n  visit(treeItem);\n  return testIds;\n}\n\nexport const statusEx = Symbol('statusEx');\n","/**\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 { TeleReporterReceiver, TeleSuite } from './teleReceiver';\nimport { statusEx } from './testTree';\n\nimport type * as reporterTypes from '../../types/testReporter';\nimport type { ReporterV2 } from '../reporters/reporterV2';\n\nexport type TeleSuiteUpdaterProgress = {\n  total: number;\n  passed: number;\n  failed: number;\n  skipped: number;\n};\n\nexport type TeleSuiteUpdaterTestModel = {\n  config: reporterTypes.FullConfig;\n  rootSuite: reporterTypes.Suite;\n  loadErrors: reporterTypes.TestError[];\n  progress: TeleSuiteUpdaterProgress;\n};\n\nexport type TeleSuiteUpdaterOptions = {\n  onUpdate: (force?: boolean) => void,\n  onError?: (error: reporterTypes.TestError) => void;\n  pathSeparator: string;\n};\n\nexport class TeleSuiteUpdater {\n  rootSuite: TeleSuite | undefined;\n  config: reporterTypes.FullConfig | undefined;\n  readonly loadErrors: reporterTypes.TestError[] = [];\n  readonly progress: TeleSuiteUpdaterProgress = {\n    total: 0,\n    passed: 0,\n    failed: 0,\n    skipped: 0,\n  };\n\n  private _receiver: TeleReporterReceiver;\n  private _lastRunReceiver: TeleReporterReceiver | undefined;\n  private _lastRunTestCount = 0;\n  private _options: TeleSuiteUpdaterOptions;\n  private _testResultsSnapshot: Map<string, reporterTypes.TestResult[]> | undefined;\n\n  constructor(options: TeleSuiteUpdaterOptions) {\n    this._receiver = new TeleReporterReceiver(this._createReporter(), {\n      mergeProjects: true,\n      mergeTestCases: true,\n      resolvePath: (rootDir, relativePath) => rootDir + options.pathSeparator + relativePath,\n      clearPreviousResultsWhenTestBegins: true,\n    });\n    this._options = options;\n  }\n\n  private _createReporter(): ReporterV2 {\n    return {\n      version: () => 'v2',\n\n      onConfigure: (c: reporterTypes.FullConfig) => {\n        this.config = c;\n        // TeleReportReceiver is merging everything into a single suite, so when we\n        // run one test, we still get many tests via rootSuite.allTests().length.\n        // To work around that, have a dedicated per-run receiver that will only have\n        // suite for a single test run, and hence will have correct total.\n        this._lastRunReceiver = new TeleReporterReceiver({\n          version: () => 'v2',\n          onBegin: (suite: reporterTypes.Suite) => {\n            this._lastRunTestCount = suite.allTests().length;\n            this._lastRunReceiver = undefined;\n          }\n        }, {\n          mergeProjects: true,\n          mergeTestCases: false,\n          resolvePath: (rootDir, relativePath) => rootDir + this._options.pathSeparator + relativePath,\n        });\n      },\n\n      onBegin: (suite: reporterTypes.Suite) => {\n        if (!this.rootSuite)\n          this.rootSuite = suite as TeleSuite;\n        // As soon as new test tree is built add previous results, before calling onUpdate\n        // to avoid flashing empty results in the UI.\n        if (this._testResultsSnapshot) {\n          for (const test of this.rootSuite.allTests())\n            test.results = this._testResultsSnapshot?.get(test.id) || test.results;\n          this._testResultsSnapshot = undefined;\n        }\n        this.progress.total = this._lastRunTestCount;\n        this.progress.passed = 0;\n        this.progress.failed = 0;\n        this.progress.skipped = 0;\n        this._options.onUpdate(true);\n      },\n\n      onEnd: () => {\n        this._options.onUpdate(true);\n      },\n\n      onTestBegin: (test: reporterTypes.TestCase, testResult: reporterTypes.TestResult) => {\n        (testResult as any)[statusEx] = 'running';\n        this._options.onUpdate();\n      },\n\n      onTestEnd: (test: reporterTypes.TestCase, testResult: reporterTypes.TestResult) => {\n        if (test.outcome() === 'skipped')\n          ++this.progress.skipped;\n        else if (test.outcome() === 'unexpected')\n          ++this.progress.failed;\n        else\n          ++this.progress.passed;\n        (testResult as any)[statusEx] = testResult.status;\n        this._options.onUpdate();\n      },\n\n      onError: (error: reporterTypes.TestError) => this._handleOnError(error),\n\n      printsToStdio: () => false,\n    };\n  }\n\n  processGlobalReport(report: any[]) {\n    const receiver = new TeleReporterReceiver({\n      version: () => 'v2',\n      onConfigure: (c: reporterTypes.FullConfig) => {\n        this.config = c;\n      },\n      onError: (error: reporterTypes.TestError) => this._handleOnError(error)\n    });\n    for (const message of report)\n      void receiver.dispatch(message);\n  }\n\n  processListReport(report: any[]) {\n    // Save test results and reset all projects, the results will be restored after\n    // new project structure is built.\n    const tests = this.rootSuite?.allTests() || [];\n    this._testResultsSnapshot = new Map(tests.map(test => [test.id, test.results]));\n    this._receiver.reset();\n    for (const message of report)\n      void this._receiver.dispatch(message);\n  }\n\n  processTestReportEvent(message: any) {\n    // The order of receiver dispatches matters here, we want to assign `lastRunTestCount`\n    // before we use it.\n    this._lastRunReceiver?.dispatch(message)?.catch(() => { });\n    this._receiver.dispatch(message)?.catch(() => { });\n  }\n\n  private _handleOnError(error: reporterTypes.TestError) {\n    this.loadErrors.push(error);\n    this._options.onError?.(error);\n    this._options.onUpdate();\n  }\n\n  asModel(): TeleSuiteUpdaterTestModel {\n    return {\n      rootSuite: this.rootSuite || new TeleSuite('', 'root'),\n      config: this.config!,\n      loadErrors: this.loadErrors,\n      progress: this.progress,\n    };\n  }\n}\n","/*\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 * as React from 'react';\nimport './xtermWrapper.css';\nimport type { ITheme, Terminal } from '@xterm/xterm';\nimport type { FitAddon } from '@xterm/addon-fit';\nimport type { XtermModule } from './xtermModule';\nimport { currentTheme, addThemeListener, removeThemeListener } from '../theme';\nimport { useMeasure } from '../uiUtils';\n\nexport type XtermDataSource = {\n  pending: (string | Uint8Array)[];\n  clear: () => void,\n  write: (data: string | Uint8Array) => void;\n  resize: (cols: number, rows: number) => void;\n};\n\nexport const XtermWrapper: React.FC<{ source: XtermDataSource }> = ({\n  source,\n}) => {\n  const [measure, xtermElement] = useMeasure<HTMLDivElement>();\n  const [theme, setTheme] = React.useState(currentTheme());\n  const [modulePromise] = React.useState<Promise<XtermModule>>(import('./xtermModule').then(m => m.default));\n  const terminal = React.useRef<{ terminal: Terminal, fitAddon: FitAddon } | null>(null);\n\n  React.useEffect(() => {\n    addThemeListener(setTheme);\n    return () => removeThemeListener(setTheme);\n  }, []);\n\n  React.useEffect(() => {\n    const oldSourceWrite = source.write;\n    const oldSourceClear = source.clear;\n\n    (async () => {\n      // Always load the module first.\n      const { Terminal, FitAddon } = await modulePromise;\n      const element = xtermElement.current;\n      if (!element)\n        return;\n\n      const terminalTheme = theme === 'dark-mode' ? darkTheme : lightTheme;\n      if (terminal.current && terminal.current.terminal.options.theme === terminalTheme)\n        return;\n\n      if (terminal.current)\n        element.textContent = '';\n\n      const newTerminal = new Terminal({\n        convertEol: true,\n        fontSize: 13,\n        scrollback: 10000,\n        fontFamily: 'monospace',\n        theme: terminalTheme,\n      });\n\n      const fitAddon = new FitAddon();\n      newTerminal.loadAddon(fitAddon);\n      for (const p of source.pending)\n        newTerminal.write(p);\n      source.write = (data => {\n        source.pending.push(data);\n        newTerminal.write(data);\n      });\n      source.clear = () => {\n        source.pending = [];\n        newTerminal.clear();\n      };\n      newTerminal.open(element);\n      fitAddon.fit();\n      terminal.current = { terminal: newTerminal, fitAddon };\n    })();\n    return () => {\n      source.clear = oldSourceClear;\n      source.write = oldSourceWrite;\n    };\n  }, [modulePromise, terminal, xtermElement, source, theme]);\n\n  React.useEffect(() => {\n    // Fit reads data from the terminal itself, which updates lazily, probably on some timer\n    // or mutation observer. Work around it.\n    setTimeout(() => {\n      if (!terminal.current)\n        return;\n      terminal.current.fitAddon.fit();\n      source.resize(terminal.current.terminal.cols, terminal.current.terminal.rows);\n    }, 250);\n  }, [measure, source]);\n\n  return <div data-testid='output' className='xterm-wrapper' style={{ flex: 'auto' }} ref={xtermElement}></div>;\n};\n\nconst lightTheme: ITheme = {\n  foreground: '#383a42',\n  background: '#fafafa',\n  cursor: '#383a42',\n  black: '#000000',\n  red: '#e45649',\n  green: '#50a14f',\n  yellow: '#c18401',\n  blue: '#4078f2',\n  magenta: '#a626a4',\n  cyan: '#0184bc',\n  white: '#a0a0a0',\n  brightBlack: '#000000',\n  brightRed: '#e06c75',\n  brightGreen: '#98c379',\n  brightYellow: '#d19a66',\n  brightBlue: '#4078f2',\n  brightMagenta: '#a626a4',\n  brightCyan: '#0184bc',\n  brightWhite: '#383a42',\n  selectionBackground: '#d7d7d7',\n  selectionForeground: '#383a42',\n};\n\nconst darkTheme: ITheme = {\n  foreground: '#f8f8f2',\n  background: '#1e1e1e',\n  cursor: '#f8f8f0',\n  black: '#000000',\n  red: '#ff5555',\n  green: '#50fa7b',\n  yellow: '#f1fa8c',\n  blue: '#bd93f9',\n  magenta: '#ff79c6',\n  cyan: '#8be9fd',\n  white: '#bfbfbf',\n  brightBlack: '#4d4d4d',\n  brightRed: '#ff6e6e',\n  brightGreen: '#69ff94',\n  brightYellow: '#ffffa5',\n  brightBlue: '#d6acff',\n  brightMagenta: '#ff92df',\n  brightCyan: '#a4ffff',\n  brightWhite: '#e6e6e6',\n  selectionBackground: '#44475a',\n  selectionForeground: '#f8f8f2',\n};\n","/**\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 '@web/common.css';\nimport { Expandable } from '@web/components/expandable';\nimport '@web/third_party/vscode/codicon.css';\nimport { settings } from '@web/uiUtils';\nimport React from 'react';\nimport './uiModeFiltersView.css';\nimport type { TeleSuiteUpdaterTestModel } from '@testIsomorphic/teleSuiteUpdater';\n\nexport const FiltersView: React.FC<{\n  filterText: string;\n  setFilterText: (text: string) => void;\n  statusFilters: Map<string, boolean>;\n  setStatusFilters: (filters: Map<string, boolean>) => void;\n  projectFilters: Map<string, boolean>;\n  setProjectFilters: (filters: Map<string, boolean>) => void;\n  testModel: TeleSuiteUpdaterTestModel | undefined,\n  runTests: () => void;\n}> = ({ filterText, setFilterText, statusFilters, setStatusFilters, projectFilters, setProjectFilters, testModel, runTests }) => {\n  const [expanded, setExpanded] = React.useState(false);\n  const inputRef = React.useRef<HTMLInputElement>(null);\n  React.useEffect(() => {\n    inputRef.current?.focus();\n  }, []);\n\n  const statusLine = [...statusFilters.entries()].filter(([_, v]) => v).map(([s]) => s).join(' ') || 'all';\n  const projectsLine = [...projectFilters.entries()].filter(([_, v]) => v).map(([p]) => p).join(' ') || 'all';\n  return <div className='filters'>\n    <Expandable\n      expanded={expanded}\n      setExpanded={setExpanded}\n      title={<input ref={inputRef} type='search' placeholder='Filter (e.g. text, @tag)' spellCheck={false} value={filterText}\n        onChange={e => {\n          setFilterText(e.target.value);\n        }}\n        onKeyDown={e => {\n          if (e.key === 'Enter')\n            runTests();\n        }} />}>\n    </Expandable>\n    <div className='filter-summary' title={'Status: ' + statusLine + '\\nProjects: ' + projectsLine} onClick={() => setExpanded(!expanded)}>\n      <span className='filter-label'>Status:</span> {statusLine}\n      <span className='filter-label'>Projects:</span> {projectsLine}\n    </div>\n    {expanded && <div className='hbox' style={{ marginLeft: 14, maxHeight: 200, overflowY: 'auto' }}>\n      <div className='filter-list' role='list' data-testid='status-filters'>\n        {[...statusFilters.entries()].map(([status, value]) => {\n          return <div className='filter-entry' key={status} role='listitem'>\n            <label>\n              <input type='checkbox' checked={value} onChange={() => {\n                const copy = new Map(statusFilters);\n                copy.set(status, !copy.get(status));\n                setStatusFilters(copy);\n              }}/>\n              <div>{status}</div>\n            </label>\n          </div>;\n        })}\n      </div>\n      <div className='filter-list' role='list' data-testid='project-filters'>\n        {[...projectFilters.entries()].map(([projectName, value]) => {\n          return <div className='filter-entry' key={projectName}  role='listitem'>\n            <label>\n              <input type='checkbox' checked={value} onChange={() => {\n                const copy = new Map(projectFilters);\n                copy.set(projectName, !copy.get(projectName));\n                setProjectFilters(copy);\n                const configFile = testModel?.config?.configFile;\n                if (configFile)\n                  settings.setObject(configFile + ':projects', [...copy.entries()].filter(([_, v]) => v).map(([k]) => k));\n              }}/>\n              <div>{projectName || 'untitled'}</div>\n            </label>\n          </div>;\n        })}\n      </div>\n    </div>}\n  </div>;\n};\n","/**\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 { clsx } from '@web/uiUtils';\nimport './tag.css';\n\nexport const TagView = ({ tag, style, onClick }: { tag: string, style?: React.CSSProperties, onClick?: (e: React.MouseEvent) => void }) => {\n  return <span\n    className={clsx('tag', `tag-color-${tagNameToColor(tag)}`)}\n    onClick={onClick}\n    style={{ margin: '6px 0 0 6px', ...style }}\n    title={`Click to filter by tag: ${tag}`}\n  >\n    {tag}\n  </span>;\n};\n\n// hash string to integer in range [0, 6] for color index, to get same color for same tag\nfunction tagNameToColor(str: string) {\n  let hash = 0;\n  for (let i = 0; i < str.length; i++)\n    hash = str.charCodeAt(i) + ((hash << 8) - hash);\n  return Math.abs(hash % 6);\n}\n","/**\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 type { TreeItem } from '@testIsomorphic/testTree';\nimport type { TestTree } from '@testIsomorphic/testTree';\nimport '@web/common.css';\nimport { Toolbar } from '@web/components/toolbar';\nimport { ToolbarButton } from '@web/components/toolbarButton';\nimport type { TreeState } from '@web/components/treeView';\nimport { TreeView } from '@web/components/treeView';\nimport '@web/third_party/vscode/codicon.css';\nimport { msToString } from '@web/uiUtils';\nimport type * as reporterTypes from 'playwright/types/testReporter';\nimport React from 'react';\nimport type { SourceLocation } from './modelUtil';\nimport { testStatusIcon } from './testUtils';\nimport './uiModeTestListView.css';\nimport type { TestServerConnection } from '@testIsomorphic/testServerConnection';\nimport { TagView } from './tag';\nimport type { TeleSuiteUpdaterTestModel } from '@testIsomorphic/teleSuiteUpdater';\n\nconst TestTreeView = TreeView<TreeItem>;\n\nexport const TestListView: React.FC<{\n  filterText: string,\n  testTree: TestTree,\n  testServerConnection: TestServerConnection | undefined,\n  testModel?: TeleSuiteUpdaterTestModel,\n  runTests: (mode: 'bounce-if-busy' | 'queue-if-busy', testIds: Set<string>) => void,\n  runningState?: { testIds: Set<string>, itemSelectedByUser?: boolean, completed?: boolean },\n  watchAll: boolean,\n  watchedTreeIds: { value: Set<string> },\n  setWatchedTreeIds: (ids: { value: Set<string> }) => void,\n  isLoading?: boolean,\n  onItemSelected: (item: { treeItem?: TreeItem, testCase?: reporterTypes.TestCase, testFile?: SourceLocation }) => void,\n  requestedCollapseAllCount: number,\n  requestedExpandAllCount: number,\n  setFilterText: (text: string) => void,\n  onRevealSource: () => void,\n}> = ({ filterText, testModel, testServerConnection, testTree, runTests, runningState, watchAll, watchedTreeIds, setWatchedTreeIds, isLoading, onItemSelected, requestedCollapseAllCount, requestedExpandAllCount, setFilterText, onRevealSource }) => {\n  const [treeState, setTreeState] = React.useState<TreeState>({ expandedItems: new Map() });\n  const [selectedTreeItemId, setSelectedTreeItemId] = React.useState<string | undefined>();\n  const [collapseAllCount, setCollapseAllCount] = React.useState(requestedCollapseAllCount);\n  const [expandAllCount, setExpandAllCount] = React.useState(requestedExpandAllCount);\n\n  // Look for a first failure within the run batch to select it.\n  React.useEffect(() => {\n    // If collapse was requested, clear the expanded items and return w/o selected item.\n    if (collapseAllCount !== requestedCollapseAllCount) {\n      treeState.expandedItems.clear();\n      for (const item of testTree.flatTreeItems())\n        treeState.expandedItems.set(item.id, false);\n      setCollapseAllCount(requestedCollapseAllCount);\n      setSelectedTreeItemId(undefined);\n      setTreeState({ ...treeState });\n      return;\n    }\n\n    if (expandAllCount !== requestedExpandAllCount) {\n      treeState.expandedItems.clear();\n      for (const item of testTree.flatTreeItems())\n        treeState.expandedItems.set(item.id, true);\n      setExpandAllCount(requestedExpandAllCount);\n      setSelectedTreeItemId(undefined);\n      setTreeState({ ...treeState });\n      return;\n    }\n\n    if (!runningState || runningState.itemSelectedByUser)\n      return;\n    let selectedTreeItem: TreeItem | undefined;\n    const visit = (treeItem: TreeItem) => {\n      treeItem.children.forEach(visit);\n      if (selectedTreeItem)\n        return;\n      if (treeItem.status === 'failed') {\n        if (treeItem.kind === 'test' && runningState.testIds.has(treeItem.test.id))\n          selectedTreeItem = treeItem;\n        else if (treeItem.kind === 'case' && runningState.testIds.has(treeItem.tests[0]?.id))\n          selectedTreeItem = treeItem;\n      }\n    };\n    visit(testTree.rootItem);\n\n    if (selectedTreeItem)\n      setSelectedTreeItemId(selectedTreeItem.id);\n  }, [runningState, setSelectedTreeItemId, testTree, collapseAllCount, setCollapseAllCount, requestedCollapseAllCount, expandAllCount, setExpandAllCount, requestedExpandAllCount, treeState, setTreeState]);\n\n  // Compute selected item\n  const selectedTreeItem = React.useMemo(() => {\n    if (!selectedTreeItemId)\n      return undefined;\n    return testTree.treeItemById(selectedTreeItemId);\n  }, [selectedTreeItemId, testTree]);\n\n  // Handle selection effects separately\n  React.useEffect(() => {\n    if (!testModel)\n      return;\n    const testFile = itemLocation(selectedTreeItem, testModel);\n    let selectedTest: reporterTypes.TestCase | undefined;\n    if (selectedTreeItem?.kind === 'test')\n      selectedTest = selectedTreeItem.test;\n    else if (selectedTreeItem?.kind === 'case' && selectedTreeItem.tests.length === 1)\n      selectedTest = selectedTreeItem.tests[0];\n    onItemSelected({ treeItem: selectedTreeItem, testCase: selectedTest, testFile });\n  }, [testModel, selectedTreeItem, onItemSelected]);\n\n  // Update watch all.\n  React.useEffect(() => {\n    if (isLoading)\n      return;\n    if (watchAll) {\n      testServerConnection?.watchNoReply({ fileNames: testTree.fileNames() });\n    } else {\n      const fileNames = new Set<string>();\n      for (const itemId of watchedTreeIds.value) {\n        const treeItem = testTree.treeItemById(itemId);\n        const fileName = treeItem?.location.file;\n        if (fileName)\n          fileNames.add(fileName);\n      }\n      testServerConnection?.watchNoReply({ fileNames: [...fileNames] });\n    }\n  }, [isLoading, testTree, watchAll, watchedTreeIds, testServerConnection]);\n\n  const runTreeItem = (treeItem: TreeItem) => {\n    setSelectedTreeItemId(treeItem.id);\n    runTests('bounce-if-busy', testTree.collectTestIds(treeItem));\n  };\n\n  const handleTagClick = (e: React.MouseEvent, tag: string) => {\n    e.preventDefault();\n    e.stopPropagation();\n    if (e.metaKey || e.ctrlKey) {\n      const parts = filterText.split(' ');\n      if (parts.includes(tag))\n        setFilterText(parts.filter(t => t !== tag).join(' ').trim());\n      else\n        setFilterText((filterText + ' ' + tag).trim());\n    } else {\n      // Replace all existing tags with this tag.\n      setFilterText((filterText.split(' ').filter(t => !t.startsWith('@')).join(' ') + ' ' + tag).trim());\n    }\n  };\n\n  return <TestTreeView\n    name='tests'\n    treeState={treeState}\n    setTreeState={setTreeState}\n    rootItem={testTree.rootItem}\n    dataTestId='test-tree'\n    render={treeItem => {\n      const prefixId = treeItem.id.replace(/[^\\w\\d-_]/g, '-');\n      const labelId = prefixId + '-label';\n      const timeId = prefixId + '-time';\n      return <div className='hbox ui-mode-tree-item' aria-labelledby={`${labelId} ${timeId}`}>\n        <div id={labelId} className='ui-mode-tree-item-title'>\n          <span>{treeItem.title}</span>\n          {treeItem.kind === 'case' ? treeItem.tags.map(tag => <TagView key={tag} tag={tag.slice(1)} onClick={e => handleTagClick(e, tag)} />) : null}\n        </div>\n        {!!treeItem.duration && treeItem.status !== 'skipped' && <div id={timeId} className='ui-mode-tree-item-time'>{msToString(treeItem.duration)}</div>}\n        <Toolbar noMinHeight={true} noShadow={true}>\n          <ToolbarButton icon='play' title='Run' onClick={() => runTreeItem(treeItem)} disabled={!!runningState && !runningState.completed}></ToolbarButton>\n          <ToolbarButton icon='go-to-file' title='Show source' onClick={onRevealSource} style={(treeItem.kind === 'group' && treeItem.subKind === 'folder') ? { visibility: 'hidden' } : {}}></ToolbarButton>\n          {!watchAll && <ToolbarButton icon='eye' title='Watch' onClick={() => {\n            if (watchedTreeIds.value.has(treeItem.id))\n              watchedTreeIds.value.delete(treeItem.id);\n            else\n              watchedTreeIds.value.add(treeItem.id);\n            setWatchedTreeIds({ ...watchedTreeIds });\n          }} toggled={watchedTreeIds.value.has(treeItem.id)}></ToolbarButton>}\n        </Toolbar>\n      </div>;\n    }}\n    icon={treeItem => testStatusIcon(treeItem.status)}\n    title={treeItem => treeItem.title}\n    selectedItem={selectedTreeItem}\n    onAccepted={runTreeItem}\n    onSelected={treeItem => {\n      if (runningState)\n        runningState.itemSelectedByUser = true;\n      setSelectedTreeItemId(treeItem.id);\n    }}\n    isError={treeItem => treeItem.kind === 'group' ? treeItem.hasLoadErrors : false}\n    autoExpandDepth={filterText ? 5 : 1}\n    noItemsMessage={isLoading ? 'Loading\\u2026' : 'No tests'} />;\n};\n\nfunction itemLocation(item: TreeItem | undefined, model: TeleSuiteUpdaterTestModel | undefined): SourceLocation | undefined {\n  if (!item || !model)\n    return;\n  return {\n    file: item.location.file,\n    line: item.location.line,\n    column: item.location.column,\n    source: {\n      errors: model.loadErrors.filter(e => e.location?.file === item.location.file).map(e => ({ line: e.location!.line, message: e.message! })),\n      content: undefined,\n    }\n  };\n}\n","/**\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 function artifactsFolderName(workerIndex: number) {\n  return `.playwright-artifacts-${workerIndex}`;\n}\n","/**\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 { artifactsFolderName } from '@testIsomorphic/folders';\nimport type { TreeItem } from '@testIsomorphic/testTree';\nimport '@web/common.css';\nimport '@web/third_party/vscode/codicon.css';\nimport type * as reporterTypes from 'playwright/types/testReporter';\nimport React from 'react';\nimport type { ContextEntry } from '../types/entries';\nimport type { SourceLocation } from './modelUtil';\nimport { MultiTraceModel } from './modelUtil';\nimport { Workbench } from './workbench';\n\nexport const TraceView: React.FC<{\n  item: { treeItem?: TreeItem, testFile?: SourceLocation, testCase?: reporterTypes.TestCase },\n  rootDir?: string,\n  onOpenExternally?: (location: SourceLocation) => void,\n  revealSource?: boolean,\n  pathSeparator: string,\n}> = ({ item, rootDir, onOpenExternally, revealSource, pathSeparator }) => {\n  const [model, setModel] = React.useState<{ model: MultiTraceModel, isLive: boolean } | undefined>(undefined);\n  const [counter, setCounter] = React.useState(0);\n  const pollTimer = React.useRef<NodeJS.Timeout | null>(null);\n\n  const { outputDir } = React.useMemo(() => {\n    const outputDir = item.testCase ? outputDirForTestCase(item.testCase) : undefined;\n    return { outputDir };\n  }, [item]);\n\n  React.useEffect(() => {\n    if (pollTimer.current)\n      clearTimeout(pollTimer.current);\n\n    const result = item.testCase?.results[0];\n    if (!result) {\n      setModel(undefined);\n      return;\n    }\n\n    // Test finished.\n    const attachment = result && result.duration >= 0 && result.attachments.find(a => a.name === 'trace');\n    if (attachment && attachment.path) {\n      loadSingleTraceFile(attachment.path).then(model => setModel({ model, isLive: false }));\n      return;\n    }\n\n    if (!outputDir) {\n      setModel(undefined);\n      return;\n    }\n\n    const traceLocation = [\n      outputDir,\n      artifactsFolderName(result!.workerIndex),\n      'traces',\n      `${item.testCase?.id}.json`\n    ].join(pathSeparator);\n    // Start polling running test.\n    pollTimer.current = setTimeout(async () => {\n      try {\n        const model = await loadSingleTraceFile(traceLocation);\n        setModel({ model, isLive: true });\n      } catch {\n        const model = new MultiTraceModel('', []);\n        model.errorDescriptors.push(...result.errors.flatMap(error => !!error.message ? [{ message: error.message }] : []));\n        setModel({ model, isLive: false });\n      } finally {\n        setCounter(counter + 1);\n      }\n    }, 500);\n    return () => {\n      if (pollTimer.current)\n        clearTimeout(pollTimer.current);\n    };\n  }, [outputDir, item, setModel, counter, setCounter, pathSeparator]);\n\n  return <Workbench\n    model={model?.model}\n    key='workbench'\n    showSourcesFirst={true}\n    rootDir={rootDir}\n    fallbackLocation={item.testFile}\n    isLive={model?.isLive}\n    status={item.treeItem?.status}\n    annotations={item.testCase?.annotations ?? []}\n    onOpenExternally={onOpenExternally}\n    revealSource={revealSource}\n  />;\n};\n\nconst outputDirForTestCase = (testCase: reporterTypes.TestCase): string | undefined => {\n  for (let suite: reporterTypes.Suite | undefined = testCase.parent; suite; suite = suite.parent) {\n    if (suite.project())\n      return suite.project()?.outputDir;\n  }\n  return undefined;\n};\n\nasync function loadSingleTraceFile(url: string): Promise<MultiTraceModel> {\n  const params = new URLSearchParams();\n  params.set('trace', url);\n  const response = await fetch(`contexts?${params.toString()}`);\n  const contextEntries = await response.json() as ContextEntry[];\n  return new MultiTraceModel(url, contextEntries);\n}\n","/**\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 '@web/third_party/vscode/codicon.css';\nimport '@web/common.css';\nimport React from 'react';\nimport { TeleSuite } from '@testIsomorphic/teleReceiver';\nimport { TeleSuiteUpdater, type TeleSuiteUpdaterProgress, type TeleSuiteUpdaterTestModel } from '@testIsomorphic/teleSuiteUpdater';\nimport type { TeleTestCase } from '@testIsomorphic/teleReceiver';\nimport type * as reporterTypes from 'playwright/types/testReporter';\nimport { SplitView } from '@web/components/splitView';\nimport type { SourceLocation } from './modelUtil';\nimport './uiModeView.css';\nimport { ToolbarButton } from '@web/components/toolbarButton';\nimport { Toolbar } from '@web/components/toolbar';\nimport type { XtermDataSource } from '@web/components/xtermWrapper';\nimport { XtermWrapper } from '@web/components/xtermWrapper';\nimport { clsx, settings, useSetting } from '@web/uiUtils';\nimport { statusEx, TestTree } from '@testIsomorphic/testTree';\nimport type { TreeItem  } from '@testIsomorphic/testTree';\nimport { TestServerConnection, WebSocketTestServerTransport } from '@testIsomorphic/testServerConnection';\nimport { FiltersView } from './uiModeFiltersView';\nimport { TestListView } from './uiModeTestListView';\nimport { TraceView } from './uiModeTraceView';\nimport { SettingsView } from './settingsView';\nimport { DefaultSettingsView } from './defaultSettingsView';\n\nlet xtermSize = { cols: 80, rows: 24 };\nconst xtermDataSource: XtermDataSource = {\n  pending: [],\n  clear: () => {},\n  write: data => xtermDataSource.pending.push(data),\n  resize: () => {},\n};\n\nconst searchParams = new URLSearchParams(window.location.search);\nconst testServerBaseUrl = new URL(searchParams.get('server') ?? '../', window.location.href);\nconst wsURL = new URL(searchParams.get('ws')!, testServerBaseUrl);\nwsURL.protocol = (wsURL.protocol === 'https:' ? 'wss:' : 'ws:');\nconst queryParams = {\n  args: searchParams.getAll('arg'),\n  grep: searchParams.get('grep') || undefined,\n  grepInvert: searchParams.get('grepInvert') || undefined,\n  projects: searchParams.getAll('project'),\n  workers: searchParams.get('workers') || undefined,\n  headed: searchParams.has('headed'),\n  updateSnapshots: (searchParams.get('updateSnapshots') as reporterTypes.FullConfig['updateSnapshots'] | undefined) || undefined,\n  reporters: searchParams.has('reporter') ? searchParams.getAll('reporter') : undefined,\n  pathSeparator: searchParams.get('pathSeparator') || '/',\n};\nif (queryParams.updateSnapshots && !['all', 'changed', 'none', 'missing'].includes(queryParams.updateSnapshots))\n  queryParams.updateSnapshots = undefined;\n\nconst isMac = navigator.platform === 'MacIntel';\n\nexport const UIModeView: React.FC<{}> = ({\n}) => {\n  const [filterText, setFilterText] = React.useState<string>('');\n  const [isShowingOutput, setIsShowingOutput] = React.useState<boolean>(false);\n  const [outputContainsError, setOutputContainsError] = React.useState(false);\n  const [statusFilters, setStatusFilters] = React.useState<Map<string, boolean>>(new Map([\n    ['passed', false],\n    ['failed', false],\n    ['skipped', false],\n  ]));\n  const [projectFilters, setProjectFilters] = React.useState<Map<string, boolean>>(new Map());\n  const [testModel, setTestModel] = React.useState<TeleSuiteUpdaterTestModel>();\n  const [progress, setProgress] = React.useState<TeleSuiteUpdaterProgress & { total: number } | undefined>();\n  const [selectedItem, setSelectedItem] = React.useState<{ treeItem?: TreeItem, testFile?: SourceLocation, testCase?: reporterTypes.TestCase }>({});\n  const [visibleTestIds, setVisibleTestIds] = React.useState<Set<string>>(new Set());\n  const [isLoading, setIsLoading] = React.useState<boolean>(false);\n  const [runningState, setRunningState] = React.useState<{ testIds: Set<string>, itemSelectedByUser?: boolean, completed?: boolean } | undefined>();\n  const isRunningTest = runningState && !runningState.completed;\n\n  const [watchAll, setWatchAll] = useSetting<boolean>('watch-all', false);\n  const [watchedTreeIds, setWatchedTreeIds] = React.useState<{ value: Set<string> }>({ value: new Set() });\n  const commandQueue = React.useRef(Promise.resolve());\n  const runTestBacklog = React.useRef<Set<string>>(new Set());\n  const [collapseAllCount, setCollapseAllCount] = React.useState(0);\n  const [expandAllCount, setExpandAllCount] = React.useState(0);\n  const [isDisconnected, setIsDisconnected] = React.useState(false);\n  const [hasBrowsers, setHasBrowsers] = React.useState(true);\n  const [testServerConnection, setTestServerConnection] = React.useState<TestServerConnection>();\n  const [teleSuiteUpdater, setTeleSuiteUpdater] = React.useState<TeleSuiteUpdater>();\n  const [settingsVisible, setSettingsVisible] = React.useState(false);\n  const [testingOptionsVisible, setTestingOptionsVisible] = React.useState(false);\n  const [revealSource, setRevealSource] = React.useState(false);\n  const onRevealSource = React.useCallback(() => setRevealSource(true), [setRevealSource]);\n\n  const [singleWorker, setSingleWorker] = useSetting<boolean>('single-worker', false);\n  const [updateSnapshots, setUpdateSnapshots] = useSetting<reporterTypes.FullConfig['updateSnapshots']>('updateSnapshots', 'missing');\n  const [mergeFiles] = useSetting('mergeFiles', false);\n\n  const inputRef = React.useRef<HTMLInputElement>(null);\n\n  const reloadTests = React.useCallback(() => {\n    setTestServerConnection(prevConnection => {\n      prevConnection?.close();\n      return new TestServerConnection(new WebSocketTestServerTransport(wsURL));\n    });\n  }, []);\n\n  // Load tests on startup.\n  React.useEffect(() => {\n    inputRef.current?.focus();\n    setIsLoading(true);\n    reloadTests();\n  }, [reloadTests]);\n\n  // Wire server connection to the auxiliary UI features.\n  React.useEffect(() => {\n    if (!testServerConnection)\n      return;\n    const disposables = [\n      testServerConnection.onStdio(params => {\n        if (params.buffer) {\n          const data = atob(params.buffer);\n          xtermDataSource.write(data);\n        } else {\n          xtermDataSource.write(params.text!);\n        }\n\n        if (params.type === 'stderr')\n          setOutputContainsError(true);\n      }),\n      testServerConnection.onClose(() => setIsDisconnected(true))\n    ];\n    xtermDataSource.resize = (cols, rows) => {\n      xtermSize = { cols, rows };\n      testServerConnection.resizeTerminalNoReply({ cols, rows });\n    };\n    return () => {\n      for (const disposable of disposables)\n        disposable.dispose();\n    };\n  }, [testServerConnection]);\n\n  // This is the main routine, every time connection updates it starts the\n  // whole workflow.\n  React.useEffect(() => {\n    if (!testServerConnection)\n      return;\n\n    let throttleTimer: NodeJS.Timeout | undefined;\n    const teleSuiteUpdater = new TeleSuiteUpdater({\n      onUpdate: immediate => {\n        clearTimeout(throttleTimer);\n        throttleTimer = undefined;\n        if (immediate) {\n          setTestModel(teleSuiteUpdater.asModel());\n        } else if (!throttleTimer) {\n          throttleTimer = setTimeout(() => {\n            setTestModel(teleSuiteUpdater.asModel());\n          }, 250);\n        }\n      },\n      onError: error => {\n        xtermDataSource.write((error.stack || error.value || '') + '\\n');\n        setOutputContainsError(true);\n      },\n      pathSeparator: queryParams.pathSeparator,\n    });\n\n    setTeleSuiteUpdater(teleSuiteUpdater);\n\n    setTestModel(undefined);\n    setIsLoading(true);\n    setWatchedTreeIds({ value: new Set() });\n    (async () => {\n      try {\n        await testServerConnection.initialize({\n          interceptStdio: true,\n          watchTestDirs: true\n        });\n        const { status, report } = await testServerConnection.runGlobalSetup({});\n        teleSuiteUpdater.processGlobalReport(report);\n        if (status !== 'passed')\n          return;\n\n        const result = await testServerConnection.listTests({ projects: queryParams.projects, locations: queryParams.args, grep: queryParams.grep, grepInvert: queryParams.grepInvert });\n        teleSuiteUpdater.processListReport(result.report);\n\n        testServerConnection.onReport(params => {\n          teleSuiteUpdater.processTestReportEvent(params);\n        });\n\n        const { hasBrowsers } = await testServerConnection.checkBrowsers({});\n        setHasBrowsers(hasBrowsers);\n      } finally {\n        setIsLoading(false);\n      }\n    })();\n    return () => {\n      clearTimeout(throttleTimer);\n    };\n  }, [testServerConnection]);\n\n  // Update project filter default values.\n  React.useEffect(() => {\n    if (!testModel)\n      return;\n\n    const { config, rootSuite } = testModel;\n    const selectedProjects = config.configFile ? settings.getObject<string[] | undefined>(config.configFile + ':projects', undefined) : undefined;\n    const newFilter = new Map(projectFilters);\n    for (const projectName of newFilter.keys()) {\n      if (!rootSuite.suites.find(s => s.title === projectName))\n        newFilter.delete(projectName);\n    }\n    for (const projectSuite of rootSuite.suites) {\n      if (!newFilter.has(projectSuite.title))\n        newFilter.set(projectSuite.title, !!selectedProjects?.includes(projectSuite.title));\n    }\n    if (!selectedProjects && newFilter.size && ![...newFilter.values()].includes(true))\n      newFilter.set(newFilter.entries().next().value![0], true);\n    if (projectFilters.size !== newFilter.size || [...projectFilters].some(([k, v]) => newFilter.get(k) !== v))\n      setProjectFilters(newFilter);\n  }, [projectFilters, testModel]);\n\n  // Update progress.\n  React.useEffect(() => {\n    if (isRunningTest && testModel?.progress)\n      setProgress(testModel.progress);\n    else if (!testModel)\n      setProgress(undefined);\n  }, [testModel, isRunningTest]);\n\n  // Test tree is built from the model and filters.\n  const { testTree } = React.useMemo(() => {\n    if (!testModel)\n      return { testTree: new TestTree('', new TeleSuite('', 'root'), [], projectFilters, queryParams.pathSeparator, mergeFiles) };\n    const testTree = new TestTree('', testModel.rootSuite, testModel.loadErrors, projectFilters, queryParams.pathSeparator, mergeFiles);\n    testTree.filterTree(filterText, statusFilters, isRunningTest ? runningState?.testIds : undefined);\n    testTree.sortAndPropagateStatus();\n    testTree.shortenRoot();\n    testTree.flattenForSingleProject();\n    setVisibleTestIds(testTree.testIds());\n    return { testTree };\n  }, [filterText, testModel, statusFilters, projectFilters, setVisibleTestIds, runningState, isRunningTest, mergeFiles]);\n\n  const runTests = React.useCallback((mode: 'queue-if-busy' | 'bounce-if-busy', testIds: Set<string>) => {\n    if (!testServerConnection || !testModel)\n      return;\n    if (mode === 'bounce-if-busy' && isRunningTest)\n      return;\n\n    runTestBacklog.current = new Set([...runTestBacklog.current, ...testIds]);\n    commandQueue.current = commandQueue.current.then(async () => {\n      const testIds = runTestBacklog.current;\n      runTestBacklog.current = new Set();\n      if (!testIds.size)\n        return;\n\n      // Clear test results.\n      {\n        for (const test of testModel.rootSuite?.allTests() || []) {\n          if (testIds.has(test.id)) {\n            test.results = [];\n            const result = (test as TeleTestCase)._createTestResult('pending');\n            (result as any)[statusEx] = 'scheduled';\n          }\n        }\n        setTestModel({ ...testModel });\n      }\n\n      const time = '  [' + new Date().toLocaleTimeString() + ']';\n      xtermDataSource.write('\\x1B[2m—'.repeat(Math.max(0, xtermSize.cols - time.length)) + time + '\\x1B[22m');\n      setProgress({ total: 0, passed: 0, failed: 0, skipped: 0 });\n      setRunningState({ testIds });\n\n      await testServerConnection.runTests({\n        locations: queryParams.args,\n        grep: queryParams.grep,\n        grepInvert: queryParams.grepInvert,\n        testIds: [...testIds],\n        projects: [...projectFilters].filter(([_, v]) => v).map(([p]) => p),\n        updateSnapshots,\n        reporters: queryParams.reporters,\n        workers: singleWorker ? 1 : undefined,\n        trace: 'on',\n      });\n      // Clear pending tests in case of interrupt.\n      for (const test of testModel.rootSuite?.allTests() || []) {\n        if (test.results[0]?.duration === -1)\n          test.results = [];\n      }\n      setTestModel({ ...testModel });\n      setRunningState(oldState => oldState ? ({ ...oldState, completed: true }) : undefined);\n    });\n  }, [projectFilters, isRunningTest, testModel, testServerConnection, updateSnapshots, singleWorker]);\n\n  React.useEffect(() => {\n    if (!testServerConnection || !teleSuiteUpdater)\n      return;\n    const disposable = testServerConnection.onTestFilesChanged(async params => {\n      // fetch the new list of tests\n      commandQueue.current = commandQueue.current.then(async () => {\n        setIsLoading(true);\n        try {\n          const result = await testServerConnection.listTests({ projects: queryParams.projects, locations: queryParams.args, grep: queryParams.grep, grepInvert: queryParams.grepInvert });\n          teleSuiteUpdater.processListReport(result.report);\n        } catch (e) {\n          // eslint-disable-next-line no-console\n          console.log(e);\n        } finally {\n          setIsLoading(false);\n        }\n      });\n      await commandQueue.current;\n\n      if (params.testFiles.length === 0)\n        return;\n\n      // run affected watched tests\n      const testModel = teleSuiteUpdater.asModel();\n      const testTree = new TestTree('', testModel.rootSuite, testModel.loadErrors, projectFilters, queryParams.pathSeparator, mergeFiles);\n\n      const testIds: string[] = [];\n      const set = new Set(params.testFiles);\n      if (watchAll) {\n        const visit = (treeItem: TreeItem) => {\n          const fileName = treeItem.location.file;\n          if (fileName && set.has(fileName))\n            testIds.push(...testTree.collectTestIds(treeItem));\n          if (treeItem.kind === 'group' && treeItem.subKind === 'folder')\n            treeItem.children.forEach(visit);\n        };\n        visit(testTree.rootItem);\n      } else {\n        for (const treeId of watchedTreeIds.value) {\n          const treeItem = testTree.treeItemById(treeId);\n          const fileName = treeItem?.location.file;\n          if (fileName && set.has(fileName))\n            testIds.push(...testTree.collectTestIds(treeItem));\n        }\n      }\n      runTests('queue-if-busy', new Set(testIds));\n    });\n    return () => disposable.dispose();\n  }, [runTests, testServerConnection, watchAll, watchedTreeIds, teleSuiteUpdater, projectFilters, mergeFiles]);\n\n  // Shortcuts.\n  React.useEffect(() => {\n    if (!testServerConnection)\n      return;\n    const onShortcutEvent = (e: KeyboardEvent) => {\n      if (e.code === 'Backquote' && e.ctrlKey) {\n        e.preventDefault();\n        setIsShowingOutput(!isShowingOutput);\n      } else if (e.code === 'F5' && e.shiftKey) {\n        e.preventDefault();\n        testServerConnection?.stopTestsNoReply({});\n      } else if (e.code === 'F5') {\n        e.preventDefault();\n        runTests('bounce-if-busy', visibleTestIds);\n      }\n    };\n    addEventListener('keydown', onShortcutEvent);\n    return () => {\n      removeEventListener('keydown', onShortcutEvent);\n    };\n  }, [runTests, reloadTests, testServerConnection, visibleTestIds, isShowingOutput]);\n\n  const dialogRef = React.useRef<HTMLDialogElement>(null);\n  const openInstallDialog = React.useCallback((e: React.MouseEvent) => {\n    e.preventDefault();\n    e.stopPropagation();\n    dialogRef.current?.showModal();\n  }, []);\n  const closeInstallDialog = React.useCallback((e: React.MouseEvent) => {\n    e.preventDefault();\n    e.stopPropagation();\n    dialogRef.current?.close();\n  }, []);\n  const installBrowsers = React.useCallback((e: React.MouseEvent) => {\n    closeInstallDialog(e);\n    setIsShowingOutput(true);\n    testServerConnection?.installBrowsers({}).then(async () => {\n      setIsShowingOutput(false);\n      const { hasBrowsers } = await testServerConnection?.checkBrowsers({});\n      setHasBrowsers(hasBrowsers);\n    });\n  }, [closeInstallDialog, testServerConnection]);\n\n  return <div className='vbox ui-mode'>\n    {!hasBrowsers && <dialog ref={dialogRef}>\n      <div className='title'><span className='codicon codicon-lightbulb'></span>Install browsers</div>\n      <div className='body'>\n        Playwright did not find installed browsers.\n        <br></br>\n        Would you like to run `playwright install`?\n        <br></br>\n        <button className='button' onClick={installBrowsers}>Install</button>\n        <button className='button secondary' onClick={closeInstallDialog}>Dismiss</button>\n      </div>\n    </dialog>}\n    {isDisconnected && <div className='disconnected'>\n      <div className='title'>UI Mode disconnected</div>\n      <div><a href='#' onClick={() => window.location.href = '/'}>Reload the page</a> to reconnect</div>\n    </div>}\n    <SplitView\n      sidebarSize={250}\n      minSidebarSize={150}\n      orientation='horizontal'\n      sidebarIsFirst={true}\n      settingName='testListSidebar'\n      main={<div className='vbox'>\n        <div className={clsx('vbox', !isShowingOutput && 'hidden')}>\n          <Toolbar>\n            <div className='section-title' style={{ flex: 'none' }}>Output</div>\n            <ToolbarButton icon='circle-slash' title='Clear output' onClick={() => { xtermDataSource.clear(); setOutputContainsError(false); }}></ToolbarButton>\n            <div className='spacer'></div>\n            <ToolbarButton icon='close' title='Close' onClick={() => setIsShowingOutput(false)}></ToolbarButton>\n          </Toolbar>\n          <XtermWrapper source={xtermDataSource}></XtermWrapper>\n        </div>\n        <div className={clsx('vbox', isShowingOutput && 'hidden')}>\n          <TraceView\n            pathSeparator={queryParams.pathSeparator}\n            item={selectedItem}\n            rootDir={testModel?.config?.rootDir}\n            revealSource={revealSource}\n            onOpenExternally={location => testServerConnection?.openNoReply({ location: { file: location.file, line: location.line, column: location.column } })}\n          />\n        </div>\n      </div>}\n      sidebar={<div className='vbox ui-mode-sidebar'>\n        <Toolbar noShadow={true} noMinHeight={true}>\n          <img src='playwright-logo.svg' alt='Playwright logo' />\n          <div className='section-title'>Playwright</div>\n          <ToolbarButton icon='refresh' title='Reload' onClick={() => reloadTests()} disabled={isRunningTest || isLoading}></ToolbarButton>\n          <div style={{ position: 'relative' }}>\n            <ToolbarButton icon={'terminal'} title={'Toggle output — ' + (isMac ? '⌃`' : 'Ctrl + `')} toggled={isShowingOutput} onClick={() => { setIsShowingOutput(!isShowingOutput); }} />\n            {outputContainsError && <div title='Output contains error' style={{ position: 'absolute', top: 2, right: 2, width: 7, height: 7, borderRadius: '50%', backgroundColor: 'var(--vscode-notificationsErrorIcon-foreground)' }} />}\n          </div>\n          {!hasBrowsers && <ToolbarButton icon='lightbulb-autofix' style={{ color: 'var(--vscode-list-warningForeground)' }} title='Playwright browsers are missing' onClick={openInstallDialog} />}\n        </Toolbar>\n        <FiltersView\n          filterText={filterText}\n          setFilterText={setFilterText}\n          statusFilters={statusFilters}\n          setStatusFilters={setStatusFilters}\n          projectFilters={projectFilters}\n          setProjectFilters={setProjectFilters}\n          testModel={testModel}\n          runTests={() => runTests('bounce-if-busy', visibleTestIds)} />\n        <Toolbar className='section-toolbar' noMinHeight={true}>\n          {!isRunningTest && !progress && <div className='section-title'>Tests</div>}\n          {!isRunningTest && progress && <div data-testid='status-line' className='status-line'>\n            <div>{progress.passed}/{progress.total} passed ({(progress.passed / progress.total) * 100 | 0}%)</div>\n          </div>}\n          {isRunningTest && progress && <div data-testid='status-line' className='status-line'>\n            <div>Running {progress.passed}/{runningState.testIds.size} passed ({(progress.passed / runningState.testIds.size) * 100 | 0}%)</div>\n          </div>}\n          <ToolbarButton icon='play' title='Run all — F5' onClick={() => runTests('bounce-if-busy', visibleTestIds)} disabled={isRunningTest || isLoading}></ToolbarButton>\n          <ToolbarButton icon='debug-stop' title={'Stop — ' + (isMac ? '⇧F5' : 'Shift + F5')} onClick={() => testServerConnection?.stopTests({})} disabled={!isRunningTest || isLoading}></ToolbarButton>\n          <ToolbarButton icon='eye' title='Watch all' toggled={watchAll} onClick={() => {\n            setWatchedTreeIds({ value: new Set() });\n            setWatchAll(!watchAll);\n          }}></ToolbarButton>\n          <ToolbarButton icon='collapse-all' title='Collapse all' onClick={() => {\n            setCollapseAllCount(collapseAllCount + 1);\n          }} />\n          <ToolbarButton icon='expand-all' title='Expand all' onClick={() => {\n            setExpandAllCount(expandAllCount + 1);\n          }} />\n        </Toolbar>\n        <TestListView\n          filterText={filterText}\n          testModel={testModel}\n          testTree={testTree}\n          testServerConnection={testServerConnection}\n          runningState={runningState}\n          runTests={runTests}\n          onItemSelected={setSelectedItem}\n          watchAll={watchAll}\n          watchedTreeIds={watchedTreeIds}\n          setWatchedTreeIds={setWatchedTreeIds}\n          isLoading={isLoading}\n          requestedCollapseAllCount={collapseAllCount}\n          requestedExpandAllCount={expandAllCount}\n          setFilterText={setFilterText}\n          onRevealSource={onRevealSource}\n        />\n        <Toolbar noShadow={true} noMinHeight={true} className='settings-toolbar' onClick={() => setTestingOptionsVisible(!testingOptionsVisible)}>\n          <span\n            className={`codicon codicon-${testingOptionsVisible ? 'chevron-down' : 'chevron-right'}`}\n            style={{ marginLeft: 5 }}\n            title={testingOptionsVisible ? 'Hide Testing Options' : 'Show Testing Options'}\n          />\n          <div className='section-title'>Testing Options</div>\n        </Toolbar>\n        {testingOptionsVisible && <SettingsView settings={[\n          { type: 'check', value: singleWorker, set: setSingleWorker, name: 'Single worker' },\n          { type: 'select', options: [\n            { label: 'All', value: 'all' },\n            { label: 'Changed', value: 'changed' },\n            { label: 'Missing', value: 'missing' },\n            { label: 'None', value: 'none' },\n          ], value: updateSnapshots, set: setUpdateSnapshots as (value: string) => void, name: 'Update snapshots' },\n        ]} />}\n        <Toolbar noShadow={true} noMinHeight={true} className='settings-toolbar' onClick={() => setSettingsVisible(!settingsVisible)}>\n          <span\n            className={`codicon codicon-${settingsVisible ? 'chevron-down' : 'chevron-right'}`}\n            style={{ marginLeft: 5 }}\n            title={settingsVisible ? 'Hide Settings' : 'Show Settings'}\n          />\n          <div className='section-title'>Settings</div>\n        </Toolbar>\n        {settingsVisible && <DefaultSettingsView location='ui-mode' />}\n      </div>\n      }\n    />\n  </div>;\n};\n","/**\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 '@web/common.css';\nimport { applyTheme } from '@web/theme';\nimport '@web/third_party/vscode/codicon.css';\nimport * as ReactDOM from 'react-dom/client';\nimport { UIModeView } from './ui/uiModeView';\n\n(async () => {\n  applyTheme();\n  if (window.location.protocol !== 'file:') {\n    if (window.location.href.includes('isUnderTest=true'))\n      await new Promise(f => setTimeout(f, 1000));\n    if (!navigator.serviceWorker)\n      throw new Error(`Service workers are not supported.\\nMake sure to serve the website (${window.location}) via HTTPS or localhost.`);\n    navigator.serviceWorker.register('sw.bundle.js');\n    if (!navigator.serviceWorker.controller) {\n      await new Promise<void>(f => {\n        navigator.serviceWorker.oncontrollerchange = () => f();\n      });\n    }\n\n    // Keep SW running.\n    setInterval(function() { fetch('ping'); }, 10000);\n  }\n\n  ReactDOM.createRoot(document.querySelector('#root')!).render(<UIModeView/>);\n})();\n"],"file":"uiMode.Wi-DvIEY.js"}