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

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/FrameManager.js

@@ -1,199 +0,0 @@
-// 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 '../common/common.js';
-import { Events as ResourceTreeModelEvents, ResourceTreeModel } from './ResourceTreeModel.js';
-import { TargetManager } from './TargetManager.js';
-let frameManagerInstance = null;
-/**
- * The FrameManager is a central storage for all #frames. It collects #frames from all
- * ResourceTreeModel-instances (one per target), so that #frames can be found by id
- * without needing to know their target.
- */
-export class FrameManager extends Common.ObjectWrapper.ObjectWrapper {
-    #eventListeners = new WeakMap();
-    // Maps frameIds to #frames and a count of how many ResourceTreeModels contain this frame.
-    // (OOPIFs are usually first attached to a new target and then detached from their old target,
-    // therefore being contained in 2 models for a short period of time.)
-    #frames = new Map();
-    #framesForTarget = new Map();
-    #outermostFrame = null;
-    #transferringFramesDataCache = new Map();
-    #awaitedFrames = new Map();
-    constructor() {
-        super();
-        TargetManager.instance().observeModels(ResourceTreeModel, this);
-    }
-    static instance({ forceNew } = { forceNew: false }) {
-        if (!frameManagerInstance || forceNew) {
-            frameManagerInstance = new FrameManager();
-        }
-        return frameManagerInstance;
-    }
-    static removeInstance() {
-        frameManagerInstance = null;
-    }
-    modelAdded(resourceTreeModel) {
-        const addListener = resourceTreeModel.addEventListener(ResourceTreeModelEvents.FrameAdded, this.frameAdded, this);
-        const detachListener = resourceTreeModel.addEventListener(ResourceTreeModelEvents.FrameDetached, this.frameDetached, this);
-        const navigatedListener = resourceTreeModel.addEventListener(ResourceTreeModelEvents.FrameNavigated, this.frameNavigated, this);
-        const resourceAddedListener = resourceTreeModel.addEventListener(ResourceTreeModelEvents.ResourceAdded, this.resourceAdded, this);
-        this.#eventListeners.set(resourceTreeModel, [addListener, detachListener, navigatedListener, resourceAddedListener]);
-        this.#framesForTarget.set(resourceTreeModel.target().id(), new Set());
-    }
-    modelRemoved(resourceTreeModel) {
-        const listeners = this.#eventListeners.get(resourceTreeModel);
-        if (listeners) {
-            Common.EventTarget.removeEventListeners(listeners);
-        }
-        // Iterate over this model's #frames and decrease their count or remove them.
-        // (The ResourceTreeModel does not send FrameDetached events when a model
-        // is removed.)
-        const frameSet = this.#framesForTarget.get(resourceTreeModel.target().id());
-        if (frameSet) {
-            for (const frameId of frameSet) {
-                this.decreaseOrRemoveFrame(frameId);
-            }
-        }
-        this.#framesForTarget.delete(resourceTreeModel.target().id());
-    }
-    frameAdded(event) {
-        const frame = event.data;
-        const frameData = this.#frames.get(frame.id);
-        // If the frame is already in the map, increase its count, otherwise add it to the map.
-        if (frameData) {
-            // In order to not lose the following attributes of a frame during
-            // an OOPIF transfer we need to copy them to the new frame
-            frame.setCreationStackTrace(frameData.frame.getCreationStackTraceData());
-            this.#frames.set(frame.id, { frame, count: frameData.count + 1 });
-        }
-        else {
-            // If the transferring frame's detached event is received before its frame added
-            // event in the new target, the frame's cached attributes are reassigned.
-            const cachedFrameAttributes = this.#transferringFramesDataCache.get(frame.id);
-            if (cachedFrameAttributes?.creationStackTrace && cachedFrameAttributes?.creationStackTraceTarget) {
-                frame.setCreationStackTrace({
-                    creationStackTrace: cachedFrameAttributes.creationStackTrace,
-                    creationStackTraceTarget: cachedFrameAttributes.creationStackTraceTarget,
-                });
-            }
-            this.#frames.set(frame.id, { frame, count: 1 });
-            this.#transferringFramesDataCache.delete(frame.id);
-        }
-        this.resetOutermostFrame();
-        // Add the frameId to the the targetId's set of frameIds.
-        const frameSet = this.#framesForTarget.get(frame.resourceTreeModel().target().id());
-        if (frameSet) {
-            frameSet.add(frame.id);
-        }
-        this.dispatchEventToListeners("FrameAddedToTarget" /* Events.FRAME_ADDED_TO_TARGET */, { frame });
-        this.resolveAwaitedFrame(frame);
-    }
-    frameDetached(event) {
-        const { frame, isSwap } = event.data;
-        // Decrease the frame's count or remove it entirely from the map.
-        this.decreaseOrRemoveFrame(frame.id);
-        // If the transferring frame's detached event is received before its frame
-        // added event in the new target, we persist some attributes of the frame here
-        // so that later on the frame added event in the new target they can be reassigned.
-        if (isSwap && !this.#frames.get(frame.id)) {
-            const traceData = frame.getCreationStackTraceData();
-            const cachedFrameAttributes = {
-                ...(traceData.creationStackTrace && { creationStackTrace: traceData.creationStackTrace }),
-                ...(traceData.creationStackTrace && { creationStackTraceTarget: traceData.creationStackTraceTarget }),
-            };
-            this.#transferringFramesDataCache.set(frame.id, cachedFrameAttributes);
-        }
-        // Remove the frameId from the target's set of frameIds.
-        const frameSet = this.#framesForTarget.get(frame.resourceTreeModel().target().id());
-        if (frameSet) {
-            frameSet.delete(frame.id);
-        }
-    }
-    frameNavigated(event) {
-        const frame = event.data;
-        this.dispatchEventToListeners("FrameNavigated" /* Events.FRAME_NAVIGATED */, { frame });
-        if (frame.isOutermostFrame()) {
-            this.dispatchEventToListeners("OutermostFrameNavigated" /* Events.OUTERMOST_FRAME_NAVIGATED */, { frame });
-        }
-    }
-    resourceAdded(event) {
-        this.dispatchEventToListeners("ResourceAdded" /* Events.RESOURCE_ADDED */, { resource: event.data });
-    }
-    decreaseOrRemoveFrame(frameId) {
-        const frameData = this.#frames.get(frameId);
-        if (frameData) {
-            if (frameData.count === 1) {
-                this.#frames.delete(frameId);
-                this.resetOutermostFrame();
-                this.dispatchEventToListeners("FrameRemoved" /* Events.FRAME_REMOVED */, { frameId });
-            }
-            else {
-                frameData.count--;
-            }
-        }
-    }
-    /**
-     * Looks for the outermost frame in `#frames` and sets `#outermostFrame` accordingly.
-     *
-     * Important: This method needs to be called everytime `#frames` is updated.
-     */
-    resetOutermostFrame() {
-        const outermostFrames = this.getAllFrames().filter(frame => frame.isOutermostFrame());
-        this.#outermostFrame = outermostFrames.length > 0 ? outermostFrames[0] : null;
-    }
-    /**
-     * Returns the ResourceTreeFrame with a given frameId.
-     * When a frame is being detached a new ResourceTreeFrame but with the same
-     * frameId is created. Consequently getFrame() will return a different
-     * ResourceTreeFrame after detachment. Callers of getFrame() should therefore
-     * immediately use the function return value and not store it for later use.
-     */
-    getFrame(frameId) {
-        const frameData = this.#frames.get(frameId);
-        if (frameData) {
-            return frameData.frame;
-        }
-        return null;
-    }
-    getAllFrames() {
-        return Array.from(this.#frames.values(), frameData => frameData.frame);
-    }
-    getOutermostFrame() {
-        return this.#outermostFrame;
-    }
-    async getOrWaitForFrame(frameId, notInTarget) {
-        const frame = this.getFrame(frameId);
-        if (frame && (!notInTarget || notInTarget !== frame.resourceTreeModel().target())) {
-            return frame;
-        }
-        return await new Promise(resolve => {
-            const waiting = this.#awaitedFrames.get(frameId);
-            if (waiting) {
-                waiting.push({ notInTarget, resolve });
-            }
-            else {
-                this.#awaitedFrames.set(frameId, [{ notInTarget, resolve }]);
-            }
-        });
-    }
-    resolveAwaitedFrame(frame) {
-        const waiting = this.#awaitedFrames.get(frame.id);
-        if (!waiting) {
-            return;
-        }
-        const newWaiting = waiting.filter(({ notInTarget, resolve }) => {
-            if (!notInTarget || notInTarget !== frame.resourceTreeModel().target()) {
-                resolve(frame);
-                return false;
-            }
-            return true;
-        });
-        if (newWaiting.length > 0) {
-            this.#awaitedFrames.set(frame.id, newWaiting);
-        }
-        else {
-            this.#awaitedFrames.delete(frame.id);
-        }
-    }
-}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/HeapProfilerModel.js

@@ -1,130 +0,0 @@
-// 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 { RuntimeModel } from './RuntimeModel.js';
-import { SDKModel } from './SDKModel.js';
-export class HeapProfilerModel extends SDKModel {
-    #enabled;
-    #heapProfilerAgent;
-    #runtimeModel;
-    #samplingProfilerDepth;
-    constructor(target) {
-        super(target);
-        target.registerHeapProfilerDispatcher(new HeapProfilerDispatcher(this));
-        this.#enabled = false;
-        this.#heapProfilerAgent = target.heapProfilerAgent();
-        this.#runtimeModel = target.model(RuntimeModel);
-        this.#samplingProfilerDepth = 0;
-    }
-    debuggerModel() {
-        return this.#runtimeModel.debuggerModel();
-    }
-    runtimeModel() {
-        return this.#runtimeModel;
-    }
-    async enable() {
-        if (this.#enabled) {
-            return;
-        }
-        this.#enabled = true;
-        await this.#heapProfilerAgent.invoke_enable();
-    }
-    async startSampling(samplingRateInBytes) {
-        if (this.#samplingProfilerDepth++) {
-            return false;
-        }
-        const defaultSamplingIntervalInBytes = 16384;
-        const response = await this.#heapProfilerAgent.invoke_startSampling({ samplingInterval: samplingRateInBytes || defaultSamplingIntervalInBytes });
-        return Boolean(response.getError());
-    }
-    async stopSampling() {
-        if (!this.#samplingProfilerDepth) {
-            throw new Error('Sampling profiler is not running.');
-        }
-        if (--this.#samplingProfilerDepth) {
-            return await this.getSamplingProfile();
-        }
-        const response = await this.#heapProfilerAgent.invoke_stopSampling();
-        if (response.getError()) {
-            return null;
-        }
-        return response.profile;
-    }
-    async getSamplingProfile() {
-        const response = await this.#heapProfilerAgent.invoke_getSamplingProfile();
-        if (response.getError()) {
-            return null;
-        }
-        return response.profile;
-    }
-    async collectGarbage() {
-        const response = await this.#heapProfilerAgent.invoke_collectGarbage();
-        return Boolean(response.getError());
-    }
-    async snapshotObjectIdForObjectId(objectId) {
-        const response = await this.#heapProfilerAgent.invoke_getHeapObjectId({ objectId });
-        if (response.getError()) {
-            return null;
-        }
-        return response.heapSnapshotObjectId;
-    }
-    async objectForSnapshotObjectId(snapshotObjectId, objectGroupName) {
-        const result = await this.#heapProfilerAgent.invoke_getObjectByHeapObjectId({ objectId: snapshotObjectId, objectGroup: objectGroupName });
-        if (result.getError()) {
-            return null;
-        }
-        return this.#runtimeModel.createRemoteObject(result.result);
-    }
-    async addInspectedHeapObject(snapshotObjectId) {
-        const response = await this.#heapProfilerAgent.invoke_addInspectedHeapObject({ heapObjectId: snapshotObjectId });
-        return Boolean(response.getError());
-    }
-    async takeHeapSnapshot(heapSnapshotOptions) {
-        await this.#heapProfilerAgent.invoke_takeHeapSnapshot(heapSnapshotOptions);
-    }
-    async startTrackingHeapObjects(recordAllocationStacks) {
-        const response = await this.#heapProfilerAgent.invoke_startTrackingHeapObjects({ trackAllocations: recordAllocationStacks });
-        return Boolean(response.getError());
-    }
-    async stopTrackingHeapObjects(reportProgress) {
-        const response = await this.#heapProfilerAgent.invoke_stopTrackingHeapObjects({ reportProgress });
-        return Boolean(response.getError());
-    }
-    heapStatsUpdate(samples) {
-        this.dispatchEventToListeners("HeapStatsUpdate" /* Events.HEAP_STATS_UPDATED */, samples);
-    }
-    lastSeenObjectId(lastSeenObjectId, timestamp) {
-        this.dispatchEventToListeners("LastSeenObjectId" /* Events.LAST_SEEN_OBJECT_ID */, { lastSeenObjectId, timestamp });
-    }
-    addHeapSnapshotChunk(chunk) {
-        this.dispatchEventToListeners("AddHeapSnapshotChunk" /* Events.ADD_HEAP_SNAPSHOT_CHUNK */, chunk);
-    }
-    reportHeapSnapshotProgress(done, total, finished) {
-        this.dispatchEventToListeners("ReportHeapSnapshotProgress" /* Events.REPORT_HEAP_SNAPSHOT_PROGRESS */, { done, total, finished });
-    }
-    resetProfiles() {
-        this.dispatchEventToListeners("ResetProfiles" /* Events.RESET_PROFILES */, this);
-    }
-}
-class HeapProfilerDispatcher {
-    #heapProfilerModel;
-    constructor(model) {
-        this.#heapProfilerModel = model;
-    }
-    heapStatsUpdate({ statsUpdate }) {
-        this.#heapProfilerModel.heapStatsUpdate(statsUpdate);
-    }
-    lastSeenObjectId({ lastSeenObjectId, timestamp }) {
-        this.#heapProfilerModel.lastSeenObjectId(lastSeenObjectId, timestamp);
-    }
-    addHeapSnapshotChunk({ chunk }) {
-        this.#heapProfilerModel.addHeapSnapshotChunk(chunk);
-    }
-    reportHeapSnapshotProgress({ done, total, finished }) {
-        this.#heapProfilerModel.reportHeapSnapshotProgress(done, total, finished);
-    }
-    resetProfiles() {
-        this.#heapProfilerModel.resetProfiles();
-    }
-}
-SDKModel.register(HeapProfilerModel, { capabilities: 4 /* Capability.JS */, autostart: false });

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/HttpReasonPhraseStrings.js

@@ -1,75 +0,0 @@
-// 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 '../i18n/i18n.js';
-/**
- * Reason phrase sources
- * See https://www.rfc-editor.org/rfc/rfc9110.html#name-status-codes
- **/
-export function getStatusText(statusCode) {
-    const statusTextLookup = {
-        100: 'Continue',
-        101: 'Switching Protocols',
-        102: 'Processing',
-        103: 'Early Hints',
-        200: 'OK',
-        201: 'Created',
-        202: 'Accepted',
-        203: 'Non-Authoritative Information',
-        204: 'No Content',
-        205: 'Reset Content',
-        206: 'Partial Content',
-        207: 'Multi-Status',
-        208: 'Already Reported',
-        226: 'IM Used',
-        300: 'Multiple Choices',
-        301: 'Moved Permanently',
-        302: 'Found',
-        303: 'See Other',
-        304: 'Not Modified',
-        305: 'Use Proxy',
-        307: 'Temporary Redirect',
-        308: 'Permanent Redirect',
-        400: 'Bad Request',
-        401: 'Unauthorized',
-        402: 'Payment Required',
-        403: 'Forbidden',
-        404: 'Not Found',
-        405: 'Method Not Allowed',
-        406: 'Not Acceptable',
-        407: 'Proxy Authentication Required',
-        408: 'Request Timeout',
-        409: 'Conflict',
-        410: 'Gone',
-        411: 'Length Required',
-        412: 'Precondition Failed',
-        413: 'Content Too Large',
-        414: 'URI Too Long',
-        415: 'Unsupported Media Type',
-        416: 'Range Not Satisfiable',
-        417: 'Expectation Failed',
-        418: 'I\'m a teapot',
-        421: 'Misdirected Request',
-        422: 'Unprocessable Content',
-        423: 'Locked',
-        424: 'Failed Dependency',
-        425: 'Too Early',
-        426: 'Upgrade Required',
-        428: 'Precondition Required',
-        429: 'Too Many Requests',
-        431: 'Request Header Fields Too Large',
-        451: 'Unavailable For Legal Reasons',
-        500: 'Internal Server Error',
-        501: 'Not Implemented',
-        502: 'Bad Gateway',
-        503: 'Service Unavailable',
-        504: 'Gateway Timeout',
-        505: 'HTTP Version Not Supported',
-        506: 'Variant Also Negotiates',
-        507: 'Insufficient Storage',
-        508: 'Loop Detected',
-        510: 'Not Extended',
-        511: 'Network Authentication Required',
-    };
-    return i18n.i18n.lockedString(statusTextLookup[statusCode] ?? '');
-}

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/IOModel.js

@@ -1,80 +0,0 @@
-// 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 '../common/common.js';
-import { RemoteObject } from './RemoteObject.js';
-import { SDKModel } from './SDKModel.js';
-export class IOModel extends SDKModel {
-    async read(handle, size, offset) {
-        const result = await this.target().ioAgent().invoke_read({ handle, offset, size });
-        if (result.getError()) {
-            throw new Error(result.getError());
-        }
-        if (result.eof) {
-            return null;
-        }
-        if (result.base64Encoded) {
-            return Common.Base64.decode(result.data);
-        }
-        return result.data;
-    }
-    async close(handle) {
-        await this.target().ioAgent().invoke_close({ handle });
-    }
-    async resolveBlob(objectOrObjectId) {
-        const objectId = objectOrObjectId instanceof RemoteObject ? objectOrObjectId.objectId : objectOrObjectId;
-        if (!objectId) {
-            throw new Error('Remote object has undefined objectId');
-        }
-        const result = await this.target().ioAgent().invoke_resolveBlob({ objectId });
-        if (result.getError()) {
-            throw new Error(result.getError());
-        }
-        return `blob:${result.uuid}`;
-    }
-    async readToString(handle) {
-        const strings = [];
-        const decoder = new TextDecoder();
-        for (;;) {
-            const data = await this.read(handle, 1024 * 1024);
-            if (data === null) {
-                strings.push(decoder.decode());
-                break;
-            }
-            if (data instanceof Uint8Array) {
-                strings.push(decoder.decode(data, { stream: true }));
-            }
-            else {
-                strings.push(data);
-            }
-        }
-        return strings.join('');
-    }
-    async readToBuffer(handle) {
-        const items = [];
-        for (;;) {
-            const data = await this.read(handle, 1024 * 1024);
-            if (data === null) {
-                break;
-            }
-            if (data instanceof Uint8Array) {
-                items.push(data);
-            }
-            else {
-                throw new Error('Unexpected stream data type: expected binary, got a string');
-            }
-        }
-        let length = 0;
-        for (const item of items) {
-            length += item.length;
-        }
-        const result = new Uint8Array(length);
-        let offset = 0;
-        for (const item of items) {
-            result.set(item, offset);
-            offset += item.length;
-        }
-        return result;
-    }
-}
-SDKModel.register(IOModel, { capabilities: 131072 /* Capability.IO */, autostart: true });

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/IsolateManager.js

@@ -1,208 +0,0 @@
-// Copyright 2019 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 '../common/common.js';
-import { RuntimeModel } from './RuntimeModel.js';
-import { TargetManager } from './TargetManager.js';
-let isolateManagerInstance;
-export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper {
-    #isolates = new Map();
-    /**
-     * Contains null while the isolateId is being retrieved.
-     */
-    #isolateIdByModel = new Map();
-    #observers = new Set();
-    #pollId = 0;
-    constructor() {
-        super();
-        TargetManager.instance().observeModels(RuntimeModel, this);
-    }
-    static instance({ forceNew } = { forceNew: false }) {
-        if (!isolateManagerInstance || forceNew) {
-            isolateManagerInstance = new IsolateManager();
-        }
-        return isolateManagerInstance;
-    }
-    observeIsolates(observer) {
-        if (this.#observers.has(observer)) {
-            throw new Error('Observer can only be registered once');
-        }
-        if (!this.#observers.size) {
-            void this.poll();
-        }
-        this.#observers.add(observer);
-        for (const isolate of this.#isolates.values()) {
-            observer.isolateAdded(isolate);
-        }
-    }
-    modelAdded(model) {
-        void this.#modelAdded(model);
-    }
-    async #modelAdded(model) {
-        this.#isolateIdByModel.set(model, null);
-        const isolateId = await model.isolateId();
-        if (!this.#isolateIdByModel.has(model)) {
-            // The model has been removed during await.
-            return;
-        }
-        if (!isolateId) {
-            this.#isolateIdByModel.delete(model);
-            return;
-        }
-        this.#isolateIdByModel.set(model, isolateId);
-        let isolate = this.#isolates.get(isolateId);
-        if (!isolate) {
-            isolate = new Isolate(isolateId);
-            this.#isolates.set(isolateId, isolate);
-        }
-        isolate.models().add(model);
-        if (isolate.models().size === 1) {
-            for (const observer of this.#observers) {
-                observer.isolateAdded(isolate);
-            }
-        }
-        else {
-            for (const observer of this.#observers) {
-                observer.isolateChanged(isolate);
-            }
-        }
-    }
-    modelRemoved(model) {
-        const isolateId = this.#isolateIdByModel.get(model);
-        this.#isolateIdByModel.delete(model);
-        if (!isolateId) {
-            return;
-        }
-        const isolate = this.#isolates.get(isolateId);
-        if (!isolate) {
-            return;
-        }
-        isolate.models().delete(model);
-        if (isolate.models().size) {
-            for (const observer of this.#observers) {
-                observer.isolateChanged(isolate);
-            }
-            return;
-        }
-        for (const observer of this.#observers) {
-            observer.isolateRemoved(isolate);
-        }
-        this.#isolates.delete(isolateId);
-    }
-    isolateByModel(model) {
-        return this.#isolates.get(this.#isolateIdByModel.get(model) || '') || null;
-    }
-    isolates() {
-        return this.#isolates.values();
-    }
-    async poll() {
-        const pollId = this.#pollId;
-        while (pollId === this.#pollId) {
-            await Promise.all(Array.from(this.isolates(), isolate => isolate.update()));
-            await new Promise(r => window.setTimeout(r, PollIntervalMs));
-        }
-    }
-}
-export const MemoryTrendWindowMs = 120e3;
-const PollIntervalMs = 2e3;
-export class Isolate {
-    #id;
-    #models;
-    #usedHeapSize;
-    #memoryTrend;
-    constructor(id) {
-        this.#id = id;
-        this.#models = new Set();
-        this.#usedHeapSize = 0;
-        const count = MemoryTrendWindowMs / PollIntervalMs;
-        this.#memoryTrend = new MemoryTrend(count);
-    }
-    id() {
-        return this.#id;
-    }
-    models() {
-        return this.#models;
-    }
-    runtimeModel() {
-        return this.#models.values().next().value || null;
-    }
-    heapProfilerModel() {
-        const runtimeModel = this.runtimeModel();
-        return runtimeModel?.heapProfilerModel() ?? null;
-    }
-    async update() {
-        const model = this.runtimeModel();
-        const usage = model && await model.heapUsage();
-        if (!usage) {
-            return;
-        }
-        this.#usedHeapSize = usage.usedSize + (usage.embedderHeapUsedSize ?? 0) + (usage.backingStorageSize ?? 0);
-        this.#memoryTrend.add(this.#usedHeapSize);
-        IsolateManager.instance().dispatchEventToListeners("MemoryChanged" /* Events.MEMORY_CHANGED */, this);
-    }
-    samplesCount() {
-        return this.#memoryTrend.count();
-    }
-    usedHeapSize() {
-        return this.#usedHeapSize;
-    }
-    /**
-     * bytes per millisecond
-     */
-    usedHeapSizeGrowRate() {
-        return this.#memoryTrend.fitSlope();
-    }
-}
-export class MemoryTrend {
-    #maxCount;
-    #base;
-    #index;
-    #x;
-    #y;
-    #sx;
-    #sy;
-    #sxx;
-    #sxy;
-    constructor(maxCount) {
-        this.#maxCount = maxCount | 0;
-        this.reset();
-    }
-    reset() {
-        this.#base = Date.now();
-        this.#index = 0;
-        this.#x = [];
-        this.#y = [];
-        this.#sx = 0;
-        this.#sy = 0;
-        this.#sxx = 0;
-        this.#sxy = 0;
-    }
-    count() {
-        return this.#x.length;
-    }
-    add(heapSize, timestamp) {
-        const x = typeof timestamp === 'number' ? timestamp : Date.now() - this.#base;
-        const y = heapSize;
-        if (this.#x.length === this.#maxCount) {
-            // Turns into a cyclic buffer once it reaches the |#maxCount|.
-            const x0 = this.#x[this.#index];
-            const y0 = this.#y[this.#index];
-            this.#sx -= x0;
-            this.#sy -= y0;
-            this.#sxx -= x0 * x0;
-            this.#sxy -= x0 * y0;
-        }
-        this.#sx += x;
-        this.#sy += y;
-        this.#sxx += x * x;
-        this.#sxy += x * y;
-        this.#x[this.#index] = x;
-        this.#y[this.#index] = y;
-        this.#index = (this.#index + 1) % this.#maxCount;
-    }
-    fitSlope() {
-        // We use the linear regression model to find the slope.
-        const n = this.count();
-        return n < 2 ? 0 : (this.#sxy - this.#sx * this.#sy / n) / (this.#sxx - this.#sx * this.#sx / n);
-    }
-}