casperjs 1.0.0.RC1

data/modules/cli.js

@@ -0,0 +1,138 @@
+/*!
+ * Casper is a navigation utility for PhantomJS.
+ *
+ * Documentation: http://casperjs.org/
+ * Repository:    http://github.com/n1k0/casperjs
+ *
+ * Copyright (c) 2011-2012 Nicolas Perriault
+ *
+ * Part of source code is Copyright Joyent, Inc. and other Node contributors.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/*global CasperError console exports phantom require*/
+
+var system = require('system');
+var utils = require('utils');
+
+/**
+ * Extracts, normalize ad organize PhantomJS CLI arguments in a dedicated
+ * Object.
+ *
+ * @param  array  phantomArgs  system.args value
+ * @return Object
+ */
+exports.parse = function parse(phantomArgs) {
+    "use strict";
+    var extract = {
+        args: [],
+        options: {},
+        raw: {
+            args: [],
+            options: {}
+        },
+        drop: function drop(what) {
+            if (utils.isNumber(what)) {
+                // deleting an arg by its position
+                this.args = this.args.filter(function _filter(arg, index) {
+                    return index !== what;
+                });
+            } else if (utils.isString(what)) {
+                // deleting an arg by its value
+                this.args = this.args.filter(function _filter(arg) {
+                    return arg !== what;
+                });
+                // deleting an option by its name (key)
+                var self = this;
+                Object.keys(this.options).forEach(function _forEach(option) {
+                    if (option === what) {
+                        delete self.options[what];
+                    }
+                });
+            } else {
+                throw new CasperError("cannot drop argument of type " + typeof what);
+            }
+        },
+        has: function has(what) {
+            if (utils.isNumber(what)) {
+                return what in this.args;
+            } else if (utils.isString(what)) {
+                return what in this.options;
+            } else {
+                throw new CasperError("Unsupported cli arg tester " + typeof what);
+            }
+        },
+        get: function get(what) {
+            if (utils.isNumber(what)) {
+                return this.args[what];
+            } else if (utils.isString(what)) {
+                return this.options[what];
+            } else {
+                throw new CasperError("Unsupported cli arg getter " + typeof what);
+            }
+        }
+    };
+    phantomArgs.forEach(function _forEach(arg) {
+        if (arg.indexOf('--') === 0) {
+            // named option
+            var optionMatch = arg.match(/^--(.*?)=(.*)/i);
+            if (optionMatch) {
+                extract.options[optionMatch[1]] = castArgument(optionMatch[2]);
+                extract.raw.options[optionMatch[1]] = optionMatch[2];
+            } else {
+                // flag
+                var flagMatch = arg.match(/^--(.*)/);
+                if (flagMatch) {
+                    extract.options[flagMatch[1]] = extract.raw.options[flagMatch[1]] = true;
+                }
+            }
+        } else {
+            // positional arg
+            extract.args.push(castArgument(arg));
+            extract.raw.args.push(castArgument(arg));
+        }
+    });
+    extract.raw = utils.mergeObjects(extract.raw, {
+        drop: extract.drop,
+        has: extract.has,
+        get: extract.get
+    });
+    return extract;
+};
+
+/**
+ * Cast a string argument to its typed equivalent.
+ *
+ * @param  String  arg
+ * @return Mixed
+ */
+function castArgument(arg) {
+    "use strict";
+    if (arg.match(/^-?\d+$/)) {
+        return parseInt(arg, 10);
+    } else if (arg.match(/^-?\d+\.\d+$/)) {
+        return parseFloat(arg);
+    } else if (arg.match(/^(true|false)$/i)) {
+        return arg.trim().toLowerCase() === "true" ? true : false;
+    } else {
+        return arg;
+    }
+}

data/modules/clientutils.js

@@ -0,0 +1,595 @@
+/*!
+ * Casper is a navigation utility for PhantomJS.
+ *
+ * Documentation: http://casperjs.org/
+ * Repository:    http://github.com/n1k0/casperjs
+ *
+ * Copyright (c) 2011-2012 Nicolas Perriault
+ *
+ * Part of source code is Copyright Joyent, Inc. and other Node contributors.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/*global console escape exports NodeList window*/
+
+(function(exports) {
+    "use strict";
+
+    exports.create = function create(options) {
+        return new this.ClientUtils(options);
+    };
+
+    /**
+     * Casper client-side helpers.
+     */
+    exports.ClientUtils = function ClientUtils(options) {
+        // private members
+        var BASE64_ENCODE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        var BASE64_DECODE_CHARS = new Array(
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+            52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
+            -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+            15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+            -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+            41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1
+        );
+        var SUPPORTED_SELECTOR_TYPES = ['css', 'xpath'];
+
+        // public members
+        this.options = options || {};
+
+        /**
+         * Clicks on the DOM element behind the provided selector.
+         *
+         * @param  String  selector  A CSS3 selector to the element to click
+         * @return Boolean
+         */
+        this.click = function click(selector) {
+            return this.mouseEvent('click', selector);
+        };
+
+        /**
+         * Decodes a base64 encoded string. Succeeds where window.atob() fails.
+         *
+         * @param  String  str  The base64 encoded contents
+         * @return string
+         */
+        this.decode = function decode(str) {
+            var c1, c2, c3, c4, i = 0, len = str.length, out = "";
+            while (i < len) {
+                do {
+                    c1 = BASE64_DECODE_CHARS[str.charCodeAt(i++) & 0xff];
+                } while (i < len && c1 === -1);
+                if (c1 === -1) {
+                    break;
+                }
+                do {
+                    c2 = BASE64_DECODE_CHARS[str.charCodeAt(i++) & 0xff];
+                } while (i < len && c2 === -1);
+                if (c2 === -1) {
+                    break;
+                }
+                out += String.fromCharCode((c1 << 2) | ((c2 & 0x30) >> 4));
+                do {
+                    c3 = str.charCodeAt(i++) & 0xff;
+                    if (c3 === 61)
+                    return out;
+                    c3 = BASE64_DECODE_CHARS[c3];
+                } while (i < len && c3 === -1);
+                if (c3 === -1) {
+                    break;
+                }
+                out += String.fromCharCode(((c2 & 0XF) << 4) | ((c3 & 0x3C) >> 2));
+                do {
+                    c4 = str.charCodeAt(i++) & 0xff;
+                    if (c4 === 61) {
+                        return out;
+                    }
+                    c4 = BASE64_DECODE_CHARS[c4];
+                } while (i < len && c4 === -1);
+                if (c4 === -1) {
+                    break;
+                }
+                out += String.fromCharCode(((c3 & 0x03) << 6) | c4);
+            }
+            return out;
+        };
+
+        /**
+         * Base64 encodes a string, even binary ones. Succeeds where
+         * window.btoa() fails.
+         *
+         * @param  String  str  The string content to encode
+         * @return string
+         */
+        this.encode = function encode(str) {
+            var out = "", i = 0, len = str.length, c1, c2, c3;
+            while (i < len) {
+                c1 = str.charCodeAt(i++) & 0xff;
+                if (i === len) {
+                    out += BASE64_ENCODE_CHARS.charAt(c1 >> 2);
+                    out += BASE64_ENCODE_CHARS.charAt((c1 & 0x3) << 4);
+                    out += "==";
+                    break;
+                }
+                c2 = str.charCodeAt(i++);
+                if (i === len) {
+                    out += BASE64_ENCODE_CHARS.charAt(c1 >> 2);
+                    out += BASE64_ENCODE_CHARS.charAt(((c1 & 0x3)<< 4) | ((c2 & 0xF0) >> 4));
+                    out += BASE64_ENCODE_CHARS.charAt((c2 & 0xF) << 2);
+                    out += "=";
+                    break;
+                }
+                c3 = str.charCodeAt(i++);
+                out += BASE64_ENCODE_CHARS.charAt(c1 >> 2);
+                out += BASE64_ENCODE_CHARS.charAt(((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4));
+                out += BASE64_ENCODE_CHARS.charAt(((c2 & 0xF) << 2) | ((c3 & 0xC0) >> 6));
+                out += BASE64_ENCODE_CHARS.charAt(c3 & 0x3F);
+            }
+            return out;
+        };
+
+        /**
+         * Checks if a given DOM element exists in remote page.
+         *
+         * @param  String  selector  CSS3 selector
+         * @return Boolean
+         */
+        this.exists = function exists(selector) {
+            try {
+                return this.findAll(selector).length > 0;
+            } catch (e) {
+                return false;
+            }
+        };
+
+        /**
+         * Fetches innerText within the element(s) matching a given CSS3
+         * selector.
+         *
+         * @param  String  selector  A CSS3 selector
+         * @return String
+         */
+        this.fetchText = function fetchText(selector) {
+            var text = '', elements = this.findAll(selector);
+            if (elements && elements.length) {
+                Array.prototype.forEach.call(elements, function _forEach(element) {
+                    text += element.textContent || element.innerText;
+                });
+            }
+            return text;
+        };
+
+        /**
+         * Fills a form with provided field values, and optionnaly submits it.
+         *
+         * @param  HTMLElement|String  form    A form element, or a CSS3 selector to a form element
+         * @param  Object              vals    Field values
+         * @return Object                      An object containing setting result for each field, including file uploads
+         */
+        this.fill = function fill(form, vals) {
+            var out = {
+                errors: [],
+                fields: [],
+                files:  []
+            };
+            if (!(form instanceof HTMLElement) || typeof form === "string") {
+                this.log("attempting to fetch form element from selector: '" + form + "'", "info");
+                try {
+                    form = this.findOne(form);
+                } catch (e) {
+                    if (e.name === "SYNTAX_ERR") {
+                        out.errors.push("invalid form selector provided: '" + form + "'");
+                        return out;
+                    }
+                }
+            }
+            if (!form) {
+                out.errors.push("form not found");
+                return out;
+            }
+            for (var name in vals) {
+                if (!vals.hasOwnProperty(name)) {
+                    continue;
+                }
+                var field = this.findAll('[name="' + name + '"]', form);
+                var value = vals[name];
+                if (!field) {
+                    out.errors.push('no field named "' + name + '" in form');
+                    continue;
+                }
+                try {
+                    out.fields[name] = this.setField(field, value);
+                } catch (err) {
+                    if (err.name === "FileUploadError") {
+                        out.files.push({
+                            name: name,
+                            path: err.path
+                        });
+                    } else {
+                        this.log(err, "error");
+                        throw err;
+                    }
+                }
+            }
+            return out;
+        };
+
+        /**
+         * Finds all DOM elements matching by the provided selector.
+         *
+         * @param  String            selector  CSS3 selector
+         * @param  HTMLElement|null  scope     Element to search child elements within
+         * @return NodeList|undefined
+         */
+        this.findAll = function findAll(selector, scope) {
+            scope = scope || document;
+            try {
+                var pSelector = this.processSelector(selector);
+                if (pSelector.type === 'xpath') {
+                    return this.getElementsByXPath(pSelector.path);
+                } else {
+                    return scope.querySelectorAll(pSelector.path);
+                }
+            } catch (e) {
+                this.log('findAll(): invalid selector provided "' + selector + '":' + e, "error");
+            }
+        };
+
+        /**
+         * Finds a DOM element by the provided selector.
+         *
+         * @param  String            selector  CSS3 selector
+         * @param  HTMLElement|null  scope     Element to search child elements within
+         * @return HTMLElement|undefined
+         */
+        this.findOne = function findOne(selector, scope) {
+            scope = scope || document;
+            try {
+                var pSelector = this.processSelector(selector);
+                if (pSelector.type === 'xpath') {
+                    return this.getElementByXPath(pSelector.path);
+                } else {
+                    return scope.querySelector(pSelector.path);
+                }
+            } catch (e) {
+                this.log('findOne(): invalid selector provided "' + selector + '":' + e, "error");
+            }
+        };
+
+        /**
+         * Downloads a resource behind an url and returns its base64-encoded
+         * contents.
+         *
+         * @param  String  url     The resource url
+         * @param  String  method  The request method, optional (default: GET)
+         * @param  Object  data    The request data, optional
+         * @return String          Base64 contents string
+         */
+        this.getBase64 = function getBase64(url, method, data) {
+            return this.encode(this.getBinary(url, method, data));
+        };
+
+        /**
+         * Retrieves string contents from a binary file behind an url. Silently
+         * fails but log errors.
+         *
+         * @param  String  url
+         * @param  String  method
+         * @param  Object  data
+         * @return string
+         */
+        this.getBinary = function getBinary(url, method, data) {
+            try {
+                var xhr = new XMLHttpRequest(), dataString = "";
+                if (typeof method !== "string" || ["GET", "POST"].indexOf(method.toUpperCase()) === -1) {
+                    method = "GET";
+                } else {
+                    method = method.toUpperCase();
+                }
+                xhr.open(method, url, false);
+                this.log("getBinary(): Using HTTP method: '" + method + "'", "debug");
+                xhr.overrideMimeType("text/plain; charset=x-user-defined");
+                if (method === "POST") {
+                    if (typeof data === "object") {
+                        var dataList = [];
+                        for (var k in data) {
+                            dataList.push(escape(k) + "=" + escape(data[k].toString()));
+                        }
+                        dataString = dataList.join('&');
+                        this.log("getBinary(): Using request data: '" + dataString + "'", "debug");
+                    } else if (typeof data === "string") {
+                        dataString = data;
+                    }
+                    xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
+                }
+                xhr.send(method === "POST" ? dataString : null);
+                return xhr.responseText;
+            } catch (e) {
+                if (e.name === "NETWORK_ERR" && e.code === 101) {
+                    this.log("getBinary(): Unfortunately, casperjs cannot make cross domain ajax requests", "warning");
+                }
+                this.log("getBinary(): Error while fetching " + url + ": " + e, "error");
+                return "";
+            }
+        };
+
+        /**
+         * Retrieves bounding rect coordinates of the HTML element matching the
+         * provided CSS3 selector
+         *
+         * @param  String  selector
+         * @return Object or null
+         */
+        this.getElementBounds = function getElementBounds(selector) {
+            try {
+                var clipRect = this.findOne(selector).getBoundingClientRect();
+                return {
+                    top:    clipRect.top,
+                    left:   clipRect.left,
+                    width:  clipRect.width,
+                    height: clipRect.height
+                };
+            } catch (e) {
+                this.log("Unable to fetch bounds for element " + selector, "warning");
+            }
+        };
+
+        /**
+         * Retrieves a single DOM element matching a given XPath expression.
+         *
+         * @param  String  expression  The XPath expression
+         * @return HTMLElement or null
+         */
+        this.getElementByXPath = function getElementByXPath(expression) {
+            var a = document.evaluate(expression, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+            if (a.snapshotLength > 0) {
+                return a.snapshotItem(0);
+            }
+        };
+
+        /**
+         * Retrieves all DOM elements matching a given XPath expression.
+         *
+         * @param  String  expression  The XPath expression
+         * @return Array
+         */
+        this.getElementsByXPath = function getElementsByXPath(expression) {
+            var nodes = [];
+            var a = document.evaluate(expression, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+            for (var i = 0; i < a.snapshotLength; i++) {
+                nodes.push(a.snapshotItem(i));
+            }
+            return nodes;
+        };
+
+        /**
+         * Logs a message. Will format the message a way CasperJS will be able
+         * to log phantomjs side.
+         *
+         * @param  String  message  The message to log
+         * @param  String  level    The log level
+         */
+        this.log = function log(message, level) {
+            console.log("[casper:" + (level || "debug") + "] " + message);
+        };
+
+        /**
+         * Dispatches a mouse event to the DOM element behind the provided selector.
+         *
+         * @param  String   type     Type of event to dispatch
+         * @param  String  selector  A CSS3 selector to the element to click
+         * @return Boolean
+         */
+        this.mouseEvent = function mouseEvent(type, selector) {
+            var elem = this.findOne(selector);
+            if (!elem) {
+                this.log("mouseEvent(): Couldn't find any element matching '" + selector + "' selector", "error");
+                return false;
+            }
+            var evt = document.createEvent("MouseEvents");
+            evt.initMouseEvent(type, true, true, window, 1, 1, 1, 1, 1, false, false, false, false, 0, elem);
+            // dispatchEvent return value is false if at least one of the event
+            // handlers which handled this event called preventDefault
+            return elem.dispatchEvent(evt);
+        };
+
+        /**
+         * Processes a selector input, either as a string or an object.
+         *
+         * If passed an object, if must be of the form:
+         *
+         *     selectorObject = {
+         *         type: <'css' or 'xpath'>,
+         *         path: <a string>
+         *     }
+         *
+         * @param  String|Object  selector  The selector string or object
+         *
+         * @return an object containing 'type' and 'path' keys
+         */
+        this.processSelector = function processSelector(selector) {
+            var selectorObject = {
+                toString: function toString() {
+                    return this.type + ' selector: ' + this.path;
+                }
+            };
+            if (typeof selector === "string") {
+                // defaults to CSS selector
+                selectorObject.type = "css";
+                selectorObject.path = selector;
+                return selectorObject;
+            } else if (typeof selector === "object") {
+                // validation
+                if (!selector.hasOwnProperty('type') || !selector.hasOwnProperty('path')) {
+                    throw new Error("Incomplete selector object");
+                } else if (SUPPORTED_SELECTOR_TYPES.indexOf(selector.type) === -1) {
+                    throw new Error("Unsupported selector type: " + selector.type);
+                }
+                if (!selector.hasOwnProperty('toString')) {
+                    selector.toString = selectorObject.toString;
+                }
+                return selector;
+            }
+            throw new Error("Unsupported selector type: " + typeof selector);
+        };
+
+        /**
+         * Removes all DOM elements matching a given XPath expression.
+         *
+         * @param  String  expression  The XPath expression
+         * @return Array
+         */
+        this.removeElementsByXPath = function removeElementsByXPath(expression) {
+            var a = document.evaluate(expression, document, null, XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null);
+            for (var i = 0; i < a.snapshotLength; i++) {
+                a.snapshotItem(i).parentNode.removeChild(a.snapshotItem(i));
+            }
+        };
+
+        /**
+         * Sets a field (or a set of fields) value. Fails silently, but log
+         * error messages.
+         *
+         * @param  HTMLElement|NodeList  field  One or more element defining a field
+         * @param  mixed                 value  The field value to set
+         */
+        this.setField = function setField(field, value) {
+            var logValue, fields, out;
+            value = logValue = (value || "");
+            if (field instanceof NodeList) {
+                fields = field;
+                field = fields[0];
+            }
+            if (!field instanceof HTMLElement) {
+                this.log("Invalid field type; only HTMLElement and NodeList are supported", "error");
+            }
+            if (this.options && this.options.safeLogs && field.getAttribute('type') === "password") {
+                // obfuscate password value
+                logValue = new Array(value.length + 1).join("*");
+            }
+            this.log('Set "' + field.getAttribute('name') + '" field value to ' + logValue, "debug");
+            try {
+                field.focus();
+            } catch (e) {
+                this.log("Unable to focus() input field " + field.getAttribute('name') + ": " + e, "warning");
+            }
+            var nodeName = field.nodeName.toLowerCase();
+            switch (nodeName) {
+                case "input":
+                    var type = field.getAttribute('type') || "text";
+                    switch (type.toLowerCase()) {
+                        case "color":
+                        case "date":
+                        case "datetime":
+                        case "datetime-local":
+                        case "email":
+                        case "hidden":
+                        case "month":
+                        case "number":
+                        case "password":
+                        case "range":
+                        case "search":
+                        case "tel":
+                        case "text":
+                        case "time":
+                        case "url":
+                        case "week":
+                            field.value = value;
+                            break;
+                        case "checkbox":
+                            if (fields.length > 1) {
+                                var values = value;
+                                if (!Array.isArray(values)) {
+                                    values = [values];
+                                }
+                                Array.prototype.forEach.call(fields, function _forEach(f) {
+                                    f.checked = values.indexOf(f.value) !== -1 ? true : false;
+                                });
+                            } else {
+                                field.checked = value ? true : false;
+                            }
+                            break;
+                        case "file":
+                            throw {
+                                name:    "FileUploadError",
+                                message: "File field must be filled using page.uploadFile",
+                                path:    value
+                            };
+                        case "radio":
+                            if (fields) {
+                                Array.prototype.forEach.call(fields, function _forEach(e) {
+                                    e.checked = (e.value === value);
+                                });
+                            } else {
+                                out = 'Urovided radio elements are empty';
+                            }
+                            break;
+                        default:
+                            out = "Unsupported input field type: " + type;
+                            break;
+                    }
+                    break;
+                case "select":
+                case "textarea":
+                    field.value = value;
+                    break;
+                default:
+                    out = 'Unsupported field type: ' + nodeName;
+                    break;
+            }
+            // firing the `change` event
+            var changeEvent = document.createEvent("HTMLEvents");
+            changeEvent.initEvent('change', true, true);
+            field.dispatchEvent(changeEvent);
+            // blur the field
+            try {
+                field.blur();
+            } catch (err) {
+                this.log("Unable to blur() input field " + field.getAttribute('name') + ": " + err, "warning");
+            }
+            return out;
+        };
+
+        /**
+         * Checks if a given DOM element is visible in remote page.
+         *
+         * @param  String  selector  CSS3 selector
+         * @return Boolean
+         */
+        this.visible = function visible(selector) {
+            try {
+                var comp,
+                    el = this.findOne(selector);
+
+                if (el) {
+                    comp = window.getComputedStyle(el, null);
+                    return comp.visibility !== 'hidden' && comp.display !== 'none' && el.offsetHeight > 0 && el.offsetWidth > 0;
+                }
+                return false;
+            } catch (e) {
+                return false;
+            }
+        };
+    };
+})(typeof exports === "object" ? exports : window);