chrome-devtools-mcp 0.10.0 → 0.10.2

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

@@ -0,0 +1,297 @@
+// 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';
+import { resolveLazyDescription, } from './MarkdownIssueDescription.js';
+const UIStrings = {
+    /**
+     * @description Title for Compression Dictionary Transport specification url link
+     */
+    compressionDictionaryTransport: 'Compression Dictionary Transport',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/SharedDictionaryIssue.ts', UIStrings);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+function getIssueCode(details) {
+    switch (details.sharedDictionaryError) {
+        case "UseErrorCrossOriginNoCorsRequest" /* Protocol.Audits.SharedDictionaryError.UseErrorCrossOriginNoCorsRequest */:
+            return "SharedDictionaryIssue::UseErrorCrossOriginNoCorsRequest" /* IssueCode.USE_ERROR_CROSS_ORIGIN_NO_CORS_REQUEST */;
+        case "UseErrorDictionaryLoadFailure" /* Protocol.Audits.SharedDictionaryError.UseErrorDictionaryLoadFailure */:
+            return "SharedDictionaryIssue::UseErrorDictionaryLoadFailure" /* IssueCode.USE_ERROR_DICTIONARY_LOAD_FAILURE */;
+        case "UseErrorMatchingDictionaryNotUsed" /* Protocol.Audits.SharedDictionaryError.UseErrorMatchingDictionaryNotUsed */:
+            return "SharedDictionaryIssue::UseErrorMatchingDictionaryNotUsed" /* IssueCode.USE_ERROR_MATCHING_DICTIONARY_NOT_USED */;
+        case "UseErrorUnexpectedContentDictionaryHeader" /* Protocol.Audits.SharedDictionaryError.UseErrorUnexpectedContentDictionaryHeader */:
+            return "SharedDictionaryIssue::UseErrorUnexpectedContentDictionaryHeader" /* IssueCode.USE_ERROR_UNEXPECTED_CONTENT_DICTIONARY_HEADER */;
+        case "WriteErrorCossOriginNoCorsRequest" /* Protocol.Audits.SharedDictionaryError.WriteErrorCossOriginNoCorsRequest */:
+            return "SharedDictionaryIssue::WriteErrorCossOriginNoCorsRequest" /* IssueCode.WRITE_ERROR_CROSS_ORIGIN_NO_CORS_REQUEST */;
+        case "WriteErrorDisallowedBySettings" /* Protocol.Audits.SharedDictionaryError.WriteErrorDisallowedBySettings */:
+            return "SharedDictionaryIssue::WriteErrorDisallowedBySettings" /* IssueCode.WRITE_ERROR_DISALLOWED_BY_SETTINGS */;
+        case "WriteErrorExpiredResponse" /* Protocol.Audits.SharedDictionaryError.WriteErrorExpiredResponse */:
+            return "SharedDictionaryIssue::WriteErrorExpiredResponse" /* IssueCode.WRITE_ERROR_EXPIRED_RESPONSE */;
+        case "WriteErrorFeatureDisabled" /* Protocol.Audits.SharedDictionaryError.WriteErrorFeatureDisabled */:
+            return "SharedDictionaryIssue::WriteErrorFeatureDisabled" /* IssueCode.WRITE_ERROR_FEATURE_DISABLED */;
+        case "WriteErrorInsufficientResources" /* Protocol.Audits.SharedDictionaryError.WriteErrorInsufficientResources */:
+            return "SharedDictionaryIssue::WriteErrorInsufficientResources" /* IssueCode.WRITE_ERROR_INSUFFICIENT_RESOURCES */;
+        case "WriteErrorInvalidMatchField" /* Protocol.Audits.SharedDictionaryError.WriteErrorInvalidMatchField */:
+            return "SharedDictionaryIssue::WriteErrorInvalidMatchField" /* IssueCode.WRITE_ERROR_INVALID_MATCH_FIELD */;
+        case "WriteErrorInvalidStructuredHeader" /* Protocol.Audits.SharedDictionaryError.WriteErrorInvalidStructuredHeader */:
+            return "SharedDictionaryIssue::WriteErrorInvalidStructuredHeader" /* IssueCode.WRITE_ERROR_INVALID_STRUCTURED_HEADER */;
+        case "WriteErrorInvalidTTLField" /* Protocol.Audits.SharedDictionaryError.WriteErrorInvalidTTLField */:
+            return "SharedDictionaryIssue::WriteErrorInvalidTTLField" /* IssueCode.WRITE_ERROR_INVALID_TTL_FIELD */;
+        case "WriteErrorNavigationRequest" /* Protocol.Audits.SharedDictionaryError.WriteErrorNavigationRequest */:
+            return "SharedDictionaryIssue::WriteErrorNavigationRequest" /* IssueCode.WRITE_ERROR_NAVIGATION_REQUEST */;
+        case "WriteErrorNoMatchField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNoMatchField */:
+            return "SharedDictionaryIssue::WriteErrorNoMatchField" /* IssueCode.WRITE_ERROR_NO_MATCH_FIELD */;
+        case "WriteErrorNonIntegerTTLField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonIntegerTTLField */:
+            return "SharedDictionaryIssue::WriteErrorNonIntegerTTLField" /* IssueCode.WRITE_ERROR_NON_INTEGER_TTL_FIELD */;
+        case "WriteErrorNonListMatchDestField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonListMatchDestField */:
+            return "SharedDictionaryIssue::WriteErrorNonListMatchDestField" /* IssueCode.WRITE_ERROR_NON_LIST_MATCH_DEST_FIELD */;
+        case "WriteErrorNonSecureContext" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonSecureContext */:
+            return "SharedDictionaryIssue::WriteErrorNonSecureContext" /* IssueCode.WRITE_ERROR_NON_SECURE_CONTEXT */;
+        case "WriteErrorNonStringIdField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonStringIdField */:
+            return "SharedDictionaryIssue::WriteErrorNonStringIdField" /* IssueCode.WRITE_ERROR_NON_STRING_ID_FIELD */;
+        case "WriteErrorNonStringInMatchDestList" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonStringInMatchDestList */:
+            return "SharedDictionaryIssue::WriteErrorNonStringInMatchDestList" /* IssueCode.WRITE_ERROR_NON_STRING_IN_MATCH_DEST_LIST */;
+        case "WriteErrorNonStringMatchField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonStringMatchField */:
+            return "SharedDictionaryIssue::WriteErrorNonStringMatchField" /* IssueCode.WRITE_ERROR_NON_STRING_MATCH_FIELD */;
+        case "WriteErrorNonTokenTypeField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonTokenTypeField */:
+            return "SharedDictionaryIssue::WriteErrorNonTokenTypeField" /* IssueCode.WRITE_ERROR_NON_TOKEN_TYPE_FIELD */;
+        case "WriteErrorRequestAborted" /* Protocol.Audits.SharedDictionaryError.WriteErrorRequestAborted */:
+            return "SharedDictionaryIssue::WriteErrorRequestAborted" /* IssueCode.WRITE_ERROR_REQUEST_ABORTED */;
+        case "WriteErrorShuttingDown" /* Protocol.Audits.SharedDictionaryError.WriteErrorShuttingDown */:
+            return "SharedDictionaryIssue::WriteErrorShuttingDown" /* IssueCode.WRITE_ERROR_SHUTTING_DOWN */;
+        case "WriteErrorTooLongIdField" /* Protocol.Audits.SharedDictionaryError.WriteErrorTooLongIdField */:
+            return "SharedDictionaryIssue::WriteErrorTooLongIdField" /* IssueCode.WRITE_ERROR_TOO_LONG_ID_FIELD */;
+        case "WriteErrorUnsupportedType" /* Protocol.Audits.SharedDictionaryError.WriteErrorUnsupportedType */:
+            return "SharedDictionaryIssue::WriteErrorUnsupportedType" /* IssueCode.WRITE_ERROR_UNSUPPORTED_TYPE */;
+        default:
+            return "SharedDictionaryIssue::WriteErrorUnknown" /* IssueCode.UNKNOWN */;
+    }
+}
+export class SharedDictionaryIssue extends Issue {
+    #issueDetails;
+    constructor(issueDetails, issuesModel) {
+        super({
+            code: getIssueCode(issueDetails),
+            umaCode: [
+                "SharedDictionaryIssue" /* Protocol.Audits.InspectorIssueCode.SharedDictionaryIssue */,
+                issueDetails.sharedDictionaryError,
+            ].join('::'),
+        }, issuesModel);
+        this.#issueDetails = issueDetails;
+    }
+    requests() {
+        if (this.#issueDetails.request) {
+            return [this.#issueDetails.request];
+        }
+        return [];
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    getDescription() {
+        const description = issueDescriptions.get(this.#issueDetails.sharedDictionaryError);
+        if (!description) {
+            return null;
+        }
+        return resolveLazyDescription(description);
+    }
+    primaryKey() {
+        return JSON.stringify(this.#issueDetails);
+    }
+    getKind() {
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.sharedDictionaryIssueDetails;
+        if (!details) {
+            console.warn('Shared Dictionary issue without details received.');
+            return [];
+        }
+        return [new SharedDictionaryIssue(details, issuesModel)];
+    }
+}
+const specLinks = [{
+        link: 'https://datatracker.ietf.org/doc/draft-ietf-httpbis-compression-dictionary/',
+        linkTitle: i18nLazyString(UIStrings.compressionDictionaryTransport),
+    }];
+const issueDescriptions = new Map([
+    [
+        "UseErrorCrossOriginNoCorsRequest" /* Protocol.Audits.SharedDictionaryError.UseErrorCrossOriginNoCorsRequest */,
+        {
+            file: 'sharedDictionaryUseErrorCrossOriginNoCorsRequest.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "UseErrorDictionaryLoadFailure" /* Protocol.Audits.SharedDictionaryError.UseErrorDictionaryLoadFailure */,
+        {
+            file: 'sharedDictionaryUseErrorDictionaryLoadFailure.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "UseErrorMatchingDictionaryNotUsed" /* Protocol.Audits.SharedDictionaryError.UseErrorMatchingDictionaryNotUsed */,
+        {
+            file: 'sharedDictionaryUseErrorMatchingDictionaryNotUsed.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "UseErrorUnexpectedContentDictionaryHeader" /* Protocol.Audits.SharedDictionaryError.UseErrorUnexpectedContentDictionaryHeader */,
+        {
+            file: 'sharedDictionaryUseErrorUnexpectedContentDictionaryHeader.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorCossOriginNoCorsRequest" /* Protocol.Audits.SharedDictionaryError.WriteErrorCossOriginNoCorsRequest */,
+        {
+            file: 'sharedDictionaryWriteErrorCossOriginNoCorsRequest.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorDisallowedBySettings" /* Protocol.Audits.SharedDictionaryError.WriteErrorDisallowedBySettings */,
+        {
+            file: 'sharedDictionaryWriteErrorDisallowedBySettings.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorExpiredResponse" /* Protocol.Audits.SharedDictionaryError.WriteErrorExpiredResponse */,
+        {
+            file: 'sharedDictionaryWriteErrorExpiredResponse.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorFeatureDisabled" /* Protocol.Audits.SharedDictionaryError.WriteErrorFeatureDisabled */,
+        {
+            file: 'sharedDictionaryWriteErrorFeatureDisabled.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorInsufficientResources" /* Protocol.Audits.SharedDictionaryError.WriteErrorInsufficientResources */,
+        {
+            file: 'sharedDictionaryWriteErrorInsufficientResources.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorInvalidMatchField" /* Protocol.Audits.SharedDictionaryError.WriteErrorInvalidMatchField */,
+        {
+            file: 'sharedDictionaryWriteErrorInvalidMatchField.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorInvalidStructuredHeader" /* Protocol.Audits.SharedDictionaryError.WriteErrorInvalidStructuredHeader */,
+        {
+            file: 'sharedDictionaryWriteErrorInvalidStructuredHeader.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorInvalidTTLField" /* Protocol.Audits.SharedDictionaryError.WriteErrorInvalidTTLField */,
+        {
+            file: 'sharedDictionaryWriteErrorInvalidTTLField.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorNavigationRequest" /* Protocol.Audits.SharedDictionaryError.WriteErrorNavigationRequest */,
+        {
+            file: 'sharedDictionaryWriteErrorNavigationRequest.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorNoMatchField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNoMatchField */,
+        {
+            file: 'sharedDictionaryWriteErrorNoMatchField.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorNonIntegerTTLField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonIntegerTTLField */,
+        {
+            file: 'sharedDictionaryWriteErrorNonIntegerTTLField.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorNonListMatchDestField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonListMatchDestField */,
+        {
+            file: 'sharedDictionaryWriteErrorNonListMatchDestField.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorNonSecureContext" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonSecureContext */,
+        {
+            file: 'sharedDictionaryWriteErrorNonSecureContext.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorNonStringIdField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonStringIdField */,
+        {
+            file: 'sharedDictionaryWriteErrorNonStringIdField.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorNonStringInMatchDestList" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonStringInMatchDestList */,
+        {
+            file: 'sharedDictionaryWriteErrorNonStringInMatchDestList.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorNonStringMatchField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonStringMatchField */,
+        {
+            file: 'sharedDictionaryWriteErrorNonStringMatchField.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorNonTokenTypeField" /* Protocol.Audits.SharedDictionaryError.WriteErrorNonTokenTypeField */,
+        {
+            file: 'sharedDictionaryWriteErrorNonTokenTypeField.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorRequestAborted" /* Protocol.Audits.SharedDictionaryError.WriteErrorRequestAborted */,
+        {
+            file: 'sharedDictionaryWriteErrorRequestAborted.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorShuttingDown" /* Protocol.Audits.SharedDictionaryError.WriteErrorShuttingDown */,
+        {
+            file: 'sharedDictionaryWriteErrorShuttingDown.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorTooLongIdField" /* Protocol.Audits.SharedDictionaryError.WriteErrorTooLongIdField */,
+        {
+            file: 'sharedDictionaryWriteErrorTooLongIdField.md',
+            links: specLinks,
+        },
+    ],
+    [
+        "WriteErrorUnsupportedType" /* Protocol.Audits.SharedDictionaryError.WriteErrorUnsupportedType */,
+        {
+            file: 'sharedDictionaryWriteErrorUnsupportedType.md',
+            links: specLinks,
+        },
+    ],
+]);

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

@@ -0,0 +1,81 @@
+// 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 Common from '../../core/common/common.js';
+import * as Bindings from '../../models/bindings/bindings.js';
+import * as Workspace from '../../models/workspace/workspace.js';
+import { ContentSecurityPolicyIssue, trustedTypesPolicyViolationCode, trustedTypesSinkViolationCode, } from './ContentSecurityPolicyIssue.js';
+import { toZeroBasedLocation } from './Issue.js';
+import { getIssueTitleFromMarkdownDescription } from './MarkdownIssueDescription.js';
+import { PropertyRuleIssue } from './PropertyRuleIssue.js';
+import { lateImportStylesheetLoadingCode } from './StylesheetLoadingIssue.js';
+export class SourceFrameIssuesManager {
+    issuesManager;
+    #sourceFrameMessageManager = new Bindings.PresentationConsoleMessageHelper.PresentationSourceFrameMessageManager();
+    constructor(issuesManager) {
+        this.issuesManager = issuesManager;
+        this.issuesManager.addEventListener("IssueAdded" /* Events.ISSUE_ADDED */, this.#onIssueAdded, this);
+        this.issuesManager.addEventListener("FullUpdateRequired" /* Events.FULL_UPDATE_REQUIRED */, this.#onFullUpdateRequired, this);
+    }
+    #onIssueAdded(event) {
+        const { issue } = event.data;
+        void this.#addIssue(issue);
+    }
+    async #addIssue(issue) {
+        if (!this.#isTrustedTypeIssue(issue) && !this.#isLateImportIssue(issue) && !this.#isPropertyRuleIssue(issue)) {
+            return;
+        }
+        const issuesModel = issue.model();
+        if (!issuesModel) {
+            return;
+        }
+        const srcLocation = toZeroBasedLocation(issue.details().sourceCodeLocation);
+        const description = issue.getDescription();
+        if (!description || !srcLocation) {
+            return;
+        }
+        const messageText = await getIssueTitleFromMarkdownDescription(description);
+        if (!messageText) {
+            return;
+        }
+        const clickHandler = () => {
+            void Common.Revealer.reveal(issue);
+        };
+        this.#sourceFrameMessageManager.addMessage(new IssueMessage(messageText, issue.getKind(), clickHandler), {
+            line: srcLocation.lineNumber,
+            column: srcLocation.columnNumber ?? -1,
+            url: srcLocation.url,
+            scriptId: srcLocation.scriptId,
+        }, issuesModel.target());
+    }
+    #onFullUpdateRequired() {
+        this.#resetMessages();
+        const issues = this.issuesManager.issues();
+        for (const issue of issues) {
+            void this.#addIssue(issue);
+        }
+    }
+    #isTrustedTypeIssue(issue) {
+        return issue instanceof ContentSecurityPolicyIssue && issue.code() === trustedTypesSinkViolationCode ||
+            issue.code() === trustedTypesPolicyViolationCode;
+    }
+    #isPropertyRuleIssue(issue) {
+        return issue instanceof PropertyRuleIssue;
+    }
+    #isLateImportIssue(issue) {
+        return issue.code() === lateImportStylesheetLoadingCode;
+    }
+    #resetMessages() {
+        this.#sourceFrameMessageManager.clear();
+    }
+}
+export class IssueMessage extends Workspace.UISourceCode.Message {
+    #kind;
+    constructor(title, kind, clickHandler) {
+        super("Issue" /* Workspace.UISourceCode.Message.Level.ISSUE */, title, clickHandler);
+        this.#kind = kind;
+    }
+    getIssueKind() {
+        return this.#kind;
+    }
+}

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

@@ -0,0 +1,63 @@
+// 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 { Issue } from './Issue.js';
+export const lateImportStylesheetLoadingCode = [
+    "StylesheetLoadingIssue" /* Protocol.Audits.InspectorIssueCode.StylesheetLoadingIssue */,
+    "LateImportRule" /* Protocol.Audits.StyleSheetLoadingIssueReason.LateImportRule */,
+].join('::');
+export class StylesheetLoadingIssue extends Issue {
+    #issueDetails;
+    constructor(issueDetails, issuesModel) {
+        const code = `${"StylesheetLoadingIssue" /* Protocol.Audits.InspectorIssueCode.StylesheetLoadingIssue */}::${issueDetails.styleSheetLoadingIssueReason}`;
+        super(code, issuesModel);
+        this.#issueDetails = issueDetails;
+    }
+    sources() {
+        return [this.#issueDetails.sourceCodeLocation];
+    }
+    requests() {
+        if (!this.#issueDetails.failedRequestInfo) {
+            return [];
+        }
+        const { url, requestId } = this.#issueDetails.failedRequestInfo;
+        if (!requestId) {
+            return [];
+        }
+        return [{ url, requestId }];
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    primaryKey() {
+        return JSON.stringify(this.#issueDetails);
+    }
+    getDescription() {
+        switch (this.#issueDetails.styleSheetLoadingIssueReason) {
+            case "LateImportRule" /* Protocol.Audits.StyleSheetLoadingIssueReason.LateImportRule */:
+                return {
+                    file: 'stylesheetLateImport.md',
+                    links: [],
+                };
+            case "RequestFailed" /* Protocol.Audits.StyleSheetLoadingIssueReason.RequestFailed */:
+                return {
+                    file: 'stylesheetRequestFailed.md',
+                    links: [],
+                };
+        }
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getKind() {
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    static fromInspectorIssue(issueModel, inspectorIssue) {
+        const stylesheetLoadingDetails = inspectorIssue.details.stylesheetLoadingIssueDetails;
+        if (!stylesheetLoadingDetails) {
+            console.warn('Stylesheet loading issue without details received');
+            return [];
+        }
+        return [new StylesheetLoadingIssue(stylesheetLoadingDetails, issueModel)];
+    }
+}

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

@@ -0,0 +1,67 @@
+// Copyright 2025 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 HTTP Unencoded Digest specification url
+     */
+    unencodedDigestHeader: 'HTTP Unencoded Digest specification',
+    /**
+     *@description Title for the URL of the integration of unencoded-digest and SRI.
+     */
+    integrityIntegration: 'Server-Initiated Integrity Checks',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/UnencodedDigestIssue.ts', UIStrings);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+export class UnencodedDigestIssue extends Issue {
+    #issueDetails;
+    constructor(issueDetails, issuesModel) {
+        super({
+            code: `${"UnencodedDigestIssue" /* Protocol.Audits.InspectorIssueCode.UnencodedDigestIssue */}::${issueDetails.error}`,
+            umaCode: `${"UnencodedDigestIssue" /* Protocol.Audits.InspectorIssueCode.UnencodedDigestIssue */}::${issueDetails.error}`,
+        }, issuesModel);
+        this.#issueDetails = issueDetails;
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    primaryKey() {
+        return JSON.stringify(this.details());
+    }
+    getDescription() {
+        const description = {
+            file: `unencodedDigest${this.details().error}.md`,
+            links: [
+                {
+                    link: 'https://www.ietf.org/archive/id/draft-ietf-httpbis-unencoded-digest-01.html',
+                    linkTitle: i18nLazyString(UIStrings.unencodedDigestHeader),
+                },
+                {
+                    link: 'https://wicg.github.io/signature-based-sri/#unencoded-digest-validation',
+                    linkTitle: i18nLazyString(UIStrings.integrityIntegration),
+                },
+            ],
+        };
+        return resolveLazyDescription(description);
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getKind() {
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    requests() {
+        return this.details().request ? [this.details().request] : [];
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.unencodedDigestIssueDetails;
+        if (!details) {
+            console.warn('Unencoded-Digest issue without details received.');
+            return [];
+        }
+        return [new UnencodedDigestIssue(details, issuesModel)];
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/CoepCoopSandboxedIframeCannotNavigateToCoopPage.md

@@ -0,0 +1,4 @@
+# An iframe navigation to a document with a Cross-Origin Opener Policy was blocked
+
+A document with a Cross-Origin Opener Policy (COOP) was blocked from loading in an iframe, because the iframe specifies a sandbox attribute.
+This protects COOP-enabled documents from inheriting properties from its opener.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/CoepCorpNotSameOrigin.md

@@ -0,0 +1,8 @@
+# Specify a more permissive Cross-Origin Resource Policy to prevent a resource from being blocked
+
+Your site tries to access an external resource that only allows same-origin usage.
+This behavior prevents a document from loading any non-same-origin resources which don’t explicitly grant permission to be loaded.
+
+To solve this, add the following to the resource’s HTML response header:
+* `Cross-Origin-Resource-Policy: same-site` if the resource and your site are served from the same site.
+* `Cross-Origin-Resource-Policy: cross-origin` if the resource is served from another location than your website. ⚠️If you set this header, any website can embed this resource.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/CoepCorpNotSameOriginAfterDefaultedToSameOriginByCoep.md

@@ -0,0 +1,18 @@
+# Specify a Cross-Origin Resource Policy to prevent a resource from being blocked
+
+Because your site has the Cross-Origin Embedder Policy (COEP) enabled, each
+resource must specify a suitable Cross-Origin Resource Policy (CORP). This
+behavior prevents a document from loading cross-origin resources which don’t
+explicitly grant permission to be loaded.
+
+To solve this, add the following to the resource’ response header:
+* `Cross-Origin-Resource-Policy: same-site` if the resource and your site are
+  served from the same site.
+* `Cross-Origin-Resource-Policy: cross-origin` if the resource is served from
+  another location than your website. ⚠️If you set this header, any website can
+  embed this resource.
+
+Alternatively, the document can use the variant: `Cross-Origin-Embedder-Policy:
+credentialless` instead of `require-corp`. It allows loading the resource,
+despite the missing CORP header, at the cost of requesting it without
+credentials like Cookies.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/CoepCorpNotSameSite.md

@@ -0,0 +1,7 @@
+# Specify a more permissive Cross-Origin Resource Policy to prevent a resource from being blocked
+
+Your site tries to access an external resource that only allows same-site usage.
+This behavior prevents a document from loading any non-same-site resources which don’t explicitly grant permission to be loaded.
+
+To solve this, add the following to the resource’s HTML response header: `Cross-Origin-Resource-Policy: cross-origin`
+⚠️If you set this header, any website can embed this resource.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/CoepFrameResourceNeedsCoepHeader.md

@@ -0,0 +1,10 @@
+# Specify a Cross-Origin Embedder Policy to prevent this frame from being blocked
+
+Because your site has the Cross-Origin Embedder Policy (COEP) enabled, each
+embedded iframe must also specify this policy. This behavior protects private
+data from being exposed to untrusted third party sites.
+
+To solve this, add one of following to the embedded frame’s HTML response
+header:
+* `Cross-Origin-Embedder-Policy: require-corp`
+* `Cross-Origin-Embedder-Policy: credentialless` (Chrome > 96)

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/CompatibilityModeQuirks.md

@@ -0,0 +1,5 @@
+# Page layout may be unexpected due to Quirks Mode
+
+One or more documents in this page is in Quirks Mode, which will render the affected document(s) with quirks incompatible with the current HTML and CSS specifications.
+
+Quirks Mode exists mostly due to historical reasons. If this is not intentional, you can [add or modify the DOCTYPE to be `<!DOCTYPE html>`](issueQuirksModeDoctype) to render the page in No Quirks Mode.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/CookieAttributeValueExceedsMaxSize.md

@@ -0,0 +1,5 @@
+# Ensure cookie attribute values don’t exceed 1024 characters
+
+Cookie attribute values exceeding 1024 characters in size will result in the attribute being ignored. This could lead to unexpected behavior since the cookie will be processed as if the offending attribute / attribute value pair were not present.
+
+Resolve this issue by ensuring that cookie attribute values don’t exceed 1024 characters.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/LowTextContrast.md

@@ -0,0 +1,5 @@
+# Users may have difficulties reading text content due to insufficient color contrast
+
+Low-contrast text is difficult or impossible for users to read. A [minimum contrast ratio (AA) of 4.5](issuesContrastWCAG21AA) is recommended for all text. Since font size and weight affect color perception, an exception is made for very large or bold text — in this case, a contrast ratio of 3.0 is allowed. The [enhanced conformance level (AAA)](issuesContrastWCAG21AAA) requires the contrast ratio to be above 7.0 for regular text and 4.5 for large text.
+
+Update colors or change the font size or weight to achieve sufficient contrast. You can use the [“Suggest color” feature](issuesContrastSuggestColor) in the DevTools color picker to automatically select a better text color.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/SameSiteExcludeContextDowngradeRead.md

@@ -0,0 +1,8 @@
+# Migrate entirely to HTTPS to have cookies sent to same-site subresources
+
+A cookie was not sent to {PLACEHOLDER_destination} origin from {PLACEHOLDER_origin} context.
+Because this cookie would have been sent across schemes on the same site, it was not sent.
+This behavior enhances the `SameSite` attribute’s protection of user data from request forgery by network attackers.
+
+Resolve this issue by migrating your site (as defined by the eTLD+1) entirely to HTTPS.
+It is also recommended to mark the cookie with the `Secure` attribute if that is not already the case.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/SameSiteExcludeContextDowngradeSet.md

@@ -0,0 +1,8 @@
+# Migrate entirely to HTTPS to allow cookies to be set by same-site subresources
+
+A cookie was not set by {PLACEHOLDER_origin} origin in {PLACEHOLDER_destination} context.
+Because this cookie would have been set across schemes on the same site, it was blocked.
+This behavior enhances the `SameSite` attribute’s protection of user data from request forgery by network attackers.
+
+Resolve this issue by migrating your site (as defined by the eTLD+1) entirely to HTTPS.
+It is also recommended to mark the cookie with the `Secure` attribute if that is not already the case.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/SameSiteExcludeNavigationContextDowngrade.md

@@ -0,0 +1,8 @@
+# Migrate entirely to HTTPS to have cookies sent on same-site requests
+
+A cookie was not sent to {PLACEHOLDER_destination} origin from {PLACEHOLDER_origin} context on a navigation.
+Because this cookie would have been sent across schemes on the same site, it was not sent.
+This behavior enhances the `SameSite` attribute’s protection of user data from request forgery by network attackers.
+
+Resolve this issue by migrating your site (as defined by the eTLD+1) entirely to HTTPS.
+It is also recommended to mark the cookie with the `Secure` attribute if that is not already the case.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/SameSiteInvalidSameParty.md

@@ -0,0 +1,8 @@
+# Mark SameParty cookies as Secure and do not use SameSite=Strict for SameParty cookies
+
+Cookies marked with `SameParty` must also be marked with `Secure`. In addition, cookies marked
+with `SameParty` cannot use `SameSite=Strict`.
+
+Resolve this issue by updating the attributes of the cookie:
+  * Remove `SameParty` if the cookie should only be used by the same site but not the same first-party set
+  * Remove `SameSite=Strict` and specify `Secure` if the cookie should be available to all sites of the same first-party set

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/SameSiteNoneInsecureErrorRead.md

@@ -0,0 +1,8 @@
+# Mark cross-site cookies as Secure to allow them to be sent in cross-site requests
+
+Cookies marked with `SameSite=None` must also be marked with `Secure` to get sent in cross-site requests.
+This behavior protects user data from being sent over an insecure connection.
+
+Resolve this issue by updating the attributes of the cookie:
+* Specify `SameSite=None` and `Secure` if the cookie should be sent in cross-site requests. This enables third-party use.
+* Specify `SameSite=Strict` or `SameSite=Lax` if the cookie should not be sent in cross-site requests.

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/descriptions/SameSiteNoneInsecureErrorSet.md

@@ -0,0 +1,8 @@
+# Mark cross-site cookies as Secure to allow setting them in cross-site contexts
+
+Cookies marked with `SameSite=None` must also be marked with `Secure` to allow setting them in a cross-site context.
+This behavior protects user data from being sent over an insecure connection.
+
+Resolve this issue by updating the attributes of the cookie:
+* Specify `SameSite=None` and `Secure` if the cookie is intended to be set in cross-site contexts. Note that only cookies sent over HTTPS may use the `Secure` attribute.
+* Specify `SameSite=Strict` or `SameSite=Lax` if the cookie should not be set by cross-site requests.