@appium/base-driver 8.7.3 → 9.0.0

package/build/lib/protocol/errors.js

@@ -1,1018 +1,970 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.XPathLookupError = exports.UnsupportedOperationError = exports.UnknownMethodError = exports.UnknownError = exports.UnknownCommandError = exports.UnexpectedAlertOpenError = exports.UnableToSetCookieError = exports.UnableToCaptureScreen = exports.TimeoutError = exports.StaleElementReferenceError = exports.SessionNotCreatedError = exports.ScriptTimeoutError = exports.ProxyRequestError = exports.ProtocolError = exports.NotYetImplementedError = exports.NotImplementedError = exports.NoSuchWindowError = exports.NoSuchFrameError = exports.NoSuchElementError = exports.NoSuchDriverError = exports.NoSuchCookieError = exports.NoSuchContextError = exports.NoSuchAlertError = exports.NoAlertOpenError = exports.MoveTargetOutOfBoundsError = exports.JavaScriptError = exports.InvalidSelectorError = exports.InvalidElementStateError = exports.InvalidElementCoordinatesError = exports.InvalidCoordinatesError = exports.InvalidCookieDomainError = exports.InvalidContextError = exports.InvalidArgumentError = exports.InsecureCertificateError = exports.IMENotAvailableError = exports.IMEEngineActivationFailedError = exports.ElementNotVisibleError = exports.ElementNotInteractableError = exports.ElementIsNotSelectableError = exports.ElementClickInterceptedError = exports.BadParametersError = void 0;
-exports.errorFromMJSONWPStatusCode = errorFromMJSONWPStatusCode;
-exports.errorFromW3CJsonCode = errorFromW3CJsonCode;
-exports.errors = void 0;
-exports.getResponseForJsonwpError = getResponseForJsonwpError;
-exports.getResponseForW3CError = getResponseForW3CError;
-exports.isErrorType = isErrorType;
-exports.isUnknownError = isUnknownError;
-
-require("source-map-support/register");
-
-var _es6Error = _interopRequireDefault(require("es6-error"));
-
-var _lodash = _interopRequireDefault(require("lodash"));
-
-var _support = require("@appium/support");
-
-var _httpStatusCodes = require("http-status-codes");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const mjsonwpLog = _support.logger.getLogger('MJSONWP');
-
-const w3cLog = _support.logger.getLogger('W3C');
-
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResponseForJsonwpError = exports.getResponseForW3CError = exports.errorFromW3CJsonCode = exports.errorFromMJSONWPStatusCode = exports.isUnknownError = exports.isErrorType = exports.errors = exports.ProxyRequestError = exports.BadParametersError = exports.UnableToCaptureScreen = exports.NotImplementedError = exports.NotYetImplementedError = exports.InvalidContextError = exports.NoSuchContextError = exports.MoveTargetOutOfBoundsError = exports.SessionNotCreatedError = exports.InvalidSelectorError = exports.IMEEngineActivationFailedError = exports.IMENotAvailableError = exports.InvalidCoordinatesError = exports.InvalidElementCoordinatesError = exports.ScriptTimeoutError = exports.NoSuchAlertError = exports.NoAlertOpenError = exports.UnexpectedAlertOpenError = exports.UnableToSetCookieError = exports.NoSuchCookieError = exports.InvalidCookieDomainError = exports.InvalidArgumentError = exports.NoSuchWindowError = exports.TimeoutError = exports.XPathLookupError = exports.JavaScriptError = exports.InsecureCertificateError = exports.ElementNotInteractableError = exports.ElementClickInterceptedError = exports.ElementIsNotSelectableError = exports.UnsupportedOperationError = exports.UnknownMethodError = exports.UnknownError = exports.InvalidElementStateError = exports.ElementNotVisibleError = exports.StaleElementReferenceError = exports.UnknownCommandError = exports.NoSuchFrameError = exports.NoSuchElementError = exports.NoSuchDriverError = exports.ProtocolError = void 0;
+const es6_error_1 = __importDefault(require("es6-error"));
+const lodash_1 = __importDefault(require("lodash"));
+const support_1 = require("@appium/support");
+const http_status_codes_1 = require("http-status-codes");
+const mjsonwpLog = support_1.logger.getLogger('MJSONWP');
+const w3cLog = support_1.logger.getLogger('W3C');
 const W3C_UNKNOWN_ERROR = 'unknown error';
-
-class ProtocolError extends _es6Error.default {
-  constructor(msg, jsonwpCode, w3cStatus, error) {
-    super(msg);
-    this.jsonwpCode = jsonwpCode;
-    this.error = error || W3C_UNKNOWN_ERROR;
-
-    if (this.jsonwpCode === null) {
-      this.jsonwpCode = 13;
-    }
-
-    this.w3cStatus = w3cStatus || _httpStatusCodes.StatusCodes.BAD_REQUEST;
-    this._stacktrace = null;
-  }
-
-  get stacktrace() {
-    return this._stacktrace || this.stack;
-  }
-
-  set stacktrace(value) {
-    this._stacktrace = value;
-  }
-
-}
-
+// base error class for all of our errors
+class ProtocolError extends es6_error_1.default {
+    constructor(msg, jsonwpCode, w3cStatus, error) {
+        super(msg);
+        this.jsonwpCode = jsonwpCode;
+        this.error = error || W3C_UNKNOWN_ERROR;
+        if (this.jsonwpCode === null) {
+            this.jsonwpCode = 13;
+        }
+        this.w3cStatus = w3cStatus || http_status_codes_1.StatusCodes.BAD_REQUEST;
+        this._stacktrace = null;
+    }
+    get stacktrace() {
+        return this._stacktrace || this.stack;
+    }
+    set stacktrace(value) {
+        this._stacktrace = value;
+    }
+}
 exports.ProtocolError = ProtocolError;
-
+// https://github.com/SeleniumHQ/selenium/blob/176b4a9e3082ac1926f2a436eb346760c37a5998/java/client/src/org/openqa/selenium/remote/ErrorCodes.java#L215
+// https://github.com/SeleniumHQ/selenium/issues/5562#issuecomment-370379470
+// https://w3c.github.io/webdriver/webdriver-spec.html#dfn-error-code
 class NoSuchDriverError extends ProtocolError {
-  static code() {
-    return 6;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.NOT_FOUND;
-  }
-
-  static error() {
-    return 'invalid session id';
-  }
-
-  constructor(err) {
-    super(err || 'A session is either terminated or not started', NoSuchDriverError.code(), NoSuchDriverError.w3cStatus(), NoSuchDriverError.error());
-  }
-
-}
-
+    static code() {
+        return 6;
+    }
+    // W3C Error is called InvalidSessionID
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.NOT_FOUND;
+    }
+    static error() {
+        return 'invalid session id';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message || 'A session is either terminated or not started', NoSuchDriverError.code(), NoSuchDriverError.w3cStatus(), NoSuchDriverError.error());
+    }
+}
 exports.NoSuchDriverError = NoSuchDriverError;
-
 class NoSuchElementError extends ProtocolError {
-  static code() {
-    return 7;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.NOT_FOUND;
-  }
-
-  static error() {
-    return 'no such element';
-  }
-
-  constructor(err) {
-    super(err || 'An element could not be located on the page using the given ' + 'search parameters.', NoSuchElementError.code(), NoSuchElementError.w3cStatus(), NoSuchElementError.error());
-  }
-
-}
-
+    static code() {
+        return 7;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.NOT_FOUND;
+    }
+    static error() {
+        return 'no such element';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message ||
+            'An element could not be located on the page using the given ' + 'search parameters.', NoSuchElementError.code(), NoSuchElementError.w3cStatus(), NoSuchElementError.error());
+    }
+}
 exports.NoSuchElementError = NoSuchElementError;
-
 class NoSuchFrameError extends ProtocolError {
-  static code() {
-    return 8;
-  }
-
-  static error() {
-    return 'no such frame';
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.NOT_FOUND;
-  }
-
-  constructor(err) {
-    super(err || 'A request to switch to a frame could not be satisfied because ' + 'the frame could not be found.', NoSuchFrameError.code(), NoSuchFrameError.w3cStatus(), NoSuchFrameError.error());
-  }
-
-}
-
+    static code() {
+        return 8;
+    }
+    static error() {
+        return 'no such frame';
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.NOT_FOUND;
+    }
+    /**
+     *
+     * @param {string} [message]
+     */
+    constructor(message) {
+        super(message ||
+            'A request to switch to a frame could not be satisfied because ' +
+                'the frame could not be found.', NoSuchFrameError.code(), NoSuchFrameError.w3cStatus(), NoSuchFrameError.error());
+    }
+}
 exports.NoSuchFrameError = NoSuchFrameError;
-
 class UnknownCommandError extends ProtocolError {
-  static code() {
-    return 9;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.NOT_FOUND;
-  }
-
-  static error() {
-    return 'unknown command';
-  }
-
-  constructor(err) {
-    super(err || 'The requested resource could not be found, or a request was ' + 'received using an HTTP method that is not supported by the mapped ' + 'resource.', UnknownCommandError.code(), UnknownCommandError.w3cStatus(), UnknownCommandError.error());
-  }
-
-}
-
+    static code() {
+        return 9;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.NOT_FOUND;
+    }
+    static error() {
+        return 'unknown command';
+    }
+    /**
+     *
+     * @param {string} [message]
+     */
+    constructor(message) {
+        super(message ||
+            'The requested resource could not be found, or a request was ' +
+                'received using an HTTP method that is not supported by the mapped ' +
+                'resource.', UnknownCommandError.code(), UnknownCommandError.w3cStatus(), UnknownCommandError.error());
+    }
+}
 exports.UnknownCommandError = UnknownCommandError;
-
 class StaleElementReferenceError extends ProtocolError {
-  static code() {
-    return 10;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.NOT_FOUND;
-  }
-
-  static error() {
-    return 'stale element reference';
-  }
-
-  constructor(err) {
-    super(err || 'An element command failed because the referenced element is no ' + 'longer attached to the DOM.', StaleElementReferenceError.code(), StaleElementReferenceError.w3cStatus(), StaleElementReferenceError.error());
-  }
-
-}
-
+    static code() {
+        return 10;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.NOT_FOUND;
+    }
+    static error() {
+        return 'stale element reference';
+    }
+    /**
+     *
+     * @param {string} [message]
+     */
+    constructor(message) {
+        super(message ||
+            'An element command failed because the referenced element is no ' +
+                'longer attached to the DOM.', StaleElementReferenceError.code(), StaleElementReferenceError.w3cStatus(), StaleElementReferenceError.error());
+    }
+}
 exports.StaleElementReferenceError = StaleElementReferenceError;
-
 class ElementNotVisibleError extends ProtocolError {
-  static code() {
-    return 11;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-  static error() {
-    return 'element not visible';
-  }
-
-  constructor(err) {
-    super(err || 'An element command could not be completed because the element is ' + 'not visible on the page.', ElementNotVisibleError.code(), ElementNotVisibleError.w3cStatus(), ElementNotVisibleError.error());
-  }
-
-}
-
+    static code() {
+        return 11;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+    static error() {
+        return 'element not visible';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message ||
+            'An element command could not be completed because the element is ' +
+                'not visible on the page.', ElementNotVisibleError.code(), ElementNotVisibleError.w3cStatus(), ElementNotVisibleError.error());
+    }
+}
 exports.ElementNotVisibleError = ElementNotVisibleError;
-
 class InvalidElementStateError extends ProtocolError {
-  static code() {
-    return 12;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-  static error() {
-    return 'invalid element state';
-  }
-
-  constructor(err) {
-    super(err || 'An element command could not be completed because the element is ' + 'in an invalid state (e.g. attempting to click a disabled element).', InvalidElementStateError.code(), InvalidElementStateError.w3cStatus(), InvalidElementStateError.error());
-  }
-
-}
-
+    static code() {
+        return 12;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+    static error() {
+        return 'invalid element state';
+    }
+    /**
+     *
+     * @param {string} [message]
+     */
+    constructor(message) {
+        super(message ||
+            'An element command could not be completed because the element is ' +
+                'in an invalid state (e.g. attempting to click a disabled element).', InvalidElementStateError.code(), InvalidElementStateError.w3cStatus(), InvalidElementStateError.error());
+    }
+}
 exports.InvalidElementStateError = InvalidElementStateError;
-
 class UnknownError extends ProtocolError {
-  static code() {
-    return 13;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  }
-
-  static error() {
-    return W3C_UNKNOWN_ERROR;
-  }
-
-  constructor(errorOrMessage) {
-    const origMessage = _lodash.default.isString((errorOrMessage || {}).message) ? errorOrMessage.message : errorOrMessage;
-    const message = 'An unknown server-side error occurred while processing the command.' + (origMessage ? ` Original error: ${origMessage}` : '');
-    super(message, UnknownError.code(), UnknownError.w3cStatus(), UnknownError.error());
-  }
-
-}
-
+    static code() {
+        return 13;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    }
+    static error() {
+        return W3C_UNKNOWN_ERROR;
+    }
+    constructor(errorOrMessage) {
+        const origMessage = lodash_1.default.isString((errorOrMessage || {}).message)
+            ? errorOrMessage.message
+            : errorOrMessage;
+        const message = 'An unknown server-side error occurred while processing the command.' +
+            (origMessage ? ` Original error: ${origMessage}` : '');
+        super(message, UnknownError.code(), UnknownError.w3cStatus(), UnknownError.error());
+    }
+}
 exports.UnknownError = UnknownError;
-
 class UnknownMethodError extends ProtocolError {
-  static code() {
-    return 405;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.METHOD_NOT_ALLOWED;
-  }
-
-  static error() {
-    return 'unknown method';
-  }
-
-  constructor(err) {
-    super(err || 'The requested command matched a known URL but did not match an method for that URL', UnknownMethodError.code(), UnknownMethodError.w3cStatus(), UnknownMethodError.error());
-  }
-
-}
-
+    static code() {
+        return 405;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.METHOD_NOT_ALLOWED;
+    }
+    static error() {
+        return 'unknown method';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message ||
+            'The requested command matched a known URL but did not match an method for that URL', UnknownMethodError.code(), UnknownMethodError.w3cStatus(), UnknownMethodError.error());
+    }
+}
 exports.UnknownMethodError = UnknownMethodError;
-
 class UnsupportedOperationError extends ProtocolError {
-  static code() {
-    return 405;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  }
-
-  static error() {
-    return 'unsupported operation';
-  }
-
-  constructor(err) {
-    super(err || 'A server-side error occurred. Command cannot be supported.', UnsupportedOperationError.code(), UnsupportedOperationError.w3cStatus(), UnsupportedOperationError.error());
-  }
-
-}
-
+    static code() {
+        return 405;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    }
+    static error() {
+        return 'unsupported operation';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message || 'A server-side error occurred. Command cannot be supported.', UnsupportedOperationError.code(), UnsupportedOperationError.w3cStatus(), UnsupportedOperationError.error());
+    }
+}
 exports.UnsupportedOperationError = UnsupportedOperationError;
-
 class ElementIsNotSelectableError extends ProtocolError {
-  static code() {
-    return 15;
-  }
-
-  static error() {
-    return 'element not selectable';
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-  constructor(err) {
-    super(err || 'An attempt was made to select an element that cannot be selected.', ElementIsNotSelectableError.code(), ElementIsNotSelectableError.w3cStatus(), ElementIsNotSelectableError.error());
-  }
-
-}
-
+    static code() {
+        return 15;
+    }
+    static error() {
+        return 'element not selectable';
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message || 'An attempt was made to select an element that cannot be selected.', ElementIsNotSelectableError.code(), ElementIsNotSelectableError.w3cStatus(), ElementIsNotSelectableError.error());
+    }
+}
 exports.ElementIsNotSelectableError = ElementIsNotSelectableError;
-
 class ElementClickInterceptedError extends ProtocolError {
-  static code() {
-    return 64;
-  }
-
-  static error() {
-    return 'element click intercepted';
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-  constructor(err) {
-    super(err || 'The Element Click command could not be completed because the element receiving ' + 'the events is obscuring the element that was requested clicked', ElementClickInterceptedError.code(), ElementClickInterceptedError.w3cStatus(), ElementClickInterceptedError.error());
-  }
-
-}
-
+    static code() {
+        return 64;
+    }
+    static error() {
+        return 'element click intercepted';
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message ||
+            'The Element Click command could not be completed because the element receiving ' +
+                'the events is obscuring the element that was requested clicked', ElementClickInterceptedError.code(), ElementClickInterceptedError.w3cStatus(), ElementClickInterceptedError.error());
+    }
+}
 exports.ElementClickInterceptedError = ElementClickInterceptedError;
-
 class ElementNotInteractableError extends ProtocolError {
-  static code() {
-    return 60;
-  }
-
-  static error() {
-    return 'element not interactable';
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-  constructor(err) {
-    super(err || 'A command could not be completed because the element is not pointer- or keyboard interactable', ElementNotInteractableError.code(), ElementNotInteractableError.w3cStatus(), ElementNotInteractableError.error());
-  }
-
-}
-
+    static code() {
+        return 60;
+    }
+    static error() {
+        return 'element not interactable';
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message ||
+            'A command could not be completed because the element is not pointer- or keyboard interactable', ElementNotInteractableError.code(), ElementNotInteractableError.w3cStatus(), ElementNotInteractableError.error());
+    }
+}
 exports.ElementNotInteractableError = ElementNotInteractableError;
-
 class InsecureCertificateError extends ProtocolError {
-  static error() {
-    return 'insecure certificate';
-  }
-
-  constructor(err) {
-    super(err || 'Navigation caused the user agent to hit a certificate warning, which is usually the result of an expired or invalid TLS certificate', ElementIsNotSelectableError.code(), null, InsecureCertificateError.error());
-  }
-
-}
-
+    static error() {
+        return 'insecure certificate';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message ||
+            'Navigation caused the user agent to hit a certificate warning, which is usually the result of an expired or invalid TLS certificate', ElementIsNotSelectableError.code(), null, InsecureCertificateError.error());
+    }
+}
 exports.InsecureCertificateError = InsecureCertificateError;
-
 class JavaScriptError extends ProtocolError {
-  static code() {
-    return 17;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  }
-
-  static error() {
-    return 'javascript error';
-  }
-
-  constructor(err) {
-    super(err || 'An error occurred while executing user supplied JavaScript.', JavaScriptError.code(), JavaScriptError.w3cStatus(), JavaScriptError.error());
-  }
-
-}
-
+    static code() {
+        return 17;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    }
+    static error() {
+        return 'javascript error';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message || 'An error occurred while executing user supplied JavaScript.', JavaScriptError.code(), JavaScriptError.w3cStatus(), JavaScriptError.error());
+    }
+}
 exports.JavaScriptError = JavaScriptError;
-
 class XPathLookupError extends ProtocolError {
-  static code() {
-    return 19;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-  static error() {
-    return 'invalid selector';
-  }
-
-  constructor(err) {
-    super(err || 'An error occurred while searching for an element by XPath.', XPathLookupError.code(), XPathLookupError.w3cStatus(), XPathLookupError.error());
-  }
-
-}
-
+    static code() {
+        return 19;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+    static error() {
+        return 'invalid selector';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message || 'An error occurred while searching for an element by XPath.', XPathLookupError.code(), XPathLookupError.w3cStatus(), XPathLookupError.error());
+    }
+}
 exports.XPathLookupError = XPathLookupError;
-
 class TimeoutError extends ProtocolError {
-  static code() {
-    return 21;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.REQUEST_TIMEOUT;
-  }
-
-  static error() {
-    return 'timeout';
-  }
-
-  constructor(err) {
-    super(err || 'An operation did not complete before its timeout expired.', TimeoutError.code(), TimeoutError.w3cStatus(), TimeoutError.error());
-  }
-
-}
-
+    static code() {
+        return 21;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.REQUEST_TIMEOUT;
+    }
+    static error() {
+        return 'timeout';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message || 'An operation did not complete before its timeout expired.', TimeoutError.code(), TimeoutError.w3cStatus(), TimeoutError.error());
+    }
+}
 exports.TimeoutError = TimeoutError;
-
 class NoSuchWindowError extends ProtocolError {
-  static code() {
-    return 23;
-  }
-
-  static error() {
-    return 'no such window';
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.NOT_FOUND;
-  }
-
-  constructor(err) {
-    super(err || 'A request to switch to a different window could not be satisfied ' + 'because the window could not be found.', NoSuchWindowError.code(), NoSuchWindowError.w3cStatus(), NoSuchWindowError.error());
-  }
-
-}
-
+    static code() {
+        return 23;
+    }
+    static error() {
+        return 'no such window';
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.NOT_FOUND;
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message ||
+            'A request to switch to a different window could not be satisfied ' +
+                'because the window could not be found.', NoSuchWindowError.code(), NoSuchWindowError.w3cStatus(), NoSuchWindowError.error());
+    }
+}
 exports.NoSuchWindowError = NoSuchWindowError;
-
 class InvalidArgumentError extends ProtocolError {
-  static code() {
-    return 61;
-  }
-
-  static error() {
-    return 'invalid argument';
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-  constructor(err) {
-    super(err || 'The arguments passed to the command are either invalid or malformed', InvalidArgumentError.code(), InvalidArgumentError.w3cStatus(), InvalidArgumentError.error());
-  }
-
-}
-
+    static code() {
+        return 61;
+    }
+    static error() {
+        return 'invalid argument';
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err || 'The arguments passed to the command are either invalid or malformed', InvalidArgumentError.code(), InvalidArgumentError.w3cStatus(), InvalidArgumentError.error());
+    }
+}
 exports.InvalidArgumentError = InvalidArgumentError;
-
 class InvalidCookieDomainError extends ProtocolError {
-  static code() {
-    return 24;
-  }
-
-  static error() {
-    return 'invalid cookie domain';
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-  constructor(err) {
-    super(err || 'An illegal attempt was made to set a cookie under a different ' + 'domain than the current page.', InvalidCookieDomainError.code(), InvalidCookieDomainError.w3cStatus(), InvalidCookieDomainError.error());
-  }
-
-}
-
+    static code() {
+        return 24;
+    }
+    static error() {
+        return 'invalid cookie domain';
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err ||
+            'An illegal attempt was made to set a cookie under a different ' +
+                'domain than the current page.', InvalidCookieDomainError.code(), InvalidCookieDomainError.w3cStatus(), InvalidCookieDomainError.error());
+    }
+}
 exports.InvalidCookieDomainError = InvalidCookieDomainError;
-
 class NoSuchCookieError extends ProtocolError {
-  static code() {
-    return 62;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.NOT_FOUND;
-  }
-
-  static error() {
-    return 'no such cookie';
-  }
-
-  constructor(err) {
-    super(err || 'No cookie matching the given path name was found amongst the associated cookies of the current browsing context’s active document', NoSuchCookieError.code(), NoSuchCookieError.w3cStatus(), NoSuchCookieError.error());
-  }
-
-}
-
+    static code() {
+        return 62;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.NOT_FOUND;
+    }
+    static error() {
+        return 'no such cookie';
+    }
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err ||
+            'No cookie matching the given path name was found amongst the associated cookies of the current browsing context’s active document', NoSuchCookieError.code(), NoSuchCookieError.w3cStatus(), NoSuchCookieError.error());
+    }
+}
 exports.NoSuchCookieError = NoSuchCookieError;
-
 class UnableToSetCookieError extends ProtocolError {
-  static code() {
-    return 25;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  }
-
-  static error() {
-    return 'unable to set cookie';
-  }
-
-  constructor(err) {
-    super(err || "A request to set a cookie's value could not be satisfied.", UnableToSetCookieError.code(), UnableToSetCookieError.w3cStatus(), UnableToSetCookieError.error());
-  }
-
-}
-
+    static code() {
+        return 25;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    }
+    static error() {
+        return 'unable to set cookie';
+    }
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err || "A request to set a cookie's value could not be satisfied.", UnableToSetCookieError.code(), UnableToSetCookieError.w3cStatus(), UnableToSetCookieError.error());
+    }
+}
 exports.UnableToSetCookieError = UnableToSetCookieError;
-
 class UnexpectedAlertOpenError extends ProtocolError {
-  static code() {
-    return 26;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  }
-
-  static error() {
-    return 'unexpected alert open';
-  }
-
-  constructor(err) {
-    super(err || 'A modal dialog was open, blocking this operation', UnexpectedAlertOpenError.code(), UnexpectedAlertOpenError.w3cStatus(), UnexpectedAlertOpenError.error());
-  }
-
-}
-
+    static code() {
+        return 26;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    }
+    static error() {
+        return 'unexpected alert open';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message || 'A modal dialog was open, blocking this operation', UnexpectedAlertOpenError.code(), UnexpectedAlertOpenError.w3cStatus(), UnexpectedAlertOpenError.error());
+    }
+}
 exports.UnexpectedAlertOpenError = UnexpectedAlertOpenError;
-
 class NoAlertOpenError extends ProtocolError {
-  static code() {
-    return 27;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.NOT_FOUND;
-  }
-
-  static error() {
-    return 'no such alert';
-  }
-
-  constructor(err) {
-    super(err || 'An attempt was made to operate on a modal dialog when one ' + 'was not open.', NoAlertOpenError.code(), NoAlertOpenError.w3cStatus(), NoAlertOpenError.error());
-  }
-
-}
-
+    static code() {
+        return 27;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.NOT_FOUND;
+    }
+    static error() {
+        return 'no such alert';
+    }
+    /**
+     *
+     * @param {string} [message]
+     */
+    constructor(message) {
+        super(message || 'An attempt was made to operate on a modal dialog when one ' + 'was not open.', NoAlertOpenError.code(), NoAlertOpenError.w3cStatus(), NoAlertOpenError.error());
+    }
+}
 exports.NoAlertOpenError = NoAlertOpenError;
-
-class NoSuchAlertError extends NoAlertOpenError {}
-
+class NoSuchAlertError extends NoAlertOpenError {
+}
 exports.NoSuchAlertError = NoSuchAlertError;
-
 class ScriptTimeoutError extends ProtocolError {
-  static code() {
-    return 28;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.REQUEST_TIMEOUT;
-  }
-
-  static error() {
-    return 'script timeout';
-  }
-
-  constructor(err) {
-    super(err || 'A script did not complete before its timeout expired.', ScriptTimeoutError.code(), ScriptTimeoutError.w3cStatus(), ScriptTimeoutError.error());
-  }
-
-}
-
+    static code() {
+        return 28;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.REQUEST_TIMEOUT;
+    }
+    static error() {
+        return 'script timeout';
+    }
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err || 'A script did not complete before its timeout expired.', ScriptTimeoutError.code(), ScriptTimeoutError.w3cStatus(), ScriptTimeoutError.error());
+    }
+}
 exports.ScriptTimeoutError = ScriptTimeoutError;
-
 class InvalidElementCoordinatesError extends ProtocolError {
-  static code() {
-    return 29;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-  static error() {
-    return 'invalid coordinates';
-  }
-
-  constructor(err) {
-    super(err || 'The coordinates provided to an interactions operation are invalid.', InvalidElementCoordinatesError.code(), InvalidElementCoordinatesError.w3cStatus(), InvalidElementCoordinatesError.error());
-  }
-
-}
-
+    static code() {
+        return 29;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+    static error() {
+        return 'invalid coordinates';
+    }
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err || 'The coordinates provided to an interactions operation are invalid.', InvalidElementCoordinatesError.code(), InvalidElementCoordinatesError.w3cStatus(), InvalidElementCoordinatesError.error());
+    }
+}
 exports.InvalidElementCoordinatesError = InvalidElementCoordinatesError;
-
-class InvalidCoordinatesError extends InvalidElementCoordinatesError {}
-
+class InvalidCoordinatesError extends InvalidElementCoordinatesError {
+}
 exports.InvalidCoordinatesError = InvalidCoordinatesError;
-
 class IMENotAvailableError extends ProtocolError {
-  static code() {
-    return 30;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  }
-
-  static error() {
-    return 'unsupported operation';
-  }
-
-  constructor(err) {
-    super(err || 'IME was not available.', IMENotAvailableError.code(), IMENotAvailableError.w3cStatus(), IMENotAvailableError.error());
-  }
-
-}
-
+    static code() {
+        return 30;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    }
+    static error() {
+        return 'unsupported operation';
+    }
+    /**
+     * @param {string} [message] error message
+     */
+    constructor(message) {
+        super(message || 'IME was not available.', IMENotAvailableError.code(), IMENotAvailableError.w3cStatus(), IMENotAvailableError.error());
+    }
+}
 exports.IMENotAvailableError = IMENotAvailableError;
-
 class IMEEngineActivationFailedError extends ProtocolError {
-  static code() {
-    return 31;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  }
-
-  static error() {
-    return 'unsupported operation';
-  }
-
-  constructor(err) {
-    super(err || 'An IME engine could not be started.', IMEEngineActivationFailedError.code(), IMEEngineActivationFailedError.w3cStatus(), IMEEngineActivationFailedError.error());
-  }
-
-}
-
+    static code() {
+        return 31;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    }
+    static error() {
+        return 'unsupported operation';
+    }
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err || 'An IME engine could not be started.', IMEEngineActivationFailedError.code(), IMEEngineActivationFailedError.w3cStatus(), IMEEngineActivationFailedError.error());
+    }
+}
 exports.IMEEngineActivationFailedError = IMEEngineActivationFailedError;
-
 class InvalidSelectorError extends ProtocolError {
-  static code() {
-    return 32;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-  static error() {
-    return 'invalid selector';
-  }
-
-  constructor(err) {
-    super(err || 'Argument was an invalid selector (e.g. XPath/CSS).', InvalidSelectorError.code(), InvalidSelectorError.w3cStatus(), InvalidSelectorError.error());
-  }
-
-}
-
+    static code() {
+        return 32;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+    static error() {
+        return 'invalid selector';
+    }
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err || 'Argument was an invalid selector (e.g. XPath/CSS).', InvalidSelectorError.code(), InvalidSelectorError.w3cStatus(), InvalidSelectorError.error());
+    }
+}
 exports.InvalidSelectorError = InvalidSelectorError;
-
 class SessionNotCreatedError extends ProtocolError {
-  static code() {
-    return 33;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  }
-
-  static error() {
-    return 'session not created';
-  }
-
-  constructor(details) {
-    let message = 'A new session could not be created.';
-
-    if (details) {
-      message += ` Details: ${details}`;
-    }
-
-    super(message, SessionNotCreatedError.code(), SessionNotCreatedError.w3cStatus(), SessionNotCreatedError.error());
-  }
-
-}
-
+    static code() {
+        return 33;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    }
+    static error() {
+        return 'session not created';
+    }
+    constructor(details) {
+        let message = 'A new session could not be created.';
+        if (details) {
+            message += ` Details: ${details}`;
+        }
+        super(message, SessionNotCreatedError.code(), SessionNotCreatedError.w3cStatus(), SessionNotCreatedError.error());
+    }
+}
 exports.SessionNotCreatedError = SessionNotCreatedError;
-
 class MoveTargetOutOfBoundsError extends ProtocolError {
-  static code() {
-    return 34;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  }
-
-  static error() {
-    return 'move target out of bounds';
-  }
-
-  constructor(err) {
-    super(err || 'Target provided for a move action is out of bounds.', MoveTargetOutOfBoundsError.code(), MoveTargetOutOfBoundsError.w3cStatus(), MoveTargetOutOfBoundsError.error());
-  }
-
-}
-
+    static code() {
+        return 34;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    }
+    static error() {
+        return 'move target out of bounds';
+    }
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err || 'Target provided for a move action is out of bounds.', MoveTargetOutOfBoundsError.code(), MoveTargetOutOfBoundsError.w3cStatus(), MoveTargetOutOfBoundsError.error());
+    }
+}
 exports.MoveTargetOutOfBoundsError = MoveTargetOutOfBoundsError;
-
 class NoSuchContextError extends ProtocolError {
-  static code() {
-    return 35;
-  }
-
-  constructor(err) {
-    super(err || 'No such context found.', NoSuchContextError.code());
-  }
-
-}
-
+    static code() {
+        return 35;
+    }
+    /**
+     *
+     * @param {string} [message]
+     */
+    constructor(message) {
+        super(message || 'No such context found.', NoSuchContextError.code());
+    }
+}
 exports.NoSuchContextError = NoSuchContextError;
-
 class InvalidContextError extends ProtocolError {
-  static code() {
-    return 36;
-  }
-
-  constructor(err) {
-    super(err || 'That command could not be executed in the current context.', InvalidContextError.code());
-  }
-
-}
-
+    static code() {
+        return 36;
+    }
+    /**
+     *
+     * @param {string} [message]
+     */
+    constructor(message) {
+        super(message || 'That command could not be executed in the current context.', InvalidContextError.code());
+    }
+}
 exports.InvalidContextError = InvalidContextError;
-
+// These are aliases for UnknownMethodError
 class NotYetImplementedError extends UnknownMethodError {
-  constructor(err) {
-    super(err || 'Method has not yet been implemented');
-  }
-
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err || 'Method has not yet been implemented');
+    }
 }
-
 exports.NotYetImplementedError = NotYetImplementedError;
-
 class NotImplementedError extends UnknownMethodError {
-  constructor(err) {
-    super(err || 'Method is not implemented');
-  }
-
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err || 'Method is not implemented');
+    }
 }
-
 exports.NotImplementedError = NotImplementedError;
-
 class UnableToCaptureScreen extends ProtocolError {
-  static code() {
-    return 63;
-  }
-
-  static w3cStatus() {
-    return _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  }
-
-  static error() {
-    return 'unable to capture screen';
-  }
-
-  constructor(err) {
-    super(err || 'A screen capture was made impossible', UnableToCaptureScreen.code(), UnableToCaptureScreen.w3cStatus(), UnableToCaptureScreen.error());
-  }
-
-}
-
+    static code() {
+        return 63;
+    }
+    static w3cStatus() {
+        return http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    }
+    static error() {
+        return 'unable to capture screen';
+    }
+    /**
+     * @param {string} [err] error message
+     */
+    constructor(err) {
+        super(err || 'A screen capture was made impossible', UnableToCaptureScreen.code(), UnableToCaptureScreen.w3cStatus(), UnableToCaptureScreen.error());
+    }
+}
 exports.UnableToCaptureScreen = UnableToCaptureScreen;
-
-class BadParametersError extends _es6Error.default {
-  static error() {
-    return 'invalid argument';
-  }
-
-  constructor(requiredParams, actualParams, errMessage) {
-    let message;
-
-    if (!errMessage) {
-      message = `Parameters were incorrect. We wanted ` + `${JSON.stringify(requiredParams)} and you ` + `sent ${JSON.stringify(actualParams)}`;
-    } else {
-      message = `Parameters were incorrect. You sent ${JSON.stringify(actualParams)}, ${errMessage}`;
-    }
-
-    super(message);
-    this.w3cStatus = _httpStatusCodes.StatusCodes.BAD_REQUEST;
-  }
-
-}
-
+// Equivalent to W3C InvalidArgumentError
+class BadParametersError extends es6_error_1.default {
+    static error() {
+        return 'invalid argument';
+    }
+    constructor(requiredParams, actualParams, errMessage) {
+        let message;
+        if (!errMessage) {
+            message =
+                `Parameters were incorrect. We wanted ` +
+                    `${JSON.stringify(requiredParams)} and you ` +
+                    `sent ${JSON.stringify(actualParams)}`;
+        }
+        else {
+            message = `Parameters were incorrect. You sent ${JSON.stringify(actualParams)}, ${errMessage}`;
+        }
+        super(message);
+        this.w3cStatus = http_status_codes_1.StatusCodes.BAD_REQUEST;
+    }
+}
 exports.BadParametersError = BadParametersError;
-
-class ProxyRequestError extends _es6Error.default {
-  constructor(err, responseError, httpStatus) {
-    let responseErrorObj = _support.util.safeJsonParse(responseError);
-
-    if (!_lodash.default.isPlainObject(responseErrorObj)) {
-      responseErrorObj = {};
-    }
-
-    let origMessage = _lodash.default.isString(responseError) ? responseError : '';
-
-    if (!_lodash.default.isEmpty(responseErrorObj)) {
-      if (_lodash.default.isString(responseErrorObj.value)) {
-        origMessage = responseErrorObj.value;
-      } else if (_lodash.default.isPlainObject(responseErrorObj.value) && _lodash.default.isString(responseErrorObj.value.message)) {
-        origMessage = responseErrorObj.value.message;
-      }
-    }
-
-    super(_lodash.default.isEmpty(err) ? `Proxy request unsuccessful. ${origMessage}` : err);
-    this.w3cStatus = _httpStatusCodes.StatusCodes.BAD_REQUEST;
-
-    if (_lodash.default.isPlainObject(responseErrorObj.value) && _lodash.default.has(responseErrorObj.value, 'error')) {
-      this.w3c = responseErrorObj.value;
-      this.w3cStatus = httpStatus || _httpStatusCodes.StatusCodes.BAD_REQUEST;
-    } else {
-      this.jsonwp = responseErrorObj;
-    }
-  }
-
-  getActualError() {
-    var _this$jsonwp, _this$jsonwp2;
-
-    if (_support.util.hasValue((_this$jsonwp = this.jsonwp) === null || _this$jsonwp === void 0 ? void 0 : _this$jsonwp.status) && _support.util.hasValue((_this$jsonwp2 = this.jsonwp) === null || _this$jsonwp2 === void 0 ? void 0 : _this$jsonwp2.value)) {
-      return errorFromMJSONWPStatusCode(this.jsonwp.status, this.jsonwp.value);
-    } else if (_support.util.hasValue(this.w3c) && _lodash.default.isNumber(this.w3cStatus) && this.w3cStatus >= 300) {
-      return errorFromW3CJsonCode(this.w3c.error, this.w3c.message || this.message, this.w3c.stacktrace);
-    }
-
-    return new UnknownError(this.message);
-  }
-
-}
-
+/**
+ * ProxyRequestError is a custom error and will be thrown up on unsuccessful proxy request and
+ * will contain information about the proxy failure.
+ * In case of ProxyRequestError should fetch the actual error by calling `getActualError()`
+ * for proxy failure to generate the client response.
+ */
+class ProxyRequestError extends es6_error_1.default {
+    constructor(err, responseError, httpStatus) {
+        let responseErrorObj = support_1.util.safeJsonParse(responseError);
+        if (!lodash_1.default.isPlainObject(responseErrorObj)) {
+            responseErrorObj = {};
+        }
+        let origMessage = lodash_1.default.isString(responseError) ? responseError : '';
+        if (!lodash_1.default.isEmpty(responseErrorObj)) {
+            if (lodash_1.default.isString(responseErrorObj.value)) {
+                origMessage = responseErrorObj.value;
+            }
+            else if (lodash_1.default.isPlainObject(responseErrorObj.value) &&
+                lodash_1.default.isString(responseErrorObj.value.message)) {
+                origMessage = responseErrorObj.value.message;
+            }
+        }
+        super(lodash_1.default.isEmpty(err) ? `Proxy request unsuccessful. ${origMessage}` : err);
+        this.w3cStatus = http_status_codes_1.StatusCodes.BAD_REQUEST;
+        // If the response error is an object and value is an object, it's a W3C error (for JSONWP value is a string)
+        if (lodash_1.default.isPlainObject(responseErrorObj.value) && lodash_1.default.has(responseErrorObj.value, 'error')) {
+            this.w3c = responseErrorObj.value;
+            this.w3cStatus = httpStatus || http_status_codes_1.StatusCodes.BAD_REQUEST;
+        }
+        else {
+            this.jsonwp = responseErrorObj;
+        }
+    }
+    getActualError() {
+        // If it's MJSONWP error, returns actual error cause for request failure based on `jsonwp.status`
+        if (support_1.util.hasValue(this.jsonwp?.status) && support_1.util.hasValue(this.jsonwp?.value)) {
+            return errorFromMJSONWPStatusCode(this.jsonwp.status, this.jsonwp.value);
+        }
+        else if (support_1.util.hasValue(this.w3c) && lodash_1.default.isNumber(this.w3cStatus) && this.w3cStatus >= 300) {
+            return errorFromW3CJsonCode(this.w3c.error, this.w3c.message || this.message, this.w3c.stacktrace);
+        }
+        return new UnknownError(this.message);
+    }
+}
 exports.ProxyRequestError = ProxyRequestError;
+// map of error class name to error class
 const errors = {
-  NotYetImplementedError,
-  NotImplementedError,
-  BadParametersError,
-  InvalidArgumentError,
-  NoSuchDriverError,
-  NoSuchElementError,
-  UnknownCommandError,
-  StaleElementReferenceError,
-  ElementNotVisibleError,
-  InvalidElementStateError,
-  UnknownError,
-  ElementIsNotSelectableError,
-  ElementClickInterceptedError,
-  ElementNotInteractableError,
-  InsecureCertificateError,
-  JavaScriptError,
-  XPathLookupError,
-  TimeoutError,
-  NoSuchWindowError,
-  NoSuchCookieError,
-  InvalidCookieDomainError,
-  InvalidCoordinatesError,
-  UnableToSetCookieError,
-  UnexpectedAlertOpenError,
-  NoAlertOpenError,
-  ScriptTimeoutError,
-  InvalidElementCoordinatesError,
-  IMENotAvailableError,
-  IMEEngineActivationFailedError,
-  InvalidSelectorError,
-  SessionNotCreatedError,
-  MoveTargetOutOfBoundsError,
-  NoSuchAlertError,
-  NoSuchContextError,
-  InvalidContextError,
-  NoSuchFrameError,
-  UnableToCaptureScreen,
-  UnknownMethodError,
-  UnsupportedOperationError,
-  ProxyRequestError
+    NotYetImplementedError,
+    NotImplementedError,
+    BadParametersError,
+    InvalidArgumentError,
+    NoSuchDriverError,
+    NoSuchElementError,
+    UnknownCommandError,
+    StaleElementReferenceError,
+    ElementNotVisibleError,
+    InvalidElementStateError,
+    UnknownError,
+    ElementIsNotSelectableError,
+    ElementClickInterceptedError,
+    ElementNotInteractableError,
+    InsecureCertificateError,
+    JavaScriptError,
+    XPathLookupError,
+    TimeoutError,
+    NoSuchWindowError,
+    NoSuchCookieError,
+    InvalidCookieDomainError,
+    InvalidCoordinatesError,
+    UnableToSetCookieError,
+    UnexpectedAlertOpenError,
+    NoAlertOpenError,
+    ScriptTimeoutError,
+    InvalidElementCoordinatesError,
+    IMENotAvailableError,
+    IMEEngineActivationFailedError,
+    InvalidSelectorError,
+    SessionNotCreatedError,
+    MoveTargetOutOfBoundsError,
+    NoSuchAlertError,
+    NoSuchContextError,
+    InvalidContextError,
+    NoSuchFrameError,
+    UnableToCaptureScreen,
+    UnknownMethodError,
+    UnsupportedOperationError,
+    ProxyRequestError,
 };
 exports.errors = errors;
+// map of error code to error class
 const jsonwpErrorCodeMap = {};
-
-for (let ErrorClass of _lodash.default.values(errors)) {
-  if ('code' in ErrorClass) {
-    jsonwpErrorCodeMap[ErrorClass.code()] = ErrorClass;
-  }
+for (let ErrorClass of lodash_1.default.values(errors)) {
+    if ('code' in ErrorClass) {
+        jsonwpErrorCodeMap[ErrorClass.code()] = ErrorClass;
+    }
 }
-
 const w3cErrorCodeMap = {};
-
-for (let ErrorClass of _lodash.default.values(errors)) {
-  if ('error' in ErrorClass) {
-    w3cErrorCodeMap[ErrorClass.error()] = ErrorClass;
-  }
+for (let ErrorClass of lodash_1.default.values(errors)) {
+    if ('error' in ErrorClass) {
+        w3cErrorCodeMap[ErrorClass.error()] = ErrorClass;
+    }
 }
-
 function isUnknownError(err) {
-  return !err.constructor.name || !_lodash.default.values(errors).find(function equalNames(error) {
-    return error.name === err.constructor.name;
-  });
+    return (!err.constructor.name ||
+        !lodash_1.default.values(errors).find(function equalNames(error) {
+            return error.name === err.constructor.name;
+        }));
 }
-
+exports.isUnknownError = isUnknownError;
 function isErrorType(err, type) {
-  if (type.name === ProtocolError.name) {
-    return !!err.jsonwpCode;
-  } else if (type.name === ProxyRequestError.name) {
-    if (err.jsonwp) {
-      return !!err.jsonwp.status;
-    }
-
-    if (_lodash.default.isPlainObject(err.w3c)) {
-      return _lodash.default.isNumber(err.w3cStatus) && err.w3cStatus >= 300;
-    }
-
-    return false;
-  }
-
-  return err.constructor.name === type.name;
-}
-
+    // `name` property is the constructor name
+    if (type.name === ProtocolError.name) {
+        // `jsonwpCode` is `0` on success
+        return !!err.jsonwpCode;
+    }
+    else if (type.name === ProxyRequestError.name) {
+        // `status` is `0` on success
+        if (err.jsonwp) {
+            return !!err.jsonwp.status;
+        }
+        if (lodash_1.default.isPlainObject(err.w3c)) {
+            return lodash_1.default.isNumber(err.w3cStatus) && err.w3cStatus >= 300;
+        }
+        return false;
+    }
+    return err.constructor.name === type.name;
+}
+exports.isErrorType = isErrorType;
+/**
+ * Retrieve an error derived from MJSONWP status
+ * @param {number} code JSONWP status code
+ * @param {string|Object} value The error message, or an object with a `message` property
+ * @return {ProtocolError} The error that is associated with provided JSONWP status code
+ */
 function errorFromMJSONWPStatusCode(code, value = '') {
-  const message = (value || {}).message || value || '';
-
-  if (code !== UnknownError.code() && jsonwpErrorCodeMap[code]) {
-    mjsonwpLog.debug(`Matched JSONWP error code ${code} to ${jsonwpErrorCodeMap[code].name}`);
-    return new jsonwpErrorCodeMap[code](message);
-  }
-
-  mjsonwpLog.debug(`Matched JSONWP error code ${code} to UnknownError`);
-  return new UnknownError(message);
-}
-
+    // if `value` is an object, pull message from it, otherwise use the plain
+    // value, or default to an empty string, if null
+    const message = (value || {}).message || value || '';
+    if (code !== UnknownError.code() && jsonwpErrorCodeMap[code]) {
+        mjsonwpLog.debug(`Matched JSONWP error code ${code} to ${jsonwpErrorCodeMap[code].name}`);
+        return new jsonwpErrorCodeMap[code](message);
+    }
+    mjsonwpLog.debug(`Matched JSONWP error code ${code} to UnknownError`);
+    return new UnknownError(message);
+}
+exports.errorFromMJSONWPStatusCode = errorFromMJSONWPStatusCode;
+/**
+ * Retrieve an error derived from W3C JSON Code
+ * @param {string} code W3C error string (see https://www.w3.org/TR/webdriver/#handling-errors `JSON Error Code` column)
+ * @param {string} message the error message
+ * @param {?string} stacktrace an optional error stacktrace
+ * @return {ProtocolError}  The error that is associated with the W3C error string
+ */
 function errorFromW3CJsonCode(code, message, stacktrace = null) {
-  if (code && w3cErrorCodeMap[code.toLowerCase()]) {
-    w3cLog.debug(`Matched W3C error code '${code}' to ${w3cErrorCodeMap[code.toLowerCase()].name}`);
-    const resultError = new w3cErrorCodeMap[code.toLowerCase()](message);
+    if (code && w3cErrorCodeMap[code.toLowerCase()]) {
+        w3cLog.debug(`Matched W3C error code '${code}' to ${w3cErrorCodeMap[code.toLowerCase()].name}`);
+        const resultError = new w3cErrorCodeMap[code.toLowerCase()](message);
+        resultError.stacktrace = stacktrace;
+        return resultError;
+    }
+    w3cLog.debug(`Matched W3C error code '${code}' to UnknownError`);
+    const resultError = new UnknownError(message);
     resultError.stacktrace = stacktrace;
     return resultError;
-  }
-
-  w3cLog.debug(`Matched W3C error code '${code}' to UnknownError`);
-  const resultError = new UnknownError(message);
-  resultError.stacktrace = stacktrace;
-  return resultError;
-}
-
+}
+exports.errorFromW3CJsonCode = errorFromW3CJsonCode;
+/**
+ *
+ * @param {any} err
+ * @returns {err is ProtocolError}
+ */
 function isProtocolError(err) {
-  return 'w3cStatus' in err;
+    return 'w3cStatus' in err;
 }
-
+/**
+ * Convert an Appium error to proper W3C HTTP response
+ * @param {ProtocolError|MJSONWPError} err The error that needs to be translated
+ */
 function getResponseForW3CError(err) {
-  let httpStatus;
-  let w3cErrorString;
-
-  if (!isProtocolError(err)) {
-    err = _support.util.hasValue(err.status) ? errorFromMJSONWPStatusCode(err.status, err.value) : new errors.UnknownError(err.message);
-  }
-
-  if (isErrorType(err, errors.BadParametersError)) {
-    w3cLog.debug(`Bad parameters: ${err}`);
-    w3cErrorString = BadParametersError.error();
-  } else {
-    w3cErrorString = err.error;
-  }
-
-  httpStatus = err.w3cStatus;
-
-  if (!w3cErrorString) {
-    w3cErrorString = UnknownError.error();
-  }
-
-  let httpResBody = {
-    value: {
-      error: w3cErrorString,
-      message: err.message,
-      stacktrace: err.stacktrace || err.stack
-    }
-  };
-  return [httpStatus, httpResBody];
-}
-
+    let httpStatus;
+    // W3C defined error message (https://www.w3.org/TR/webdriver/#dfn-error-code)
+    let w3cErrorString;
+    if (!isProtocolError(err)) {
+        err = support_1.util.hasValue(err.status)
+            ? // If it's a JSONWP error, find corresponding error
+                errorFromMJSONWPStatusCode(err.status, err.value)
+            : new errors.UnknownError(err.message);
+    }
+    if (isErrorType(err, errors.BadParametersError)) {
+        // respond with a 400 if we have bad parameters
+        w3cLog.debug(`Bad parameters: ${err}`);
+        w3cErrorString = BadParametersError.error();
+    }
+    else {
+        w3cErrorString = err.error;
+    }
+    httpStatus = err.w3cStatus;
+    if (!w3cErrorString) {
+        w3cErrorString = UnknownError.error();
+    }
+    let httpResBody = {
+        value: {
+            error: w3cErrorString,
+            message: err.message,
+            stacktrace: err.stacktrace || err.stack,
+        },
+    };
+    return [httpStatus, httpResBody];
+}
+exports.getResponseForW3CError = getResponseForW3CError;
+/**
+ * Convert an Appium error to a proper JSONWP response
+ * @param {ProtocolError} err The error to be converted
+ */
 function getResponseForJsonwpError(err) {
-  if (isUnknownError(err)) {
-    err = new errors.UnknownError(err);
-  }
-
-  let httpStatus = _httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR;
-  let httpResBody = {
-    status: err.jsonwpCode,
-    value: {
-      message: err.message
-    }
-  };
-
-  if (isErrorType(err, errors.BadParametersError)) {
-    mjsonwpLog.debug(`Bad parameters: ${err}`);
-    httpStatus = _httpStatusCodes.StatusCodes.BAD_REQUEST;
-    httpResBody = err.message;
-  } else if (isErrorType(err, errors.NotYetImplementedError) || isErrorType(err, errors.NotImplementedError)) {
-    httpStatus = _httpStatusCodes.StatusCodes.NOT_IMPLEMENTED;
-  } else if (isErrorType(err, errors.NoSuchDriverError)) {
-    httpStatus = _httpStatusCodes.StatusCodes.NOT_FOUND;
-  }
-
-  return [httpStatus, httpResBody];
-}
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["mjsonwpLog","logger","getLogger","w3cLog","W3C_UNKNOWN_ERROR","ProtocolError","ES6Error","constructor","msg","jsonwpCode","w3cStatus","error","HTTPStatusCodes","BAD_REQUEST","_stacktrace","stacktrace","stack","value","NoSuchDriverError","code","NOT_FOUND","err","NoSuchElementError","NoSuchFrameError","UnknownCommandError","StaleElementReferenceError","ElementNotVisibleError","InvalidElementStateError","UnknownError","INTERNAL_SERVER_ERROR","errorOrMessage","origMessage","_","isString","message","UnknownMethodError","METHOD_NOT_ALLOWED","UnsupportedOperationError","ElementIsNotSelectableError","ElementClickInterceptedError","ElementNotInteractableError","InsecureCertificateError","JavaScriptError","XPathLookupError","TimeoutError","REQUEST_TIMEOUT","NoSuchWindowError","InvalidArgumentError","InvalidCookieDomainError","NoSuchCookieError","UnableToSetCookieError","UnexpectedAlertOpenError","NoAlertOpenError","NoSuchAlertError","ScriptTimeoutError","InvalidElementCoordinatesError","InvalidCoordinatesError","IMENotAvailableError","IMEEngineActivationFailedError","InvalidSelectorError","SessionNotCreatedError","details","MoveTargetOutOfBoundsError","NoSuchContextError","InvalidContextError","NotYetImplementedError","NotImplementedError","UnableToCaptureScreen","BadParametersError","requiredParams","actualParams","errMessage","JSON","stringify","ProxyRequestError","responseError","httpStatus","responseErrorObj","util","safeJsonParse","isPlainObject","isEmpty","has","w3c","jsonwp","getActualError","hasValue","status","errorFromMJSONWPStatusCode","isNumber","errorFromW3CJsonCode","errors","jsonwpErrorCodeMap","ErrorClass","values","w3cErrorCodeMap","isUnknownError","name","find","equalNames","isErrorType","type","debug","toLowerCase","resultError","isProtocolError","getResponseForW3CError","w3cErrorString","httpResBody","getResponseForJsonwpError","NOT_IMPLEMENTED"],"sources":["../../../lib/protocol/errors.js"],"sourcesContent":["import ES6Error from 'es6-error';\nimport _ from 'lodash';\nimport {util, logger} from '@appium/support';\nimport {StatusCodes as HTTPStatusCodes} from 'http-status-codes';\n\nconst mjsonwpLog = logger.getLogger('MJSONWP');\nconst w3cLog = logger.getLogger('W3C');\n\nconst W3C_UNKNOWN_ERROR = 'unknown error';\n\n// base error class for all of our errors\nexport class ProtocolError extends ES6Error {\n  constructor(msg, jsonwpCode, w3cStatus, error) {\n    super(msg);\n    this.jsonwpCode = jsonwpCode;\n    this.error = error || W3C_UNKNOWN_ERROR;\n    if (this.jsonwpCode === null) {\n      this.jsonwpCode = 13;\n    }\n    this.w3cStatus = w3cStatus || HTTPStatusCodes.BAD_REQUEST;\n    this._stacktrace = null;\n  }\n\n  get stacktrace() {\n    return this._stacktrace || this.stack;\n  }\n\n  set stacktrace(value) {\n    this._stacktrace = value;\n  }\n}\n\n// https://github.com/SeleniumHQ/selenium/blob/176b4a9e3082ac1926f2a436eb346760c37a5998/java/client/src/org/openqa/selenium/remote/ErrorCodes.java#L215\n// https://github.com/SeleniumHQ/selenium/issues/5562#issuecomment-370379470\n// https://w3c.github.io/webdriver/webdriver-spec.html#dfn-error-code\n\nexport class NoSuchDriverError extends ProtocolError {\n  static code() {\n    return 6;\n  }\n  // W3C Error is called InvalidSessionID\n  static w3cStatus() {\n    return HTTPStatusCodes.NOT_FOUND;\n  }\n  static error() {\n    return 'invalid session id';\n  }\n  constructor(err) {\n    super(\n      err || 'A session is either terminated or not started',\n      NoSuchDriverError.code(),\n      NoSuchDriverError.w3cStatus(),\n      NoSuchDriverError.error()\n    );\n  }\n}\n\nexport class NoSuchElementError extends ProtocolError {\n  static code() {\n    return 7;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.NOT_FOUND;\n  }\n  static error() {\n    return 'no such element';\n  }\n  constructor(err) {\n    super(\n      err || 'An element could not be located on the page using the given ' + 'search parameters.',\n      NoSuchElementError.code(),\n      NoSuchElementError.w3cStatus(),\n      NoSuchElementError.error()\n    );\n  }\n}\n\nexport class NoSuchFrameError extends ProtocolError {\n  static code() {\n    return 8;\n  }\n  static error() {\n    return 'no such frame';\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.NOT_FOUND;\n  }\n  constructor(err) {\n    super(\n      err ||\n        'A request to switch to a frame could not be satisfied because ' +\n          'the frame could not be found.',\n      NoSuchFrameError.code(),\n      NoSuchFrameError.w3cStatus(),\n      NoSuchFrameError.error()\n    );\n  }\n}\n\nexport class UnknownCommandError extends ProtocolError {\n  static code() {\n    return 9;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.NOT_FOUND;\n  }\n  static error() {\n    return 'unknown command';\n  }\n  constructor(err) {\n    super(\n      err ||\n        'The requested resource could not be found, or a request was ' +\n          'received using an HTTP method that is not supported by the mapped ' +\n          'resource.',\n      UnknownCommandError.code(),\n      UnknownCommandError.w3cStatus(),\n      UnknownCommandError.error()\n    );\n  }\n}\n\nexport class StaleElementReferenceError extends ProtocolError {\n  static code() {\n    return 10;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.NOT_FOUND;\n  }\n  static error() {\n    return 'stale element reference';\n  }\n  constructor(err) {\n    super(\n      err ||\n        'An element command failed because the referenced element is no ' +\n          'longer attached to the DOM.',\n      StaleElementReferenceError.code(),\n      StaleElementReferenceError.w3cStatus(),\n      StaleElementReferenceError.error()\n    );\n  }\n}\n\nexport class ElementNotVisibleError extends ProtocolError {\n  static code() {\n    return 11;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.BAD_REQUEST;\n  }\n  static error() {\n    return 'element not visible';\n  }\n  constructor(err) {\n    super(\n      err ||\n        'An element command could not be completed because the element is ' +\n          'not visible on the page.',\n      ElementNotVisibleError.code(),\n      ElementNotVisibleError.w3cStatus(),\n      ElementNotVisibleError.error()\n    );\n  }\n}\n\nexport class InvalidElementStateError extends ProtocolError {\n  static code() {\n    return 12;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.BAD_REQUEST;\n  }\n  static error() {\n    return 'invalid element state';\n  }\n  constructor(err) {\n    super(\n      err ||\n        'An element command could not be completed because the element is ' +\n          'in an invalid state (e.g. attempting to click a disabled element).',\n      InvalidElementStateError.code(),\n      InvalidElementStateError.w3cStatus(),\n      InvalidElementStateError.error()\n    );\n  }\n}\n\nexport class UnknownError extends ProtocolError {\n  static code() {\n    return 13;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n  }\n  static error() {\n    return W3C_UNKNOWN_ERROR;\n  }\n  constructor(errorOrMessage) {\n    const origMessage = _.isString((errorOrMessage || {}).message)\n      ? errorOrMessage.message\n      : errorOrMessage;\n    const message =\n      'An unknown server-side error occurred while processing the command.' +\n      (origMessage ? ` Original error: ${origMessage}` : '');\n    super(message, UnknownError.code(), UnknownError.w3cStatus(), UnknownError.error());\n  }\n}\n\nexport class UnknownMethodError extends ProtocolError {\n  static code() {\n    return 405;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.METHOD_NOT_ALLOWED;\n  }\n  static error() {\n    return 'unknown method';\n  }\n  constructor(err) {\n    super(\n      err || 'The requested command matched a known URL but did not match an method for that URL',\n      UnknownMethodError.code(),\n      UnknownMethodError.w3cStatus(),\n      UnknownMethodError.error()\n    );\n  }\n}\n\nexport class UnsupportedOperationError extends ProtocolError {\n  static code() {\n    return 405;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n  }\n  static error() {\n    return 'unsupported operation';\n  }\n  constructor(err) {\n    super(\n      err || 'A server-side error occurred. Command cannot be supported.',\n      UnsupportedOperationError.code(),\n      UnsupportedOperationError.w3cStatus(),\n      UnsupportedOperationError.error()\n    );\n  }\n}\n\nexport class ElementIsNotSelectableError extends ProtocolError {\n  static code() {\n    return 15;\n  }\n  static error() {\n    return 'element not selectable';\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.BAD_REQUEST;\n  }\n  constructor(err) {\n    super(\n      err || 'An attempt was made to select an element that cannot be selected.',\n      ElementIsNotSelectableError.code(),\n      ElementIsNotSelectableError.w3cStatus(),\n      ElementIsNotSelectableError.error()\n    );\n  }\n}\n\nexport class ElementClickInterceptedError extends ProtocolError {\n  static code() {\n    return 64;\n  }\n  static error() {\n    return 'element click intercepted';\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.BAD_REQUEST;\n  }\n  constructor(err) {\n    super(\n      err ||\n        'The Element Click command could not be completed because the element receiving ' +\n          'the events is obscuring the element that was requested clicked',\n      ElementClickInterceptedError.code(),\n      ElementClickInterceptedError.w3cStatus(),\n      ElementClickInterceptedError.error()\n    );\n  }\n}\n\nexport class ElementNotInteractableError extends ProtocolError {\n  static code() {\n    return 60;\n  }\n  static error() {\n    return 'element not interactable';\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.BAD_REQUEST;\n  }\n  constructor(err) {\n    super(\n      err ||\n        'A command could not be completed because the element is not pointer- or keyboard interactable',\n      ElementNotInteractableError.code(),\n      ElementNotInteractableError.w3cStatus(),\n      ElementNotInteractableError.error()\n    );\n  }\n}\n\nexport class InsecureCertificateError extends ProtocolError {\n  static error() {\n    return 'insecure certificate';\n  }\n  constructor(err) {\n    super(\n      err ||\n        'Navigation caused the user agent to hit a certificate warning, which is usually the result of an expired or invalid TLS certificate',\n      ElementIsNotSelectableError.code(),\n      null,\n      InsecureCertificateError.error()\n    );\n  }\n}\n\nexport class JavaScriptError extends ProtocolError {\n  static code() {\n    return 17;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n  }\n  static error() {\n    return 'javascript error';\n  }\n  constructor(err) {\n    super(\n      err || 'An error occurred while executing user supplied JavaScript.',\n      JavaScriptError.code(),\n      JavaScriptError.w3cStatus(),\n      JavaScriptError.error()\n    );\n  }\n}\n\nexport class XPathLookupError extends ProtocolError {\n  static code() {\n    return 19;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.BAD_REQUEST;\n  }\n  static error() {\n    return 'invalid selector';\n  }\n  constructor(err) {\n    super(\n      err || 'An error occurred while searching for an element by XPath.',\n      XPathLookupError.code(),\n      XPathLookupError.w3cStatus(),\n      XPathLookupError.error()\n    );\n  }\n}\n\nexport class TimeoutError extends ProtocolError {\n  static code() {\n    return 21;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.REQUEST_TIMEOUT;\n  }\n  static error() {\n    return 'timeout';\n  }\n  constructor(err) {\n    super(\n      err || 'An operation did not complete before its timeout expired.',\n      TimeoutError.code(),\n      TimeoutError.w3cStatus(),\n      TimeoutError.error()\n    );\n  }\n}\n\nexport class NoSuchWindowError extends ProtocolError {\n  static code() {\n    return 23;\n  }\n  static error() {\n    return 'no such window';\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.NOT_FOUND;\n  }\n  constructor(err) {\n    super(\n      err ||\n        'A request to switch to a different window could not be satisfied ' +\n          'because the window could not be found.',\n      NoSuchWindowError.code(),\n      NoSuchWindowError.w3cStatus(),\n      NoSuchWindowError.error()\n    );\n  }\n}\n\nexport class InvalidArgumentError extends ProtocolError {\n  static code() {\n    return 61;\n  }\n  static error() {\n    return 'invalid argument';\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.BAD_REQUEST;\n  }\n  constructor(err) {\n    super(\n      err || 'The arguments passed to the command are either invalid or malformed',\n      InvalidArgumentError.code(),\n      InvalidArgumentError.w3cStatus(),\n      InvalidArgumentError.error()\n    );\n  }\n}\n\nexport class InvalidCookieDomainError extends ProtocolError {\n  static code() {\n    return 24;\n  }\n  static error() {\n    return 'invalid cookie domain';\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.BAD_REQUEST;\n  }\n  constructor(err) {\n    super(\n      err ||\n        'An illegal attempt was made to set a cookie under a different ' +\n          'domain than the current page.',\n      InvalidCookieDomainError.code(),\n      InvalidCookieDomainError.w3cStatus(),\n      InvalidCookieDomainError.error()\n    );\n  }\n}\n\nexport class NoSuchCookieError extends ProtocolError {\n  static code() {\n    return 62;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.NOT_FOUND;\n  }\n  static error() {\n    return 'no such cookie';\n  }\n  constructor(err) {\n    super(\n      err ||\n        'No cookie matching the given path name was found amongst the associated cookies of the current browsing context’s active document',\n      NoSuchCookieError.code(),\n      NoSuchCookieError.w3cStatus(),\n      NoSuchCookieError.error()\n    );\n  }\n}\n\nexport class UnableToSetCookieError extends ProtocolError {\n  static code() {\n    return 25;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n  }\n  static error() {\n    return 'unable to set cookie';\n  }\n  constructor(err) {\n    super(\n      err || \"A request to set a cookie's value could not be satisfied.\",\n      UnableToSetCookieError.code(),\n      UnableToSetCookieError.w3cStatus(),\n      UnableToSetCookieError.error()\n    );\n  }\n}\n\nexport class UnexpectedAlertOpenError extends ProtocolError {\n  static code() {\n    return 26;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n  }\n  static error() {\n    return 'unexpected alert open';\n  }\n  constructor(err) {\n    super(\n      err || 'A modal dialog was open, blocking this operation',\n      UnexpectedAlertOpenError.code(),\n      UnexpectedAlertOpenError.w3cStatus(),\n      UnexpectedAlertOpenError.error()\n    );\n  }\n}\n\nexport class NoAlertOpenError extends ProtocolError {\n  static code() {\n    return 27;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.NOT_FOUND;\n  }\n  static error() {\n    return 'no such alert';\n  }\n  constructor(err) {\n    super(\n      err || 'An attempt was made to operate on a modal dialog when one ' + 'was not open.',\n      NoAlertOpenError.code(),\n      NoAlertOpenError.w3cStatus(),\n      NoAlertOpenError.error()\n    );\n  }\n}\n\nexport class NoSuchAlertError extends NoAlertOpenError {}\n\nexport class ScriptTimeoutError extends ProtocolError {\n  static code() {\n    return 28;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.REQUEST_TIMEOUT;\n  }\n  static error() {\n    return 'script timeout';\n  }\n  constructor(err) {\n    super(\n      err || 'A script did not complete before its timeout expired.',\n      ScriptTimeoutError.code(),\n      ScriptTimeoutError.w3cStatus(),\n      ScriptTimeoutError.error()\n    );\n  }\n}\n\nexport class InvalidElementCoordinatesError extends ProtocolError {\n  static code() {\n    return 29;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.BAD_REQUEST;\n  }\n  static error() {\n    return 'invalid coordinates';\n  }\n  constructor(err) {\n    super(\n      err || 'The coordinates provided to an interactions operation are invalid.',\n      InvalidElementCoordinatesError.code(),\n      InvalidElementCoordinatesError.w3cStatus(),\n      InvalidElementCoordinatesError.error()\n    );\n  }\n}\n\nexport class InvalidCoordinatesError extends InvalidElementCoordinatesError {}\n\nexport class IMENotAvailableError extends ProtocolError {\n  static code() {\n    return 30;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n  }\n  static error() {\n    return 'unsupported operation';\n  }\n  constructor(err) {\n    super(\n      err || 'IME was not available.',\n      IMENotAvailableError.code(),\n      IMENotAvailableError.w3cStatus(),\n      IMENotAvailableError.error()\n    );\n  }\n}\n\nexport class IMEEngineActivationFailedError extends ProtocolError {\n  static code() {\n    return 31;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n  }\n  static error() {\n    return 'unsupported operation';\n  }\n  constructor(err) {\n    super(\n      err || 'An IME engine could not be started.',\n      IMEEngineActivationFailedError.code(),\n      IMEEngineActivationFailedError.w3cStatus(),\n      IMEEngineActivationFailedError.error()\n    );\n  }\n}\n\nexport class InvalidSelectorError extends ProtocolError {\n  static code() {\n    return 32;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.BAD_REQUEST;\n  }\n  static error() {\n    return 'invalid selector';\n  }\n  constructor(err) {\n    super(\n      err || 'Argument was an invalid selector (e.g. XPath/CSS).',\n      InvalidSelectorError.code(),\n      InvalidSelectorError.w3cStatus(),\n      InvalidSelectorError.error()\n    );\n  }\n}\n\nexport class SessionNotCreatedError extends ProtocolError {\n  static code() {\n    return 33;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n  }\n  static error() {\n    return 'session not created';\n  }\n  constructor(details) {\n    let message = 'A new session could not be created.';\n    if (details) {\n      message += ` Details: ${details}`;\n    }\n\n    super(\n      message,\n      SessionNotCreatedError.code(),\n      SessionNotCreatedError.w3cStatus(),\n      SessionNotCreatedError.error()\n    );\n  }\n}\n\nexport class MoveTargetOutOfBoundsError extends ProtocolError {\n  static code() {\n    return 34;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n  }\n  static error() {\n    return 'move target out of bounds';\n  }\n  constructor(err) {\n    super(\n      err || 'Target provided for a move action is out of bounds.',\n      MoveTargetOutOfBoundsError.code(),\n      MoveTargetOutOfBoundsError.w3cStatus(),\n      MoveTargetOutOfBoundsError.error()\n    );\n  }\n}\n\nexport class NoSuchContextError extends ProtocolError {\n  static code() {\n    return 35;\n  }\n  constructor(err) {\n    super(err || 'No such context found.', NoSuchContextError.code());\n  }\n}\n\nexport class InvalidContextError extends ProtocolError {\n  static code() {\n    return 36;\n  }\n  constructor(err) {\n    super(\n      err || 'That command could not be executed in the current context.',\n      InvalidContextError.code()\n    );\n  }\n}\n\n// These are aliases for UnknownMethodError\nexport class NotYetImplementedError extends UnknownMethodError {\n  constructor(err) {\n    super(err || 'Method has not yet been implemented');\n  }\n}\nexport class NotImplementedError extends UnknownMethodError {\n  constructor(err) {\n    super(err || 'Method is not implemented');\n  }\n}\n\nexport class UnableToCaptureScreen extends ProtocolError {\n  static code() {\n    return 63;\n  }\n  static w3cStatus() {\n    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n  }\n  static error() {\n    return 'unable to capture screen';\n  }\n  constructor(err) {\n    super(\n      err || 'A screen capture was made impossible',\n      UnableToCaptureScreen.code(),\n      UnableToCaptureScreen.w3cStatus(),\n      UnableToCaptureScreen.error()\n    );\n  }\n}\n\n// Equivalent to W3C InvalidArgumentError\nexport class BadParametersError extends ES6Error {\n  static error() {\n    return 'invalid argument';\n  }\n  constructor(requiredParams, actualParams, errMessage) {\n    let message;\n    if (!errMessage) {\n      message =\n        `Parameters were incorrect. We wanted ` +\n        `${JSON.stringify(requiredParams)} and you ` +\n        `sent ${JSON.stringify(actualParams)}`;\n    } else {\n      message = `Parameters were incorrect. You sent ${JSON.stringify(\n        actualParams\n      )}, ${errMessage}`;\n    }\n    super(message);\n    this.w3cStatus = HTTPStatusCodes.BAD_REQUEST;\n  }\n}\n\n/**\n * ProxyRequestError is a custom error and will be thrown up on unsuccessful proxy request and\n * will contain information about the proxy failure.\n * In case of ProxyRequestError should fetch the actual error by calling `getActualError()`\n * for proxy failure to generate the client response.\n */\nexport class ProxyRequestError extends ES6Error {\n  constructor(err, responseError, httpStatus) {\n    let responseErrorObj = util.safeJsonParse(responseError);\n    if (!_.isPlainObject(responseErrorObj)) {\n      responseErrorObj = {};\n    }\n    let origMessage = _.isString(responseError) ? responseError : '';\n    if (!_.isEmpty(responseErrorObj)) {\n      if (_.isString(responseErrorObj.value)) {\n        origMessage = responseErrorObj.value;\n      } else if (\n        _.isPlainObject(responseErrorObj.value) &&\n        _.isString(responseErrorObj.value.message)\n      ) {\n        origMessage = responseErrorObj.value.message;\n      }\n    }\n    super(_.isEmpty(err) ? `Proxy request unsuccessful. ${origMessage}` : err);\n\n    this.w3cStatus = HTTPStatusCodes.BAD_REQUEST;\n\n    // If the response error is an object and value is an object, it's a W3C error (for JSONWP value is a string)\n    if (_.isPlainObject(responseErrorObj.value) && _.has(responseErrorObj.value, 'error')) {\n      this.w3c = responseErrorObj.value;\n      this.w3cStatus = httpStatus || HTTPStatusCodes.BAD_REQUEST;\n    } else {\n      this.jsonwp = responseErrorObj;\n    }\n  }\n\n  getActualError() {\n    // If it's MJSONWP error, returns actual error cause for request failure based on `jsonwp.status`\n    if (util.hasValue(this.jsonwp?.status) && util.hasValue(this.jsonwp?.value)) {\n      return errorFromMJSONWPStatusCode(this.jsonwp.status, this.jsonwp.value);\n    } else if (util.hasValue(this.w3c) && _.isNumber(this.w3cStatus) && this.w3cStatus >= 300) {\n      return errorFromW3CJsonCode(\n        this.w3c.error,\n        this.w3c.message || this.message,\n        this.w3c.stacktrace\n      );\n    }\n    return new UnknownError(this.message);\n  }\n}\n// map of error class name to error class\nconst errors = {\n  NotYetImplementedError,\n  NotImplementedError,\n  BadParametersError,\n  InvalidArgumentError,\n  NoSuchDriverError,\n  NoSuchElementError,\n  UnknownCommandError,\n  StaleElementReferenceError,\n  ElementNotVisibleError,\n  InvalidElementStateError,\n  UnknownError,\n  ElementIsNotSelectableError,\n  ElementClickInterceptedError,\n  ElementNotInteractableError,\n  InsecureCertificateError,\n  JavaScriptError,\n  XPathLookupError,\n  TimeoutError,\n  NoSuchWindowError,\n  NoSuchCookieError,\n  InvalidCookieDomainError,\n  InvalidCoordinatesError,\n  UnableToSetCookieError,\n  UnexpectedAlertOpenError,\n  NoAlertOpenError,\n  ScriptTimeoutError,\n  InvalidElementCoordinatesError,\n  IMENotAvailableError,\n  IMEEngineActivationFailedError,\n  InvalidSelectorError,\n  SessionNotCreatedError,\n  MoveTargetOutOfBoundsError,\n  NoSuchAlertError,\n  NoSuchContextError,\n  InvalidContextError,\n  NoSuchFrameError,\n  UnableToCaptureScreen,\n  UnknownMethodError,\n  UnsupportedOperationError,\n  ProxyRequestError,\n};\n\n// map of error code to error class\nconst jsonwpErrorCodeMap = {};\nfor (let ErrorClass of _.values(errors)) {\n  if ('code' in ErrorClass) {\n    jsonwpErrorCodeMap[ErrorClass.code()] = ErrorClass;\n  }\n}\n\nconst w3cErrorCodeMap = {};\nfor (let ErrorClass of _.values(errors)) {\n  if ('error' in ErrorClass) {\n    w3cErrorCodeMap[ErrorClass.error()] = ErrorClass;\n  }\n}\n\nfunction isUnknownError(err) {\n  return (\n    !err.constructor.name ||\n    !_.values(errors).find(function equalNames(error) {\n      return error.name === err.constructor.name;\n    })\n  );\n}\n\nfunction isErrorType(err, type) {\n  // `name` property is the constructor name\n  if (type.name === ProtocolError.name) {\n    // `jsonwpCode` is `0` on success\n    return !!err.jsonwpCode;\n  } else if (type.name === ProxyRequestError.name) {\n    // `status` is `0` on success\n    if (err.jsonwp) {\n      return !!err.jsonwp.status;\n    }\n\n    if (_.isPlainObject(err.w3c)) {\n      return _.isNumber(err.w3cStatus) && err.w3cStatus >= 300;\n    }\n\n    return false;\n  }\n  return err.constructor.name === type.name;\n}\n\n/**\n * Retrieve an error derived from MJSONWP status\n * @param {number} code JSONWP status code\n * @param {string|Object} value The error message, or an object with a `message` property\n * @return {ProtocolError} The error that is associated with provided JSONWP status code\n */\nfunction errorFromMJSONWPStatusCode(code, value = '') {\n  // if `value` is an object, pull message from it, otherwise use the plain\n  // value, or default to an empty string, if null\n  const message = (value || {}).message || value || '';\n  if (code !== UnknownError.code() && jsonwpErrorCodeMap[code]) {\n    mjsonwpLog.debug(`Matched JSONWP error code ${code} to ${jsonwpErrorCodeMap[code].name}`);\n    return new jsonwpErrorCodeMap[code](message);\n  }\n  mjsonwpLog.debug(`Matched JSONWP error code ${code} to UnknownError`);\n  return new UnknownError(message);\n}\n\n/**\n * Retrieve an error derived from W3C JSON Code\n * @param {string} code W3C error string (see https://www.w3.org/TR/webdriver/#handling-errors `JSON Error Code` column)\n * @param {string} message the error message\n * @param {?string} stacktrace an optional error stacktrace\n * @return {ProtocolError}  The error that is associated with the W3C error string\n */\nfunction errorFromW3CJsonCode(code, message, stacktrace = null) {\n  if (code && w3cErrorCodeMap[code.toLowerCase()]) {\n    w3cLog.debug(`Matched W3C error code '${code}' to ${w3cErrorCodeMap[code.toLowerCase()].name}`);\n    const resultError = new w3cErrorCodeMap[code.toLowerCase()](message);\n    resultError.stacktrace = stacktrace;\n    return resultError;\n  }\n  w3cLog.debug(`Matched W3C error code '${code}' to UnknownError`);\n  const resultError = new UnknownError(message);\n  resultError.stacktrace = stacktrace;\n  return resultError;\n}\n\n/**\n *\n * @param {any} err\n * @returns {err is ProtocolError}\n */\nfunction isProtocolError(err) {\n  return 'w3cStatus' in err;\n}\n\n/**\n * Convert an Appium error to proper W3C HTTP response\n * @param {ProtocolError|MJSONWPError} err The error that needs to be translated\n */\nfunction getResponseForW3CError(err) {\n  let httpStatus;\n\n  // W3C defined error message (https://www.w3.org/TR/webdriver/#dfn-error-code)\n  let w3cErrorString;\n\n  if (!isProtocolError(err)) {\n    err = util.hasValue(err.status)\n      ? // If it's a JSONWP error, find corresponding error\n        errorFromMJSONWPStatusCode(err.status, err.value)\n      : new errors.UnknownError(err.message);\n  }\n\n  if (isErrorType(err, errors.BadParametersError)) {\n    // respond with a 400 if we have bad parameters\n    w3cLog.debug(`Bad parameters: ${err}`);\n    w3cErrorString = BadParametersError.error();\n  } else {\n    w3cErrorString = err.error;\n  }\n\n  httpStatus = err.w3cStatus;\n\n  if (!w3cErrorString) {\n    w3cErrorString = UnknownError.error();\n  }\n\n  let httpResBody = {\n    value: {\n      error: w3cErrorString,\n      message: err.message,\n      stacktrace: err.stacktrace || err.stack,\n    },\n  };\n  return [httpStatus, httpResBody];\n}\n\n/**\n * Convert an Appium error to a proper JSONWP response\n * @param {ProtocolError} err The error to be converted\n */\nfunction getResponseForJsonwpError(err) {\n  if (isUnknownError(err)) {\n    err = new errors.UnknownError(err);\n  }\n  // MJSONWP errors are usually 500 status code so set it to that by default\n  let httpStatus = HTTPStatusCodes.INTERNAL_SERVER_ERROR;\n\n  /** @type {HttpResultBody} */\n  let httpResBody = {\n    status: err.jsonwpCode,\n    value: {\n      message: err.message,\n    },\n  };\n\n  if (isErrorType(err, errors.BadParametersError)) {\n    // respond with a 400 if we have bad parameters\n    mjsonwpLog.debug(`Bad parameters: ${err}`);\n    httpStatus = HTTPStatusCodes.BAD_REQUEST;\n    httpResBody = err.message;\n  } else if (\n    isErrorType(err, errors.NotYetImplementedError) ||\n    isErrorType(err, errors.NotImplementedError)\n  ) {\n    // respond with a 501 if the method is not implemented\n    httpStatus = HTTPStatusCodes.NOT_IMPLEMENTED;\n  } else if (isErrorType(err, errors.NoSuchDriverError)) {\n    // respond with a 404 if there is no driver for the session\n    httpStatus = HTTPStatusCodes.NOT_FOUND;\n  }\n\n  return [httpStatus, httpResBody];\n}\n\nexport {\n  errors,\n  isErrorType,\n  isUnknownError,\n  errorFromMJSONWPStatusCode,\n  errorFromW3CJsonCode,\n  getResponseForW3CError,\n  getResponseForJsonwpError,\n};\n\n/**\n * @typedef { string | {value: HttpResultBodyValue, status?: number } } HttpResultBody\n */\n\n/**\n * @typedef HttpResultBodyValue\n * @property {string} [message]\n * @property {string|Error} [error]\n * @property {string} [stacktrace]\n */\n\n/**\n * @typedef MJSONWPError\n * @property {number} status\n * @property {string|object} value\n * @property {string} message\n */\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;;;AAEA,MAAMA,UAAU,GAAGC,eAAA,CAAOC,SAAP,CAAiB,SAAjB,CAAnB;;AACA,MAAMC,MAAM,GAAGF,eAAA,CAAOC,SAAP,CAAiB,KAAjB,CAAf;;AAEA,MAAME,iBAAiB,GAAG,eAA1B;;AAGO,MAAMC,aAAN,SAA4BC,iBAA5B,CAAqC;EAC1CC,WAAW,CAACC,GAAD,EAAMC,UAAN,EAAkBC,SAAlB,EAA6BC,KAA7B,EAAoC;IAC7C,MAAMH,GAAN;IACA,KAAKC,UAAL,GAAkBA,UAAlB;IACA,KAAKE,KAAL,GAAaA,KAAK,IAAIP,iBAAtB;;IACA,IAAI,KAAKK,UAAL,KAAoB,IAAxB,EAA8B;MAC5B,KAAKA,UAAL,GAAkB,EAAlB;IACD;;IACD,KAAKC,SAAL,GAAiBA,SAAS,IAAIE,4BAAA,CAAgBC,WAA9C;IACA,KAAKC,WAAL,GAAmB,IAAnB;EACD;;EAEa,IAAVC,UAAU,GAAG;IACf,OAAO,KAAKD,WAAL,IAAoB,KAAKE,KAAhC;EACD;;EAEa,IAAVD,UAAU,CAACE,KAAD,EAAQ;IACpB,KAAKH,WAAL,GAAmBG,KAAnB;EACD;;AAlByC;;;;AAyBrC,MAAMC,iBAAN,SAAgCb,aAAhC,CAA8C;EACxC,OAAJc,IAAI,GAAG;IACZ,OAAO,CAAP;EACD;;EAEe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBQ,SAAvB;EACD;;EACW,OAALT,KAAK,GAAG;IACb,OAAO,oBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,+CADT,EAEEH,iBAAiB,CAACC,IAAlB,EAFF,EAGED,iBAAiB,CAACR,SAAlB,EAHF,EAIEQ,iBAAiB,CAACP,KAAlB,EAJF;EAMD;;AAlBkD;;;;AAqB9C,MAAMW,kBAAN,SAAiCjB,aAAjC,CAA+C;EACzC,OAAJc,IAAI,GAAG;IACZ,OAAO,CAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBQ,SAAvB;EACD;;EACW,OAALT,KAAK,GAAG;IACb,OAAO,iBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,iEAAiE,oBAD1E,EAEEC,kBAAkB,CAACH,IAAnB,EAFF,EAGEG,kBAAkB,CAACZ,SAAnB,EAHF,EAIEY,kBAAkB,CAACX,KAAnB,EAJF;EAMD;;AAjBmD;;;;AAoB/C,MAAMY,gBAAN,SAA+BlB,aAA/B,CAA6C;EACvC,OAAJc,IAAI,GAAG;IACZ,OAAO,CAAP;EACD;;EACW,OAALR,KAAK,GAAG;IACb,OAAO,eAAP;EACD;;EACe,OAATD,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBQ,SAAvB;EACD;;EACDb,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,mEACE,+BAHN,EAIEE,gBAAgB,CAACJ,IAAjB,EAJF,EAKEI,gBAAgB,CAACb,SAAjB,EALF,EAMEa,gBAAgB,CAACZ,KAAjB,EANF;EAQD;;AAnBiD;;;;AAsB7C,MAAMa,mBAAN,SAAkCnB,aAAlC,CAAgD;EAC1C,OAAJc,IAAI,GAAG;IACZ,OAAO,CAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBQ,SAAvB;EACD;;EACW,OAALT,KAAK,GAAG;IACb,OAAO,iBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,iEACE,oEADF,GAEE,WAJN,EAKEG,mBAAmB,CAACL,IAApB,EALF,EAMEK,mBAAmB,CAACd,SAApB,EANF,EAOEc,mBAAmB,CAACb,KAApB,EAPF;EASD;;AApBoD;;;;AAuBhD,MAAMc,0BAAN,SAAyCpB,aAAzC,CAAuD;EACjD,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBQ,SAAvB;EACD;;EACW,OAALT,KAAK,GAAG;IACb,OAAO,yBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,oEACE,6BAHN,EAIEI,0BAA0B,CAACN,IAA3B,EAJF,EAKEM,0BAA0B,CAACf,SAA3B,EALF,EAMEe,0BAA0B,CAACd,KAA3B,EANF;EAQD;;AAnB2D;;;;AAsBvD,MAAMe,sBAAN,SAAqCrB,aAArC,CAAmD;EAC7C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBC,WAAvB;EACD;;EACW,OAALF,KAAK,GAAG;IACb,OAAO,qBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,sEACE,0BAHN,EAIEK,sBAAsB,CAACP,IAAvB,EAJF,EAKEO,sBAAsB,CAAChB,SAAvB,EALF,EAMEgB,sBAAsB,CAACf,KAAvB,EANF;EAQD;;AAnBuD;;;;AAsBnD,MAAMgB,wBAAN,SAAuCtB,aAAvC,CAAqD;EAC/C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBC,WAAvB;EACD;;EACW,OAALF,KAAK,GAAG;IACb,OAAO,uBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,sEACE,oEAHN,EAIEM,wBAAwB,CAACR,IAAzB,EAJF,EAKEQ,wBAAwB,CAACjB,SAAzB,EALF,EAMEiB,wBAAwB,CAAChB,KAAzB,EANF;EAQD;;AAnByD;;;;AAsBrD,MAAMiB,YAAN,SAA2BvB,aAA3B,CAAyC;EACnC,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiB,qBAAvB;EACD;;EACW,OAALlB,KAAK,GAAG;IACb,OAAOP,iBAAP;EACD;;EACDG,WAAW,CAACuB,cAAD,EAAiB;IAC1B,MAAMC,WAAW,GAAGC,eAAA,CAAEC,QAAF,CAAW,CAACH,cAAc,IAAI,EAAnB,EAAuBI,OAAlC,IAChBJ,cAAc,CAACI,OADC,GAEhBJ,cAFJ;IAGA,MAAMI,OAAO,GACX,yEACCH,WAAW,GAAI,oBAAmBA,WAAY,EAAnC,GAAuC,EADnD,CADF;IAGA,MAAMG,OAAN,EAAeN,YAAY,CAACT,IAAb,EAAf,EAAoCS,YAAY,CAAClB,SAAb,EAApC,EAA8DkB,YAAY,CAACjB,KAAb,EAA9D;EACD;;AAlB6C;;;;AAqBzC,MAAMwB,kBAAN,SAAiC9B,aAAjC,CAA+C;EACzC,OAAJc,IAAI,GAAG;IACZ,OAAO,GAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBwB,kBAAvB;EACD;;EACW,OAALzB,KAAK,GAAG;IACb,OAAO,gBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,oFADT,EAEEc,kBAAkB,CAAChB,IAAnB,EAFF,EAGEgB,kBAAkB,CAACzB,SAAnB,EAHF,EAIEyB,kBAAkB,CAACxB,KAAnB,EAJF;EAMD;;AAjBmD;;;;AAoB/C,MAAM0B,yBAAN,SAAwChC,aAAxC,CAAsD;EAChD,OAAJc,IAAI,GAAG;IACZ,OAAO,GAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiB,qBAAvB;EACD;;EACW,OAALlB,KAAK,GAAG;IACb,OAAO,uBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,4DADT,EAEEgB,yBAAyB,CAAClB,IAA1B,EAFF,EAGEkB,yBAAyB,CAAC3B,SAA1B,EAHF,EAIE2B,yBAAyB,CAAC1B,KAA1B,EAJF;EAMD;;AAjB0D;;;;AAoBtD,MAAM2B,2BAAN,SAA0CjC,aAA1C,CAAwD;EAClD,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACW,OAALR,KAAK,GAAG;IACb,OAAO,wBAAP;EACD;;EACe,OAATD,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBC,WAAvB;EACD;;EACDN,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,mEADT,EAEEiB,2BAA2B,CAACnB,IAA5B,EAFF,EAGEmB,2BAA2B,CAAC5B,SAA5B,EAHF,EAIE4B,2BAA2B,CAAC3B,KAA5B,EAJF;EAMD;;AAjB4D;;;;AAoBxD,MAAM4B,4BAAN,SAA2ClC,aAA3C,CAAyD;EACnD,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACW,OAALR,KAAK,GAAG;IACb,OAAO,2BAAP;EACD;;EACe,OAATD,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBC,WAAvB;EACD;;EACDN,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,oFACE,gEAHN,EAIEkB,4BAA4B,CAACpB,IAA7B,EAJF,EAKEoB,4BAA4B,CAAC7B,SAA7B,EALF,EAME6B,4BAA4B,CAAC5B,KAA7B,EANF;EAQD;;AAnB6D;;;;AAsBzD,MAAM6B,2BAAN,SAA0CnC,aAA1C,CAAwD;EAClD,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACW,OAALR,KAAK,GAAG;IACb,OAAO,0BAAP;EACD;;EACe,OAATD,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBC,WAAvB;EACD;;EACDN,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,+FAFJ,EAGEmB,2BAA2B,CAACrB,IAA5B,EAHF,EAIEqB,2BAA2B,CAAC9B,SAA5B,EAJF,EAKE8B,2BAA2B,CAAC7B,KAA5B,EALF;EAOD;;AAlB4D;;;;AAqBxD,MAAM8B,wBAAN,SAAuCpC,aAAvC,CAAqD;EAC9C,OAALM,KAAK,GAAG;IACb,OAAO,sBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,qIAFJ,EAGEiB,2BAA2B,CAACnB,IAA5B,EAHF,EAIE,IAJF,EAKEsB,wBAAwB,CAAC9B,KAAzB,EALF;EAOD;;AAZyD;;;;AAerD,MAAM+B,eAAN,SAA8BrC,aAA9B,CAA4C;EACtC,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiB,qBAAvB;EACD;;EACW,OAALlB,KAAK,GAAG;IACb,OAAO,kBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,6DADT,EAEEqB,eAAe,CAACvB,IAAhB,EAFF,EAGEuB,eAAe,CAAChC,SAAhB,EAHF,EAIEgC,eAAe,CAAC/B,KAAhB,EAJF;EAMD;;AAjBgD;;;;AAoB5C,MAAMgC,gBAAN,SAA+BtC,aAA/B,CAA6C;EACvC,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBC,WAAvB;EACD;;EACW,OAALF,KAAK,GAAG;IACb,OAAO,kBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,4DADT,EAEEsB,gBAAgB,CAACxB,IAAjB,EAFF,EAGEwB,gBAAgB,CAACjC,SAAjB,EAHF,EAIEiC,gBAAgB,CAAChC,KAAjB,EAJF;EAMD;;AAjBiD;;;;AAoB7C,MAAMiC,YAAN,SAA2BvC,aAA3B,CAAyC;EACnC,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiC,eAAvB;EACD;;EACW,OAALlC,KAAK,GAAG;IACb,OAAO,SAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,2DADT,EAEEuB,YAAY,CAACzB,IAAb,EAFF,EAGEyB,YAAY,CAAClC,SAAb,EAHF,EAIEkC,YAAY,CAACjC,KAAb,EAJF;EAMD;;AAjB6C;;;;AAoBzC,MAAMmC,iBAAN,SAAgCzC,aAAhC,CAA8C;EACxC,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACW,OAALR,KAAK,GAAG;IACb,OAAO,gBAAP;EACD;;EACe,OAATD,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBQ,SAAvB;EACD;;EACDb,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,sEACE,wCAHN,EAIEyB,iBAAiB,CAAC3B,IAAlB,EAJF,EAKE2B,iBAAiB,CAACpC,SAAlB,EALF,EAMEoC,iBAAiB,CAACnC,KAAlB,EANF;EAQD;;AAnBkD;;;;AAsB9C,MAAMoC,oBAAN,SAAmC1C,aAAnC,CAAiD;EAC3C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACW,OAALR,KAAK,GAAG;IACb,OAAO,kBAAP;EACD;;EACe,OAATD,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBC,WAAvB;EACD;;EACDN,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,qEADT,EAEE0B,oBAAoB,CAAC5B,IAArB,EAFF,EAGE4B,oBAAoB,CAACrC,SAArB,EAHF,EAIEqC,oBAAoB,CAACpC,KAArB,EAJF;EAMD;;AAjBqD;;;;AAoBjD,MAAMqC,wBAAN,SAAuC3C,aAAvC,CAAqD;EAC/C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACW,OAALR,KAAK,GAAG;IACb,OAAO,uBAAP;EACD;;EACe,OAATD,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBC,WAAvB;EACD;;EACDN,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,mEACE,+BAHN,EAIE2B,wBAAwB,CAAC7B,IAAzB,EAJF,EAKE6B,wBAAwB,CAACtC,SAAzB,EALF,EAMEsC,wBAAwB,CAACrC,KAAzB,EANF;EAQD;;AAnByD;;;;AAsBrD,MAAMsC,iBAAN,SAAgC5C,aAAhC,CAA8C;EACxC,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBQ,SAAvB;EACD;;EACW,OAALT,KAAK,GAAG;IACb,OAAO,gBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IACD,mIAFJ,EAGE4B,iBAAiB,CAAC9B,IAAlB,EAHF,EAIE8B,iBAAiB,CAACvC,SAAlB,EAJF,EAKEuC,iBAAiB,CAACtC,KAAlB,EALF;EAOD;;AAlBkD;;;;AAqB9C,MAAMuC,sBAAN,SAAqC7C,aAArC,CAAmD;EAC7C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiB,qBAAvB;EACD;;EACW,OAALlB,KAAK,GAAG;IACb,OAAO,sBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,2DADT,EAEE6B,sBAAsB,CAAC/B,IAAvB,EAFF,EAGE+B,sBAAsB,CAACxC,SAAvB,EAHF,EAIEwC,sBAAsB,CAACvC,KAAvB,EAJF;EAMD;;AAjBuD;;;;AAoBnD,MAAMwC,wBAAN,SAAuC9C,aAAvC,CAAqD;EAC/C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiB,qBAAvB;EACD;;EACW,OAALlB,KAAK,GAAG;IACb,OAAO,uBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,kDADT,EAEE8B,wBAAwB,CAAChC,IAAzB,EAFF,EAGEgC,wBAAwB,CAACzC,SAAzB,EAHF,EAIEyC,wBAAwB,CAACxC,KAAzB,EAJF;EAMD;;AAjByD;;;;AAoBrD,MAAMyC,gBAAN,SAA+B/C,aAA/B,CAA6C;EACvC,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBQ,SAAvB;EACD;;EACW,OAALT,KAAK,GAAG;IACb,OAAO,eAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,+DAA+D,eADxE,EAEE+B,gBAAgB,CAACjC,IAAjB,EAFF,EAGEiC,gBAAgB,CAAC1C,SAAjB,EAHF,EAIE0C,gBAAgB,CAACzC,KAAjB,EAJF;EAMD;;AAjBiD;;;;AAoB7C,MAAM0C,gBAAN,SAA+BD,gBAA/B,CAAgD;;;;AAEhD,MAAME,kBAAN,SAAiCjD,aAAjC,CAA+C;EACzC,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiC,eAAvB;EACD;;EACW,OAALlC,KAAK,GAAG;IACb,OAAO,gBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,uDADT,EAEEiC,kBAAkB,CAACnC,IAAnB,EAFF,EAGEmC,kBAAkB,CAAC5C,SAAnB,EAHF,EAIE4C,kBAAkB,CAAC3C,KAAnB,EAJF;EAMD;;AAjBmD;;;;AAoB/C,MAAM4C,8BAAN,SAA6ClD,aAA7C,CAA2D;EACrD,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBC,WAAvB;EACD;;EACW,OAALF,KAAK,GAAG;IACb,OAAO,qBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,oEADT,EAEEkC,8BAA8B,CAACpC,IAA/B,EAFF,EAGEoC,8BAA8B,CAAC7C,SAA/B,EAHF,EAIE6C,8BAA8B,CAAC5C,KAA/B,EAJF;EAMD;;AAjB+D;;;;AAoB3D,MAAM6C,uBAAN,SAAsCD,8BAAtC,CAAqE;;;;AAErE,MAAME,oBAAN,SAAmCpD,aAAnC,CAAiD;EAC3C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiB,qBAAvB;EACD;;EACW,OAALlB,KAAK,GAAG;IACb,OAAO,uBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,wBADT,EAEEoC,oBAAoB,CAACtC,IAArB,EAFF,EAGEsC,oBAAoB,CAAC/C,SAArB,EAHF,EAIE+C,oBAAoB,CAAC9C,KAArB,EAJF;EAMD;;AAjBqD;;;;AAoBjD,MAAM+C,8BAAN,SAA6CrD,aAA7C,CAA2D;EACrD,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiB,qBAAvB;EACD;;EACW,OAALlB,KAAK,GAAG;IACb,OAAO,uBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,qCADT,EAEEqC,8BAA8B,CAACvC,IAA/B,EAFF,EAGEuC,8BAA8B,CAAChD,SAA/B,EAHF,EAIEgD,8BAA8B,CAAC/C,KAA/B,EAJF;EAMD;;AAjB+D;;;;AAoB3D,MAAMgD,oBAAN,SAAmCtD,aAAnC,CAAiD;EAC3C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBC,WAAvB;EACD;;EACW,OAALF,KAAK,GAAG;IACb,OAAO,kBAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,oDADT,EAEEsC,oBAAoB,CAACxC,IAArB,EAFF,EAGEwC,oBAAoB,CAACjD,SAArB,EAHF,EAIEiD,oBAAoB,CAAChD,KAArB,EAJF;EAMD;;AAjBqD;;;;AAoBjD,MAAMiD,sBAAN,SAAqCvD,aAArC,CAAmD;EAC7C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiB,qBAAvB;EACD;;EACW,OAALlB,KAAK,GAAG;IACb,OAAO,qBAAP;EACD;;EACDJ,WAAW,CAACsD,OAAD,EAAU;IACnB,IAAI3B,OAAO,GAAG,qCAAd;;IACA,IAAI2B,OAAJ,EAAa;MACX3B,OAAO,IAAK,aAAY2B,OAAQ,EAAhC;IACD;;IAED,MACE3B,OADF,EAEE0B,sBAAsB,CAACzC,IAAvB,EAFF,EAGEyC,sBAAsB,CAAClD,SAAvB,EAHF,EAIEkD,sBAAsB,CAACjD,KAAvB,EAJF;EAMD;;AAtBuD;;;;AAyBnD,MAAMmD,0BAAN,SAAyCzD,aAAzC,CAAuD;EACjD,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiB,qBAAvB;EACD;;EACW,OAALlB,KAAK,GAAG;IACb,OAAO,2BAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,qDADT,EAEEyC,0BAA0B,CAAC3C,IAA3B,EAFF,EAGE2C,0BAA0B,CAACpD,SAA3B,EAHF,EAIEoD,0BAA0B,CAACnD,KAA3B,EAJF;EAMD;;AAjB2D;;;;AAoBvD,MAAMoD,kBAAN,SAAiC1D,aAAjC,CAA+C;EACzC,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACDZ,WAAW,CAACc,GAAD,EAAM;IACf,MAAMA,GAAG,IAAI,wBAAb,EAAuC0C,kBAAkB,CAAC5C,IAAnB,EAAvC;EACD;;AANmD;;;;AAS/C,MAAM6C,mBAAN,SAAkC3D,aAAlC,CAAgD;EAC1C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACDZ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,4DADT,EAEE2C,mBAAmB,CAAC7C,IAApB,EAFF;EAID;;AAToD;;;;AAahD,MAAM8C,sBAAN,SAAqC9B,kBAArC,CAAwD;EAC7D5B,WAAW,CAACc,GAAD,EAAM;IACf,MAAMA,GAAG,IAAI,qCAAb;EACD;;AAH4D;;;;AAKxD,MAAM6C,mBAAN,SAAkC/B,kBAAlC,CAAqD;EAC1D5B,WAAW,CAACc,GAAD,EAAM;IACf,MAAMA,GAAG,IAAI,2BAAb;EACD;;AAHyD;;;;AAMrD,MAAM8C,qBAAN,SAAoC9D,aAApC,CAAkD;EAC5C,OAAJc,IAAI,GAAG;IACZ,OAAO,EAAP;EACD;;EACe,OAATT,SAAS,GAAG;IACjB,OAAOE,4BAAA,CAAgBiB,qBAAvB;EACD;;EACW,OAALlB,KAAK,GAAG;IACb,OAAO,0BAAP;EACD;;EACDJ,WAAW,CAACc,GAAD,EAAM;IACf,MACEA,GAAG,IAAI,sCADT,EAEE8C,qBAAqB,CAAChD,IAAtB,EAFF,EAGEgD,qBAAqB,CAACzD,SAAtB,EAHF,EAIEyD,qBAAqB,CAACxD,KAAtB,EAJF;EAMD;;AAjBsD;;;;AAqBlD,MAAMyD,kBAAN,SAAiC9D,iBAAjC,CAA0C;EACnC,OAALK,KAAK,GAAG;IACb,OAAO,kBAAP;EACD;;EACDJ,WAAW,CAAC8D,cAAD,EAAiBC,YAAjB,EAA+BC,UAA/B,EAA2C;IACpD,IAAIrC,OAAJ;;IACA,IAAI,CAACqC,UAAL,EAAiB;MACfrC,OAAO,GACJ,uCAAD,GACC,GAAEsC,IAAI,CAACC,SAAL,CAAeJ,cAAf,CAA+B,WADlC,GAEC,QAAOG,IAAI,CAACC,SAAL,CAAeH,YAAf,CAA6B,EAHvC;IAID,CALD,MAKO;MACLpC,OAAO,GAAI,uCAAsCsC,IAAI,CAACC,SAAL,CAC/CH,YAD+C,CAE/C,KAAIC,UAAW,EAFjB;IAGD;;IACD,MAAMrC,OAAN;IACA,KAAKxB,SAAL,GAAiBE,4BAAA,CAAgBC,WAAjC;EACD;;AAlB8C;;;;AA2B1C,MAAM6D,iBAAN,SAAgCpE,iBAAhC,CAAyC;EAC9CC,WAAW,CAACc,GAAD,EAAMsD,aAAN,EAAqBC,UAArB,EAAiC;IAC1C,IAAIC,gBAAgB,GAAGC,aAAA,CAAKC,aAAL,CAAmBJ,aAAnB,CAAvB;;IACA,IAAI,CAAC3C,eAAA,CAAEgD,aAAF,CAAgBH,gBAAhB,CAAL,EAAwC;MACtCA,gBAAgB,GAAG,EAAnB;IACD;;IACD,IAAI9C,WAAW,GAAGC,eAAA,CAAEC,QAAF,CAAW0C,aAAX,IAA4BA,aAA5B,GAA4C,EAA9D;;IACA,IAAI,CAAC3C,eAAA,CAAEiD,OAAF,CAAUJ,gBAAV,CAAL,EAAkC;MAChC,IAAI7C,eAAA,CAAEC,QAAF,CAAW4C,gBAAgB,CAAC5D,KAA5B,CAAJ,EAAwC;QACtCc,WAAW,GAAG8C,gBAAgB,CAAC5D,KAA/B;MACD,CAFD,MAEO,IACLe,eAAA,CAAEgD,aAAF,CAAgBH,gBAAgB,CAAC5D,KAAjC,KACAe,eAAA,CAAEC,QAAF,CAAW4C,gBAAgB,CAAC5D,KAAjB,CAAuBiB,OAAlC,CAFK,EAGL;QACAH,WAAW,GAAG8C,gBAAgB,CAAC5D,KAAjB,CAAuBiB,OAArC;MACD;IACF;;IACD,MAAMF,eAAA,CAAEiD,OAAF,CAAU5D,GAAV,IAAkB,+BAA8BU,WAAY,EAA5D,GAAgEV,GAAtE;IAEA,KAAKX,SAAL,GAAiBE,4BAAA,CAAgBC,WAAjC;;IAGA,IAAImB,eAAA,CAAEgD,aAAF,CAAgBH,gBAAgB,CAAC5D,KAAjC,KAA2Ce,eAAA,CAAEkD,GAAF,CAAML,gBAAgB,CAAC5D,KAAvB,EAA8B,OAA9B,CAA/C,EAAuF;MACrF,KAAKkE,GAAL,GAAWN,gBAAgB,CAAC5D,KAA5B;MACA,KAAKP,SAAL,GAAiBkE,UAAU,IAAIhE,4BAAA,CAAgBC,WAA/C;IACD,CAHD,MAGO;MACL,KAAKuE,MAAL,GAAcP,gBAAd;IACD;EACF;;EAEDQ,cAAc,GAAG;IAAA;;IAEf,IAAIP,aAAA,CAAKQ,QAAL,iBAAc,KAAKF,MAAnB,iDAAc,aAAaG,MAA3B,KAAsCT,aAAA,CAAKQ,QAAL,kBAAc,KAAKF,MAAnB,kDAAc,cAAanE,KAA3B,CAA1C,EAA6E;MAC3E,OAAOuE,0BAA0B,CAAC,KAAKJ,MAAL,CAAYG,MAAb,EAAqB,KAAKH,MAAL,CAAYnE,KAAjC,CAAjC;IACD,CAFD,MAEO,IAAI6D,aAAA,CAAKQ,QAAL,CAAc,KAAKH,GAAnB,KAA2BnD,eAAA,CAAEyD,QAAF,CAAW,KAAK/E,SAAhB,CAA3B,IAAyD,KAAKA,SAAL,IAAkB,GAA/E,EAAoF;MACzF,OAAOgF,oBAAoB,CACzB,KAAKP,GAAL,CAASxE,KADgB,EAEzB,KAAKwE,GAAL,CAASjD,OAAT,IAAoB,KAAKA,OAFA,EAGzB,KAAKiD,GAAL,CAASpE,UAHgB,CAA3B;IAKD;;IACD,OAAO,IAAIa,YAAJ,CAAiB,KAAKM,OAAtB,CAAP;EACD;;AA1C6C;;;AA6ChD,MAAMyD,MAAM,GAAG;EACb1B,sBADa;EAEbC,mBAFa;EAGbE,kBAHa;EAIbrB,oBAJa;EAKb7B,iBALa;EAMbI,kBANa;EAObE,mBAPa;EAQbC,0BARa;EASbC,sBATa;EAUbC,wBAVa;EAWbC,YAXa;EAYbU,2BAZa;EAabC,4BAba;EAcbC,2BAda;EAebC,wBAfa;EAgBbC,eAhBa;EAiBbC,gBAjBa;EAkBbC,YAlBa;EAmBbE,iBAnBa;EAoBbG,iBApBa;EAqBbD,wBArBa;EAsBbQ,uBAtBa;EAuBbN,sBAvBa;EAwBbC,wBAxBa;EAyBbC,gBAzBa;EA0BbE,kBA1Ba;EA2BbC,8BA3Ba;EA4BbE,oBA5Ba;EA6BbC,8BA7Ba;EA8BbC,oBA9Ba;EA+BbC,sBA/Ba;EAgCbE,0BAhCa;EAiCbT,gBAjCa;EAkCbU,kBAlCa;EAmCbC,mBAnCa;EAoCbzC,gBApCa;EAqCb4C,qBArCa;EAsCbhC,kBAtCa;EAuCbE,yBAvCa;EAwCbqC;AAxCa,CAAf;;AA4CA,MAAMkB,kBAAkB,GAAG,EAA3B;;AACA,KAAK,IAAIC,UAAT,IAAuB7D,eAAA,CAAE8D,MAAF,CAASH,MAAT,CAAvB,EAAyC;EACvC,IAAI,UAAUE,UAAd,EAA0B;IACxBD,kBAAkB,CAACC,UAAU,CAAC1E,IAAX,EAAD,CAAlB,GAAwC0E,UAAxC;EACD;AACF;;AAED,MAAME,eAAe,GAAG,EAAxB;;AACA,KAAK,IAAIF,UAAT,IAAuB7D,eAAA,CAAE8D,MAAF,CAASH,MAAT,CAAvB,EAAyC;EACvC,IAAI,WAAWE,UAAf,EAA2B;IACzBE,eAAe,CAACF,UAAU,CAAClF,KAAX,EAAD,CAAf,GAAsCkF,UAAtC;EACD;AACF;;AAED,SAASG,cAAT,CAAwB3E,GAAxB,EAA6B;EAC3B,OACE,CAACA,GAAG,CAACd,WAAJ,CAAgB0F,IAAjB,IACA,CAACjE,eAAA,CAAE8D,MAAF,CAASH,MAAT,EAAiBO,IAAjB,CAAsB,SAASC,UAAT,CAAoBxF,KAApB,EAA2B;IAChD,OAAOA,KAAK,CAACsF,IAAN,KAAe5E,GAAG,CAACd,WAAJ,CAAgB0F,IAAtC;EACD,CAFA,CAFH;AAMD;;AAED,SAASG,WAAT,CAAqB/E,GAArB,EAA0BgF,IAA1B,EAAgC;EAE9B,IAAIA,IAAI,CAACJ,IAAL,KAAc5F,aAAa,CAAC4F,IAAhC,EAAsC;IAEpC,OAAO,CAAC,CAAC5E,GAAG,CAACZ,UAAb;EACD,CAHD,MAGO,IAAI4F,IAAI,CAACJ,IAAL,KAAcvB,iBAAiB,CAACuB,IAApC,EAA0C;IAE/C,IAAI5E,GAAG,CAAC+D,MAAR,EAAgB;MACd,OAAO,CAAC,CAAC/D,GAAG,CAAC+D,MAAJ,CAAWG,MAApB;IACD;;IAED,IAAIvD,eAAA,CAAEgD,aAAF,CAAgB3D,GAAG,CAAC8D,GAApB,CAAJ,EAA8B;MAC5B,OAAOnD,eAAA,CAAEyD,QAAF,CAAWpE,GAAG,CAACX,SAAf,KAA6BW,GAAG,CAACX,SAAJ,IAAiB,GAArD;IACD;;IAED,OAAO,KAAP;EACD;;EACD,OAAOW,GAAG,CAACd,WAAJ,CAAgB0F,IAAhB,KAAyBI,IAAI,CAACJ,IAArC;AACD;;AAQD,SAAST,0BAAT,CAAoCrE,IAApC,EAA0CF,KAAK,GAAG,EAAlD,EAAsD;EAGpD,MAAMiB,OAAO,GAAG,CAACjB,KAAK,IAAI,EAAV,EAAciB,OAAd,IAAyBjB,KAAzB,IAAkC,EAAlD;;EACA,IAAIE,IAAI,KAAKS,YAAY,CAACT,IAAb,EAAT,IAAgCyE,kBAAkB,CAACzE,IAAD,CAAtD,EAA8D;IAC5DnB,UAAU,CAACsG,KAAX,CAAkB,6BAA4BnF,IAAK,OAAMyE,kBAAkB,CAACzE,IAAD,CAAlB,CAAyB8E,IAAK,EAAvF;IACA,OAAO,IAAIL,kBAAkB,CAACzE,IAAD,CAAtB,CAA6Be,OAA7B,CAAP;EACD;;EACDlC,UAAU,CAACsG,KAAX,CAAkB,6BAA4BnF,IAAK,kBAAnD;EACA,OAAO,IAAIS,YAAJ,CAAiBM,OAAjB,CAAP;AACD;;AASD,SAASwD,oBAAT,CAA8BvE,IAA9B,EAAoCe,OAApC,EAA6CnB,UAAU,GAAG,IAA1D,EAAgE;EAC9D,IAAII,IAAI,IAAI4E,eAAe,CAAC5E,IAAI,CAACoF,WAAL,EAAD,CAA3B,EAAiD;IAC/CpG,MAAM,CAACmG,KAAP,CAAc,2BAA0BnF,IAAK,QAAO4E,eAAe,CAAC5E,IAAI,CAACoF,WAAL,EAAD,CAAf,CAAoCN,IAAK,EAA7F;IACA,MAAMO,WAAW,GAAG,IAAIT,eAAe,CAAC5E,IAAI,CAACoF,WAAL,EAAD,CAAnB,CAAwCrE,OAAxC,CAApB;IACAsE,WAAW,CAACzF,UAAZ,GAAyBA,UAAzB;IACA,OAAOyF,WAAP;EACD;;EACDrG,MAAM,CAACmG,KAAP,CAAc,2BAA0BnF,IAAK,mBAA7C;EACA,MAAMqF,WAAW,GAAG,IAAI5E,YAAJ,CAAiBM,OAAjB,CAApB;EACAsE,WAAW,CAACzF,UAAZ,GAAyBA,UAAzB;EACA,OAAOyF,WAAP;AACD;;AAOD,SAASC,eAAT,CAAyBpF,GAAzB,EAA8B;EAC5B,OAAO,eAAeA,GAAtB;AACD;;AAMD,SAASqF,sBAAT,CAAgCrF,GAAhC,EAAqC;EACnC,IAAIuD,UAAJ;EAGA,IAAI+B,cAAJ;;EAEA,IAAI,CAACF,eAAe,CAACpF,GAAD,CAApB,EAA2B;IACzBA,GAAG,GAAGyD,aAAA,CAAKQ,QAAL,CAAcjE,GAAG,CAACkE,MAAlB,IAEFC,0BAA0B,CAACnE,GAAG,CAACkE,MAAL,EAAalE,GAAG,CAACJ,KAAjB,CAFxB,GAGF,IAAI0E,MAAM,CAAC/D,YAAX,CAAwBP,GAAG,CAACa,OAA5B,CAHJ;EAID;;EAED,IAAIkE,WAAW,CAAC/E,GAAD,EAAMsE,MAAM,CAACvB,kBAAb,CAAf,EAAiD;IAE/CjE,MAAM,CAACmG,KAAP,CAAc,mBAAkBjF,GAAI,EAApC;IACAsF,cAAc,GAAGvC,kBAAkB,CAACzD,KAAnB,EAAjB;EACD,CAJD,MAIO;IACLgG,cAAc,GAAGtF,GAAG,CAACV,KAArB;EACD;;EAEDiE,UAAU,GAAGvD,GAAG,CAACX,SAAjB;;EAEA,IAAI,CAACiG,cAAL,EAAqB;IACnBA,cAAc,GAAG/E,YAAY,CAACjB,KAAb,EAAjB;EACD;;EAED,IAAIiG,WAAW,GAAG;IAChB3F,KAAK,EAAE;MACLN,KAAK,EAAEgG,cADF;MAELzE,OAAO,EAAEb,GAAG,CAACa,OAFR;MAGLnB,UAAU,EAAEM,GAAG,CAACN,UAAJ,IAAkBM,GAAG,CAACL;IAH7B;EADS,CAAlB;EAOA,OAAO,CAAC4D,UAAD,EAAagC,WAAb,CAAP;AACD;;AAMD,SAASC,yBAAT,CAAmCxF,GAAnC,EAAwC;EACtC,IAAI2E,cAAc,CAAC3E,GAAD,CAAlB,EAAyB;IACvBA,GAAG,GAAG,IAAIsE,MAAM,CAAC/D,YAAX,CAAwBP,GAAxB,CAAN;EACD;;EAED,IAAIuD,UAAU,GAAGhE,4BAAA,CAAgBiB,qBAAjC;EAGA,IAAI+E,WAAW,GAAG;IAChBrB,MAAM,EAAElE,GAAG,CAACZ,UADI;IAEhBQ,KAAK,EAAE;MACLiB,OAAO,EAAEb,GAAG,CAACa;IADR;EAFS,CAAlB;;EAOA,IAAIkE,WAAW,CAAC/E,GAAD,EAAMsE,MAAM,CAACvB,kBAAb,CAAf,EAAiD;IAE/CpE,UAAU,CAACsG,KAAX,CAAkB,mBAAkBjF,GAAI,EAAxC;IACAuD,UAAU,GAAGhE,4BAAA,CAAgBC,WAA7B;IACA+F,WAAW,GAAGvF,GAAG,CAACa,OAAlB;EACD,CALD,MAKO,IACLkE,WAAW,CAAC/E,GAAD,EAAMsE,MAAM,CAAC1B,sBAAb,CAAX,IACAmC,WAAW,CAAC/E,GAAD,EAAMsE,MAAM,CAACzB,mBAAb,CAFN,EAGL;IAEAU,UAAU,GAAGhE,4BAAA,CAAgBkG,eAA7B;EACD,CANM,MAMA,IAAIV,WAAW,CAAC/E,GAAD,EAAMsE,MAAM,CAACzE,iBAAb,CAAf,EAAgD;IAErD0D,UAAU,GAAGhE,4BAAA,CAAgBQ,SAA7B;EACD;;EAED,OAAO,CAACwD,UAAD,EAAagC,WAAb,CAAP;AACD"}
+    if (isUnknownError(err)) {
+        err = new errors.UnknownError(err);
+    }
+    // MJSONWP errors are usually 500 status code so set it to that by default
+    let httpStatus = http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR;
+    /** @type {HttpResultBody} */
+    let httpResBody = {
+        status: err.jsonwpCode,
+        value: {
+            message: err.message,
+        },
+    };
+    if (isErrorType(err, errors.BadParametersError)) {
+        // respond with a 400 if we have bad parameters
+        mjsonwpLog.debug(`Bad parameters: ${err}`);
+        httpStatus = http_status_codes_1.StatusCodes.BAD_REQUEST;
+        httpResBody = err.message;
+    }
+    else if (isErrorType(err, errors.NotYetImplementedError) ||
+        isErrorType(err, errors.NotImplementedError)) {
+        // respond with a 501 if the method is not implemented
+        httpStatus = http_status_codes_1.StatusCodes.NOT_IMPLEMENTED;
+    }
+    else if (isErrorType(err, errors.NoSuchDriverError)) {
+        // respond with a 404 if there is no driver for the session
+        httpStatus = http_status_codes_1.StatusCodes.NOT_FOUND;
+    }
+    return [httpStatus, httpResBody];
+}
+exports.getResponseForJsonwpError = getResponseForJsonwpError;
+/**
+ * @typedef { string | {value: HttpResultBodyValue, status?: number } } HttpResultBody
+ */
+/**
+ * @typedef HttpResultBodyValue
+ * @property {string} [message]
+ * @property {string|Error} [error]
+ * @property {string} [stacktrace]
+ */
+/**
+ * @typedef MJSONWPError
+ * @property {number} status
+ * @property {string|object} value
+ * @property {string} message
+ */
+//# sourceMappingURL=errors.js.map