chrome-devtools-mcp 0.0.1 → 0.0.2

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/ParsedURL.js

@@ -0,0 +1,459 @@
+// Copyright 2012 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 Platform from '../platform/platform.js';
+/**
+ * http://tools.ietf.org/html/rfc3986#section-5.2.4
+ */
+export function normalizePath(path) {
+    if (path.indexOf('..') === -1 && path.indexOf('.') === -1) {
+        return path;
+    }
+    // Remove leading slash (will be added back below) so we
+    // can handle all (including empty) segments consistently.
+    const segments = (path[0] === '/' ? path.substring(1) : path).split('/');
+    const normalizedSegments = [];
+    for (const segment of segments) {
+        if (segment === '.') {
+            continue;
+        }
+        else if (segment === '..') {
+            normalizedSegments.pop();
+        }
+        else {
+            normalizedSegments.push(segment);
+        }
+    }
+    let normalizedPath = normalizedSegments.join('/');
+    if (path[0] === '/' && normalizedPath) {
+        normalizedPath = '/' + normalizedPath;
+    }
+    if (normalizedPath[normalizedPath.length - 1] !== '/' &&
+        ((path[path.length - 1] === '/') || (segments[segments.length - 1] === '.') ||
+            (segments[segments.length - 1] === '..'))) {
+        normalizedPath = normalizedPath + '/';
+    }
+    return normalizedPath;
+}
+export function schemeIs(url, scheme) {
+    try {
+        return (new URL(url)).protocol === scheme;
+    }
+    catch {
+        return false;
+    }
+}
+export class ParsedURL {
+    isValid;
+    url;
+    scheme;
+    user;
+    host;
+    port;
+    path;
+    queryParams;
+    fragment;
+    folderPathComponents;
+    lastPathComponent;
+    blobInnerScheme;
+    #displayName;
+    #dataURLDisplayName;
+    constructor(url) {
+        this.isValid = false;
+        this.url = url;
+        this.scheme = '';
+        this.user = '';
+        this.host = '';
+        this.port = '';
+        this.path = '';
+        this.queryParams = '';
+        this.fragment = '';
+        this.folderPathComponents = '';
+        this.lastPathComponent = '';
+        const isBlobUrl = this.url.startsWith('blob:');
+        const urlToMatch = isBlobUrl ? url.substring(5) : url;
+        const match = urlToMatch.match(ParsedURL.urlRegex());
+        if (match) {
+            this.isValid = true;
+            if (isBlobUrl) {
+                this.blobInnerScheme = match[2].toLowerCase();
+                this.scheme = 'blob';
+            }
+            else {
+                this.scheme = match[2].toLowerCase();
+            }
+            this.user = match[3] ?? '';
+            this.host = match[4] ?? '';
+            this.port = match[5] ?? '';
+            this.path = match[6] ?? '/';
+            this.queryParams = match[7] ?? '';
+            this.fragment = match[8] ?? '';
+        }
+        else {
+            if (this.url.startsWith('data:')) {
+                this.scheme = 'data';
+                return;
+            }
+            if (this.url.startsWith('blob:')) {
+                this.scheme = 'blob';
+                return;
+            }
+            if (this.url === 'about:blank') {
+                this.scheme = 'about';
+                return;
+            }
+            this.path = this.url;
+        }
+        const lastSlashExceptTrailingIndex = this.path.lastIndexOf('/', this.path.length - 2);
+        if (lastSlashExceptTrailingIndex !== -1) {
+            this.lastPathComponent = this.path.substring(lastSlashExceptTrailingIndex + 1);
+        }
+        else {
+            this.lastPathComponent = this.path;
+        }
+        const lastSlashIndex = this.path.lastIndexOf('/');
+        if (lastSlashIndex !== -1) {
+            this.folderPathComponents = this.path.substring(0, lastSlashIndex);
+        }
+    }
+    static fromString(string) {
+        const parsedURL = new ParsedURL(string.toString());
+        if (parsedURL.isValid) {
+            return parsedURL;
+        }
+        return null;
+    }
+    static preEncodeSpecialCharactersInPath(path) {
+        // Based on net::FilePathToFileURL. Ideally we would handle
+        // '\\' as well on non-Windows file systems.
+        for (const specialChar of ['%', ';', '#', '?', ' ']) {
+            (path) = path.replaceAll(specialChar, encodeURIComponent(specialChar));
+        }
+        return path;
+    }
+    static rawPathToEncodedPathString(path) {
+        const partiallyEncoded = ParsedURL.preEncodeSpecialCharactersInPath(path);
+        if (path.startsWith('/')) {
+            return new URL(partiallyEncoded, 'file:///').pathname;
+        }
+        // URL prepends a '/'
+        return new URL('/' + partiallyEncoded, 'file:///').pathname.substr(1);
+    }
+    /**
+     * @param name Must not be encoded
+     */
+    static encodedFromParentPathAndName(parentPath, name) {
+        return ParsedURL.concatenate(parentPath, '/', ParsedURL.preEncodeSpecialCharactersInPath(name));
+    }
+    /**
+     * @param name Must not be encoded
+     */
+    static urlFromParentUrlAndName(parentUrl, name) {
+        return ParsedURL.concatenate(parentUrl, '/', ParsedURL.preEncodeSpecialCharactersInPath(name));
+    }
+    static encodedPathToRawPathString(encPath) {
+        return decodeURIComponent(encPath);
+    }
+    static rawPathToUrlString(fileSystemPath) {
+        let preEncodedPath = ParsedURL.preEncodeSpecialCharactersInPath(fileSystemPath.replace(/\\/g, '/'));
+        preEncodedPath = preEncodedPath.replace(/\\/g, '/');
+        if (!preEncodedPath.startsWith('file://')) {
+            if (preEncodedPath.startsWith('/')) {
+                preEncodedPath = 'file://' + preEncodedPath;
+            }
+            else {
+                preEncodedPath = 'file:///' + preEncodedPath;
+            }
+        }
+        return new URL(preEncodedPath).toString();
+    }
+    static relativePathToUrlString(relativePath, baseURL) {
+        const preEncodedPath = ParsedURL.preEncodeSpecialCharactersInPath(relativePath.replace(/\\/g, '/'));
+        return new URL(preEncodedPath, baseURL).toString();
+    }
+    static urlToRawPathString(fileURL, isWindows) {
+        console.assert(fileURL.startsWith('file://'), 'This must be a file URL.');
+        const decodedFileURL = decodeURIComponent(fileURL);
+        if (isWindows) {
+            return decodedFileURL.substr('file:///'.length).replace(/\//g, '\\');
+        }
+        return decodedFileURL.substr('file://'.length);
+    }
+    static sliceUrlToEncodedPathString(url, start) {
+        return url.substring(start);
+    }
+    static substr(devToolsPath, from, length) {
+        return devToolsPath.substr(from, length);
+    }
+    static substring(devToolsPath, start, end) {
+        return devToolsPath.substring(start, end);
+    }
+    static prepend(prefix, devToolsPath) {
+        return prefix + devToolsPath;
+    }
+    static concatenate(devToolsPath, ...appendage) {
+        return devToolsPath.concat(...appendage);
+    }
+    static trim(devToolsPath) {
+        return devToolsPath.trim();
+    }
+    static slice(devToolsPath, start, end) {
+        return devToolsPath.slice(start, end);
+    }
+    static join(devToolsPaths, separator) {
+        return devToolsPaths.join(separator);
+    }
+    static split(devToolsPath, separator, limit) {
+        return devToolsPath.split(separator, limit);
+    }
+    static toLowerCase(devToolsPath) {
+        return devToolsPath.toLowerCase();
+    }
+    static isValidUrlString(str) {
+        return new ParsedURL(str).isValid;
+    }
+    static urlWithoutHash(url) {
+        const hashIndex = url.indexOf('#');
+        if (hashIndex !== -1) {
+            return url.substr(0, hashIndex);
+        }
+        return url;
+    }
+    static urlRegex() {
+        if (ParsedURL.urlRegexInstance) {
+            return ParsedURL.urlRegexInstance;
+        }
+        // RegExp groups:
+        // 1 - scheme, hostname, ?port
+        // 2 - scheme (using the RFC3986 grammar)
+        // 3 - ?user:password
+        // 4 - hostname
+        // 5 - ?port
+        // 6 - ?path
+        // 7 - ?query
+        // 8 - ?fragment
+        const schemeRegex = /([A-Za-z][A-Za-z0-9+.-]*):\/\//;
+        const userRegex = /(?:([A-Za-z0-9\-._~%!$&'()*+,;=:]*)@)?/;
+        const hostRegex = /((?:\[::\d?\])|(?:[^\s\/:]*))/;
+        const portRegex = /(?::([\d]+))?/;
+        const pathRegex = /(\/[^#?]*)?/;
+        const queryRegex = /(?:\?([^#]*))?/;
+        const fragmentRegex = /(?:#(.*))?/;
+        ParsedURL.urlRegexInstance = new RegExp('^(' + schemeRegex.source + userRegex.source + hostRegex.source + portRegex.source + ')' + pathRegex.source +
+            queryRegex.source + fragmentRegex.source + '$');
+        return ParsedURL.urlRegexInstance;
+    }
+    static extractPath(url) {
+        const parsedURL = this.fromString(url);
+        return (parsedURL ? parsedURL.path : '');
+    }
+    static extractOrigin(url) {
+        const parsedURL = this.fromString(url);
+        return parsedURL ? parsedURL.securityOrigin() : Platform.DevToolsPath.EmptyUrlString;
+    }
+    static extractExtension(url) {
+        url = ParsedURL.urlWithoutHash(url);
+        const indexOfQuestionMark = url.indexOf('?');
+        if (indexOfQuestionMark !== -1) {
+            url = url.substr(0, indexOfQuestionMark);
+        }
+        const lastIndexOfSlash = url.lastIndexOf('/');
+        if (lastIndexOfSlash !== -1) {
+            url = url.substr(lastIndexOfSlash + 1);
+        }
+        const lastIndexOfDot = url.lastIndexOf('.');
+        if (lastIndexOfDot !== -1) {
+            url = url.substr(lastIndexOfDot + 1);
+            const lastIndexOfPercent = url.indexOf('%');
+            if (lastIndexOfPercent !== -1) {
+                return url.substr(0, lastIndexOfPercent);
+            }
+            return url;
+        }
+        return '';
+    }
+    static extractName(url) {
+        let index = url.lastIndexOf('/');
+        const pathAndQuery = index !== -1 ? url.substr(index + 1) : url;
+        index = pathAndQuery.indexOf('?');
+        return index < 0 ? pathAndQuery : pathAndQuery.substr(0, index);
+    }
+    static completeURL(baseURL, href) {
+        // Return special URLs as-is.
+        if (href.startsWith('data:') || href.startsWith('blob:') || href.startsWith('javascript:') ||
+            href.startsWith('mailto:')) {
+            return href;
+        }
+        // Return absolute URLs with normalized path and other components as-is.
+        const trimmedHref = href.trim();
+        const parsedHref = this.fromString(trimmedHref);
+        if (parsedHref?.scheme) {
+            const securityOrigin = parsedHref.securityOrigin();
+            const pathText = normalizePath(parsedHref.path);
+            const queryText = parsedHref.queryParams && `?${parsedHref.queryParams}`;
+            const fragmentText = parsedHref.fragment && `#${parsedHref.fragment}`;
+            return securityOrigin + pathText + queryText + fragmentText;
+        }
+        const parsedURL = this.fromString(baseURL);
+        if (!parsedURL) {
+            return null;
+        }
+        if (parsedURL.isDataURL()) {
+            return href;
+        }
+        if (href.length > 1 && href.charAt(0) === '/' && href.charAt(1) === '/') {
+            // href starts with "//" which is a full URL with the protocol dropped (use the baseURL protocol).
+            return parsedURL.scheme + ':' + href;
+        }
+        const securityOrigin = parsedURL.securityOrigin();
+        const pathText = parsedURL.path;
+        const queryText = parsedURL.queryParams ? '?' + parsedURL.queryParams : '';
+        // Empty href resolves to a URL without fragment.
+        if (!href.length) {
+            return securityOrigin + pathText + queryText;
+        }
+        if (href.charAt(0) === '#') {
+            return securityOrigin + pathText + queryText + href;
+        }
+        if (href.charAt(0) === '?') {
+            return securityOrigin + pathText + href;
+        }
+        const hrefMatches = href.match(/^[^#?]*/);
+        if (!hrefMatches || !href.length) {
+            throw new Error('Invalid href');
+        }
+        let hrefPath = hrefMatches[0];
+        const hrefSuffix = href.substring(hrefPath.length);
+        if (hrefPath.charAt(0) !== '/') {
+            hrefPath = parsedURL.folderPathComponents + '/' + hrefPath;
+        }
+        return securityOrigin + normalizePath(hrefPath) + hrefSuffix;
+    }
+    static splitLineAndColumn(string) {
+        // Only look for line and column numbers in the path to avoid matching port numbers.
+        const beforePathMatch = string.match(ParsedURL.urlRegex());
+        let beforePath = '';
+        let pathAndAfter = string;
+        if (beforePathMatch) {
+            beforePath = beforePathMatch[1];
+            pathAndAfter = string.substring(beforePathMatch[1].length);
+        }
+        const lineColumnRegEx = /(?::(\d+))?(?::(\d+))?$/;
+        const lineColumnMatch = lineColumnRegEx.exec(pathAndAfter);
+        let lineNumber;
+        let columnNumber;
+        console.assert(Boolean(lineColumnMatch));
+        if (!lineColumnMatch) {
+            return { url: string, lineNumber: 0, columnNumber: 0 };
+        }
+        if (typeof (lineColumnMatch[1]) === 'string') {
+            lineNumber = parseInt(lineColumnMatch[1], 10);
+            // Immediately convert line and column to 0-based numbers.
+            lineNumber = isNaN(lineNumber) ? undefined : lineNumber - 1;
+        }
+        if (typeof (lineColumnMatch[2]) === 'string') {
+            columnNumber = parseInt(lineColumnMatch[2], 10);
+            columnNumber = isNaN(columnNumber) ? undefined : columnNumber - 1;
+        }
+        let url = beforePath + pathAndAfter.substring(0, pathAndAfter.length - lineColumnMatch[0].length);
+        if (lineColumnMatch[1] === undefined && lineColumnMatch[2] === undefined) {
+            const wasmCodeOffsetRegex = /wasm-function\[\d+\]:0x([a-z0-9]+)$/g;
+            const wasmCodeOffsetMatch = wasmCodeOffsetRegex.exec(pathAndAfter);
+            if (wasmCodeOffsetMatch && typeof (wasmCodeOffsetMatch[1]) === 'string') {
+                url = ParsedURL.removeWasmFunctionInfoFromURL(url);
+                columnNumber = parseInt(wasmCodeOffsetMatch[1], 16);
+                columnNumber = isNaN(columnNumber) ? undefined : columnNumber;
+            }
+        }
+        return { url, lineNumber, columnNumber };
+    }
+    static removeWasmFunctionInfoFromURL(url) {
+        const wasmFunctionRegEx = /:wasm-function\[\d+\]/;
+        const wasmFunctionIndex = url.search(wasmFunctionRegEx);
+        if (wasmFunctionIndex === -1) {
+            return url;
+        }
+        return ParsedURL.substring(url, 0, wasmFunctionIndex);
+    }
+    static beginsWithWindowsDriveLetter(url) {
+        return /^[A-Za-z]:/.test(url);
+    }
+    static beginsWithScheme(url) {
+        return /^[A-Za-z][A-Za-z0-9+.-]*:/.test(url);
+    }
+    static isRelativeURL(url) {
+        return !this.beginsWithScheme(url) || this.beginsWithWindowsDriveLetter(url);
+    }
+    get displayName() {
+        if (this.#displayName) {
+            return this.#displayName;
+        }
+        if (this.isDataURL()) {
+            return this.dataURLDisplayName();
+        }
+        if (this.isBlobURL()) {
+            return this.url;
+        }
+        if (this.isAboutBlank()) {
+            return this.url;
+        }
+        this.#displayName = this.lastPathComponent;
+        if (!this.#displayName) {
+            this.#displayName = (this.host || '') + '/';
+        }
+        if (this.#displayName === '/') {
+            this.#displayName = this.url;
+        }
+        return this.#displayName;
+    }
+    dataURLDisplayName() {
+        if (this.#dataURLDisplayName) {
+            return this.#dataURLDisplayName;
+        }
+        if (!this.isDataURL()) {
+            return '';
+        }
+        this.#dataURLDisplayName = Platform.StringUtilities.trimEndWithMaxLength(this.url, 20);
+        return this.#dataURLDisplayName;
+    }
+    isAboutBlank() {
+        return this.url === 'about:blank';
+    }
+    isDataURL() {
+        return this.scheme === 'data';
+    }
+    extractDataUrlMimeType() {
+        const regexp = /^data:((?<type>\w+)\/(?<subtype>\w+))?(;base64)?,/;
+        const match = this.url.match(regexp);
+        return {
+            type: match?.groups?.type,
+            subtype: match?.groups?.subtype,
+        };
+    }
+    isBlobURL() {
+        return this.url.startsWith('blob:');
+    }
+    lastPathComponentWithFragment() {
+        return this.lastPathComponent + (this.fragment ? '#' + this.fragment : '');
+    }
+    domain() {
+        if (this.isDataURL()) {
+            return 'data:';
+        }
+        return this.host + (this.port ? ':' + this.port : '');
+    }
+    securityOrigin() {
+        if (this.isDataURL()) {
+            return 'data:';
+        }
+        const scheme = this.isBlobURL() ? this.blobInnerScheme : this.scheme;
+        return scheme + '://' + this.domain();
+    }
+    urlWithoutScheme() {
+        if (this.scheme && this.url.startsWith(this.scheme + '://')) {
+            return this.url.substring(this.scheme.length + 3);
+        }
+        return this.url;
+    }
+    static urlRegexInstance = null;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/Progress.js

@@ -0,0 +1,137 @@
+// Copyright 2012 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export class Progress {
+    setTotalWork(_totalWork) {
+    }
+    setTitle(_title) {
+    }
+    setWorked(_worked, _title) {
+    }
+    incrementWorked(_worked) {
+    }
+    done() {
+    }
+    isCanceled() {
+        return false;
+    }
+}
+export class CompositeProgress {
+    parent;
+    #children;
+    #childrenDone;
+    constructor(parent) {
+        this.parent = parent;
+        this.#children = [];
+        this.#childrenDone = 0;
+        this.parent.setTotalWork(1);
+        this.parent.setWorked(0);
+    }
+    childDone() {
+        if (++this.#childrenDone !== this.#children.length) {
+            return;
+        }
+        this.parent.done();
+    }
+    createSubProgress(weight) {
+        const child = new SubProgress(this, weight);
+        this.#children.push(child);
+        return child;
+    }
+    update() {
+        let totalWeights = 0;
+        let done = 0;
+        for (let i = 0; i < this.#children.length; ++i) {
+            const child = this.#children[i];
+            if (child.getTotalWork()) {
+                done += child.getWeight() * child.getWorked() / child.getTotalWork();
+            }
+            totalWeights += child.getWeight();
+        }
+        this.parent.setWorked(done / totalWeights);
+    }
+}
+export class SubProgress {
+    #composite;
+    #weight;
+    #worked;
+    #totalWork;
+    constructor(composite, weight) {
+        this.#composite = composite;
+        this.#weight = weight || 1;
+        this.#worked = 0;
+        this.#totalWork = 0;
+    }
+    isCanceled() {
+        return this.#composite.parent.isCanceled();
+    }
+    setTitle(title) {
+        this.#composite.parent.setTitle(title);
+    }
+    done() {
+        this.setWorked(this.#totalWork);
+        this.#composite.childDone();
+    }
+    setTotalWork(totalWork) {
+        this.#totalWork = totalWork;
+        this.#composite.update();
+    }
+    setWorked(worked, title) {
+        this.#worked = worked;
+        if (typeof title !== 'undefined') {
+            this.setTitle(title);
+        }
+        this.#composite.update();
+    }
+    incrementWorked(worked) {
+        this.setWorked(this.#worked + (worked || 1));
+    }
+    getWeight() {
+        return this.#weight;
+    }
+    getWorked() {
+        return this.#worked;
+    }
+    getTotalWork() {
+        return this.#totalWork;
+    }
+}
+export class ProgressProxy {
+    #delegate;
+    #doneCallback;
+    constructor(delegate, doneCallback) {
+        this.#delegate = delegate;
+        this.#doneCallback = doneCallback;
+    }
+    isCanceled() {
+        return this.#delegate ? this.#delegate.isCanceled() : false;
+    }
+    setTitle(title) {
+        if (this.#delegate) {
+            this.#delegate.setTitle(title);
+        }
+    }
+    done() {
+        if (this.#delegate) {
+            this.#delegate.done();
+        }
+        if (this.#doneCallback) {
+            this.#doneCallback();
+        }
+    }
+    setTotalWork(totalWork) {
+        if (this.#delegate) {
+            this.#delegate.setTotalWork(totalWork);
+        }
+    }
+    setWorked(worked, title) {
+        if (this.#delegate) {
+            this.#delegate.setWorked(worked, title);
+        }
+    }
+    incrementWorked(worked) {
+        if (this.#delegate) {
+            this.#delegate.incrementWorked(worked);
+        }
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/QueryParamHandler.js

@@ -0,0 +1,4 @@
+// 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.
+export {};

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/ResolverBase.js

@@ -0,0 +1,69 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+/**
+ * A class that facilitates resolving a id to an object of type T. If the id does not yet resolve, a promise
+ * is created that gets resolved once `onResolve` is called with the corresponding id.
+ *
+ * This class enables clients to control the duration of the wait and the lifetime of the associated
+ * promises by using the `clear` method on this class.
+ */
+export class ResolverBase {
+    #unresolvedIds = new Map();
+    /**
+     * Returns a promise that resolves once the `id` can be resolved to an object.
+     */
+    async waitFor(id) {
+        const obj = this.getForId(id);
+        if (!obj) {
+            return await this.getOrCreatePromise(id);
+        }
+        return obj;
+    }
+    /**
+     * Resolve the `id`. Returns the object immediately if it can be resolved,
+     * and otherwise waits for the object to appear and calls `callback` once
+     * it is resolved.
+     */
+    tryGet(id, callback) {
+        const obj = this.getForId(id);
+        if (!obj) {
+            const swallowTheError = () => { };
+            void this.getOrCreatePromise(id).catch(swallowTheError).then(obj => {
+                if (obj) {
+                    callback(obj);
+                }
+            });
+            return null;
+        }
+        return obj;
+    }
+    /**
+     * Aborts all waiting and rejects all unresolved promises.
+     */
+    clear() {
+        this.stopListening();
+        for (const [id, { reject }] of this.#unresolvedIds.entries()) {
+            reject(new Error(`Object with ${id} never resolved.`));
+        }
+        this.#unresolvedIds.clear();
+    }
+    getOrCreatePromise(id) {
+        const promiseInfo = this.#unresolvedIds.get(id);
+        if (promiseInfo) {
+            return promiseInfo.promise;
+        }
+        const { resolve, reject, promise } = Promise.withResolvers();
+        this.#unresolvedIds.set(id, { promise, resolve, reject });
+        this.startListening();
+        return promise;
+    }
+    onResolve(id, t) {
+        const promiseInfo = this.#unresolvedIds.get(id);
+        this.#unresolvedIds.delete(id);
+        if (this.#unresolvedIds.size === 0) {
+            this.stopListening();
+        }
+        promiseInfo?.resolve(t);
+    }
+}