lighthouse 9.6.7 → 10.0.0

package/core/lib/cdt/generated/SourceMap.js

@@ -0,0 +1,527 @@
+// @ts-nocheck
+// generated by yarn build-cdt-lib
+/* eslint-disable */
+"use strict";
+const Common = require('../Common.js');
+const Platform = require('../Platform.js');
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextSourceMap = exports.SourceMapEntry = exports.Offset = exports.Section = exports.SourceMapV3 = void 0;
+/*
+ * Copyright (C) 2012 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the #name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+;
+;
+;
+;
+;
+;
+;
+;
+;
+class SourceMapV3 {
+    version;
+    file;
+    sources;
+    sections;
+    mappings;
+    sourceRoot;
+    names;
+    sourcesContent;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    x_google_ignoreList;
+    constructor() {
+    }
+}
+exports.SourceMapV3 = SourceMapV3;
+class Section {
+    map;
+    offset;
+    url;
+    constructor() {
+    }
+}
+exports.Section = Section;
+class Offset {
+    line;
+    column;
+    constructor() {
+    }
+}
+exports.Offset = Offset;
+class SourceMapEntry {
+    lineNumber;
+    columnNumber;
+    sourceURL;
+    sourceLineNumber;
+    sourceColumnNumber;
+    name;
+    constructor(lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber, name) {
+        this.lineNumber = lineNumber;
+        this.columnNumber = columnNumber;
+        this.sourceURL = sourceURL;
+        this.sourceLineNumber = sourceLineNumber;
+        this.sourceColumnNumber = sourceColumnNumber;
+        this.name = name;
+    }
+    static compare(entry1, entry2) {
+        if (entry1.lineNumber !== entry2.lineNumber) {
+            return entry1.lineNumber - entry2.lineNumber;
+        }
+        return entry1.columnNumber - entry2.columnNumber;
+    }
+}
+exports.SourceMapEntry = SourceMapEntry;
+const base64Digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const base64Map = new Map();
+for (let i = 0; i < base64Digits.length; ++i) {
+    base64Map.set(base64Digits.charAt(i), i);
+}
+const sourceMapToSourceList = new WeakMap();
+class TextSourceMap {
+    #initiator;
+    #json;
+    #compiledURLInternal;
+    #sourceMappingURL;
+    #baseURL;
+    #mappingsInternal;
+    #sourceInfos;
+    /**
+     * Implements Source Map V3 model. See https://github.com/google/closure-compiler/wiki/Source-Maps
+     * for format description.
+     */
+    constructor(compiledURL, sourceMappingURL, payload, initiator) {
+        this.#initiator = initiator;
+        this.#json = payload;
+        this.#compiledURLInternal = compiledURL;
+        this.#sourceMappingURL = sourceMappingURL;
+        this.#baseURL = (sourceMappingURL.startsWith('data:') ? compiledURL : sourceMappingURL);
+        this.#mappingsInternal = null;
+        this.#sourceInfos = new Map();
+        if (this.#json.sections) {
+            const sectionWithURL = Boolean(this.#json.sections.find(section => Boolean(section.url)));
+            if (sectionWithURL) {
+                console.warn(`SourceMap "${sourceMappingURL}" contains unsupported "URL" field in one of its sections.`);
+            }
+        }
+        this.eachSection(this.parseSources.bind(this));
+    }
+    compiledURL() {
+        return this.#compiledURLInternal;
+    }
+    url() {
+        return this.#sourceMappingURL;
+    }
+    sourceURLs() {
+        return [...this.#sourceInfos.keys()];
+    }
+    embeddedContentByURL(sourceURL) {
+        const entry = this.#sourceInfos.get(sourceURL);
+        if (!entry) {
+            return null;
+        }
+        return entry.content;
+    }
+    findEntry(lineNumber, columnNumber) {
+        const mappings = this.mappings();
+        const index = Platform.ArrayUtilities.upperBound(mappings, undefined, (unused, entry) => lineNumber - entry.lineNumber || columnNumber - entry.columnNumber);
+        return index ? mappings[index - 1] : null;
+    }
+    findEntryRanges(lineNumber, columnNumber) {
+        const mappings = this.mappings();
+        const endIndex = Platform.ArrayUtilities.upperBound(mappings, undefined, (unused, entry) => lineNumber - entry.lineNumber || columnNumber - entry.columnNumber);
+        if (!endIndex) {
+            // If the line and column are preceding all the entries, then there is nothing to map.
+            return null;
+        }
+        // startIndex must be within mappings range because endIndex must be not falsy
+        const startIndex = endIndex - 1;
+        const sourceURL = mappings[startIndex].sourceURL;
+        if (!sourceURL) {
+            return null;
+        }
+        // Let us compute the range that contains the source position in the compiled code.
+        const endLine = endIndex < mappings.length ? mappings[endIndex].lineNumber : 2 ** 31 - 1;
+        const endColumn = endIndex < mappings.length ? mappings[endIndex].columnNumber : 2 ** 31 - 1;
+        const range = new TextUtils.TextRange.TextRange(mappings[startIndex].lineNumber, mappings[startIndex].columnNumber, endLine, endColumn);
+        // Now try to find the corresponding token in the original code.
+        const reverseMappings = this.reversedMappings(sourceURL);
+        const startSourceLine = mappings[startIndex].sourceLineNumber;
+        const startSourceColumn = mappings[startIndex].sourceColumnNumber;
+        const endReverseIndex = Platform.ArrayUtilities.upperBound(reverseMappings, undefined, (unused, i) => startSourceLine - mappings[i].sourceLineNumber || startSourceColumn - mappings[i].sourceColumnNumber);
+        if (!endReverseIndex) {
+            return null;
+        }
+        const endSourceLine = endReverseIndex < reverseMappings.length ?
+            mappings[reverseMappings[endReverseIndex]].sourceLineNumber :
+            2 ** 31 - 1;
+        const endSourceColumn = endReverseIndex < reverseMappings.length ?
+            mappings[reverseMappings[endReverseIndex]].sourceColumnNumber :
+            2 ** 31 - 1;
+        const sourceRange = new TextUtils.TextRange.TextRange(startSourceLine, startSourceColumn, endSourceLine, endSourceColumn);
+        return { range, sourceRange, sourceURL };
+    }
+    sourceLineMapping(sourceURL, lineNumber, columnNumber) {
+        const mappings = this.mappings();
+        const reverseMappings = this.reversedMappings(sourceURL);
+        const first = Platform.ArrayUtilities.lowerBound(reverseMappings, lineNumber, lineComparator);
+        const last = Platform.ArrayUtilities.upperBound(reverseMappings, lineNumber, lineComparator);
+        if (first >= reverseMappings.length || mappings[reverseMappings[first]].sourceLineNumber !== lineNumber) {
+            return null;
+        }
+        const columnMappings = reverseMappings.slice(first, last);
+        if (!columnMappings.length) {
+            return null;
+        }
+        const index = Platform.ArrayUtilities.lowerBound(columnMappings, columnNumber, (columnNumber, i) => columnNumber - mappings[i].sourceColumnNumber);
+        return index >= columnMappings.length ? mappings[columnMappings[columnMappings.length - 1]] :
+            mappings[columnMappings[index]];
+        function lineComparator(lineNumber, i) {
+            return lineNumber - mappings[i].sourceLineNumber;
+        }
+    }
+    findReverseIndices(sourceURL, lineNumber, columnNumber) {
+        const mappings = this.mappings();
+        const reverseMappings = this.reversedMappings(sourceURL);
+        const endIndex = Platform.ArrayUtilities.upperBound(reverseMappings, undefined, (unused, i) => lineNumber - mappings[i].sourceLineNumber || columnNumber - mappings[i].sourceColumnNumber);
+        let startIndex = endIndex;
+        while (startIndex > 0 &&
+            mappings[reverseMappings[startIndex - 1]].sourceLineNumber ===
+                mappings[reverseMappings[endIndex - 1]].sourceLineNumber &&
+            mappings[reverseMappings[startIndex - 1]].sourceColumnNumber ===
+                mappings[reverseMappings[endIndex - 1]].sourceColumnNumber) {
+            --startIndex;
+        }
+        return reverseMappings.slice(startIndex, endIndex);
+    }
+    findReverseEntries(sourceURL, lineNumber, columnNumber) {
+        const mappings = this.mappings();
+        return this.findReverseIndices(sourceURL, lineNumber, columnNumber).map(i => mappings[i]);
+    }
+    findReverseRanges(sourceURL, lineNumber, columnNumber) {
+        const mappings = this.mappings();
+        const indices = this.findReverseIndices(sourceURL, lineNumber, columnNumber);
+        const ranges = [];
+        for (let i = 0; i < indices.length; ++i) {
+            const startIndex = indices[i];
+            // Merge adjacent ranges.
+            let endIndex = startIndex + 1;
+            while (i + 1 < indices.length && endIndex === indices[i + 1]) {
+                ++endIndex;
+                ++i;
+            }
+            // Source maps don't contain end positions for entries, but each entry is assumed to
+            // span until the following entry. This doesn't work however in case of the last
+            // entry, where there's no following entry. We also don't know the number of lines
+            // and columns in the original source code (which might not be available at all), so
+            // for that case we store the maximum signed 32-bit integer, which is definitely going
+            // to be larger than any script we can process and can safely be serialized as part of
+            // the skip list we send to V8 with `Debugger.stepOver` (http://crbug.com/1305956).
+            const startLine = mappings[startIndex].lineNumber;
+            const startColumn = mappings[startIndex].columnNumber;
+            const endLine = endIndex < mappings.length ? mappings[endIndex].lineNumber : 2 ** 31 - 1;
+            const endColumn = endIndex < mappings.length ? mappings[endIndex].columnNumber : 2 ** 31 - 1;
+            ranges.push(new TextUtils.TextRange.TextRange(startLine, startColumn, endLine, endColumn));
+        }
+        return ranges;
+    }
+    /** @return {Array<{lineNumber: number, columnNumber: number, sourceURL?: string, sourceLineNumber: number, sourceColumnNumber: number, name?: string, lastColumnNumber?: number}>} */
+    mappings() {
+        this.#ensureMappingsProcessed();
+        return this.#mappingsInternal ?? [];
+    }
+    reversedMappings(sourceURL) {
+        this.#ensureMappingsProcessed();
+        return this.#sourceInfos.get(sourceURL)?.reverseMappings ?? [];
+    }
+    #ensureMappingsProcessed() {
+        if (this.#mappingsInternal === null) {
+            this.#mappingsInternal = [];
+            this.eachSection(this.parseMap.bind(this));
+            this.#computeReverseMappings(this.#mappingsInternal);
+            this.#json = null;
+        }
+    }
+    #computeReverseMappings(mappings) {
+        const reverseMappingsPerUrl = new Map();
+        for (let i = 0; i < mappings.length; i++) {
+            const entryUrl = mappings[i].sourceURL;
+            if (!entryUrl) {
+                continue;
+            }
+            let reverseMap = reverseMappingsPerUrl.get(entryUrl);
+            if (!reverseMap) {
+                reverseMap = [];
+                reverseMappingsPerUrl.set(entryUrl, reverseMap);
+            }
+            reverseMap.push(i);
+        }
+        for (const [url, reverseMap] of reverseMappingsPerUrl.entries()) {
+            const info = this.#sourceInfos.get(url);
+            if (!info) {
+                continue;
+            }
+            reverseMap.sort(sourceMappingComparator);
+            info.reverseMappings = reverseMap;
+        }
+        function sourceMappingComparator(indexA, indexB) {
+            const a = mappings[indexA];
+            const b = mappings[indexB];
+            return a.sourceLineNumber - b.sourceLineNumber || a.sourceColumnNumber - b.sourceColumnNumber ||
+                a.lineNumber - b.lineNumber || a.columnNumber - b.columnNumber;
+        }
+    }
+    eachSection(callback) {
+        if (!this.#json) {
+            return;
+        }
+        if (!this.#json.sections) {
+            callback(this.#json, 0, 0);
+            return;
+        }
+        for (const section of this.#json.sections) {
+            callback(section.map, section.offset.line, section.offset.column);
+        }
+    }
+    parseSources(sourceMap) {
+        const sourcesList = [];
+        const sourceRoot = sourceMap.sourceRoot || Platform.DevToolsPath.EmptyUrlString;
+        const ignoreList = new Set(sourceMap.x_google_ignoreList);
+        for (let i = 0; i < sourceMap.sources.length; ++i) {
+            let href = sourceMap.sources[i];
+            // The source map v3 proposal says to prepend the sourceRoot to the source URL
+            // and if the resulting URL is not absolute, then resolve the source URL against
+            // the source map URL. Appending the sourceRoot (if one exists) is not likely to
+            // be meaningful or useful if the source URL is already absolute though. In this
+            // case, use the source URL as is without prepending the sourceRoot.
+            if (Common.ParsedURL.ParsedURL.isRelativeURL(href)) {
+                if (sourceRoot && !sourceRoot.endsWith('/') && href && !href.startsWith('/')) {
+                    href = Common.ParsedURL.ParsedURL.concatenate(sourceRoot, '/', href);
+                }
+                else {
+                    href = Common.ParsedURL.ParsedURL.concatenate(sourceRoot, href);
+                }
+            }
+            let url = '' || href;
+            const source = sourceMap.sourcesContent && sourceMap.sourcesContent[i];
+            if (url === this.#compiledURLInternal && source) {
+            }
+            sourcesList.push(url);
+            if (!this.#sourceInfos.has(url)) {
+                const content = source ?? null;
+                const ignoreListHint = ignoreList.has(i);
+                this.#sourceInfos.set(url, new TextSourceMap.SourceInfo(content, ignoreListHint));
+            }
+        }
+        sourceMapToSourceList.set(sourceMap, sourcesList);
+    }
+    parseMap(map, lineNumber, columnNumber) {
+        let sourceIndex = 0;
+        let sourceLineNumber = 0;
+        let sourceColumnNumber = 0;
+        let nameIndex = 0;
+        // TODO(crbug.com/1011811): refactor away map.
+        // `sources` can be undefined if it wasn't previously
+        // processed and added to the list. However, that
+        // is not WAI and we should make sure that we can
+        // only reach this point when we are certain
+        // we have the list available.
+        const sources = sourceMapToSourceList.get(map);
+        const names = map.names || [];
+        const stringCharIterator = new TextSourceMap.StringCharIterator(map.mappings);
+        let sourceURL = sources && sources[sourceIndex];
+        while (true) {
+            if (stringCharIterator.peek() === ',') {
+                stringCharIterator.next();
+            }
+            else {
+                while (stringCharIterator.peek() === ';') {
+                    lineNumber += 1;
+                    columnNumber = 0;
+                    stringCharIterator.next();
+                }
+                if (!stringCharIterator.hasNext()) {
+                    break;
+                }
+            }
+            columnNumber += this.decodeVLQ(stringCharIterator);
+            if (!stringCharIterator.hasNext() || this.isSeparator(stringCharIterator.peek())) {
+                this.mappings().push(new SourceMapEntry(lineNumber, columnNumber));
+                continue;
+            }
+            const sourceIndexDelta = this.decodeVLQ(stringCharIterator);
+            if (sourceIndexDelta) {
+                sourceIndex += sourceIndexDelta;
+                if (sources) {
+                    sourceURL = sources[sourceIndex];
+                }
+            }
+            sourceLineNumber += this.decodeVLQ(stringCharIterator);
+            sourceColumnNumber += this.decodeVLQ(stringCharIterator);
+            if (!stringCharIterator.hasNext() || this.isSeparator(stringCharIterator.peek())) {
+                this.mappings().push(new SourceMapEntry(lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber));
+                continue;
+            }
+            nameIndex += this.decodeVLQ(stringCharIterator);
+            this.mappings().push(new SourceMapEntry(lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber, names[nameIndex]));
+        }
+        // As per spec, mappings are not necessarily sorted.
+        this.mappings().sort(SourceMapEntry.compare);
+    }
+    isSeparator(char) {
+        return char === ',' || char === ';';
+    }
+    decodeVLQ(stringCharIterator) {
+        // Read unsigned value.
+        let result = 0;
+        let shift = 0;
+        let digit = TextSourceMap._VLQ_CONTINUATION_MASK;
+        while (digit & TextSourceMap._VLQ_CONTINUATION_MASK) {
+            digit = base64Map.get(stringCharIterator.next()) || 0;
+            result += (digit & TextSourceMap._VLQ_BASE_MASK) << shift;
+            shift += TextSourceMap._VLQ_BASE_SHIFT;
+        }
+        // Fix the sign.
+        const negative = result & 1;
+        result >>= 1;
+        return negative ? -result : result;
+    }
+    reverseMapTextRange(url, textRange) {
+        function comparator(position, mappingIndex) {
+            if (position.lineNumber !== mappings[mappingIndex].sourceLineNumber) {
+                return position.lineNumber - mappings[mappingIndex].sourceLineNumber;
+            }
+            return position.columnNumber - mappings[mappingIndex].sourceColumnNumber;
+        }
+        const reverseMappings = this.reversedMappings(url);
+        const mappings = this.mappings();
+        if (!reverseMappings.length) {
+            return null;
+        }
+        const startIndex = Platform.ArrayUtilities.lowerBound(reverseMappings, { lineNumber: textRange.startLine, columnNumber: textRange.startColumn }, comparator);
+        const endIndex = Platform.ArrayUtilities.upperBound(reverseMappings, { lineNumber: textRange.endLine, columnNumber: textRange.endColumn }, comparator);
+        if (endIndex >= reverseMappings.length) {
+            return null;
+        }
+        const startMapping = mappings[reverseMappings[startIndex]];
+        const endMapping = mappings[reverseMappings[endIndex]];
+        return new TextUtils.TextRange.TextRange(startMapping.lineNumber, startMapping.columnNumber, endMapping.lineNumber, endMapping.columnNumber);
+    }
+    mapsOrigin() {
+        const mappings = this.mappings();
+        if (mappings.length > 0) {
+            const firstEntry = mappings[0];
+            return firstEntry?.lineNumber === 0 || firstEntry.columnNumber === 0;
+        }
+        return false;
+    }
+    hasIgnoreListHint(sourceURL) {
+        return this.#sourceInfos.get(sourceURL)?.ignoreListHint ?? false;
+    }
+    /**
+     * Returns a list of ranges in the generated script for original sources that
+     * match a predicate. Each range is a [begin, end) pair, meaning that code at
+     * the beginning location, up to but not including the end location, matches
+     * the predicate.
+     */
+    findRanges(predicate, options) {
+        const mappings = this.mappings();
+        const ranges = [];
+        if (!mappings.length) {
+            return [];
+        }
+        let current = null;
+        // If the first mapping isn't at the beginning of the original source, it's
+        // up to the caller to decide if it should be considered matching the
+        // predicate or not. By default, it's not.
+        if ((mappings[0].lineNumber !== 0 || mappings[0].columnNumber !== 0) && options?.isStartMatching) {
+            current = TextUtils.TextRange.TextRange.createUnboundedFromLocation(0, 0);
+            ranges.push(current);
+        }
+        for (const { sourceURL, lineNumber, columnNumber } of mappings) {
+            const ignoreListHint = sourceURL && predicate(sourceURL);
+            if (!current && ignoreListHint) {
+                current = TextUtils.TextRange.TextRange.createUnboundedFromLocation(lineNumber, columnNumber);
+                ranges.push(current);
+                continue;
+            }
+            if (current && !ignoreListHint) {
+                current.endLine = lineNumber;
+                current.endColumn = columnNumber;
+                current = null;
+            }
+        }
+        return ranges;
+    }
+}
+exports.TextSourceMap = TextSourceMap;
+(function (TextSourceMap) {
+    // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    TextSourceMap._VLQ_BASE_SHIFT = 5;
+    // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    TextSourceMap._VLQ_BASE_MASK = (1 << 5) - 1;
+    // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    TextSourceMap._VLQ_CONTINUATION_MASK = 1 << 5;
+    class StringCharIterator {
+        string;
+        position;
+        constructor(string) {
+            this.string = string;
+            this.position = 0;
+        }
+        next() {
+            return this.string.charAt(this.position++);
+        }
+        peek() {
+            return this.string.charAt(this.position);
+        }
+        hasNext() {
+            return this.position < this.string.length;
+        }
+    }
+    TextSourceMap.StringCharIterator = StringCharIterator;
+    class SourceInfo {
+        content;
+        ignoreListHint;
+        reverseMappings = null;
+        constructor(content, ignoreListHint) {
+            this.content = content;
+            this.ignoreListHint = ignoreListHint;
+        }
+    }
+    TextSourceMap.SourceInfo = SourceInfo;
+})(TextSourceMap = exports.TextSourceMap || (exports.TextSourceMap = {}));
+
+
+module.exports = TextSourceMap;

package/core/lib/cdt/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "//": "Temporary file until made esm"
+}

package/core/lib/csp-evaluator.d.ts

@@ -0,0 +1,41 @@
+export type Finding = import('csp_evaluator/finding').Finding;
+/**
+ * @param {Finding} finding
+ * @return {LH.IcuMessage|string}
+ */
+export function getTranslatedDescription(finding: Finding): LH.IcuMessage | string;
+/**
+ * @param {string[]} rawCsps
+ * @return {{bypasses: Finding[], warnings: Finding[], syntax: Finding[][]}}
+ */
+export function evaluateRawCspsForXss(rawCsps: string[]): {
+    bypasses: Finding[];
+    warnings: Finding[];
+    syntax: Finding[][];
+};
+/**
+ * @param {string} rawCsp
+ */
+export function parseCsp(rawCsp: string): import("csp_evaluator/dist/csp.js").Csp;
+export namespace UIStrings {
+    const missingBaseUri: string;
+    const missingScriptSrc: string;
+    const missingObjectSrc: string;
+    const strictDynamic: string;
+    const unsafeInline: string;
+    const unsafeInlineFallback: string;
+    const allowlistFallback: string;
+    const reportToOnly: string;
+    const reportingDestinationMissing: string;
+    const nonceLength: string;
+    const nonceCharset: string;
+    const missingSemicolon: string;
+    const unknownDirective: string;
+    const unknownKeyword: string;
+    const deprecatedReflectedXSS: string;
+    const deprecatedReferrer: string;
+    const deprecatedDisownOpener: string;
+    const plainWildcards: string;
+    const plainUrlScheme: string;
+}
+//# sourceMappingURL=csp-evaluator.d.ts.map