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

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/httparchive-nostats-subset.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./lib/subsets/httparchive-nostats.js");

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/httparchive-subset.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./lib/subsets/httparchive.js");

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/lib/create-entity-finder-api.js

@@ -0,0 +1,118 @@
+"use strict";
+const DOMAIN_IN_URL_REGEX = /:\/\/(\S*?)(:\d+)?(\/|$)/;
+const DOMAIN_CHARACTERS = /([a-z0-9.-]+\.[a-z0-9]+|localhost)/i;
+const IP_REGEX = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+const ROOT_DOMAIN_REGEX = /[^.]+\.([^.]+|(gov|com|co|ne)\.\w{2})$/i;
+function getDomainFromOriginOrURL(originOrURL) {
+    if (typeof originOrURL !== 'string')
+        return null;
+    if (originOrURL.length > 10000 || originOrURL.startsWith('data:'))
+        return null;
+    if (DOMAIN_IN_URL_REGEX.test(originOrURL))
+        return originOrURL.match(DOMAIN_IN_URL_REGEX)[1];
+    if (DOMAIN_CHARACTERS.test(originOrURL))
+        return originOrURL.match(DOMAIN_CHARACTERS)[0];
+    return null;
+}
+function getRootDomain(originOrURL) {
+    const domain = getDomainFromOriginOrURL(originOrURL);
+    if (!domain)
+        return null;
+    if (IP_REGEX.test(domain))
+        return domain;
+    const match = domain.match(ROOT_DOMAIN_REGEX);
+    return (match && match[0]) || domain;
+}
+function sliceSubdomainFromDomain(domain, rootDomain) {
+    if (domain.length <= rootDomain.length)
+        return domain;
+    return domain
+        .split('.')
+        .slice(1)
+        .join('.');
+}
+function getEntityInDataset(entityByDomain, entityBySubDomain, entityByRootDomain, originOrURL) {
+    const domain = getDomainFromOriginOrURL(originOrURL);
+    const rootDomain = getRootDomain(domain);
+    if (!domain || !rootDomain)
+        return undefined;
+    if (entityByDomain.has(domain))
+        return entityByDomain.get(domain);
+    for (let subdomain = domain; subdomain.length > rootDomain.length; subdomain = sliceSubdomainFromDomain(subdomain, rootDomain)) {
+        if (entityBySubDomain.has(subdomain))
+            return entityBySubDomain.get(subdomain);
+    }
+    if (entityByRootDomain.has(rootDomain))
+        return entityByRootDomain.get(rootDomain);
+    return undefined;
+}
+function getProductInDataset(entityByDomain, entityBySubDomain, entityByRootDomain, originOrURL) {
+    const entity = getEntityInDataset(entityByDomain, entityBySubDomain, entityByRootDomain, originOrURL);
+    const products = entity && entity.products;
+    if (!products)
+        return undefined;
+    if (typeof originOrURL !== 'string')
+        return undefined;
+    for (const product of products) {
+        for (const pattern of product.urlPatterns) {
+            if (pattern instanceof RegExp && pattern.test(originOrURL))
+                return product;
+            if (typeof pattern === 'string' && originOrURL.includes(pattern))
+                return product;
+        }
+    }
+    return undefined;
+}
+function cloneEntities(entities) {
+    return entities.map(entity_ => {
+        const entity = {
+            company: entity_.name,
+            categories: [entity_.category],
+            ...entity_,
+        };
+        const products = (entity_.products || []).map(product => ({
+            company: entity.company,
+            category: entity.category,
+            categories: [entity.category],
+            facades: [],
+            ...product,
+            urlPatterns: (product.urlPatterns || []).map(s => s.startsWith('REGEXP:') ? new RegExp(s.slice('REGEXP:'.length)) : s),
+        }));
+        entity.products = products;
+        return entity;
+    });
+}
+function createAPIFromDataset(entities_) {
+    const entities = cloneEntities(entities_);
+    const entityByDomain = new Map();
+    const entityByRootDomain = new Map();
+    const entityBySubDomain = new Map();
+    for (const entity of entities) {
+        entity.totalExecutionTime = Number(entity.totalExecutionTime) || 0;
+        entity.totalOccurrences = Number(entity.totalOccurrences) || 0;
+        entity.averageExecutionTime = entity.totalExecutionTime / entity.totalOccurrences;
+        for (const domain of entity.domains) {
+            if (entityByDomain.has(domain)) {
+                const duplicate = entityByDomain.get(domain);
+                throw new Error(`Duplicate domain ${domain} (${entity.name} and ${duplicate.name})`);
+            }
+            entityByDomain.set(domain, entity);
+            const rootDomain = getRootDomain(domain);
+            if (domain.startsWith('*.')) {
+                const wildcardDomain = domain.slice(2);
+                if (wildcardDomain === rootDomain)
+                    entityByRootDomain.set(rootDomain, entity);
+                else
+                    entityBySubDomain.set(wildcardDomain, entity);
+            }
+        }
+    }
+    for (const [rootDomain, entity] of entityByRootDomain.entries()) {
+        if (!entity)
+            entityByRootDomain.delete(rootDomain);
+    }
+    const getEntity = getEntityInDataset.bind(null, entityByDomain, entityBySubDomain, entityByRootDomain);
+    const getProduct = getProductInDataset.bind(null, entityByDomain, entityBySubDomain, entityByRootDomain);
+    return { getEntity, getProduct, getRootDomain, entities };
+}
+module.exports = { createAPIFromDataset };

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/lib/create-entity-finder-api.test.js

@@ -0,0 +1,40 @@
+"use strict";
+const { createAPIFromDataset } = require('./create-entity-finder-api.js');
+describe('getEntity', () => {
+    let api;
+    beforeEach(() => {
+        api = createAPIFromDataset([
+            {
+                name: 'Domain',
+                domains: ['*.example.com', '*.example.co.uk'],
+            },
+            {
+                name: 'Subdomain',
+                domains: ['*.sub.example.com', '*.sub.example.co.uk'],
+            },
+            {
+                name: 'Subsubdomain',
+                domains: ['very.specific.example.com'],
+            },
+        ]);
+    });
+    it('should find direct domains', () => {
+        expect(api.getEntity('https://very.specific.example.com/path').name).toEqual('Subsubdomain');
+    });
+    it('should find wildcard subdomains', () => {
+        expect(api.getEntity('https://foo.sub.example.com/path').name).toEqual('Subdomain');
+        expect(api.getEntity('https://bar.sub.example.com/path').name).toEqual('Subdomain');
+        expect(api.getEntity('https://baz.bar.sub.example.com/path').name).toEqual('Subdomain');
+        expect(api.getEntity('https://foo.sub.example.co.uk/path').name).toEqual('Subdomain');
+        expect(api.getEntity('https://bar.sub.example.co.uk/path').name).toEqual('Subdomain');
+        expect(api.getEntity('https://baz.bar.sub.example.co.uk/path').name).toEqual('Subdomain');
+    });
+    it('should find wildcard domains', () => {
+        expect(api.getEntity('https://foo.example.com/path').name).toEqual('Domain');
+        expect(api.getEntity('https://bar.example.com/path').name).toEqual('Domain');
+        expect(api.getEntity('https://baz.bar.example.com/path').name).toEqual('Domain');
+        expect(api.getEntity('https://foo.example.co.uk/path').name).toEqual('Domain');
+        expect(api.getEntity('https://bar.example.co.uk/path').name).toEqual('Domain');
+        expect(api.getEntity('https://baz.bar.example.co.uk/path').name).toEqual('Domain');
+    });
+});

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/lib/entities.test.js

@@ -0,0 +1,26 @@
+"use strict";
+const _ = require('lodash');
+const { entities, getRootDomain, getEntity } = require('./index.js');
+describe('Entities', () => {
+    it('should not have duplicate names', () => {
+        for (let i = 0; i < entities.length; i++) {
+            for (let j = i + 1; j < entities.length; j++) {
+                const nameA = entities[i].name.replace(/\s+/, '').toLowerCase();
+                const nameB = entities[j].name.replace(/\s+/, '').toLowerCase();
+                if (nameA !== nameB)
+                    continue;
+                expect(entities[i]).toBe(entities[j]);
+            }
+        }
+    });
+    it('should not have non-supported wilcards', () => {
+        for (const entity of entities) {
+            for (const domain of entity.domains) {
+                // Wildcards must be like `*.blah.com`
+                // Wildcards cannot be `*blah.com` or `blah*.com`
+                expect(domain).toEqual(expect.not.stringMatching(/\w\*/));
+                expect(domain).toEqual(expect.not.stringMatching(/\*\w/));
+            }
+        }
+    });
+});

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+const { createAPIFromDataset } = require('./create-entity-finder-api.js');
+const entities = require('../dist/entities.json');
+module.exports = createAPIFromDataset(entities);

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/lib/index.test.js

@@ -0,0 +1,215 @@
+"use strict";
+const fs = require('fs');
+const path = require('path');
+const { entities, getRootDomain, getEntity, getProduct } = require('./index.js');
+describe('getRootDomain', () => {
+    it('works for IP addresses', () => {
+        expect(getRootDomain('8.8.8.8')).toEqual('8.8.8.8');
+        expect(getRootDomain('192.168.0.1')).toEqual('192.168.0.1');
+    });
+    it('works for basic domains', () => {
+        expect(getRootDomain('cdn.cnn.com')).toEqual('cnn.com');
+        expect(getRootDomain('www.hulce.photography')).toEqual('hulce.photography');
+        expect(getRootDomain('api.supercool.io')).toEqual('supercool.io');
+    });
+    it('works for country-tlds', () => {
+        expect(getRootDomain('content.yahoo.co.jp')).toEqual('yahoo.co.jp');
+        expect(getRootDomain('go.visit.gov.in')).toEqual('visit.gov.in');
+    });
+    it('works for URLs', () => {
+        expect(getRootDomain('https://content.yahoo.co.jp/path/?query=param')).toEqual('yahoo.co.jp');
+        expect(getRootDomain('https://a.b.c.it/path/?query=param&two=2')).toEqual('c.it');
+        expect(getRootDomain('https://foo.bar:433/path/?query=param&two=2')).toEqual('foo.bar');
+    });
+    it('works for localhost', () => {
+        expect(getRootDomain('https://localhost:8080/path/?query=param')).toEqual('localhost');
+        expect(getRootDomain('https://localhost/path/?query=param&two=2')).toEqual('localhost');
+        expect(getRootDomain('localhost:9000/path/?query=param&two=2')).toEqual('localhost');
+        expect(getRootDomain('localhost:1200')).toEqual('localhost');
+    });
+    it('works for wildcard domains', () => {
+        expect(getRootDomain('*.google.com')).toEqual('google.com');
+        expect(getRootDomain('*.yahoo.co.jp')).toEqual('yahoo.co.jp');
+        expect(getRootDomain('*.hulce.photography')).toEqual('hulce.photography');
+    });
+    it('runs on *massive* inputs', () => {
+        const massiveInput = '123456789'.repeat(100e3);
+        expect(getRootDomain(massiveInput)).toEqual(null);
+    });
+    it('runs on data URIs', () => {
+        const dataUri = 'data:image/gif;base64,R0lGODlhAQABAIAAAP8AADAAACwAAAAAAQABAAACAkQBADs=';
+        expect(getRootDomain(dataUri)).toEqual(null);
+    });
+    it('returns null on invalid inputs', () => {
+        expect(getRootDomain('this is not a domain')).toEqual(null);
+        expect(getRootDomain('neither-is-this')).toEqual(null);
+        expect(getRootDomain('http://nor this')).toEqual(null);
+    });
+});
+describe('getEntity', () => {
+    it('works for direct domain usage', () => {
+        expect(getEntity('https://js.connect.facebook.net/lib.js')).toMatchInlineSnapshot(`
+      Object {
+        "averageExecutionTime": 347.4278160199557,
+        "categories": Array [
+          "social",
+        ],
+        "category": "social",
+        "company": "Facebook",
+        "domains": Array [
+          "*.facebook.com",
+          "*.atlassbx.com",
+          "*.fbsbx.com",
+          "fbcdn-photos-e-a.akamaihd.net",
+          "*.facebook.net",
+          "*.fbcdn.net",
+        ],
+        "examples": Array [
+          "www.facebook.com",
+          "connect.facebook.net",
+          "staticxx.facebook.com",
+          "static.xx.fbcdn.net",
+          "m.facebook.com",
+          "an.facebook.com",
+          "platform-lookaside.fbsbx.com",
+        ],
+        "homepage": "https://www.facebook.com",
+        "name": "Facebook",
+        "products": Array [
+          Object {
+            "categories": Array [
+              "social",
+            ],
+            "category": "social",
+            "company": "Facebook",
+            "facades": Array [
+              Object {
+                "name": "React Live Chat Loader",
+                "repo": "https://github.com/calibreapp/react-live-chat-loader",
+              },
+            ],
+            "name": "Facebook Messenger Customer Chat",
+            "urlPatterns": Array [
+              /connect\\\\\\.facebook\\\\\\.net\\\\/\\.\\*\\\\/sdk\\\\/xfbml\\\\\\.customerchat\\\\\\.js/,
+            ],
+          },
+        ],
+        "totalExecutionTime": 1097107210,
+        "totalOccurrences": 3157799,
+      }
+    `);
+    });
+    it('works for inferred domain usage', () => {
+        expect(getEntity('https://unknown.typekit.net/fonts.css')).toMatchInlineSnapshot(`
+      Object {
+        "averageExecutionTime": 660.2645605704683,
+        "categories": Array [
+          "cdn",
+        ],
+        "category": "cdn",
+        "company": "Adobe",
+        "domains": Array [
+          "*.typekit.com",
+          "*.typekit.net",
+        ],
+        "examples": Array [
+          "use.typekit.net",
+          "p.typekit.net",
+        ],
+        "homepage": "https://fonts.adobe.com/",
+        "name": "Adobe TypeKit",
+        "products": Array [],
+        "totalExecutionTime": 78981507,
+        "totalOccurrences": 119621,
+      }
+    `);
+    });
+    it('does not over-infer', () => {
+        expect(getEntity('https://unknown.gstatic.com/what')).toEqual(undefined);
+    });
+    it('only infers as a fallback', () => {
+        expect(getEntity('http://fbcdn-photos-e-a.akamaihd.net/1234.jpg').name).toEqual('Facebook');
+        expect(getEntity('http://unknown.akamaihd.net/1234.jpg').name).toEqual('Akamai');
+    });
+    it('runs on *massive* inputs', () => {
+        const massiveInput = '123456789'.repeat(100e3);
+        expect(getEntity(massiveInput)).toEqual(undefined);
+    });
+    it('runs on data URIs', () => {
+        const dataUri = 'data:image/gif;base64,R0lGODlhAQABAIAAAP8AADAAACwAAAAAAQABAAACAkQBADs=';
+        expect(getEntity(dataUri)).toEqual(undefined);
+    });
+    it('supports multi-tennant domains', () => {
+        expect(getEntity('https://gemius.mgr.consensu.org/cmp/v2/stub.js').name).toEqual('Gemius CMP');
+        expect(getEntity('https://quantcast.mgr.consensu.org/choice/KygWsHah2_7Qa/rssing.com/choice.js').name).toEqual('Quantcast Choice');
+        expect(getEntity('https://static.quantcast.mgr.consensu.org/v50/cmpui-popup.js').name).toEqual('Quantcast Choice');
+    });
+});
+describe('getProduct', () => {
+    it('works on basic url', () => {
+        expect(getProduct('https://www.youtube.com/embed/alGcULGtiv8')).toMatchObject({
+            name: 'YouTube Embedded Player',
+            company: 'YouTube',
+            category: 'video',
+            categories: ['video'],
+            facades: [
+                {
+                    name: 'Lite YouTube',
+                    repo: 'https://github.com/paulirish/lite-youtube-embed',
+                },
+                {
+                    name: 'Ngx Lite Video',
+                    repo: 'https://github.com/karim-mamdouh/ngx-lite-video',
+                },
+            ],
+        });
+    });
+    it('works on regex based', () => {
+        expect(getProduct('https://connect.facebook.net/en_US/sdk/xfbml.customerchat.js')).toMatchObject({
+            name: 'Facebook Messenger Customer Chat',
+            facades: [
+                {
+                    name: 'React Live Chat Loader',
+                    repo: 'https://github.com/calibreapp/react-live-chat-loader',
+                },
+            ],
+        });
+    });
+    it('returns undefined when product does not match', () => {
+        expect(getProduct('https://js.connect.facebook.net/lib.js')).toEqual(undefined);
+    });
+    it('returns undefined with no products', () => {
+        expect(getProduct('https://unknown.typekit.net/fonts.css')).toEqual(undefined);
+    });
+});
+describe('build state', () => {
+    it('should use the complete entities set', () => {
+        const sourceOfTruthEntities = require('../data/entities.js');
+        expect(entities).toHaveLength(sourceOfTruthEntities.length);
+    });
+    it('should have all the same subsets in root as lib', () => {
+        const srcSizes = fs.readdirSync(path.join(__dirname, 'subsets'));
+        const dstSizes = fs.readdirSync(path.join(__dirname, '../')).filter(f => f.includes('-subset'));
+        expect(dstSizes).toHaveLength(srcSizes.length); // run `yarn build` if this fails
+        for (const file of dstSizes) {
+            if (file.endsWith('.js'))
+                require(path.join(__dirname, '../', file));
+        }
+    });
+});
+it('should work on real web data', () => {
+    const urls = fs
+        .readFileSync(path.join(__dirname, '../data/random-urls.txt'), 'utf8')
+        .split('\n')
+        .filter(Boolean);
+    for (const url of urls) {
+        getEntity(url); // ensure it doesn't throw
+    }
+    const top1000 = urls.slice(0, 1000).map(url => {
+        const cleanedUrl = url.split('?')[0];
+        const entity = getEntity(url);
+        return `${entity && entity.name} - ${cleanedUrl}`;
+    });
+    // It's expected that this snapshot will change as coverage changes.
+    expect(top1000).toMatchSnapshot();
+});

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/lib/subsets/httparchive-nostats.js

@@ -0,0 +1,4 @@
+"use strict";
+const { createAPIFromDataset } = require('../create-entity-finder-api.js');
+const entities = require('../../dist/entities-httparchive-nostats.json');
+module.exports = createAPIFromDataset(entities);

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/lib/subsets/httparchive.js

@@ -0,0 +1,4 @@
+"use strict";
+const { createAPIFromDataset } = require('../create-entity-finder-api.js');
+const entities = require('../../dist/entities-httparchive.json');
+module.exports = createAPIFromDataset(entities);

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/lib/subsets/nostats.js

@@ -0,0 +1,4 @@
+"use strict";
+const { createAPIFromDataset } = require('../create-entity-finder-api.js');
+const entities = require('../../dist/entities-nostats.json');
+module.exports = createAPIFromDataset(entities);

package/build/node_modules/chrome-devtools-frontend/front_end/third_party/third-party-web/package/nostats-subset.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./lib/subsets/nostats.js");

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

@@ -0,0 +1,2 @@
+import ThirdPartyWeb from './lib/nostats-subset.js';
+export { ThirdPartyWeb };

package/build/node_modules/chrome-devtools-frontend/mcp/HostBindings.js

@@ -0,0 +1,222 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { readFile } from 'node:fs/promises';
+import { URL } from 'node:url';
+import { streamWrite } from '../front_end/core/host/ResourceLoader.js';
+export class McpHostBindings {
+    connectAutomaticFileSystem() {
+    }
+    disconnectAutomaticFileSystem() {
+    }
+    addFileSystem() {
+    }
+    loadCompleted() {
+    }
+    indexPath() {
+    }
+    setInspectedPageBounds() {
+    }
+    showCertificateViewer() {
+    }
+    setWhitelistedShortcuts() {
+    }
+    setEyeDropperActive() {
+    }
+    inspectElementCompleted() {
+    }
+    openInNewTab() {
+    }
+    openSearchResultsInNewTab() {
+    }
+    showItemInFolder() {
+    }
+    removeFileSystem() {
+    }
+    requestFileSystems() {
+    }
+    save() {
+    }
+    append() {
+    }
+    close() {
+    }
+    searchInPath() {
+    }
+    stopIndexing() {
+    }
+    bringToFront() {
+    }
+    closeWindow() {
+    }
+    copyText() {
+    }
+    inspectedURLChanged() {
+    }
+    isolatedFileSystem() {
+        return null;
+    }
+    loadNetworkResource(urlString, _headers, streamId, callback) {
+        let url;
+        try {
+            url = new URL(urlString);
+        }
+        catch {
+            callback({
+                statusCode: 404,
+                urlValid: false,
+            });
+            return;
+        }
+        let contentPromise;
+        if (url.protocol === 'file:') {
+            contentPromise = readFile(url, { encoding: 'utf8' });
+        }
+        else if (url.protocol === 'http:' || url.protocol === 'https:') {
+            // We skip parsing headers. DevTools only sets cache and user agent, which is probably fine to not forward.
+            contentPromise = fetch(url).then(response => {
+                if (!response.ok) {
+                    throw new Error('Fetch failed');
+                }
+                return response.text();
+            });
+        }
+        else {
+            // Unknown protocol.
+            callback({
+                statusCode: 404,
+                urlValid: false,
+            });
+            return;
+        }
+        contentPromise
+            .then(content => {
+            streamWrite(streamId, content);
+            callback({ statusCode: 200 });
+        })
+            .catch(() => {
+            callback({ statusCode: 404 });
+        });
+    }
+    registerPreference() {
+    }
+    getPreferences() {
+    }
+    getPreference() {
+    }
+    setPreference() {
+    }
+    removePreference() {
+    }
+    clearPreferences() {
+    }
+    getSyncInformation() {
+    }
+    getHostConfig() {
+    }
+    upgradeDraggedFileSystemPermissions() {
+    }
+    platform() {
+        switch (process.platform) {
+            case 'darwin':
+                return 'mac';
+            case 'win32':
+                return 'windows';
+            default:
+                return 'linux';
+        }
+    }
+    recordCountHistogram() {
+    }
+    recordEnumeratedHistogram() {
+    }
+    recordPerformanceHistogram() {
+    }
+    recordUserMetricsAction() {
+    }
+    recordNewBadgeUsage() {
+    }
+    sendMessageToBackend() {
+    }
+    setDevicesDiscoveryConfig() {
+    }
+    setDevicesUpdatesEnabled() {
+    }
+    openRemotePage() {
+    }
+    openNodeFrontend() {
+    }
+    setInjectedScriptForOrigin() {
+    }
+    setIsDocked() {
+    }
+    showSurvey() {
+    }
+    canShowSurvey() {
+    }
+    zoomFactor() {
+        return 1;
+    }
+    zoomIn() {
+    }
+    zoomOut() {
+    }
+    resetZoom() {
+    }
+    showContextMenuAtPoint() {
+    }
+    reattach() {
+    }
+    readyForTest() {
+    }
+    connectionReady() {
+    }
+    setOpenNewWindowForPopups() {
+    }
+    isHostedMode() {
+        return true;
+    }
+    setAddExtensionCallback() {
+    }
+    initialTargetId() {
+        return Promise.resolve(null);
+    }
+    doAidaConversation(_request, _streamId, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    registerAidaClientEvent(_request, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    aidaCodeComplete(_request, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    dispatchHttpRequest(_request, cb) {
+        cb({
+            error: 'Not implemented',
+        });
+    }
+    recordImpression() {
+    }
+    recordResize() {
+    }
+    recordClick() {
+    }
+    recordHover() {
+    }
+    recordDrag() {
+    }
+    recordChange() {
+    }
+    recordKeyDown() {
+    }
+    recordSettingAccess() {
+    }
+    recordFunctionCall() {
+    }
+}