@posthog/browser-common 0.0.0 → 0.2.0

package/dist/utils/autocapture-utils.js

@@ -0,0 +1,479 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    isTextSelectionTarget: ()=>isTextSelectionTarget,
+    shouldCaptureRageclick: ()=>shouldCaptureRageclick,
+    shouldCaptureValue: ()=>shouldCaptureValue,
+    splitClassString: ()=>splitClassString,
+    shouldCaptureDomEvent: ()=>shouldCaptureDomEvent,
+    getEventTarget: ()=>getEventTarget,
+    getNestedSpanText: ()=>getNestedSpanText,
+    isAngularStyleAttr: ()=>isAngularStyleAttr,
+    getSafeText: ()=>getSafeText,
+    isSensitiveElement: ()=>isSensitiveElement,
+    shouldSkipDeadClick: ()=>shouldSkipDeadClick,
+    autocaptureCompatibleElements: ()=>autocaptureCompatibleElements,
+    makeSafeText: ()=>makeSafeText,
+    shouldCaptureDeadClick: ()=>shouldCaptureDeadClick,
+    getClassNames: ()=>getClassNames,
+    getDirectAndNestedSpanText: ()=>getDirectAndNestedSpanText,
+    getParentElement: ()=>getParentElement,
+    shouldCaptureElement: ()=>shouldCaptureElement,
+    MAX_DOM_ANCESTOR_DEPTH: ()=>MAX_DOM_ANCESTOR_DEPTH,
+    DEFAULT_CONTENT_IGNORELIST_WITH_STEPPERS: ()=>DEFAULT_CONTENT_IGNORELIST_WITH_STEPPERS,
+    getElementsChainString: ()=>getElementsChainString
+});
+const external_general_utils_js_namespaceObject = require("./general-utils.js");
+const core_namespaceObject = require("@posthog/core");
+const external_logger_js_namespaceObject = require("./logger.js");
+const external_globals_js_namespaceObject = require("./globals.js");
+const external_url_targeting_utils_js_namespaceObject = require("./url-targeting-utils.js");
+const external_element_utils_js_namespaceObject = require("./element-utils.js");
+const MAX_DOM_ANCESTOR_DEPTH = 1000;
+function splitClassString(s) {
+    return s ? (0, core_namespaceObject.trim)(s).split(/\s+/) : [];
+}
+function checkForURLMatches(urlsList, instance) {
+    const url = (0, external_url_targeting_utils_js_namespaceObject.getTargetingUrl)(instance);
+    return !!(url && urlsList && urlsList.some((regex)=>url.match(regex)));
+}
+function getClassNames(el) {
+    let className = '';
+    switch(typeof el.className){
+        case 'string':
+            className = el.className;
+            break;
+        case 'object':
+            className = (el.className && 'baseVal' in el.className ? el.className.baseVal : null) || el.getAttribute('class') || '';
+            break;
+        default:
+            className = '';
+    }
+    return splitClassString(className);
+}
+function makeSafeText(s) {
+    if ((0, core_namespaceObject.isNullish)(s)) return null;
+    return (0, core_namespaceObject.trim)(s).split(/(\s+)/).filter((s)=>shouldCaptureValue(s)).join('').replace(/[\r\n]/g, ' ').replace(/[ ]+/g, ' ').substring(0, 255);
+}
+function getSafeText(el) {
+    let elText = '';
+    if (shouldCaptureElement(el) && !isSensitiveElement(el) && el.childNodes && el.childNodes.length) (0, external_general_utils_js_namespaceObject.each)(el.childNodes, function(child) {
+        if ((0, external_element_utils_js_namespaceObject.isTextNode)(child) && child.textContent) elText += makeSafeText(child.textContent) ?? '';
+    });
+    return (0, core_namespaceObject.trim)(elText);
+}
+function getEventTarget(e) {
+    if ((0, core_namespaceObject.isUndefined)(e.target)) return e.srcElement || null;
+    if (e.target?.shadowRoot) return e.composedPath()[0] || null;
+    return e.target || null;
+}
+const autocaptureCompatibleElements = [
+    'a',
+    'button',
+    'form',
+    'input',
+    'select',
+    'textarea',
+    'label'
+];
+function checkIfElementTreePassesElementAllowList(elements, autocaptureConfig) {
+    const allowlist = autocaptureConfig?.element_allowlist;
+    if ((0, core_namespaceObject.isUndefined)(allowlist)) return true;
+    for (const el of elements)if (allowlist.some((elementType)=>el.tagName.toLowerCase() === elementType)) return true;
+    return false;
+}
+function elementMatchesCSSSelector(el, selector) {
+    const matches = el.matches || el.matchesSelector || el.msMatchesSelector || el.mozMatchesSelector || el.webkitMatchesSelector || el.oMatchesSelector;
+    try {
+        return matches ? matches.call(el, selector) : false;
+    } catch  {
+        return false;
+    }
+}
+function checkIfElementsMatchCSSSelector(elements, selectorList) {
+    if ((0, core_namespaceObject.isUndefined)(selectorList)) return true;
+    for (const el of elements)if (selectorList.some((selector)=>elementMatchesCSSSelector(el, selector))) return true;
+    return false;
+}
+function getParentElement(curEl) {
+    const parentNode = curEl.parentNode;
+    if (!parentNode || !(0, external_element_utils_js_namespaceObject.isElementNode)(parentNode)) return false;
+    return parentNode;
+}
+const DEFAULT_AUTOCAPTURE_IGNORE_LIST = [
+    '.ph-no-autocapture',
+    '[data-ph-no-autocapture]'
+];
+const DEFAULT_CONTENT_IGNORELIST = [
+    'next',
+    'previous',
+    'prev',
+    '>',
+    '<'
+];
+const DEFAULT_CONTENT_IGNORELIST_WITH_STEPPERS = [
+    ...DEFAULT_CONTENT_IGNORELIST,
+    '+',
+    '-',
+    "\u2212",
+    "\u2013"
+];
+const MAX_CONTENT_IGNORELIST_ENTRIES = 10;
+const matchesContentKeyword = (text, keyword)=>/[a-z0-9]/i.test(keyword) ? text.includes(keyword) : text === keyword;
+function shouldIgnoreByContent(contentIgnorelist, elementsWithText) {
+    if (false === contentIgnorelist || (0, core_namespaceObject.isUndefined)(contentIgnorelist)) return false;
+    let keywords;
+    if (true === contentIgnorelist) keywords = DEFAULT_CONTENT_IGNORELIST;
+    else {
+        if (!(0, core_namespaceObject.isArray)(contentIgnorelist)) return false;
+        if (contentIgnorelist.length > MAX_CONTENT_IGNORELIST_ENTRIES) {
+            external_logger_js_namespaceObject.logger.error(`[PostHog] content_ignorelist array cannot exceed ${MAX_CONTENT_IGNORELIST_ENTRIES} items. Use css_selector_ignorelist for more complex matching.`);
+            return false;
+        }
+        keywords = contentIgnorelist.map((k)=>k.toLowerCase());
+    }
+    return elementsWithText.some(({ safeText, ariaLabel })=>keywords.some((keyword)=>matchesContentKeyword(safeText, keyword) || matchesContentKeyword(ariaLabel, keyword)));
+}
+const DEFAULT_DEAD_CLICK_IGNORE_LIST = [
+    '.ph-no-deadclick',
+    '.ph-no-capture'
+];
+function shouldCaptureDeadClick(el, _config) {
+    if (!external_globals_js_namespaceObject.window || cannotCheckForAutocapture(el)) return false;
+    const selectorIgnoreList = (0, core_namespaceObject.isBoolean)(_config) ? DEFAULT_DEAD_CLICK_IGNORE_LIST : _config?.css_selector_ignorelist ?? DEFAULT_DEAD_CLICK_IGNORE_LIST;
+    const { targetElementList } = getElementAndParentsForElement(el, false);
+    return !checkIfElementsMatchCSSSelector(targetElementList, selectorIgnoreList);
+}
+const DEFAULT_RAGE_CLICK_IGNORE_LIST = [
+    '.ph-no-rageclick',
+    '.ph-no-capture'
+];
+const TEXT_SELECTION_INPUT_TYPES = [
+    '',
+    'text',
+    'search',
+    'email',
+    'password',
+    'url',
+    'tel',
+    'number'
+];
+function isContentEditableTarget(el) {
+    if (el.isContentEditable) return true;
+    const contentEditable = el.getAttribute?.('contenteditable');
+    return 'true' === contentEditable || '' === contentEditable;
+}
+function isTextSelectionTarget(el) {
+    if (!el || !(0, external_element_utils_js_namespaceObject.isElementNode)(el)) return false;
+    if ((0, external_element_utils_js_namespaceObject.isTag)(el, 'textarea')) return true;
+    if ((0, external_element_utils_js_namespaceObject.isTag)(el, 'input')) return (0, core_namespaceObject.includes)(TEXT_SELECTION_INPUT_TYPES, (el.getAttribute('type') || '').toLowerCase());
+    return isContentEditableTarget(el);
+}
+function shouldCaptureRageclick(el, _config) {
+    if (!external_globals_js_namespaceObject.window || cannotCheckForAutocapture(el)) return false;
+    let selectorIgnoreList;
+    let contentIgnorelist;
+    let ignoreTextSelection;
+    if ((0, core_namespaceObject.isBoolean)(_config)) {
+        selectorIgnoreList = _config ? DEFAULT_RAGE_CLICK_IGNORE_LIST : false;
+        contentIgnorelist = void 0;
+        ignoreTextSelection = false;
+    } else {
+        selectorIgnoreList = _config?.css_selector_ignorelist ?? DEFAULT_RAGE_CLICK_IGNORE_LIST;
+        contentIgnorelist = _config?.content_ignorelist;
+        ignoreTextSelection = _config?.ignore_text_selection ?? false;
+    }
+    if (false === selectorIgnoreList) return false;
+    if (ignoreTextSelection && isTextSelectionTarget(el)) return false;
+    const { targetElementList } = getElementAndParentsForElement(el, false);
+    const elementsWithText = targetElementList.map((element)=>({
+            safeText: getSafeText(element).toLowerCase(),
+            ariaLabel: element.getAttribute('aria-label')?.toLowerCase().trim() || ''
+        }));
+    if (shouldIgnoreByContent(contentIgnorelist, elementsWithText)) return false;
+    return !checkIfElementsMatchCSSSelector(targetElementList, selectorIgnoreList);
+}
+const cannotCheckForAutocapture = (el)=>!el || (0, external_element_utils_js_namespaceObject.isTag)(el, 'html') || !(0, external_element_utils_js_namespaceObject.isElementNode)(el);
+const getElementAndParentsForElement = (el, captureOnAnyElement)=>{
+    if (!external_globals_js_namespaceObject.window || cannotCheckForAutocapture(el)) return {
+        parentIsUsefulElement: false,
+        targetElementList: []
+    };
+    let parentIsUsefulElement = false;
+    const targetElementList = [
+        el
+    ];
+    let curEl = el;
+    while(curEl.parentNode && !(0, external_element_utils_js_namespaceObject.isTag)(curEl, 'body')){
+        if ((0, external_element_utils_js_namespaceObject.isShadowRoot)(curEl.parentNode)) {
+            targetElementList.push(curEl.parentNode.host);
+            curEl = curEl.parentNode.host;
+            continue;
+        }
+        const parentNode = getParentElement(curEl);
+        if (!parentNode) break;
+        if (captureOnAnyElement || autocaptureCompatibleElements.indexOf(parentNode.tagName.toLowerCase()) > -1) parentIsUsefulElement = true;
+        else try {
+            const compStyles = external_globals_js_namespaceObject.window.getComputedStyle(parentNode);
+            if (compStyles && 'pointer' === compStyles.getPropertyValue('cursor')) parentIsUsefulElement = true;
+        } catch  {}
+        targetElementList.push(parentNode);
+        curEl = parentNode;
+    }
+    return {
+        parentIsUsefulElement,
+        targetElementList
+    };
+};
+function shouldSkipDeadClick(el) {
+    if (!external_globals_js_namespaceObject.window || cannotCheckForAutocapture(el)) return false;
+    const { targetElementList } = getElementAndParentsForElement(el, false);
+    return targetElementList.some((node)=>(0, external_element_utils_js_namespaceObject.isTag)(node, 'a'));
+}
+function shouldCaptureDomEvent(el, event, autocaptureConfig, captureOnAnyElement, allowedEventTypes, instance) {
+    if (!external_globals_js_namespaceObject.window || cannotCheckForAutocapture(el)) return false;
+    if (autocaptureConfig?.url_allowlist) {
+        if (!checkForURLMatches(autocaptureConfig.url_allowlist, instance)) return false;
+    }
+    if (autocaptureConfig?.url_ignorelist) {
+        if (checkForURLMatches(autocaptureConfig.url_ignorelist, instance)) return false;
+    }
+    if (autocaptureConfig?.dom_event_allowlist) {
+        const allowlist = autocaptureConfig.dom_event_allowlist;
+        if (allowlist && !allowlist.some((eventType)=>event.type === eventType)) return false;
+    }
+    const { parentIsUsefulElement, targetElementList } = getElementAndParentsForElement(el, captureOnAnyElement);
+    if (!checkIfElementTreePassesElementAllowList(targetElementList, autocaptureConfig)) return false;
+    if (!checkIfElementsMatchCSSSelector(targetElementList, autocaptureConfig?.css_selector_allowlist)) return false;
+    const selectorIgnoreList = autocaptureConfig?.css_selector_ignorelist ?? DEFAULT_AUTOCAPTURE_IGNORE_LIST;
+    if (checkIfElementsMatchCSSSelector(targetElementList, selectorIgnoreList)) return false;
+    try {
+        const compStyles = external_globals_js_namespaceObject.window.getComputedStyle(el);
+        if (compStyles && 'pointer' === compStyles.getPropertyValue('cursor') && 'click' === event.type) return true;
+    } catch  {}
+    const tag = el.tagName.toLowerCase();
+    switch(tag){
+        case 'html':
+            return false;
+        case 'form':
+            return (allowedEventTypes || [
+                'submit'
+            ]).indexOf(event.type) >= 0;
+        case 'input':
+        case 'select':
+        case 'textarea':
+            return (allowedEventTypes || [
+                'change',
+                'click'
+            ]).indexOf(event.type) >= 0;
+        default:
+            if (parentIsUsefulElement) return (allowedEventTypes || [
+                'click'
+            ]).indexOf(event.type) >= 0;
+            return (allowedEventTypes || [
+                'click'
+            ]).indexOf(event.type) >= 0 && (autocaptureCompatibleElements.indexOf(tag) > -1 || 'true' === el.getAttribute('contenteditable'));
+    }
+}
+function shouldCaptureElement(el) {
+    const seen = new Set();
+    let depth = 0;
+    for(let curEl = el; curEl.parentNode && !(0, external_element_utils_js_namespaceObject.isTag)(curEl, 'body'); curEl = curEl.parentNode){
+        if (depth++ >= MAX_DOM_ANCESTOR_DEPTH || seen.has(curEl)) return false;
+        seen.add(curEl);
+        const classes = getClassNames(curEl);
+        if ((0, core_namespaceObject.includes)(classes, 'ph-sensitive') || (0, core_namespaceObject.includes)(classes, 'ph-no-capture')) return false;
+    }
+    if ((0, core_namespaceObject.includes)(getClassNames(el), 'ph-include')) return true;
+    const type = el.type || '';
+    if ((0, core_namespaceObject.isString)(type)) switch(type.toLowerCase()){
+        case 'hidden':
+            return false;
+        case 'password':
+            return false;
+    }
+    const name = el.name || el.id || '';
+    if ((0, core_namespaceObject.isString)(name)) {
+        const sensitiveNameRegex = /^cc|cardnum|ccnum|creditcard|csc|cvc|cvv|exp|pass|pwd|routing|seccode|securitycode|securitynum|socialsec|socsec|ssn/i;
+        if (sensitiveNameRegex.test(name.replace(/[^a-zA-Z0-9]/g, ''))) return false;
+    }
+    return true;
+}
+function isSensitiveElement(el) {
+    const allowedInputTypes = [
+        'button',
+        'checkbox',
+        'submit',
+        'reset'
+    ];
+    if ((0, external_element_utils_js_namespaceObject.isTag)(el, 'input') && !allowedInputTypes.includes(el.type) || (0, external_element_utils_js_namespaceObject.isTag)(el, 'select') || (0, external_element_utils_js_namespaceObject.isTag)(el, 'textarea') || 'true' === el.getAttribute('contenteditable')) return true;
+    return false;
+}
+const coreCCPattern = "(4[0-9]{12}(?:[0-9]{3})?)|(5[1-5][0-9]{14})|(6(?:011|5[0-9]{2})[0-9]{12})|(3[47][0-9]{13})|(3(?:0[0-5]|[68][0-9])[0-9]{11})|((?:2131|1800|35[0-9]{3})[0-9]{11})";
+const anchoredCCRegex = new RegExp(`^(?:${coreCCPattern})$`);
+const unanchoredCCRegex = new RegExp(coreCCPattern);
+const coreSSNPattern = "\\d{3}-?\\d{2}-?\\d{4}";
+const anchoredSSNRegex = new RegExp(`^(${coreSSNPattern})$`);
+const unanchoredSSNRegex = new RegExp(`(${coreSSNPattern})`);
+function shouldCaptureValue(value, anchorRegexes = true) {
+    if ((0, core_namespaceObject.isNullish)(value)) return false;
+    if ((0, core_namespaceObject.isString)(value)) {
+        value = (0, core_namespaceObject.trim)(value);
+        const ccRegex = anchorRegexes ? anchoredCCRegex : unanchoredCCRegex;
+        if (ccRegex.test((value || '').replace(/[- ]/g, ''))) return false;
+        const ssnRegex = anchorRegexes ? anchoredSSNRegex : unanchoredSSNRegex;
+        if (ssnRegex.test(value)) return false;
+    }
+    return true;
+}
+function isAngularStyleAttr(attributeName) {
+    if ((0, core_namespaceObject.isString)(attributeName)) return '_ngcontent' === attributeName.substring(0, 10) || '_nghost' === attributeName.substring(0, 7);
+    return false;
+}
+function getDirectAndNestedSpanText(target) {
+    let text = getSafeText(target);
+    text = `${text} ${getNestedSpanText(target)}`.trim();
+    return shouldCaptureValue(text) ? text : '';
+}
+function getNestedSpanText(target) {
+    let text = '';
+    if (target && target.childNodes && target.childNodes.length) (0, external_general_utils_js_namespaceObject.each)(target.childNodes, function(child) {
+        if (child && child.tagName?.toLowerCase() === 'span') try {
+            const spanText = getSafeText(child);
+            text = `${text} ${spanText}`.trim();
+            if (child.childNodes && child.childNodes.length) text = `${text} ${getNestedSpanText(child)}`.trim();
+        } catch (e) {
+            external_logger_js_namespaceObject.logger.error('[AutoCapture]', e);
+        }
+    });
+    return text;
+}
+function getElementsChainString(elements) {
+    return elementsToString(extractElements(elements));
+}
+function escapeQuotes(input) {
+    return input.replace(/"|\\"/g, '\\"');
+}
+function elementsToString(elements) {
+    const ret = elements.map((element)=>{
+        let el_string = '';
+        if (element.tag_name) el_string += element.tag_name;
+        if (element.attr_class) {
+            element.attr_class.sort();
+            for (const single_class of element.attr_class)el_string += `.${single_class.replace(/"/g, '')}`;
+        }
+        const attributes = {
+            ...element.text ? {
+                text: element.text
+            } : {},
+            'nth-child': element.nth_child ?? 0,
+            'nth-of-type': element.nth_of_type ?? 0,
+            ...element.href ? {
+                href: element.href
+            } : {},
+            ...element.attr_id ? {
+                attr_id: element.attr_id
+            } : {},
+            ...element.attributes
+        };
+        const sortedAttributes = {};
+        (0, external_general_utils_js_namespaceObject.entries)(attributes).sort(([a], [b])=>a.localeCompare(b)).forEach(([key, value])=>sortedAttributes[escapeQuotes(key.toString())] = escapeQuotes(value.toString()));
+        el_string += ':';
+        el_string += (0, external_general_utils_js_namespaceObject.entries)(sortedAttributes).map(([key, value])=>`${key}="${value}"`).join('');
+        return el_string;
+    });
+    return ret.join(';');
+}
+function extractElements(elements) {
+    return elements.map((el)=>{
+        const attributes = {};
+        const response = {
+            text: el['$el_text']?.slice(0, 400),
+            tag_name: el['tag_name'],
+            href: el['attr__href']?.slice(0, 2048),
+            attr_class: extractAttrClass(el),
+            attr_id: el['attr__id'],
+            nth_child: el['nth_child'],
+            nth_of_type: el['nth_of_type'],
+            attributes
+        };
+        (0, external_general_utils_js_namespaceObject.entries)(el).filter(([key])=>0 === key.indexOf('attr__')).forEach(([key, value])=>response.attributes[key] = value);
+        return response;
+    });
+}
+function extractAttrClass(el) {
+    const attr_class = el['attr__class'];
+    if (!attr_class) return;
+    if ((0, core_namespaceObject.isArray)(attr_class)) return attr_class;
+    return splitClassString(attr_class);
+}
+exports.DEFAULT_CONTENT_IGNORELIST_WITH_STEPPERS = __webpack_exports__.DEFAULT_CONTENT_IGNORELIST_WITH_STEPPERS;
+exports.MAX_DOM_ANCESTOR_DEPTH = __webpack_exports__.MAX_DOM_ANCESTOR_DEPTH;
+exports.autocaptureCompatibleElements = __webpack_exports__.autocaptureCompatibleElements;
+exports.getClassNames = __webpack_exports__.getClassNames;
+exports.getDirectAndNestedSpanText = __webpack_exports__.getDirectAndNestedSpanText;
+exports.getElementsChainString = __webpack_exports__.getElementsChainString;
+exports.getEventTarget = __webpack_exports__.getEventTarget;
+exports.getNestedSpanText = __webpack_exports__.getNestedSpanText;
+exports.getParentElement = __webpack_exports__.getParentElement;
+exports.getSafeText = __webpack_exports__.getSafeText;
+exports.isAngularStyleAttr = __webpack_exports__.isAngularStyleAttr;
+exports.isSensitiveElement = __webpack_exports__.isSensitiveElement;
+exports.isTextSelectionTarget = __webpack_exports__.isTextSelectionTarget;
+exports.makeSafeText = __webpack_exports__.makeSafeText;
+exports.shouldCaptureDeadClick = __webpack_exports__.shouldCaptureDeadClick;
+exports.shouldCaptureDomEvent = __webpack_exports__.shouldCaptureDomEvent;
+exports.shouldCaptureElement = __webpack_exports__.shouldCaptureElement;
+exports.shouldCaptureRageclick = __webpack_exports__.shouldCaptureRageclick;
+exports.shouldCaptureValue = __webpack_exports__.shouldCaptureValue;
+exports.shouldSkipDeadClick = __webpack_exports__.shouldSkipDeadClick;
+exports.splitClassString = __webpack_exports__.splitClassString;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "DEFAULT_CONTENT_IGNORELIST_WITH_STEPPERS",
+    "MAX_DOM_ANCESTOR_DEPTH",
+    "autocaptureCompatibleElements",
+    "getClassNames",
+    "getDirectAndNestedSpanText",
+    "getElementsChainString",
+    "getEventTarget",
+    "getNestedSpanText",
+    "getParentElement",
+    "getSafeText",
+    "isAngularStyleAttr",
+    "isSensitiveElement",
+    "isTextSelectionTarget",
+    "makeSafeText",
+    "shouldCaptureDeadClick",
+    "shouldCaptureDomEvent",
+    "shouldCaptureElement",
+    "shouldCaptureRageclick",
+    "shouldCaptureValue",
+    "shouldSkipDeadClick",
+    "splitClassString"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});