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

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

@@ -0,0 +1,58 @@
+// 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';
+const UIStrings = {
+    /**
+     * @description Title for Partitioning BlobURL explainer url link.
+     */
+    partitioningBlobURL: 'Partitioning BlobURL',
+    /**
+     * @description Title for Chrome Status Entry url link.
+     */
+    chromeStatusEntry: 'Chrome Status Entry'
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/PartitioningBlobURLIssue.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class PartitioningBlobURLIssue extends Issue {
+    constructor(issueDetails, issuesModel) {
+        super("PartitioningBlobURLIssue" /* Protocol.Audits.InspectorIssueCode.PartitioningBlobURLIssue */, issueDetails, issuesModel);
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getDescription() {
+        const fileName = this.details().partitioningBlobURLInfo ===
+            "BlockedCrossPartitionFetching" /* Protocol.Audits.PartitioningBlobURLInfo.BlockedCrossPartitionFetching */ ?
+            'fetchingPartitionedBlobURL.md' :
+            'navigatingPartitionedBlobURL.md';
+        return {
+            file: fileName,
+            links: [
+                {
+                    link: 'https://developers.google.com/privacy-sandbox/cookies/storage-partitioning',
+                    linkTitle: i18nString(UIStrings.partitioningBlobURL),
+                },
+                {
+                    link: 'https://chromestatus.com/feature/5130361898795008',
+                    linkTitle: i18nString(UIStrings.chromeStatusEntry),
+                },
+            ],
+        };
+    }
+    getKind() {
+        return "BreakingChange" /* IssueKind.BREAKING_CHANGE */;
+    }
+    primaryKey() {
+        return JSON.stringify(this.details());
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.partitioningBlobURLIssueDetails;
+        if (!details) {
+            console.warn('Partitioning BlobURL issue without details received.');
+            return [];
+        }
+        return [new PartitioningBlobURLIssue(details, issuesModel)];
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/issues_manager/PropertyRuleIssue.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 { Issue } from './Issue.js';
+export class PropertyRuleIssue extends Issue {
+    #primaryKey;
+    constructor(issueDetails, issuesModel) {
+        const code = JSON.stringify(issueDetails);
+        super(code, issueDetails, issuesModel);
+        this.#primaryKey = code;
+    }
+    sources() {
+        return [this.details().sourceCodeLocation];
+    }
+    primaryKey() {
+        return this.#primaryKey;
+    }
+    getPropertyName() {
+        switch (this.details().propertyRuleIssueReason) {
+            case "InvalidInherits" /* Protocol.Audits.PropertyRuleIssueReason.InvalidInherits */:
+                return 'inherits';
+            case "InvalidInitialValue" /* Protocol.Audits.PropertyRuleIssueReason.InvalidInitialValue */:
+                return 'initial-value';
+            case "InvalidSyntax" /* Protocol.Audits.PropertyRuleIssueReason.InvalidSyntax */:
+                return 'syntax';
+        }
+        return '';
+    }
+    getDescription() {
+        if (this.details().propertyRuleIssueReason === "InvalidName" /* Protocol.Audits.PropertyRuleIssueReason.InvalidName */) {
+            return {
+                file: 'propertyRuleInvalidNameIssue.md',
+                links: [],
+            };
+        }
+        const value = this.details().propertyValue ? `: ${this.details().propertyValue}` : '';
+        const property = `${this.getPropertyName()}${value}`;
+        return {
+            file: 'propertyRuleIssue.md',
+            substitutions: new Map([['PLACEHOLDER_property', property]]),
+            links: [],
+        };
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getKind() {
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    static fromInspectorIssue(issueModel, inspectorIssue) {
+        const propertyRuleIssueDetails = inspectorIssue.details.propertyRuleIssueDetails;
+        if (!propertyRuleIssueDetails) {
+            console.warn('Property rule issue without details received');
+            return [];
+        }
+        return [new PropertyRuleIssue(propertyRuleIssueDetails, issueModel)];
+    }
+}

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

@@ -0,0 +1,48 @@
+// 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';
+const UIStrings = {
+    /**
+     * @description Link title for the Quirks Mode issue in the Issues panel
+     */
+    documentCompatibilityMode: 'Document compatibility mode',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/QuirksModeIssue.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class QuirksModeIssue extends Issue {
+    constructor(issueDetails, issuesModel) {
+        const mode = issueDetails.isLimitedQuirksMode ? 'LimitedQuirksMode' : 'QuirksMode';
+        const umaCode = ["QuirksModeIssue" /* Protocol.Audits.InspectorIssueCode.QuirksModeIssue */, mode].join('::');
+        super({ code: "QuirksModeIssue" /* Protocol.Audits.InspectorIssueCode.QuirksModeIssue */, umaCode }, issueDetails, issuesModel);
+    }
+    primaryKey() {
+        return `${this.code()}-(${this.details().documentNodeId})-(${this.details().url})`;
+    }
+    getCategory() {
+        return "QuirksMode" /* IssueCategory.QUIRKS_MODE */;
+    }
+    getDescription() {
+        return {
+            file: 'CompatibilityModeQuirks.md',
+            links: [
+                {
+                    link: 'https://web.dev/doctype/',
+                    linkTitle: i18nString(UIStrings.documentCompatibilityMode),
+                },
+            ],
+        };
+    }
+    getKind() {
+        return "Improvement" /* IssueKind.IMPROVEMENT */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const quirksModeIssueDetails = inspectorIssue.details.quirksModeIssueDetails;
+        if (!quirksModeIssueDetails) {
+            console.warn('Quirks Mode issue without details received.');
+            return [];
+        }
+        return [new QuirksModeIssue(quirksModeIssueDetails, issuesModel)];
+    }
+}

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

@@ -0,0 +1,70 @@
+// 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 SDK from '../../core/sdk/sdk.js';
+import { CookieIssue } from './CookieIssue.js';
+import { IssuesManager } from './IssuesManager.js';
+function issuesAssociatedWithNetworkRequest(issues, request) {
+    return issues.filter(issue => {
+        for (const affectedRequest of issue.requests()) {
+            if (affectedRequest.requestId === request.requestId()) {
+                return true;
+            }
+        }
+        return false;
+    });
+}
+function issuesAssociatedWithCookie(issues, domain, name, path) {
+    return issues.filter(issue => {
+        for (const cookie of issue.cookies()) {
+            if (cookie.domain === domain && cookie.name === name && cookie.path === path) {
+                return true;
+            }
+        }
+        return false;
+    });
+}
+/**
+ * @throws In case obj has an unsupported type (i.e. not part of the IssuesAssociatble union).
+ */
+export function issuesAssociatedWith(issues, obj) {
+    if (obj instanceof SDK.NetworkRequest.NetworkRequest) {
+        return issuesAssociatedWithNetworkRequest(issues, obj);
+    }
+    if (obj instanceof SDK.Cookie.Cookie) {
+        return issuesAssociatedWithCookie(issues, obj.domain(), obj.name(), obj.path());
+    }
+    throw new Error(`issues can not be associated with ${JSON.stringify(obj)}`);
+}
+export function hasIssues(obj) {
+    const issues = Array.from(IssuesManager.instance().issues());
+    return issuesAssociatedWith(issues, obj).length > 0;
+}
+export function hasIssueOfCategory(obj, category) {
+    const issues = Array.from(IssuesManager.instance().issues());
+    return issuesAssociatedWith(issues, obj).some(issue => issue.getCategory() === category);
+}
+export function hasThirdPartyPhaseoutCookieIssue(obj) {
+    const issues = Array.from(IssuesManager.instance().issues());
+    return issuesAssociatedWith(issues, obj)
+        .some(issue => CookieIssue.getSubCategory(issue.code()) === "ThirdPartyPhaseoutCookie" /* CookieIssueSubCategory.THIRD_PARTY_PHASEOUT_COOKIE */);
+}
+export function hasThirdPartyPhaseoutCookieIssueForDomain(domain) {
+    const issues = Array.from(IssuesManager.instance().issues());
+    const issuesForDomain = issues.filter(issue => Array.from(issue.cookies()).some(cookie => cookie.domain === domain));
+    return issuesForDomain.some(issue => CookieIssue.getSubCategory(issue.code()) === "ThirdPartyPhaseoutCookie" /* CookieIssueSubCategory.THIRD_PARTY_PHASEOUT_COOKIE */);
+}
+export async function reveal(obj, category) {
+    if (typeof obj === 'string') {
+        const issue = IssuesManager.instance().getIssueById(obj);
+        if (issue) {
+            return await Common.Revealer.reveal(issue);
+        }
+    }
+    const issues = Array.from(IssuesManager.instance().issues());
+    const candidates = issuesAssociatedWith(issues, obj).filter(issue => !category || issue.getCategory() === category);
+    if (candidates.length > 0) {
+        return await Common.Revealer.reveal(candidates[0]);
+    }
+}

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

@@ -0,0 +1,87 @@
+// 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 Message Signatures specification url
+     */
+    httpMessageSignatures: 'HTTP Message Signatures (RFC9421)',
+    /**
+     * @description Title for Signature-based Integrity specification url
+     */
+    signatureBasedIntegrity: 'Signature-based Integrity',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/SRIMessageSignatureIssue.ts', UIStrings);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+function generateGroupingIssueCode(details) {
+    const issueCode = `${"SRIMessageSignatureIssue" /* Protocol.Audits.InspectorIssueCode.SRIMessageSignatureIssue */}::${details.error}`;
+    if (details.error === "ValidationFailedSignatureMismatch" /* Protocol.Audits.SRIMessageSignatureError.ValidationFailedSignatureMismatch */) {
+        // Signature mismatch errors should be grouped by "signature base".
+        return issueCode + details.signatureBase;
+    }
+    if (details.error === "ValidationFailedIntegrityMismatch" /* Protocol.Audits.SRIMessageSignatureError.ValidationFailedIntegrityMismatch */) {
+        // Integrity mismatch errors should be grouped by integrity assertion.
+        return issueCode + details.integrityAssertions.join();
+    }
+    // Otherwise, simply group by issue type:
+    return issueCode;
+}
+export class SRIMessageSignatureIssue extends Issue {
+    constructor(issueDetails, issuesModel) {
+        super({
+            code: generateGroupingIssueCode(issueDetails),
+            umaCode: `${"SRIMessageSignatureIssue" /* Protocol.Audits.InspectorIssueCode.SRIMessageSignatureIssue */}::${issueDetails.error}`,
+        }, issueDetails, issuesModel);
+    }
+    // Overriding `Issue<String>`:
+    primaryKey() {
+        return JSON.stringify(this.details());
+    }
+    getDescription() {
+        const details = this.details();
+        const description = {
+            file: `sri${details.error}.md`,
+            links: [
+                {
+                    link: 'https://www.rfc-editor.org/rfc/rfc9421.html',
+                    linkTitle: i18nLazyString(UIStrings.httpMessageSignatures),
+                },
+                {
+                    link: 'https://wicg.github.io/signature-based-sri/',
+                    linkTitle: i18nLazyString(UIStrings.signatureBasedIntegrity),
+                }
+            ],
+            substitutions: new Map()
+        };
+        if (details.error === "ValidationFailedSignatureMismatch" /* Protocol.Audits.SRIMessageSignatureError.ValidationFailedSignatureMismatch */) {
+            description.substitutions?.set('PLACEHOLDER_signatureBase', () => details.signatureBase);
+        }
+        if (details.error === "ValidationFailedIntegrityMismatch" /* Protocol.Audits.SRIMessageSignatureError.ValidationFailedIntegrityMismatch */) {
+            description.substitutions?.set('PLACEHOLDER_integrityAssertions', () => {
+                const prefix = '\n* ';
+                return prefix + this.details().integrityAssertions.join(prefix);
+            });
+        }
+        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.sriMessageSignatureIssueDetails;
+        if (!details) {
+            console.warn('SRI Message Signature issue without details received.');
+            return [];
+        }
+        return [new SRIMessageSignatureIssue(details, issuesModel)];
+    }
+}

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

@@ -0,0 +1,49 @@
+// 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';
+const UIStrings = {
+    /**
+     * @description Label for the link for SharedArrayBuffer Issues. The full text reads "Enabling `SharedArrayBuffer`"
+     * and is the title of an article that describes how to enable a JavaScript feature called SharedArrayBuffer.
+     */
+    enablingSharedArrayBuffer: 'Enabling `SharedArrayBuffer`',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/SharedArrayBufferIssue.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class SharedArrayBufferIssue extends Issue {
+    constructor(issueDetails, issuesModel) {
+        const umaCode = ["SharedArrayBufferIssue" /* Protocol.Audits.InspectorIssueCode.SharedArrayBufferIssue */, issueDetails.type].join('::');
+        super({ code: "SharedArrayBufferIssue" /* Protocol.Audits.InspectorIssueCode.SharedArrayBufferIssue */, umaCode }, issueDetails, issuesModel);
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getDescription() {
+        return {
+            file: 'sharedArrayBuffer.md',
+            links: [{
+                    link: 'https://developer.chrome.com/blog/enabling-shared-array-buffer/',
+                    linkTitle: i18nString(UIStrings.enablingSharedArrayBuffer),
+                }],
+        };
+    }
+    primaryKey() {
+        return JSON.stringify(this.details());
+    }
+    getKind() {
+        if (this.details().isWarning) {
+            return "BreakingChange" /* IssueKind.BREAKING_CHANGE */;
+        }
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const sabIssueDetails = inspectorIssue.details.sharedArrayBufferIssueDetails;
+        if (!sabIssueDetails) {
+            console.warn('SAB transfer issue without details received.');
+            return [];
+        }
+        return [new SharedArrayBufferIssue(sabIssueDetails, issuesModel)];
+    }
+}

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

@@ -0,0 +1,292 @@
+// 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 {
+    constructor(issueDetails, issuesModel) {
+        super({
+            code: getIssueCode(issueDetails),
+            umaCode: [
+                "SharedDictionaryIssue" /* Protocol.Audits.InspectorIssueCode.SharedDictionaryIssue */,
+                issueDetails.sharedDictionaryError,
+            ].join('::'),
+        }, issueDetails, issuesModel);
+    }
+    requests() {
+        if (this.details().request) {
+            return [this.details().request];
+        }
+        return [];
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getDescription() {
+        const description = issueDescriptions.get(this.details().sharedDictionaryError);
+        if (!description) {
+            return null;
+        }
+        return resolveLazyDescription(description);
+    }
+    primaryKey() {
+        return JSON.stringify(this.details());
+    }
+    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,
+        },
+    ],
+]);