@openreplay/tracker 5.0.2-beta → 5.0.2

package/cjs/modules/network.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const messages_gen_js_1 = require("../app/messages.gen.js");
+const utils_js_1 = require("../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';
+}
+function default_1(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((0, messages_gen_js_1.NetworkRequest)('fetch', method, String(reqResInfo.url), stringify(reqResInfo.request), stringify(reqResInfo.response), r.status, startTime + (0, utils_js_1.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((0, messages_gen_js_1.NetworkRequest)('xhr', method, String(reqResInfo.url), stringify(reqResInfo.request), stringify(reqResInfo.response), xhr.status, startTime + (0, utils_js_1.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);
+    };
+    /* ====== <> ====== */
+}
+exports.default = default_1;

package/cjs/modules/performance.d.ts

@@ -0,0 +1,7 @@
+import type App from '../app/index.js';
+export declare const deviceMemory: number;
+export declare const jsHeapSizeLimit: number;
+export interface Options {
+    capturePerformance: boolean;
+}
+export default function (app: App, opts: Partial<Options>): void;

package/cjs/modules/performance.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsHeapSizeLimit = exports.deviceMemory = void 0;
+const utils_js_1 = require("../utils.js");
+const messages_gen_js_1 = require("../app/messages.gen.js");
+const perf = utils_js_1.IN_BROWSER && 'performance' in window && 'memory' in performance // works in Chrome only
+    ? performance
+    : { memory: {} };
+exports.deviceMemory = utils_js_1.IN_BROWSER ? (navigator.deviceMemory || 0) * 1024 : 0;
+exports.jsHeapSizeLimit = perf.memory.jsHeapSizeLimit || 0;
+function default_1(app, opts) {
+    const options = Object.assign({
+        capturePerformance: true,
+    }, opts);
+    if (!options.capturePerformance) {
+        return;
+    }
+    let frames;
+    let ticks;
+    const nextFrame = () => {
+        if (frames === undefined || frames === -1) {
+            return;
+        }
+        frames++;
+        requestAnimationFrame(nextFrame);
+    };
+    app.ticker.attach(() => {
+        if (ticks === undefined || ticks === -1) {
+            return;
+        }
+        ticks++;
+    }, 0, false);
+    const sendPerformanceTrack = () => {
+        if (frames === undefined || ticks === undefined) {
+            return;
+        }
+        app.send((0, messages_gen_js_1.PerformanceTrack)(frames, ticks, perf.memory.totalJSHeapSize || 0, perf.memory.usedJSHeapSize || 0));
+        ticks = frames = document.hidden ? -1 : 0;
+    };
+    app.attachStartCallback(() => {
+        ticks = frames = -1;
+        sendPerformanceTrack();
+        nextFrame();
+    });
+    app.attachStopCallback(() => {
+        ticks = frames = undefined;
+    });
+    app.ticker.attach(sendPerformanceTrack, 40, false);
+    if (document.hidden !== undefined) {
+        app.attachEventListener(document, 'visibilitychange', sendPerformanceTrack, false, false);
+    }
+}
+exports.default = default_1;

package/cjs/modules/scroll.d.ts

@@ -0,0 +1,2 @@
+import type App from '../app/index.js';
+export default function (app: App): void;

package/cjs/modules/scroll.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const messages_gen_js_1 = require("../app/messages.gen.js");
+const guards_js_1 = require("../app/guards.js");
+function getDocumentScroll(doc) {
+    const win = doc.defaultView;
+    return [
+        (win && win.pageXOffset) ||
+            (doc.documentElement && doc.documentElement.scrollLeft) ||
+            (doc.body && doc.body.scrollLeft) ||
+            0,
+        (win && win.pageYOffset) ||
+            (doc.documentElement && doc.documentElement.scrollTop) ||
+            (doc.body && doc.body.scrollTop) ||
+            0,
+    ];
+}
+function default_1(app) {
+    let documentScroll = false;
+    const nodeScroll = new Map();
+    function setNodeScroll(target) {
+        if (!(0, guards_js_1.isNode)(target)) {
+            return;
+        }
+        if ((0, guards_js_1.isElementNode)(target)) {
+            nodeScroll.set(target, [target.scrollLeft, target.scrollTop]);
+        }
+        if ((0, guards_js_1.isDocument)(target)) {
+            nodeScroll.set(target, getDocumentScroll(target));
+        }
+    }
+    const sendSetViewportScroll = app.safe(() => app.send((0, messages_gen_js_1.SetViewportScroll)(...getDocumentScroll(document))));
+    const sendSetNodeScroll = app.safe((s, node) => {
+        const id = app.nodes.getID(node);
+        if (id !== undefined) {
+            app.send((0, messages_gen_js_1.SetNodeScroll)(id, s[0], s[1]));
+        }
+    });
+    app.attachStartCallback(sendSetViewportScroll);
+    app.attachStopCallback(() => {
+        documentScroll = false;
+        nodeScroll.clear();
+    });
+    app.nodes.attachNodeCallback((node, isStart) => {
+        // MBTODO: iterate over all the nodes on start instead of using isStart hack
+        if (isStart) {
+            if ((0, guards_js_1.isElementNode)(node) && node.scrollLeft + node.scrollTop > 0) {
+                nodeScroll.set(node, [node.scrollLeft, node.scrollTop]);
+            }
+            else if ((0, guards_js_1.isDocument)(node)) {
+                // DRY somehow?
+                nodeScroll.set(node, getDocumentScroll(node));
+            }
+        }
+        if ((0, guards_js_1.isRootNode)(node)) {
+            // scroll is not-composed event (https://javascript.info/shadow-dom-events)
+            app.nodes.attachNodeListener(node, 'scroll', (e) => {
+                setNodeScroll(e.target);
+            });
+        }
+    });
+    app.attachEventListener(document, 'scroll', (e) => {
+        const target = e.target;
+        if (target === document) {
+            documentScroll = true;
+            return;
+        }
+        setNodeScroll(target);
+    });
+    app.ticker.attach(() => {
+        if (documentScroll) {
+            sendSetViewportScroll();
+            documentScroll = false;
+        }
+        nodeScroll.forEach(sendSetNodeScroll);
+        nodeScroll.clear();
+    }, 5, false);
+}
+exports.default = default_1;

package/cjs/modules/timing.d.ts

@@ -0,0 +1,7 @@
+import type App from '../app/index.js';
+export interface Options {
+    captureResourceTimings: boolean;
+    capturePageLoadTimings: boolean;
+    capturePageRenderTimings: boolean;
+}
+export default function (app: App, opts: Partial<Options>): void;

package/cjs/modules/timing.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const guards_js_1 = require("../app/guards.js");
+const utils_js_1 = require("../utils.js");
+const messages_gen_js_1 = require("../app/messages.gen.js");
+function getPaintBlocks(resources) {
+    const paintBlocks = [];
+    const elements = document.getElementsByTagName('*');
+    const styleURL = /url\(("[^"]*"|'[^']*'|[^)]*)\)/i;
+    for (let i = 0; i < elements.length; i++) {
+        const element = elements[i];
+        let src = '';
+        if ((0, guards_js_1.hasTag)(element, 'img')) {
+            src = element.currentSrc || element.src;
+        }
+        if (!src) {
+            const backgroundImage = getComputedStyle(element).getPropertyValue('background-image');
+            if (backgroundImage) {
+                const matches = styleURL.exec(backgroundImage);
+                if (matches !== null) {
+                    src = matches[1];
+                    if (src.startsWith('"') || src.startsWith("'")) {
+                        src = src.substr(1, src.length - 2);
+                    }
+                }
+            }
+        }
+        if (!src)
+            continue;
+        const time = src.substr(0, 10) === 'data:image' ? 0 : resources[src];
+        if (time === undefined)
+            continue;
+        const rect = element.getBoundingClientRect();
+        const top = Math.max(rect.top, 0);
+        const left = Math.max(rect.left, 0);
+        const bottom = Math.min(rect.bottom, window.innerHeight ||
+            (document.documentElement && document.documentElement.clientHeight) ||
+            0);
+        const right = Math.min(rect.right, window.innerWidth || (document.documentElement && document.documentElement.clientWidth) || 0);
+        if (bottom <= top || right <= left)
+            continue;
+        const area = (bottom - top) * (right - left);
+        paintBlocks.push({ time, area });
+    }
+    return paintBlocks;
+}
+function calculateSpeedIndex(firstContentfulPaint, paintBlocks) {
+    let a = (Math.max((document.documentElement && document.documentElement.clientWidth) || 0, window.innerWidth || 0) *
+        Math.max((document.documentElement && document.documentElement.clientHeight) || 0, window.innerHeight || 0)) /
+        10;
+    let s = a * firstContentfulPaint;
+    for (let i = 0; i < paintBlocks.length; i++) {
+        const { time, area } = paintBlocks[i];
+        a += area;
+        s += area * (time > firstContentfulPaint ? time : firstContentfulPaint);
+    }
+    return a === 0 ? 0 : s / a;
+}
+function default_1(app, opts) {
+    const options = Object.assign({
+        captureResourceTimings: true,
+        capturePageLoadTimings: true,
+        capturePageRenderTimings: true,
+    }, opts);
+    if (!('PerformanceObserver' in window)) {
+        options.captureResourceTimings = false;
+    }
+    if (!options.captureResourceTimings) {
+        return;
+    } // Resources are necessary for all timings
+    let resources = {};
+    function resourceTiming(entry) {
+        if (entry.duration < 0 || !(0, utils_js_1.isURL)(entry.name) || app.isServiceURL(entry.name))
+            return;
+        if (resources !== null) {
+            resources[entry.name] = entry.startTime + entry.duration;
+        }
+        app.send((0, messages_gen_js_1.ResourceTiming)(entry.startTime + (0, utils_js_1.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;
+    app.attachStartCallback(function ({ sessionID }) {
+        if (sessionID !== prevSessionID) {
+            // Send past page resources on a newly started session
+            performance.getEntriesByType('resource').forEach(resourceTiming);
+            prevSessionID = sessionID;
+        }
+        observer.observe({ entryTypes: ['resource'] });
+    });
+    app.attachStopCallback(function () {
+        observer.disconnect();
+    });
+    let firstPaint = 0, firstContentfulPaint = 0;
+    if (options.capturePageLoadTimings) {
+        let pageLoadTimingSent = false;
+        app.ticker.attach(() => {
+            if (pageLoadTimingSent) {
+                return;
+            }
+            if (firstPaint === 0 || firstContentfulPaint === 0) {
+                performance.getEntriesByType('paint').forEach((entry) => {
+                    const { name, startTime } = entry;
+                    switch (name) {
+                        case 'first-paint':
+                            firstPaint = startTime;
+                            break;
+                        case 'first-contentful-paint':
+                            firstContentfulPaint = startTime;
+                            break;
+                    }
+                });
+            }
+            if (performance.timing.loadEventEnd || performance.now() > 30000) {
+                pageLoadTimingSent = true;
+                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((0, messages_gen_js_1.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);
+    }
+    if (options.capturePageRenderTimings) {
+        let visuallyComplete = 0, interactiveWindowStartTime = 0, interactiveWindowTickTime = 0, paintBlocks = null;
+        let pageRenderTimingSent = false;
+        app.ticker.attach(() => {
+            if (pageRenderTimingSent) {
+                return;
+            }
+            const time = performance.now();
+            if (resources !== null) {
+                visuallyComplete = Math.max.apply(null, Object.keys(resources).map((k) => resources[k]));
+                if (time - visuallyComplete > 1000) {
+                    paintBlocks = getPaintBlocks(resources);
+                    resources = null;
+                }
+            }
+            if (interactiveWindowTickTime !== null) {
+                if (time - interactiveWindowTickTime > 50) {
+                    interactiveWindowStartTime = time;
+                }
+                interactiveWindowTickTime = time - interactiveWindowStartTime > 5000 ? null : time;
+            }
+            if ((paintBlocks !== null && interactiveWindowTickTime === null) || time > 30000) {
+                pageRenderTimingSent = true;
+                resources = null;
+                const speedIndex = paintBlocks === null
+                    ? 0
+                    : calculateSpeedIndex(firstContentfulPaint || firstPaint, paintBlocks);
+                const { domContentLoadedEventEnd, navigationStart } = performance.timing;
+                const timeToInteractive = interactiveWindowTickTime === null
+                    ? Math.max(interactiveWindowStartTime, firstContentfulPaint, domContentLoadedEventEnd - navigationStart || 0)
+                    : 0;
+                app.send((0, messages_gen_js_1.PageRenderTiming)(speedIndex, firstContentfulPaint > visuallyComplete ? firstContentfulPaint : visuallyComplete, timeToInteractive));
+            }
+        });
+    }
+}
+exports.default = default_1;

package/cjs/modules/viewport.d.ts

@@ -0,0 +1,2 @@
+import type App from '../app/index.js';
+export default function (app: App): void;

package/cjs/modules/viewport.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_js_1 = require("../utils.js");
+const messages_gen_js_1 = require("../app/messages.gen.js");
+function default_1(app) {
+    let url, width, height;
+    let navigationStart;
+    let referrer = document.referrer;
+    const sendSetPageLocation = app.safe(() => {
+        const { URL } = document;
+        if (URL !== url) {
+            url = URL;
+            app.send((0, messages_gen_js_1.SetPageLocation)(url, referrer, navigationStart));
+            navigationStart = 0;
+            referrer = url;
+        }
+    });
+    const sendSetViewportSize = app.safe(() => {
+        const { innerWidth, innerHeight } = window;
+        if (innerWidth !== width || innerHeight !== height) {
+            width = innerWidth;
+            height = innerHeight;
+            app.send((0, messages_gen_js_1.SetViewportSize)(width, height));
+        }
+    });
+    const sendSetPageVisibility = document.hidden === undefined
+        ? Function.prototype
+        : app.safe(() => app.send((0, messages_gen_js_1.SetPageVisibility)(document.hidden)));
+    app.attachStartCallback(() => {
+        url = '';
+        navigationStart = (0, utils_js_1.getTimeOrigin)();
+        width = height = -1;
+        sendSetPageLocation();
+        sendSetViewportSize();
+        sendSetPageVisibility();
+    });
+    if (document.hidden !== undefined) {
+        app.attachEventListener(document, 'visibilitychange', sendSetPageVisibility, false, false);
+    }
+    app.ticker.attach(sendSetPageLocation, 1, false);
+    app.ticker.attach(sendSetViewportSize, 5, false);
+}
+exports.default = default_1;

package/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/cjs/utils.d.ts

@@ -0,0 +1,13 @@
+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;
+export declare function isURL(s: string): boolean;
+export declare const DOCS_HOST = "https://docs.openreplay.com";
+export declare function deprecationWarn(nameOfFeature: string, useInstead: string, docsPath?: string): void;
+export declare function getLabelAttribute(e: Element): string | null;
+export declare function hasOpenreplayAttribute(e: Element, attr: string): boolean;

package/cjs/utils.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOpenreplayAttribute = exports.getLabelAttribute = exports.deprecationWarn = exports.DOCS_HOST = exports.isURL = exports.normSpaces = exports.stars = exports.now = exports.getTimeOrigin = exports.adjustTimeOrigin = exports.MAX_STR_LEN = exports.IS_FIREFOX = exports.IN_BROWSER = void 0;
+const DEPRECATED_ATTRS = { htmlmasked: 'hidden', masked: 'obscured' };
+exports.IN_BROWSER = !(typeof window === 'undefined');
+exports.IS_FIREFOX = exports.IN_BROWSER && navigator.userAgent.match(/firefox|fxios/i);
+exports.MAX_STR_LEN = 1e5;
+// Buggy to use `performance.timeOrigin || performance.timing.navigationStart`
+// https://github.com/mdn/content/issues/4713
+// Maybe move to timer/ticker
+let timeOrigin = exports.IN_BROWSER ? Date.now() - performance.now() : 0;
+function adjustTimeOrigin() {
+    timeOrigin = Date.now() - performance.now();
+}
+exports.adjustTimeOrigin = adjustTimeOrigin;
+function getTimeOrigin() {
+    return timeOrigin;
+}
+exports.getTimeOrigin = getTimeOrigin;
+exports.now = exports.IN_BROWSER && !!performance.now
+    ? () => Math.round(performance.now() + timeOrigin)
+    : () => Date.now();
+exports.stars = 'repeat' in String.prototype
+    ? (str) => '*'.repeat(str.length)
+    : (str) => str.replace(/./g, '*');
+function normSpaces(str) {
+    return str.trim().replace(/\s+/g, ' ');
+}
+exports.normSpaces = normSpaces;
+// isAbsoluteUrl regexp:  /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url)
+function isURL(s) {
+    return s.startsWith('https://') || s.startsWith('http://');
+}
+exports.isURL = isURL;
+// TODO: JOIN IT WITH LOGGER somehow (use logging decorators?); Don't forget about index.js loggin when there is no logger instance.
+exports.DOCS_HOST = 'https://docs.openreplay.com';
+const warnedFeatures = {};
+function deprecationWarn(nameOfFeature, useInstead, docsPath = '/') {
+    if (warnedFeatures[nameOfFeature]) {
+        return;
+    }
+    console.warn(`OpenReplay: ${nameOfFeature} is deprecated. ${useInstead ? `Please, use ${useInstead} instead.` : ''} Visit ${exports.DOCS_HOST}${docsPath} for more information.`);
+    warnedFeatures[nameOfFeature] = true;
+}
+exports.deprecationWarn = deprecationWarn;
+function getLabelAttribute(e) {
+    let value = e.getAttribute('data-openreplay-label');
+    if (value !== null) {
+        return value;
+    }
+    value = e.getAttribute('data-asayer-label');
+    if (value !== null) {
+        deprecationWarn('"data-asayer-label" attribute', '"data-openreplay-label" attribute', '/');
+    }
+    return value;
+}
+exports.getLabelAttribute = getLabelAttribute;
+function hasOpenreplayAttribute(e, attr) {
+    const newName = `data-openreplay-${attr}`;
+    if (e.hasAttribute(newName)) {
+        // @ts-ignore
+        if (DEPRECATED_ATTRS[attr]) {
+            deprecationWarn(`"${newName}" attribute`, 
+            // @ts-ignore
+            `"${DEPRECATED_ATTRS[attr]}" attribute`, '/installation/sanitize-data');
+        }
+        return true;
+    }
+    return false;
+}
+exports.hasOpenreplayAttribute = hasOpenreplayAttribute;

package/cjs/vendors/finder/finder.d.ts

@@ -0,0 +1,12 @@
+export type Options = {
+    root: Element;
+    idName: (name: string) => boolean;
+    className: (name: string) => boolean;
+    tagName: (name: string) => boolean;
+    attr: (name: string, value: string) => boolean;
+    seedMinLength: number;
+    optimizedMinLength: number;
+    threshold: number;
+    maxNumberOfTries: number;
+};
+export declare function finder(input: Element, options?: Partial<Options>): string;