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

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/source-map-scopes-codec/package/src/encode/encoder.js

@@ -0,0 +1,283 @@
+// Copyright 2025 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.
+import { encodeSigned, encodeUnsigned } from "../vlq.js";
+import { comparePositions } from "../util.js";
+const DEFAULT_SCOPE_STATE = {
+    line: 0,
+    column: 0,
+    name: 0,
+    kind: 0,
+    variable: 0,
+};
+const DEFAULT_RANGE_STATE = {
+    line: 0,
+    column: 0,
+    defScopeIdx: 0,
+};
+export class Encoder {
+    #info;
+    #names;
+    // Hash map to resolve indices of strings in the "names" array. Otherwise we'd have
+    // to use 'indexOf' for every name we want to encode.
+    #namesToIndex = new Map();
+    #scopeState = { ...DEFAULT_SCOPE_STATE };
+    #rangeState = { ...DEFAULT_RANGE_STATE };
+    #encodedItems = [];
+    #currentItem = "";
+    #scopeToCount = new Map();
+    #scopeCounter = 0;
+    constructor(info, names) {
+        this.#info = info;
+        this.#names = names;
+        for (let i = 0; i < names.length; ++i) {
+            this.#namesToIndex.set(names[i], i);
+        }
+    }
+    encode() {
+        this.#encodedItems = [];
+        this.#info.scopes.forEach((scope) => {
+            this.#scopeState.line = 0;
+            this.#scopeState.column = 0;
+            this.#encodeOriginalScope(scope);
+        });
+        this.#info.ranges.forEach((range) => {
+            this.#encodeGeneratedRange(range);
+        });
+        return this.#encodedItems.join(",");
+    }
+    #encodeOriginalScope(scope) {
+        if (scope === null) {
+            this.#encodedItems.push("");
+            return;
+        }
+        this.#encodeOriginalScopeStart(scope);
+        this.#encodeOriginalScopeVariables(scope);
+        scope.children.forEach((child) => this.#encodeOriginalScope(child));
+        this.#encodeOriginalScopeEnd(scope);
+    }
+    #encodeOriginalScopeStart(scope) {
+        const { line, column } = scope.start;
+        this.#verifyPositionWithScopeState(line, column);
+        let flags = 0;
+        const encodedLine = line - this.#scopeState.line;
+        const encodedColumn = encodedLine === 0
+            ? column - this.#scopeState.column
+            : column;
+        this.#scopeState.line = line;
+        this.#scopeState.column = column;
+        let encodedName;
+        if (scope.name !== undefined) {
+            flags |= 1 /* OriginalScopeFlags.HAS_NAME */;
+            const nameIdx = this.#resolveNamesIdx(scope.name);
+            encodedName = nameIdx - this.#scopeState.name;
+            this.#scopeState.name = nameIdx;
+        }
+        let encodedKind;
+        if (scope.kind !== undefined) {
+            flags |= 2 /* OriginalScopeFlags.HAS_KIND */;
+            const kindIdx = this.#resolveNamesIdx(scope.kind);
+            encodedKind = kindIdx - this.#scopeState.kind;
+            this.#scopeState.kind = kindIdx;
+        }
+        if (scope.isStackFrame)
+            flags |= 4 /* OriginalScopeFlags.IS_STACK_FRAME */;
+        this.#encodeTag("B" /* EncodedTag.ORIGINAL_SCOPE_START */).#encodeUnsigned(flags)
+            .#encodeUnsigned(encodedLine).#encodeUnsigned(encodedColumn);
+        if (encodedName !== undefined)
+            this.#encodeSigned(encodedName);
+        if (encodedKind !== undefined)
+            this.#encodeSigned(encodedKind);
+        this.#finishItem();
+        this.#scopeToCount.set(scope, this.#scopeCounter++);
+    }
+    #encodeOriginalScopeVariables(scope) {
+        if (scope.variables.length === 0)
+            return;
+        this.#encodeTag("D" /* EncodedTag.ORIGINAL_SCOPE_VARIABLES */);
+        for (const variable of scope.variables) {
+            const idx = this.#resolveNamesIdx(variable);
+            this.#encodeSigned(idx - this.#scopeState.variable);
+            this.#scopeState.variable = idx;
+        }
+        this.#finishItem();
+    }
+    #encodeOriginalScopeEnd(scope) {
+        const { line, column } = scope.end;
+        this.#verifyPositionWithScopeState(line, column);
+        const encodedLine = line - this.#scopeState.line;
+        const encodedColumn = encodedLine === 0
+            ? column - this.#scopeState.column
+            : column;
+        this.#scopeState.line = line;
+        this.#scopeState.column = column;
+        this.#encodeTag("C" /* EncodedTag.ORIGINAL_SCOPE_END */).#encodeUnsigned(encodedLine)
+            .#encodeUnsigned(encodedColumn).#finishItem();
+    }
+    #encodeGeneratedRange(range) {
+        this.#encodeGeneratedRangeStart(range);
+        this.#encodeGeneratedRangeBindings(range);
+        this.#encodeGeneratedRangeSubRangeBindings(range);
+        this.#encodeGeneratedRangeCallSite(range);
+        range.children.forEach((child) => this.#encodeGeneratedRange(child));
+        this.#encodeGeneratedRangeEnd(range);
+    }
+    #encodeGeneratedRangeStart(range) {
+        const { line, column } = range.start;
+        this.#verifyPositionWithRangeState(line, column);
+        let flags = 0;
+        const encodedLine = line - this.#rangeState.line;
+        let encodedColumn = column - this.#rangeState.column;
+        if (encodedLine > 0) {
+            flags |= 1 /* GeneratedRangeFlags.HAS_LINE */;
+            encodedColumn = column;
+        }
+        this.#rangeState.line = line;
+        this.#rangeState.column = column;
+        let encodedDefinition;
+        if (range.originalScope) {
+            const definitionIdx = this.#scopeToCount.get(range.originalScope);
+            if (definitionIdx === undefined) {
+                throw new Error("Unknown OriginalScope for definition!");
+            }
+            flags |= 2 /* GeneratedRangeFlags.HAS_DEFINITION */;
+            encodedDefinition = definitionIdx - this.#rangeState.defScopeIdx;
+            this.#rangeState.defScopeIdx = definitionIdx;
+        }
+        if (range.isStackFrame)
+            flags |= 4 /* GeneratedRangeFlags.IS_STACK_FRAME */;
+        if (range.isHidden)
+            flags |= 8 /* GeneratedRangeFlags.IS_HIDDEN */;
+        this.#encodeTag("E" /* EncodedTag.GENERATED_RANGE_START */).#encodeUnsigned(flags);
+        if (encodedLine > 0)
+            this.#encodeUnsigned(encodedLine);
+        this.#encodeUnsigned(encodedColumn);
+        if (encodedDefinition !== undefined)
+            this.#encodeSigned(encodedDefinition);
+        this.#finishItem();
+    }
+    #encodeGeneratedRangeSubRangeBindings(range) {
+        if (range.values.length === 0)
+            return;
+        for (let i = 0; i < range.values.length; ++i) {
+            const value = range.values[i];
+            if (!Array.isArray(value) || value.length <= 1) {
+                continue;
+            }
+            this.#encodeTag("H" /* EncodedTag.GENERATED_RANGE_SUBRANGE_BINDING */)
+                .#encodeUnsigned(i);
+            let lastLine = range.start.line;
+            let lastColumn = range.start.column;
+            for (let j = 1; j < value.length; ++j) {
+                const subRange = value[j];
+                const prevSubRange = value[j - 1];
+                if (comparePositions(prevSubRange.to, subRange.from) !== 0) {
+                    throw new Error("Sub-range bindings must not have gaps");
+                }
+                const encodedLine = subRange.from.line - lastLine;
+                const encodedColumn = encodedLine === 0
+                    ? subRange.from.column - lastColumn
+                    : subRange.from.column;
+                if (encodedLine < 0 || encodedColumn < 0) {
+                    throw new Error("Sub-range bindings must be sorted");
+                }
+                lastLine = subRange.from.line;
+                lastColumn = subRange.from.column;
+                const binding = subRange.value === undefined
+                    ? 0
+                    : this.#resolveNamesIdx(subRange.value) + 1;
+                this.#encodeUnsigned(binding).#encodeUnsigned(encodedLine)
+                    .#encodeUnsigned(encodedColumn);
+            }
+            this.#finishItem();
+        }
+    }
+    #encodeGeneratedRangeBindings(range) {
+        if (range.values.length === 0)
+            return;
+        if (!range.originalScope) {
+            throw new Error("Range has binding expressions but no OriginalScope");
+        }
+        else if (range.originalScope.variables.length !== range.values.length) {
+            throw new Error("Range's binding expressions don't match OriginalScopes' variables");
+        }
+        this.#encodeTag("G" /* EncodedTag.GENERATED_RANGE_BINDINGS */);
+        for (const val of range.values) {
+            if (val === null || val === undefined) {
+                this.#encodeUnsigned(0);
+            }
+            else if (typeof val === "string") {
+                this.#encodeUnsigned(this.#resolveNamesIdx(val) + 1);
+            }
+            else {
+                const initialValue = val[0];
+                const binding = initialValue.value === undefined
+                    ? 0
+                    : this.#resolveNamesIdx(initialValue.value) + 1;
+                this.#encodeUnsigned(binding);
+            }
+        }
+        this.#finishItem();
+    }
+    #encodeGeneratedRangeCallSite(range) {
+        if (!range.callSite)
+            return;
+        const { sourceIndex, line, column } = range.callSite;
+        // TODO: Throw if stackFrame flag is set or OriginalScope index is invalid or no generated range is here.
+        this.#encodeTag("I" /* EncodedTag.GENERATED_RANGE_CALL_SITE */).#encodeUnsigned(sourceIndex).#encodeUnsigned(line).#encodeUnsigned(column).#finishItem();
+    }
+    #encodeGeneratedRangeEnd(range) {
+        const { line, column } = range.end;
+        this.#verifyPositionWithRangeState(line, column);
+        let flags = 0;
+        const encodedLine = line - this.#rangeState.line;
+        let encodedColumn = column - this.#rangeState.column;
+        if (encodedLine > 0) {
+            flags |= 1 /* GeneratedRangeFlags.HAS_LINE */;
+            encodedColumn = column;
+        }
+        this.#rangeState.line = line;
+        this.#rangeState.column = column;
+        this.#encodeTag("F" /* EncodedTag.GENERATED_RANGE_END */);
+        if (encodedLine > 0)
+            this.#encodeUnsigned(encodedLine);
+        this.#encodeUnsigned(encodedColumn).#finishItem();
+    }
+    #resolveNamesIdx(name) {
+        const index = this.#namesToIndex.get(name);
+        if (index !== undefined)
+            return index;
+        const addedIndex = this.#names.length;
+        this.#names.push(name);
+        this.#namesToIndex.set(name, addedIndex);
+        return addedIndex;
+    }
+    #verifyPositionWithScopeState(line, column) {
+        if (this.#scopeState.line > line ||
+            (this.#scopeState.line === line && this.#scopeState.column > column)) {
+            throw new Error(`Attempting to encode scope item (${line}, ${column}) that precedes the last encoded scope item (${this.#scopeState.line}, ${this.#scopeState.column})`);
+        }
+    }
+    #verifyPositionWithRangeState(line, column) {
+        if (this.#rangeState.line > line ||
+            (this.#rangeState.line === line && this.#rangeState.column > column)) {
+            throw new Error(`Attempting to encode range item that precedes the last encoded range item (${line}, ${column})`);
+        }
+    }
+    #encodeTag(tag) {
+        this.#currentItem += tag;
+        return this;
+    }
+    #encodeSigned(n) {
+        this.#currentItem += encodeSigned(n);
+        return this;
+    }
+    #encodeUnsigned(n) {
+        this.#currentItem += encodeUnsigned(n);
+        return this;
+    }
+    #finishItem() {
+        this.#encodedItems.push(this.#currentItem);
+        this.#currentItem = "";
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/source-map-scopes-codec/package/src/mod.js

@@ -0,0 +1,7 @@
+// Copyright 2025 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.
+export { encode } from "./encode/encode.js";
+export { decode } from "./decode/decode.js";
+export { ScopeInfoBuilder } from "./builder/builder.js";
+export { SafeScopeInfoBuilder } from "./builder/safe_builder.js";

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/source-map-scopes-codec/package/src/util.js

@@ -0,0 +1,9 @@
+// Copyright 2025 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.
+/**
+ * @returns A negative number iff `a` precedes `b`, 0 iff `a` and `b` are equal and a positive number iff `b` precedes `a`.
+ */
+export function comparePositions(a, b) {
+    return a.line - b.line || a.column - b.column;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/source-map-scopes-codec/package/src/vlq.js

@@ -0,0 +1,84 @@
+// Copyright 2025 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.
+/**
+ * @fileoverview
+ *
+ * VLQ implementation taken mostly verbatim from Chrome DevTools itself.
+ */
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64_CODES = new Uint8Array(123);
+for (let index = 0; index < BASE64_CHARS.length; ++index) {
+    BASE64_CODES[BASE64_CHARS.charCodeAt(index)] = index;
+}
+const VLQ_BASE_SHIFT = 5;
+const VLQ_BASE_MASK = (1 << 5) - 1;
+const VLQ_CONTINUATION_MASK = 1 << 5;
+export function encodeSigned(n) {
+    // Set the sign bit as the least significant bit.
+    n = n >= 0 ? 2 * n : 1 - 2 * n;
+    return encodeUnsigned(n);
+}
+export function encodeUnsigned(n) {
+    // Encode into a base64 run.
+    let result = "";
+    while (true) {
+        // Extract the lowest 5 bits and remove them from the number.
+        const digit = n & 0x1f;
+        n >>>= 5;
+        // Is there anything more left to encode?
+        if (n === 0) {
+            // We are done encoding, finish the run.
+            result += BASE64_CHARS[digit];
+            break;
+        }
+        else {
+            // There is still more encode, so add the digit and the continuation bit.
+            result += BASE64_CHARS[0x20 + digit];
+        }
+    }
+    return result;
+}
+export class TokenIterator {
+    #string;
+    #position;
+    constructor(string) {
+        this.#string = string;
+        this.#position = 0;
+    }
+    nextChar() {
+        return this.#string.charAt(this.#position++);
+    }
+    /** Returns the unicode value of the next character and advances the iterator  */
+    nextCharCode() {
+        return this.#string.charCodeAt(this.#position++);
+    }
+    peek() {
+        return this.#string.charAt(this.#position);
+    }
+    hasNext() {
+        return this.#position < this.#string.length;
+    }
+    nextSignedVLQ() {
+        let result = this.nextUnsignedVLQ();
+        // Fix the sign.
+        const negative = result & 1;
+        result >>>= 1;
+        return negative ? -result : result;
+    }
+    nextUnsignedVLQ() {
+        let result = 0;
+        let shift = 0;
+        let digit = 0;
+        do {
+            const charCode = this.nextCharCode();
+            digit = BASE64_CODES[charCode];
+            result += (digit & VLQ_BASE_MASK) << shift;
+            shift += VLQ_BASE_SHIFT;
+        } while (digit & VLQ_CONTINUATION_MASK);
+        return result;
+    }
+    currentChar() {
+        return this.#string.charAt(this.#position - 1);
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/source-map-scopes-codec/source-map-scopes-codec.js

@@ -0,0 +1,4 @@
+// Copyright 2025 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.
+export * from './package/src/mod.js';

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2019 Patrick Hulce
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.