appium-desktop-driver 1.7.2-preview.1 → 1.7.2

package/build/lib/xpath/core.js

@@ -39,45 +39,33 @@ exports.processExprNodeAsPredicate = processExprNodeAsPredicate;
 exports.predicateProcessableBeforeNode = predicateProcessableBeforeNode;
 const base_driver_1 = require("@appium/base-driver");
 const xpath_analyzer_1 = __importStar(require("xpath-analyzer"));
-const types_1 = require("../powershell/types");
-const converter_bridge_1 = require("../server/converter-bridge");
-const conditions_1 = require("../powershell/conditions");
-const common_1 = require("../powershell/common");
+const powershell_1 = require("../powershell");
 const functions_1 = require("./functions");
 const OptimizeLastStep = Symbol.for('LastStep');
 const XPathAllowedProperties = Object.freeze([
-    types_1.Property.ACCELERATOR_KEY,
-    types_1.Property.ACCESS_KEY,
-    types_1.Property.AUTOMATION_ID,
-    types_1.Property.CLASS_NAME,
-    types_1.Property.FRAMEWORK_ID,
-    types_1.Property.HAS_KEYBOARD_FOCUS,
-    types_1.Property.HELP_TEXT,
-    types_1.Property.IS_CONTENT_ELEMENT,
-    types_1.Property.IS_CONTROL_ELEMENT,
-    types_1.Property.IS_ENABLED,
-    types_1.Property.IS_KEYBOARD_FOCUSABLE,
-    types_1.Property.IS_OFFSCREEN,
-    types_1.Property.IS_PASSWORD,
-    types_1.Property.IS_REQUIRED_FOR_FORM,
-    types_1.Property.ITEM_STATUS,
-    types_1.Property.ITEM_TYPE,
-    types_1.Property.LOCALIZED_CONTROL_TYPE,
-    types_1.Property.NAME,
-    types_1.Property.ORIENTATION,
-    types_1.Property.PROCESS_ID,
-    types_1.Property.RUNTIME_ID,
+    powershell_1.Property.ACCELERATOR_KEY,
+    powershell_1.Property.ACCESS_KEY,
+    powershell_1.Property.AUTOMATION_ID,
+    powershell_1.Property.CLASS_NAME,
+    powershell_1.Property.FRAMEWORK_ID,
+    powershell_1.Property.HAS_KEYBOARD_FOCUS,
+    powershell_1.Property.HELP_TEXT,
+    powershell_1.Property.IS_CONTENT_ELEMENT,
+    powershell_1.Property.IS_CONTROL_ELEMENT,
+    powershell_1.Property.IS_ENABLED,
+    powershell_1.Property.IS_KEYBOARD_FOCUSABLE,
+    powershell_1.Property.IS_OFFSCREEN,
+    powershell_1.Property.IS_PASSWORD,
+    powershell_1.Property.IS_REQUIRED_FOR_FORM,
+    powershell_1.Property.ITEM_STATUS,
+    powershell_1.Property.ITEM_TYPE,
+    powershell_1.Property.LOCALIZED_CONTROL_TYPE,
+    powershell_1.Property.NAME,
+    powershell_1.Property.ORIENTATION,
+    powershell_1.Property.PROCESS_ID,
+    powershell_1.Property.RUNTIME_ID,
 ]);
-function rootElement() {
-    return { type: 'root' };
-}
-function foundElement(elementId) {
-    return { type: 'found', elementId };
-}
-function getContextElementId(el) {
-    return el.type === 'found' && el.elementId ? el.elementId : null;
-}
-async function xpathToElIdOrIds(selector, mult, context, sendCommand) {
+async function xpathToElIdOrIds(selector, mult, context, sendPowerShellCommand) {
     let parsedXPath;
     try {
         parsedXPath = new xpath_analyzer_1.default(selector).parse();
@@ -111,11 +99,8 @@ async function xpathToElIdOrIds(selector, mult, context, sendCommand) {
     if (parsedXPath.type === 'absolute-location-path' && parsedXPath.steps[0].axis === xpath_analyzer_1.CHILD) {
         parsedXPath.steps[0].axis = xpath_analyzer_1.SELF;
     }
-    const contextEl = context ? foundElement(context) : rootElement();
-    const foundElements = await processExprNode(parsedXPath, contextEl, sendCommand);
-    const els = foundElements
-        .filter((el) => typeof el === 'object' && el !== null && 'type' in el && el.type === 'found')
-        .map((el) => ({ [base_driver_1.W3C_ELEMENT_KEY]: el.elementId ?? '' }));
+    const foundElements = await processExprNode(parsedXPath, context ? new powershell_1.FoundAutomationElement(context) : powershell_1.AutomationElement.automationRoot, sendPowerShellCommand);
+    const els = foundElements.filter((el) => el instanceof powershell_1.FoundAutomationElement).map((el) => ({ [base_driver_1.W3C_ELEMENT_KEY]: el.runtimeId }));
     if (mult) {
         return els;
     }
@@ -124,33 +109,33 @@ async function xpathToElIdOrIds(selector, mult, context, sendCommand) {
     }
     return els[0];
 }
-async function processExprNode(exprNode, context, sendCommand) {
+async function processExprNode(exprNode, context, sendPowerShellCommand) {
     switch (exprNode.type) {
         case xpath_analyzer_1.NUMBER:
             return [exprNode.number];
         case xpath_analyzer_1.LITERAL:
             return [exprNode.string];
         case xpath_analyzer_1.UNION:
-            return [...await processExprNode(exprNode.lhs, context, sendCommand), ...await processExprNode(exprNode.rhs, context, sendCommand)];
+            return [...await processExprNode(exprNode.lhs, context, sendPowerShellCommand), ...await processExprNode(exprNode.rhs, context, sendPowerShellCommand)];
         case xpath_analyzer_1.FUNCTION_CALL:
-            return await (0, functions_1.handleFunctionCall)(exprNode.name, context, sendCommand, ...exprNode.args);
+            return await (0, functions_1.handleFunctionCall)(exprNode.name, context, sendPowerShellCommand, ...exprNode.args);
         case xpath_analyzer_1.ABSOLUTE_LOCATION_PATH:
         case xpath_analyzer_1.RELATIVE_LOCATION_PATH: {
             const result = [];
             for (const element of convertToElementArray(context)) {
-                result.push(await handleLocationNode(exprNode, element, sendCommand));
+                result.push(await handleLocationNode(exprNode, element, sendPowerShellCommand));
             }
             return result.flat();
         }
         case xpath_analyzer_1.PATH: {
-            const filterResult = await processExprNode(exprNode.filter, context, sendCommand);
+            const filterResult = await processExprNode(exprNode.filter, context, sendPowerShellCommand);
             const result = [];
             for (const item of filterResult) {
-                if (isXPathElement(item)) {
+                if (item instanceof powershell_1.AutomationElement) {
                     const itemAfterSteps = await handleLocationNode({
                         type: xpath_analyzer_1.RELATIVE_LOCATION_PATH,
                         steps: exprNode.steps,
-                    }, item, sendCommand);
+                    }, item, sendPowerShellCommand);
                     result.push(itemAfterSteps);
                 }
             }
@@ -158,14 +143,17 @@ async function processExprNode(exprNode, context, sendCommand) {
         }
         case xpath_analyzer_1.FILTER: {
             const result = [];
-            const exprResult = await processExprNode(exprNode.primary, context, sendCommand);
+            const exprResult = await processExprNode(exprNode.primary, context, sendPowerShellCommand);
             for (const item of exprResult) {
-                if (isXPathElement(item)) {
+                if (item instanceof powershell_1.AutomationElement) {
                     const filteredItem = await executeStep({
                         axis: xpath_analyzer_1.SELF,
-                        test: { type: xpath_analyzer_1.NODE_TYPE_TEST, name: xpath_analyzer_1.NODE },
+                        test: {
+                            type: xpath_analyzer_1.NODE_TYPE_TEST,
+                            name: xpath_analyzer_1.NODE,
+                        },
                         predicates: exprNode.predicates,
-                    }, item, sendCommand);
+                    }, item, sendPowerShellCommand);
                     result.push(filteredItem);
                 }
             }
@@ -173,8 +161,8 @@ async function processExprNode(exprNode, context, sendCommand) {
         }
         case xpath_analyzer_1.OR:
         case xpath_analyzer_1.AND: {
-            const [lhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.BOOLEAN, context, sendCommand, exprNode.lhs);
-            const [rhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.BOOLEAN, context, sendCommand, exprNode.rhs);
+            const [lhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.BOOLEAN, context, sendPowerShellCommand, exprNode.lhs);
+            const [rhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.BOOLEAN, context, sendPowerShellCommand, exprNode.rhs);
             if (exprNode.type === xpath_analyzer_1.AND) {
                 return [lhs && rhs];
             }
@@ -183,11 +171,11 @@ async function processExprNode(exprNode, context, sendCommand) {
             }
         }
         case xpath_analyzer_1.NEGATION:
-            return [-await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.NUMBER, context, sendCommand, exprNode.lhs)];
+            return [-await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.NUMBER, context, sendPowerShellCommand, exprNode.lhs)];
         case xpath_analyzer_1.EQUALITY:
         case xpath_analyzer_1.INEQUALITY: {
-            const [lhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.STRING, context, sendCommand, exprNode.lhs);
-            const [rhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.STRING, context, sendCommand, exprNode.rhs);
+            const [lhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.STRING, context, sendPowerShellCommand, exprNode.lhs);
+            const [rhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.STRING, context, sendPowerShellCommand, exprNode.rhs);
             if (isNaN(Number(lhs)) || isNaN(Number(rhs))) {
                 return [exprNode.type === xpath_analyzer_1.EQUALITY ? (lhs === rhs) : (lhs !== rhs)];
             }
@@ -201,74 +189,86 @@ async function processExprNode(exprNode, context, sendCommand) {
         case xpath_analyzer_1.LESS_THAN_OR_EQUAL:
         case xpath_analyzer_1.MODULUS:
         case xpath_analyzer_1.MULTIPLICATIVE:
-        case xpath_analyzer_1.SUBTRACTIVE: {
-            const [lhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.NUMBER, context, sendCommand, exprNode.lhs);
-            const [rhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.NUMBER, context, sendCommand, exprNode.rhs);
-            switch (exprNode.type) {
-                case xpath_analyzer_1.ADDITIVE: return [(lhs + rhs)];
-                case xpath_analyzer_1.DIVISIONAL: return [(lhs / rhs)];
-                case xpath_analyzer_1.GREATER_THAN: return [(lhs > rhs)];
-                case xpath_analyzer_1.GREATER_THAN_OR_EQUAL: return [(lhs >= rhs)];
-                case xpath_analyzer_1.LESS_THAN: return [(lhs < rhs)];
-                case xpath_analyzer_1.LESS_THAN_OR_EQUAL: return [(lhs <= rhs)];
-                case xpath_analyzer_1.MODULUS: return [(lhs % rhs)];
-                case xpath_analyzer_1.MULTIPLICATIVE: return [(lhs * rhs)];
-                case xpath_analyzer_1.SUBTRACTIVE: return [(lhs - rhs)];
+        case xpath_analyzer_1.SUBTRACTIVE:
+            {
+                const [lhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.NUMBER, context, sendPowerShellCommand, exprNode.lhs);
+                const [rhs] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.NUMBER, context, sendPowerShellCommand, exprNode.rhs);
+                switch (exprNode.type) {
+                    case xpath_analyzer_1.ADDITIVE:
+                        return [(lhs + rhs)];
+                    case xpath_analyzer_1.DIVISIONAL:
+                        return [(lhs / rhs)];
+                    case xpath_analyzer_1.GREATER_THAN:
+                        return [(lhs > rhs)];
+                    case xpath_analyzer_1.GREATER_THAN_OR_EQUAL:
+                        return [(lhs >= rhs)];
+                    case xpath_analyzer_1.LESS_THAN:
+                        return [(lhs < rhs)];
+                    case xpath_analyzer_1.LESS_THAN_OR_EQUAL:
+                        return [(lhs <= rhs)];
+                    case xpath_analyzer_1.MODULUS:
+                        return [(lhs % rhs)];
+                    case xpath_analyzer_1.MULTIPLICATIVE:
+                        return [(lhs * rhs)];
+                    case xpath_analyzer_1.SUBTRACTIVE:
+                        return [(lhs - rhs)];
+                }
             }
-        }
     }
 }
-async function handleLocationNode(location, context, sendCommand) {
+async function handleLocationNode(location, context, sendPowerShellCommand) {
     if (location.steps.some((step) => step.test.name === null)) {
         throw new base_driver_1.errors.InvalidSelectorError('Expected path step expression.');
     }
     if (location.type === xpath_analyzer_1.ABSOLUTE_LOCATION_PATH) {
-        context = rootElement();
+        context = powershell_1.AutomationElement.automationRoot;
+    }
+    if (context instanceof powershell_1.AutomationElementGroup && context.groups.length > 1) {
+        throw new base_driver_1.errors.InvalidArgumentError(`handleLocationNode expects single context, but received ${context.groups.length} contexts.`);
     }
     optimizeDoubleSlash(location.steps);
     for (const [index, step] of location.steps.entries()) {
         if (step.axis === xpath_analyzer_1.ATTRIBUTE) {
             if (index === location.steps.length - 1) {
-                return await convertAttributeNodeTestToStringArray(step.test, context, sendCommand);
+                return await convertAttributeNodeTestToStringArray(step.test, context, sendPowerShellCommand);
             }
             else {
                 return [];
             }
         }
-        const result = await executeStep(step, context, sendCommand);
-        if (Array.isArray(result)) {
-            // Multi-element result - process remaining steps for each element
-            if (index < location.steps.length - 1) {
-                const combinedResults = [];
-                for (const el of result) {
-                    const subResults = await handleLocationNode({
-                        type: xpath_analyzer_1.RELATIVE_LOCATION_PATH,
-                        steps: location.steps.slice(index + 1),
-                    }, el, sendCommand);
-                    combinedResults.push(...subResults);
-                }
-                return removeDuplicateElements(combinedResults);
+        if (context instanceof powershell_1.AutomationElementGroup) {
+            const results = [];
+            for (const el of context.groups) {
+                results.push(await executeStep(step, el, sendPowerShellCommand));
             }
-            context = result[0] ?? rootElement();
-            return removeDuplicateElements(result);
+            context = new powershell_1.AutomationElementGroup(...flattenElementGroupsAndRemoveDuplicates(results));
+        }
+        else {
+            context = await executeStep(step, context, sendPowerShellCommand);
         }
-        context = result;
     }
     return convertToElementArray(context);
 }
-async function processExprNodeAsPredicate(exprNode, context, positions, sendCommand, relativeExprNodes) {
+async function processExprNodeAsPredicate(exprNode, context, positions, sendPowerShellCommand, relativeExprNodes) {
     relativeExprNodes ??= [];
     switch (exprNode.type) {
         case xpath_analyzer_1.NUMBER:
             return await processExprNodeAsPredicate({
                 type: xpath_analyzer_1.EQUALITY,
-                lhs: { type: xpath_analyzer_1.FUNCTION_CALL, name: xpath_analyzer_1.POSITION, args: [] },
-                rhs: { type: xpath_analyzer_1.NUMBER, number: exprNode.number }
-            }, context, positions, sendCommand, relativeExprNodes);
+                lhs: {
+                    type: xpath_analyzer_1.FUNCTION_CALL,
+                    name: xpath_analyzer_1.POSITION,
+                    args: [],
+                },
+                rhs: {
+                    type: xpath_analyzer_1.NUMBER,
+                    number: exprNode.number,
+                }
+            }, context, positions, sendPowerShellCommand, relativeExprNodes);
         case xpath_analyzer_1.OR:
-            return [new conditions_1.OrCondition((await processExprNodeAsPredicate(exprNode.lhs, context, positions, sendCommand, relativeExprNodes))[0], (await processExprNodeAsPredicate(exprNode.rhs, context, positions, sendCommand, relativeExprNodes))[0]), relativeExprNodes];
+            return [new powershell_1.OrCondition((await processExprNodeAsPredicate(exprNode.lhs, context, positions, sendPowerShellCommand, relativeExprNodes))[0], (await processExprNodeAsPredicate(exprNode.rhs, context, positions, sendPowerShellCommand, relativeExprNodes))[0]), relativeExprNodes];
         case xpath_analyzer_1.AND:
-            return [new conditions_1.AndCondition((await processExprNodeAsPredicate(exprNode.lhs, context, positions, sendCommand, relativeExprNodes))[0], (await processExprNodeAsPredicate(exprNode.rhs, context, positions, sendCommand, relativeExprNodes))[0]), relativeExprNodes];
+            return [new powershell_1.AndCondition((await processExprNodeAsPredicate(exprNode.lhs, context, positions, sendPowerShellCommand, relativeExprNodes))[0], (await processExprNodeAsPredicate(exprNode.rhs, context, positions, sendPowerShellCommand, relativeExprNodes))[0]), relativeExprNodes];
         case xpath_analyzer_1.EQUALITY:
         case xpath_analyzer_1.INEQUALITY: {
             if ((exprNode.lhs.type === xpath_analyzer_1.RELATIVE_LOCATION_PATH) !== (exprNode.rhs.type === xpath_analyzer_1.RELATIVE_LOCATION_PATH)) {
@@ -277,21 +277,21 @@ async function processExprNodeAsPredicate(exprNode, context, positions, sendComm
                     && exprNode.lhs.steps[0].test.type === xpath_analyzer_1.NODE_NAME_TEST
                     && XPathAllowedProperties.includes(exprNode.lhs.steps[0].test.name?.toLowerCase())) {
                     const propertyName = exprNode.lhs.steps[0].test.name?.toLowerCase();
-                    const [value] = await processExprNode(exprNode.rhs, context, sendCommand);
-                    if (propertyName === types_1.Property.RUNTIME_ID) {
-                        return [new conditions_1.PropertyCondition(propertyName, new common_1.PSInt32Array(String(value).split('.').map(Number))), relativeExprNodes];
+                    const [value] = await processExprNode(exprNode.rhs, context, sendPowerShellCommand);
+                    if (propertyName === powershell_1.Property.RUNTIME_ID) {
+                        return [new powershell_1.PropertyCondition(propertyName, new powershell_1.PSInt32Array(String(value).split('.').map(Number))), relativeExprNodes];
                     }
-                    if (propertyName === types_1.Property.ORIENTATION) {
-                        return [new conditions_1.PropertyCondition(propertyName, new common_1.PSOrientationType(String(value))), relativeExprNodes];
+                    if (propertyName === powershell_1.Property.ORIENTATION) {
+                        return [new powershell_1.PropertyCondition(propertyName, new powershell_1.PSOrientationType(String(value))), relativeExprNodes];
                     }
-                    if (Object.values(types_1.Int32Property).includes(propertyName)) {
-                        return [new conditions_1.PropertyCondition(propertyName, new common_1.PSInt32(Number(value))), relativeExprNodes];
+                    if (Object.values(powershell_1.Int32Property).includes(propertyName)) {
+                        return [new powershell_1.PropertyCondition(propertyName, new powershell_1.PSInt32(Number(value))), relativeExprNodes];
                     }
-                    if (Object.values(types_1.StringProperty).includes(propertyName)) {
-                        return [new conditions_1.PropertyCondition(propertyName, new common_1.PSString(String(value))), relativeExprNodes];
+                    if (Object.values(powershell_1.StringProperty).includes(propertyName)) {
+                        return [new powershell_1.PropertyCondition(propertyName, new powershell_1.PSString(String(value))), relativeExprNodes];
                     }
-                    if (Object.values(types_1.BooleanProperty).includes(propertyName)) {
-                        return [new conditions_1.PropertyCondition(propertyName, new common_1.PSBoolean(Boolean(value))), relativeExprNodes];
+                    if (Object.values(powershell_1.BooleanProperty).includes(propertyName)) {
+                        return [new powershell_1.PropertyCondition(propertyName, new powershell_1.PSBoolean(Boolean(value))), relativeExprNodes];
                     }
                 }
                 if (exprNode.rhs.type === xpath_analyzer_1.RELATIVE_LOCATION_PATH
@@ -299,21 +299,21 @@ async function processExprNodeAsPredicate(exprNode, context, positions, sendComm
                     && exprNode.rhs.steps[0].test.type === xpath_analyzer_1.NODE_NAME_TEST
                     && XPathAllowedProperties.includes(exprNode.rhs.steps[0].test.name?.toLowerCase())) {
                     const propertyName = exprNode.rhs.steps[0].test.name?.toLowerCase();
-                    const [value] = await processExprNode(exprNode.lhs, context, sendCommand);
-                    if (propertyName === types_1.Property.RUNTIME_ID) {
-                        return [new conditions_1.PropertyCondition(propertyName, new common_1.PSInt32Array(String(value).split('.').map(Number))), relativeExprNodes];
+                    const [value] = await processExprNode(exprNode.lhs, context, sendPowerShellCommand);
+                    if (propertyName === powershell_1.Property.RUNTIME_ID) {
+                        return [new powershell_1.PropertyCondition(propertyName, new powershell_1.PSInt32Array(String(value).split('.').map(Number))), relativeExprNodes];
                     }
-                    if (propertyName === types_1.Property.ORIENTATION) {
-                        return [new conditions_1.PropertyCondition(propertyName, new common_1.PSOrientationType(String(value))), relativeExprNodes];
+                    if (propertyName === powershell_1.Property.ORIENTATION) {
+                        return [new powershell_1.PropertyCondition(propertyName, new powershell_1.PSOrientationType(String(value))), relativeExprNodes];
                     }
-                    if (Object.values(types_1.Int32Property).includes(propertyName)) {
-                        return [new conditions_1.PropertyCondition(propertyName, new common_1.PSInt32(Number(value))), relativeExprNodes];
+                    if (Object.values(powershell_1.Int32Property).includes(propertyName)) {
+                        return [new powershell_1.PropertyCondition(propertyName, new powershell_1.PSInt32(Number(value))), relativeExprNodes];
                     }
-                    if (Object.values(types_1.StringProperty).includes(propertyName)) {
-                        return [new conditions_1.PropertyCondition(propertyName, new common_1.PSString(String(value))), relativeExprNodes];
+                    if (Object.values(powershell_1.StringProperty).includes(propertyName)) {
+                        return [new powershell_1.PropertyCondition(propertyName, new powershell_1.PSString(String(value))), relativeExprNodes];
                     }
-                    if (Object.values(types_1.BooleanProperty).includes(propertyName)) {
-                        return [new conditions_1.PropertyCondition(propertyName, new common_1.PSBoolean(Boolean(value))), relativeExprNodes];
+                    if (Object.values(powershell_1.BooleanProperty).includes(propertyName)) {
+                        return [new powershell_1.PropertyCondition(propertyName, new powershell_1.PSBoolean(Boolean(value))), relativeExprNodes];
                     }
                 }
             }
@@ -323,149 +323,159 @@ async function processExprNodeAsPredicate(exprNode, context, positions, sendComm
                         positions.add(0x7FFFFFFF);
                     }
                     else {
-                        const [value] = await processExprNode(exprNode.rhs, context, sendCommand);
+                        const [value] = await processExprNode(exprNode.rhs, context, sendPowerShellCommand);
                         if (typeof value !== 'number') {
-                            return [new conditions_1.FalseCondition()];
+                            return [new powershell_1.FalseCondition()];
                         }
                         positions.add(value);
                     }
-                    return [new conditions_1.TrueCondition()];
+                    return [new powershell_1.TrueCondition];
                 }
                 if (exprNode.rhs.type === xpath_analyzer_1.FUNCTION_CALL && exprNode.rhs.name === xpath_analyzer_1.POSITION) {
                     if (exprNode.lhs.type === xpath_analyzer_1.FUNCTION_CALL && exprNode.lhs.name === xpath_analyzer_1.LAST) {
                         positions.add(0x7FFFFFFF);
                     }
                     else {
-                        const [value] = await processExprNode(exprNode.lhs, context, sendCommand);
+                        const [value] = await processExprNode(exprNode.lhs, context, sendPowerShellCommand);
                         if (typeof value !== 'number') {
-                            return [new conditions_1.FalseCondition()];
+                            return [new powershell_1.FalseCondition()];
                         }
                         positions.add(value);
                     }
-                    return [new conditions_1.TrueCondition()];
+                    return [new powershell_1.TrueCondition];
                 }
             }
         }
         // eslint-disable-next-line no-fallthrough
         default: {
-            const result = await processExprNode(exprNode, context, sendCommand);
+            const result = await processExprNode(exprNode, context, sendPowerShellCommand);
             if (result.length === 1 && typeof result[0] === 'number' && !isNaN(result[0])) {
                 return await processExprNodeAsPredicate({
                     type: xpath_analyzer_1.EQUALITY,
-                    lhs: { type: xpath_analyzer_1.FUNCTION_CALL, name: xpath_analyzer_1.POSITION, args: [] },
-                    rhs: { type: xpath_analyzer_1.NUMBER, number: result[0] }
-                }, context, positions, sendCommand, relativeExprNodes);
+                    lhs: {
+                        type: xpath_analyzer_1.FUNCTION_CALL,
+                        name: xpath_analyzer_1.POSITION,
+                        args: [],
+                    },
+                    rhs: {
+                        type: xpath_analyzer_1.NUMBER,
+                        number: result[0],
+                    }
+                }, context, positions, sendPowerShellCommand, relativeExprNodes);
             }
             relativeExprNodes.push(exprNode);
-            return [new conditions_1.TrueCondition(), relativeExprNodes];
+            return [new powershell_1.TrueCondition(), relativeExprNodes];
         }
     }
 }
-const SCOPE_MAP = new Map([
-    [xpath_analyzer_1.ANCESTOR, 'ancestors'],
-    [xpath_analyzer_1.ANCESTOR_OR_SELF, 'ancestors-or-self'],
-    [xpath_analyzer_1.CHILD, 'children'],
-    [xpath_analyzer_1.DESCENDANT, 'descendants'],
-    [xpath_analyzer_1.DESCENDANT_OR_SELF, 'subtree'],
-    [xpath_analyzer_1.FOLLOWING, 'following'],
-    [xpath_analyzer_1.FOLLOWING_SIBLING, 'following-sibling'],
-    [xpath_analyzer_1.PARENT, 'parent'],
-    [xpath_analyzer_1.PRECEDING, 'preceding'],
-    [xpath_analyzer_1.PRECEDING_SIBLING, 'preceding-sibling'],
-    [xpath_analyzer_1.SELF, 'element'],
-]);
-async function executeStep(step, context, sendCommand) {
+async function executeStep(step, context, sendPowerShellCommand) {
     const predicateConditions = [];
     const relativeExprNodes = [];
     const positions = new Set();
     for (const predicate of step.predicates) {
-        const [condition, exprNodes] = await processExprNodeAsPredicate(predicate, context, positions, sendCommand);
+        const [condition, exprNodes] = await processExprNodeAsPredicate(predicate, context, positions, sendPowerShellCommand);
         predicateConditions.push(condition);
         if (exprNodes) {
             relativeExprNodes.push(...exprNodes);
         }
     }
-    const nodeTestCondition = convertNodeTestToCondition(step.test);
-    const condition = predicateConditions.length > 0
-        ? new conditions_1.AndCondition(nodeTestCondition, ...predicateConditions)
-        : nodeTestCondition;
-    if (step.axis === xpath_analyzer_1.NAMESPACE) {
-        return [];
-    }
-    const scope = SCOPE_MAP.get(step.axis);
-    if (!scope) {
-        throw new base_driver_1.errors.InvalidArgumentError(`Unsupported axis: ${step.axis}`);
-    }
-    const conditionDto = (0, converter_bridge_1.conditionToDto)(condition);
-    const contextElementId = getContextElementId(context);
-    let elIds;
-    if (step[OptimizeLastStep]) {
-        const result = await sendCommand('findElement', { scope, condition: conditionDto, contextElementId });
-        elIds = result ? [result] : [];
-    }
-    else {
-        elIds = await sendCommand('findElements', { scope, condition: conditionDto, contextElementId }) ?? [];
+    const condition = predicateConditions.length > 0 ? new powershell_1.AndCondition(convertNodeTestToCondition(step.test), ...predicateConditions) : convertNodeTestToCondition(step.test);
+    let find;
+    switch (step.axis) {
+        case xpath_analyzer_1.ANCESTOR:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.ANCESTORS, condition) : context.findAll(powershell_1.TreeScope.ANCESTORS, condition);
+            break;
+        case xpath_analyzer_1.ANCESTOR_OR_SELF:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.ANCESTORS_OR_SELF, condition) : context.findAll(powershell_1.TreeScope.ANCESTORS_OR_SELF, condition);
+            break;
+        case xpath_analyzer_1.CHILD:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.CHILDREN, condition) : context.findAll(powershell_1.TreeScope.CHILDREN, condition);
+            break;
+        case xpath_analyzer_1.DESCENDANT:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.DESCENDANTS, condition) : context.findAll(powershell_1.TreeScope.DESCENDANTS, condition);
+            break;
+        case xpath_analyzer_1.DESCENDANT_OR_SELF:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.SUBTREE, condition) : context.findAll(powershell_1.TreeScope.SUBTREE, condition);
+            break;
+        case xpath_analyzer_1.FOLLOWING:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.FOLLOWING, condition) : context.findAll(powershell_1.TreeScope.FOLLOWING, condition);
+            break;
+        case xpath_analyzer_1.FOLLOWING_SIBLING:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.FOLLOWING_SIBLING, condition) : context.findAll(powershell_1.TreeScope.FOLLOWING_SIBLING, condition);
+            break;
+        case xpath_analyzer_1.NAMESPACE:
+            return new powershell_1.AutomationElementGroup( /* empty */);
+        case xpath_analyzer_1.PARENT:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.PARENT, condition) : context.findAll(powershell_1.TreeScope.PARENT, condition);
+            break;
+        case xpath_analyzer_1.PRECEDING:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.PRECEDING, condition) : context.findAll(powershell_1.TreeScope.PRECEDING, condition);
+            break;
+        case xpath_analyzer_1.PRECEDING_SIBLING:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.PRECEDING_SIBLING, condition) : context.findAll(powershell_1.TreeScope.PRECEDING_SIBLING, condition);
+            break;
+        case xpath_analyzer_1.SELF:
+            find = step[OptimizeLastStep] ? context.findFirst(powershell_1.TreeScope.ELEMENT, condition) : context.findAll(powershell_1.TreeScope.ELEMENT, condition);
+            break;
+        default:
+            throw new base_driver_1.errors.InvalidArgumentError(); // should not be reached, attribute is handled before that
     }
+    const result = await sendPowerShellCommand(find.buildCommand());
+    const els = result.split('\n').map((id) => id.trim()).filter(Boolean).map((id) => new powershell_1.FoundAutomationElement(id));
     const validEls = [];
-    for (const elId of elIds) {
+    for (const el of els) {
         let isValid = true;
         for (const exprNode of relativeExprNodes) {
-            const el = foundElement(elId);
-            const [isTrue] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.BOOLEAN, el, sendCommand, exprNode);
+            const [isTrue] = await (0, functions_1.handleFunctionCall)(xpath_analyzer_1.BOOLEAN, el, sendPowerShellCommand, exprNode);
             if (!isTrue) {
                 isValid = false;
                 break;
             }
         }
         if (isValid) {
-            validEls.push(foundElement(elId));
+            validEls.push(el);
         }
     }
     const positionsArray = Array.from(positions);
     if (positionsArray.length === 0) {
-        return validEls;
+        return new powershell_1.AutomationElementGroup(...validEls);
     }
     else {
-        return positionsArray
-            .map((index) => index === 0x7FFFFFFF ? validEls[validEls.length - 1] : validEls[index - 1])
-            .filter(Boolean);
+        return new powershell_1.AutomationElementGroup(...positionsArray.map((index) => index === 0x7FFFFFFF ? validEls[validEls.length - 1] : validEls[index - 1]).filter(Boolean));
     }
 }
 function convertNodeTestToCondition(nodeTest) {
     switch (nodeTest.type) {
         case xpath_analyzer_1.NODE_NAME_TEST:
             if (nodeTest.name === '*') {
-                return new conditions_1.TrueCondition();
+                return new powershell_1.TrueCondition();
             }
+            // workaround for ControlType 50039 and 50040 not supported in UIAutomationClient
             if (nodeTest.name.toLowerCase() === 'appbar' || nodeTest.name.toLowerCase() === 'semanticzoom') {
-                return new conditions_1.PropertyCondition(types_1.Property.LOCALIZED_CONTROL_TYPE, new common_1.PSString(new common_1.PSControlType(nodeTest.name).toString()));
+                // PSControlType already has a logic to correct the value to localized control type
+                return new powershell_1.PropertyCondition(powershell_1.Property.LOCALIZED_CONTROL_TYPE, new powershell_1.PSString(new powershell_1.PSControlType(nodeTest.name).toString()));
             }
-            return new conditions_1.PropertyCondition(types_1.Property.CONTROL_TYPE, new common_1.PSControlType(nodeTest.name));
+            return new powershell_1.PropertyCondition(powershell_1.Property.CONTROL_TYPE, new powershell_1.PSControlType(nodeTest.name));
         case xpath_analyzer_1.NODE_TYPE_TEST:
             if (nodeTest.name === xpath_analyzer_1.NODE) {
-                return new conditions_1.TrueCondition();
+                return new powershell_1.TrueCondition();
             }
         // eslint-disable-next-line no-fallthrough
         case xpath_analyzer_1.PROCESSING_INSTRUCTION_TEST:
-            return new conditions_1.FalseCondition();
+            return new powershell_1.FalseCondition();
     }
 }
-async function convertAttributeNodeTestToStringArray(nodeTest, context, sendCommand) {
-    const contextId = getContextElementId(context);
-    // Get the runtime IDs for the context element(s)
-    const runtimeId = await sendCommand('getProperty', {
-        elementId: contextId ?? await sendCommand('saveRootElementToTable', {}),
-        property: 'RuntimeId',
-    });
-    const elIds = runtimeId.split('\n').map((id) => id.trim()).filter(Boolean);
+async function convertAttributeNodeTestToStringArray(nodeTest, context, sendPowerShellCommand) {
+    const result = await sendPowerShellCommand(context.buildGetPropertyCommand(powershell_1.Property.RUNTIME_ID));
+    const els = result.split('\n').map((id) => id.trim()).filter(Boolean).map((id) => new powershell_1.FoundAutomationElement(id.trim()));
     const extraProperties = ['x', 'y', 'width', 'height'];
     switch (nodeTest.type) {
         case xpath_analyzer_1.NODE_TYPE_TEST:
             if (nodeTest.name === xpath_analyzer_1.NODE) {
                 const results = [];
-                for (const name of Object.values(types_1.Property)) {
-                    for (const elId of elIds) {
-                        results.push(await sendCommand('getProperty', { elementId: elId, property: name }));
+                for (const name of Object.values(powershell_1.Property)) {
+                    for (const el of els) {
+                        results.push(await sendPowerShellCommand(el.buildGetPropertyCommand(name)));
                     }
                 }
                 return results;
@@ -474,16 +484,16 @@ async function convertAttributeNodeTestToStringArray(nodeTest, context, sendComm
         case xpath_analyzer_1.NODE_NAME_TEST:
             if (extraProperties.includes(nodeTest.name.toLowerCase())) {
                 const results = [];
-                for (const elId of elIds) {
-                    const rect = await sendCommand('getRect', { elementId: elId });
-                    results.push(String(rect[nodeTest.name.toLowerCase()]));
+                for (const el of els) {
+                    const rectJson = await sendPowerShellCommand(el.buildGetElementRectCommand());
+                    results.push(JSON.parse(rectJson.replaceAll(/(?:infinity)/gi, 0x7FFFFFFF.toString()))[nodeTest.name.toLowerCase()]);
                 }
                 return results;
             }
-            if (Object.values(types_1.Property).includes(nodeTest.name.toLowerCase())) {
+            if (Object.values(powershell_1.Property).includes(nodeTest.name.toLowerCase())) {
                 const results = [];
-                for (const elId of elIds) {
-                    results.push(await sendCommand('getProperty', { elementId: elId, property: nodeTest.name }));
+                for (const el of els) {
+                    results.push(await sendPowerShellCommand(el.buildGetPropertyCommand(nodeTest.name)));
                 }
                 return results;
             }
@@ -493,26 +503,33 @@ async function convertAttributeNodeTestToStringArray(nodeTest, context, sendComm
             return [];
     }
 }
-function isXPathElement(value) {
-    return typeof value === 'object' && value !== null && 'type' in value && (value.type === 'root' || value.type === 'found');
-}
 function convertToElementArray(element) {
+    if (element instanceof powershell_1.AutomationElementGroup) {
+        return flattenElementGroupsAndRemoveDuplicates(element.groups);
+    }
     return [element];
 }
-function removeDuplicateElements(elements) {
+function flattenElementGroupsAndRemoveDuplicates(elements) {
     const seen = new Set();
-    return elements.filter((el) => {
-        if (el.type === 'found' && el.elementId) {
-            if (seen.has(el.elementId)) {
-                return false;
+    return elements.reduce((acc, el) => {
+        if (el instanceof powershell_1.AutomationElementGroup) {
+            return acc.concat(flattenElementGroupsAndRemoveDuplicates(el.groups));
+        }
+        else {
+            if (el instanceof powershell_1.FoundAutomationElement && seen.has(el.runtimeId)) {
+                return acc;
+            }
+            if (el instanceof powershell_1.FoundAutomationElement) {
+                seen.add(el.runtimeId);
             }
-            seen.add(el.elementId);
+            acc.push(el);
+            return acc;
         }
-        return true;
-    });
+    }, []);
 }
 function optimizeDoubleSlash(steps) {
     for (let i = 0; i < steps.length - 1; i++) {
+        // detect double slash: //element is the same as /descendant-or-self::node()/child::element
         if (steps[i].axis === xpath_analyzer_1.DESCENDANT_OR_SELF && steps[i].test.type === xpath_analyzer_1.NODE_TYPE_TEST && steps[i].predicates.length === 0 && steps[i + 1].axis === xpath_analyzer_1.CHILD) {
             const optimizedStep = { axis: xpath_analyzer_1.DESCENDANT, test: steps[i + 1].test, predicates: steps[i + 1].predicates };
             if (steps[i + 1][OptimizeLastStep]) {
@@ -522,6 +539,7 @@ function optimizeDoubleSlash(steps) {
             if (steps[i].predicates.some((predicate) => predicate.type === xpath_analyzer_1.FUNCTION_CALL && (predicate.name === xpath_analyzer_1.LAST || predicate.name === xpath_analyzer_1.POSITION))) {
                 stepsToAdd.push({ axis: xpath_analyzer_1.PARENT, test: { type: xpath_analyzer_1.NODE_TYPE_TEST, name: 'node' }, predicates: [] }, steps[i + 1]);
             }
+            // mutates the original array by reference
             steps.splice(i, 2, ...stepsToAdd);
         }
     }
@@ -567,8 +585,9 @@ function predicateProcessableBeforeNode(exprNode) {
             }
         }
         // eslint-disable-next-line no-fallthrough
-        default:
+        default: {
             return false;
+        }
     }
 }
 //# sourceMappingURL=core.js.map