social media network

English

_ga_CEP9QLJYWD

csrftoken

_gcl_au

_ga_22ZG6XL68Z

Domain 'listin-diario.disqus.com' uses the commercial generic top-level domain (.com) and includes subdomain 'listin-diario'. The second-level label 'disqus' is 6 characters long holding two vowels versus 4 consonants. Segmentation suggests 4 words: d, is, qu, s. Average segment length settles at 1.5 characters. No strong language cues emerged from the frequency lists.

csrfmiddlewaretoken

username

password

default-src *.facebook.com *.fbcdn.net *.facebook.net 'self' blob:;script-src *.facebook.com *.fbcdn.net *.facebook.net blob: 'self' 'nonce-c3nrwxBQ';style-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob: 'unsafe-inline';connect-src *.facebook.com facebook.com *.fbcdn.net *.facebook.net wss://*.facebook.com:* wss://*.fbcdn.net attachment.fbsbx.com *.cdninstagram.com blob: 'self' data: https://edge-chat.facebook.net https://edge-chat-latest.facebook.net wss://edge-chat-latest.facebook.net wss://edge-chat.facebook.net wss://edge-chat.socialplugin.facebook.net wss://edge-chat-latest.socialplugin.facebook.net https://edge-chat.socialplugin.facebook.net https://edge-chat-latest.socialplugin.facebook.net;font-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;img-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;media-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;child-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;frame-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;manifest-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;object-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;worker-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;block-all-mixed-content;upgrade-insecure-requests;

default-src *.facebook.com *.fbcdn.net *.facebook.net 'self' blob:;script-src *.facebook.com *.fbcdn.net *.facebook.net blob: 'self' 'nonce-c3nrwxBQ';style-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob: 'unsafe-inline';connect-src *.facebook.com facebook.com *.fbcdn.net *.facebook.net wss://*.facebook.com:* wss://*.fbcdn.net attachment.fbsbx.com *.cdninstagram.com blob: 'self' data: https://edge-chat.facebook.net https://edge-chat-latest.facebook.net wss://edge-chat-latest.facebook.net wss://edge-chat.facebook.net wss://edge-chat.socialplugin.facebook.net wss://edge-chat-latest.socialplugin.facebook.net https://edge-chat.socialplugin.facebook.net https://edge-chat-latest.socialplugin.facebook.net;font-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;img-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;media-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;child-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;frame-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;manifest-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;object-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;worker-src *.facebook.com *.fbcdn.net *.facebook.net 'self' data: blob:;block-all-mixed-content;upgrade-insecure-requests;report-uri https://www.facebook.com/csp/reporting/?m=tr_exp&minimize=0;

script-src 'none'; form-action 'none'; frame-src 'none'; report-uri https://csp.withgoogle.com/csp/scaffolding/ascnsrsggc:197:0

script-src 'none'; form-action 'none'; frame-src 'none'; report-uri https://csp.withgoogle.com/csp/scaffolding/ascnsrsggc:165:0

a921868893c5619a021cf80397548d8e4410c55408436fb760ef3fa251ace0cd

c849cdeb7d018cb881cb0d8317158780cf57522b098a4dd6e1698b39db2a42d9

b1388948feedf6e1e425c3dbcae50348d07c400ca3c00ddc2f50fcde374ba11e

5649807295e7ae6c56c55cf90f0ef2f7e6f50228b168b00c7902aaa6a6dd66d7

334555c22851b3a4f2e0dc7be3038ad664270da2594615d6288484976f88f978

0ce1a2c09ca86a263ec13575dca5a867858827803edb2947725cd685f2055805

33cf7bbfefefe7d99930e0ef87025fa0d0d4532efc72cfefb516841b13e83601

5db1da993c2ed44f27b7f31b8a920459181cc50ce9aa77651daaf1916669ee48

6468c054277fb2337fbad32f07777f8a7f74510475a16d23b6f5ae0c5cd3d7f7

3b2d7f5e6efb92b6c4f52c5fc47a8e49da8b130ef980254d650227dc3310f215

f5627ea74eac809576ae16667ed7522b8dff46df48c38d9452dbe2eb208d2eef

25a2decba869c7a32b49c4d3e07024eb599f048d9726e8f067fcb2194ab7a813

ddd27c56494ef10af8e7105502ad103ccf8f2d29157698661f1cc9e7f4d2f5e0

3d8d55c9d7f750294a5f59ec8196e4492ce37548841632d8f4c4efd2d4eb5c8a

Versions of jquery prior to 1.9.0 are vulnerable to Cross-Site Scripting. The load method fails to recognize and remove "<script>" HTML tags that contain a whitespace character, i.e: "</script >", which results in the enclosed script logic to be executed. This allows attackers to execute arbitrary JavaScript in a victim's browser.


## Recommendation

Upgrade to version 1.9.0 or later.

jQuery 1.x and 2.x are End-of-Life and no longer receiving security updates

jQuery before 3.4.0, as used in Drupal, Backdrop CMS, and other products, mishandles jQuery.extend(true, {}, ...) because of Object.prototype pollution

passing HTML containing <option> elements from untrusted sources - even after sanitizing it - to one of jQuery's DOM manipulation methods (i.e. .html(), .append(), and others) may execute untrusted code.

Regex in its jQuery.htmlPrefilter sometimes may introduce XSS

475f2e9c01ca4b7f2ae7b36a77ed3a35586246a86e517e1fa3088f2668e879a6

fd272a2b28c77e6c6d4521ae06ccfba9ee96ec48fefb4ceab15f0ab25a8dec5e

1e5a442f8454245a9ec92f4fd0c6bf851a011bea07f982160dc0c36846dabdd7

9aa6b840d441302d3518aa13857c608e2ccc7cb488040126fba1c8d15f1008b1

557fbc5cbc2876cf63b4f48343a09070cbe0db483f13a759477d36a747bf1daf

18c9db1b52459f530986198aab0fb36b72faebf4d84c09b5a1896419906775c9

c2230239c7907e3c9f6f6417f903fbd5734f84c555943bbcc3abd974985108fc

55fb00b2f28ef206f983a65a05e54da4b823fcf21ed816b82cded5349963e1f8

1713cc28a121a2f6f897067b0b1f54b4bebe1847122e305fa4557d9f1d3c81b4

654179f48d71aefb94fc3c074d27c78942b7bb0d633b77b70e364eb4888013b4

02487ac34920f7a8b237909f0c330d783bceab5503ae091c276e7c021e8d48a2

d53a29bf760442e1b5581dcd18abb3db747dae7a4a82ed63869b2b9a364be4f3

75e384ab2e4b5997cd1d5ebcf49204acab1c6119bd6d170c1c07962e79c1dad5

70287a3f02238d894a087b4d80019e3362135fd4a69d3014b0d81db4bec83c39

Disqus, disqus.com, comments, blog, blogs, discussion

keywords

google

Disqus is a global comment system that improves discussion on websites and connects conversations across the web.

description

viewport

apple-mobile-web-app-capable

MarkMonitor Inc.

GOOGLE.COM

RegistrarSafe, LLC

FACEBOOK.NET

DOUBLECLICK.NET

GoDaddy.com, LLC

DISQUSCDN.COM

DISQUS.COM

Amazon Web Services, LLC

Amazon

Amazon.com, Inc.

Amazon Web Services

Amazon Webservices EC2

AMAZO-CF


//
// shared/foundation.js
//
// This file contains the absolute minimum code necessary in order
// to create a new application in the DISQUS namespace.
//
// You should load this file *before* anything that modifies the DISQUS global.
//

/*jshint browser:true, undef:true, strict:true, expr:true, white:true */
/*global DISQUS:true */

var DISQUS = (function (window, undefined) {
    "use strict";

    var DISQUS = window.DISQUS || {};

    // Exception thrown from DISQUS.assert method on failure
    DISQUS.AssertionError = function (message) {
        this.message = message;
    };

    DISQUS.AssertionError.prototype.toString = function () {
        return 'Assertion Error: ' + (this.message || '[no message]');
    };


    // Raises a DISQUS.AssertionError if value is falsy
    DISQUS.assert = function (value, message, soft) {
        if (value)
            return;

        if (soft)
            window.console && window.console.log("DISQUS assertion failed: " + message);
        else
            throw new DISQUS.AssertionError(message);
    };


    // Functions to clean attached modules (used by define and cleanup)
    var cleanFuncs = [];

    // Attaches a new public interface (module) to the DISQUS namespace.
    // For example, if DISQUS object is { 'a': { 'b': {} } }:
    //
    //   DISQUS.define('a.b.c', function () { return { 'd': 'hello' }; }); will transform it into
    //     -> { 'a': { 'b': { 'c': { 'd' : hello' }}}}
    //
    //   and DISQUS.define('a', function () { return { 'x': 'world' }; }); will transform it into
    //     -> { 'a': { 'b': {}}, 'x': 'world' }
    //
    // Attach modules to DISQUS using only this function.

    DISQUS.define = function (name, fn) {
        /*jshint loopfunc:true */
        if (typeof name === 'function') {
            fn = name;
            name = '';
        }

        var parts = name.split('.');
        var part  = parts.shift();
        var cur   = DISQUS;

        var exports = (fn || function () { return {}; }).call({
            overwrites: function (obj) {
                obj.__overwrites__ = true;
                return obj;
            }
        }, window);

        while (part) {
            cur = (cur[part] ? cur[part] : cur[part] = {});
            part = parts.shift();
        }

        for (var key in exports) {
            if (!exports.hasOwnProperty(key))
                continue;

            /*jshint eqnull:true */
            if (!exports.__overwrites__ && cur[key] !== null) {
                DISQUS.assert(!cur.hasOwnProperty(key),
                              'Unsafe attempt to redefine existing module: ' + key,
                              true /* soft assertion */);
            }

            cur[key] = exports[key];
            cleanFuncs.push(function (cur, key) {
                return function () { delete cur[key]; };
            }(cur, key));
        }
        return cur;
    };


    // Alias for DISQUS.define for the sake of semantics.
    // You should use it when you need to get a reference to another
    // DISQUS module before that module is defined:
    //
    //   var collections = DISQUS.use('lounge.collections');
    //
    // DISQUS.use is a single argument function because we don't
    // want to encourage people to use it instead of DISQUS.define.

    DISQUS.use = function (name) {
        return DISQUS.define(name);
    };

    DISQUS.cleanup = function () {
        for (var i = 0; i < cleanFuncs.length; i++) {
            cleanFuncs[i]();
        }
    };

    return DISQUS;
})(window);

/*jshint expr:true, undef:true, strict:true, white:true, browser:true */
/*global DISQUS:false*/
//
// shared/corefuncs.js
//

DISQUS.define(function (window, undefined) {
    "use strict";

    var DISQUS     = window.DISQUS;
    var document   = window.document;
    var head       = document.getElementsByTagName('head')[0] ||
                     document.body;
    var jobs       = { running: false, timer: null, queue: [] };
    var uid        = 0;

    // Taken from _.uniqueId
    DISQUS.getUid = function (prefix) {
        var id = ++uid + '';
        return prefix ? prefix + id : id;
    };

    /* Defers func() execution until cond() is true */
    DISQUS.defer = function (cond, func) {
        function beat() {
            /*jshint boss:true */
            var queue = jobs.queue;

            if (queue.length === 0) {
                jobs.running = false;
                clearInterval(jobs.timer);
            }

            for (var i = 0, pair; pair = queue[i]; i++) {
                if (pair[0]()) {
                    queue.splice(i--, 1);
                    pair[1]();
                }
            }
        }

        jobs.queue.push([cond, func]);
        beat();

        if (!jobs.running) {
            jobs.running = true;
            jobs.timer = setInterval(beat, 100);
        }
    };

    DISQUS.isOwn = function (obj, key) {
        // The object.hasOwnProperty method fails when the
        // property under consideration is named 'hasOwnProperty'.
        return Object.prototype.hasOwnProperty.call(obj, key);
    };

    DISQUS.isString = function (str) {
        return Object.prototype.toString.call(str) === "[object String]";
    };

    /*
     * Iterates over an object or a collection and calls a callback
     * function with each item as a parameter.
     */
    DISQUS.each = function (collection, callback) {
        var length = collection.length,
            forEach = Array.prototype.forEach;

        if (!isNaN(length)) {
            // Treat collection as an array
            if (forEach) {
                forEach.call(collection, callback);
            } else {
                for (var i = 0; i < length; i++) {
                    callback(collection[i], i, collection);
                }
            }
        } else {
            // Treat collection as an object
            for (var key in collection) {
                if (DISQUS.isOwn(collection, key)) {
                    callback(collection[key], key, collection);
                }
            }
        }
    };

    // Borrowed from underscore
    DISQUS.extend = function (obj) {
        DISQUS.each(Array.prototype.slice.call(arguments, 1), function (source) {
            for (var prop in source) {
                obj[prop] = source[prop];
            }
        });
        return obj;
    };

    DISQUS.serializeArgs = function (params) {
        var pcs = [];
        DISQUS.each(params, function (val, key) {
            if (val !== undefined) {
                pcs.push(key + (val !== null ? '=' + encodeURIComponent(val) : ''));
            }
        });
        return pcs.join('&');
    };

    DISQUS.serialize = function (url, params, nocache) {
        if (params) {
            url += (~url.indexOf('?') ?
                        (url.charAt(url.length - 1) == '&' ? '': '&') : '?');
            url += DISQUS.serializeArgs(params);
        }

        if (nocache) {
            var ncp = {};
            ncp[(new Date()).getTime()] = null;
            return DISQUS.serialize(url, ncp);
        }

        var len = url.length;
        return (url.charAt(len - 1) == "&" ? url.slice(0, len - 1) : url);
    };

    var TIMEOUT_DURATION = 2e4; // 20 seconds
    var addEvent, removeEvent;

    // select the correct event listener function. all of our supported
    // browsers will use one of these
    if ('addEventListener' in window) {
        addEvent = function (node, event, handler) {
            node.addEventListener(event, handler, false);
        };
        removeEvent = function (node, event, handler) {
            node.removeEventListener(event, handler, false);
        };
    }
    else {
        addEvent = function (node, event, handler) {
            node.attachEvent('on' + event, handler);
        };
        removeEvent = function (node, event, handler) {
            node.detachEvent('on' + event, handler);
        };
    }

    DISQUS.require = function (url, params, nocache, success, failure) {
        var script = document.createElement('script');
        var evName = script.addEventListener ? 'load' : 'readystatechange';
        var timeout = null;

        script.src = DISQUS.serialize(url, params, nocache);
        script.async = true;
        script.charset = 'UTF-8';

        function handler(ev) {
            ev = ev || window.event;
            if (!ev.target) {
                ev.target = ev.srcElement;
            }

            if (ev.type != 'load' && !/^(complete|loaded)$/.test(ev.target.readyState)) {
                return; // Not ready yet
            }

            if (success) {
                success();
            }

            if (timeout) {
                clearTimeout(timeout);
            }

            removeEvent(ev.target, evName, handler);
        }

        if (success || failure) {
            addEvent(script, evName, handler);
        }

        if (failure) {
            timeout = setTimeout(function () {
                failure();
            }, TIMEOUT_DURATION);
        }

        head.appendChild(script);
        return DISQUS;
    };

    DISQUS.requireStylesheet = function (url, params, nocache) {
        var link = document.createElement('link');
        link.rel = 'stylesheet';
        link.type = 'text/css';
        link.href = DISQUS.serialize(url, params, nocache);
        head.appendChild(link);
        return DISQUS;
    };

    DISQUS.requireSet = function (urls, nocache, callback) {
        var remaining = urls.length;
        DISQUS.each(urls, function (url) {
            DISQUS.require(url, {}, nocache, function () {
                if (--remaining === 0) { callback(); }
            });
        });
    };

    DISQUS.injectCss = function (css) {
        var style = document.createElement('style');
        style.setAttribute('type', 'text/css');

        // Make inline CSS more readable by splitting each rule onto a separate line
        css = css.replace(/\}/g, "}\n");

        if (window.location.href.match(/^https/))
            css = css.replace(/http:\/\//g, 'https://');

        if (style.styleSheet) { // Internet Explorer only
            style.styleSheet.cssText = css;
        } else {
            style.appendChild(document.createTextNode(css));
        }

        head.appendChild(style);
    };

    DISQUS.isString = function (val) {
        return Object.prototype.toString.call(val) === '[object String]';
    };
});

/*jshint boss:true*/
/*global DISQUS */
DISQUS.define('Events', function (window, undefined) {
    "use strict";

    // Returns a function that will be executed at most one time, no matter how
    // often you call it. Useful for lazy initialization.
    var once = function (func) {
        var ran = false, memo;
        return function () {
            if (ran) return memo;
            ran = true;
            memo = func.apply(this, arguments);
            func = null;
            return memo;
        };
    };
    var has = DISQUS.isOwn;
    var keys = Object.keys || function (obj) {
        if (obj !== Object(obj)) throw new TypeError('Invalid object');
        var keys = [];
        for (var key in obj) if (has(obj, key)) keys[keys.length] = key;
        return keys;
    };
    var slice = [].slice;

    // Backbone.Events
    // ---------------

    // A module that can be mixed in to *any object* in order to provide it with
    // custom events. You may bind with `on` or remove with `off` callback
    // functions to an event; `trigger`-ing an event fires all callbacks in
    // succession.
    //
    // var object = {};
    // _.extend(object, Backbone.Events);
    // object.on('expand', function(){ alert('expanded'); });
    // object.trigger('expand');
    //
    var Events = {

        // Bind an event to a `callback` function. Passing `"all"` will bind
        // the callback to all events fired.
        on: function (name, callback, context) {
            if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
            this._events = this._events || {};
            var events = this._events[name] || (this._events[name] = []);
            events.push({callback: callback, context: context, ctx: context || this});
            return this;
        },

        // Bind an event to only be triggered a single time. After the first time
        // the callback is invoked, it will be removed.
        once: function (name, callback, context) {
            if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
            var self = this;
            var onced = once(function () {
                self.off(name, onced);
                callback.apply(this, arguments);
            });
            onced._callback = callback;
            return this.on(name, onced, context);
        },

        // Remove one or many callbacks. If `context` is null, removes all
        // callbacks with that function. If `callback` is null, removes all
        // callbacks for the event. If `name` is null, removes all bound
        // callbacks for all events.
        off: function (name, callback, context) {
            var retain, ev, events, names, i, l, j, k;
            if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
            if (!name && !callback && !context) {
                this._events = {};
                return this;
            }

            names = name ? [name] : keys(this._events);
            for (i = 0, l = names.length; i < l; i++) {
                name = names[i];
                if (events = this._events[name]) {
                    this._events[name] = retain = [];
                    if (callback || context) {
                        for (j = 0, k = events.length; j < k; j++) {
                            ev = events[j];
                            if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
                                (context && context !== ev.context)) {
                                retain.push(ev);
                            }
                        }
                    }
                    if (!retain.length) delete this._events[name];
                }
            }

            return this;
        },

        // Trigger one or many events, firing all bound callbacks. Callbacks are
        // passed the same arguments as `trigger` is, apart from the event name
        // (unless you're listening on `"all"`, which will cause your callback to
        // receive the true name of the event as the first argument).
        trigger: function (name) {
            if (!this._events) return this;
            var args = slice.call(arguments, 1);
            if (!eventsApi(this, 'trigger', name, args)) return this;
            var events = this._events[name];
            var allEvents = this._events.all;
            if (events) triggerEvents(events, args);
            if (allEvents) triggerEvents(allEvents, arguments);
            return this;
        },

        // Tell this object to stop listening to either specific events ... or
        // to every object it's currently listening to.
        stopListening: function (obj, name, callback) {
            var listeners = this._listeners;
            if (!listeners) return this;
            var deleteListener = !name && !callback;
            if (typeof name === 'object') callback = this;
            if (obj) (listeners = {})[obj._listenerId] = obj;
            for (var id in listeners) {
                listeners[id].off(name, callback, this);
                if (deleteListener) delete this._listeners[id];
            }
            return this;
        }

    };

    // Regular expression used to split event strings.
    var eventSplitter = /\s+/;

    // Implement fancy features of the Events API such as multiple event
    // names `"change blur"` and jQuery-style event maps `{change: action}`
    // in terms of the existing API.
    var eventsApi = function (obj, action, name, rest) {
        if (!name) return true;

        // Handle event maps.
        if (typeof name === 'object') {
            for (var key in name) {
                obj[action].apply(obj, [key, name[key]].concat(rest));
            }
            return false;
        }

        // Handle space separated event names.
        if (eventSplitter.test(name)) {
            var names = name.split(eventSplitter);
            for (var i = 0, l = names.length; i < l; i++) {
                obj[action].apply(obj, [names[i]].concat(rest));
            }
            return false;
        }

        return true;
    };

    // A difficult-to-believe, but optimized internal dispatch function for
    // triggering events. Tries to keep the usual cases speedy (most internal
    // Backbone events have 3 arguments).
    var triggerEvents = function (events, args) {
        var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
        switch (args.length) {
        case 0:
            while (++i < l) {
                (ev = events[i]).callback.call(ev.ctx);
            }
            return;
        case 1:
            while (++i < l) {
                (ev = events[i]).callback.call(ev.ctx, a1);
            }
            return;
        case 2:
            while (++i < l) {
                (ev = events[i]).callback.call(ev.ctx, a1, a2);
            }
            return;
        case 3:
            while (++i < l) {
                (ev = events[i]).callback.call(ev.ctx, a1, a2, a3);
            }
            return;
        default:
            while (++i < l) {
                (ev = events[i]).callback.apply(ev.ctx, args);
            }
        }
    };

    var listenMethods = {listenTo: 'on', listenToOnce: 'once'};

    // Inversion-of-control versions of `on` and `once`. Tell *this* object to
    // listen to an event in another object ... keeping track of what it's
    // listening to.
    DISQUS.each(listenMethods, function (implementation, method) {
        Events[method] = function (obj, name, callback) {
            var listeners = this._listeners || (this._listeners = {});
            var id = obj._listenerId || (obj._listenerId = DISQUS.getUid('l'));
            listeners[id] = obj;
            if (typeof name === 'object') callback = this;
            obj[implementation](name, callback, this);
            return this;
        };
    });

    // Aliases for backwards compatibility.
    Events.bind = Events.on;
    Events.unbind = Events.off;

    return Events;
});
 // used for /follow/ /login/ /signup/ social oauth dialogs
// faking the bus
DISQUS.use('Bus');
_.extend(DISQUS.Bus, DISQUS.Events);



    if (window.AB_TESTS === undefined) {
        var AB_TESTS = {};
    }



    // Global tests
    $(document).ready(function() {
        $('a[rel*=facebox]').facebox();
    });




<% var has_custom_avatar = data.avatar_url && data.avatar_url.indexOf('noavatar') < 0; %>
<% var has_custom_username = data.username && data.username.indexOf('disqus_') < 0; %>
<% if (data.username) { %>
    <% if (data.has_forums) { %>
        <li class="admin<% if (has_custom_avatar || !has_custom_username) { %> avatar-menu-admin<% } %>" data-analytics="header admin"><a href="<%= data.urlMap.admin %>"><strong>Admin</strong></a></li>
    <% } %>
    <li class="user-dropdown dropdown-toggle<% if (has_custom_avatar || !has_custom_username) { %> avatar-menu<% } else { %> username-menu<% } %>" data-analytics="header username dropdown" data-floater-marker="<% if (has_custom_avatar || !has_custom_username) { %>square<% } %>">
        <a href="<%= data.urlMap.home %>/<%= data.username %>/">
            <% if (has_custom_avatar) { %>
                <img src="<%= data.avatar_url %>" class="avatar">
            <% } else if (has_custom_username) { %>
                <%= data.username %>
            <% } else { %>
                <img src="<%= data.avatar_url %>" class="avatar">
            <% } %>
            <span class="caret"></span>
        </a>
        <ul class="clearfix dropdown">
            <li data-analytics="header view profile"><a href="<%= data.urlMap.home %>/<%= data.username %>/">View Profile</a></li>
            <li class="js-edit-profile" data-analytics="header edit profile"><a href="<%= data.urlMap.home_settings_profile %>">Edit Profile</a></li>
            <li class="logout" data-analytics="header logout"><a href="<%= data.urlMap.logout %>">Logout</a></li>
        </ul>
    </li>
<% } else { %>
    <li class="link-login" data-analytics="header login"><a href="<%= data.urlMap.login %>?next=<%= encodeURIComponent(document.location.href) %>">Log in</a></li>
<% } %>





            // Global tests
            $(document).ready(function() {
                $('a[rel*=facebox]').facebox();
            });
        

(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
        j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
        'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
        })(window,document,'script','dataLayer','GTM-MRHN8JCT');


    var jesterObj = {
        product: 'dotcom',
        zone: 'login',
    };
    
    
    window.DISQUS.jester.pv(jesterObj);



DISQUS.define('web.urls', function () {
    return {
        twitter: 'https://disqus.com/_ax/twitter/begin/?ctkn=GBxmM2zWzoUPkO0FZMSLQI9gFIKmRd9j&amp;',
        google: 'https://disqus.com/_ax/google/begin/?ctkn=GBxmM2zWzoUPkO0FZMSLQI9gFIKmRd9j&amp;',
        facebook: 'https://disqus.com/_ax/facebook/begin/?ctkn=GBxmM2zWzoUPkO0FZMSLQI9gFIKmRd9j&amp;',
        microsoft: 'https://disqus.com/_ax/microsoft/begin/?ctkn=GBxmM2zWzoUPkO0FZMSLQI9gFIKmRd9j&amp;',
        apple: 'https://disqus.com/_ax/apple/begin/?ctkn=GBxmM2zWzoUPkO0FZMSLQI9gFIKmRd9j&amp;',
        dashboard: 'http://disqus.com/dashboard/'
    }
});

$(document).ready(function () {
    $("form").submit(function () {
        $(this).find('.button.submit')
               .attr('disabled', 'disabled')
               .addClass('submitted');
        $(this).find('#password-input')
               .attr('readonly', 'readonly');
        $(this).find('#username-input')
               .attr('readonly', 'readonly');
    });
});



        
        data-profile-username="${username}" data-profile-hash="${emailHash}" href="/${username}"
        
    


  DISQUS.ui.config({
    disqusUrl: 'https://disqus.com',
    mediaUrl: '//a.disquscdn.com/1784829303/'
  });


Requests	IP Address	Location	AS Autonomous System
11	199.232.168.134Fastly · CDN	Paris, Île-de-France, France	AS54113Fastly, Inc.
10	151.101.192.134Fastly · CDN	United States	AS54113Fastly, Inc.
10	199.232.170.49Fastly · CDN	Paris, Île-de-France, France	AS54113Fastly, Inc.
10	143.204.181.74Cloudfront · CDN	United States	AS16509Amazon.com, Inc.
41	4	-	-

Security Scan Report: listin-diario.disqus.com

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Page Statistics

Detected Technologies6

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History