@openreplay/tracker 3.4.13 → 3.4.17-beta.0

package/lib/app/{observer.js → observer/observer.js}

@@ -1,40 +1,52 @@
-import { stars, hasOpenreplayAttribute } from "../utils.js";
-import { CreateDocument, CreateElementNode, CreateTextNode, SetNodeData, SetCSSDataURLBased, SetNodeAttribute, SetNodeAttributeURLBased, RemoveNodeAttribute, MoveNode, RemoveNode, CreateIFrameDocument, } from "../messages/index.js";
+import { RemoveNodeAttribute, SetNodeAttribute, SetNodeAttributeURLBased, SetCSSDataURLBased, SetNodeData, CreateTextNode, CreateElementNode, MoveNode, RemoveNode, } from "../../messages/index.js";
+import { isInstance, inDocument } from "../context.js";
 function isSVGElement(node) {
     return node.namespaceURI === 'http://www.w3.org/2000/svg';
 }
+function isIgnored(node) {
+    if (isInstance(node, Text)) {
+        return false;
+    }
+    if (!isInstance(node, Element)) {
+        return true;
+    }
+    const tag = node.tagName.toUpperCase();
+    if (tag === 'LINK') {
+        const rel = node.getAttribute('rel');
+        const as = node.getAttribute('as');
+        return !((rel === null || rel === void 0 ? void 0 : rel.includes('stylesheet')) || as === "style" || as === "font");
+    }
+    return (tag === 'SCRIPT' ||
+        tag === 'NOSCRIPT' ||
+        tag === 'META' ||
+        tag === 'TITLE' ||
+        tag === 'BASE');
+}
+function isRootNode(node) {
+    return isInstance(node, Document) || isInstance(node, ShadowRoot);
+}
+function isObservable(node) {
+    if (isRootNode(node)) {
+        return true;
+    }
+    return !isIgnored(node);
+}
 export default class Observer {
-    constructor(app, options, context = window) {
+    constructor(app, context = window) {
         this.app = app;
-        this.options = options;
         this.context = context;
-        this.iframeObservers = [];
+        this.commited = [];
+        this.recents = [];
+        this.myNodes = [];
+        this.indexes = [];
+        this.attributesList = [];
+        this.textSet = new Set();
+        this.inUpperContext = context.parent === context; //TODO: get rid of context here
         this.observer = new MutationObserver(this.app.safe((mutations) => {
-            var _a;
             for (const mutation of mutations) {
                 const target = mutation.target;
                 const type = mutation.type;
-                // Special case
-                // Document 'childList' might happen in case of iframe. 
-                // TODO: generalize as much as possible
-                if (this.isInstance(target, Document)
-                    && type === 'childList'
-                //&& new Array(mutation.addedNodes).some(node => this.isInstance(node, HTMLHtmlElement))
-                ) {
-                    const parentFrame = (_a = target.defaultView) === null || _a === void 0 ? void 0 : _a.frameElement;
-                    if (!parentFrame) {
-                        continue;
-                    }
-                    this.bindTree(target.documentElement);
-                    const frameID = this.app.nodes.getID(parentFrame);
-                    const docID = this.app.nodes.getID(target.documentElement);
-                    if (frameID === undefined || docID === undefined) {
-                        continue;
-                    }
-                    this.app.send(CreateIFrameDocument(frameID, docID));
-                    continue;
-                }
-                if (this.isIgnored(target) || !context.document.contains(target)) {
+                if (!isObservable(target) || !inDocument(target)) {
                     continue;
                 }
                 if (type === 'childList') {
@@ -50,7 +62,7 @@ export default class Observer {
                 if (id === undefined) {
                     continue;
                 }
-                if (id >= this.recents.length) {
+                if (id >= this.recents.length) { // TODO: something more convinient
                     this.recents[id] = undefined;
                 }
                 if (type === 'attributes') {
@@ -72,12 +84,6 @@ export default class Observer {
             }
             this.commitNodes();
         }));
-        this.commited = [];
-        this.recents = [];
-        this.indexes = [0];
-        this.attributesList = [];
-        this.textSet = new Set();
-        this.textMasked = new Set();
     }
     clear() {
         this.commited.length = 0;
@@ -85,40 +91,6 @@ export default class Observer {
         this.indexes.length = 1;
         this.attributesList.length = 0;
         this.textSet.clear();
-        this.textMasked.clear();
-    }
-    // TODO: we need a type expert here so we won't have to ignore the lines
-    isInstance(node, constr) {
-        let context = this.context;
-        while (context.parent && context.parent !== context) {
-            // @ts-ignore
-            if (node instanceof context[constr.name]) {
-                return true;
-            }
-            // @ts-ignore
-            context = context.parent;
-        }
-        // @ts-ignore
-        return node instanceof context[constr.name];
-    }
-    isIgnored(node) {
-        if (this.isInstance(node, Text)) {
-            return false;
-        }
-        if (!this.isInstance(node, Element)) {
-            return true;
-        }
-        const tag = node.tagName.toUpperCase();
-        if (tag === 'LINK') {
-            const rel = node.getAttribute('rel');
-            const as = node.getAttribute('as');
-            return !((rel === null || rel === void 0 ? void 0 : rel.includes('stylesheet')) || as === "style" || as === "font");
-        }
-        return (tag === 'SCRIPT' ||
-            tag === 'NOSCRIPT' ||
-            tag === 'META' ||
-            tag === 'TITLE' ||
-            tag === 'BASE');
     }
     sendNodeAttribute(id, node, name, value) {
         if (isSVGElement(node)) {
@@ -148,7 +120,7 @@ export default class Observer {
             return;
         }
         if (name === 'value' &&
-            this.isInstance(node, HTMLInputElement) &&
+            isInstance(node, HTMLInputElement) &&
             node.type !== 'button' &&
             node.type !== 'reset' &&
             node.type !== 'submit') {
@@ -158,7 +130,7 @@ export default class Observer {
             this.app.send(new RemoveNodeAttribute(id, name));
             return;
         }
-        if (name === 'style' || name === 'href' && this.isInstance(node, HTMLLinkElement)) {
+        if (name === 'style' || name === 'href' && isInstance(node, HTMLLinkElement)) {
             this.app.send(new SetNodeAttributeURLBased(id, name, value, this.app.getBaseHref()));
             return;
         }
@@ -167,47 +139,27 @@ export default class Observer {
         }
         this.app.send(new SetNodeAttribute(id, name, value));
     }
-    /* TODO:  abstract sanitation */
-    getInnerTextSecure(el) {
-        const id = this.app.nodes.getID(el);
-        if (!id) {
-            return '';
-        }
-        return this.checkObscure(id, el.innerText);
-    }
-    checkObscure(id, data) {
-        if (this.textMasked.has(id)) {
-            return data.replace(/[^\f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]/g, '█');
-        }
-        if (this.options.obscureTextNumbers) {
-            data = data.replace(/\d/g, '0');
-        }
-        if (this.options.obscureTextEmails) {
-            data = data.replace(/([^\s]+)@([^\s]+)\.([^\s]+)/g, (...f) => stars(f[1]) + '@' + stars(f[2]) + '.' + stars(f[3]));
-        }
-        return data;
-    }
     sendNodeData(id, parentElement, data) {
-        if (this.isInstance(parentElement, HTMLStyleElement) || this.isInstance(parentElement, SVGStyleElement)) {
+        if (isInstance(parentElement, HTMLStyleElement) || isInstance(parentElement, SVGStyleElement)) {
             this.app.send(new SetCSSDataURLBased(id, data, this.app.getBaseHref()));
             return;
         }
-        data = this.checkObscure(id, data);
+        data = this.app.sanitizer.sanitize(id, data);
         this.app.send(new SetNodeData(id, data));
     }
-    /* end TODO:  abstract sanitation */
     bindNode(node) {
         const r = this.app.nodes.registerNode(node);
         const id = r[0];
         this.recents[id] = r[1] || this.recents[id] || false;
+        this.myNodes[id] = true;
     }
     bindTree(node) {
-        if (this.isIgnored(node)) {
+        if (!isObservable(node)) {
             return;
         }
         this.bindNode(node);
         const walker = document.createTreeWalker(node, NodeFilter.SHOW_ELEMENT + NodeFilter.SHOW_TEXT, {
-            acceptNode: (node) => this.isIgnored(node) || this.app.nodes.getID(node) !== undefined
+            acceptNode: (node) => isIgnored(node) || this.app.nodes.getID(node) !== undefined
                 ? NodeFilter.FILTER_REJECT
                 : NodeFilter.FILTER_ACCEPT,
         }, 
@@ -224,12 +176,15 @@ export default class Observer {
         }
     }
     _commitNode(id, node) {
+        if (isRootNode(node)) {
+            return true;
+        }
         const parent = node.parentNode;
         let parentID;
-        if (this.isInstance(node, HTMLHtmlElement)) {
-            this.indexes[id] = 0;
-        }
-        else {
+        // 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)
+        // TODO: Clean the logic (though now it workd fine) 
+        if (!isInstance(node, HTMLHtmlElement) || !this.inUpperContext) {
             if (parent === null) {
                 this.unbindNode(node);
                 return false;
@@ -243,23 +198,20 @@ export default class Observer {
                 this.unbindNode(node);
                 return false;
             }
-            if (this.textMasked.has(parentID) ||
-                (this.isInstance(node, Element) && hasOpenreplayAttribute(node, 'masked'))) {
-                this.textMasked.add(id);
-            }
-            let sibling = node.previousSibling;
-            while (sibling !== null) {
-                const siblingID = this.app.nodes.getID(sibling);
-                if (siblingID !== undefined) {
-                    this.commitNode(siblingID);
-                    this.indexes[id] = this.indexes[siblingID] + 1;
-                    break;
-                }
-                sibling = sibling.previousSibling;
-            }
-            if (sibling === null) {
-                this.indexes[id] = 0;
+            this.app.sanitizer.handleNode(id, parentID, node);
+        }
+        let sibling = node.previousSibling;
+        while (sibling !== null) {
+            const siblingID = this.app.nodes.getID(sibling);
+            if (siblingID !== undefined) {
+                this.commitNode(siblingID);
+                this.indexes[id] = this.indexes[siblingID] + 1;
+                break;
             }
+            sibling = sibling.previousSibling;
+        }
+        if (sibling === null) {
+            this.indexes[id] = 0; //
         }
         const isNew = this.recents[id];
         const index = this.indexes[id];
@@ -267,7 +219,7 @@ export default class Observer {
             throw 'commitNode: missing node index';
         }
         if (isNew === true) {
-            if (this.isInstance(node, Element)) {
+            if (isInstance(node, Element)) {
                 if (parentID !== undefined) {
                     this.app.send(new CreateElementNode(id, parentID, index, node.tagName, isSVGElement(node)));
                 }
@@ -275,12 +227,8 @@ export default class Observer {
                     const attr = node.attributes[i];
                     this.sendNodeAttribute(id, node, attr.nodeName, attr.value);
                 }
-                if (this.isInstance(node, HTMLIFrameElement) &&
-                    (this.options.captureIFrames || node.getAttribute("data-openreplay-capture"))) {
-                    this.handleIframe(node);
-                }
             }
-            else if (this.isInstance(node, Text)) {
+            else if (isInstance(node, Text)) {
                 // for text node id != 0, hence parentID !== undefined and parent is Element
                 this.app.send(new CreateTextNode(id, parentID, index));
                 this.sendNodeData(id, parent, node.data);
@@ -292,7 +240,7 @@ export default class Observer {
         }
         const attr = this.attributesList[id];
         if (attr !== undefined) {
-            if (!this.isInstance(node, Element)) {
+            if (!isInstance(node, Element)) {
                 throw 'commitNode: node is not an element';
             }
             for (const name of attr) {
@@ -300,7 +248,7 @@ export default class Observer {
             }
         }
         if (this.textSet.has(id)) {
-            if (!this.isInstance(node, Text)) {
+            if (!isInstance(node, Text)) {
                 throw 'commitNode: node is not a text';
             }
             // for text node id != 0, hence parent is Element
@@ -322,6 +270,11 @@ export default class Observer {
     commitNodes() {
         let node;
         for (let id = 0; id < this.recents.length; id++) {
+            // TODO: make things/logic nice here.
+            // commit required in any case if recents[id] true or false (in case of unbinding) or undefined (in case of attr change).
+            if (!this.myNodes[id]) {
+                continue;
+            }
             this.commitNode(id);
             if (this.recents[id] === true && (node = this.app.nodes.getNode(id))) {
                 this.app.nodes.callNodeCallbacks(node);
@@ -329,49 +282,9 @@ export default class Observer {
         }
         this.clear();
     }
-    handleIframe(iframe) {
-        let context = null;
-        const handle = this.app.safe(() => {
-            const id = this.app.nodes.getID(iframe);
-            if (id === undefined) {
-                return;
-            }
-            if (iframe.contentWindow === context) {
-                return;
-            }
-            context = iframe.contentWindow;
-            if (!context) {
-                return;
-            }
-            const observer = new Observer(this.app, this.options, context);
-            this.iframeObservers.push(observer);
-            observer.observeIframe(id, context);
-        });
-        this.app.attachEventListener(iframe, "load", handle);
-        handle();
-    }
-    // TODO: abstract common functionality, separate FrameObserver
-    observeIframe(id, context) {
-        const doc = context.document;
-        this.observer.observe(doc, {
-            childList: true,
-            attributes: true,
-            characterData: true,
-            subtree: true,
-            attributeOldValue: false,
-            characterDataOldValue: false,
-        });
-        this.bindTree(doc.documentElement);
-        const docID = this.app.nodes.getID(doc.documentElement);
-        if (docID === undefined) {
-            console.log("Wrong");
-            return;
-        }
-        this.app.send(CreateIFrameDocument(id, docID));
-        this.commitNodes();
-    }
-    observe() {
-        this.observer.observe(this.context.document, {
+    // ISSSUE
+    observeRoot(node, beforeCommit, nodeToBind = node) {
+        this.observer.observe(node, {
             childList: true,
             attributes: true,
             characterData: true,
@@ -379,14 +292,13 @@ export default class Observer {
             attributeOldValue: false,
             characterDataOldValue: false,
         });
-        this.app.send(new CreateDocument());
-        this.bindTree(this.context.document.documentElement);
+        this.bindTree(nodeToBind);
+        beforeCommit(this.app.nodes.getID(node));
         this.commitNodes();
     }
     disconnect() {
-        this.iframeObservers.forEach(o => o.disconnect());
-        this.iframeObservers = [];
         this.observer.disconnect();
         this.clear();
+        this.myNodes.length = 0;
     }
 }

package/lib/app/observer/shadow_root_observer.d.ts

@@ -0,0 +1,4 @@
+import Observer from "./observer.js";
+export default class ShadowRootObserver extends Observer {
+    observe(el: Element): void;
+}

package/lib/app/observer/shadow_root_observer.js

@@ -0,0 +1,18 @@
+import Observer from "./observer.js";
+import { CreateIFrameDocument } from "../../messages/index.js";
+export default class ShadowRootObserver extends Observer {
+    observe(el) {
+        const shRoot = el.shadowRoot;
+        const hostID = this.app.nodes.getID(el);
+        if (!shRoot || hostID === undefined) {
+            return;
+        } // log
+        this.observeRoot(shRoot, (rootID) => {
+            if (rootID === undefined) {
+                console.log("OpenReplay: Shadow Root was not bound");
+                return;
+            }
+            this.app.send(CreateIFrameDocument(hostID, rootID));
+        });
+    }
+}

package/lib/app/observer/top_observer.d.ts

@@ -0,0 +1,15 @@
+import Observer from "./observer.js";
+import App from "../index.js";
+export interface Options {
+    captureIFrames: boolean;
+}
+export default class TopObserver extends Observer {
+    private readonly options;
+    constructor(app: App, options: Partial<Options>);
+    private iframeObservers;
+    private handleIframe;
+    private shadowRootObservers;
+    private handleShadowRoot;
+    observe(): void;
+    disconnect(): void;
+}

package/lib/app/observer/top_observer.js

@@ -0,0 +1,81 @@
+import Observer from "./observer.js";
+import { isInstance } from "../context.js";
+import IFrameObserver from "./iframe_observer.js";
+import ShadowRootObserver from "./shadow_root_observer.js";
+import { CreateDocument } from "../../messages/index.js";
+const attachShadowNativeFn = Element.prototype.attachShadow;
+export default class TopObserver extends Observer {
+    constructor(app, options) {
+        super(app);
+        this.iframeObservers = [];
+        this.shadowRootObservers = [];
+        this.options = Object.assign({
+            captureIFrames: false
+        }, options);
+        // IFrames
+        this.app.nodes.attachNodeCallback(node => {
+            if (isInstance(node, HTMLIFrameElement) &&
+                (this.options.captureIFrames || node.getAttribute("data-openreplay-capture"))) {
+                this.handleIframe(node);
+            }
+        });
+        // ShadowDOM
+        this.app.nodes.attachNodeCallback(node => {
+            if (isInstance(node, Element) && node.shadowRoot !== null) {
+                this.handleShadowRoot(node.shadowRoot);
+            }
+        });
+    }
+    handleIframe(iframe) {
+        let context = null;
+        const handle = this.app.safe(() => {
+            const id = this.app.nodes.getID(iframe);
+            if (id === undefined) {
+                return;
+            } //log
+            if (iframe.contentWindow === context) {
+                return;
+            } //Does this happen frequently?
+            context = iframe.contentWindow;
+            if (!context) {
+                return;
+            }
+            const observer = new IFrameObserver(this.app, context);
+            this.iframeObservers.push(observer);
+            observer.observe(iframe);
+        });
+        this.app.attachEventListener(iframe, "load", handle);
+        handle();
+    }
+    handleShadowRoot(shRoot) {
+        const observer = new ShadowRootObserver(this.app, this.context);
+        this.shadowRootObservers.push(observer);
+        observer.observe(shRoot.host);
+    }
+    observe() {
+        // Protection from several subsequent calls?
+        const observer = this;
+        Element.prototype.attachShadow = function () {
+            const shadow = attachShadowNativeFn.apply(this, arguments);
+            observer.handleShadowRoot(shadow);
+            return shadow;
+        };
+        // Can observe documentElement (<html>) here, because it is not supposed to be changing.
+        // However, it is possible in some exotic cases and may cause an ignorance of the newly created <html>
+        // In this case context.document have to be observed, but this will cause 
+        // the change in the re-player behaviour caused by CreateDocument message: 
+        //   the 0-node ("fRoot") will become #document rather than documentElement as it is now.
+        // Alternatively - observe(#document) then bindNode(documentElement)
+        this.observeRoot(this.context.document, () => {
+            this.app.send(new CreateDocument());
+        }, this.context.document.documentElement);
+    }
+    disconnect() {
+        Element.prototype.attachShadow = attachShadowNativeFn;
+        this.iframeObservers.forEach(o => o.disconnect());
+        this.iframeObservers = [];
+        this.shadowRootObservers.forEach(o => o.disconnect());
+        this.shadowRootObservers = [];
+        super.disconnect();
+    }
+}

package/lib/app/sanitizer.d.ts

@@ -0,0 +1,16 @@
+import App from "./index.js";
+export interface Options {
+    obscureTextEmails: boolean;
+    obscureTextNumbers: boolean;
+}
+export default class Sanitizer {
+    private readonly app;
+    private readonly masked;
+    private readonly options;
+    constructor(app: App, options: Partial<Options>);
+    handleNode(id: number, parentID: number, node: Node): void;
+    sanitize(id: number, data: string): string;
+    isMasked(id: number): boolean;
+    getInnerTextSecure(el: HTMLElement): string;
+    clear(): void;
+}

package/lib/app/sanitizer.js

@@ -1 +1,44 @@
-"use strict";
+import { stars, hasOpenreplayAttribute } from "../utils.js";
+import { isInstance } from "./context.js";
+export default class Sanitizer {
+    constructor(app, options) {
+        this.app = app;
+        this.masked = new Set();
+        this.options = Object.assign({
+            obscureTextEmails: true,
+            obscureTextNumbers: false,
+        }, options);
+    }
+    handleNode(id, parentID, node) {
+        if (this.masked.has(parentID) ||
+            (isInstance(node, Element) && hasOpenreplayAttribute(node, 'masked'))) {
+            this.masked.add(id);
+        }
+    }
+    sanitize(id, data) {
+        if (this.masked.has(id)) {
+            // TODO: is it the best place to put trim() ? Might trimmed spaces be considered in layout in certain cases?
+            return data.trim().replace(/[^\f\n\r\t\v\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]/g, '█');
+        }
+        if (this.options.obscureTextNumbers) {
+            data = data.replace(/\d/g, '0');
+        }
+        if (this.options.obscureTextEmails) {
+            data = data.replace(/([^\s]+)@([^\s]+)\.([^\s]+)/g, (...f) => stars(f[1]) + '@' + stars(f[2]) + '.' + stars(f[3]));
+        }
+        return data;
+    }
+    isMasked(id) {
+        return this.masked.has(id);
+    }
+    getInnerTextSecure(el) {
+        const id = this.app.nodes.getID(el);
+        if (!id) {
+            return '';
+        }
+        return this.sanitize(id, el.innerText);
+    }
+    clear() {
+        this.masked.clear();
+    }
+}

package/lib/index.d.ts

@@ -37,4 +37,5 @@ export default class API {
     event(key: string, payload: any, issue?: boolean): void;
     issue(key: string, payload: any): void;
     handleError: (e: Error | ErrorEvent | PromiseRejectionEvent) => void;
+    resetNextPageSession(flag: boolean): void;
 }

package/lib/index.js

@@ -111,7 +111,7 @@ export default class API {
             // no-cors issue only with text/plain or not-set Content-Type
             // req.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
             req.send(JSON.stringify({
-                trackerVersion: '3.4.13',
+                trackerVersion: '3.4.17-beta.0',
                 projectKey: options.projectKey,
                 doNotTrack,
                 // TODO: add precise reason (an exact API missing)
@@ -219,4 +219,10 @@ export default class API {
             this.app.send(new CustomIssue(key, payload));
         }
     }
+    resetNextPageSession(flag) {
+        if (typeof flag !== 'boolean' || !this.app) {
+            return;
+        }
+        this.app.resetNextPageSession(flag);
+    }
 }

package/lib/modules/exception.js

@@ -37,7 +37,14 @@ export function getExceptionMessageFromEvent(e) {
             return getExceptionMessage(e.reason, []);
         }
         else {
-            return new JSException('Unhandled Promise Rejection', String(e.reason), '[]');
+            let message;
+            try {
+                message = JSON.stringify(e.reason);
+            }
+            catch (_) {
+                message = String(e.reason);
+            }
+            return new JSException('Unhandled Promise Rejection', message, '[]');
         }
     }
     return null;

package/lib/modules/img.js

@@ -1,6 +1,17 @@
 import { timestamp, isURL } from "../utils.js";
-import { ResourceTiming, SetNodeAttributeURLBased } from "../messages/index.js";
+import { ResourceTiming, SetNodeAttributeURLBased, SetNodeAttribute } from "../messages/index.js";
+const PLACEHOLDER_SRC = "https://static.openreplay.com/tracker/placeholder.jpeg";
 export default function (app) {
+    function sendPlaceholder(id, node) {
+        app.send(new SetNodeAttribute(id, "src", PLACEHOLDER_SRC));
+        const { width, height } = node.getBoundingClientRect();
+        if (!node.hasAttribute("width")) {
+            app.send(new SetNodeAttribute(id, "width", String(width)));
+        }
+        if (!node.hasAttribute("height")) {
+            app.send(new SetNodeAttribute(id, "height", String(height)));
+        }
+    }
     const sendImgSrc = app.safe(function () {
         const id = app.nodes.getID(this);
         if (id === undefined) {
@@ -15,7 +26,10 @@ export default function (app) {
                 app.send(new ResourceTiming(timestamp(), 0, 0, 0, 0, 0, src, 'img'));
             }
         }
-        else if (src.length < 1e5) {
+        else if (src.length >= 1e5 || app.sanitizer.isMasked(id)) {
+            sendPlaceholder(id, this);
+        }
+        else {
             app.send(new SetNodeAttributeURLBased(id, 'src', src, app.getBaseHref()));
         }
     });

package/lib/modules/input.d.ts

@@ -1,5 +1,6 @@
 import App from "../app/index.js";
-export declare function getInputLabel(node: HTMLInputElement): string;
+declare type TextEditableElement = HTMLInputElement | HTMLTextAreaElement;
+export declare function getInputLabel(node: TextEditableElement): string;
 export declare const enum InputMode {
     Plain = 0,
     Obscured = 1,
@@ -11,3 +12,4 @@ export interface Options {
     defaultInputMode: InputMode;
 }
 export default function (app: App, opts: Partial<Options>): void;
+export {};