@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/builder/safe_builder.js

@@ -0,0 +1,226 @@
+// 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 { comparePositions } from "../util.js";
+import { ScopeInfoBuilder } from "./builder.js";
+/**
+ * Similar to `ScopeInfoBuilder`, but with checks that scopes/ranges are well
+ * nested and don't partially overlap.
+ */
+export class SafeScopeInfoBuilder extends ScopeInfoBuilder {
+    addNullScope() {
+        this.#verifyEmptyScopeStack("add null scope");
+        this.#verifyEmptyRangeStack("add null scope");
+        super.addNullScope();
+        return this;
+    }
+    startScope(line, column, options) {
+        this.#verifyEmptyRangeStack("start scope");
+        const parent = this.scopeStack.at(-1);
+        if (parent && comparePositions(parent.start, { line, column }) > 0) {
+            throw new Error(`Scope start (${line}, ${column}) must not precede parent start (${parent.start.line}, ${parent.start.column})`);
+        }
+        const precedingSibling = parent?.children.at(-1);
+        if (precedingSibling &&
+            comparePositions(precedingSibling.end, { line, column }) > 0) {
+            throw new Error(`Scope start (${line}, ${column}) must not precede preceding siblings' end (${precedingSibling
+                .end.line,
+                precedingSibling.end.column})`);
+        }
+        super.startScope(line, column, options);
+        return this;
+    }
+    setScopeName(name) {
+        this.#verifyScopePresent("setScopeName");
+        this.#verifyEmptyRangeStack("setScopeName");
+        super.setScopeName(name);
+        return this;
+    }
+    setScopeKind(kind) {
+        this.#verifyScopePresent("setScopeKind");
+        this.#verifyEmptyRangeStack("setScopeKind");
+        super.setScopeKind(kind);
+        return this;
+    }
+    setScopeStackFrame(isStackFrame) {
+        this.#verifyScopePresent("setScopeStackFrame");
+        this.#verifyEmptyRangeStack("setScopeStackFrame");
+        super.setScopeStackFrame(isStackFrame);
+        return this;
+    }
+    setScopeVariables(variables) {
+        this.#verifyScopePresent("setScopeVariables");
+        this.#verifyEmptyRangeStack("setScopeVariables");
+        super.setScopeVariables(variables);
+        return this;
+    }
+    endScope(line, column) {
+        this.#verifyEmptyRangeStack("end scope");
+        if (this.scopeStack.length === 0) {
+            throw new Error("No scope to end");
+        }
+        const scope = this.scopeStack.at(-1);
+        if (comparePositions(scope.start, { line, column }) > 0) {
+            throw new Error(`Scope end (${line}, ${column}) must not precede scope start (${scope.start.line}, ${scope.start.column})`);
+        }
+        super.endScope(line, column);
+        return this;
+    }
+    startRange(line, column, options) {
+        this.#verifyEmptyScopeStack("starRange");
+        const parent = this.rangeStack.at(-1);
+        if (parent && comparePositions(parent.start, { line, column }) > 0) {
+            throw new Error(`Range start (${line}, ${column}) must not precede parent start (${parent.start.line}, ${parent.start.column})`);
+        }
+        const precedingSibling = parent?.children.at(-1);
+        if (precedingSibling &&
+            comparePositions(precedingSibling.end, { line, column }) > 0) {
+            throw new Error(`Range start (${line}, ${column}) must not precede preceding siblings' end (${precedingSibling
+                .end.line,
+                precedingSibling.end.column})`);
+        }
+        if (options?.scopeKey !== undefined &&
+            !this.isValidScopeKey(options.scopeKey)) {
+            throw new Error(`${options.scopeKey} does not reference a valid OriginalScope`);
+        }
+        if (options?.scope && !this.isKnownScope(options.scope)) {
+            throw new Error("The provided definition scope was not produced by this builder!");
+        }
+        if (options?.values?.length && options?.scope === undefined &&
+            options?.scopeKey === undefined) {
+            throw new Error("Provided bindings without providing an OriginalScope");
+        }
+        else if (options?.values?.length && options?.scope &&
+            options.values.length !== options.scope.variables.length) {
+            throw new Error("Provided bindings don't match up with OriginalScope.variables");
+        }
+        else if (options?.values?.length && options?.scopeKey !== undefined) {
+            const scope = this.getScopeByValidKey(options.scopeKey);
+            if (options.values.length !== scope.variables.length) {
+                throw new Error("Provided bindings don't match up with OriginalScope.variables");
+            }
+        }
+        super.startRange(line, column, options);
+        return this;
+    }
+    setRangeDefinitionScope(scope) {
+        this.#verifyEmptyScopeStack("setRangeDefinitionScope");
+        this.#verifyRangePresent("setRangeDefinitionScope");
+        if (!this.isKnownScope(scope)) {
+            throw new Error("The provided definition scope was not produced by this builder!");
+        }
+        super.setRangeDefinitionScope(scope);
+        return this;
+    }
+    setRangeDefinitionScopeKey(scopeKey) {
+        this.#verifyEmptyScopeStack("setRangeDefinitionScope");
+        this.#verifyRangePresent("setRangeDefinitionScope");
+        if (!this.isValidScopeKey(scopeKey)) {
+            throw new Error(`The provided scope key ${scopeKey} is not know nto the builder!`);
+        }
+        super.setRangeDefinitionScopeKey(scopeKey);
+        return this;
+    }
+    setRangeStackFrame(isStackFrame) {
+        this.#verifyEmptyScopeStack("setRangeStackFrame");
+        this.#verifyRangePresent("setRangeStackFrame");
+        super.setRangeStackFrame(isStackFrame);
+        return this;
+    }
+    setRangeHidden(isHidden) {
+        this.#verifyEmptyScopeStack("setRangeHidden");
+        this.#verifyRangePresent("setRangeHidden");
+        super.setRangeHidden(isHidden);
+        return this;
+    }
+    setRangeValues(values) {
+        this.#verifyEmptyScopeStack("setRangeValues");
+        this.#verifyRangePresent("setRangeValues");
+        const range = this.rangeStack.at(-1);
+        if (!range.originalScope) {
+            throw new Error("Setting an OriginalScope for a range is required before value bindings can be provided!");
+        }
+        else if (range.originalScope.variables.length !== values.length) {
+            throw new Error("Provided bindings don't match up with OriginalScope.variables");
+        }
+        super.setRangeValues(values);
+        return this;
+    }
+    setRangeCallSite(callSite) {
+        this.#verifyEmptyScopeStack("setRangeCallSite");
+        this.#verifyRangePresent("setRangeCallSite");
+        super.setRangeCallSite(callSite);
+        return this;
+    }
+    endRange(line, column) {
+        this.#verifyEmptyScopeStack("endRange");
+        if (this.rangeStack.length === 0) {
+            throw new Error("No range to end");
+        }
+        const range = this.rangeStack.at(-1);
+        if (comparePositions(range.start, { line, column }) > 0) {
+            throw new Error(`Range end (${line}, ${column}) must not precede range start (${range.start.line}, ${range.start.column})`);
+        }
+        this.#verifyRangeValues(range, { line, column });
+        super.endRange(line, column);
+        return this;
+    }
+    build() {
+        if (this.scopeStack.length > 0) {
+            throw new Error("Can't build ScopeInfo while an OriginalScope is unclosed.");
+        }
+        this.#verifyEmptyRangeStack("build ScopeInfo");
+        return super.build();
+    }
+    #verifyEmptyScopeStack(op) {
+        if (this.scopeStack.length > 0) {
+            throw new Error(`Can't ${op} while a OriginalScope is unclosed.`);
+        }
+    }
+    #verifyEmptyRangeStack(op) {
+        if (this.rangeStack.length > 0) {
+            throw new Error(`Can't ${op} while a GeneratedRange is unclosed.`);
+        }
+    }
+    #verifyScopePresent(op) {
+        if (this.scopeStack.length === 0) {
+            throw new Error(`Can't ${op} while no OriginalScope is on the stack.`);
+        }
+    }
+    #verifyRangePresent(op) {
+        if (this.rangeStack.length === 0) {
+            throw new Error(`Can't ${op} while no GeneratedRange is on the stack.`);
+        }
+    }
+    #verifyRangeValues(range, end) {
+        for (const value of range.values) {
+            if (!Array.isArray(value)) {
+                continue;
+            }
+            const subRanges = value;
+            if (subRanges.length === 0) {
+                continue;
+            }
+            const first = subRanges.at(0);
+            if (comparePositions(first.from, range.start) !== 0) {
+                throw new Error(`Sub-range bindings must start at the generated range's start. Expected ${range.start.line}:${range.start.column}, but got ${first.from.line}:${first.from.column}`);
+            }
+            const last = subRanges.at(-1);
+            if (comparePositions(last.to, end) !== 0) {
+                throw new Error(`Sub-range bindings must end at the generated range's end. Expected ${end.line}:${end.column}, but got ${last.to.line}:${last.to.column}`);
+            }
+            for (let i = 0; i < subRanges.length; ++i) {
+                const current = subRanges[i];
+                if (comparePositions(current.from, current.to) >= 0) {
+                    throw new Error(`Sub-range binding 'from' (${current.from.line}:${current.from.column}) must precede 'to' (${current.to.line}:${current.to.column})`);
+                }
+                if (i > 0) {
+                    const prev = subRanges[i - 1];
+                    if (comparePositions(prev.to, current.from) !== 0) {
+                        throw new Error(`Sub-range bindings must be sorted and not overlap. Found gap between ${prev.to.line}:${prev.to.column} and ${current.from.line}:${current.from.column}`);
+                    }
+                }
+            }
+        }
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/source-map-scopes-codec/package/src/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 {};

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

@@ -0,0 +1,394 @@
+// 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 { TokenIterator } from "../vlq.js";
+export const DEFAULT_DECODE_OPTIONS = {
+    mode: 2 /* DecodeMode.LAX */,
+    generatedOffset: { line: 0, column: 0 },
+};
+export function decode(sourceMap, options = DEFAULT_DECODE_OPTIONS) {
+    const opts = { ...DEFAULT_DECODE_OPTIONS, ...options };
+    if ("sections" in sourceMap) {
+        return decodeIndexMap(sourceMap, {
+            ...opts,
+            generatedOffset: { line: 0, column: 0 },
+        });
+    }
+    return decodeMap(sourceMap, opts);
+}
+function decodeMap(sourceMap, options) {
+    if (!sourceMap.scopes || !sourceMap.names)
+        return { scopes: [], ranges: [] };
+    return new Decoder(sourceMap.scopes, sourceMap.names, options).decode();
+}
+function decodeIndexMap(sourceMap, options) {
+    const scopeInfo = { scopes: [], ranges: [] };
+    for (const section of sourceMap.sections) {
+        const { scopes, ranges } = decode(section.map, {
+            ...options,
+            generatedOffset: section.offset,
+        });
+        for (const scope of scopes)
+            scopeInfo.scopes.push(scope);
+        for (const range of ranges)
+            scopeInfo.ranges.push(range);
+    }
+    return scopeInfo;
+}
+const DEFAULT_SCOPE_STATE = {
+    line: 0,
+    column: 0,
+    name: 0,
+    kind: 0,
+    variable: 0,
+};
+const DEFAULT_RANGE_STATE = {
+    line: 0,
+    column: 0,
+    defScopeIdx: 0,
+};
+class Decoder {
+    #encodedScopes;
+    #names;
+    #mode;
+    #scopes = [];
+    #ranges = [];
+    #scopeState = { ...DEFAULT_SCOPE_STATE };
+    #rangeState = { ...DEFAULT_RANGE_STATE };
+    #scopeStack = [];
+    #rangeStack = [];
+    #flatOriginalScopes = [];
+    #subRangeBindingsForRange = new Map();
+    constructor(scopes, names, options) {
+        this.#encodedScopes = scopes;
+        this.#names = names;
+        this.#mode = options.mode;
+        this.#rangeState.line = options.generatedOffset.line;
+        this.#rangeState.column = options.generatedOffset.column;
+    }
+    decode() {
+        const iter = new TokenIterator(this.#encodedScopes);
+        while (iter.hasNext()) {
+            if (iter.peek() === ",") {
+                iter.nextChar(); // Consume ",".
+                this.#scopes.push(null); // Add an EmptyItem;
+                continue;
+            }
+            const tag = iter.nextUnsignedVLQ();
+            switch (tag) {
+                case 1 /* Tag.ORIGINAL_SCOPE_START */: {
+                    const item = {
+                        flags: iter.nextUnsignedVLQ(),
+                        line: iter.nextUnsignedVLQ(),
+                        column: iter.nextUnsignedVLQ(),
+                    };
+                    if (item.flags & 1 /* OriginalScopeFlags.HAS_NAME */) {
+                        item.nameIdx = iter.nextSignedVLQ();
+                    }
+                    if (item.flags & 2 /* OriginalScopeFlags.HAS_KIND */) {
+                        item.kindIdx = iter.nextSignedVLQ();
+                    }
+                    this.#handleOriginalScopeStartItem(item);
+                    break;
+                }
+                case 3 /* Tag.ORIGINAL_SCOPE_VARIABLES */: {
+                    const variableIdxs = [];
+                    while (iter.hasNext() && iter.peek() !== ",") {
+                        variableIdxs.push(iter.nextSignedVLQ());
+                    }
+                    this.#handleOriginalScopeVariablesItem(variableIdxs);
+                    break;
+                }
+                case 2 /* Tag.ORIGINAL_SCOPE_END */: {
+                    this.#handleOriginalScopeEndItem(iter.nextUnsignedVLQ(), iter.nextUnsignedVLQ());
+                    break;
+                }
+                case 4 /* Tag.GENERATED_RANGE_START */: {
+                    const flags = iter.nextUnsignedVLQ();
+                    const line = flags & 1 /* GeneratedRangeFlags.HAS_LINE */
+                        ? iter.nextUnsignedVLQ()
+                        : undefined;
+                    const column = iter.nextUnsignedVLQ();
+                    const definitionIdx = flags & 2 /* GeneratedRangeFlags.HAS_DEFINITION */
+                        ? iter.nextSignedVLQ()
+                        : undefined;
+                    this.#handleGeneratedRangeStartItem({
+                        flags,
+                        line,
+                        column,
+                        definitionIdx,
+                    });
+                    break;
+                }
+                case 5 /* Tag.GENERATED_RANGE_END */: {
+                    const lineOrColumn = iter.nextUnsignedVLQ();
+                    const maybeColumn = iter.hasNext() && iter.peek() !== ","
+                        ? iter.nextUnsignedVLQ()
+                        : undefined;
+                    if (maybeColumn !== undefined) {
+                        this.#handleGeneratedRangeEndItem(lineOrColumn, maybeColumn);
+                    }
+                    else {
+                        this.#handleGeneratedRangeEndItem(0, lineOrColumn);
+                    }
+                    break;
+                }
+                case 6 /* Tag.GENERATED_RANGE_BINDINGS */: {
+                    const valueIdxs = [];
+                    while (iter.hasNext() && iter.peek() !== ",") {
+                        valueIdxs.push(iter.nextUnsignedVLQ());
+                    }
+                    this.#handleGeneratedRangeBindingsItem(valueIdxs);
+                    break;
+                }
+                case 7 /* Tag.GENERATED_RANGE_SUBRANGE_BINDING */: {
+                    const variableIndex = iter.nextUnsignedVLQ();
+                    const bindings = [];
+                    while (iter.hasNext() && iter.peek() !== ",") {
+                        bindings.push([
+                            iter.nextUnsignedVLQ(),
+                            iter.nextUnsignedVLQ(),
+                            iter.nextUnsignedVLQ(),
+                        ]);
+                    }
+                    this.#recordGeneratedSubRangeBindingItem(variableIndex, bindings);
+                    break;
+                }
+                case 8 /* Tag.GENERATED_RANGE_CALL_SITE */: {
+                    this.#handleGeneratedRangeCallSite(iter.nextUnsignedVLQ(), iter.nextUnsignedVLQ(), iter.nextUnsignedVLQ());
+                    break;
+                }
+            }
+            // Consume any trailing VLQ and the the ","
+            while (iter.hasNext() && iter.peek() !== ",")
+                iter.nextUnsignedVLQ();
+            if (iter.hasNext())
+                iter.nextChar();
+        }
+        if (iter.currentChar() === ",") {
+            // Handle trailing EmptyItem.
+            this.#scopes.push(null);
+        }
+        if (this.#scopeStack.length > 0) {
+            this.#throwInStrictMode("Encountered ORIGINAL_SCOPE_START without matching END!");
+        }
+        if (this.#rangeStack.length > 0) {
+            this.#throwInStrictMode("Encountered GENERATED_RANGE_START without matching END!");
+        }
+        const info = { scopes: this.#scopes, ranges: this.#ranges };
+        this.#scopes = [];
+        this.#ranges = [];
+        this.#flatOriginalScopes = [];
+        return info;
+    }
+    #throwInStrictMode(message) {
+        if (this.#mode === 1 /* DecodeMode.STRICT */)
+            throw new Error(message);
+    }
+    #handleOriginalScopeStartItem(item) {
+        this.#scopeState.line += item.line;
+        if (item.line === 0) {
+            this.#scopeState.column += item.column;
+        }
+        else {
+            this.#scopeState.column = item.column;
+        }
+        const scope = {
+            start: { line: this.#scopeState.line, column: this.#scopeState.column },
+            end: { line: this.#scopeState.line, column: this.#scopeState.column },
+            isStackFrame: false,
+            variables: [],
+            children: [],
+        };
+        if (item.nameIdx !== undefined) {
+            this.#scopeState.name += item.nameIdx;
+            scope.name = this.#resolveName(this.#scopeState.name);
+        }
+        if (item.kindIdx !== undefined) {
+            this.#scopeState.kind += item.kindIdx;
+            scope.kind = this.#resolveName(this.#scopeState.kind);
+        }
+        scope.isStackFrame = Boolean(item.flags & 4 /* OriginalScopeFlags.IS_STACK_FRAME */);
+        this.#scopeStack.push(scope);
+        this.#flatOriginalScopes.push(scope);
+    }
+    #handleOriginalScopeVariablesItem(variableIdxs) {
+        const scope = this.#scopeStack.at(-1);
+        if (!scope) {
+            this.#throwInStrictMode("Encountered ORIGINAL_SCOPE_VARIABLES without surrounding ORIGINAL_SCOPE_START");
+            return;
+        }
+        for (const variableIdx of variableIdxs) {
+            this.#scopeState.variable += variableIdx;
+            scope.variables.push(this.#resolveName(this.#scopeState.variable));
+        }
+    }
+    #handleOriginalScopeEndItem(line, column) {
+        this.#scopeState.line += line;
+        if (line === 0) {
+            this.#scopeState.column += column;
+        }
+        else {
+            this.#scopeState.column = column;
+        }
+        const scope = this.#scopeStack.pop();
+        if (!scope) {
+            this.#throwInStrictMode("Encountered ORIGINAL_SCOPE_END without matching ORIGINAL_SCOPE_START!");
+            return;
+        }
+        scope.end = {
+            line: this.#scopeState.line,
+            column: this.#scopeState.column,
+        };
+        if (this.#scopeStack.length > 0) {
+            const parent = this.#scopeStack.at(-1);
+            scope.parent = parent;
+            parent.children.push(scope);
+        }
+        else {
+            this.#scopes.push(scope);
+            this.#scopeState.line = 0;
+            this.#scopeState.column = 0;
+        }
+    }
+    #handleGeneratedRangeStartItem(item) {
+        if (item.line !== undefined) {
+            this.#rangeState.line += item.line;
+            this.#rangeState.column = item.column;
+        }
+        else {
+            this.#rangeState.column += item.column;
+        }
+        const range = {
+            start: {
+                line: this.#rangeState.line,
+                column: this.#rangeState.column,
+            },
+            end: {
+                line: this.#rangeState.line,
+                column: this.#rangeState.column,
+            },
+            isStackFrame: Boolean(item.flags & 4 /* GeneratedRangeFlags.IS_STACK_FRAME */),
+            isHidden: Boolean(item.flags & 8 /* GeneratedRangeFlags.IS_HIDDEN */),
+            values: [],
+            children: [],
+        };
+        if (item.definitionIdx !== undefined) {
+            this.#rangeState.defScopeIdx += item.definitionIdx;
+            if (this.#rangeState.defScopeIdx < 0 ||
+                this.#rangeState.defScopeIdx >= this.#flatOriginalScopes.length) {
+                this.#throwInStrictMode("Invalid definition scope index");
+            }
+            else {
+                range.originalScope =
+                    this.#flatOriginalScopes[this.#rangeState.defScopeIdx];
+            }
+        }
+        this.#rangeStack.push(range);
+        this.#subRangeBindingsForRange.clear();
+    }
+    #handleGeneratedRangeBindingsItem(valueIdxs) {
+        const range = this.#rangeStack.at(-1);
+        if (!range) {
+            this.#throwInStrictMode("Encountered GENERATED_RANGE_BINDINGS without surrounding GENERATED_RANGE_START");
+            return;
+        }
+        for (const valueIdx of valueIdxs) {
+            if (valueIdx === 0) {
+                range.values.push(null);
+            }
+            else {
+                range.values.push(this.#resolveName(valueIdx - 1));
+            }
+        }
+    }
+    #recordGeneratedSubRangeBindingItem(variableIndex, bindings) {
+        if (this.#subRangeBindingsForRange.has(variableIndex)) {
+            this.#throwInStrictMode("Encountered multiple GENERATED_RANGE_SUBRANGE_BINDING items for the same variable");
+            return;
+        }
+        this.#subRangeBindingsForRange.set(variableIndex, bindings);
+    }
+    #handleGeneratedRangeCallSite(sourceIndex, line, column) {
+        const range = this.#rangeStack.at(-1);
+        if (!range) {
+            this.#throwInStrictMode("Encountered GENERATED_RANGE_CALL_SITE without surrounding GENERATED_RANGE_START");
+            return;
+        }
+        range.callSite = {
+            sourceIndex,
+            line,
+            column,
+        };
+    }
+    #handleGeneratedRangeEndItem(line, column) {
+        if (line !== 0) {
+            this.#rangeState.line += line;
+            this.#rangeState.column = column;
+        }
+        else {
+            this.#rangeState.column += column;
+        }
+        const range = this.#rangeStack.pop();
+        if (!range) {
+            this.#throwInStrictMode("Encountered GENERATED_RANGE_END without matching GENERATED_RANGE_START!");
+            return;
+        }
+        range.end = {
+            line: this.#rangeState.line,
+            column: this.#rangeState.column,
+        };
+        this.#handleGeneratedRangeSubRangeBindings(range);
+        if (this.#rangeStack.length > 0) {
+            const parent = this.#rangeStack.at(-1);
+            range.parent = parent;
+            parent.children.push(range);
+        }
+        else {
+            this.#ranges.push(range);
+        }
+    }
+    #handleGeneratedRangeSubRangeBindings(range) {
+        for (const [variableIndex, bindings] of this.#subRangeBindingsForRange) {
+            const value = range.values[variableIndex];
+            const subRanges = [];
+            range.values[variableIndex] = subRanges;
+            let lastLine = range.start.line;
+            let lastColumn = range.start.column;
+            subRanges.push({
+                from: { line: lastLine, column: lastColumn },
+                to: { line: 0, column: 0 },
+                value: value,
+            });
+            for (const [binding, line, column] of bindings) {
+                lastLine += line;
+                if (line === 0) {
+                    lastColumn += column;
+                }
+                else {
+                    lastColumn = column;
+                }
+                subRanges.push({
+                    from: { line: lastLine, column: lastColumn },
+                    to: { line: 0, column: 0 }, // This will be fixed in the post-processing step.
+                    value: binding === 0 ? undefined : this.#resolveName(binding - 1),
+                });
+            }
+        }
+        for (const value of range.values) {
+            if (Array.isArray(value)) {
+                const subRanges = value;
+                for (let i = 0; i < subRanges.length - 1; ++i) {
+                    subRanges[i].to = subRanges[i + 1].from;
+                }
+                subRanges[subRanges.length - 1].to = range.end;
+            }
+        }
+    }
+    #resolveName(index) {
+        if (index < 0 || index >= this.#names.length) {
+            this.#throwInStrictMode("Illegal index into the 'names' array");
+        }
+        return this.#names[index] ?? "";
+    }
+}

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

@@ -0,0 +1,24 @@
+// 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 { Encoder } from "./encoder.js";
+/**
+ * Encodes the `ScopeInfo` into a source map JSON object.
+ *
+ * If `inputSourceMap` is provided, `encode` will augment the "names" array and
+ * overwrite the "scopes" field, before returning the provided `inputSourceMap` again.
+ */
+export function encode(scopesInfo, inputSourceMap) {
+    inputSourceMap ||= {
+        version: 3,
+        mappings: "",
+        sources: new Array(scopesInfo.scopes.length).fill(null),
+    };
+    inputSourceMap.names ||= [];
+    if (inputSourceMap.sources.length !== scopesInfo.scopes.length) {
+        throw new Error(`SourceMapJson.sources.length must match ScopesInfo.scopes! ${inputSourceMap.sources.length} vs ${scopesInfo.scopes.length}`);
+    }
+    inputSourceMap.scopes = new Encoder(scopesInfo, inputSourceMap.names)
+        .encode();
+    return inputSourceMap;
+}