@openreplay/tracker 16.1.4 → 16.2.1

package/dist/cjs/index.js

@@ -3702,6 +3702,381 @@ class Nodes {
     }
 }
 
+let fakeIdHolder = 1000000 * 99;
+function inlineRemoteCss(node, id, baseHref, getNextID, insertRule, addOwner, forceFetch, sendPlain, onPlain) {
+    const sheetId = sendPlain ? null : getNextID();
+    if (!sendPlain) {
+        addOwner(sheetId, id);
+    }
+    const sheet = node.sheet;
+    if (sheet && !forceFetch) {
+        try {
+            const cssText = stringifyStylesheet(sheet);
+            if (cssText) {
+                processCssText(cssText);
+                return;
+            }
+        }
+        catch (e) {
+            // console.warn("Could not stringify sheet, falling back to fetch:", e);
+        }
+    }
+    // Fall back to fetching if we couldn't get or stringify the sheet
+    if (node.href) {
+        fetch(node.href)
+            .then(response => {
+            if (!response.ok) {
+                throw new Error(`response status ${response.status}`);
+            }
+            return response.text();
+        })
+            .then(cssText => {
+            if (sendPlain && onPlain) {
+                onPlain(cssText, fakeIdHolder++);
+            }
+            else {
+                processCssText(cssText);
+            }
+        })
+            .catch(error => {
+            console.error(`OpenReplay: Failed to fetch CSS from ${node.href}:`, error);
+        });
+    }
+    function processCssText(cssText) {
+        // Remove comments
+        cssText = cssText.replace(/\/\*[\s\S]*?\*\//g, '');
+        // Parse and process the CSS text to extract rules
+        const ruleTexts = parseCSS(cssText);
+        for (let i = 0; i < ruleTexts.length; i++) {
+            insertRule(sheetId, ruleTexts[i], i, baseHref);
+        }
+    }
+    function parseCSS(cssText) {
+        const rules = [];
+        let inComment = false;
+        let inString = false;
+        let stringChar = '';
+        let braceLevel = 0;
+        let currentRule = '';
+        for (let i = 0; i < cssText.length; i++) {
+            const char = cssText[i];
+            const nextChar = cssText[i + 1] || '';
+            // comments
+            if (!inString && char === '/' && nextChar === '*') {
+                inComment = true;
+                i++; // Skip the next character
+                continue;
+            }
+            if (inComment) {
+                if (char === '*' && nextChar === '/') {
+                    inComment = false;
+                    i++; // Skip the next character
+                }
+                continue;
+            }
+            if (!inString && (char === '"' || char === "'")) {
+                inString = true;
+                stringChar = char;
+                currentRule += char;
+                continue;
+            }
+            if (inString) {
+                currentRule += char;
+                if (char === stringChar && cssText[i - 1] !== '\\') {
+                    inString = false;
+                }
+                continue;
+            }
+            currentRule += char;
+            if (char === '{') {
+                braceLevel++;
+            }
+            else if (char === '}') {
+                braceLevel--;
+                if (braceLevel === 0) {
+                    // End of a top-level rule
+                    rules.push(currentRule.trim());
+                    currentRule = '';
+                }
+            }
+        }
+        // Handle any remaining text (should be rare)
+        if (currentRule.trim()) {
+            rules.push(currentRule.trim());
+        }
+        return rules;
+    }
+    function stringifyStylesheet(s) {
+        try {
+            const rules = s.rules || s.cssRules;
+            if (!rules) {
+                return null;
+            }
+            let sheetHref = s.href;
+            if (!sheetHref && s.ownerNode && s.ownerNode.ownerDocument) {
+                // an inline <style> element
+                sheetHref = s.ownerNode.ownerDocument.location.href;
+            }
+            const stringifiedRules = Array.from(rules, (rule) => stringifyRule(rule, sheetHref)).join('');
+            return fixBrowserCompatibilityIssuesInCSS(stringifiedRules);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    function stringifyRule(rule, sheetHref) {
+        if (isCSSImportRule(rule)) {
+            let importStringified;
+            try {
+                importStringified =
+                    // for same-origin stylesheets,
+                    // we can access the imported stylesheet rules directly
+                    stringifyStylesheet(rule.styleSheet) ||
+                        // work around browser issues with the raw string `@import url(...)` statement
+                        escapeImportStatement(rule);
+            }
+            catch (error) {
+                importStringified = rule.cssText;
+            }
+            if (rule.styleSheet.href) {
+                // url()s within the imported stylesheet are relative to _that_ sheet's href
+                return absolutifyURLs(importStringified, rule.styleSheet.href);
+            }
+            return importStringified;
+        }
+        else {
+            let ruleStringified = rule.cssText;
+            if (isCSSStyleRule(rule) && rule.selectorText.includes(':')) {
+                // Safari does not escape selectors with : properly
+                ruleStringified = fixSafariColons(ruleStringified);
+            }
+            if (sheetHref) {
+                return absolutifyURLs(ruleStringified, sheetHref);
+            }
+            return ruleStringified;
+        }
+    }
+    function fixBrowserCompatibilityIssuesInCSS(cssText) {
+        // Fix for Chrome's handling of webkit-background-clip
+        if (cssText.includes(' background-clip: text;') &&
+            !cssText.includes(' -webkit-background-clip: text;')) {
+            cssText = cssText.replace(/\sbackground-clip:\s*text;/g, ' -webkit-background-clip: text; background-clip: text;');
+        }
+        return cssText;
+    }
+    function escapeImportStatement(rule) {
+        const { cssText } = rule;
+        if (cssText.split('"').length < 3)
+            return cssText;
+        const statement = ['@import', `url(${JSON.stringify(rule.href)})`];
+        if (rule.layerName === '') {
+            statement.push(`layer`);
+        }
+        else if (rule.layerName) {
+            statement.push(`layer(${rule.layerName})`);
+        }
+        if (rule.supportsText) {
+            statement.push(`supports(${rule.supportsText})`);
+        }
+        if (rule.media.length) {
+            statement.push(rule.media.mediaText);
+        }
+        return statement.join(' ') + ';';
+    }
+    function fixSafariColons(cssStringified) {
+        const regex = /(\[(?:[\w-]+)[^\\])(:(?:[\w-]+)\])/gm;
+        return cssStringified.replace(regex, '$1\\$2');
+    }
+    function isCSSImportRule(rule) {
+        return 'styleSheet' in rule;
+    }
+    function isCSSStyleRule(rule) {
+        return 'selectorText' in rule;
+    }
+    function absolutifyURLs(cssText, href) {
+        if (!cssText)
+            return '';
+        const URL_IN_CSS_REF = /url\((?:(')([^']*)'|(")(.*?)"|([^)]*))\)/gm;
+        const URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\/\//i;
+        const URL_WWW_MATCH = /^www\..*/i;
+        const DATA_URI = /^(data:)([^,]*),(.*)/i;
+        return cssText.replace(URL_IN_CSS_REF, (origin, quote1, path1, quote2, path2, path3) => {
+            const filePath = path1 || path2 || path3;
+            const maybeQuote = quote1 || quote2 || '';
+            if (!filePath) {
+                return origin;
+            }
+            if (URL_PROTOCOL_MATCH.test(filePath) || URL_WWW_MATCH.test(filePath)) {
+                return `url(${maybeQuote}${filePath}${maybeQuote})`;
+            }
+            if (DATA_URI.test(filePath)) {
+                return `url(${maybeQuote}${filePath}${maybeQuote})`;
+            }
+            if (filePath[0] === '/') {
+                return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;
+            }
+            const stack = href.split('/');
+            const parts = filePath.split('/');
+            stack.pop();
+            for (const part of parts) {
+                if (part === '.') {
+                    continue;
+                }
+                else if (part === '..') {
+                    stack.pop();
+                }
+                else {
+                    stack.push(part);
+                }
+            }
+            return `url(${maybeQuote}${stack.join('/')}${maybeQuote})`;
+        });
+    }
+    function extractOrigin(url) {
+        let origin = '';
+        if (url.indexOf('//') > -1) {
+            origin = url.split('/').slice(0, 3).join('/');
+        }
+        else {
+            origin = url.split('/')[0];
+        }
+        origin = origin.split('?')[0];
+        return origin;
+    }
+}
+
+function hasAdoptedSS(node) {
+    return (isRootNode(node) &&
+        // @ts-ignore
+        !!node.adoptedStyleSheets);
+}
+// TODO: encapsulate to be init-ed on-start and join with cssrules.ts under one folder
+let _id = 0xf;
+function nextID() {
+    return _id++;
+}
+const styleSheetIDMap = new Map();
+function ConstructedStyleSheets (app) {
+    if (app === null) {
+        return;
+    }
+    if (!hasAdoptedSS(document)) {
+        return;
+    }
+    const styleSheetIDMap = new Map();
+    const adoptedStyleSheetsOwnings = new Map();
+    const sendAdoptedStyleSheetsUpdate = (root) => setTimeout(() => {
+        let nodeID = app.nodes.getID(root);
+        if (root === document) {
+            nodeID = 0; // main document doesn't have nodeID. ID count starts from the documentElement
+        }
+        if (nodeID === undefined) {
+            return;
+        }
+        let pastOwning = adoptedStyleSheetsOwnings.get(nodeID);
+        if (!pastOwning) {
+            pastOwning = [];
+        }
+        const nowOwning = [];
+        const styleSheets = root.adoptedStyleSheets;
+        if (styleSheets && Symbol.iterator in styleSheets) {
+            for (const s of styleSheets) {
+                let sheetID = styleSheetIDMap.get(s);
+                const init = !sheetID;
+                if (!sheetID) {
+                    sheetID = nextID();
+                    styleSheetIDMap.set(s, sheetID);
+                }
+                if (!pastOwning.includes(sheetID)) {
+                    app.send(AdoptedSSAddOwner(sheetID, nodeID));
+                }
+                if (init) {
+                    const rules = s.cssRules;
+                    for (let i = 0; i < rules.length; i++) {
+                        app.send(AdoptedSSInsertRuleURLBased(sheetID, rules[i].cssText, i, app.getBaseHref()));
+                    }
+                }
+                nowOwning.push(sheetID);
+            }
+        }
+        if (Symbol.iterator in pastOwning) {
+            for (const sheetID of pastOwning) {
+                if (!nowOwning.includes(sheetID)) {
+                    app.send(AdoptedSSRemoveOwner(sheetID, nodeID));
+                }
+            }
+        }
+        adoptedStyleSheetsOwnings.set(nodeID, nowOwning);
+    }, 20); // Mysterious bug:
+    /* On the page https://explore.fast.design/components/fast-accordion
+      the only rule inside the only adoptedStyleSheet of the iframe-s document
+      gets changed during first milliseconds after the load.
+      However, none of the documented methods (replace, insertRule) is triggered.
+      The rule is not substituted (remains the same object), however the text gets changed.
+    */
+    function patchAdoptedStyleSheets(prototype) {
+        const nativeAdoptedStyleSheetsDescriptor = Object.getOwnPropertyDescriptor(prototype, 'adoptedStyleSheets');
+        if (nativeAdoptedStyleSheetsDescriptor) {
+            Object.defineProperty(prototype, 'adoptedStyleSheets', {
+                ...nativeAdoptedStyleSheetsDescriptor,
+                set: function (value) {
+                    // @ts-ignore
+                    const retVal = nativeAdoptedStyleSheetsDescriptor.set.call(this, value);
+                    sendAdoptedStyleSheetsUpdate(this);
+                    return retVal;
+                },
+            });
+        }
+    }
+    const patchContext = (context) => {
+        // @ts-ignore
+        if (context.__openreplay_adpss_patched__) {
+            return;
+        }
+        else {
+            // @ts-ignore
+            context.__openreplay_adpss_patched__ = true;
+        }
+        patchAdoptedStyleSheets(context.Document.prototype);
+        patchAdoptedStyleSheets(context.ShadowRoot.prototype);
+        //@ts-ignore TODO: upgrade ts to 4.8+
+        const { replace, replaceSync } = context.CSSStyleSheet.prototype;
+        //@ts-ignore
+        context.CSSStyleSheet.prototype.replace = function (text) {
+            return replace.call(this, text).then((sheet) => {
+                const sheetID = styleSheetIDMap.get(this);
+                if (sheetID) {
+                    app.send(AdoptedSSReplaceURLBased(sheetID, text, app.getBaseHref()));
+                }
+                return sheet;
+            });
+        };
+        //@ts-ignore
+        context.CSSStyleSheet.prototype.replaceSync = function (text) {
+            const sheetID = styleSheetIDMap.get(this);
+            if (sheetID) {
+                app.send(AdoptedSSReplaceURLBased(sheetID, text, app.getBaseHref()));
+            }
+            return replaceSync.call(this, text);
+        };
+    };
+    patchContext(window);
+    app.observer.attachContextCallback(app.safe(patchContext));
+    app.attachStopCallback(() => {
+        styleSheetIDMap.clear();
+        adoptedStyleSheetsOwnings.clear();
+    });
+    // So far main Document is not triggered with nodeCallbacks
+    app.attachStartCallback(() => {
+        sendAdoptedStyleSheetsUpdate(document);
+    });
+    app.nodes.attachNodeCallback((node) => {
+        if (hasAdoptedSS(node)) {
+            sendAdoptedStyleSheetsUpdate(node);
+        }
+    });
+}
+
 const iconCache = {};
 const svgUrlCache = {};
 async function parseUseEl(useElement, mode, domParser) {
@@ -3720,7 +4095,7 @@ async function parseUseEl(useElement, mode, domParser) {
         <svg xmlns="http://www.w3.org/2000/svg" viewBox="${symbol.getAttribute('viewBox') || '0 0 24 24'}">
           ${symbol.innerHTML}
         </svg>
-      `.trim();
+      `;
                 iconCache[symbolId] = inlineSvg;
                 return inlineSvg;
             }
@@ -3780,7 +4155,7 @@ async function parseUseEl(useElement, mode, domParser) {
         <svg xmlns="http://www.w3.org/2000/svg" viewBox="${symbol.getAttribute('viewBox') || '0 0 24 24'}">
           ${symbol.innerHTML}
         </svg>
-      `.trim();
+      `;
             iconCache[symbolId] = inlineSvg;
             return inlineSvg;
         }
@@ -3827,7 +4202,7 @@ var RecentsType;
     RecentsType[RecentsType["Changed"] = 2] = "Changed";
 })(RecentsType || (RecentsType = {}));
 class Observer {
-    constructor(app, isTopContext = false, options = { disableSprites: false }) {
+    constructor(app, isTopContext = false, options = {}) {
         this.app = app;
         this.isTopContext = isTopContext;
         this.commited = [];
@@ -3836,8 +4211,17 @@ class Observer {
         this.attributesMap = new Map();
         this.textSet = new Set();
         this.disableSprites = false;
+        /**
+         * this option means that, instead of using link element with href to load css,
+         * we will try to parse the css text instead and send it as css rules set
+         * can (and will) affect performance
+         * */
+        this.inlineRemoteCss = false;
+        this.inlinerOptions = undefined;
         this.domParser = new DOMParser();
-        this.disableSprites = options.disableSprites;
+        this.disableSprites = Boolean(options.disableSprites);
+        this.inlineRemoteCss = Boolean(options.inlineRemoteCss);
+        this.inlinerOptions = options.inlinerOptions;
         this.observer = createMutationObserver(this.app.safe((mutations) => {
             for (const mutation of mutations) {
                 // mutations order is sequential
@@ -3911,10 +4295,12 @@ class Observer {
                 false);
                 let removed = 0;
                 const totalBeforeRemove = this.app.nodes.getNodeCount();
+                const contentDocument = iframe.contentDocument;
+                const nodesUnregister = this.app.nodes.unregisterNode.bind(this.app.nodes);
                 while (walker.nextNode()) {
-                    if (!iframe.contentDocument.contains(walker.currentNode)) {
+                    if (!contentDocument.contains(walker.currentNode)) {
                         removed += 1;
-                        this.app.nodes.unregisterNode(walker.currentNode);
+                        nodesUnregister(walker.currentNode);
                     }
                 }
                 const removedPercent = Math.floor((removed / totalBeforeRemove) * 100);
@@ -3926,7 +4312,7 @@ class Observer {
     }
     sendNodeAttribute(id, node, name, value) {
         if (isSVGElement(node)) {
-            if (name.substring(0, 6) === 'xlink:') {
+            if (name.startsWith('xlink:')) {
                 name = name.substring(6);
             }
             if (value === null) {
@@ -3975,6 +4361,23 @@ class Observer {
             return;
         }
         if (name === 'style' || (name === 'href' && hasTag(node, 'link'))) {
+            if ('rel' in node && node.rel === 'stylesheet' && this.inlineRemoteCss) {
+                setTimeout(() => {
+                    inlineRemoteCss(
+                    // @ts-ignore
+                    node, id, this.app.getBaseHref(), nextID, (id, cssText, index, baseHref) => {
+                        this.app.send(AdoptedSSInsertRuleURLBased(id, cssText, index, baseHref));
+                    }, (sheetId, ownerId) => {
+                        this.app.send(AdoptedSSAddOwner(sheetId, ownerId));
+                    }, this.inlinerOptions?.forceFetch, this.inlinerOptions?.forcePlain, (cssText, fakeTextId) => {
+                        this.app.send(CreateTextNode(fakeTextId, id, 0));
+                        setTimeout(() => {
+                            this.app.send(SetCSSDataURLBased(fakeTextId, cssText, this.app.getBaseHref()));
+                        }, 10);
+                    });
+                }, 0);
+                return;
+            }
             this.app.send(SetNodeAttributeURLBased(id, name, value, this.app.getBaseHref()));
             return;
         }
@@ -4054,7 +4457,8 @@ class Observer {
         if (isRootNode(node)) {
             return true;
         }
-        const parent = node.parentNode;
+        // @ts-ignore SALESFORCE
+        const parent = node.assignedSlot ? node.assignedSlot : node.parentNode;
         let parentID;
         // Disable parent check for the upper context HTMLHtmlElement, because it is root there... (before)
         // TODO: get rid of "special" cases (there is an issue with CreateDocument altered behaviour though)
@@ -4111,7 +4515,12 @@ class Observer {
                         el.style.width = `${width}px`;
                         el.style.height = `${height}px`;
                     }
-                    this.app.send(CreateElementNode(id, parentID, index, el.tagName, isSVGElement(node)));
+                    if ('rel' in el && el.rel === 'stylesheet' && this.inlineRemoteCss) {
+                        this.app.send(CreateElementNode(id, parentID, index, 'STYLE', false));
+                    }
+                    else {
+                        this.app.send(CreateElementNode(id, parentID, index, el.tagName, isSVGElement(node)));
+                    }
                 }
                 for (let i = 0; i < el.attributes.length; i++) {
                     const attr = el.attributes[i];
@@ -4159,12 +4568,12 @@ class Observer {
     }
     commitNodes(isStart = false) {
         let node;
-        this.recents.forEach((type, id) => {
+        for (const [id, type] of this.recents.entries()) {
             this.commitNode(id);
             if (type === RecentsType.New && (node = this.app.nodes.getNode(id))) {
                 this.app.nodes.callNodeCallbacks(node, isStart);
             }
-        });
+        }
         this.clear();
     }
     // ISSSUE (nodeToBinde should be the same as node in all cases. Look at the comment about 0-node at the beginning of the file.)
@@ -4286,14 +4695,67 @@ class IFrameOffsets {
     }
 }
 
+var InlineCssMode;
+(function (InlineCssMode) {
+    /** default behavior -- will parse and cache the css file on backend */
+    InlineCssMode[InlineCssMode["Disabled"] = 0] = "Disabled";
+    /** will attempt to record the linked css file as AdoptedStyleSheet object */
+    InlineCssMode[InlineCssMode["Inline"] = 1] = "Inline";
+    /** will fetch the file, then simulated AdoptedStyleSheets behavior programmaticaly for the replay */
+    InlineCssMode[InlineCssMode["InlineFetched"] = 2] = "InlineFetched";
+    /** will fetch the file, then save it as plain css inside <style> node */
+    InlineCssMode[InlineCssMode["PlainFetched"] = 3] = "PlainFetched";
+})(InlineCssMode || (InlineCssMode = {}));
+function getInlineOptions(mode) {
+    switch (mode) {
+        case InlineCssMode.Inline:
+            return {
+                inlineRemoteCss: true,
+                inlinerOptions: {
+                    forceFetch: false,
+                    forcePlain: false,
+                },
+            };
+        case InlineCssMode.InlineFetched:
+            return {
+                inlineRemoteCss: true,
+                inlinerOptions: {
+                    forceFetch: true,
+                    forcePlain: false,
+                },
+            };
+        case InlineCssMode.PlainFetched:
+            return {
+                inlineRemoteCss: true,
+                inlinerOptions: {
+                    forceFetch: true,
+                    forcePlain: true,
+                },
+            };
+        case InlineCssMode.Disabled:
+        default:
+            return {
+                inlineRemoteCss: false,
+                inlinerOptions: {
+                    forceFetch: false,
+                    forcePlain: false,
+                },
+            };
+    }
+}
 const attachShadowNativeFn = IN_BROWSER ? Element.prototype.attachShadow : () => new ShadowRoot();
 class TopObserver extends Observer {
     constructor(params) {
         const opts = Object.assign({
             captureIFrames: true,
             disableSprites: false,
+            inlineCss: 0,
         }, params.options);
-        super(params.app, true, opts);
+        const observerOptions = {
+            disableSprites: opts.disableSprites,
+            ...getInlineOptions(opts.inlineCss)
+        };
+        super(params.app, true, observerOptions);
         this.iframeOffsets = new IFrameOffsets();
         this.contextCallbacks = [];
         // Attached once per Tracker instance
@@ -4342,7 +4804,7 @@ class TopObserver extends Observer {
                 this.app.debug.info('doc already observed for', id);
                 return;
             }
-            const observer = new IFrameObserver(this.app);
+            const observer = new IFrameObserver(this.app, false, {});
             this.iframeObservers.set(iframe, observer);
             this.docObservers.set(currentDoc, observer);
             this.iframeObserversArr.push(observer);
@@ -4744,7 +5206,7 @@ class App {
         this.stopCallbacks = [];
         this.commitCallbacks = [];
         this.activityState = ActivityState.NotActive;
-        this.version = '16.1.4'; // TODO: version compatability check inside each plugin.
+        this.version = '16.2.1'; // TODO: version compatability check inside each plugin.
         this.socketMode = false;
         this.compressionThreshold = 24 * 1000;
         this.bc = null;
@@ -4977,6 +5439,30 @@ class App {
             }
         };
         this.startTimeout = null;
+        this.send = (message, urgent = false) => {
+            if (this.activityState === ActivityState.NotActive) {
+                return;
+            }
+            // ====================================================
+            if (this.activityState === ActivityState.ColdStart) {
+                this.bufferedMessages1.push(message);
+                if (!this.singleBuffer) {
+                    this.bufferedMessages2.push(message);
+                }
+                this.conditionsManager?.processMessage(message);
+            }
+            else {
+                this.messages.push(message);
+            }
+            // TODO: commit on start if there were `urgent` sends;
+            // Clarify where urgent can be used for;
+            // Clarify workflow for each type of message in case it was sent before start
+            //      (like Fetch before start; maybe add an option "preCapture: boolean" or sth alike)
+            // Careful: `this.delay` is equal to zero before start so all Timestamp-s will have to be updated on start
+            if (this.activityState === ActivityState.Active && urgent) {
+                this.commit();
+            }
+        };
         this.coldStartCommitN = 0;
         this.delay = 0;
         this.attachStartCallback = (cb, useSafe = false) => {
@@ -5043,18 +5529,6 @@ class App {
         this.onUxtCb = [];
         this.contextId = Math.random().toString(36).slice(2);
         this.projectKey = projectKey;
-        if (Object.keys(options).findIndex((k) => ['fixedCanvasScaling', 'disableCanvas'].includes(k)) !==
-            -1) {
-            console.warn('Openreplay: canvas options are moving to separate key "canvas" in next update. Please update your configuration.');
-            options = {
-                ...options,
-                canvas: {
-                    __save_canvas_locally: options.__save_canvas_locally,
-                    fixedCanvasScaling: options.fixedCanvasScaling,
-                    disableCanvas: options.disableCanvas,
-                },
-            };
-        }
         this.networkOptions = options.network;
         const defaultOptions = {
             revID: '',
@@ -5069,18 +5543,14 @@ class App {
             __is_snippet: false,
             __debug_report_edp: null,
             __debug__: LogLevel.Silent,
-            __save_canvas_locally: false,
             localStorage: null,
             sessionStorage: null,
-            disableStringDict: false,
             forceSingleTab: false,
             assistSocketHost: '',
-            fixedCanvasScaling: false,
-            disableCanvas: false,
             captureIFrames: true,
-            disableSprites: false,
-            obscureTextEmails: true,
+            obscureTextEmails: false,
             obscureTextNumbers: false,
+            disableStringDict: false,
             crossdomain: {
                 parentDomain: '*',
             },
@@ -5091,6 +5561,8 @@ class App {
                 useAnimationFrame: false,
             },
             forceNgOff: false,
+            inlineCss: 0,
+            disableSprites: false,
         };
         this.options = simpleMerge(defaultOptions, options);
         if (!this.insideIframe &&
@@ -5329,30 +5801,6 @@ class App {
         }
         this.debug.error('OpenReplay error: ', context, e);
     }
-    send(message, urgent = false) {
-        if (this.activityState === ActivityState.NotActive) {
-            return;
-        }
-        // ====================================================
-        if (this.activityState === ActivityState.ColdStart) {
-            this.bufferedMessages1.push(message);
-            if (!this.singleBuffer) {
-                this.bufferedMessages2.push(message);
-            }
-            this.conditionsManager?.processMessage(message);
-        }
-        else {
-            this.messages.push(message);
-        }
-        // TODO: commit on start if there were `urgent` sends;
-        // Clarify where urgent can be used for;
-        // Clarify workflow for each type of message in case it was sent before start
-        //      (like Fetch before start; maybe add an option "preCapture: boolean" or sth alike)
-        // Careful: `this.delay` is equal to zero before start so all Timestamp-s will have to be updated on start
-        if (this.activityState === ActivityState.Active && urgent) {
-            this.commit();
-        }
-    }
     /**
      * Normal workflow: add timestamp and tab data to batch, then commit it
      * every ~30ms
@@ -7593,138 +8041,6 @@ function Viewport (app) {
     app.ticker.attach(sendSetViewportSize, 5, false);
 }
 
-function hasAdoptedSS(node) {
-    return (isRootNode(node) &&
-        // @ts-ignore
-        !!node.adoptedStyleSheets);
-}
-// TODO: encapsulate to be init-ed on-start and join with cssrules.ts under one folder
-let _id = 0xf;
-function nextID() {
-    return _id++;
-}
-const styleSheetIDMap = new Map();
-function ConstructedStyleSheets (app) {
-    if (app === null) {
-        return;
-    }
-    if (!hasAdoptedSS(document)) {
-        return;
-    }
-    const styleSheetIDMap = new Map();
-    const adoptedStyleSheetsOwnings = new Map();
-    const sendAdoptedStyleSheetsUpdate = (root) => setTimeout(() => {
-        let nodeID = app.nodes.getID(root);
-        if (root === document) {
-            nodeID = 0; // main document doesn't have nodeID. ID count starts from the documentElement
-        }
-        if (nodeID === undefined) {
-            return;
-        }
-        let pastOwning = adoptedStyleSheetsOwnings.get(nodeID);
-        if (!pastOwning) {
-            pastOwning = [];
-        }
-        const nowOwning = [];
-        const styleSheets = root.adoptedStyleSheets;
-        if (styleSheets && Symbol.iterator in styleSheets) {
-            for (const s of styleSheets) {
-                let sheetID = styleSheetIDMap.get(s);
-                const init = !sheetID;
-                if (!sheetID) {
-                    sheetID = nextID();
-                    styleSheetIDMap.set(s, sheetID);
-                }
-                if (!pastOwning.includes(sheetID)) {
-                    app.send(AdoptedSSAddOwner(sheetID, nodeID));
-                }
-                if (init) {
-                    const rules = s.cssRules;
-                    for (let i = 0; i < rules.length; i++) {
-                        app.send(AdoptedSSInsertRuleURLBased(sheetID, rules[i].cssText, i, app.getBaseHref()));
-                    }
-                }
-                nowOwning.push(sheetID);
-            }
-        }
-        if (Symbol.iterator in pastOwning) {
-            for (const sheetID of pastOwning) {
-                if (!nowOwning.includes(sheetID)) {
-                    app.send(AdoptedSSRemoveOwner(sheetID, nodeID));
-                }
-            }
-        }
-        adoptedStyleSheetsOwnings.set(nodeID, nowOwning);
-    }, 20); // Mysterious bug:
-    /* On the page https://explore.fast.design/components/fast-accordion
-      the only rule inside the only adoptedStyleSheet of the iframe-s document
-      gets changed during first milliseconds after the load.
-      However, none of the documented methods (replace, insertRule) is triggered.
-      The rule is not substituted (remains the same object), however the text gets changed.
-    */
-    function patchAdoptedStyleSheets(prototype) {
-        const nativeAdoptedStyleSheetsDescriptor = Object.getOwnPropertyDescriptor(prototype, 'adoptedStyleSheets');
-        if (nativeAdoptedStyleSheetsDescriptor) {
-            Object.defineProperty(prototype, 'adoptedStyleSheets', {
-                ...nativeAdoptedStyleSheetsDescriptor,
-                set: function (value) {
-                    // @ts-ignore
-                    const retVal = nativeAdoptedStyleSheetsDescriptor.set.call(this, value);
-                    sendAdoptedStyleSheetsUpdate(this);
-                    return retVal;
-                },
-            });
-        }
-    }
-    const patchContext = (context) => {
-        // @ts-ignore
-        if (context.__openreplay_adpss_patched__) {
-            return;
-        }
-        else {
-            // @ts-ignore
-            context.__openreplay_adpss_patched__ = true;
-        }
-        patchAdoptedStyleSheets(context.Document.prototype);
-        patchAdoptedStyleSheets(context.ShadowRoot.prototype);
-        //@ts-ignore TODO: upgrade ts to 4.8+
-        const { replace, replaceSync } = context.CSSStyleSheet.prototype;
-        //@ts-ignore
-        context.CSSStyleSheet.prototype.replace = function (text) {
-            return replace.call(this, text).then((sheet) => {
-                const sheetID = styleSheetIDMap.get(this);
-                if (sheetID) {
-                    app.send(AdoptedSSReplaceURLBased(sheetID, text, app.getBaseHref()));
-                }
-                return sheet;
-            });
-        };
-        //@ts-ignore
-        context.CSSStyleSheet.prototype.replaceSync = function (text) {
-            const sheetID = styleSheetIDMap.get(this);
-            if (sheetID) {
-                app.send(AdoptedSSReplaceURLBased(sheetID, text, app.getBaseHref()));
-            }
-            return replaceSync.call(this, text);
-        };
-    };
-    patchContext(window);
-    app.observer.attachContextCallback(app.safe(patchContext));
-    app.attachStopCallback(() => {
-        styleSheetIDMap.clear();
-        adoptedStyleSheetsOwnings.clear();
-    });
-    // So far main Document is not triggered with nodeCallbacks
-    app.attachStartCallback(() => {
-        sendAdoptedStyleSheetsUpdate(document);
-    });
-    app.nodes.attachNodeCallback((node) => {
-        if (hasAdoptedSS(node)) {
-            sendAdoptedStyleSheetsUpdate(node);
-        }
-    });
-}
-
 function CSSRules (app) {
     if (app === null) {
         return;
@@ -9380,7 +9696,7 @@ class API {
         this.signalStartIssue = (reason, missingApi) => {
             const doNotTrack = this.checkDoNotTrack();
             console.log("Tracker couldn't start due to:", JSON.stringify({
-                trackerVersion: '16.1.4',
+                trackerVersion: '16.2.1',
                 projectKey: this.options.projectKey,
                 doNotTrack,
                 reason: missingApi.length ? `missing api: ${missingApi.join(',')}` : reason,