@rpascene/shared 0.30.8

package/dist/lib/extractor/debug.js

@@ -0,0 +1,12 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_index_js_namespaceObject = require("./index.js");
+const external_util_js_namespaceObject = require("./util.js");
+console.log((0, external_index_js_namespaceObject.webExtractTextWithPosition)(document.body, true));
+console.log(JSON.stringify((0, external_index_js_namespaceObject.webExtractTextWithPosition)(document.body, true)));
+(0, external_util_js_namespaceObject.setExtractTextWithPositionOnWindow)();
+(0, external_util_js_namespaceObject.setRpasceneVisibleRectOnWindow)();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/extractor/dom-util.js

@@ -0,0 +1,150 @@
+"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__, {
+    isFormElement: ()=>isFormElement,
+    isButtonElement: ()=>isButtonElement,
+    isAElement: ()=>isAElement,
+    isSvgElement: ()=>isSvgElement,
+    isTextElement: ()=>isTextElement,
+    generateElementByPosition: ()=>generateElementByPosition,
+    isImgElement: ()=>isImgElement,
+    isNotContainerElement: ()=>isNotContainerElement,
+    isContainerElement: ()=>isContainerElement
+});
+const index_js_namespaceObject = require("../constants/index.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+function isFormElement(node, currentWindow = globalThis) {
+    return node instanceof currentWindow.HTMLElement && ('input' === node.tagName.toLowerCase() || 'textarea' === node.tagName.toLowerCase() || 'select' === node.tagName.toLowerCase() || 'option' === node.tagName.toLowerCase());
+}
+function isButtonElement(node, currentWindow = globalThis) {
+    return node instanceof currentWindow.HTMLElement && 'button' === node.tagName.toLowerCase();
+}
+function isAElement(node, currentWindow = globalThis) {
+    return node instanceof currentWindow.HTMLElement && 'a' === node.tagName.toLowerCase();
+}
+function isSvgElement(node, currentWindow = globalThis) {
+    return node instanceof currentWindow.SVGElement;
+}
+function isImgElement(node, currentWindow = globalThis) {
+    if (!includeBaseElement(node) && node instanceof currentWindow.Element) {
+        const computedStyle = window.getComputedStyle(node);
+        const backgroundImage = computedStyle.getPropertyValue('background-image');
+        if ('none' !== backgroundImage) return true;
+    }
+    if (isIconfont(node)) return true;
+    return node instanceof currentWindow.HTMLElement && 'img' === node.tagName.toLowerCase() || node instanceof currentWindow.SVGElement && 'svg' === node.tagName.toLowerCase();
+}
+function isIconfont(node, currentWindow = globalThis) {
+    if (node instanceof currentWindow.Element) {
+        const computedStyle = window.getComputedStyle(node);
+        const fontFamilyValue = computedStyle.fontFamily || '';
+        return fontFamilyValue.toLowerCase().indexOf('iconfont') >= 0;
+    }
+    return false;
+}
+function isNotContainerElement(node, currentWindow = globalThis) {
+    return isTextElement(node, currentWindow) || isIconfont(node, currentWindow) || isImgElement(node, currentWindow) || isButtonElement(node, currentWindow) || isAElement(node, currentWindow) || isFormElement(node, currentWindow);
+}
+function isTextElement(node, currentWindow = globalThis) {
+    var _node_nodeName_toLowerCase, _node_nodeName;
+    if (node instanceof currentWindow.Element) {
+        var _node_childNodes;
+        if ((null == node ? void 0 : null == (_node_childNodes = node.childNodes) ? void 0 : _node_childNodes.length) === 1 && (null == node ? void 0 : node.childNodes[0]) instanceof currentWindow.Text) return true;
+    }
+    return (null == (_node_nodeName = node.nodeName) ? void 0 : null == (_node_nodeName_toLowerCase = _node_nodeName.toLowerCase) ? void 0 : _node_nodeName_toLowerCase.call(_node_nodeName)) === '#text' && !isIconfont(node);
+}
+function isContainerElement(node, currentWindow = globalThis) {
+    if (!(node instanceof currentWindow.HTMLElement)) return false;
+    if (includeBaseElement(node, currentWindow)) return false;
+    const computedStyle = window.getComputedStyle(node);
+    const backgroundColor = computedStyle.getPropertyValue('background-color');
+    if (backgroundColor) return true;
+    return false;
+}
+function includeBaseElement(node, currentWindow = globalThis) {
+    if (!(node instanceof currentWindow.HTMLElement)) return false;
+    if (node.innerText) return true;
+    const includeList = [
+        'svg',
+        'button',
+        'input',
+        'textarea',
+        'select',
+        'option',
+        'img',
+        'a'
+    ];
+    for (const tagName of includeList){
+        const element = node.querySelectorAll(tagName);
+        if (element.length > 0) return true;
+    }
+    return false;
+}
+function generateElementByPosition(position) {
+    const rect = {
+        left: Math.max(position.x - 4, 0),
+        top: Math.max(position.y - 4, 0),
+        width: 8,
+        height: 8
+    };
+    const id = (0, external_utils_js_namespaceObject.generateHashId)(rect);
+    const element = {
+        id,
+        attributes: {
+            nodeType: index_js_namespaceObject.NodeType.POSITION
+        },
+        rect,
+        content: '',
+        center: [
+            position.x,
+            position.y
+        ]
+    };
+    return element;
+}
+exports.generateElementByPosition = __webpack_exports__.generateElementByPosition;
+exports.isAElement = __webpack_exports__.isAElement;
+exports.isButtonElement = __webpack_exports__.isButtonElement;
+exports.isContainerElement = __webpack_exports__.isContainerElement;
+exports.isFormElement = __webpack_exports__.isFormElement;
+exports.isImgElement = __webpack_exports__.isImgElement;
+exports.isNotContainerElement = __webpack_exports__.isNotContainerElement;
+exports.isSvgElement = __webpack_exports__.isSvgElement;
+exports.isTextElement = __webpack_exports__.isTextElement;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "generateElementByPosition",
+    "isAElement",
+    "isButtonElement",
+    "isContainerElement",
+    "isFormElement",
+    "isImgElement",
+    "isNotContainerElement",
+    "isSvgElement",
+    "isTextElement"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/extractor/index.js

@@ -0,0 +1,153 @@
+"use strict";
+var __webpack_modules__ = {
+    "./customLocator": function(module) {
+        module.exports = require("./customLocator.js");
+    },
+    "./dom-util": function(module) {
+        module.exports = require("./dom-util.js");
+    },
+    "./locator": function(module) {
+        module.exports = require("./locator.js");
+    },
+    "./tree": function(module) {
+        module.exports = require("./tree.js");
+    },
+    "./util": function(module) {
+        module.exports = require("./util.js");
+    },
+    "./web-extractor": function(module) {
+        module.exports = require("./web-extractor.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+        descriptionOfTree: ()=>_tree__WEBPACK_IMPORTED_MODULE_0__.descriptionOfTree,
+        generateElementByPosition: ()=>_dom_util__WEBPACK_IMPORTED_MODULE_4__.generateElementByPosition,
+        getElementInfoByXpath: ()=>_locator__WEBPACK_IMPORTED_MODULE_3__.getElementInfoByXpath,
+        getElementXpath: ()=>_locator__WEBPACK_IMPORTED_MODULE_3__.getElementXpath,
+        getNodeFromCacheList: ()=>_util__WEBPACK_IMPORTED_MODULE_2__.getNodeFromCacheList,
+        getNodeInfoByXpath: ()=>_locator__WEBPACK_IMPORTED_MODULE_3__.getNodeInfoByXpath,
+        getXpathsById: ()=>_locator__WEBPACK_IMPORTED_MODULE_3__.getXpathsById,
+        getXpathsByPoint: ()=>_locator__WEBPACK_IMPORTED_MODULE_3__.getXpathsByPoint,
+        isNotContainerElement: ()=>_dom_util__WEBPACK_IMPORTED_MODULE_4__.isNotContainerElement,
+        setNodeHashCacheListOnWindow: ()=>_util__WEBPACK_IMPORTED_MODULE_2__.setNodeHashCacheListOnWindow,
+        traverseTree: ()=>_tree__WEBPACK_IMPORTED_MODULE_0__.traverseTree,
+        treeToList: ()=>_tree__WEBPACK_IMPORTED_MODULE_0__.treeToList,
+        trimAttributes: ()=>_tree__WEBPACK_IMPORTED_MODULE_0__.trimAttributes,
+        truncateText: ()=>_tree__WEBPACK_IMPORTED_MODULE_0__.truncateText,
+        webExtractNodeTree: ()=>_web_extractor__WEBPACK_IMPORTED_MODULE_1__.extractTreeNode,
+        webExtractNodeTreeAsString: ()=>_web_extractor__WEBPACK_IMPORTED_MODULE_1__.extractTreeNodeAsString,
+        webExtractTextWithPosition: ()=>_web_extractor__WEBPACK_IMPORTED_MODULE_1__.extractTextWithPosition
+    });
+    var _tree__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./tree");
+    var _web_extractor__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./web-extractor");
+    var _util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./util");
+    var _locator__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./locator");
+    var _dom_util__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./dom-util");
+    var _customLocator__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("./customLocator");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _customLocator__WEBPACK_IMPORTED_MODULE_5__)if ([
+        "trimAttributes",
+        "setNodeHashCacheListOnWindow",
+        "getNodeInfoByXpath",
+        "getXpathsById",
+        "getElementInfoByXpath",
+        "generateElementByPosition",
+        "descriptionOfTree",
+        "getNodeFromCacheList",
+        "treeToList",
+        "truncateText",
+        "webExtractTextWithPosition",
+        "getElementXpath",
+        "webExtractNodeTree",
+        "default",
+        "getXpathsByPoint",
+        "traverseTree",
+        "isNotContainerElement",
+        "webExtractNodeTreeAsString"
+    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _customLocator__WEBPACK_IMPORTED_MODULE_5__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+exports.descriptionOfTree = __webpack_exports__.descriptionOfTree;
+exports.generateElementByPosition = __webpack_exports__.generateElementByPosition;
+exports.getElementInfoByXpath = __webpack_exports__.getElementInfoByXpath;
+exports.getElementXpath = __webpack_exports__.getElementXpath;
+exports.getNodeFromCacheList = __webpack_exports__.getNodeFromCacheList;
+exports.getNodeInfoByXpath = __webpack_exports__.getNodeInfoByXpath;
+exports.getXpathsById = __webpack_exports__.getXpathsById;
+exports.getXpathsByPoint = __webpack_exports__.getXpathsByPoint;
+exports.isNotContainerElement = __webpack_exports__.isNotContainerElement;
+exports.setNodeHashCacheListOnWindow = __webpack_exports__.setNodeHashCacheListOnWindow;
+exports.traverseTree = __webpack_exports__.traverseTree;
+exports.treeToList = __webpack_exports__.treeToList;
+exports.trimAttributes = __webpack_exports__.trimAttributes;
+exports.truncateText = __webpack_exports__.truncateText;
+exports.webExtractNodeTree = __webpack_exports__.webExtractNodeTree;
+exports.webExtractNodeTreeAsString = __webpack_exports__.webExtractNodeTreeAsString;
+exports.webExtractTextWithPosition = __webpack_exports__.webExtractTextWithPosition;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "descriptionOfTree",
+    "generateElementByPosition",
+    "getElementInfoByXpath",
+    "getElementXpath",
+    "getNodeFromCacheList",
+    "getNodeInfoByXpath",
+    "getXpathsById",
+    "getXpathsByPoint",
+    "isNotContainerElement",
+    "setNodeHashCacheListOnWindow",
+    "traverseTree",
+    "treeToList",
+    "trimAttributes",
+    "truncateText",
+    "webExtractNodeTree",
+    "webExtractNodeTreeAsString",
+    "webExtractTextWithPosition"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/extractor/locator.js

@@ -0,0 +1,141 @@
+"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__, {
+    getXpathsByPoint: ()=>getXpathsByPoint,
+    getNodeInfoByXpath: ()=>getNodeInfoByXpath,
+    getElementInfoByXpath: ()=>getElementInfoByXpath,
+    getXpathsById: ()=>getXpathsById,
+    getElementXpath: ()=>getElementXpath
+});
+const external_dom_util_js_namespaceObject = require("./dom-util.js");
+const external_util_js_namespaceObject = require("./util.js");
+const external_web_extractor_js_namespaceObject = require("./web-extractor.js");
+const getElementXpathIndex = (element)=>{
+    let index = 1;
+    let prev = element.previousElementSibling;
+    while(prev){
+        if (prev.nodeName.toLowerCase() === element.nodeName.toLowerCase()) index++;
+        prev = prev.previousElementSibling;
+    }
+    return index;
+};
+const normalizeXpathText = (text)=>{
+    if ('string' != typeof text) return '';
+    return text.replace(/\s+/g, ' ').trim();
+};
+const buildCurrentElementXpath = (element, isOrderSensitive, isLeafElement)=>{
+    var _element_textContent;
+    const parentPath = element.parentNode ? getElementXpath(element.parentNode, isOrderSensitive) : '';
+    const prefix = parentPath ? `${parentPath}/` : '/';
+    const tagName = element.nodeName.toLowerCase();
+    const textContent = null == (_element_textContent = element.textContent) ? void 0 : _element_textContent.trim();
+    if (isOrderSensitive) {
+        const index = getElementXpathIndex(element);
+        return `${prefix}${tagName}[${index}]`;
+    }
+    if (isLeafElement && textContent) return `${prefix}${tagName}[normalize-space()="${normalizeXpathText(textContent)}"]`;
+    const index = getElementXpathIndex(element);
+    return `${prefix}${tagName}[${index}]`;
+};
+const getElementXpath = (element, isOrderSensitive = false, isLeafElement = false)=>{
+    if (element.nodeType === Node.TEXT_NODE) {
+        const parentNode = element.parentNode;
+        if (parentNode && parentNode.nodeType === Node.ELEMENT_NODE) {
+            var _element_textContent;
+            const parentXPath = getElementXpath(parentNode, isOrderSensitive, true);
+            const textContent = null == (_element_textContent = element.textContent) ? void 0 : _element_textContent.trim();
+            if (textContent) return `${parentXPath}/text()[normalize-space()="${normalizeXpathText(textContent)}"]`;
+            return `${parentXPath}/text()`;
+        }
+        return '';
+    }
+    if (element.nodeType !== Node.ELEMENT_NODE) return '';
+    const el = element;
+    if (el === document.documentElement) return '/html';
+    if (el === document.body) return '/html/body';
+    if ((0, external_dom_util_js_namespaceObject.isSvgElement)(el)) {
+        let parent = el.parentNode;
+        while(parent && parent.nodeType === Node.ELEMENT_NODE){
+            if (!(0, external_dom_util_js_namespaceObject.isSvgElement)(parent)) return getElementXpath(parent, isOrderSensitive, isLeafElement);
+            parent = parent.parentNode;
+        }
+        return getElementXpath(el.parentNode, isOrderSensitive, isLeafElement);
+    }
+    return buildCurrentElementXpath(el, isOrderSensitive, isLeafElement);
+};
+function getXpathsById(id) {
+    const node = (0, external_util_js_namespaceObject.getNodeFromCacheList)(id);
+    if (!node) return null;
+    const fullXPath = getElementXpath(node, false, true);
+    return [
+        fullXPath
+    ];
+}
+function getXpathsByPoint(point, isOrderSensitive) {
+    const element = document.elementFromPoint(point.left, point.top);
+    if (!element) return null;
+    const fullXPath = getElementXpath(element, isOrderSensitive, true);
+    return [
+        fullXPath
+    ];
+}
+function getNodeInfoByXpath(xpath) {
+    const xpathResult = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+    if (1 !== xpathResult.snapshotLength) return null;
+    const node = xpathResult.snapshotItem(0);
+    return node;
+}
+function getElementInfoByXpath(xpath) {
+    const node = getNodeInfoByXpath(xpath);
+    if (!node) return null;
+    if (node instanceof HTMLElement) {
+        const rect = (0, external_util_js_namespaceObject.getRect)(node, 1, window);
+        const isVisible = (0, external_util_js_namespaceObject.isElementPartiallyInViewport)(rect, window, document, 1);
+        if (!isVisible) node.scrollIntoView({
+            behavior: 'instant',
+            block: 'center'
+        });
+    }
+    return (0, external_web_extractor_js_namespaceObject.collectElementInfo)(node, window, document, 1, {
+        left: 0,
+        top: 0
+    }, true);
+}
+exports.getElementInfoByXpath = __webpack_exports__.getElementInfoByXpath;
+exports.getElementXpath = __webpack_exports__.getElementXpath;
+exports.getNodeInfoByXpath = __webpack_exports__.getNodeInfoByXpath;
+exports.getXpathsById = __webpack_exports__.getXpathsById;
+exports.getXpathsByPoint = __webpack_exports__.getXpathsByPoint;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getElementInfoByXpath",
+    "getElementXpath",
+    "getNodeInfoByXpath",
+    "getXpathsById",
+    "getXpathsByPoint"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/extractor/tree.js

@@ -0,0 +1,127 @@
+"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__, {
+    descriptionOfTree: ()=>descriptionOfTree,
+    traverseTree: ()=>traverseTree,
+    treeToList: ()=>treeToList,
+    trimAttributes: ()=>trimAttributes,
+    truncateText: ()=>truncateText
+});
+function truncateText(text, maxLength = 150) {
+    if (void 0 === text) return '';
+    if ('object' == typeof text) text = JSON.stringify(text);
+    if ('number' == typeof text) return text.toString();
+    if ('string' == typeof text && text.length > maxLength) return `${text.slice(0, maxLength)}...`;
+    if ('string' == typeof text) return text.trim();
+    return '';
+}
+function trimAttributes(attributes, truncateTextLength) {
+    const tailorAttributes = Object.keys(attributes).reduce((res, currentKey)=>{
+        const attributeVal = attributes[currentKey];
+        if ('style' === currentKey || 'htmlTagName' === currentKey || 'nodeType' === currentKey) return res;
+        res[currentKey] = truncateText(attributeVal, truncateTextLength);
+        return res;
+    }, {});
+    return tailorAttributes;
+}
+const nodeSizeThreshold = 4;
+function descriptionOfTree(tree, truncateTextLength, filterNonTextContent = false, visibleOnly = true) {
+    const attributesString = (kv)=>Object.entries(kv).map(([key, value])=>`${key}="${truncateText(value, truncateTextLength)}"`).join(' ');
+    function buildContentTree(node, indent = 0, visibleOnly = true) {
+        let before = '';
+        let contentWithIndent = '';
+        let after = '';
+        let emptyNode = true;
+        const indentStr = '  '.repeat(indent);
+        let children = '';
+        for(let i = 0; i < (node.children || []).length; i++){
+            const childContent = buildContentTree(node.children[i], indent + 1, visibleOnly);
+            if (childContent) children += `\n${childContent}`;
+        }
+        if (node.node && node.node.rect.width > nodeSizeThreshold && node.node.rect.height > nodeSizeThreshold && (!filterNonTextContent || filterNonTextContent && node.node.content) && (!visibleOnly || visibleOnly && node.node.isVisible)) {
+            var _node_node_attributes;
+            emptyNode = false;
+            let nodeTypeString;
+            nodeTypeString = (null == (_node_node_attributes = node.node.attributes) ? void 0 : _node_node_attributes.htmlTagName) ? node.node.attributes.htmlTagName.replace(/[<>]/g, '') : node.node.attributes.nodeType.replace(/\sNode$/, '').toLowerCase();
+            const markerId = node.node.indexId;
+            const markerIdString = markerId ? `markerId="${markerId}"` : '';
+            const rectAttribute = node.node.rect ? {
+                left: node.node.rect.left,
+                top: node.node.rect.top,
+                width: node.node.rect.width,
+                height: node.node.rect.height
+            } : {};
+            before = `<${nodeTypeString} id="${node.node.id}" ${markerIdString} ${attributesString(trimAttributes(node.node.attributes || {}, truncateTextLength))} ${attributesString(rectAttribute)}>`;
+            const content = truncateText(node.node.content, truncateTextLength);
+            contentWithIndent = content ? `\n${indentStr}  ${content}` : '';
+            after = `</${nodeTypeString}>`;
+        } else if (!filterNonTextContent) {
+            if (!children.trim().startsWith('<>')) {
+                before = '<>';
+                contentWithIndent = '';
+                after = '</>';
+            }
+        }
+        if (emptyNode && !children.trim()) return '';
+        const result = `${indentStr}${before}${contentWithIndent}${children}\n${indentStr}${after}`;
+        if (result.trim()) return result;
+        return '';
+    }
+    const result = buildContentTree(tree, 0, visibleOnly);
+    return result.replace(/^\s*\n/gm, '');
+}
+function treeToList(tree) {
+    const result = [];
+    function dfs(node) {
+        if (node.node) result.push(node.node);
+        for (const child of node.children)dfs(child);
+    }
+    dfs(tree);
+    return result;
+}
+function traverseTree(tree, onNode) {
+    function dfs(node) {
+        if (node.node) node.node = onNode(node.node);
+        for (const child of node.children)dfs(child);
+    }
+    dfs(tree);
+    return tree;
+}
+exports.descriptionOfTree = __webpack_exports__.descriptionOfTree;
+exports.traverseTree = __webpack_exports__.traverseTree;
+exports.treeToList = __webpack_exports__.treeToList;
+exports.trimAttributes = __webpack_exports__.trimAttributes;
+exports.truncateText = __webpack_exports__.truncateText;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "descriptionOfTree",
+    "traverseTree",
+    "treeToList",
+    "trimAttributes",
+    "truncateText"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});