joenilson / residentes

	(function() {

		Object.defineProperty(Element.prototype, "textContent",

			{

				get: function() {

					return innerText.get.call(this);

				},

				set: function(s) {

					return innerText.set.call(this, s);

				}

			}

		);

	})();

}

// isArray polyfill for ie8

if(!Array.isArray) {

    return Object.prototype.toString.call(arg) === '[object Array]';

  };

};/**

 * @license wysihtml5x v0.4.13

 * https://github.com/Edicy/wysihtml5

 *

 * Author: Christopher Blum (https://github.com/tiff)

 * Secondary author of extended features: Oliver Pulges (https://github.com/pulges)

 *

 * Copyright (C) 2012 XING AG

 * Licensed under the MIT license (MIT)

 *

 */

var wysihtml5 = {

  version: "0.4.13",

  // namespaces

  commands:   {},

  dom:        {},

  quirks:     {},

  toolbar:    {},

  lang:       {},

  selection:  {},

  views:      {},

  INVISIBLE_SPACE: "\uFEFF",

  EMPTY_FUNCTION: function() {},

  ELEMENT_NODE: 1,

  TEXT_NODE:    3,

  BACKSPACE_KEY:  8,

  ENTER_KEY:      13,

  ESCAPE_KEY:     27,

  SPACE_KEY:      32,

  DELETE_KEY:     46

};

;/**

 * Rangy, a cross-browser JavaScript range and selection library

 * http://code.google.com/p/rangy/

 *

 * Copyright 2014, Tim Down

 * Licensed under the MIT license.

 * Version: 1.3alpha.20140804

 * Build date: 4 August 2014

 */

(function(factory, global) {

        // AMD. Register as an anonymous module.

        define(factory);

/*

    TODO: look into this properly.

    } else if (typeof exports == "object") {

        // Node/CommonJS style for Browserify

        module.exports = factory;

*/

    } else {

        // No AMD or CommonJS support so we place Rangy in a global variable

        global.rangy = factory();

    }

})(function() {

    var OBJECT = "object", FUNCTION = "function", UNDEFINED = "undefined";

    // Minimal set of properties required for DOM Level 2 Range compliance. Comparison constants such as START_TO_START

    // are omitted because ranges in KHTML do not have them but otherwise work perfectly well. See issue 113.

    var domRangeProperties = ["startContainer", "startOffset", "endContainer", "endOffset", "collapsed",

        "commonAncestorContainer"];

    // Minimal set of methods required for DOM Level 2 Range compliance

    var domRangeMethods = ["setStart", "setStartBefore", "setStartAfter", "setEnd", "setEndBefore",

        "setEndAfter", "collapse", "selectNode", "selectNodeContents", "compareBoundaryPoints", "deleteContents",

        "extractContents", "cloneContents", "insertNode", "surroundContents", "cloneRange", "toString", "detach"];

    var textRangeProperties = ["boundingHeight", "boundingLeft", "boundingTop", "boundingWidth", "htmlText", "text"];

    // Subset of TextRange's full set of methods that we're interested in

    var textRangeMethods = ["collapse", "compareEndPoints", "duplicate", "moveToElementText", "parentElement", "select",

        "setEndPoint", "getBoundingClientRect"];

    /*----------------------------------------------------------------------------------------------------------------*/

    // Trio of functions taken from Peter Michaux's article:

    // http://peter.michaux.ca/articles/feature-detection-state-of-the-art-browser-scripting

    function isHostMethod(o, p) {

        var t = typeof o[p];

        return t == FUNCTION || (!!(t == OBJECT && o[p])) || t == "unknown";

    }

    function isHostObject(o, p) {

        return !!(typeof o[p] == OBJECT && o[p]);

    }

    function isHostProperty(o, p) {

        return typeof o[p] != UNDEFINED;

    }

    // Creates a convenience function to save verbose repeated calls to tests functions

    function createMultiplePropertyTest(testFunc) {

        return function(o, props) {

            var i = props.length;

            while (i--) {

                if (!testFunc(o, props[i])) {

                    return false;

                }

            }

            return true;

        };

    }

    // Next trio of functions are a convenience to save verbose repeated calls to previous two functions

    var areHostMethods = createMultiplePropertyTest(isHostMethod);

    var areHostObjects = createMultiplePropertyTest(isHostObject);

    var areHostProperties = createMultiplePropertyTest(isHostProperty);

    function isTextRange(range) {

        return range && areHostMethods(range, textRangeMethods) && areHostProperties(range, textRangeProperties);

    }

    function getBody(doc) {

        return isHostObject(doc, "body") ? doc.body : doc.getElementsByTagName("body")[0];

    }

    var modules = {};

    var api = {

        version: "1.3alpha.20140804",

        initialized: false,

        supported: true,

        util: {

            isHostMethod: isHostMethod,

            isHostObject: isHostObject,

            isHostProperty: isHostProperty,

            areHostMethods: areHostMethods,

            areHostObjects: areHostObjects,

            areHostProperties: areHostProperties,

            isTextRange: isTextRange,

            getBody: getBody

        },

        features: {},

        modules: modules,

        config: {

            alertOnFail: true,

            alertOnWarn: false,

            preferTextRange: false,

        }

    };

    function consoleLog(msg) {

        if (isHostObject(window, "console") && isHostMethod(window.console, "log")) {

            window.console.log(msg);

        }

    }

    function alertOrLog(msg, shouldAlert) {

        if (shouldAlert) {

            window.alert(msg);

        } else  {

            consoleLog(msg);

        }

    }

    function fail(reason) {

        api.initialized = true;

        api.supported = false;

        alertOrLog("Rangy is not supported on this page in your browser. Reason: " + reason, api.config.alertOnFail);

    }

    api.fail = fail;

    function warn(msg) {

        alertOrLog("Rangy warning: " + msg, api.config.alertOnWarn);

    }

    api.warn = warn;

    // Add utility extend() method

    if ({}.hasOwnProperty) {

        api.util.extend = function(obj, props, deep) {

            var o, p;

            for (var i in props) {

                if (props.hasOwnProperty(i)) {

                    o = obj[i];

                    p = props[i];

                    if (deep && o !== null && typeof o == "object" && p !== null && typeof p == "object") {

                        api.util.extend(o, p, true);

                    }

                    obj[i] = p;

                }

            }

            // Special case for toString, which does not show up in for...in loops in IE <= 8

            if (props.hasOwnProperty("toString")) {

                obj.toString = props.toString;

            }

            return obj;

        };

    } else {

        fail("hasOwnProperty not supported");

    }

    // Test whether Array.prototype.slice can be relied on for NodeLists and use an alternative toArray() if not

    (function() {

        var el = document.createElement("div");

        el.appendChild(document.createElement("span"));

        var slice = [].slice;

        var toArray;

        try {

                toArray = function(arrayLike) {

                    return slice.call(arrayLike, 0);

                };

            }

        if (!toArray) {

            toArray = function(arrayLike) {

                var arr = [];

                for (var i = 0, len = arrayLike.length; i < len; ++i) {

                    arr[i] = arrayLike[i];

                }

                return arr;

            };

        }

        api.util.toArray = toArray;

    })();

    // Very simple event handler wrapper function that doesn't attempt to solve issues such as "this" handling or

    // normalization of event properties

    var addListener;

    if (isHostMethod(document, "addEventListener")) {

        addListener = function(obj, eventType, listener) {

            obj.addEventListener(eventType, listener, false);

        };

    } else if (isHostMethod(document, "attachEvent")) {

        addListener = function(obj, eventType, listener) {

            obj.attachEvent("on" + eventType, listener);

        };

    } else {

        fail("Document does not have required addEventListener or attachEvent method");

    }

    var initListeners = [];

    function getErrorDesc(ex) {

        return ex.message || ex.description || String(ex);

    }

    // Initialization

    function init() {

        if (api.initialized) {

            return;

        }

        var testRange;

        var implementsDomRange = false, implementsTextRange = false;

        // First, perform basic feature tests

        if (isHostMethod(document, "createRange")) {

            testRange = document.createRange();

            if (areHostMethods(testRange, domRangeMethods) && areHostProperties(testRange, domRangeProperties)) {

                implementsDomRange = true;

            }

        }

        var body = getBody(document);

        if (!body || body.nodeName.toLowerCase() != "body") {

            fail("No body element found");

            return;

        }

        if (body && isHostMethod(body, "createTextRange")) {

            testRange = body.createTextRange();

            if (isTextRange(testRange)) {

                implementsTextRange = true;

            }

        }

        if (!implementsDomRange && !implementsTextRange) {

            fail("Neither Range nor TextRange are available");

            return;

        }

        api.initialized = true;

        api.features = {

            implementsDomRange: implementsDomRange,

            implementsTextRange: implementsTextRange

        };

        // Initialize modules

        var module, errorMessage;

            if ( (module = modules[moduleName]) instanceof Module ) {

                module.init(module, api);

            }

        }

        // Call init listeners

        for (var i = 0, len = initListeners.length; i < len; ++i) {

            try {

                initListeners[i](api);

            } catch (ex) {

                errorMessage = "Rangy init listener threw an exception. Continuing. Detail: " + getErrorDesc(ex);

                consoleLog(errorMessage);

            }

        }

    }

    // Allow external scripts to initialize this library in case it's loaded after the document has loaded

    api.init = init;

    // Execute listener immediately if already initialized

    api.addInitListener = function(listener) {

        if (api.initialized) {

            listener(api);

        } else {

            initListeners.push(listener);

        }

    };

    var shimListeners = [];

    api.addShimListener = function(listener) {

        shimListeners.push(listener);

    };

    function shim(win) {

        win = win || window;

        init();

        // Notify listeners

        for (var i = 0, len = shimListeners.length; i < len; ++i) {

            shimListeners[i](win);

        }

    }

    api.shim = api.createMissingNativeApi = shim;

    function Module(name, dependencies, initializer) {

        this.name = name;

        this.dependencies = dependencies;

        this.initialized = false;

        this.supported = false;

        this.initializer = initializer;

    }

    Module.prototype = {

        init: function() {

            var requiredModuleNames = this.dependencies || [];

            for (var i = 0, len = requiredModuleNames.length, requiredModule, moduleName; i < len; ++i) {

                moduleName = requiredModuleNames[i];

                requiredModule = modules[moduleName];

                if (!requiredModule || !(requiredModule instanceof Module)) {

                    throw new Error("required module '" + moduleName + "' not found");

                }

                requiredModule.init();

                if (!requiredModule.supported) {

                    throw new Error("required module '" + moduleName + "' not supported");

                }

            }

            // Now run initializer

            this.initializer(this);

        },

        fail: function(reason) {

            this.initialized = true;

            this.supported = false;

            throw new Error("Module '" + this.name + "' failed to load: " + reason);

        },

        warn: function(msg) {

            api.warn("Module " + this.name + ": " + msg);

        },

        deprecationNotice: function(deprecated, replacement) {

            api.warn("DEPRECATED: " + deprecated + " in module " + this.name + "is deprecated. Please use " +

                replacement + " instead");

        },

        createError: function(msg) {

            return new Error("Error in Rangy " + this.name + " module: " + msg);

        }

    };

    function createModule(isCore, name, dependencies, initFunc) {

        var newModule = new Module(name, dependencies, function(module) {

            if (!module.initialized) {

                module.initialized = true;

                try {

                    initFunc(api, module);

                    module.supported = true;

                } catch (ex) {

                    var errorMessage = "Module '" + name + "' failed to load: " + getErrorDesc(ex);

                    consoleLog(errorMessage);

                }

            }

        });

        modules[name] = newModule;

    }

    api.createModule = function(name) {

        // Allow 2 or 3 arguments (second argument is an optional array of dependencies)

        var initFunc, dependencies;

        if (arguments.length == 2) {

            initFunc = arguments[1];

            dependencies = [];

        } else {

            initFunc = arguments[2];

            dependencies = arguments[1];

        }

        var module = createModule(false, name, dependencies, initFunc);

        // Initialize the module immediately if the core is already initialized

        if (api.initialized) {

            module.init();

        }

    };

    api.createCoreModule = function(name, dependencies, initFunc) {

        createModule(true, name, dependencies, initFunc);

    };

    /*----------------------------------------------------------------------------------------------------------------*/

    // Ensure rangy.rangePrototype and rangy.selectionPrototype are available immediately

    function RangePrototype() {}

    api.RangePrototype = RangePrototype;

    api.rangePrototype = new RangePrototype();

    function SelectionPrototype() {}

    api.selectionPrototype = new SelectionPrototype();

    /*----------------------------------------------------------------------------------------------------------------*/

    // Wait for document to load before running tests

    var docReady = false;

        if (!docReady) {

            docReady = true;

            if (!api.initialized && api.config.autoInitialize) {

                init();

            }

        }

    };

    // Test whether we have window and document objects that we will need

    if (typeof window == UNDEFINED) {

        fail("No window found");

    }

    if (typeof document == UNDEFINED) {

        fail("No document found");

    }

    if (isHostMethod(document, "addEventListener")) {

        document.addEventListener("DOMContentLoaded", loadHandler, false);

    }

    // Add a fallback in case the DOMContentLoaded event isn't supported

    addListener(window, "load", loadHandler);

    /*----------------------------------------------------------------------------------------------------------------*/

    // DOM utility methods used by Rangy

    api.createCoreModule("DomUtil", [], function(api, module) {

        var UNDEF = "undefined";

        var util = api.util;

        // Perform feature tests

        if (!util.areHostMethods(document, ["createDocumentFragment", "createElement", "createTextNode"])) {

            module.fail("document missing a Node creation method");

        }

        if (!util.isHostMethod(document, "getElementsByTagName")) {

            module.fail("document missing getElementsByTagName method");

        }

        var el = document.createElement("div");

        if (!util.areHostMethods(el, ["insertBefore", "appendChild", "cloneNode"] ||

                !util.areHostObjects(el, ["previousSibling", "nextSibling", "childNodes", "parentNode"]))) {

            module.fail("Incomplete Element implementation");

        }

        // innerHTML is required for Range's createContextualFragment method

        if (!util.isHostProperty(el, "innerHTML")) {

            module.fail("Element is missing innerHTML property");

        }

        var textNode = document.createTextNode("test");

        if (!util.areHostMethods(textNode, ["splitText", "deleteData", "insertData", "appendData", "cloneNode"] ||

                !util.areHostObjects(el, ["previousSibling", "nextSibling", "childNodes", "parentNode"]) ||

                !util.areHostProperties(textNode, ["data"]))) {

            module.fail("Incomplete Text Node implementation");

        }

        /*----------------------------------------------------------------------------------------------------------------*/

        // Removed use of indexOf because of a bizarre bug in Opera that is thrown in one of the Acid3 tests. I haven't been

        // able to replicate it outside of the test. The bug is that indexOf returns -1 when called on an Array that

        // contains just the document as a single element and the value searched for is the document.

        var arrayContains = /*Array.prototype.indexOf ?

            function(arr, val) {

                return arr.indexOf(val) > -1;

            }:*/

            function(arr, val) {

                var i = arr.length;

                while (i--) {

                    if (arr[i] === val) {

                        return true;

                    }

                }

                return false;

            };

        // Opera 11 puts HTML elements in the null namespace, it seems, and IE 7 has undefined namespaceURI

        function isHtmlNamespace(node) {

            var ns;

            return typeof node.namespaceURI == UNDEF || ((ns = node.namespaceURI) === null || ns == "http://www.w3.org/1999/xhtml");

        }

        function parentElement(node) {

            var parent = node.parentNode;

        }

        function getNodeIndex(node) {

            var i = 0;

            while( (node = node.previousSibling) ) {

                ++i;

            }

            return i;

        }

        function getNodeLength(node) {

            switch (node.nodeType) {

                case 7:

                case 10:

                    return 0;

                case 3:

                case 8:

                    return node.length;

                default:

                    return node.childNodes.length;

            }

        }

        function getCommonAncestor(node1, node2) {

            var ancestors = [], n;

            for (n = node1; n; n = n.parentNode) {

                ancestors.push(n);

            }

            for (n = node2; n; n = n.parentNode) {

                if (arrayContains(ancestors, n)) {

                    return n;

                }

            }

            return null;

        }

        function isAncestorOf(ancestor, descendant, selfIsAncestor) {

            var n = selfIsAncestor ? descendant : descendant.parentNode;

            while (n) {

                if (n === ancestor) {

                    return true;

                    n = n.parentNode;

                }

            }

            return false;

        }

        function isOrIsAncestorOf(ancestor, descendant) {

            return isAncestorOf(ancestor, descendant, true);

        }

        function getClosestAncestorIn(node, ancestor, selfIsAncestor) {

            var p, n = selfIsAncestor ? node : node.parentNode;

            while (n) {

                p = n.parentNode;

                if (p === ancestor) {

                    return n;

                }

                n = p;

            }

            return null;

        }

        function isCharacterDataNode(node) {

            var t = node.nodeType;

            return t == 3 || t == 4 || t == 8 ; // Text, CDataSection or Comment

        }

        function isTextOrCommentNode(node) {

            if (!node) {

                return false;

            }

            var t = node.nodeType;

            return t == 3 || t == 8 ; // Text or Comment

        }

        function insertAfter(node, precedingNode) {

            var nextNode = precedingNode.nextSibling, parent = precedingNode.parentNode;

            if (nextNode) {

                parent.insertBefore(node, nextNode);

            } else {

                parent.appendChild(node);

            }

            return node;

        }

        // Note that we cannot use splitText() because it is bugridden in IE 9.

        function splitDataNode(node, index, positionsToPreserve) {

            var newNode = node.cloneNode(false);

            newNode.deleteData(0, index);

            node.deleteData(index, node.length - index);

            insertAfter(newNode, node);

            // Preserve positions

            if (positionsToPreserve) {

                for (var i = 0, position; position = positionsToPreserve[i++]; ) {

                    // Handle case where position was inside the portion of node after the split point

                    if (position.node == node && position.offset > index) {

                        position.node = newNode;

                        position.offset -= index;

                    }

                    // Handle the case where the position is a node offset within node's parent

                    else if (position.node == node.parentNode && position.offset > getNodeIndex(node)) {

                        ++position.offset;

                    }

                }

            }

            return newNode;

        }

        function getDocument(node) {

            if (node.nodeType == 9) {

                return node;

            } else if (typeof node.ownerDocument != UNDEF) {

                return node.ownerDocument;

            } else if (typeof node.document != UNDEF) {

                return node.document;

            } else if (node.parentNode) {

                return getDocument(node.parentNode);

            } else {

                throw module.createError("getDocument: no document found for node");

            }

        }

        function getWindow(node) {

            var doc = getDocument(node);

            if (typeof doc.defaultView != UNDEF) {

                return doc.defaultView;

            } else if (typeof doc.parentWindow != UNDEF) {

                return doc.parentWindow;

            } else {

                throw module.createError("Cannot get a window object for node");

            }

        }

        function getIframeDocument(iframeEl) {

            if (typeof iframeEl.contentDocument != UNDEF) {

                return iframeEl.contentDocument;

            } else if (typeof iframeEl.contentWindow != UNDEF) {

                return iframeEl.contentWindow.document;

            } else {

                throw module.createError("getIframeDocument: No Document object found for iframe element");

            }

        }

        function getIframeWindow(iframeEl) {

            if (typeof iframeEl.contentWindow != UNDEF) {

                return iframeEl.contentWindow;

            } else if (typeof iframeEl.contentDocument != UNDEF) {

                return iframeEl.contentDocument.defaultView;

            } else {

                throw module.createError("getIframeWindow: No Window object found for iframe element");

            }

        }

        // This looks bad. Is it worth it?

        function isWindow(obj) {

            return obj && util.isHostMethod(obj, "setTimeout") && util.isHostObject(obj, "document");

        }

        function getContentDocument(obj, module, methodName) {

            var doc;

            if (!obj) {

                doc = document;

            }

            // Test if a DOM node has been passed and obtain a document object for it if so

            else if (util.isHostProperty(obj, "nodeType")) {

                    getIframeDocument(obj) : getDocument(obj);

            }

            // Test if the doc parameter appears to be a Window object

            else if (isWindow(obj)) {

                doc = obj.document;

            }

            if (!doc) {

                throw module.createError(methodName + "(): Parameter must be a Window object or DOM node");

            }

            return doc;

        }

        function getRootContainer(node) {

            var parent;

            while ( (parent = node.parentNode) ) {

                node = parent;

            }

            return node;

        }

        function comparePoints(nodeA, offsetA, nodeB, offsetB) {

            // See http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Comparing

            var nodeC, root, childA, childB, n;