chrome-devtools-frontend 1.0.1679060 → 1.0.1681091

package/AUTHORS

@@ -24,6 +24,7 @@ Anna Agoha <annaagoha@gmail.com>
 Anthony Xie <anthonyxie64@gmail.com>
 Axel Chong <haxatron1@gmail.com>
 Anton Bershanskyi <bershanskyi@gmail.com>
+Ashish Shrees <flowoker1@gmail.com>
 Aviv Keller <me@aviv.sh>
 Biboswan Roy <biboswan98@gmail.com>
 Boris Verkhovskiy <boris.verk@gmail.com>

package/front_end/core/platform/TypescriptUtilities.ts

@@ -17,15 +17,6 @@ export function assertNever(_type: never, message: string): never {
   throw new Error(message);
 }
 
-/**
- * This is useful to check on the type-level that the unhandled cases of
- * a switch are exactly `T` (where T is usually a union type of enum values).
- * @param caseVariable
- */
-export function assertUnhandled<T>(_caseVariable: T): T {
-  return _caseVariable;
-}
-
 export type FieldsThatExtend<Type, Selector> = {
   [Key in keyof Type]: Type[Key] extends Selector ? Key : never;
 }[keyof Type];

package/front_end/core/platform/platform.ts

@@ -24,7 +24,7 @@ import * as UserVisibleError from './UserVisibleError.js';
  * `Platform.TypeScriptUtilities.assertNotNullOrUndefined` causes a compile
  * error).
  */
-export {assertNever, assertNotNullOrUndefined, assertUnhandled} from './TypescriptUtilities.js';
+export {assertNever, assertNotNullOrUndefined} from './TypescriptUtilities.js';
 export {
   ArrayUtilities,
   Brand,

package/front_end/core/root/Runtime.ts

@@ -544,6 +544,10 @@ interface DevToolsAriaLiveRecording {
   enabled: boolean;
 }
 
+interface DevToolsMobileSafeAreaEmulation {
+  enabled: boolean;
+}
+
 /**
  * The host configuration that we expect from the DevTools back-end.
  *
@@ -601,6 +605,7 @@ export type HostConfig = Platform.TypeScriptUtilities.RecursivePartial<{
   devToolsPlusButton: DevToolsPlusButton,
   devToolsAriaLiveRecording: DevToolsAriaLiveRecording,
   devToolsInstrumentationBreakpoints: DevToolsInstrumentationBreakpoints,
+  devToolsMobileSafeAreaEmulation: DevToolsMobileSafeAreaEmulation,
   extensionsOnChromeUrls: ExtensionsOnChromeUrls,
   devToolsComments: HostConfigDevToolsComments,
 }>;

package/front_end/core/sdk/CSSMetadata.ts

@@ -160,7 +160,7 @@ export class CSSMetadata {
                            if (partialValueKeywordsNoPresets.get(name)?.has(value)) {
                              return false;
                            }
-                           return CSS.supports(name, value);
+                           return true;
                          })
                          .sort(CSSMetadata.sortPrefixesAndCSSWideKeywordsToEnd);
       const presets = values.map(value => `${name}: ${value}`);
@@ -340,11 +340,6 @@ export class CSSMetadata {
     let keywords: (string[]|undefined) = propertyValues.get(propertyName) || propertyValues.get(unprefixedName);
     if (!keywords) {
       keywords = [];
-      for (const commonKeyword of CommonKeywords) {
-        if (CSS.supports(propertyName, commonKeyword)) {
-          keywords.push(commonKeyword);
-        }
-      }
       propertyValues.set(propertyName, keywords);
     }
     return keywords;

package/front_end/core/sdk/ConsoleModel.ts

@@ -34,7 +34,7 @@ import {
   RuntimeModel,
 } from './RuntimeModel.js';
 import {SDKModel} from './SDKModel.js';
-import {preserveConsoleLogSettingDescriptor} from './SDKSettings.js';
+import {consoleUserActivationEvalSettingDescriptor, preserveConsoleLogSettingDescriptor} from './SDKSettings.js';
 import {Capability, type Target, Type} from './Target.js';
 import type {TargetManager} from './TargetManager.js';
 
@@ -156,13 +156,16 @@ export class ConsoleModel extends SDKModel<EventTypes> {
           replMode: true,
           allowUnsafeEvalBlockedByCSP: false,
         },
-        this.target().targetManager().settings.moduleSetting('console-user-activation-eval').get(),
+        this.target().targetManager().settings.resolve(consoleUserActivationEvalSettingDescriptor).get(),
         /* awaitPromise */ false);
     Host.userMetrics.actionTaken(Host.UserMetrics.Action.ConsoleEvaluated);
     if ('error' in result) {
       return;
     }
-    await this.#console.showPromise();
+    try {
+      await this.#console.showPromise();
+    } catch {
+    }
     this.dispatchEventToListeners(
         Events.CommandEvaluated,
         {result: result.object, commandMessage: originatingMessage, exceptionDetails: result.exceptionDetails});

package/front_end/core/sdk/DOMModel.ts

@@ -140,6 +140,47 @@ export interface DOMNodeEventTypes {
   [DOMNodeEvents.CONTAINER_QUERY_OVERLAY_STATE_CHANGED]: {enabled: boolean};
 }
 
+export function cssEscape(value: string): string {
+  const length = value.length;
+  let index = -1;
+  let codeUnit: number;
+  let result = '';
+  const firstCodeUnit = value.charCodeAt(0);
+
+  if (length === 0) {
+    return '';
+  }
+
+  if (length === 1 && firstCodeUnit === 0x002D) {
+    return '\\' + value;
+  }
+
+  while (++index < length) {
+    codeUnit = value.charCodeAt(index);
+    if (codeUnit === 0x0000) {
+      result += '\uFFFD';
+      continue;
+    }
+
+    if ((codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit === 0x007F ||
+        (index === 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+        (index === 1 && codeUnit >= 0x0030 && codeUnit <= 0x0039 && firstCodeUnit === 0x002D)) {
+      result += '\\' + codeUnit.toString(16) + ' ';
+      continue;
+    }
+
+    if (codeUnit >= 0x0080 || codeUnit === 0x002D || codeUnit === 0x005F ||
+        (codeUnit >= 0x0030 && codeUnit <= 0x0039) || (codeUnit >= 0x0041 && codeUnit <= 0x005A) ||
+        (codeUnit >= 0x0061 && codeUnit <= 0x007A)) {
+      result += value.charAt(index);
+      continue;
+    }
+
+    result += '\\' + value.charAt(index);
+  }
+  return result;
+}
+
 export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventTypes> {
   #domModel: DOMModel;
   readonly #frameManager: FrameManager;
@@ -1025,6 +1066,102 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
         });
   }
 
+  duplicate(): void {
+    if (this.isInShadowTree()) {
+      return;
+    }
+
+    const parentNode = this.parentNode ? this.parentNode : this;
+    if (parentNode.nodeName() === '#document') {
+      return;
+    }
+
+    this.copyTo(parentNode, this.nextSibling);
+  }
+
+  /**
+   * Runs a script on the node's remote object that toggles a class name on
+   * the node and injects a stylesheet into the head of the node's document
+   * containing a rule to set "visibility: hidden" on the class and all it's
+   * ancestors.
+   */
+  async toggleHideElement(): Promise<void> {
+    let pseudoElementName = this.pseudoType() ? this.nodeName() : null;
+    if (pseudoElementName && this.pseudoIdentifier()) {
+      pseudoElementName += `(${this.pseudoIdentifier()})`;
+    }
+
+    let effectiveNode: DOMNode|null = this;
+    while (effectiveNode?.pseudoType()) {
+      if (effectiveNode !== this && effectiveNode.pseudoType() === 'column') {
+        // Ideally we would select the specific column pseudo element, but
+        // we don't have a way to do that at the moment.
+        pseudoElementName = '::column' + pseudoElementName;
+      }
+      effectiveNode = effectiveNode.parentNode;
+    }
+    if (!effectiveNode) {
+      return;
+    }
+
+    const hidden = this.marker('hidden-marker');
+    const object = await effectiveNode.resolveToObject('');
+
+    if (!object) {
+      return;
+    }
+
+    await object.callFunction((toggleClassAndInjectStyleRule as (this: Object, ...arg1: unknown[]) => void),
+                              [{value: pseudoElementName}, {value: !hidden}]);
+    object.release();
+    this.setMarker('hidden-marker', hidden ? null : true);
+
+    function toggleClassAndInjectStyleRule(this: Element, pseudoElementName: string|null, hidden: boolean): void {
+      const classNamePrefix = '__web-inspector-hide';
+      const classNameSuffix = '-shortcut__';
+      const styleTagId = '__web-inspector-hide-shortcut-style__';
+      const pseudoElementNameEscaped = pseudoElementName ? pseudoElementName.replace(/[\(\)\:]/g, '_') : '';
+      const className = classNamePrefix + pseudoElementNameEscaped + classNameSuffix;
+      this.classList.toggle(className, hidden);
+
+      let localRoot: Element|HTMLHeadElement = this;
+      while (localRoot.parentNode) {
+        localRoot = (localRoot.parentNode as Element);
+      }
+      if (localRoot.nodeType === Node.DOCUMENT_NODE) {
+        localRoot = document.head;
+      }
+
+      let style = localRoot.querySelector('style#' + styleTagId);
+      if (!style) {
+        const selectors = [];
+        selectors.push('.__web-inspector-hide-shortcut__');
+        selectors.push('.__web-inspector-hide-shortcut__ *');
+        const selector = selectors.join(', ');
+        const ruleBody = '    visibility: hidden !important;';
+        const rule = '\n' + selector + '\n{\n' + ruleBody + '\n}\n';
+
+        style = document.createElement('style');
+        style.id = styleTagId;
+        style.textContent = rule;
+
+        localRoot.appendChild(style);
+      }
+
+      // In addition to putting them on the element we want to hide, we will
+      // also add pseudo element classes to the style element to keep track of
+      // which pseudo elements we have style rules for.
+      if (pseudoElementName && !style.classList.contains(className)) {
+        style.classList.add(className);
+        style.textContent = `.${className}${pseudoElementName}, ${style.textContent}`;
+      }
+    }
+  }
+
+  isToggledToHidden(): boolean {
+    return Boolean(this.marker('hidden-marker'));
+  }
+
   isXMLNode(): boolean {
     return Boolean(this.#xmlVersion);
   }
@@ -1243,14 +1380,14 @@ export class DOMNode extends Common.ObjectWrapper.ObjectWrapper<DOMNodeEventType
     const classes = this.getAttribute('class');
 
     if (lowerCaseName === 'input' && type && !id && !classes) {
-      return lowerCaseName + '[type="' + CSS.escape(type) + '"]';
+      return lowerCaseName + '[type="' + cssEscape(type) + '"]';
     }
     if (id) {
-      return lowerCaseName + '#' + CSS.escape(id);
+      return lowerCaseName + '#' + cssEscape(id);
     }
     if (classes) {
       const classList = classes.trim().split(/\s+/g);
-      return (lowerCaseName === 'div' ? '' : lowerCaseName) + '.' + classList.map(cls => CSS.escape(cls)).join('.');
+      return (lowerCaseName === 'div' ? '' : lowerCaseName) + '.' + classList.map(cls => cssEscape(cls)).join('.');
     }
     if (this.pseudoIdentifier()) {
       return `${lowerCaseName}(${this.pseudoIdentifier()})`;
@@ -2384,6 +2521,9 @@ export class DOMNodeSnapshot extends DOMNode {
       _callback?: ((arg0: string|null, arg1: DOMNode|null) => void)|undefined): void {
   }
 
+  override duplicate(): void {
+  }
+
   override canInspectNode(): boolean {
     return false;
   }
@@ -2433,6 +2573,9 @@ export class DOMDocumentSnapshot extends DOMDocument {
       _callback?: ((arg0: string|null, arg1: DOMNode|null) => void)|undefined): void {
   }
 
+  override duplicate(): void {
+  }
+
   override canInspectNode(): boolean {
     return false;
   }

package/front_end/core/sdk/EmulationModel.ts

@@ -10,14 +10,25 @@ import type {MultitargetNetworkManager} from './NetworkManager.js';
 import {Events, OverlayModel} from './OverlayModel.js';
 import {SDKModel} from './SDKModel.js';
 import {
+  avifFormatDisabledSettingDescriptor,
   cpuPressureSettingDescriptor,
+  emulateAutoDarkModeSettingDescriptor,
+  emulatedCSSMediaFeatureColorGamutSettingDescriptor,
   emulatedCSSMediaFeatureForcedColorsSettingDescriptor,
   emulatedCSSMediaFeaturePrefersColorSchemeSettingDescriptor,
+  emulatedCSSMediaFeaturePrefersContrastSettingDescriptor,
+  emulatedCSSMediaFeaturePrefersReducedDataSettingDescriptor,
   emulatedCSSMediaFeaturePrefersReducedMotionSettingDescriptor,
+  emulatedCSSMediaFeaturePrefersReducedTransparencySettingDescriptor,
   emulatedCSSMediaSettingDescriptor,
+  emulatedOSTextScaleSettingDescriptor,
+  emulatedVisionDeficiencySettingDescriptor,
   idleDetectionSettingDescriptor,
   javaScriptDisabledSettingDescriptor,
+  jpegXlFormatDisabledSettingDescriptor,
+  localFontsDisabledSettingDescriptor,
   touchSettingDescriptor,
+  webpFormatDisabledSettingDescriptor,
 } from './SDKSettings.js';
 import {Capability, type Target} from './Target.js';
 
@@ -111,16 +122,16 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
     });
 
     const mediaTypeSetting = settings.resolve(emulatedCSSMediaSettingDescriptor);
-    const mediaFeatureColorGamutSetting = settings.moduleSetting<string>('emulated-css-media-feature-color-gamut');
+    const mediaFeatureColorGamutSetting = settings.resolve(emulatedCSSMediaFeatureColorGamutSettingDescriptor);
     const mediaFeaturePrefersColorSchemeSetting =
         settings.resolve(emulatedCSSMediaFeaturePrefersColorSchemeSettingDescriptor);
     const mediaFeatureForcedColorsSetting = settings.resolve(emulatedCSSMediaFeatureForcedColorsSettingDescriptor);
     const mediaFeaturePrefersContrastSetting =
-        settings.moduleSetting<string>('emulated-css-media-feature-prefers-contrast');
+        settings.resolve(emulatedCSSMediaFeaturePrefersContrastSettingDescriptor);
     const mediaFeaturePrefersReducedDataSetting =
-        settings.moduleSetting<string>('emulated-css-media-feature-prefers-reduced-data');
+        settings.resolve(emulatedCSSMediaFeaturePrefersReducedDataSettingDescriptor);
     const mediaFeaturePrefersReducedTransparencySetting =
-        settings.moduleSetting<string>('emulated-css-media-feature-prefers-reduced-transparency');
+        settings.resolve(emulatedCSSMediaFeaturePrefersReducedTransparencySettingDescriptor);
     const mediaFeaturePrefersReducedMotionSetting =
         settings.resolve(emulatedCSSMediaFeaturePrefersReducedMotionSettingDescriptor);
     // Note: this uses a different format than what the CDP API expects,
@@ -171,7 +182,7 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
     });
     void this.updateCssMedia();
 
-    const autoDarkModeSetting = settings.moduleSetting('emulate-auto-dark-mode');
+    const autoDarkModeSetting = settings.resolve(emulateAutoDarkModeSettingDescriptor);
     autoDarkModeSetting.addChangeListener(() => {
       const enabled = autoDarkModeSetting.get();
       mediaFeaturePrefersColorSchemeSetting.set(enabled ? 'dark' : '');
@@ -182,13 +193,13 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       void this.emulateAutoDarkMode(true);
     }
 
-    const visionDeficiencySetting = settings.moduleSetting('emulated-vision-deficiency');
+    const visionDeficiencySetting = settings.resolve(emulatedVisionDeficiencySettingDescriptor);
     visionDeficiencySetting.addChangeListener(() => this.emulateVisionDeficiency(visionDeficiencySetting.get()));
     if (visionDeficiencySetting.get()) {
       void this.emulateVisionDeficiency(visionDeficiencySetting.get());
     }
 
-    const osTextScaleSetting = settings.moduleSetting('emulated-os-text-scale');
+    const osTextScaleSetting = settings.resolve(emulatedOSTextScaleSettingDescriptor);
     osTextScaleSetting.addChangeListener(() => {
       void this.emulateOSTextScale(parseFloat(osTextScaleSetting.get()) || undefined);
     });
@@ -196,15 +207,15 @@ export class EmulationModel extends SDKModel<EmulationModelEventTypes> implement
       void this.emulateOSTextScale(parseFloat(osTextScaleSetting.get()) || undefined);
     }
 
-    const localFontsDisabledSetting = settings.moduleSetting('local-fonts-disabled');
+    const localFontsDisabledSetting = settings.resolve(localFontsDisabledSettingDescriptor);
     localFontsDisabledSetting.addChangeListener(() => this.setLocalFontsDisabled(localFontsDisabledSetting.get()));
     if (localFontsDisabledSetting.get()) {
       this.setLocalFontsDisabled(localFontsDisabledSetting.get());
     }
 
-    const avifFormatDisabledSetting = settings.moduleSetting('avif-format-disabled');
-    const jpegXlFormatDisabledSetting = settings.moduleSetting('jpeg-xl-format-disabled');
-    const webpFormatDisabledSetting = settings.moduleSetting('webp-format-disabled');
+    const avifFormatDisabledSetting = settings.resolve(avifFormatDisabledSettingDescriptor);
+    const jpegXlFormatDisabledSetting = settings.resolve(jpegXlFormatDisabledSettingDescriptor);
+    const webpFormatDisabledSetting = settings.resolve(webpFormatDisabledSettingDescriptor);
 
     const updateDisabledImageFormats = (): void => {
       const types = [];

package/front_end/core/sdk/NetworkManager.ts

@@ -26,6 +26,7 @@ import {
 } from './NetworkRequest.js';
 import {type ExecutionContext, RuntimeModel} from './RuntimeModel.js';
 import {SDKModel} from './SDKModel.js';
+import {cacheDisabledSettingDescriptor, requestBlockingEnabledSettingDescriptor} from './SDKSettings.js';
 import {Capability, type Target} from './Target.js';
 import {type SDKModelObserver, TargetManager} from './TargetManager.js';
 
@@ -187,7 +188,7 @@ export class NetworkManager extends SDKModel<EventTypes> {
     const settings = this.target().targetManager().settings;
     this.activeNetworkThrottlingKey = activeNetworkThrottlingKeySetting(settings);
 
-    if (settings.moduleSetting('cache-disabled').get()) {
+    if (settings.resolve(cacheDisabledSettingDescriptor).get()) {
       void this.#networkAgent.invoke_setCacheDisabled({cacheDisabled: true});
     }
 
@@ -211,7 +212,7 @@ export class NetworkManager extends SDKModel<EventTypes> {
     }
     this.#bypassServiceWorkerSetting.addChangeListener(this.bypassServiceWorkerChanged, this);
 
-    settings.moduleSetting('cache-disabled').addChangeListener(this.cacheDisabledSettingChanged, this);
+    settings.resolve(cacheDisabledSettingDescriptor).addChangeListener(this.cacheDisabledSettingChanged, this);
   }
 
   static forRequest(request: NetworkRequest): NetworkManager|null {
@@ -555,7 +556,7 @@ export class NetworkManager extends SDKModel<EventTypes> {
 
   override dispose(): void {
     const settings = this.target().targetManager().settings;
-    settings.moduleSetting('cache-disabled').removeChangeListener(this.cacheDisabledSettingChanged, this);
+    settings.resolve(cacheDisabledSettingDescriptor).removeChangeListener(this.cacheDisabledSettingChanged, this);
     settings.moduleSetting('network-log.preserve-log').removeChangeListener(this.preserveLogChanged, this);
   }
 
@@ -1992,7 +1993,7 @@ export class RequestConditions extends Common.ObjectWrapper.ObjectWrapper<Reques
   constructor(settings: Common.Settings.Settings) {
     super();
     this.#setting = settings.createSetting<RequestConditionsSetting[]>('network-blocked-patterns', []);
-    this.#conditionsEnabledSetting = settings.moduleSetting<boolean>('request-blocking-enabled');
+    this.#conditionsEnabledSetting = settings.resolve(requestBlockingEnabledSettingDescriptor);
     for (const condition of this.#setting.get()) {
       try {
         this.#conditions.push(RequestCondition.createFromSetting(condition, settings));
@@ -2433,8 +2434,8 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
 
   private async updateInterceptionPatterns(): Promise<void> {
     const settings = this.#targetManager.settings;
-    if (!settings.moduleSetting('cache-disabled').get()) {
-      settings.moduleSetting('cache-disabled').set(true);
+    if (!settings.resolve(cacheDisabledSettingDescriptor).get()) {
+      settings.resolve(cacheDisabledSettingDescriptor).set(true);
     }
     this.#updatingInterceptionPatternsPromise = null;
     const promises = ([] as Array<Promise<unknown>>);

package/front_end/core/sdk/PageResourceLoader.ts

@@ -17,6 +17,7 @@ import {
   type ResourceTreeFrame,
   ResourceTreeModel,
 } from './ResourceTreeModel.js';
+import {cacheDisabledSettingDescriptor, enableRemoteFileLoadingSettingDescriptor} from './SDKSettings.js';
 import type {Target} from './Target.js';
 import {TargetManager} from './TargetManager.js';
 
@@ -433,7 +434,7 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
   }> {
     const networkManager = (target.model(NetworkManager) as NetworkManager);
     const ioModel = (target.model(IOModel) as IOModel);
-    const disableCache = this.#settings.moduleSetting('cache-disabled').get();
+    const disableCache = this.#settings.resolve(cacheDisabledSettingDescriptor).get();
     const resource = await networkManager.loadNetworkResource(frameId, url, {disableCache, includeCredentials: true});
     try {
       const content = resource.stream ?
@@ -470,11 +471,11 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
       headers['User-Agent'] = currentUserAgent;
     }
 
-    if (this.#settings.moduleSetting('cache-disabled').get()) {
+    if (this.#settings.resolve(cacheDisabledSettingDescriptor).get()) {
       headers['Cache-Control'] = 'no-cache';
     }
 
-    const allowRemoteFilePaths = this.#settings.moduleSetting('network.enable-remote-file-loading').get();
+    const allowRemoteFilePaths = this.#settings.resolve(enableRemoteFileLoadingSettingDescriptor).get();
 
     return await new Promise(
         resolve => Host.ResourceLoader.load(url, headers, (success, _responseHeaders, content, errorDescription) => {

package/front_end/core/sdk/RuntimeModel.ts

@@ -19,6 +19,7 @@ import {
   ScopeRemoteObject,
 } from './RemoteObject.js';
 import {SDKModel} from './SDKModel.js';
+import {customFormattersSettingDescriptor} from './SDKSettings.js';
 import {Capability, type Target, Type} from './Target.js';
 
 export class RuntimeModel extends SDKModel<EventTypes> {
@@ -32,12 +33,13 @@ export class RuntimeModel extends SDKModel<EventTypes> {
     this.target().registerRuntimeDispatcher(new RuntimeDispatcher(this));
     void this.agent.invoke_enable();
 
-    const settings = this.target().targetManager().context.get(Common.Settings.Settings);
-    if (settings.moduleSetting('custom-formatters').get()) {
+    const customFormattersSetting =
+        this.target().targetManager().context.get(Common.Settings.Settings).resolve(customFormattersSettingDescriptor);
+    if (customFormattersSetting.get()) {
       void this.agent.invoke_setCustomObjectFormatterEnabled({enabled: true});
     }
 
-    settings.moduleSetting('custom-formatters').addChangeListener(this.customFormattersStateChanged.bind(this));
+    customFormattersSetting.addChangeListener(this.customFormattersStateChanged.bind(this));
   }
 
   static isSideEffectFailure(response: Protocol.Runtime.EvaluateResponse|EvaluationResult): boolean {

package/front_end/core/sdk/SDKSettings.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import type * as Protocol from '../../generated/protocol.js';
 import * as Common from '../common/common.js';
 
 export const jsSourceMapsEnabledSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
@@ -199,3 +200,115 @@ export const emulatedCSSMediaFeaturePrefersReducedMotionSettingDescriptor: Commo
   defaultValue: '',
   storageType: Common.Settings.SettingStorageType.SESSION,
 };
+
+export const emulatedCSSMediaFeaturePrefersContrastSettingDescriptor: Common.Settings.SettingDescriptor<string> = {
+  name: 'emulated-css-media-feature-prefers-contrast',
+  type: Common.Settings.SettingType.ENUM,
+  defaultValue: '',
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const emulatedCSSMediaFeaturePrefersReducedDataSettingDescriptor: Common.Settings.SettingDescriptor<string> = {
+  name: 'emulated-css-media-feature-prefers-reduced-data',
+  type: Common.Settings.SettingType.ENUM,
+  defaultValue: '',
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const emulatedCSSMediaFeaturePrefersReducedTransparencySettingDescriptor:
+    Common.Settings.SettingDescriptor<string> = {
+  name: 'emulated-css-media-feature-prefers-reduced-transparency',
+  type: Common.Settings.SettingType.ENUM,
+  defaultValue: '',
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const emulatedCSSMediaFeatureColorGamutSettingDescriptor: Common.Settings.SettingDescriptor<string> = {
+  name: 'emulated-css-media-feature-color-gamut',
+  type: Common.Settings.SettingType.ENUM,
+  defaultValue: '',
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const emulatedVisionDeficiencySettingDescriptor:
+    Common.Settings.SettingDescriptor<Protocol.Emulation.SetEmulatedVisionDeficiencyRequestType> = {
+  name: 'emulated-vision-deficiency',
+  type: Common.Settings.SettingType.ENUM,
+  defaultValue: 'none' as Protocol.Emulation.SetEmulatedVisionDeficiencyRequestType,
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const emulatedOSTextScaleSettingDescriptor: Common.Settings.SettingDescriptor<string> = {
+  name: 'emulated-os-text-scale',
+  type: Common.Settings.SettingType.ENUM,
+  defaultValue: '',
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const localFontsDisabledSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'local-fonts-disabled',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const avifFormatDisabledSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'avif-format-disabled',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const jpegXlFormatDisabledSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'jpeg-xl-format-disabled',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const webpFormatDisabledSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'webp-format-disabled',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const customFormattersSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'custom-formatters',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+};
+
+export const requestBlockingEnabledSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'request-blocking-enabled',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+  storageType: Common.Settings.SettingStorageType.LOCAL,
+};
+
+export const cacheDisabledSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'cache-disabled',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+};
+
+export const emulateAutoDarkModeSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'emulate-auto-dark-mode',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+  storageType: Common.Settings.SettingStorageType.SESSION,
+};
+
+export const enableRemoteFileLoadingSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'network.enable-remote-file-loading',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: false,
+  storageType: Common.Settings.SettingStorageType.SYNCED,
+};
+
+export const consoleUserActivationEvalSettingDescriptor: Common.Settings.SettingDescriptor<boolean> = {
+  name: 'console-user-activation-eval',
+  type: Common.Settings.SettingType.BOOLEAN,
+  defaultValue: true,
+  storageType: Common.Settings.SettingStorageType.SYNCED,
+};