appium-webdriveragent 13.1.3 → 13.2.1

package/WebDriverAgentLib/Utilities/FBSettingsHandler.m

@@ -0,0 +1,356 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "FBSettingsHandler.h"
+
+#import "FBActiveAppDetectionPoint.h"
+#import "FBClassChainQueryParser.h"
+#import "FBCommandStatus.h"
+#import "FBConfiguration.h"
+#import "FBSession.h"
+#import "FBSettings.h"
+
+typedef FBCommandStatus * _Nullable (^FBSettingApplyBlock)(FBSession *session, id value);
+typedef id _Nonnull (^FBSettingGetBlock)(FBSession *session);
+
+static id FBNormalizedSettingValue(id value)
+{
+  return value == NSNull.null ? nil : value;
+}
+
+static NSSet<NSString *> *FBNilClearableSettingKeys(void)
+{
+  static NSSet<NSString *> *keys;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    keys = [NSSet setWithObjects:
+      FB_SETTING_DEFAULT_ALERT_ACTION,
+      FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR,
+      FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR,
+      FB_SETTING_AUTO_CLICK_ALERT_SELECTOR,
+      nil];
+  });
+  return keys;
+}
+
+@implementation FBSettingsHandler
+
++ (NSDictionary<NSString *, FBSettingApplyBlock> *)settersMap
+{
+  static NSDictionary<NSString *, FBSettingApplyBlock> *settersMap;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary<NSString *, FBSettingApplyBlock> *map = [NSMutableDictionary dictionary];
+    map[FB_SETTING_USE_COMPACT_RESPONSES] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setShouldUseCompactResponses:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setElementResponseAttributes:(NSString *)value];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setMjpegServerScreenshotQuality:[value unsignedIntegerValue]];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_SERVER_FRAMERATE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setMjpegServerFramerate:[value unsignedIntegerValue]];
+      return nil;
+    };
+    map[FB_SETTING_SCREENSHOT_QUALITY] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setScreenshotQuality:[value unsignedIntegerValue]];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_SCALING_FACTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setMjpegScalingFactor:[value floatValue]];
+      return nil;
+    };
+    map[FB_SETTING_MJPEG_FIX_ORIENTATION] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setMjpegShouldFixOrientation:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_KEYBOARD_AUTOCORRECTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setKeyboardAutocorrection:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_KEYBOARD_PREDICTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setKeyboardPrediction:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_RESPECT_SYSTEM_ALERTS] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setShouldRespectSystemAlerts:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_DEPTH] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setSnapshotMaxDepth:[value intValue]];
+      return nil;
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_CHILDREN] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setSnapshotMaxChildren:[value intValue]];
+      return nil;
+    };
+    map[FB_SETTING_USE_FIRST_MATCH] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setUseFirstMatch:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_BOUND_ELEMENTS_BY_INDEX] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setBoundElementsByIndex:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_REDUCE_MOTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setReduceMotionEnabled:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_DEFAULT_ACTIVE_APPLICATION] = ^FBCommandStatus *(FBSession *session, id value) {
+      session.defaultActiveApplication = (NSString *)value;
+      return nil;
+    };
+    map[FB_SETTING_ACTIVE_APP_DETECTION_POINT] = ^FBCommandStatus *(FBSession *session, id value) {
+      NSError *error;
+      if (![FBActiveAppDetectionPoint.sharedInstance setCoordinatesWithString:(NSString *)value
+                                                                        error:&error]) {
+        return [FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
+                                                      traceback:nil];
+      }
+      return nil;
+    };
+    map[FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setAcceptAlertButtonSelector:(NSString *)value];
+      return nil;
+    };
+    map[FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setDismissAlertButtonSelector:(NSString *)value];
+      return nil;
+    };
+    map[FB_SETTING_AUTO_CLICK_ALERT_SELECTOR] = ^FBCommandStatus *(FBSession *session, id value) {
+      return [self configureAutoClickAlertWithSelector:(NSString *)value forSession:session];
+    };
+    map[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setWaitForIdleTimeout:[value doubleValue]];
+      return nil;
+    };
+    map[FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setAnimationCoolOffTimeout:[value doubleValue]];
+      return nil;
+    };
+    map[FB_SETTING_DEFAULT_ALERT_ACTION] = ^FBCommandStatus *(FBSession *session, id value) {
+      if (nil == value) {
+        session.defaultAlertAction = nil;
+      } else if ([value isKindOfClass:NSString.class]) {
+        session.defaultAlertAction = [(NSString *)value lowercaseString];
+      }
+      return nil;
+    };
+    map[FB_SETTING_MAX_TYPING_FREQUENCY] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setMaxTypingFrequency:[value unsignedIntegerValue]];
+      return nil;
+    };
+    map[FB_SETTING_USE_CLEAR_TEXT_SHORTCUT] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setUseClearTextShortcut:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setIncludeHittableInPageSource:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setIncludeNativeFrameInPageSource:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setIncludeMinMaxValueInPageSource:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setIncludeCustomActionsInPageSource:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setEnforceCustomSnapshots:[value boolValue]];
+      return nil;
+    };
+    map[FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE] = ^FBCommandStatus *(FBSession *session, id value) {
+      [FBConfiguration setLimitXpathContextScope:[value boolValue]];
+      return nil;
+    };
+#if !TARGET_OS_TV
+    map[FB_SETTING_SCREENSHOT_ORIENTATION] = ^FBCommandStatus *(FBSession *session, id value) {
+      NSError *error;
+      if (![FBConfiguration setScreenshotOrientation:(NSString *)value error:&error]) {
+        return [FBCommandStatus invalidArgumentErrorWithMessage:error.localizedDescription
+                                                      traceback:nil];
+      }
+      return nil;
+    };
+#endif
+    settersMap = map.copy;
+  });
+  return settersMap;
+}
+
++ (NSDictionary<NSString *, FBSettingGetBlock> *)gettersMap
+{
+  static NSDictionary<NSString *, FBSettingGetBlock> *gettersMap;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary<NSString *, FBSettingGetBlock> *map = [NSMutableDictionary dictionary];
+    map[FB_SETTING_USE_COMPACT_RESPONSES] = ^id(FBSession *session) {
+      return @([FBConfiguration shouldUseCompactResponses]);
+    };
+    map[FB_SETTING_ELEMENT_RESPONSE_ATTRIBUTES] = ^id(FBSession *session) {
+      return [FBConfiguration elementResponseAttributes];
+    };
+    map[FB_SETTING_MJPEG_SERVER_SCREENSHOT_QUALITY] = ^id(FBSession *session) {
+      return @([FBConfiguration mjpegServerScreenshotQuality]);
+    };
+    map[FB_SETTING_MJPEG_SERVER_FRAMERATE] = ^id(FBSession *session) {
+      return @([FBConfiguration mjpegServerFramerate]);
+    };
+    map[FB_SETTING_MJPEG_SCALING_FACTOR] = ^id(FBSession *session) {
+      return @([FBConfiguration mjpegScalingFactor]);
+    };
+    map[FB_SETTING_MJPEG_FIX_ORIENTATION] = ^id(FBSession *session) {
+      return @([FBConfiguration mjpegShouldFixOrientation]);
+    };
+    map[FB_SETTING_SCREENSHOT_QUALITY] = ^id(FBSession *session) {
+      return @([FBConfiguration screenshotQuality]);
+    };
+    map[FB_SETTING_KEYBOARD_AUTOCORRECTION] = ^id(FBSession *session) {
+      return @([FBConfiguration keyboardAutocorrection]);
+    };
+    map[FB_SETTING_KEYBOARD_PREDICTION] = ^id(FBSession *session) {
+      return @([FBConfiguration keyboardPrediction]);
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_DEPTH] = ^id(FBSession *session) {
+      return @([FBConfiguration snapshotMaxDepth]);
+    };
+    map[FB_SETTING_SNAPSHOT_MAX_CHILDREN] = ^id(FBSession *session) {
+      return @([FBConfiguration snapshotMaxChildren]);
+    };
+    map[FB_SETTING_USE_FIRST_MATCH] = ^id(FBSession *session) {
+      return @([FBConfiguration useFirstMatch]);
+    };
+    map[FB_SETTING_WAIT_FOR_IDLE_TIMEOUT] = ^id(FBSession *session) {
+      return @([FBConfiguration waitForIdleTimeout]);
+    };
+    map[FB_SETTING_ANIMATION_COOL_OFF_TIMEOUT] = ^id(FBSession *session) {
+      return @([FBConfiguration animationCoolOffTimeout]);
+    };
+    map[FB_SETTING_BOUND_ELEMENTS_BY_INDEX] = ^id(FBSession *session) {
+      return @([FBConfiguration boundElementsByIndex]);
+    };
+    map[FB_SETTING_REDUCE_MOTION] = ^id(FBSession *session) {
+      return @([FBConfiguration reduceMotionEnabled]);
+    };
+    map[FB_SETTING_DEFAULT_ACTIVE_APPLICATION] = ^id(FBSession *session) {
+      return session.defaultActiveApplication;
+    };
+    map[FB_SETTING_ACTIVE_APP_DETECTION_POINT] = ^id(FBSession *session) {
+      return FBActiveAppDetectionPoint.sharedInstance.stringCoordinates;
+    };
+    map[FB_SETTING_ACCEPT_ALERT_BUTTON_SELECTOR] = ^id(FBSession *session) {
+      return FBConfiguration.acceptAlertButtonSelector;
+    };
+    map[FB_SETTING_DISMISS_ALERT_BUTTON_SELECTOR] = ^id(FBSession *session) {
+      return FBConfiguration.dismissAlertButtonSelector;
+    };
+    map[FB_SETTING_AUTO_CLICK_ALERT_SELECTOR] = ^id(FBSession *session) {
+      return FBConfiguration.autoClickAlertSelector;
+    };
+    map[FB_SETTING_DEFAULT_ALERT_ACTION] = ^id(FBSession *session) {
+      return session.defaultAlertAction ?: @"";
+    };
+    map[FB_SETTING_MAX_TYPING_FREQUENCY] = ^id(FBSession *session) {
+      return @([FBConfiguration maxTypingFrequency]);
+    };
+    map[FB_SETTING_RESPECT_SYSTEM_ALERTS] = ^id(FBSession *session) {
+      return @([FBConfiguration shouldRespectSystemAlerts]);
+    };
+    map[FB_SETTING_USE_CLEAR_TEXT_SHORTCUT] = ^id(FBSession *session) {
+      return @([FBConfiguration useClearTextShortcut]);
+    };
+    map[FB_SETTING_INCLUDE_HITTABLE_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @([FBConfiguration includeHittableInPageSource]);
+    };
+    map[FB_SETTING_INCLUDE_NATIVE_FRAME_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @([FBConfiguration includeNativeFrameInPageSource]);
+    };
+    map[FB_SETTING_INCLUDE_MIN_MAX_VALUE_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @([FBConfiguration includeMinMaxValueInPageSource]);
+    };
+    map[FB_SETTING_INCLUDE_CUSTOM_ACTIONS_IN_PAGE_SOURCE] = ^id(FBSession *session) {
+      return @([FBConfiguration includeCustomActionsInPageSource]);
+    };
+    map[FB_SETTING_ENFORCE_CUSTOM_SNAPSHOTS] = ^id(FBSession *session) {
+      return @([FBConfiguration enforceCustomSnapshots]);
+    };
+    map[FB_SETTING_LIMIT_XPATH_CONTEXT_SCOPE] = ^id(FBSession *session) {
+      return @([FBConfiguration limitXpathContextScope]);
+    };
+#if !TARGET_OS_TV
+    map[FB_SETTING_SCREENSHOT_ORIENTATION] = ^id(FBSession *session) {
+      return [FBConfiguration humanReadableScreenshotOrientation];
+    };
+#endif
+    gettersMap = map.copy;
+  });
+  return gettersMap;
+}
+
++ (NSDictionary *)currentSettingsForSession:(FBSession *)session
+{
+  NSDictionary<NSString *, FBSettingGetBlock> *gettersMap = [self gettersMap];
+  NSMutableDictionary *settings = [NSMutableDictionary dictionaryWithCapacity:gettersMap.count];
+  for (NSString *key in gettersMap) {
+    settings[key] = gettersMap[key](session);
+  }
+  return settings.copy;
+}
+
++ (nullable FBCommandStatus *)applySettings:(NSDictionary *)settings toSession:(FBSession *)session
+{
+  NSDictionary<NSString *, FBSettingApplyBlock> *settersMap = [self settersMap];
+  NSSet<NSString *> *nilClearableKeys = FBNilClearableSettingKeys();
+  for (NSString *key in settings) {
+    FBSettingApplyBlock handler = settersMap[key];
+    if (nil == handler) {
+      continue;
+    }
+    id value = FBNormalizedSettingValue(settings[key]);
+    if (nil == value && ![nilClearableKeys containsObject:key]) {
+      continue;
+    }
+    FBCommandStatus *status = handler(session, value);
+    if (status.hasError) {
+      return status;
+    }
+  }
+  return nil;
+}
+
++ (FBCommandStatus *)configureAutoClickAlertWithSelector:(NSString *)selector
+                                              forSession:(FBSession *)session
+{
+  if (0 == [selector length]) {
+    [FBConfiguration setAutoClickAlertSelector:selector];
+    [session disableAlertsMonitor];
+    return [FBCommandStatus ok];
+  }
+
+  NSError *error;
+  FBClassChain *parsedChain = [FBClassChainQueryParser parseQuery:selector error:&error];
+  if (nil == parsedChain) {
+    return [FBCommandStatus invalidSelectorErrorWithMessage:error.localizedDescription
+                                                  traceback:nil];
+  }
+  [FBConfiguration setAutoClickAlertSelector:selector];
+  [session enableAlertsMonitor];
+  return [FBCommandStatus ok];
+}
+
+@end

package/WebDriverAgentLib/Utilities/FBXPath-Private.h

@@ -51,6 +51,11 @@ NS_ASSUME_NONNULL_BEGIN
                      document:(xmlDocPtr)doc
                   contextNode:(nullable xmlNodePtr)contextNode;
 
++ (xmlXPathObjectPtr)evaluate:(NSString *)xpathQuery
+                     document:(xmlDocPtr)doc
+                  contextNode:(nullable xmlNodePtr)contextNode
+                 errorMessage:(NSString * _Nullable * _Nullable)errorMessage;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/WebDriverAgentLib/Utilities/FBXPath.m

@@ -14,6 +14,7 @@
 #import "FBLogger.h"
 #import "FBMacros.h"
 #import "FBXMLGenerationOptions.h"
+#import "FBXPathExtensions.h"
 #import "FBXCElementSnapshotWrapper+Helpers.h"
 #import "NSString+FBXMLSafeString.h"
 #import "XCUIApplication.h"
@@ -152,7 +153,17 @@ static NSString *const topNodeIndexPath = @"top";
 
 + (id)throwException:(NSString *)name forQuery:(NSString *)xpathQuery
 {
-  NSString *reason = [NSString stringWithFormat:@"Cannot evaluate results for XPath expression \"%@\"", xpathQuery];
+  return [self throwException:name forQuery:xpathQuery detail:nil];
+}
+
++ (id)throwException:(NSString *)name forQuery:(NSString *)xpathQuery detail:(nullable NSString *)detail
+{
+  NSString *reason;
+  if (nil != detail) {
+    reason = [NSString stringWithFormat:@"Cannot evaluate results for XPath expression \"%@\": %@", xpathQuery, detail];
+  } else {
+    reason = [NSString stringWithFormat:@"Cannot evaluate results for XPath expression \"%@\"", xpathQuery];
+  }
   @throw [NSException exceptionWithName:name reason:reason userInfo:@{}];
   return nil;
 }
@@ -284,16 +295,18 @@ static NSString *const topNodeIndexPath = @"top";
       contextNode = nodeSet->nodeTab[0];
     }
   }
+  NSString *evaluationError = nil;
   xmlXPathObjectPtr queryResult = [self evaluate:xpathQuery
                                         document:doc
-                                     contextNode:contextNode];
+                                     contextNode:contextNode
+                                    errorMessage:&evaluationError];
   if (NULL != contextNodeQueryResult) {
     xmlXPathFreeObject(contextNodeQueryResult);
   }
   if (NULL == queryResult) {
     xmlFreeTextWriter(writer);
     xmlFreeDoc(doc);
-    return [self throwException:FBInvalidXPathException forQuery:xpathQuery];
+    return [self throwException:FBInvalidXPathException forQuery:xpathQuery detail:evaluationError];
   }
 
   NSArray *matchingSnapshots = [self collectMatchingSnapshots:queryResult->nodesetval
@@ -435,6 +448,14 @@ static NSString *const topNodeIndexPath = @"top";
 + (xmlXPathObjectPtr)evaluate:(NSString *)xpathQuery
                      document:(xmlDocPtr)doc
                   contextNode:(nullable xmlNodePtr)contextNode
+{
+  return [self evaluate:xpathQuery document:doc contextNode:contextNode errorMessage:nil];
+}
+
++ (xmlXPathObjectPtr)evaluate:(NSString *)xpathQuery
+                     document:(xmlDocPtr)doc
+                  contextNode:(nullable xmlNodePtr)contextNode
+                 errorMessage:(NSString * _Nullable * _Nullable)errorMessage
 {
   xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc);
   if (NULL == xpathCtx) {
@@ -443,10 +464,21 @@ static NSString *const topNodeIndexPath = @"top";
   }
   xpathCtx->node = NULL == contextNode ? doc->children : contextNode;
 
+  FBXPathExtensions *extensions = [FBXPathExtensions new];
+  [extensions registerFunctionsWithContext:xpathCtx];
+
   xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression((const xmlChar *)[xpathQuery UTF8String], xpathCtx);
   if (NULL == xpathObj) {
+    NSString *detail = extensions.lastEvaluationError;
+    if (NULL != errorMessage) {
+      *errorMessage = detail;
+    }
+    if (nil != detail) {
+      [FBLogger logFmt:@"Failed to evaluate XPath query \"%@\": %@", xpathQuery, detail];
+    } else {
+      [FBLogger logFmt:@"Failed to invoke libxml2>xmlXPathEvalExpression for XPath query \"%@\"", xpathQuery];
+    }
     xmlXPathFreeContext(xpathCtx);
-    [FBLogger logFmt:@"Failed to invoke libxml2>xmlXPathEvalExpression for XPath query \"%@\"", xpathQuery];
     return NULL;
   }
   xmlXPathFreeContext(xpathCtx);

package/WebDriverAgentLib/Utilities/FBXPathExtensions.h

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+#import <libxml/xpath.h>
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface FBXPathExtensions : NSObject
+
+/**
+ Registers XPath 2-compatible extension functions on the given libxml2 context.
+ */
+- (void)registerFunctionsWithContext:(xmlXPathContextPtr)xpathCtx;
+
+/**
+ Human-readable message for the most recent XPath extension evaluation failure on this instance,
+ for example an invalid regular expression pattern or flags. Nil when no extension error has occurred.
+ Scoped to the libxml2 context this instance is registered with; each evaluation should use its own instance.
+ */
+@property (nonatomic, nullable, readonly, copy) NSString *lastEvaluationError;
+
+@end
+
+NS_ASSUME_NONNULL_END