evercookie 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+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.

data/README.rdoc

@@ -0,0 +1,127 @@
+## Evercookie
+
+Evercookie is a gem allowing you to use very persistent cookies on your rails project to track existing users on your system.
+It's javascript is based on https://github.com/samyk/evercookie javascript.
+Please note, that evercookie can't be fully reliable for detecting previous visiting of your site/application. For people who know the job it's simple enough to override it.
+
+As written on original javascript site (http://samy.pl/evercookie/), when creating a new cookie, it uses the following storage mechanisms when available:
+* Standard [HTTP Cookies](http://en.wikipedia.org/wiki/HTTP_cookie)
+* [Local Shared Objects](http://en.wikipedia.org/wiki/Local_Shared_Object) (Flash Cookies)
+* [Isolated Storage](http://www.silverlight.net/learn/quickstarts/isolatedstorage/) Silverlight (removed in gem)
+* Storing cookies in RGB values of auto-generated, force-cached PNGs using HTML5 Canvas tag to read pixels (cookies) back out
+* Storing cookies in and reading out [Web History](http://samy.pl/csshack/) (removed in gem)
+* Storing cookies in HTTP [ETags](http://en.wikipedia.org/wiki/HTTP_ETag)
+* Storing cookies in [Web cache](http://en.wikipedia.org/wiki/Web_cache)
+* [window.name](http://en.wikipedia.org/wiki/HTTP_cookie#window.name) caching
+* Internet Explorer [userData](http://msdn.microsoft.com/en-us/library/ms531424(VS.85).aspx) storage
+* HTML5 [Session Storage](http://dev.w3.org/html5/webstorage/#the-sessionstorage-attribute)
+* HTML5 [Local Storage](http://dev.w3.org/html5/webstorage/#dom-localstorage)
+* HTML5 [Global Storage](https://developer.mozilla.org/en/dom/storage#globalStorage)
+* HTML5 [Database Storage](http://dev.w3.org/html5/webdatabase) via SQLite
+
+## Information
+
+### RDoc
+
+RDoc documentation can be found here
+http://rubydoc.info/github/daddyz/evercookie/master/frames
+
+### Bug reports
+
+If you discover a problem with Evercookie gem, let us know about it.
+https://github.com/daddyz/evercookie/issues
+
+### Example application
+
+You can see an example of evercookie working in test/dummy application of this gem
+
+## Getting started
+
+Evercookie works was written and tested on Rails 3.2. You can add in to your Gemfile with:
+
+```ruby
+gem 'evercookie'
+```
+
+Run the bundle command to install it.
+
+### View helpers
+
+View helper that adds javascript for setting the evercookie for client:
+
+```ruby
+set_evercookie(:key, :value)
+```
+
+View helper that checks whether the cookie was set on client side and resets if some of cookies were deleted:
+
+```ruby
+check_evercookie(:key)
+```
+
+### Controller helpers
+
+Controller helper that gets the value of evercookie by key:
+
+```ruby
+evercookie_get_value(:key)
+```
+
+Controller helper that checks if specific evercookie was set:
+
+```ruby
+evercookie_is_set?(:key)
+evercookie_is_set?(:key, :value)
+```
+
+### How it works
+
+When you are calling:
+* `set_evercookie` helper it adds javascript to set evercookie values in all available storage mechanisms.
+* `check_evercookie` helper it adds javascript to get evercookie values from all storage mechanisms where it possible and resets their values where it was removed (like if user removed individual cookies it sets them back) and after that it calls it's controller action to save evercookie value in rails session
+* `evercookie_get_value` helper in controller it checks evercookie's session for provided 'key' value and returns it if exists
+* `evercookie_is_set?` helper in controller it checks if there is a provided 'key' in evercookie's session
+
+### How this gem should be used
+
+The main idea of this gem is to set somewhere in application an evercookie to track that this client already visited your application.
+I used it to track multiple registrations in such scenario:
+* After user was registered he was passed to specific view where I called set_evercookie helper:
+```ruby
+set_evercookie(:uid, user_unique_id)
+```
+* In user sign up page view I called check_evercookie helper:
+```ruby
+check_evercookie(:uid)
+```
+* In controller that was handling new user creation process I was running evercookie_get_value helper to check if previously I got evercookie value from user, and if I got it I was showing an error:
+```ruby
+evercookie_get_value(:uid)
+```
+
+### Configuring the gem
+
+You can create the initializer for evercookie gem in your Rails application initializers folder:
+
+```ruby
+Evercookie.setup do |config|
+  # path for evercookie controller
+  config.namespace = :evercookie
+
+  # name of javascript class to be used for evercookie
+  config.js_class = :evercookie
+
+  # hash name base for session storage variables
+  config.hash_name = :evercookie
+
+  # cookie name for cache storage
+  config.cookie_cache = :evercookie_cache
+
+  # cookie name for png storage
+  config.cookie_png = :evercookie_png
+
+  # cookie name for etag storage
+  config.cookie_etag = :evercookie_etag
+end
+```
+

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Evercookie'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/assets/javascripts/ec.js

@@ -0,0 +1,2 @@
+//=require 'evercookie/swfobject-2.2.min'
+//=require 'evercookie/evercookie'

data/app/assets/javascripts/evercookie/evercookie.js.erb

@@ -0,0 +1,704 @@
+/*
+ * USAGE:
+
+	var ec = new <%= Evercookie.js_class %>();
+	ec.set("id", "12345");
+	ec.get("id", function(value) { alert("value is " + value) });
+*/
+var _ec_tests = 10; //1000
+function _ec_replace(str, key, value) {
+    if (str.indexOf("&" + key + "=") > -1 || str.indexOf(key + "=") === 0) {
+        // find start
+        var idx = str.indexOf("&" + key + "="),
+                end, newstr;
+        if (idx === -1) {
+            idx = str.indexOf(key + "=");
+        }
+        // find end
+        end = str.indexOf("&", idx + 1);
+        if (end !== -1) {
+            newstr = str.substr(0, idx) + str.substr(end + (idx ? 0 : 1)) + "&" + key + "=" + value;
+        } else {
+            newstr = str.substr(0, idx) + "&" + key + "=" + value;
+        }
+        return newstr;
+    } else {
+        return str + "&" + key + "=" + value;
+    }
+}
+
+
+// necessary for flash to communicate with js...
+// please implement a better way
+var _global_lso;
+function _evercookie_flash_var(cookie) {
+    _global_lso = cookie;
+
+    // remove the flash object now
+    var swf = document.getElementById("myswf");
+    if (swf && swf.parentNode) {
+        swf.parentNode.removeChild(swf);
+    }
+}
+
+var <%= Evercookie.js_class %> = (function (window) {
+    var document = window.document,
+            Image = window.Image,
+            localStorage = window.localStorage,
+            globalStorage = window.globalStorage,
+            swfobject = window.swfobject;
+    try {
+        var sessionStorage = window.sessionStorage;
+    } catch (e) { }
+
+    this._class = function () {
+        // private property
+        var self = this,
+                _baseKeyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+                no_color = -1;
+        this._ec = {};
+
+        this.get = function (name, cb, dont_reset) {
+            self._<%= Evercookie.js_class %>(name, cb, undefined, undefined, dont_reset);
+        };
+
+        this.set = function (name, value) {
+            self._<%= Evercookie.js_class %>(name, function () {}, value);
+        };
+
+        this._<%= Evercookie.js_class %> = function (name, cb, value, i, dont_reset) {
+            if (self._<%= Evercookie.js_class %> === undefined) {
+                self = this;
+            }
+            if (i === undefined) {
+                i = 0;
+            }
+            // first run
+            if (i === 0) {
+                self.<%= Evercookie.js_class %>_database_storage(name, value);
+                self.<%= Evercookie.js_class %>_png(name, value);
+                self.<%= Evercookie.js_class %>_etag(name, value);
+                self.<%= Evercookie.js_class %>_cache(name, value);
+                self.<%= Evercookie.js_class %>_lso(name, value);
+
+                self._ec.userData      = self.<%= Evercookie.js_class %>_userdata(name, value);
+                self._ec.cookieData    = self.<%= Evercookie.js_class %>_cookie(name, value);
+                self._ec.localData     = self.<%= Evercookie.js_class %>_local_storage(name, value);
+                self._ec.globalData    = self.<%= Evercookie.js_class %>_global_storage(name, value);
+                self._ec.sessionData   = self.<%= Evercookie.js_class %>_session_storage(name, value);
+                self._ec.windowData    = self.<%= Evercookie.js_class %>_window(name, value);
+            }
+
+            // when writing data, we need to make sure lso object is there
+            if (value !== undefined) {
+                if ((typeof _global_lso === "undefined") && i++ < _ec_tests) {
+                    setTimeout(function () {
+                        self._<%= Evercookie.js_class %>(name, cb, value, i, dont_reset);
+                    }, 100);
+                }
+            }
+
+            // when reading data, we need to wait for swf, db and png
+            else
+            {
+                if (
+                        (
+                            // we support local db and haven't read data in yet
+                                (window.openDatabase && typeof self._ec.dbData === "undefined") ||
+                                        (typeof _global_lso === "undefined") ||
+                                        (typeof self._ec.etagData === "undefined") ||
+                                        (typeof self._ec.cacheData === "undefined") ||
+                                        (document.createElement("canvas").getContext && (typeof self._ec.pngData === "undefined" || self._ec.pngData === ""))
+                                ) &&
+                                i++ < _ec_tests
+                        )
+                {
+                    setTimeout(function () {
+                        self._<%= Evercookie.js_class %>(name, cb, value, i, dont_reset);
+                    }, 300);
+                }
+
+                // we hit our max wait time or got all our data
+                else
+                {
+                    // get just the piece of data we need from swf
+                    self._ec.lsoData = self.getFromStr(name, _global_lso);
+                    _global_lso = undefined;
+
+                    var tmpec = self._ec,
+                            candidates = [],
+                            bestnum = 0,
+                            candidate,
+                            item;
+                    self._ec = {};
+
+                    // figure out which is the best candidate
+                    for (item in tmpec) {
+                        if (tmpec[item] && tmpec[item] !== "null" && tmpec[item] !== "undefined") {
+                            candidates[tmpec[item]] = candidates[tmpec[item]] === undefined ? 1 : candidates[tmpec[item]] + 1;
+                        }
+                    }
+
+                    for (item in candidates) {
+                        if (candidates[item] > bestnum) {
+                            bestnum = candidates[item];
+                            candidate = item;
+                        }
+                    }
+
+                    // reset cookie everywhere
+                    if (dont_reset === undefined || dont_reset !== 1) {
+                        self.set(name, candidate);
+                    }
+                    if (typeof cb === "function") {
+                        cb(candidate, tmpec);
+                    }
+
+                    self.ajax({
+                        url: "<%= Evercookie.get_save_path %>?name=" + name,
+                        success: function (data) { }
+                    });
+                }
+            }
+        };
+
+        this.<%= Evercookie.js_class %>_window = function (name, value) {
+            try {
+                if (value !== undefined) {
+                    window.name = _ec_replace(window.name, name, value);
+                } else {
+                    return this.getFromStr(name, window.name);
+                }
+            } catch (e) { }
+        };
+
+        this.<%= Evercookie.js_class %>_userdata = function (name, value) {
+            try {
+                var elm = this.createElem("div", "userdata_el", 1);
+                elm.style.behavior = "url(#default#userData)";
+
+                if (value !== undefined) {
+                    elm.setAttribute(name, value);
+                    elm.save(name);
+                } else {
+                    elm.load(name);
+                    return elm.getAttribute(name);
+                }
+            } catch (e) {}
+        };
+
+        function newImage(src) {
+            var img = new Image();
+            img.style.visibility = "hidden";
+            img.style.position = "absolute";
+            img.src = src;
+        }
+
+        this.ajax = function (settings) {
+            var headers, name, transports, transport, i, length;
+
+            headers = {
+                'X-Requested-With': 'XMLHttpRequest',
+                'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
+            };
+
+            transports = [
+                function () { return new XMLHttpRequest(); },
+                function () { return new ActiveXObject('Msxml2.XMLHTTP'); },
+                function () { return new ActiveXObject('Microsoft.XMLHTTP'); }
+            ];
+
+            for (i = 0, length = transports.length; i < length; i++) {
+                transport = transports[i];
+                try {
+                    transport = transport();
+                    break;
+                } catch (e) {
+                }
+            }
+
+            transport.onreadystatechange = function () {
+                if (transport.readyState !== 4) {
+                    return;
+                }
+                settings.success(transport.responseText);
+            };
+            transport.open('get', settings.url, true);
+            for (name in headers) {
+                transport.setRequestHeader(name, headers[name]);
+            }
+            transport.send();
+        };
+
+        this.<%= Evercookie.js_class %>_cache = function (name, value) {
+            if (value !== undefined) {
+                // make sure we have <%= Evercookie.js_class %> session defined first
+                document.cookie = "<%= Evercookie.cookie_cache %>=" + value + "; path=<%= Evercookie.get_cookie_path %>";
+                // <%= Evercookie.get_cache_path %> handles caching
+                newImage("<%= Evercookie.get_cache_path %>?name=" + name);
+            } else {
+                // interestingly enough, we want to erase our evercookie
+                // http cookie so will force a cached response
+                var origvalue = this.getFromStr("<%= Evercookie.cookie_cache %>", document.cookie);
+                self._ec.cacheData = undefined;
+                document.cookie = "<%= Evercookie.cookie_cache %>=; expires=Mon, 20 Sep 2010 00:00:00 UTC; path=<%= Evercookie.get_cookie_path %>";
+
+                self.ajax({
+                    url: "<%= Evercookie.get_cache_path %>?name=" + name,
+                    success: function (data) {
+                        // put our cookie back
+                        document.cookie = "<%= Evercookie.cookie_cache %>=" + origvalue + "; expires=Tue, 31 Dec 2030 00:00:00 UTC; path=<%= Evercookie.get_cookie_path %>";
+
+                        self._ec.cacheData = data;
+                    }
+                });
+            }
+        };
+
+        this.<%= Evercookie.js_class %>_etag = function (name, value) {
+            if (value !== undefined) {
+                // make sure we have <%= Evercookie.js_class %> session defined first
+                document.cookie = "<%= Evercookie.cookie_etag %>=" + value + "; path=<%= Evercookie.get_cookie_path %>";
+                // <%= Evercookie.get_etag_path %> handles etagging
+                newImage("<%= Evercookie.get_etag_path %>?name=" + name);
+            } else {
+                // interestingly enough, we want to erase our <%= Evercookie.js_class %>
+                // http cookie so will force a cached response
+                var origvalue = this.getFromStr("<%= Evercookie.cookie_etag %>", document.cookie);
+                self._ec.etagData = undefined;
+                document.cookie = "<%= Evercookie.cookie_etag %>=; expires=Mon, 20 Sep 2010 00:00:00 UTC; path=<%= Evercookie.get_cookie_path %>";
+
+                self.ajax({
+                    url: "<%= Evercookie.get_etag_path %>?name=" + name,
+                    success: function (data) {
+                        // put our cookie back
+                        document.cookie = "<%= Evercookie.cookie_etag %>=" + origvalue + "; expires=Tue, 31 Dec 2030 00:00:00 UTC; path=<%= Evercookie.get_cookie_path %>";
+
+                        self._ec.etagData = data;
+                    }
+                });
+            }
+        };
+
+        this.<%= Evercookie.js_class %>_lso = function (name, value) {
+            var div = document.getElementById("swfcontainer"),
+                    flashvars = {},
+                    params = {},
+                    attributes = {};
+            if (div===null || div === undefined || !div.length) {
+                div = document.createElement("div");
+                div.setAttribute("id", "swfcontainer");
+                document.body.appendChild(div);
+            }
+
+            if (value !== undefined) {
+                flashvars.everdata = name + "=" + value;
+            }
+            params.swliveconnect = "true";
+            attributes.id        = "myswf";
+            attributes.name      = "myswf";
+            swfobject.embedSWF("<%= asset_path('ec.swf') %>", "swfcontainer", "1", "1", "9.0.0", false, flashvars, params, attributes);
+        };
+
+        this.<%= Evercookie.js_class %>_png = function (name, value) {
+            var canvas = document.createElement("canvas"),
+                    img, ctx, origvalue;
+            canvas.style.visibility = "hidden";
+            canvas.style.position = "absolute";
+            canvas.width = 200;
+            canvas.height = 1;
+            if (canvas && canvas.getContext) {
+                // <%= Evercookie.get_png_path %> handles the hard part of generating the image
+                // based off of the http cookie and returning it cached
+                img = new Image();
+                img.style.visibility = "hidden";
+                img.style.position = "absolute";
+                if (value !== undefined) {
+                    // make sure we have <%= Evercookie.js_class %> session defined first
+                    document.cookie = "<%= Evercookie.cookie_png %>=" + value + "; path=<%= Evercookie.get_cookie_path %>";
+                } else {
+                    self._ec.pngData = undefined;
+                    ctx = canvas.getContext("2d");
+
+                    // interestingly enough, we want to erase our <%= Evercookie.js_class %>
+                    // http cookie so will force a cached response
+                    origvalue = this.getFromStr("<%= Evercookie.cookie_png %>", document.cookie);
+                    document.cookie = "<%= Evercookie.cookie_png %>=; expires=Mon, 20 Sep 2010 00:00:00 UTC; path=<%= Evercookie.get_cookie_path %>";
+
+                    img.onload = function () {
+                        // put our cookie back
+                        document.cookie = "<%= Evercookie.cookie_png %>=" + origvalue + "; expires=Tue, 31 Dec 2030 00:00:00 UTC; path=<%= Evercookie.get_cookie_path %>";
+
+                        self._ec.pngData = "";
+                        ctx.drawImage(img, 0, 0);
+
+                        // get CanvasPixelArray from  given coordinates and dimensions
+                        var imgd = ctx.getImageData(0, 0, 200, 1),
+                                pix = imgd.data, i, n;
+
+                        // loop over each pixel to get the "RGB" values (ignore alpha)
+                        for (i = 0, n = pix.length; i < n; i += 4) {
+                            if (pix[i] === 0) {
+                                break;
+                            }
+                            self._ec.pngData += String.fromCharCode(pix[i]);
+                            if (pix[i + 1] === 0) {
+                                break;
+                            }
+                            self._ec.pngData += String.fromCharCode(pix[i + 1]);
+                            if (pix[i + 2] === 0) {
+                                break;
+                            }
+                            self._ec.pngData += String.fromCharCode(pix[i + 2]);
+                        }
+                    };
+                }
+                img.src = "<%= Evercookie.get_png_path %>?name=" + name;
+            }
+        };
+
+        this.<%= Evercookie.js_class %>_local_storage = function (name, value) {
+            try {
+                if (localStorage) {
+                    if (value !== undefined) {
+                        localStorage.setItem(name, value);
+                    } else {
+                        return localStorage.getItem(name);
+                    }
+                }
+            } catch (e) { }
+        };
+
+        this.<%= Evercookie.js_class %>_database_storage = function (name, value) {
+            try {
+                if (window.openDatabase) {
+                    var database = window.openDatabase("sqlite_<%= Evercookie.js_class %>", "", "<%= Evercookie.js_class %>", 1024 * 1024);
+
+                    if (value !== undefined) {
+                        database.transaction(function (tx) {
+                            tx.executeSql("CREATE TABLE IF NOT EXISTS cache(" +
+                                    "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " +
+                                    "name TEXT NOT NULL, " +
+                                    "value TEXT NOT NULL, " +
+                                    "UNIQUE (name)" +
+                                    ")", [], function (tx, rs) {}, function (tx, err) {});
+                            tx.executeSql("INSERT OR REPLACE INTO cache(name, value) " +
+                                    "VALUES(?, ?)",
+                                    [name, value], function (tx, rs) {}, function (tx, err) {});
+                        });
+                    } else {
+                        database.transaction(function (tx) {
+                            tx.executeSql("SELECT value FROM cache WHERE name=?", [name],
+                                    function (tx, result1) {
+                                        if (result1.rows.length >= 1) {
+                                            self._ec.dbData = result1.rows.item(0).value;
+                                        } else {
+                                            self._ec.dbData = "";
+                                        }
+                                    }, function (tx, err) {});
+                        });
+                    }
+                }
+            } catch (e) { }
+        };
+
+        this.<%= Evercookie.js_class %>_session_storage = function (name, value) {
+            try {
+                if (sessionStorage) {
+                    if (value !== undefined) {
+                        sessionStorage.setItem(name, value);
+                    } else {
+                        return sessionStorage.getItem(name);
+                    }
+                }
+            } catch (e) { }
+        };
+
+        this.<%= Evercookie.js_class %>_global_storage = function (name, value) {
+            if (globalStorage) {
+                var host = this.getHost();
+                try {
+                    if (value !== undefined) {
+                        globalStorage[host][name] = value;
+                    } else {
+                        return globalStorage[host][name];
+                    }
+                } catch (e) { }
+            }
+        };
+
+        // public method for encoding
+        this.encode = function (input) {
+            var output = "",
+                    chr1, chr2, chr3, enc1, enc2, enc3, enc4,
+                    i = 0;
+
+            input = this._utf8_encode(input);
+
+            while (i < input.length) {
+
+                chr1 = input.charCodeAt(i++);
+                chr2 = input.charCodeAt(i++);
+                chr3 = input.charCodeAt(i++);
+
+                enc1 = chr1 >> 2;
+                enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+                enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+                enc4 = chr3 & 63;
+
+                if (isNaN(chr2)) {
+                    enc3 = enc4 = 64;
+                } else if (isNaN(chr3)) {
+                    enc4 = 64;
+                }
+
+                output = output +
+                        _baseKeyStr.charAt(enc1) + _baseKeyStr.charAt(enc2) +
+                        _baseKeyStr.charAt(enc3) + _baseKeyStr.charAt(enc4);
+
+            }
+
+            return output;
+        };
+
+        // public method for decoding
+        this.decode = function (input) {
+            var output = "",
+                    chr1, chr2, chr3,
+                    enc1, enc2, enc3, enc4,
+                    i = 0;
+
+            input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+
+            while (i < input.length) {
+                enc1 = _baseKeyStr.indexOf(input.charAt(i++));
+                enc2 = _baseKeyStr.indexOf(input.charAt(i++));
+                enc3 = _baseKeyStr.indexOf(input.charAt(i++));
+                enc4 = _baseKeyStr.indexOf(input.charAt(i++));
+
+                chr1 = (enc1 << 2) | (enc2 >> 4);
+                chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+                chr3 = ((enc3 & 3) << 6) | enc4;
+
+                output = output + String.fromCharCode(chr1);
+
+                if (enc3 !== 64) {
+                    output = output + String.fromCharCode(chr2);
+                }
+                if (enc4 !== 64) {
+                    output = output + String.fromCharCode(chr3);
+                }
+            }
+            output = this._utf8_decode(output);
+            return output;
+        };
+
+        // private method for UTF-8 encoding
+        this._utf8_encode = function (str) {
+            str = str.replace(/\r\n/g, "\n");
+            var utftext = "", i = 0, n = str.length, c;
+            for (; i < n; i++) {
+                c = str.charCodeAt(i);
+                if (c < 128) {
+                    utftext += String.fromCharCode(c);
+                } else if ((c > 127) && (c < 2048)) {
+                    utftext += String.fromCharCode((c >> 6) | 192);
+                    utftext += String.fromCharCode((c & 63) | 128);
+                } else {
+                    utftext += String.fromCharCode((c >> 12) | 224);
+                    utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+                    utftext += String.fromCharCode((c & 63) | 128);
+                }
+            }
+            return utftext;
+        };
+
+        // private method for UTF-8 decoding
+        this._utf8_decode = function (utftext) {
+            var str = "",
+                    i = 0, n = utftext.length,
+                    c = 0, c1 = 0, c2 = 0, c3 = 0;
+            while (i < n) {
+                c = utftext.charCodeAt(i);
+                if (c < 128) {
+                    str += String.fromCharCode(c);
+                    i += 1;
+                } else if ((c > 191) && (c < 224)) {
+                    c2 = utftext.charCodeAt(i + 1);
+                    str += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+                    i += 2;
+                } else {
+                    c2 = utftext.charCodeAt(i + 1);
+                    c3 = utftext.charCodeAt(i + 2);
+                    str += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+                    i += 3;
+                }
+            }
+            return str;
+        };
+
+        this.createElem = function (type, name, append) {
+            var el;
+            if (name !== undefined && document.getElementById(name)) {
+                el = document.getElementById(name);
+            } else {
+                el = document.createElement(type);
+            }
+            el.style.visibility = "hidden";
+            el.style.position = "absolute";
+
+            if (name) {
+                el.setAttribute("id", name);
+            }
+
+            if (append) {
+                document.body.appendChild(el);
+            }
+            return el;
+        };
+
+        this.createIframe = function (url, name) {
+            var el = this.createElem("iframe", name, 1);
+            el.setAttribute("src", url);
+            return el;
+        };
+
+        // wait for our swfobject to appear (swfobject.js to load)
+        var waitForSwf = this.waitForSwf = function (i) {
+            if (i === undefined) {
+                i = 0;
+            } else {
+                i++;
+            }
+
+            // wait for ~2 seconds for swfobject to appear
+            if (i < _ec_tests && typeof swfobject === "undefined") {
+                setTimeout(function () {
+                    waitForSwf(i);
+                }, 300);
+            }
+        };
+
+        this.<%= Evercookie.js_class %>_cookie = function (name, value) {
+            if (value !== undefined) {
+                // expire the cookie first
+                document.cookie = name + "=; expires=Mon, 20 Sep 2010 00:00:00 UTC; path=<%= Evercookie.get_cookie_path %>";
+                document.cookie = name + "=" + value + "; expires=Tue, 31 Dec 2030 00:00:00 UTC; path=<%= Evercookie.get_cookie_path %>";
+            } else {
+                return this.getFromStr(name, document.cookie);
+            }
+        };
+
+        // get value from param-like string (eg, "x=y&name=VALUE")
+        this.getFromStr = function (name, text) {
+            if (typeof text !== "string") {
+                return;
+            }
+            var nameEQ = name + "=",
+                    ca = text.split(/[;&]/),
+                    i, c;
+            for (i = 0; i < ca.length; i++) {
+                c = ca[i];
+                while (c.charAt(0) === " ") {
+                    c = c.substring(1, c.length);
+                }
+                if (c.indexOf(nameEQ) === 0) {
+                    return c.substring(nameEQ.length, c.length);
+                }
+            }
+        };
+
+        this.getHost = function () {
+            return window.location.host.replace(/:\d+/, '');
+        };
+
+        this.toHex = function (str) {
+            var r = "",
+                    e = str.length,
+                    c = 0,
+                    h;
+            while (c < e) {
+                h = str.charCodeAt(c++).toString(16);
+                while (h.length < 2) {
+                    h = "0" + h;
+                }
+                r += h;
+            }
+            return r;
+        };
+
+        this.fromHex = function (str) {
+            var r = "",
+                    e = str.length,
+                    s;
+            while (e >= 0) {
+                s = e - 2;
+                r = String.fromCharCode("0x" + str.substring(s, e)) + r;
+                e = s;
+            }
+            return r;
+        };
+
+        /* create our anchor tag */
+        var _link = this.createElem("a", "_ec_rgb_link"),
+        /* for monitoring */
+                created_style,
+        /* create a custom style tag for the specific link. Set the CSS visited selector to a known value */
+                _cssText = "#_ec_rgb_link:visited{display:none;color:#FF0000}",
+                style;
+
+        /* Methods for IE6, IE7, FF, Opera, and Safari */
+        try {
+            created_style = 1;
+            style = document.createElement("style");
+            if (style.styleSheet) {
+                style.styleSheet.innerHTML = _cssText;
+            } else if (style.innerHTML) {
+                style.innerHTML = _cssText;
+            } else {
+                style.appendChild(document.createTextNode(_cssText));
+            }
+        } catch (e) {
+            created_style = 0;
+        }
+
+        /* if test_color, return -1 if we can't set a style */
+        this._getRGB = function (u, test_color) {
+            if (test_color && created_style === 0) {
+                return -1;
+            }
+
+            /* create the new anchor tag with the appropriate URL information */
+            _link.href = u;
+            _link.innerHTML = u;
+            // not sure why, but the next two appendChilds always have to happen vs just once
+            document.body.appendChild(style);
+            document.body.appendChild(_link);
+
+            /* add the link to the DOM and save the visible computed color */
+            var color;
+            if (document.defaultView) {
+                color = document.defaultView.getComputedStyle(_link, null).getPropertyValue("color");
+            } else {
+                color = _link.currentStyle.color;
+            }
+            return color;
+        };
+
+        this._testURL = function (url, no_color) {
+            var color = this._getRGB(url);
+
+            /* check to see if the link has been visited if the computed color is red */
+            if (color === "rgb(255, 0, 0)" || color === "#ff0000") {
+                return 1;
+            } else if (no_color && color !== no_color) {
+                /* if our style trick didn't work, just compare default style colors */
+                return 1;
+            }
+            /* not found */
+            return 0;
+        };
+
+    };
+    return this._class;
+}(window));