@openreplay/tracker 4.1.8 → 4.1.9-beta.2

package/lib/modules/img.js

@@ -95,7 +95,7 @@ export default function (app) {
         observer.disconnect();
     });
     app.nodes.attachNodeCallback((node) => {
-        if (!hasTag(node, 'IMG')) {
+        if (!hasTag(node, 'img')) {
             return;
         }
         app.nodes.attachNodeListener(node, 'error', () => sendImgError(node));

package/lib/modules/input.js

@@ -1,18 +1,18 @@
 import { normSpaces, IN_BROWSER, getLabelAttribute } from '../utils.js';
 import { hasTag } from '../app/guards.js';
 import { SetInputTarget, SetInputValue, SetInputChecked } from '../app/messages.gen.js';
-const INPUT_TYPES = ['text', 'password', 'email', 'search', 'number', 'range', 'date'];
+const INPUT_TYPES = ['text', 'password', 'email', 'search', 'number', 'range', 'date', 'tel'];
 function isTextEditable(node) {
-    if (hasTag(node, 'TEXTAREA')) {
+    if (hasTag(node, 'textarea')) {
         return true;
     }
-    if (!hasTag(node, 'INPUT')) {
+    if (!hasTag(node, 'input')) {
         return false;
     }
     return INPUT_TYPES.includes(node.type);
 }
 function isCheckable(node) {
-    if (!hasTag(node, 'INPUT')) {
+    if (!hasTag(node, 'input')) {
         return false;
     }
     const type = node.type;
@@ -22,7 +22,7 @@ const labelElementFor = IN_BROWSER && 'labels' in HTMLInputElement.prototype
     ? (node) => {
         let p = node;
         while ((p = p.parentNode) !== null) {
-            if (hasTag(p, 'LABEL')) {
+            if (hasTag(p, 'label')) {
                 return p;
             }
         }
@@ -34,7 +34,7 @@ const labelElementFor = IN_BROWSER && 'labels' in HTMLInputElement.prototype
     : (node) => {
         let p = node;
         while ((p = p.parentNode) !== null) {
-            if (hasTag(p, 'LABEL')) {
+            if (hasTag(p, 'label')) {
                 return p;
             }
         }
@@ -111,11 +111,7 @@ export default function (app, opts) {
         inputValues.forEach((value, id) => {
             const node = app.nodes.getNode(id);
             if (!node)
-                return;
-            if (!isTextEditable(node)) {
-                inputValues.delete(id);
-                return;
-            }
+                return inputValues.delete(id);
             if (value !== node.value) {
                 inputValues.set(id, node.value);
                 if (!registeredTargets.has(id)) {
@@ -128,11 +124,7 @@ export default function (app, opts) {
         checkableValues.forEach((checked, id) => {
             const node = app.nodes.getNode(id);
             if (!node)
-                return;
-            if (!isCheckable(node)) {
-                checkableValues.delete(id);
-                return;
-            }
+                return checkableValues.delete(id);
             if (checked !== node.checked) {
                 checkableValues.set(id, node.checked);
                 app.send(SetInputChecked(id, node.checked));
@@ -146,7 +138,7 @@ export default function (app, opts) {
             return;
         }
         // TODO: support multiple select (?): use selectedOptions; Need send target?
-        if (hasTag(node, 'SELECT')) {
+        if (hasTag(node, 'select')) {
             sendInputValue(id, node);
             app.attachEventListener(node, 'change', () => {
                 sendInputValue(id, node);

package/lib/modules/mouse.js

@@ -78,7 +78,7 @@ export default function (app) {
         if (dl !== null) {
             return dl;
         }
-        if (hasTag(target, 'INPUT')) {
+        if (hasTag(target, 'input')) {
             return getInputLabel(target);
         }
         if (isClickable(target)) {

package/lib/modules/network.d.ts

@@ -0,0 +1,28 @@
+import type App from '../app/index.js';
+declare type XHRRequestBody = Parameters<XMLHttpRequest['send']>[0];
+declare type FetchRequestBody = RequestInit['body'];
+interface RequestData {
+    body: XHRRequestBody | FetchRequestBody;
+    headers: Record<string, string>;
+}
+interface ResponseData {
+    body: any;
+    headers: Record<string, string>;
+}
+interface RequestResponseData {
+    readonly status: number;
+    readonly method: string;
+    url: string;
+    request: RequestData;
+    response: ResponseData;
+}
+declare type Sanitizer = (data: RequestResponseData) => RequestResponseData | null;
+export interface Options {
+    sessionTokenHeader: string | boolean;
+    failuresOnly: boolean;
+    ignoreHeaders: Array<string> | boolean;
+    capturePayload: boolean;
+    sanitizer?: Sanitizer;
+}
+export default function (app: App, opts?: Partial<Options>): void;
+export {};

package/lib/modules/network.js

@@ -0,0 +1,200 @@
+import { NetworkRequest } from '../app/messages.gen.js';
+import { getTimeOrigin } from '../utils.js';
+function getXHRRequestDataObject(xhr) {
+    // @ts-ignore  this is 3x faster than using Map<XHR, XHRRequestData>
+    if (!xhr.__or_req_data__) {
+        // @ts-ignore
+        xhr.__or_req_data__ = { body: undefined, headers: {} };
+    }
+    // @ts-ignore
+    return xhr.__or_req_data__;
+}
+function strMethod(method) {
+    return typeof method === 'string' ? method.toUpperCase() : 'GET';
+}
+export default function (app, opts = {}) {
+    const options = Object.assign({
+        failuresOnly: false,
+        ignoreHeaders: ['Cookie', 'Set-Cookie', 'Authorization'],
+        capturePayload: false,
+        sessionTokenHeader: false,
+    }, opts);
+    const ignoreHeaders = options.ignoreHeaders;
+    const isHIgnored = Array.isArray(ignoreHeaders)
+        ? (name) => ignoreHeaders.includes(name)
+        : () => ignoreHeaders;
+    const stHeader = options.sessionTokenHeader === true ? 'X-OpenReplay-SessionToken' : options.sessionTokenHeader;
+    function setSessionTokenHeader(setRequestHeader) {
+        if (stHeader) {
+            const sessionToken = app.getSessionToken();
+            if (sessionToken) {
+                app.safe(setRequestHeader)(stHeader, sessionToken);
+            }
+        }
+    }
+    function sanitize(reqResInfo) {
+        if (!options.capturePayload) {
+            delete reqResInfo.request.body;
+            delete reqResInfo.response.body;
+        }
+        if (options.sanitizer) {
+            const resBody = reqResInfo.response.body;
+            if (typeof resBody === 'string') {
+                // Parse response in order to have handy view in sanitisation function
+                try {
+                    reqResInfo.response.body = JSON.parse(resBody);
+                }
+                catch (_a) { }
+            }
+            return options.sanitizer(reqResInfo);
+        }
+        return reqResInfo;
+    }
+    function stringify(r) {
+        if (r && typeof r.body !== 'string') {
+            try {
+                r.body = JSON.stringify(r.body);
+            }
+            catch (_a) {
+                r.body = '<unable to stringify>';
+                app.notify.warn("Openreplay fetch couldn't stringify body:", r.body);
+            }
+        }
+        return JSON.stringify(r);
+    }
+    /* ====== Fetch ====== */
+    const origFetch = window.fetch.bind(window);
+    window.fetch = (input, init = {}) => {
+        if (!(typeof input === 'string' || input instanceof URL) || app.isServiceURL(String(input))) {
+            return origFetch(input, init);
+        }
+        setSessionTokenHeader(function (name, value) {
+            if (init.headers === undefined) {
+                init.headers = {};
+            }
+            if (init.headers instanceof Headers) {
+                init.headers.append(name, value);
+            }
+            else if (Array.isArray(init.headers)) {
+                init.headers.push([name, value]);
+            }
+            else {
+                init.headers[name] = value;
+            }
+        });
+        const startTime = performance.now();
+        return origFetch(input, init).then((response) => {
+            const duration = performance.now() - startTime;
+            if (options.failuresOnly && response.status < 400) {
+                return response;
+            }
+            const r = response.clone();
+            r.text()
+                .then((text) => {
+                const reqHs = {};
+                const resHs = {};
+                if (ignoreHeaders !== true) {
+                    // request headers
+                    const writeReqHeader = ([n, v]) => {
+                        if (!isHIgnored(n)) {
+                            reqHs[n] = v;
+                        }
+                    };
+                    if (init.headers instanceof Headers) {
+                        init.headers.forEach((v, n) => writeReqHeader([n, v]));
+                    }
+                    else if (Array.isArray(init.headers)) {
+                        init.headers.forEach(writeReqHeader);
+                    }
+                    else if (typeof init.headers === 'object') {
+                        Object.entries(init.headers).forEach(writeReqHeader);
+                    }
+                    // response headers
+                    r.headers.forEach((v, n) => {
+                        if (!isHIgnored(n))
+                            resHs[n] = v;
+                    });
+                }
+                const method = strMethod(init.method);
+                const reqResInfo = sanitize({
+                    url: String(input),
+                    method,
+                    status: r.status,
+                    request: {
+                        headers: reqHs,
+                        body: init.body,
+                    },
+                    response: {
+                        headers: resHs,
+                        body: text,
+                    },
+                });
+                if (!reqResInfo) {
+                    return;
+                }
+                app.send(NetworkRequest('fetch', method, String(reqResInfo.url), stringify(reqResInfo.request), stringify(reqResInfo.response), r.status, startTime + getTimeOrigin(), duration));
+            })
+                .catch((e) => app.debug.error('Could not process Fetch response:', e));
+            return response;
+        });
+    };
+    /* ====== <> ====== */
+    /* ====== XHR ====== */
+    const nativeOpen = XMLHttpRequest.prototype.open;
+    XMLHttpRequest.prototype.open = function (initMethod, url) {
+        const xhr = this;
+        setSessionTokenHeader((name, value) => xhr.setRequestHeader(name, value));
+        let startTime = 0;
+        xhr.addEventListener('loadstart', (e) => {
+            startTime = e.timeStamp;
+        });
+        xhr.addEventListener('load', app.safe((e) => {
+            const { headers: reqHs, body: reqBody } = getXHRRequestDataObject(xhr);
+            const duration = startTime > 0 ? e.timeStamp - startTime : 0;
+            const hString = ignoreHeaders ? '' : xhr.getAllResponseHeaders(); // might be null (though only if no response received though)
+            const resHs = hString
+                ? hString
+                    .split('\r\n')
+                    .map((h) => h.split(':'))
+                    .filter((entry) => !isHIgnored(entry[0]))
+                    .reduce((hds, [name, value]) => (Object.assign(Object.assign({}, hds), { [name]: value })), {})
+                : {};
+            const method = strMethod(initMethod);
+            const reqResInfo = sanitize({
+                url: String(url),
+                method,
+                status: xhr.status,
+                request: {
+                    headers: reqHs,
+                    body: reqBody,
+                },
+                response: {
+                    headers: resHs,
+                    body: xhr.response,
+                },
+            });
+            if (!reqResInfo) {
+                return;
+            }
+            app.send(NetworkRequest('xhr', method, String(reqResInfo.url), stringify(reqResInfo.request), stringify(reqResInfo.response), xhr.status, startTime + getTimeOrigin(), duration));
+        }));
+        //TODO: handle error (though it has no Error API nor any useful information)
+        //xhr.addEventListener('error', (e) => {})
+        return nativeOpen.apply(this, arguments);
+    };
+    const nativeSend = XMLHttpRequest.prototype.send;
+    XMLHttpRequest.prototype.send = function (body) {
+        const rdo = getXHRRequestDataObject(this);
+        rdo.body = body;
+        return nativeSend.apply(this, arguments);
+    };
+    const nativeSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+    XMLHttpRequest.prototype.setRequestHeader = function (name, value) {
+        if (!isHIgnored(name)) {
+            const rdo = getXHRRequestDataObject(this);
+            rdo.headers[name] = value;
+        }
+        return nativeSetRequestHeader.apply(this, arguments);
+    };
+    /* ====== <> ====== */
+}

package/lib/modules/timing.js

@@ -1,5 +1,5 @@
 import { hasTag } from '../app/guards.js';
-import { isURL } from '../utils.js';
+import { isURL, getTimeOrigin } from '../utils.js';
 import { ResourceTiming, PageLoadTiming, PageRenderTiming } from '../app/messages.gen.js';
 function getPaintBlocks(resources) {
     const paintBlocks = [];
@@ -8,7 +8,7 @@ function getPaintBlocks(resources) {
     for (let i = 0; i < elements.length; i++) {
         const element = elements[i];
         let src = '';
-        if (hasTag(element, 'IMG')) {
+        if (hasTag(element, 'img')) {
             src = element.currentSrc || element.src;
         }
         if (!src) {
@@ -68,13 +68,12 @@ export default function (app, opts) {
     } // Resources are necessary for all timings
     let resources = {};
     function resourceTiming(entry) {
-        var _a;
         if (entry.duration < 0 || !isURL(entry.name) || app.isServiceURL(entry.name))
             return;
         if (resources !== null) {
             resources[entry.name] = entry.startTime + entry.duration;
         }
-        app.send(ResourceTiming(entry.startTime + ((_a = performance === null || performance === void 0 ? void 0 : performance.timing) === null || _a === void 0 ? void 0 : _a.navigationStart), entry.duration, entry.responseStart && entry.startTime ? entry.responseStart - entry.startTime : 0, entry.transferSize > entry.encodedBodySize ? entry.transferSize - entry.encodedBodySize : 0, entry.encodedBodySize || 0, entry.decodedBodySize || 0, entry.name, entry.initiatorType));
+        app.send(ResourceTiming(entry.startTime + getTimeOrigin(), entry.duration, entry.responseStart && entry.startTime ? entry.responseStart - entry.startTime : 0, entry.transferSize > entry.encodedBodySize ? entry.transferSize - entry.encodedBodySize : 0, entry.encodedBodySize || 0, entry.decodedBodySize || 0, entry.name, entry.initiatorType));
     }
     const observer = new PerformanceObserver((list) => list.getEntries().forEach(resourceTiming));
     let prevSessionID;
@@ -111,7 +110,11 @@ export default function (app, opts) {
             }
             if (performance.timing.loadEventEnd || performance.now() > 30000) {
                 pageLoadTimingSent = true;
-                const { navigationStart, requestStart, responseStart, responseEnd, domContentLoadedEventStart, domContentLoadedEventEnd, loadEventStart, loadEventEnd, } = performance.timing;
+                const { 
+                // should be ok to use here, (https://github.com/mdn/content/issues/4713)
+                // since it is compared with the values obtained on the page load (before any possible sleep state)
+                // deprecated though
+                navigationStart, requestStart, responseStart, responseEnd, domContentLoadedEventStart, domContentLoadedEventEnd, loadEventStart, loadEventEnd, } = performance.timing;
                 app.send(PageLoadTiming(requestStart - navigationStart || 0, responseStart - navigationStart || 0, responseEnd - navigationStart || 0, domContentLoadedEventStart - navigationStart || 0, domContentLoadedEventEnd - navigationStart || 0, loadEventStart - navigationStart || 0, loadEventEnd - navigationStart || 0, firstPaint, firstContentfulPaint));
             }
         }, 30);
@@ -143,9 +146,9 @@ export default function (app, opts) {
                 const speedIndex = paintBlocks === null
                     ? 0
                     : calculateSpeedIndex(firstContentfulPaint || firstPaint, paintBlocks);
+                const { domContentLoadedEventEnd, navigationStart } = performance.timing;
                 const timeToInteractive = interactiveWindowTickTime === null
-                    ? Math.max(interactiveWindowStartTime, firstContentfulPaint, performance.timing.domContentLoadedEventEnd - performance.timing.navigationStart ||
-                        0)
+                    ? Math.max(interactiveWindowStartTime, firstContentfulPaint, domContentLoadedEventEnd - navigationStart || 0)
                     : 0;
                 app.send(PageRenderTiming(speedIndex, firstContentfulPaint > visuallyComplete ? firstContentfulPaint : visuallyComplete, timeToInteractive));
             }

package/lib/modules/viewport.js

@@ -1,7 +1,8 @@
+import { getTimeOrigin } from '../utils.js';
 import { SetPageLocation, SetViewportSize, SetPageVisibility } from '../app/messages.gen.js';
 export default function (app) {
     let url, width, height;
-    let navigationStart = performance.timing.navigationStart;
+    let navigationStart;
     const sendSetPageLocation = app.safe(() => {
         const { URL } = document;
         if (URL !== url) {
@@ -23,6 +24,7 @@ export default function (app) {
         : app.safe(() => app.send(SetPageVisibility(document.hidden)));
     app.attachStartCallback(() => {
         url = '';
+        navigationStart = getTimeOrigin();
         width = height = -1;
         sendSetPageLocation();
         sendSetViewportSize();

package/lib/utils.d.ts

@@ -2,6 +2,7 @@ export declare const IN_BROWSER: boolean;
 export declare const IS_FIREFOX: false | RegExpMatchArray | null;
 export declare const MAX_STR_LEN = 100000;
 export declare function adjustTimeOrigin(): void;
+export declare function getTimeOrigin(): number;
 export declare const now: () => number;
 export declare const stars: (str: string) => string;
 export declare function normSpaces(str: string): string;

package/lib/utils.js

@@ -4,12 +4,14 @@ export const IS_FIREFOX = IN_BROWSER && navigator.userAgent.match(/firefox|fxios
 export const MAX_STR_LEN = 1e5;
 // Buggy to use `performance.timeOrigin || performance.timing.navigationStart`
 // https://github.com/mdn/content/issues/4713
-let timeOrigin = IN_BROWSER
-    ? Date.now() - performance.now()
-    : 0;
+// Maybe move to timer/ticker
+let timeOrigin = IN_BROWSER ? Date.now() - performance.now() : 0;
 export function adjustTimeOrigin() {
     timeOrigin = Date.now() - performance.now();
 }
+export function getTimeOrigin() {
+    return timeOrigin;
+}
 export const now = IN_BROWSER && !!performance.now
     ? () => Math.round(performance.now() + timeOrigin)
     : () => Date.now();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openreplay/tracker",
   "description": "The OpenReplay tracker main package",
-  "version": "4.1.8",
+  "version": "4.1.9-beta.2",
   "keywords": [
     "logging",
     "replay"
@@ -21,10 +21,12 @@
     "compile": "node --experimental-modules --experimental-json-modules scripts/compile.cjs",
     "build": "npm run clean && npm run tscRun && npm run rollup && npm run compile",
     "prepare": "cd ../../ && husky install tracker/.husky/",
-    "lint-front": "lint-staged"
+    "lint-front": "lint-staged",
+    "test": "jest"
   },
   "devDependencies": {
     "@babel/core": "^7.10.2",
+    "@jest/globals": "^29.3.1",
     "@rollup/plugin-babel": "^5.0.3",
     "@rollup/plugin-node-resolve": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^5.30.0",
@@ -33,13 +35,16 @@
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.1",
+    "jest": "^29.3.1",
+    "jest-environment-jsdom": "^29.3.1",
     "lint-staged": "^13.0.3",
     "prettier": "^2.7.1",
     "replace-in-files": "^2.0.3",
     "rollup": "^2.17.0",
     "rollup-plugin-terser": "^6.1.0",
     "semver": "^6.3.0",
-    "typescript": "4.6.0-dev.20211126"
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.9.4"
   },
   "dependencies": {
     "error-stack-parser": "^2.0.6"

package/cjs/app/messages.d.ts

@@ -1,52 +0,0 @@
-import * as Messages from '../common/messages.gen.js';
-export { default } from '../common/messages.gen.js';
-export declare function BatchMetadata(version: number, pageNo: number, firstIndex: number, timestamp: number, location: string): Messages.BatchMetadata;
-export declare function PartitionedMessage(partNo: number, partTotal: number): Messages.PartitionedMessage;
-export declare function Timestamp(timestamp: number): Messages.Timestamp;
-export declare function SetPageLocation(url: string, referrer: string, navigationStart: number): Messages.SetPageLocation;
-export declare function SetViewportSize(width: number, height: number): Messages.SetViewportSize;
-export declare function SetViewportScroll(x: number, y: number): Messages.SetViewportScroll;
-export declare function CreateDocument(): Messages.CreateDocument;
-export declare function CreateElementNode(id: number, parentID: number, index: number, tag: string, svg: boolean): Messages.CreateElementNode;
-export declare function CreateTextNode(id: number, parentID: number, index: number): Messages.CreateTextNode;
-export declare function MoveNode(id: number, parentID: number, index: number): Messages.MoveNode;
-export declare function RemoveNode(id: number): Messages.RemoveNode;
-export declare function SetNodeAttribute(id: number, name: string, value: string): Messages.SetNodeAttribute;
-export declare function RemoveNodeAttribute(id: number, name: string): Messages.RemoveNodeAttribute;
-export declare function SetNodeData(id: number, data: string): Messages.SetNodeData;
-export declare function SetNodeScroll(id: number, x: number, y: number): Messages.SetNodeScroll;
-export declare function SetInputTarget(id: number, label: string): Messages.SetInputTarget;
-export declare function SetInputValue(id: number, value: string, mask: number): Messages.SetInputValue;
-export declare function SetInputChecked(id: number, checked: boolean): Messages.SetInputChecked;
-export declare function MouseMove(x: number, y: number): Messages.MouseMove;
-export declare function ConsoleLog(level: string, value: string): Messages.ConsoleLog;
-export declare function PageLoadTiming(requestStart: number, responseStart: number, responseEnd: number, domContentLoadedEventStart: number, domContentLoadedEventEnd: number, loadEventStart: number, loadEventEnd: number, firstPaint: number, firstContentfulPaint: number): Messages.PageLoadTiming;
-export declare function PageRenderTiming(speedIndex: number, visuallyComplete: number, timeToInteractive: number): Messages.PageRenderTiming;
-export declare function JSException(name: string, message: string, payload: string, metadata: string): Messages.JSException;
-export declare function RawCustomEvent(name: string, payload: string): Messages.RawCustomEvent;
-export declare function UserID(id: string): Messages.UserID;
-export declare function UserAnonymousID(id: string): Messages.UserAnonymousID;
-export declare function Metadata(key: string, value: string): Messages.Metadata;
-export declare function CSSInsertRule(id: number, rule: string, index: number): Messages.CSSInsertRule;
-export declare function CSSDeleteRule(id: number, index: number): Messages.CSSDeleteRule;
-export declare function Fetch(method: string, url: string, request: string, response: string, status: number, timestamp: number, duration: number): Messages.Fetch;
-export declare function Profiler(name: string, duration: number, args: string, result: string): Messages.Profiler;
-export declare function OTable(key: string, value: string): Messages.OTable;
-export declare function StateAction(type: string): Messages.StateAction;
-export declare function Redux(action: string, state: string, duration: number): Messages.Redux;
-export declare function Vuex(mutation: string, state: string): Messages.Vuex;
-export declare function MobX(type: string, payload: string): Messages.MobX;
-export declare function NgRx(action: string, state: string, duration: number): Messages.NgRx;
-export declare function GraphQL(operationKind: string, operationName: string, variables: string, response: string): Messages.GraphQL;
-export declare function PerformanceTrack(frames: number, ticks: number, totalJSHeapSize: number, usedJSHeapSize: number): Messages.PerformanceTrack;
-export declare function ResourceTiming(timestamp: number, duration: number, ttfb: number, headerSize: number, encodedBodySize: number, decodedBodySize: number, url: string, initiator: string): Messages.ResourceTiming;
-export declare function ConnectionInformation(downlink: number, type: string): Messages.ConnectionInformation;
-export declare function SetPageVisibility(hidden: boolean): Messages.SetPageVisibility;
-export declare function LongTask(timestamp: number, duration: number, context: number, containerType: number, containerSrc: string, containerId: string, containerName: string): Messages.LongTask;
-export declare function SetNodeAttributeURLBased(id: number, name: string, value: string, baseURL: string): Messages.SetNodeAttributeURLBased;
-export declare function SetCSSDataURLBased(id: number, data: string, baseURL: string): Messages.SetCSSDataURLBased;
-export declare function TechnicalInfo(type: string, value: string): Messages.TechnicalInfo;
-export declare function CustomIssue(name: string, payload: string): Messages.CustomIssue;
-export declare function CSSInsertRuleURLBased(id: number, rule: string, index: number, baseURL: string): Messages.CSSInsertRuleURLBased;
-export declare function MouseClick(id: number, hesitationTime: number, label: string, selector: string): Messages.MouseClick;
-export declare function CreateIFrameDocument(frameID: number, id: number): Messages.CreateIFrameDocument;