@nativescript/core 8.9.0-alpha.2 → 8.9.0-napi-es5.0

package/debugger/InspectorBackendCommands.js

@@ -1,20 +1,22 @@
 export function DomainDispatcher(domain) {
-    return (klass) => __registerDomainDispatcher(domain, klass);
+    return function (klass) { return __registerDomainDispatcher(domain, klass); };
 }
 // Heap
 // Heap domain exposes JavaScript heap attributes and capabilities.
 export var HeapDomain;
 (function (HeapDomain) {
-    class HeapFrontend {
+    var HeapFrontend = /** @class */ (function () {
+        function HeapFrontend() {
+        }
         // Information about the garbage collection.
-        garbageCollected(collection) {
+        HeapFrontend.prototype.garbageCollected = function (collection) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Heap.garbageCollected',
                 params: { collection: collection },
             }));
-        }
+        };
         // Tracking started.
-        trackingStart(timestamp, snapshotData) {
+        HeapFrontend.prototype.trackingStart = function (timestamp, snapshotData) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Heap.trackingStart',
                 params: {
@@ -22,9 +24,9 @@ export var HeapDomain;
                     snapshotData: snapshotData,
                 },
             }));
-        }
+        };
         // Tracking stopped.
-        trackingComplete(timestamp, snapshotData) {
+        HeapFrontend.prototype.trackingComplete = function (timestamp, snapshotData) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Heap.trackingComplete',
                 params: {
@@ -32,24 +34,27 @@ export var HeapDomain;
                     snapshotData: snapshotData,
                 },
             }));
-        }
-    }
+        };
+        return HeapFrontend;
+    }());
     HeapDomain.HeapFrontend = HeapFrontend;
 })(HeapDomain || (HeapDomain = {}));
 // Debugger
 // Debugger domain exposes JavaScript debugging capabilities. It allows setting and removing breakpoints, stepping through execution, exploring stack traces, etc.
 export var DebuggerDomain;
 (function (DebuggerDomain) {
-    class DebuggerFrontend {
+    var DebuggerFrontend = /** @class */ (function () {
+        function DebuggerFrontend() {
+        }
         // Called when global has been cleared and debugger client should reset its state. Happens upon navigation or reload.
-        globalObjectCleared() {
+        DebuggerFrontend.prototype.globalObjectCleared = function () {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Debugger.globalObjectCleared',
                 params: {},
             }));
-        }
+        };
         // Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.
-        scriptParsed(scriptId, url, startLine, startColumn, endLine, endColumn, isContentScript, sourceURL, sourceMapURL) {
+        DebuggerFrontend.prototype.scriptParsed = function (scriptId, url, startLine, startColumn, endLine, endColumn, isContentScript, sourceURL, sourceMapURL) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Debugger.scriptParsed',
                 params: {
@@ -64,9 +69,9 @@ export var DebuggerDomain;
                     sourceMapURL: sourceMapURL,
                 },
             }));
-        }
+        };
         // Fired when virtual machine fails to parse the script.
-        scriptFailedToParse(url, scriptSource, startLine, errorLine, errorMessage) {
+        DebuggerFrontend.prototype.scriptFailedToParse = function (url, scriptSource, startLine, errorLine, errorMessage) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Debugger.scriptFailedToParse',
                 params: {
@@ -77,16 +82,16 @@ export var DebuggerDomain;
                     errorMessage: errorMessage,
                 },
             }));
-        }
+        };
         // Fired when breakpoint is resolved to an actual script and location.
-        breakpointResolved(breakpointId, location) {
+        DebuggerFrontend.prototype.breakpointResolved = function (breakpointId, location) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Debugger.breakpointResolved',
                 params: { breakpointId: breakpointId, location: location },
             }));
-        }
+        };
         // Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.
-        paused(callFrames, reason /* XHR,DOM,EventListener,exception,assert,CSPViolation,DebuggerStatement,Breakpoint,PauseOnNextStatement,other */, data) {
+        DebuggerFrontend.prototype.paused = function (callFrames, reason /* XHR,DOM,EventListener,exception,assert,CSPViolation,DebuggerStatement,Breakpoint,PauseOnNextStatement,other */, data) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Debugger.paused',
                 params: {
@@ -95,71 +100,77 @@ export var DebuggerDomain;
                     data: data,
                 },
             }));
-        }
+        };
         // Fired when the virtual machine resumed execution.
-        resumed() {
+        DebuggerFrontend.prototype.resumed = function () {
             __inspectorSendEvent(JSON.stringify({ method: 'Debugger.resumed', params: {} }));
-        }
+        };
         // Fires when a new probe sample is collected.
-        didSampleProbe(sample) {
+        DebuggerFrontend.prototype.didSampleProbe = function (sample) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Debugger.didSampleProbe',
                 params: { sample: sample },
             }));
-        }
+        };
         // Fired when a "sound" breakpoint action is triggered on a breakpoint.
-        playBreakpointActionSound(breakpointActionId) {
+        DebuggerFrontend.prototype.playBreakpointActionSound = function (breakpointActionId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Debugger.playBreakpointActionSound',
                 params: { breakpointActionId: breakpointActionId },
             }));
-        }
-    }
+        };
+        return DebuggerFrontend;
+    }());
     DebuggerDomain.DebuggerFrontend = DebuggerFrontend;
 })(DebuggerDomain || (DebuggerDomain = {}));
 // Runtime
 // Runtime domain exposes JavaScript runtime by means of remote evaluation and mirror objects. Evaluation results are returned as mirror object that expose object type, string representation and unique identifier that can be used for further object reference. Original objects are maintained in memory unless they are either explicitly released or are released along with the other objects in their object group.
 export var RuntimeDomain;
 (function (RuntimeDomain) {
-    class RuntimeFrontend {
+    var RuntimeFrontend = /** @class */ (function () {
+        function RuntimeFrontend() {
+        }
         // Issued when new execution context is created.
-        executionContextCreated(context) {
+        RuntimeFrontend.prototype.executionContextCreated = function (context) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Runtime.executionContextCreated',
                 params: { context: context },
             }));
-        }
-    }
+        };
+        return RuntimeFrontend;
+    }());
     RuntimeDomain.RuntimeFrontend = RuntimeFrontend;
 })(RuntimeDomain || (RuntimeDomain = {}));
 // Console
 // Console domain defines methods and events for interaction with the JavaScript console. Console collects messages created by means of the <a href='http://getfirebug.com/wiki/index.php/Console_API'>JavaScript Console API</a>. One needs to enable this domain using <code>enable</code> command in order to start receiving the console messages. Browser collects messages issued while console domain is not enabled as well and reports them using <code>messageAdded</code> notification upon enabling.
 export var ConsoleDomain;
 (function (ConsoleDomain) {
-    class ConsoleFrontend {
+    var ConsoleFrontend = /** @class */ (function () {
+        function ConsoleFrontend() {
+        }
         // Issued when new console message is added.
-        messageAdded(message) {
+        ConsoleFrontend.prototype.messageAdded = function (message) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Console.messageAdded',
                 params: { message: message },
             }));
-        }
+        };
         // Issued when subsequent message(s) are equal to the previous one(s).
-        messageRepeatCountUpdated(count) {
+        ConsoleFrontend.prototype.messageRepeatCountUpdated = function (count) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Console.messageRepeatCountUpdated',
                 params: { count: count },
             }));
-        }
+        };
         // Issued when console is cleared. This happens either upon <code>clearMessages</code> command or after page navigation.
-        messagesCleared() {
+        ConsoleFrontend.prototype.messagesCleared = function () {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Console.messagesCleared',
                 params: {},
             }));
-        }
+        };
         // Issued from console.takeHeapSnapshot.
-        heapSnapshot(timestamp, snapshotData, title) {
+        ConsoleFrontend.prototype.heapSnapshot = function (timestamp, snapshotData, title) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Console.heapSnapshot',
                 params: {
@@ -168,100 +179,106 @@ export var ConsoleDomain;
                     title: title,
                 },
             }));
-        }
-    }
+        };
+        return ConsoleFrontend;
+    }());
     ConsoleDomain.ConsoleFrontend = ConsoleFrontend;
 })(ConsoleDomain || (ConsoleDomain = {}));
 // Page
 // Actions and events related to the inspected page belong to the page domain.
 export var PageDomain;
 (function (PageDomain) {
-    class PageFrontend {
-        domContentEventFired(timestamp) {
+    var PageFrontend = /** @class */ (function () {
+        function PageFrontend() {
+        }
+        PageFrontend.prototype.domContentEventFired = function (timestamp) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.domContentEventFired',
                 params: { timestamp: timestamp },
             }));
-        }
-        loadEventFired(timestamp) {
+        };
+        PageFrontend.prototype.loadEventFired = function (timestamp) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.loadEventFired',
                 params: { timestamp: timestamp },
             }));
-        }
+        };
         // Fired once navigation of the frame has completed. Frame is now associated with the new loader.
-        frameNavigated(frame) {
+        PageFrontend.prototype.frameNavigated = function (frame) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.frameNavigated',
                 params: { frame: frame },
             }));
-        }
+        };
         // Fired when frame has been detached from its parent.
-        frameDetached(frameId) {
+        PageFrontend.prototype.frameDetached = function (frameId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.frameDetached',
                 params: { frameId: frameId },
             }));
-        }
+        };
         // Fired when frame has started loading.
-        frameStartedLoading(frameId) {
+        PageFrontend.prototype.frameStartedLoading = function (frameId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.frameStartedLoading',
                 params: { frameId: frameId },
             }));
-        }
+        };
         // Fired when frame has stopped loading.
-        frameStoppedLoading(frameId) {
+        PageFrontend.prototype.frameStoppedLoading = function (frameId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.frameStoppedLoading',
                 params: { frameId: frameId },
             }));
-        }
+        };
         // Fired when frame schedules a potential navigation.
-        frameScheduledNavigation(frameId, delay) {
+        PageFrontend.prototype.frameScheduledNavigation = function (frameId, delay) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.frameScheduledNavigation',
                 params: { frameId: frameId, delay: delay },
             }));
-        }
+        };
         // Fired when frame no longer has a scheduled navigation.
-        frameClearedScheduledNavigation(frameId) {
+        PageFrontend.prototype.frameClearedScheduledNavigation = function (frameId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.frameClearedScheduledNavigation',
                 params: { frameId: frameId },
             }));
-        }
+        };
         // Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) is about to open.
-        javascriptDialogOpening(message) {
+        PageFrontend.prototype.javascriptDialogOpening = function (message) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.javascriptDialogOpening',
                 params: { message: message },
             }));
-        }
+        };
         // Fired when a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload) has been closed.
-        javascriptDialogClosed() {
+        PageFrontend.prototype.javascriptDialogClosed = function () {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.javascriptDialogClosed',
                 params: {},
             }));
-        }
+        };
         // Fired when the JavaScript is enabled/disabled on the page
-        scriptsEnabled(isEnabled) {
+        PageFrontend.prototype.scriptsEnabled = function (isEnabled) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Page.scriptsEnabled',
                 params: { isEnabled: isEnabled },
             }));
-        }
-    }
+        };
+        return PageFrontend;
+    }());
     PageDomain.PageFrontend = PageFrontend;
 })(PageDomain || (PageDomain = {}));
 // Network
 // Network domain allows tracking network activities of the page. It exposes information about http, file, data and other requests and responses, their headers, bodies, timing, etc.
 export var NetworkDomain;
 (function (NetworkDomain) {
-    class NetworkFrontend {
+    var NetworkFrontend = /** @class */ (function () {
+        function NetworkFrontend() {
+        }
         // Fired when page is about to send HTTP request.
-        requestWillBeSent(requestId, frameId, loaderId, documentURL, request, timestamp, initiator, redirectResponse, type) {
+        NetworkFrontend.prototype.requestWillBeSent = function (requestId, frameId, loaderId, documentURL, request, timestamp, initiator, redirectResponse, type) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.requestWillBeSent',
                 params: {
@@ -276,16 +293,16 @@ export var NetworkDomain;
                     type: type,
                 },
             }));
-        }
+        };
         // Fired if request ended up loading from cache.
-        requestServedFromCache(requestId) {
+        NetworkFrontend.prototype.requestServedFromCache = function (requestId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.requestServedFromCache',
                 params: { requestId: requestId },
             }));
-        }
+        };
         // Fired when HTTP response is available.
-        responseReceived(requestId, frameId, loaderId, timestamp, type, response) {
+        NetworkFrontend.prototype.responseReceived = function (requestId, frameId, loaderId, timestamp, type, response) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.responseReceived',
                 params: {
@@ -297,9 +314,9 @@ export var NetworkDomain;
                     response: response,
                 },
             }));
-        }
+        };
         // Fired when data chunk was received over the network.
-        dataReceived(requestId, timestamp, dataLength, encodedDataLength) {
+        NetworkFrontend.prototype.dataReceived = function (requestId, timestamp, dataLength, encodedDataLength) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.dataReceived',
                 params: {
@@ -309,9 +326,9 @@ export var NetworkDomain;
                     encodedDataLength: encodedDataLength,
                 },
             }));
-        }
+        };
         // Fired when HTTP request has finished loading.
-        loadingFinished(requestId, timestamp, sourceMapURL) {
+        NetworkFrontend.prototype.loadingFinished = function (requestId, timestamp, sourceMapURL) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.loadingFinished',
                 params: {
@@ -320,9 +337,9 @@ export var NetworkDomain;
                     sourceMapURL: sourceMapURL,
                 },
             }));
-        }
+        };
         // Fired when HTTP request has failed to load.
-        loadingFailed(requestId, timestamp, errorText, canceled) {
+        NetworkFrontend.prototype.loadingFailed = function (requestId, timestamp, errorText, canceled) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.loadingFailed',
                 params: {
@@ -332,9 +349,9 @@ export var NetworkDomain;
                     canceled: canceled,
                 },
             }));
-        }
+        };
         // Fired when HTTP request has been served from memory cache.
-        requestServedFromMemoryCache(requestId, frameId, loaderId, documentURL, timestamp, initiator, resource) {
+        NetworkFrontend.prototype.requestServedFromMemoryCache = function (requestId, frameId, loaderId, documentURL, timestamp, initiator, resource) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.requestServedFromMemoryCache',
                 params: {
@@ -347,9 +364,9 @@ export var NetworkDomain;
                     resource: resource,
                 },
             }));
-        }
+        };
         // Fired when WebSocket is about to initiate handshake.
-        webSocketWillSendHandshakeRequest(requestId, timestamp, request) {
+        NetworkFrontend.prototype.webSocketWillSendHandshakeRequest = function (requestId, timestamp, request) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.webSocketWillSendHandshakeRequest',
                 params: {
@@ -358,9 +375,9 @@ export var NetworkDomain;
                     request: request,
                 },
             }));
-        }
+        };
         // Fired when WebSocket handshake response becomes available.
-        webSocketHandshakeResponseReceived(requestId, timestamp, response) {
+        NetworkFrontend.prototype.webSocketHandshakeResponseReceived = function (requestId, timestamp, response) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.webSocketHandshakeResponseReceived',
                 params: {
@@ -369,23 +386,23 @@ export var NetworkDomain;
                     response: response,
                 },
             }));
-        }
+        };
         // Fired upon WebSocket creation.
-        webSocketCreated(requestId, url) {
+        NetworkFrontend.prototype.webSocketCreated = function (requestId, url) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.webSocketCreated',
                 params: { requestId: requestId, url: url },
             }));
-        }
+        };
         // Fired when WebSocket is closed.
-        webSocketClosed(requestId, timestamp) {
+        NetworkFrontend.prototype.webSocketClosed = function (requestId, timestamp) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.webSocketClosed',
                 params: { requestId: requestId, timestamp: timestamp },
             }));
-        }
+        };
         // Fired when WebSocket frame is received.
-        webSocketFrameReceived(requestId, timestamp, response) {
+        NetworkFrontend.prototype.webSocketFrameReceived = function (requestId, timestamp, response) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.webSocketFrameReceived',
                 params: {
@@ -394,9 +411,9 @@ export var NetworkDomain;
                     response: response,
                 },
             }));
-        }
+        };
         // Fired when WebSocket frame error occurs.
-        webSocketFrameError(requestId, timestamp, errorMessage) {
+        NetworkFrontend.prototype.webSocketFrameError = function (requestId, timestamp, errorMessage) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.webSocketFrameError',
                 params: {
@@ -405,9 +422,9 @@ export var NetworkDomain;
                     errorMessage: errorMessage,
                 },
             }));
-        }
+        };
         // Fired when WebSocket frame is sent.
-        webSocketFrameSent(requestId, timestamp, response) {
+        NetworkFrontend.prototype.webSocketFrameSent = function (requestId, timestamp, response) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'Network.webSocketFrameSent',
                 params: {
@@ -416,63 +433,66 @@ export var NetworkDomain;
                     response: response,
                 },
             }));
-        }
-    }
+        };
+        return NetworkFrontend;
+    }());
     NetworkDomain.NetworkFrontend = NetworkFrontend;
 })(NetworkDomain || (NetworkDomain = {}));
 // DOM
 // This domain exposes DOM read/write operations. Each DOM Node is represented with its mirror object that has an <code>id</code>. This <code>id</code> can be used to get additional information on the Node, resolve it into the JavaScript object wrapper, etc. It is important that client receives DOM events only for the nodes that are known to the client. Backend keeps track of the nodes that were sent to the client and never sends the same node twice. It is client's responsibility to collect information about the nodes that were sent to the client.
 export var DOMDomain;
 (function (DOMDomain) {
-    class DOMFrontend {
+    var DOMFrontend = /** @class */ (function () {
+        function DOMFrontend() {
+        }
         // Fired when <code>Document</code> has been totally updated. Node ids are no longer valid.
-        documentUpdated() {
+        DOMFrontend.prototype.documentUpdated = function () {
             __inspectorSendEvent(JSON.stringify({ method: 'DOM.documentUpdated', params: {} }));
-        }
+        };
         // Fired when backend wants to provide client with the missing DOM structure. This happens upon most of the calls requesting node ids.
-        setChildNodes(parentId, nodes) {
+        DOMFrontend.prototype.setChildNodes = function (parentId, nodes) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.setChildNodes',
                 params: { parentId: parentId, nodes: nodes },
             }));
-        }
+        };
         // Fired when <code>Element</code>'s attribute is modified.
-        attributeModified(nodeId, name, value) {
+        DOMFrontend.prototype.attributeModified = function (nodeId, name, value) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.attributeModified',
                 params: { nodeId: nodeId, name: name, value: value },
             }));
-        }
+        };
         // Fired when <code>Element</code>'s attribute is removed.
-        attributeRemoved(nodeId, name) {
+        DOMFrontend.prototype.attributeRemoved = function (nodeId, name) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.attributeRemoved',
                 params: { nodeId: nodeId, name: name },
             }));
-        }
+        };
         // Fired when <code>Element</code>'s inline style is modified via a CSS property modification.
-        inlineStyleInvalidated(nodeIds) {
+        DOMFrontend.prototype.inlineStyleInvalidated = function (nodeIds) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.inlineStyleInvalidated',
                 params: { nodeIds: nodeIds },
             }));
-        }
+        };
         // Mirrors <code>DOMCharacterDataModified</code> event.
-        characterDataModified(nodeId, characterData) {
+        DOMFrontend.prototype.characterDataModified = function (nodeId, characterData) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.characterDataModified',
                 params: { nodeId: nodeId, characterData: characterData },
             }));
-        }
+        };
         // Fired when <code>Container</code>'s child node count has changed.
-        childNodeCountUpdated(nodeId, childNodeCount) {
+        DOMFrontend.prototype.childNodeCountUpdated = function (nodeId, childNodeCount) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.childNodeCountUpdated',
                 params: { nodeId: nodeId, childNodeCount: childNodeCount },
             }));
-        }
+        };
         // Mirrors <code>DOMNodeInserted</code> event.
-        childNodeInserted(parentNodeId, previousNodeId, node) {
+        DOMFrontend.prototype.childNodeInserted = function (parentNodeId, previousNodeId, node) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.childNodeInserted',
                 params: {
@@ -481,30 +501,30 @@ export var DOMDomain;
                     node: node,
                 },
             }));
-        }
+        };
         // Mirrors <code>DOMNodeRemoved</code> event.
-        childNodeRemoved(parentNodeId, nodeId) {
+        DOMFrontend.prototype.childNodeRemoved = function (parentNodeId, nodeId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.childNodeRemoved',
                 params: { parentNodeId: parentNodeId, nodeId: nodeId },
             }));
-        }
+        };
         // Called when shadow root is pushed into the element.
-        shadowRootPushed(hostId, root) {
+        DOMFrontend.prototype.shadowRootPushed = function (hostId, root) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.shadowRootPushed',
                 params: { hostId: hostId, root: root },
             }));
-        }
+        };
         // Called when shadow root is popped from the element.
-        shadowRootPopped(hostId, rootId) {
+        DOMFrontend.prototype.shadowRootPopped = function (hostId, rootId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.shadowRootPopped',
                 params: { hostId: hostId, rootId: rootId },
             }));
-        }
+        };
         // Called when a pseudo element is added to an element.
-        pseudoElementAdded(parentId, pseudoElement) {
+        DOMFrontend.prototype.pseudoElementAdded = function (parentId, pseudoElement) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.pseudoElementAdded',
                 params: {
@@ -512,9 +532,9 @@ export var DOMDomain;
                     pseudoElement: pseudoElement,
                 },
             }));
-        }
+        };
         // Called when a pseudo element is removed from an element.
-        pseudoElementRemoved(parentId, pseudoElementId) {
+        DOMFrontend.prototype.pseudoElementRemoved = function (parentId, pseudoElementId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'DOM.pseudoElementRemoved',
                 params: {
@@ -522,48 +542,51 @@ export var DOMDomain;
                     pseudoElementId: pseudoElementId,
                 },
             }));
-        }
-    }
+        };
+        return DOMFrontend;
+    }());
     DOMDomain.DOMFrontend = DOMFrontend;
 })(DOMDomain || (DOMDomain = {}));
 // CSS
 // This domain exposes CSS read/write operations. All CSS objects (stylesheets, rules, and styles) have an associated 'id' used in subsequent operations on the related object. Each object type has a specific 'id' structure, and those are not interchangeable between objects of different kinds. CSS objects can be loaded using the <code>get*ForNode()</code> calls (which accept a DOM node id). A client can also discover all the existing stylesheets with the <code>getAllStyleSheets()</code> method (or keeping track of the <code>styleSheetAdded</code>/<code>styleSheetRemoved</code> events) and subsequently load the required stylesheet contents using the <code>getStyleSheet[Text]()</code> methods.
 export var CSSDomain;
 (function (CSSDomain) {
-    class CSSFrontend {
+    var CSSFrontend = /** @class */ (function () {
+        function CSSFrontend() {
+        }
         // Fires whenever a MediaQuery result changes (for example, after a browser window has been resized.) The current implementation considers only viewport-dependent media features.
-        mediaQueryResultChanged() {
+        CSSFrontend.prototype.mediaQueryResultChanged = function () {
             __inspectorSendEvent(JSON.stringify({
                 method: 'CSS.mediaQueryResultChanged',
                 params: {},
             }));
-        }
+        };
         // Fires whenever a web font gets loaded.
-        fontsUpdated() {
+        CSSFrontend.prototype.fontsUpdated = function () {
             __inspectorSendEvent(JSON.stringify({ method: 'CSS.fontsUpdated', params: {} }));
-        }
+        };
         // Fired whenever a stylesheet is changed as a result of the client operation.
-        styleSheetChanged(styleSheetId) {
+        CSSFrontend.prototype.styleSheetChanged = function (styleSheetId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'CSS.styleSheetChanged',
                 params: { styleSheetId: styleSheetId },
             }));
-        }
+        };
         // Fired whenever an active document stylesheet is added.
-        styleSheetAdded(header) {
+        CSSFrontend.prototype.styleSheetAdded = function (header) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'CSS.styleSheetAdded',
                 params: { header: header },
             }));
-        }
+        };
         // Fired whenever an active document stylesheet is removed.
-        styleSheetRemoved(styleSheetId) {
+        CSSFrontend.prototype.styleSheetRemoved = function (styleSheetId) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'CSS.styleSheetRemoved',
                 params: { styleSheetId: styleSheetId },
             }));
-        }
-        layoutEditorChange(styleSheetId, changeRange) {
+        };
+        CSSFrontend.prototype.layoutEditorChange = function (styleSheetId, changeRange) {
             __inspectorSendEvent(JSON.stringify({
                 method: 'CSS.layoutEditorChange',
                 params: {
@@ -571,8 +594,9 @@ export var CSSDomain;
                     changeRange: changeRange,
                 },
             }));
-        }
-    }
+        };
+        return CSSFrontend;
+    }());
     CSSDomain.CSSFrontend = CSSFrontend;
 })(CSSDomain || (CSSDomain = {}));
 //# sourceMappingURL=InspectorBackendCommands.js.map