chrome-ai-bridge 1.0.0

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

@@ -0,0 +1,199 @@
+// 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

@@ -0,0 +1,130 @@
+// 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

@@ -0,0 +1,75 @@
+// 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

@@ -0,0 +1,80 @@
+// 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

@@ -0,0 +1,208 @@
+// 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);
+    }
+}