@mcp-b/chrome-devtools-mcp 1.1.0 → 1.1.1

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/AttributionReportingIssue.js

@@ -0,0 +1,201 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { Issue } from './Issue.js';
+function getIssueCode(details) {
+    switch (details.violationType) {
+        case "PermissionPolicyDisabled" /* Protocol.Audits.AttributionReportingIssueType.PermissionPolicyDisabled */:
+            return "AttributionReportingIssue::PermissionPolicyDisabled" /* IssueCode.PERMISSION_POLICY_DISABLED */;
+        case "UntrustworthyReportingOrigin" /* Protocol.Audits.AttributionReportingIssueType.UntrustworthyReportingOrigin */:
+            return "AttributionReportingIssue::UntrustworthyReportingOrigin" /* IssueCode.UNTRUSTWORTHY_REPORTING_ORIGIN */;
+        case "InsecureContext" /* Protocol.Audits.AttributionReportingIssueType.InsecureContext */:
+            return "AttributionReportingIssue::InsecureContext" /* IssueCode.INSECURE_CONTEXT */;
+        case "InvalidHeader" /* Protocol.Audits.AttributionReportingIssueType.InvalidHeader */:
+            return "AttributionReportingIssue::InvalidRegisterSourceHeader" /* IssueCode.INVALID_REGISTER_SOURCE_HEADER */;
+        case "InvalidRegisterTriggerHeader" /* Protocol.Audits.AttributionReportingIssueType.InvalidRegisterTriggerHeader */:
+            return "AttributionReportingIssue::InvalidRegisterTriggerHeader" /* IssueCode.INVALID_REGISTER_TRIGGER_HEADER */;
+        case "SourceAndTriggerHeaders" /* Protocol.Audits.AttributionReportingIssueType.SourceAndTriggerHeaders */:
+            return "AttributionReportingIssue::SourceAndTriggerHeaders" /* IssueCode.SOURCE_AND_TRIGGER_HEADERS */;
+        case "SourceIgnored" /* Protocol.Audits.AttributionReportingIssueType.SourceIgnored */:
+            return "AttributionReportingIssue::SourceIgnored" /* IssueCode.SOURCE_IGNORED */;
+        case "TriggerIgnored" /* Protocol.Audits.AttributionReportingIssueType.TriggerIgnored */:
+            return "AttributionReportingIssue::TriggerIgnored" /* IssueCode.TRIGGER_IGNORED */;
+        case "OsSourceIgnored" /* Protocol.Audits.AttributionReportingIssueType.OsSourceIgnored */:
+            return "AttributionReportingIssue::OsSourceIgnored" /* IssueCode.OS_SOURCE_IGNORED */;
+        case "OsTriggerIgnored" /* Protocol.Audits.AttributionReportingIssueType.OsTriggerIgnored */:
+            return "AttributionReportingIssue::OsTriggerIgnored" /* IssueCode.OS_TRIGGER_IGNORED */;
+        case "InvalidRegisterOsSourceHeader" /* Protocol.Audits.AttributionReportingIssueType.InvalidRegisterOsSourceHeader */:
+            return "AttributionReportingIssue::InvalidRegisterOsSourceHeader" /* IssueCode.INVALID_REGISTER_OS_SOURCE_HEADER */;
+        case "InvalidRegisterOsTriggerHeader" /* Protocol.Audits.AttributionReportingIssueType.InvalidRegisterOsTriggerHeader */:
+            return "AttributionReportingIssue::InvalidRegisterOsTriggerHeader" /* IssueCode.INVALID_REGISTER_OS_TRIGGER_HEADER */;
+        case "WebAndOsHeaders" /* Protocol.Audits.AttributionReportingIssueType.WebAndOsHeaders */:
+            return "AttributionReportingIssue::WebAndOsHeaders" /* IssueCode.WEB_AND_OS_HEADERS */;
+        case "NoWebOrOsSupport" /* Protocol.Audits.AttributionReportingIssueType.NoWebOrOsSupport */:
+            return "AttributionReportingIssue::NoWebOrOsSupport" /* IssueCode.NO_WEB_OR_OS_SUPPORT */;
+        case "NavigationRegistrationWithoutTransientUserActivation" /* Protocol.Audits.AttributionReportingIssueType.NavigationRegistrationWithoutTransientUserActivation */:
+            return "AttributionReportingIssue::NavigationRegistrationWithoutTransientUserActivation" /* IssueCode.NAVIGATION_REGISTRATION_WITHOUT_TRANSIENT_USER_ACTIVATION */;
+        case "InvalidInfoHeader" /* Protocol.Audits.AttributionReportingIssueType.InvalidInfoHeader */:
+            return "AttributionReportingIssue::InvalidInfoHeader" /* IssueCode.INVALID_INFO_HEADER */;
+        case "NoRegisterSourceHeader" /* Protocol.Audits.AttributionReportingIssueType.NoRegisterSourceHeader */:
+            return "AttributionReportingIssue::NoRegisterSourceHeader" /* IssueCode.NO_REGISTER_SOURCE_HEADER */;
+        case "NoRegisterTriggerHeader" /* Protocol.Audits.AttributionReportingIssueType.NoRegisterTriggerHeader */:
+            return "AttributionReportingIssue::NoRegisterTriggerHeader" /* IssueCode.NO_REGISTER_TRIGGER_HEADER */;
+        case "NoRegisterOsSourceHeader" /* Protocol.Audits.AttributionReportingIssueType.NoRegisterOsSourceHeader */:
+            return "AttributionReportingIssue::NoRegisterOsSourceHeader" /* IssueCode.NO_REGISTER_OS_SOURCE_HEADER */;
+        case "NoRegisterOsTriggerHeader" /* Protocol.Audits.AttributionReportingIssueType.NoRegisterOsTriggerHeader */:
+            return "AttributionReportingIssue::NoRegisterOsTriggerHeader" /* IssueCode.NO_REGISTER_OS_TRIGGER_HEADER */;
+        case "NavigationRegistrationUniqueScopeAlreadySet" /* Protocol.Audits.AttributionReportingIssueType.NavigationRegistrationUniqueScopeAlreadySet */:
+            return "AttributionReportingIssue::NavigationRegistrationUniqueScopeAlreadySet" /* IssueCode.NAVIGATION_REGISTRATION_UNIQUE_SCOPE_ALREADY_SET */;
+        default:
+            return "AttributionReportingIssue::Unknown" /* IssueCode.UNKNOWN */;
+    }
+}
+const structuredHeaderLink = {
+    link: 'https://tools.ietf.org/id/draft-ietf-httpbis-header-structure-15.html#rfc.section.4.2.2',
+    linkTitle: 'Structured Headers RFC',
+};
+export class AttributionReportingIssue extends Issue {
+    constructor(issueDetails, issuesModel) {
+        super(getIssueCode(issueDetails), issueDetails, issuesModel);
+    }
+    getCategory() {
+        return "AttributionReporting" /* IssueCategory.ATTRIBUTION_REPORTING */;
+    }
+    getHeaderValidatorLink(name) {
+        const url = new URL('https://wicg.github.io/attribution-reporting-api/validate-headers');
+        url.searchParams.set('header', name);
+        const details = this.details();
+        if (details.invalidParameter) {
+            url.searchParams.set('json', details.invalidParameter);
+        }
+        return {
+            link: url.toString(),
+            linkTitle: 'Header Validator',
+        };
+    }
+    getDescription() {
+        switch (this.code()) {
+            case "AttributionReportingIssue::PermissionPolicyDisabled" /* IssueCode.PERMISSION_POLICY_DISABLED */:
+                return {
+                    file: 'arPermissionPolicyDisabled.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::UntrustworthyReportingOrigin" /* IssueCode.UNTRUSTWORTHY_REPORTING_ORIGIN */:
+                return {
+                    file: 'arUntrustworthyReportingOrigin.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::InsecureContext" /* IssueCode.INSECURE_CONTEXT */:
+                return {
+                    file: 'arInsecureContext.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::InvalidRegisterSourceHeader" /* IssueCode.INVALID_REGISTER_SOURCE_HEADER */:
+                return {
+                    file: 'arInvalidRegisterSourceHeader.md',
+                    links: [this.getHeaderValidatorLink('source')],
+                };
+            case "AttributionReportingIssue::InvalidRegisterTriggerHeader" /* IssueCode.INVALID_REGISTER_TRIGGER_HEADER */:
+                return {
+                    file: 'arInvalidRegisterTriggerHeader.md',
+                    links: [this.getHeaderValidatorLink('trigger')],
+                };
+            case "AttributionReportingIssue::InvalidRegisterOsSourceHeader" /* IssueCode.INVALID_REGISTER_OS_SOURCE_HEADER */:
+                return {
+                    file: 'arInvalidRegisterOsSourceHeader.md',
+                    links: [this.getHeaderValidatorLink('os-source')],
+                };
+            case "AttributionReportingIssue::InvalidRegisterOsTriggerHeader" /* IssueCode.INVALID_REGISTER_OS_TRIGGER_HEADER */:
+                return {
+                    file: 'arInvalidRegisterOsTriggerHeader.md',
+                    links: [this.getHeaderValidatorLink('os-trigger')],
+                };
+            case "AttributionReportingIssue::SourceAndTriggerHeaders" /* IssueCode.SOURCE_AND_TRIGGER_HEADERS */:
+                return {
+                    file: 'arSourceAndTriggerHeaders.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::WebAndOsHeaders" /* IssueCode.WEB_AND_OS_HEADERS */:
+                return {
+                    file: 'arWebAndOsHeaders.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::SourceIgnored" /* IssueCode.SOURCE_IGNORED */:
+                return {
+                    file: 'arSourceIgnored.md',
+                    links: [structuredHeaderLink],
+                };
+            case "AttributionReportingIssue::TriggerIgnored" /* IssueCode.TRIGGER_IGNORED */:
+                return {
+                    file: 'arTriggerIgnored.md',
+                    links: [structuredHeaderLink],
+                };
+            case "AttributionReportingIssue::OsSourceIgnored" /* IssueCode.OS_SOURCE_IGNORED */:
+                return {
+                    file: 'arOsSourceIgnored.md',
+                    links: [structuredHeaderLink],
+                };
+            case "AttributionReportingIssue::OsTriggerIgnored" /* IssueCode.OS_TRIGGER_IGNORED */:
+                return {
+                    file: 'arOsTriggerIgnored.md',
+                    links: [structuredHeaderLink],
+                };
+            case "AttributionReportingIssue::NavigationRegistrationWithoutTransientUserActivation" /* IssueCode.NAVIGATION_REGISTRATION_WITHOUT_TRANSIENT_USER_ACTIVATION */:
+                return {
+                    file: 'arNavigationRegistrationWithoutTransientUserActivation.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NoWebOrOsSupport" /* IssueCode.NO_WEB_OR_OS_SUPPORT */:
+                return {
+                    file: 'arNoWebOrOsSupport.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::InvalidInfoHeader" /* IssueCode.INVALID_INFO_HEADER */:
+                return {
+                    file: 'arInvalidInfoHeader.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NoRegisterSourceHeader" /* IssueCode.NO_REGISTER_SOURCE_HEADER */:
+                return {
+                    file: 'arNoRegisterSourceHeader.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NoRegisterTriggerHeader" /* IssueCode.NO_REGISTER_TRIGGER_HEADER */:
+                return {
+                    file: 'arNoRegisterTriggerHeader.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NoRegisterOsSourceHeader" /* IssueCode.NO_REGISTER_OS_SOURCE_HEADER */:
+                return {
+                    file: 'arNoRegisterOsSourceHeader.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NoRegisterOsTriggerHeader" /* IssueCode.NO_REGISTER_OS_TRIGGER_HEADER */:
+                return {
+                    file: 'arNoRegisterOsTriggerHeader.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NavigationRegistrationUniqueScopeAlreadySet" /* IssueCode.NAVIGATION_REGISTRATION_UNIQUE_SCOPE_ALREADY_SET */:
+                return {
+                    file: 'arNavigationRegistrationUniqueScopeAlreadySet.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::Unknown" /* IssueCode.UNKNOWN */:
+                return null;
+        }
+    }
+    primaryKey() {
+        return JSON.stringify(this.details());
+    }
+    getKind() {
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const { attributionReportingIssueDetails } = inspectorIssue.details;
+        if (!attributionReportingIssueDetails) {
+            console.warn('Attribution Reporting issue without details received.');
+            return [];
+        }
+        return [new AttributionReportingIssue(attributionReportingIssueDetails, issuesModel)];
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/BounceTrackingIssue.js

@@ -0,0 +1,49 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+const UIStrings = {
+    /**
+     * @description Title for Bounce Tracking Mitigation explainer url link.
+     */
+    bounceTrackingMitigations: 'Bounce tracking mitigations',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/BounceTrackingIssue.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class BounceTrackingIssue extends Issue {
+    constructor(issueDetails, issuesModel) {
+        super("BounceTrackingIssue" /* Protocol.Audits.InspectorIssueCode.BounceTrackingIssue */, issueDetails, issuesModel);
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getDescription() {
+        return {
+            file: 'bounceTrackingMitigations.md',
+            links: [
+                {
+                    link: 'https://privacycg.github.io/nav-tracking-mitigations/#bounce-tracking-mitigations',
+                    linkTitle: i18nString(UIStrings.bounceTrackingMitigations),
+                },
+            ],
+        };
+    }
+    getKind() {
+        return "BreakingChange" /* IssueKind.BREAKING_CHANGE */;
+    }
+    primaryKey() {
+        return JSON.stringify(this.details());
+    }
+    trackingSites() {
+        return this.details().trackingSites;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.bounceTrackingIssueDetails;
+        if (!details) {
+            console.warn('Bounce tracking issue without details received.');
+            return [];
+        }
+        return [new BounceTrackingIssue(details, issuesModel)];
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/CheckFormsIssuesTrigger.js

@@ -0,0 +1,31 @@
+import * as SDK from '../../core/sdk/sdk.js';
+/**
+ * Responsible for asking autofill for current form issues. This currently happens when devtools is first open.
+ */
+// TODO(crbug.com/1399414): Trigger check form issues when an element with an associated issue is editted in the issues panel.
+let checkFormsIssuesTriggerInstance = null;
+export class CheckFormsIssuesTrigger {
+    constructor() {
+        SDK.TargetManager.TargetManager.instance().addModelListener(SDK.ResourceTreeModel.ResourceTreeModel, SDK.ResourceTreeModel.Events.Load, this.#pageLoaded, this, { scoped: true });
+        for (const model of SDK.TargetManager.TargetManager.instance().models(SDK.ResourceTreeModel.ResourceTreeModel)) {
+            if (model.target().outermostTarget() !== model.target()) {
+                continue;
+            }
+            this.#checkFormsIssues(model);
+        }
+    }
+    static instance({ forceNew } = { forceNew: false }) {
+        if (!checkFormsIssuesTriggerInstance || forceNew) {
+            checkFormsIssuesTriggerInstance = new CheckFormsIssuesTrigger();
+        }
+        return checkFormsIssuesTriggerInstance;
+    }
+    // TODO(crbug.com/1399414): Handle response by dropping current issues in favor of new ones.
+    #checkFormsIssues(resourceTreeModel) {
+        void resourceTreeModel.target().auditsAgent().invoke_checkFormsIssues();
+    }
+    #pageLoaded(event) {
+        const { resourceTreeModel } = event.data;
+        this.#checkFormsIssues(resourceTreeModel);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/ClientHintIssue.js

@@ -0,0 +1,71 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+import { resolveLazyDescription, } from './MarkdownIssueDescription.js';
+const UIStrings = {
+    /**
+     * @description Title for Client Hint specification url link
+     */
+    clientHintsInfrastructure: 'Client Hints Infrastructure',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/ClientHintIssue.ts', UIStrings);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+export class ClientHintIssue extends Issue {
+    constructor(issueDetails, issuesModel) {
+        super({
+            code: "ClientHintIssue" /* Protocol.Audits.InspectorIssueCode.ClientHintIssue */,
+            umaCode: ["ClientHintIssue" /* Protocol.Audits.InspectorIssueCode.ClientHintIssue */, issueDetails.clientHintIssueReason].join('::'),
+        }, issueDetails, issuesModel);
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getDescription() {
+        const description = issueDescriptions.get(this.details().clientHintIssueReason);
+        if (!description) {
+            return null;
+        }
+        return resolveLazyDescription(description);
+    }
+    sources() {
+        return [this.details().sourceCodeLocation];
+    }
+    primaryKey() {
+        return JSON.stringify(this.details());
+    }
+    getKind() {
+        return "BreakingChange" /* IssueKind.BREAKING_CHANGE */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.clientHintIssueDetails;
+        if (!details) {
+            console.warn('Client Hint issue without details received.');
+            return [];
+        }
+        return [new ClientHintIssue(details, issuesModel)];
+    }
+}
+const issueDescriptions = new Map([
+    [
+        "MetaTagAllowListInvalidOrigin" /* Protocol.Audits.ClientHintIssueReason.MetaTagAllowListInvalidOrigin */,
+        {
+            file: 'clientHintMetaTagAllowListInvalidOrigin.md',
+            links: [{
+                    link: 'https://wicg.github.io/client-hints-infrastructure/',
+                    linkTitle: i18nLazyString(UIStrings.clientHintsInfrastructure),
+                }],
+        },
+    ],
+    [
+        "MetaTagModifiedHTML" /* Protocol.Audits.ClientHintIssueReason.MetaTagModifiedHTML */,
+        {
+            file: 'clientHintMetaTagModifiedHTML.md',
+            links: [{
+                    link: 'https://wicg.github.io/client-hints-infrastructure/',
+                    linkTitle: i18nLazyString(UIStrings.clientHintsInfrastructure),
+                }],
+        },
+    ],
+]);

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/ContentSecurityPolicyIssue.js

@@ -0,0 +1,135 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+import { resolveLazyDescription, } from './MarkdownIssueDescription.js';
+const UIStrings = {
+    /**
+     * @description Title for CSP url link
+     */
+    contentSecurityPolicySource: 'Content Security Policy - Source Allowlists',
+    /**
+     * @description Title for CSP inline issue link
+     */
+    contentSecurityPolicyInlineCode: 'Content Security Policy - Inline Code',
+    /**
+     * @description Title for the CSP eval link
+     */
+    contentSecurityPolicyEval: 'Content Security Policy - Eval',
+    /**
+     * @description Title for Trusted Types policy violation issue link. https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API
+     */
+    trustedTypesFixViolations: 'Trusted Types - Fix violations',
+    /**
+     * @description Title for Trusted Types policy violation issue link. https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API
+     */
+    trustedTypesPolicyViolation: 'Trusted Types - Policy violation',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/ContentSecurityPolicyIssue.ts', UIStrings);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+export class ContentSecurityPolicyIssue extends Issue {
+    constructor(issueDetails, issuesModel, issueId) {
+        const issueCode = [
+            "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+            issueDetails.contentSecurityPolicyViolationType,
+        ].join('::');
+        super(issueCode, issueDetails, issuesModel, issueId);
+    }
+    getCategory() {
+        return "ContentSecurityPolicy" /* IssueCategory.CONTENT_SECURITY_POLICY */;
+    }
+    primaryKey() {
+        return JSON.stringify(this.details(), [
+            'blockedURL',
+            'contentSecurityPolicyViolationType',
+            'violatedDirective',
+            'isReportOnly',
+            'sourceCodeLocation',
+            'url',
+            'lineNumber',
+            'columnNumber',
+            'violatingNodeId',
+        ]);
+    }
+    getDescription() {
+        const description = issueDescriptions.get(this.details().contentSecurityPolicyViolationType);
+        if (!description) {
+            return null;
+        }
+        return resolveLazyDescription(description);
+    }
+    getKind() {
+        if (this.details().isReportOnly) {
+            return "Improvement" /* IssueKind.IMPROVEMENT */;
+        }
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const cspDetails = inspectorIssue.details.contentSecurityPolicyIssueDetails;
+        if (!cspDetails) {
+            console.warn('Content security policy issue without details received.');
+            return [];
+        }
+        return [new ContentSecurityPolicyIssue(cspDetails, issuesModel, inspectorIssue.issueId)];
+    }
+}
+const cspURLViolation = {
+    file: 'cspURLViolation.md',
+    links: [{
+            link: 'https://developers.google.com/web/fundamentals/security/csp#source_allowlists',
+            linkTitle: i18nLazyString(UIStrings.contentSecurityPolicySource),
+        }],
+};
+const cspInlineViolation = {
+    file: 'cspInlineViolation.md',
+    links: [{
+            link: 'https://developers.google.com/web/fundamentals/security/csp#inline_code_is_considered_harmful',
+            linkTitle: i18nLazyString(UIStrings.contentSecurityPolicyInlineCode),
+        }],
+};
+const cspEvalViolation = {
+    file: 'cspEvalViolation.md',
+    links: [{
+            link: 'https://developers.google.com/web/fundamentals/security/csp#eval_too',
+            linkTitle: i18nLazyString(UIStrings.contentSecurityPolicyEval),
+        }],
+};
+const cspTrustedTypesSinkViolation = {
+    file: 'cspTrustedTypesSinkViolation.md',
+    links: [{
+            link: 'https://web.dev/trusted-types/#fix-the-violations',
+            linkTitle: i18nLazyString(UIStrings.trustedTypesFixViolations),
+        }],
+};
+const cspTrustedTypesPolicyViolation = {
+    file: 'cspTrustedTypesPolicyViolation.md',
+    links: [{ link: 'https://web.dev/trusted-types/', linkTitle: i18nLazyString(UIStrings.trustedTypesPolicyViolation) }],
+};
+export const urlViolationCode = [
+    "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+    "kURLViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KURLViolation */,
+].join('::');
+export const inlineViolationCode = [
+    "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+    "kInlineViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KInlineViolation */,
+].join('::');
+export const evalViolationCode = [
+    "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+    "kEvalViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KEvalViolation */,
+].join('::');
+export const trustedTypesSinkViolationCode = [
+    "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+    "kTrustedTypesSinkViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KTrustedTypesSinkViolation */,
+].join('::');
+export const trustedTypesPolicyViolationCode = [
+    "ContentSecurityPolicyIssue" /* Protocol.Audits.InspectorIssueCode.ContentSecurityPolicyIssue */,
+    "kTrustedTypesPolicyViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KTrustedTypesPolicyViolation */,
+].join('::');
+const issueDescriptions = new Map([
+    ["kURLViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KURLViolation */, cspURLViolation],
+    ["kInlineViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KInlineViolation */, cspInlineViolation],
+    ["kEvalViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KEvalViolation */, cspEvalViolation],
+    ["kTrustedTypesSinkViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KTrustedTypesSinkViolation */, cspTrustedTypesSinkViolation],
+    ["kTrustedTypesPolicyViolation" /* Protocol.Audits.ContentSecurityPolicyViolationType.KTrustedTypesPolicyViolation */, cspTrustedTypesPolicyViolation],
+]);

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/ContrastCheckTrigger.js

@@ -0,0 +1,59 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as Common from '../../core/common/common.js';
+import * as Root from '../../core/root/root.js';
+import * as SDK from '../../core/sdk/sdk.js';
+let contrastCheckTriggerInstance = null;
+export class ContrastCheckTrigger {
+    #pageLoadListeners = new WeakMap();
+    #frameAddedListeners = new WeakMap();
+    constructor() {
+        SDK.TargetManager.TargetManager.instance().observeModels(SDK.ResourceTreeModel.ResourceTreeModel, this);
+    }
+    static instance({ forceNew } = { forceNew: false }) {
+        if (!contrastCheckTriggerInstance || forceNew) {
+            contrastCheckTriggerInstance = new ContrastCheckTrigger();
+        }
+        return contrastCheckTriggerInstance;
+    }
+    async modelAdded(resourceTreeModel) {
+        this.#pageLoadListeners.set(resourceTreeModel, resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.Load, this.#pageLoaded, this));
+        this.#frameAddedListeners.set(resourceTreeModel, resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameAdded, this.#frameAdded, this));
+    }
+    modelRemoved(resourceTreeModel) {
+        const pageLoadListener = this.#pageLoadListeners.get(resourceTreeModel);
+        if (pageLoadListener) {
+            Common.EventTarget.removeEventListeners([pageLoadListener]);
+        }
+        const frameAddedListeners = this.#frameAddedListeners.get(resourceTreeModel);
+        if (frameAddedListeners) {
+            Common.EventTarget.removeEventListeners([frameAddedListeners]);
+        }
+    }
+    #checkContrast(resourceTreeModel) {
+        if (!Root.Runtime.experiments.isEnabled('contrast-issues')) {
+            return;
+        }
+        void resourceTreeModel.target().auditsAgent().invoke_checkContrast({});
+    }
+    #pageLoaded(event) {
+        const { resourceTreeModel } = event.data;
+        this.#checkContrast(resourceTreeModel);
+    }
+    async #frameAdded(event) {
+        if (!Root.Runtime.experiments.isEnabled('contrast-issues')) {
+            return;
+        }
+        const frame = event.data;
+        if (!frame.isMainFrame()) {
+            return;
+        }
+        // If the target document finished loading, check the contrast immediately.
+        // Otherwise, it should be triggered when the page load event fires.
+        const response = await frame.resourceTreeModel().target().runtimeAgent().invoke_evaluate({ expression: 'document.readyState', returnByValue: true });
+        if (response.result?.value === 'complete') {
+            this.#checkContrast(frame.resourceTreeModel());
+        }
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/CookieDeprecationMetadataIssue.js

@@ -0,0 +1,58 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+const UIStrings = {
+    /**
+     * @description Label for a link for third-party cookie Issues.
+     */
+    thirdPartyPhaseoutExplained: 'Changes to Chrome\'s treatment of third-party cookies',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/CookieDeprecationMetadataIssue.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+/** TODO(b/305738703): Move this issue into a warning on CookieIssue. **/
+export class CookieDeprecationMetadataIssue extends Issue {
+    constructor(issueDetails, issuesModel) {
+        // Set a distinct code for ReadCookie and SetCookie issues, so they are grouped separately.
+        const issueCode = "CookieDeprecationMetadataIssue" /* Protocol.Audits.InspectorIssueCode.CookieDeprecationMetadataIssue */ + '_' + issueDetails.operation;
+        super(issueCode, issueDetails, issuesModel);
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getDescription() {
+        const fileName = this.details().operation === 'SetCookie' ? 'cookieWarnMetadataGrantSet.md' : 'cookieWarnMetadataGrantRead.md';
+        let optOutText = '';
+        if (this.details().isOptOutTopLevel) {
+            optOutText = '\n\n (Top level site opt-out: ' + this.details().optOutPercentage +
+                '% - [learn more](gracePeriodStagedControlExplainer))';
+        }
+        return {
+            file: fileName,
+            substitutions: new Map([
+                ['PLACEHOLDER_topleveloptout', optOutText],
+            ]),
+            links: [
+                {
+                    link: 'https://goo.gle/changes-to-chrome-browsing',
+                    linkTitle: i18nString(UIStrings.thirdPartyPhaseoutExplained),
+                },
+            ],
+        };
+    }
+    getKind() {
+        return "BreakingChange" /* IssueKind.BREAKING_CHANGE */;
+    }
+    primaryKey() {
+        return JSON.stringify(this.details());
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.cookieDeprecationMetadataIssueDetails;
+        if (!details) {
+            console.warn('Cookie deprecation metadata issue without details received.');
+            return [];
+        }
+        return [new CookieDeprecationMetadataIssue(details, issuesModel)];
+    }
+}