chrome-devtools-frontend 1.0.968818 → 1.0.970391

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -4,6 +4,7 @@
 
 import * as Common from '../../core/common/common.js';
 import * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 import * as Workspace from '../workspace/workspace.js';
@@ -31,6 +32,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   private activeInternal: boolean;
   private enabled: boolean;
   private eventDescriptors: Common.EventTarget.EventDescriptor[];
+  #headerOverridesMap: Map<string, HeaderOverrideWithRegex[]> = new Map();
 
   private constructor(workspace: Workspace.Workspace.WorkspaceImpl) {
     super();
@@ -363,29 +365,97 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     }
   }
 
-  private updateInterceptionPatterns(): void {
-    void this.updateInterceptionThrottler.schedule(innerUpdateInterceptionPatterns.bind(this));
-
-    function innerUpdateInterceptionPatterns(this: NetworkPersistenceManager): Promise<void> {
-      if (!this.activeInternal || !this.projectInternal) {
-        return SDK.NetworkManager.MultitargetNetworkManager.instance().setInterceptionHandlerForPatterns(
-            [], this.interceptionHandlerBound);
+  async generateHeaderPatterns(uiSourceCode: Workspace.UISourceCode.UISourceCode):
+      Promise<{headerPatterns: Set<string>, path: string, overridesWithRegex: HeaderOverrideWithRegex[]}> {
+    const headerPatterns = new Set<string>();
+    const content = (await uiSourceCode.requestContent()).content || '';
+    let headerOverrides: HeaderOverride[] = [];
+    try {
+      headerOverrides = JSON.parse(content) as HeaderOverride[];
+      if (!headerOverrides.every(isHeaderOverride)) {
+        throw 'Type mismatch after parsing';
       }
-      const patterns = new Set<string>();
-      const indexFileName = 'index.html';
-      for (const uiSourceCode of this.projectInternal.uiSourceCodes()) {
-        const pattern = this.patternForFileSystemUISourceCode(uiSourceCode);
-        patterns.add(pattern);
-        if (pattern.endsWith('/' + indexFileName)) {
-          patterns.add(pattern.substr(0, pattern.length - indexFileName.length));
-        }
+    } catch (e) {
+      console.error('Failed to parse', uiSourceCode.url(), 'for locally overriding headers.');
+      return {headerPatterns, path: '', overridesWithRegex: []};
+    }
+    const relativePath = FileSystemWorkspaceBinding.relativePath(uiSourceCode).join('/');
+    const decodedPath = this.decodeLocalPathToUrlPath(relativePath).slice(0, -HEADERS_FILENAME.length);
+
+    const overridesWithRegex: HeaderOverrideWithRegex[] = [];
+    for (const headerOverride of headerOverrides) {
+      headerPatterns.add('http?://' + decodedPath + headerOverride.applyTo);
+
+      // Most servers have the concept of a "directory index", which is a
+      // default resource name for a request targeting a "directory", e. g.
+      // requesting "example.com/path/" would result in the same response as
+      // requesting "example.com/path/index.html". To match this behavior we
+      // generate an additional pattern without "index.html" as the longer
+      // pattern would not match against a shorter request.
+      const {head, tail} = extractDirectoryIndex(headerOverride.applyTo);
+      if (tail) {
+        headerPatterns.add('http?://' + decodedPath + head);
+
+        const pattern = escapeRegex(decodedPath + head) + '(' + escapeRegex(tail) + ')?';
+        const regex = new RegExp('^https?:\/\/' + pattern + '$');
+        overridesWithRegex.push({
+          applyToRegex: regex,
+          headers: headerOverride.headers,
+        });
+      } else {
+        const regex = new RegExp('^https?:\/\/' + escapeRegex(decodedPath + headerOverride.applyTo) + '$');
+        overridesWithRegex.push({
+          applyToRegex: regex,
+          headers: headerOverride.headers,
+        });
       }
+    }
+    return {headerPatterns, path: decodedPath, overridesWithRegex};
+  }
+
+  async updateInterceptionPatternsForTests(): Promise<void> {
+    await this.#innerUpdateInterceptionPatterns();
+  }
+
+  private updateInterceptionPatterns(): void {
+    void this.updateInterceptionThrottler.schedule(this.#innerUpdateInterceptionPatterns.bind(this));
+  }
 
+  async #innerUpdateInterceptionPatterns(): Promise<void> {
+    this.#headerOverridesMap.clear();
+    if (!this.activeInternal || !this.projectInternal) {
       return SDK.NetworkManager.MultitargetNetworkManager.instance().setInterceptionHandlerForPatterns(
-          Array.from(patterns).map(
-              pattern => ({urlPattern: pattern, requestStage: Protocol.Fetch.RequestStage.Response})),
-          this.interceptionHandlerBound);
+          [], this.interceptionHandlerBound);
+    }
+    let patterns = new Set<string>();
+    for (const uiSourceCode of this.projectInternal.uiSourceCodes()) {
+      const pattern = this.patternForFileSystemUISourceCode(uiSourceCode);
+      if (Root.Runtime.experiments.isEnabled(Root.Runtime.ExperimentName.HEADER_OVERRIDES) &&
+          uiSourceCode.name() === HEADERS_FILENAME) {
+        const {headerPatterns, path, overridesWithRegex} = await this.generateHeaderPatterns(uiSourceCode);
+        if (headerPatterns.size > 0) {
+          patterns = new Set([...patterns, ...headerPatterns]);
+          this.#headerOverridesMap.set(path, overridesWithRegex);
+        }
+      } else {
+        patterns.add(pattern);
+      }
+      // Most servers have the concept of a "directory index", which is a
+      // default resource name for a request targeting a "directory", e. g.
+      // requesting "example.com/path/" would result in the same response as
+      // requesting "example.com/path/index.html". To match this behavior we
+      // generate an additional pattern without "index.html" as the longer
+      // pattern would not match against a shorter request.
+      const {head, tail} = extractDirectoryIndex(pattern);
+      if (tail) {
+        patterns.add(head);
+      }
     }
+
+    return SDK.NetworkManager.MultitargetNetworkManager.instance().setInterceptionHandlerForPatterns(
+        Array.from(patterns).map(
+            pattern => ({urlPattern: pattern, requestStage: Protocol.Fetch.RequestStage.Response})),
+        this.interceptionHandlerBound);
   }
 
   private async onUISourceCodeRemoved(uiSourceCode: Workspace.UISourceCode.UISourceCode): Promise<void> {
@@ -409,7 +479,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     await this.unbind(uiSourceCode);
   }
 
-  private async setProject(project: Workspace.Workspace.Project|null): Promise<void> {
+  async setProject(project: Workspace.Workspace.Project|null): Promise<void> {
     if (project === this.projectInternal) {
       return;
     }
@@ -452,6 +522,49 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     }
   }
 
+  mergeHeaders(baseHeaders: Protocol.Fetch.HeaderEntry[], overrideHeaders: Protocol.Network.Headers):
+      Protocol.Fetch.HeaderEntry[] {
+    const result: Protocol.Fetch.HeaderEntry[] = [];
+    const headerMap = new Map<string, string>();
+    for (const header of baseHeaders) {
+      headerMap.set(header.name, header.value);
+    }
+    for (const [headerName, headerValue] of Object.entries(overrideHeaders)) {
+      headerMap.set(headerName, headerValue);
+    }
+    headerMap.forEach((headerValue, headerName) => {
+      result.push({name: headerName, value: headerValue});
+    });
+    return result;
+  }
+
+  #maybeMergeHeadersForPathSegment(path: string, requestUrl: string, headers: Protocol.Fetch.HeaderEntry[]):
+      Protocol.Fetch.HeaderEntry[] {
+    const headerOverrides = this.#headerOverridesMap.get(path) || [];
+    for (const headerOverride of headerOverrides) {
+      if (headerOverride.applyToRegex.test(requestUrl)) {
+        headers = this.mergeHeaders(headers, headerOverride.headers);
+      }
+    }
+    return headers;
+  }
+
+  handleHeaderInterception(interceptedRequest: SDK.NetworkManager.InterceptedRequest): Protocol.Fetch.HeaderEntry[] {
+    let result: Protocol.Fetch.HeaderEntry[] = interceptedRequest.responseHeaders || [];
+    const urlSegments = this.encodedPathFromUrl(interceptedRequest.request.url).split('/');
+    // Traverse the hierarchy of overrides from the most general to the most
+    // specific. Check with empty string first to match overrides applying to
+    // all domains.
+    // e.g. '', 'www.example.com/', 'www.example.com/path/', ...
+    let path = '';
+    result = this.#maybeMergeHeadersForPathSegment(path, interceptedRequest.request.url, result);
+    for (const segment of urlSegments) {
+      path += segment + '/';
+      result = this.#maybeMergeHeadersForPathSegment(path, interceptedRequest.request.url, result);
+    }
+    return result;
+  }
+
   private async interceptionHandler(interceptedRequest: SDK.NetworkManager.InterceptedRequest): Promise<void> {
     const method = interceptedRequest.request.method;
     if (!this.activeInternal || (method !== 'GET' && method !== 'POST')) {
@@ -460,9 +573,16 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     const proj = this.projectInternal as FileSystem;
     const path = proj.fileSystemPath() + '/' + this.encodedPathFromUrl(interceptedRequest.request.url);
     const fileSystemUISourceCode = proj.uiSourceCodeForURL(path);
-    if (!fileSystemUISourceCode) {
+    let responseHeaders: Protocol.Fetch.HeaderEntry[] = [];
+    if (Root.Runtime.experiments.isEnabled(Root.Runtime.ExperimentName.HEADER_OVERRIDES)) {
+      responseHeaders = this.handleHeaderInterception(interceptedRequest);
+    }
+    if (!fileSystemUISourceCode && !responseHeaders.length) {
       return;
     }
+    if (!responseHeaders.length) {
+      responseHeaders = interceptedRequest.responseHeaders || [];
+    }
 
     let mimeType = '';
     if (interceptedRequest.responseHeaders) {
@@ -477,32 +597,41 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     if (!mimeType) {
       const expectedResourceType =
           Common.ResourceType.resourceTypes[interceptedRequest.resourceType] || Common.ResourceType.resourceTypes.Other;
-      mimeType = fileSystemUISourceCode.mimeType();
+      mimeType = fileSystemUISourceCode?.mimeType() || '';
       if (Common.ResourceType.ResourceType.fromMimeType(mimeType) !== expectedResourceType) {
         mimeType = expectedResourceType.canonicalMimeType();
       }
     }
-    const project = fileSystemUISourceCode.project() as FileSystem;
-
-    this.originalResponseContentPromises.set(
-        fileSystemUISourceCode, interceptedRequest.responseBody().then(response => {
-          if (response.error || response.content === null) {
-            return null;
-          }
-          if (response.encoded) {
-            const text = atob(response.content);
-            const data = new Uint8Array(text.length);
-            for (let i = 0; i < text.length; ++i) {
-              data[i] = text.charCodeAt(i);
-            }
-            return new TextDecoder('utf-8').decode(data);
-          }
-          return response.content;
-        }));
 
-    const blob = await project.requestFileBlob(fileSystemUISourceCode);
-    if (blob) {
-      void interceptedRequest.continueRequestWithContent(new Blob([blob], {type: mimeType}));
+    if (fileSystemUISourceCode) {
+      this.originalResponseContentPromises.set(
+          fileSystemUISourceCode, interceptedRequest.responseBody().then(response => {
+            if (response.error || response.content === null) {
+              return null;
+            }
+            if (response.encoded) {
+              const text = atob(response.content);
+              const data = new Uint8Array(text.length);
+              for (let i = 0; i < text.length; ++i) {
+                data[i] = text.charCodeAt(i);
+              }
+              return new TextDecoder('utf-8').decode(data);
+            }
+            return response.content;
+          }));
+
+      const project = fileSystemUISourceCode.project() as FileSystem;
+      const blob = await project.requestFileBlob(fileSystemUISourceCode);
+      if (blob) {
+        void interceptedRequest.continueRequestWithContent(
+            new Blob([blob], {type: mimeType}), /* encoded */ false, responseHeaders);
+      }
+    } else {
+      const responseBody = await interceptedRequest.responseBody();
+      if (!responseBody.error && responseBody.content) {
+        void interceptedRequest.continueRequestWithContent(
+            new Blob([responseBody.content], {type: mimeType}), /* encoded */ true, responseHeaders);
+      }
     }
   }
 }
@@ -512,6 +641,8 @@ const RESERVED_FILENAMES = new Set<string>([
   'com8', 'com9', 'lpt1', 'lpt2', 'lpt3', 'lpt4', 'lpt5', 'lpt6', 'lpt7', 'lpt8', 'lpt9',
 ]);
 
+const HEADERS_FILENAME = '.headers';
+
 // TODO(crbug.com/1167717): Make this a const enum again
 // eslint-disable-next-line rulesdir/const_enum
 export enum Events {
@@ -521,3 +652,36 @@ export enum Events {
 export type EventTypes = {
   [Events.ProjectChanged]: Workspace.Workspace.Project|null,
 };
+
+interface HeaderOverride {
+  applyTo: string;
+  headers: Protocol.Network.Headers;
+}
+
+interface HeaderOverrideWithRegex {
+  applyToRegex: RegExp;
+  headers: Protocol.Network.Headers;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isHeaderOverride(arg: any): arg is HeaderOverride {
+  if (!(arg && arg.applyTo && typeof (arg.applyTo === 'string') && arg.headers && Object.keys(arg.headers).length)) {
+    return false;
+  }
+  return Object.values(arg.headers).every(value => typeof value === 'string');
+}
+
+export function escapeRegex(pattern: string): string {
+  return Platform.StringUtilities.escapeCharacters(pattern, '[]{}()\\.^$+|-,?').replaceAll('*', '.*');
+}
+
+export function extractDirectoryIndex(pattern: string): {head: string, tail?: string} {
+  const lastSlash = pattern.lastIndexOf('/');
+  const tail = lastSlash >= 0 ? pattern.slice(lastSlash + 1) : pattern;
+  const head = lastSlash >= 0 ? pattern.slice(0, lastSlash + 1) : '';
+  const regex = new RegExp('^' + escapeRegex(tail) + '$');
+  if (regex.test('index.html') || regex.test('index.htm') || regex.test('index.php')) {
+    return {head, tail};
+  }
+  return {head: pattern};
+}

package/front_end/models/timeline_model/TimelineFrameModel.ts

@@ -138,10 +138,10 @@ export class TimelineFrameModel {
     }
     this.lastBeginFrame = startTime;
 
-    this.beginFrameQueue.addFrameIfNotExists(seqId, startTime, false);
+    this.beginFrameQueue.addFrameIfNotExists(seqId, startTime, false, false);
   }
 
-  handleDroppedFrame(startTime: number, seqId: number): void {
+  handleDroppedFrame(startTime: number, seqId: number, isPartial: boolean): void {
     if (!this.lastFrame) {
       this.startFrame(startTime);
     }
@@ -149,8 +149,9 @@ export class TimelineFrameModel {
     // This line handles the case where no BeginFrame event is issued for
     // the dropped frame. In this situation, add a BeginFrame to the queue
     // as if it actually occurred.
-    this.beginFrameQueue.addFrameIfNotExists(seqId, startTime, true);
+    this.beginFrameQueue.addFrameIfNotExists(seqId, startTime, true, isPartial);
     this.beginFrameQueue.setDropped(seqId, true);
+    this.beginFrameQueue.setPartial(seqId, isPartial);
   }
 
   handleDrawFrame(startTime: number, seqId: number): void {
@@ -187,6 +188,9 @@ export class TimelineFrameModel {
         if (frame.isDropped) {
           this.lastFrame.dropped = true;
         }
+        if (frame.isPartial) {
+          this.lastFrame.isPartial = true;
+        }
       }
     }
     this.mainFrameCommitted = false;
@@ -318,7 +322,7 @@ export class TimelineFrameModel {
     } else if (event.name === RecordType.NeedsBeginFrameChanged) {
       this.handleNeedFrameChanged(timestamp, event.args['data'] && event.args['data']['needsBeginFrame']);
     } else if (event.name === RecordType.DroppedFrame) {
-      this.handleDroppedFrame(timestamp, event.args['frameSeqId']);
+      this.handleDroppedFrame(timestamp, event.args['frameSeqId'], event.args['hasPartialUpdate']);
     }
   }
 
@@ -426,6 +430,7 @@ export class TimelineFrame {
   cpuTime: number;
   idle: boolean;
   dropped: boolean;
+  isPartial: boolean;
   layerTree: TracingFrameLayerTree|null;
   paints: LayerPaintEvent[];
   mainFrameId: number|undefined;
@@ -439,6 +444,7 @@ export class TimelineFrame {
     this.cpuTime = 0;
     this.idle = false;
     this.dropped = false;
+    this.isPartial = false;
     this.layerTree = null;
     this.paints = [];
     this.mainFrameId = undefined;
@@ -545,10 +551,12 @@ class BeginFrameInfo {
   seqId: number;
   startTime: number;
   isDropped: boolean;
-  constructor(seqId: number, startTime: number, isDropped: boolean) {
+  isPartial: boolean;
+  constructor(seqId: number, startTime: number, isDropped: boolean, isPartial: boolean) {
     this.seqId = seqId;
     this.startTime = startTime;
     this.isDropped = isDropped;
+    this.isPartial = isPartial;
   }
 }
 
@@ -570,9 +578,9 @@ export class TimelineFrameBeginFrameQueue {
   }
 
   // Add a BeginFrame to the queue, if it does not already exit.
-  addFrameIfNotExists(seqId: number, startTime: number, isDropped: boolean): void {
+  addFrameIfNotExists(seqId: number, startTime: number, isDropped: boolean, isPartial: boolean): void {
     if (!(seqId in this.mapFrames)) {
-      this.mapFrames[seqId] = new BeginFrameInfo(seqId, startTime, isDropped);
+      this.mapFrames[seqId] = new BeginFrameInfo(seqId, startTime, isDropped, isPartial);
       this.queueFrames.push(seqId);
     }
   }
@@ -584,6 +592,12 @@ export class TimelineFrameBeginFrameQueue {
     }
   }
 
+  setPartial(seqId: number, isPartial: boolean): void {
+    if (seqId in this.mapFrames) {
+      this.mapFrames[seqId].isPartial = isPartial;
+    }
+  }
+
   processPendingBeginFramesOnDrawFrame(seqId: number): BeginFrameInfo[] {
     const framesToVisualize: BeginFrameInfo[] = [];
 

package/front_end/panels/animation/animationTimeline.css

@@ -338,7 +338,6 @@ text.animation-timeline-grid-label {
   background: var(--color-background-elevation-2);
   opacity: 0%;
   border-right: 1px solid var(--color-details-hairline);
-  cursor: pointer;
 }
 
 .animation-buffer-preview:focus-visible {
@@ -410,7 +409,6 @@ text.animation-timeline-grid-label {
   background-color: transparent;
   flex: 1 0 auto;
   text-align: center;
-  cursor: pointer;
 }
 
 .animation-playback-rate-button:first-child {
@@ -454,7 +452,6 @@ text.animation-timeline-grid-label {
   box-shadow: 0 1px 4px 0 var(--color-background-highlight);
   z-index: 100;
   display: none;
-  cursor: pointer;
   font-weight: 700;
   color: var(--color-background);
 }

package/front_end/panels/application/components/ReportsGrid.ts

@@ -19,6 +19,21 @@ const UIStrings = {
   *(https://developers.google.com/web/updates/2018/09/reportingapi#sending)
   */
   noReportsToDisplay: 'No reports to display',
+  /**
+  *@description Column header for a table displaying Reporting API reports.
+  *Status is one of 'Queued', 'Pending', 'MarkedForRemoval' or 'Success'.
+  */
+  status: 'Status',
+  /**
+  *@description Column header for a table displaying Reporting API reports.
+  *Destination is the name of the endpoint the report is being sent to.
+  */
+  destination: 'Destination',
+  /**
+  *@description Column header for a table displaying Reporting API reports.
+  *The column contains the timestamp of when a report was generated.
+  */
+  generatedAt: 'Generated at',
 };
 const str_ = i18n.i18n.registerUIStrings('panels/application/components/ReportsGrid.ts', UIStrings);
 export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
@@ -38,7 +53,7 @@ export class ReportsGridStatusHeader extends HTMLElement {
     // Disabled until https://crbug.com/1079231 is fixed.
     // clang-format off
     render(html`
-      ${i18n.i18n.lockedString('Status')}
+      ${i18nString(UIStrings.status)}
       <x-link href="https://web.dev/reporting-api/#report-status">
         <${IconButton.Icon.Icon.litTagName} class="inline-icon" .data=${{
           iconName: 'help_outline',
@@ -93,7 +108,7 @@ export class ReportsGrid extends HTMLElement {
         },
         {
           id: 'status',
-          title: i18n.i18n.lockedString('Status'),
+          title: i18nString(UIStrings.status),
           widthWeighting: 20,
           hideable: false,
           visible: true,
@@ -103,14 +118,14 @@ export class ReportsGrid extends HTMLElement {
         },
         {
           id: 'destination',
-          title: i18n.i18n.lockedString('Destination'),
+          title: i18nString(UIStrings.destination),
           widthWeighting: 20,
           hideable: false,
           visible: true,
         },
         {
           id: 'timestamp',
-          title: i18n.i18n.lockedString('Timestamp'),
+          title: i18nString(UIStrings.generatedAt),
           widthWeighting: 20,
           hideable: false,
           visible: true,

package/front_end/panels/application/components/trustTokensViewDeleteButton.css

@@ -12,7 +12,6 @@
   border: none;
   padding: 0;
   outline: none;
-  cursor: pointer;
 }
 
 .delete-button:hover devtools-icon {

package/front_end/panels/console/consolePinPane.css

@@ -71,23 +71,6 @@
   overflow: hidden;
 }
 
-.console-delete-pin {
-  position: absolute;
-  top: 8px;
-  left: 8px;
-  opacity: 70%;
-  cursor: pointer;
-}
-
-.console-delete-pin:hover,
-.console-delete-pin:focus-visible {
-  opacity: 100%;
-}
-
-:host-context(.-theme-with-dark-background) .console-delete-pin {
-  filter: brightness(2);
-}
-
 .console-pin-name:focus-within {
   background: var(--color-background);
   box-shadow: var(--legacy-focus-ring-active-shadow) inset;

package/front_end/panels/css_overview/cssOverviewCompletedView.css

@@ -85,7 +85,6 @@
   height: 25px;
   border-radius: 3px;
   margin-right: 16px;
-  cursor: pointer;
 }
 
 .block-title {

package/front_end/panels/elements/components/adornerSettingsPane.css

@@ -39,7 +39,6 @@
   border: none;
   border-radius: 50%;
   background-color: var(--color-background-elevation-1);
-  cursor: pointer;
 }
 
 .close::before,

package/front_end/panels/elements/components/computedStyleTrace.css

@@ -16,7 +16,7 @@
 
 .computed-style-trace:hover {
   background-color: var(--legacy-focus-bg-color);
-  cursor: pointer;
+  cursor: text;
 }
 
 .goto {

package/front_end/panels/elements/components/elementsBreadcrumbs.css

@@ -73,7 +73,6 @@
 .overflow:not(:disabled):hover {
   background-color: var(--color-background-elevation-2);
   color: var(--color-text-primary);
-  cursor: pointer;
 }
 
 .crumb-link {

package/front_end/panels/elements/computedStyleWidgetTree.css

@@ -15,7 +15,7 @@
 
 .tree-outline li:hover {
   background-color: var(--legacy-focus-bg-color);
-  cursor: pointer;
+  cursor: text;
 }
 
 .tree-outline li::before {
@@ -35,7 +35,7 @@
   margin: 1px 0 0;
   padding: 1em 0;
   width: 100%;
-  cursor: pointer;
+  cursor: text;
   color: var(--color-text-secondary);
   font-size: 11px;
   font-weight: 400;

package/front_end/panels/elements/elementsTreeOutline.css

@@ -203,7 +203,6 @@ select {
   border-radius: 5px;
   border: 1px solid var(--issue-color-yellow);
   background-color: var(--issue-color-yellow);
-  cursor: pointer;
 }
 
 .elements-gutter-decoration.elements-has-decorated-children {
@@ -278,7 +277,6 @@ select {
   position: absolute;
   top: 0;
   left: 0;
-  cursor: pointer;
   width: 15px;
   height: 15px;
 }

package/front_end/panels/emulation/deviceModeView.css

@@ -90,7 +90,6 @@
   pointer-events: auto;
   text-align: center;
   flex: none;
-  cursor: pointer;
   color: var(--color-text-primary);
   display: flex;
   align-items: center;

package/front_end/panels/event_listeners/eventListenersView.css

@@ -56,7 +56,6 @@
   border: 1px solid var(--color-details-hairline);
   margin-left: 5px;
   display: block;
-  cursor: pointer;
   opacity: 80%;
   flex-shrink: 0;
 }

package/front_end/panels/issues/components/hideIssuesMenu.css

@@ -14,7 +14,6 @@
   padding: 1px 4px;
   overflow: hidden;
   border-radius: 0;
-  cursor: pointer;
   border: none;
 
   --icon-color: var(--color-text-primary);