43 files changed, 623 insertions, 526 deletions

diff --git a/frontend/beta/properties/beta.properties.json b/frontend/beta/properties/beta.properties.json
index 7b0c1f9..476becd 100644
--- a/frontend/beta/properties/beta.properties.json
+++ b/frontend/beta/properties/beta.properties.json
@@ -1,184 +1,187 @@
 {
         "copyright.values": {             
                 "mochikit.repository": "http://svn.mochikit.com/mochikit/trunk/",
                 "mochikit.version": "1249"
         },
+
+        "html.template": "index_template.html",
+
         "js": [
                 "MochiKit/Base.js",
                 "MochiKit/Iter.js",
                 "MochiKit/DOM.js",
                 "MochiKit/Style.js",
                 "MochiKit/Signal.js",
                 "MochiKit/Format.js",
                 "MochiKit/Async.js",
                 "MochiKit/Selector.js",
                 "MochiKit/Logging.js",
                 "MochiKit/LoggingPane.js",
 
                 "YUI/yahoo.js",
                 "YUI/animation.js",
                 "YUI/event.js",
                 "YUI/dom.js",
                 "YUI/dragdrop.js",
                 "YUI/logger.js",
 
                 "YUI-extensions/yutil.js",
                 "YUI-extensions/Bench.js",
                 "YUI-extensions/Date.js",
                 "YUI-extensions/DomHelper.js",
                 "YUI-extensions/Element.js",
                 "YUI-extensions/CompositeElement.js",
                 "YUI-extensions/State.js",
                 "YUI-extensions/EventManager.js",
                 "YUI-extensions/KeyMap.js",
                 "YUI-extensions/Layer.js",
                 "YUI-extensions/MixedCollection.js",
                 "YUI-extensions/State.js",
                 "YUI-extensions/UpdateManager.js",
                 "YUI-extensions/anim/Actor.js",
                 "YUI-extensions/anim/Animator.js",
                 "YUI-extensions/dd/Registry.js",
                 "YUI-extensions/dd/ScrollManager.js",
                 "YUI-extensions/dd/StatusProxy.js",
                 "YUI-extensions/layout/ContentPanels.js",
                 "YUI-extensions/layout/LayoutManager.js",
                 "YUI-extensions/layout/BorderLayout.js",
                 "YUI-extensions/layout/BasicLayoutRegion.js",
                 "YUI-extensions/layout/LayoutRegion.js",
                 "YUI-extensions/layout/LayoutStateManager.js",
                 "YUI-extensions/layout/SplitLayoutRegion.js",
                 "YUI-extensions/layout/BorderLayoutRegions.js",
                 "YUI-extensions/widgets/BasicDialog.js",
                 "YUI-extensions/widgets/Button.js",
                 "YUI-extensions/widgets/MessageBox.js",
                 "YUI-extensions/widgets/Resizable.js",
                 "YUI-extensions/widgets/SplitBar.js",
                 "YUI-extensions/widgets/TabPanel.js",
                 "YUI-extensions/widgets/TemplateView.js",
                 "YUI-extensions/widgets/Toolbar.js",
                 "YUI-extensions/widgets/InlineEditor.js",
                 "YUI-extensions/widgets/QuickTips.js",
                 "YUI-extensions/CSS.js",
 
                 "JSON/json2.js",
 
                 "Clipperz/ByteArray.js",
                 "Clipperz/Base.js",
                 "Clipperz/CSVProcessor.js",
                 "Clipperz/KeePassExportProcessor.js",
                 "Clipperz/Date.js",
                 "Clipperz/DOM.js",
                 "Clipperz/Signal.js",
                 "Clipperz/Style.js",
                 "Clipperz/Set.js",
                 "Clipperz/NotificationCenter.js",
                 "Clipperz/Crypto/SHA.js",
                 "Clipperz/Crypto/AES.js",
                 "Clipperz/Crypto/PRNG.js",
                 "Clipperz/Crypto/BigInt.js",
                 "Clipperz/Crypto/Base.js",
                 "Clipperz/Crypto/SRP.js",
                 "Clipperz/Crypto/RSA.js",
                 "Clipperz/PM/Strings/Strings_en-US.js",
                 "Clipperz/PM/Strings/Strings_it-IT.js",
                 "Clipperz/PM/Strings/Strings_pt-BR.js",
                 "Clipperz/PM/Strings/Strings_ja-JP.js",
                 "Clipperz/PM/Strings/Strings_zh-CN.js",
                 "Clipperz/PM/Strings/Strings_es-ES.js",
                 "Clipperz/PM/Strings/Strings_fr-FR.js",
                 "Clipperz/PM/Strings/Strings_ru-RU.js",
                 "Clipperz/PM/Strings.js",
                 "Clipperz/PM/Strings/MessagePanelConfigurations.js",
                 "Clipperz/PM/Date.js",
                 "Clipperz/PM/Components/BaseComponent.js",
                 "Clipperz/PM/Components/MessageBox.js",
                 "Clipperz/PM/Components/TextFormField.js",
                 "Clipperz/PM/Components/PasswordEntropyDisplay.js",
                 "Clipperz/PM/Components/PasswordGenerator.js",
                 "Clipperz/PM/Components/Panels/BasePanel.js",
                 "Clipperz/PM/Components/Panels/LoginPanel.js",
                 "Clipperz/PM/Components/Panels/MainPanel.js",
                 "Clipperz/PM/Components/Panels/AccountPanel.js",
                 "Clipperz/PM/Components/Panels/DataPanel.js",
                 "Clipperz/PM/Components/Panels/ContactsPanel.js",
                 "Clipperz/PM/Components/Panels/ToolsPanel.js",
                 "Clipperz/PM/Components/Panels/LogoutPanel.js",
                 "Clipperz/PM/Components/RecordDetail/MainComponent.js",
                 "Clipperz/PM/Components/RecordDetail/AbstractComponent.js",
                 "Clipperz/PM/Components/RecordDetail/HeaderComponent.js",
                 "Clipperz/PM/Components/RecordDetail/TitleComponent.js",
                 "Clipperz/PM/Components/RecordDetail/NotesComponent.js",
                 "Clipperz/PM/Components/RecordDetail/FieldComponent.js",
                 "Clipperz/PM/Components/RecordDetail/AbstractFieldSubComponent.js",
                 "Clipperz/PM/Components/RecordDetail/FieldButtonComponent.js",
                 "Clipperz/PM/Components/RecordDetail/FieldLabelComponent.js",
                 "Clipperz/PM/Components/RecordDetail/FieldDragHandler.js",
                 "Clipperz/PM/Components/RecordDetail/FieldValueComponent.js",
                 "Clipperz/PM/Components/RecordDetail/FieldTypeComponent.js",
                 "Clipperz/PM/Components/RecordDetail/DirectLoginsComponent.js",
                 "Clipperz/PM/Components/RecordDetail/DirectLoginComponent.js",
                 "Clipperz/PM/Components/RecordDetail/DirectLoginBindingComponent.js",
                 "Clipperz/PM/Components/RecordDetail/DirectLoginValueComponent.js",
                 "Clipperz/PM/Components/RecordDetail/CreationWizard.js",
                 "Clipperz/PM/Components/TabPanel/TabPanelController.js",
                 "Clipperz/PM/Components/Import/MainComponent.js",
                 "Clipperz/PM/Components/Import/GenericImportComponent.js",
                 "Clipperz/PM/Components/Import/CSVImportComponent.js",
                 "Clipperz/PM/Components/Import/CSVImport/CSVImportColumns.js",
                 "Clipperz/PM/Components/Import/CSVImport/CSVImportHeader.js",
                 "Clipperz/PM/Components/Import/CSVImport/CSVImportTitle.js",
                 "Clipperz/PM/Components/Import/CSVImport/CSVImportNotes.js",
                 "Clipperz/PM/Components/Import/CSVImport/CSVImportFields.js",
                 "Clipperz/PM/Components/Import/ExcelImportComponent.js",
                 "Clipperz/PM/Components/Import/PasswordPlusImportComponent.js",
                 "Clipperz/PM/Components/Import/ClipperzImportComponent.js",
                 "Clipperz/PM/Components/Import/RoboFormImportComponent.js",
                 "Clipperz/PM/Components/Import/KeePassImportComponent.js",
                 "Clipperz/PM/Components/Printing/Header.js",
                 "Clipperz/PM/Components/Printing/Record.js",
                 "Clipperz/PM/Components/Printing/Footer.js",
                 "Clipperz/PM/Components/OTP/MainComponent.js",
                 "Clipperz/PM/Components/Compact/CompactHeader.js",
                 "Clipperz/PM/Components/Compact/LoginForm.js",
                 "Clipperz/PM/Components/Compact/CompactInterface.js",
                 "Clipperz/PM/Toll.js",
                 "Clipperz/PM/Proxy.js",
                 "Clipperz/PM/Proxy/Proxy.JSON.js",
                 "Clipperz/PM/Proxy/Proxy.Offline.js",
                 "Clipperz/PM/Proxy/Proxy.Offline.DataStore.js",
                 "Clipperz/PM/Connection.js",
                 "Clipperz/PM/Crypto.js",
                 "Clipperz/PM/BookmarkletProcessor.js",
                 "Clipperz/PM/DataModel/User.js",
                 "Clipperz/PM/DataModel/UserPreferences.js",
                 "Clipperz/PM/DataModel/Header.js",
                 "Clipperz/PM/DataModel/Statistics.js",
                 "Clipperz/PM/DataModel/Record.js",
                 "Clipperz/PM/DataModel/RecordField.js",
                 "Clipperz/PM/DataModel/RecordVersion.js",
                 "Clipperz/PM/DataModel/DirectLogin.js",
                 "Clipperz/PM/DataModel/DirectLoginReference.js",
                 "Clipperz/PM/DataModel/DirectLoginInput.js",
                 "Clipperz/PM/DataModel/DirectLoginBinding.js",
                 "Clipperz/PM/DataModel/OneTimePasswordManager.js",
                 "Clipperz/PM/DataModel/OneTimePassword.js",
                 "Clipperz/YUI/IBLayoutManager.js",
                 "Clipperz/YUI/IBLayoutRegion.js",
                 "Clipperz/YUI/Drawer.js",
                 "Clipperz/YUI/Collapser.js",
                 "Clipperz/YUI/MessageBox.js",
                 "Clipperz/YUI/DomHelper.js",
 
                 "Clipperz/PM/Main.js"
         ],
 
         "css": [
                 "yui-extensions/reset-min.css",
                 "yui-extensions/core.css",
                 "yui-extensions/basic-dialog.css",
                 "yui-extensions/button.css",
                 "clipperz/clipperz.css",
                 "clipperz/compact.css",
                 "clipperz/ytheme-clipperz.css"
         ]
 }
diff --git a/frontend/gamma/js/MochiKit/Async.js b/frontend/gamma/js/MochiKit/Async.js
index c7408e7..cc43835 100644
--- a/frontend/gamma/js/MochiKit/Async.js
+++ b/frontend/gamma/js/MochiKit/Async.js
@@ -1,640 +1,706 @@
 /***
 
 MochiKit.Async 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Async', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'Async', '1.5', ['Base']);
 
 /** @id MochiKit.Async.Deferred */
 MochiKit.Async.Deferred = function (/* optional */ canceller) {
     this.chain = [];
     this.id = this._nextId();
     this.fired = -1;
     this.paused = 0;
     this.results = [null, null];
     this.canceller = canceller;
     this.silentlyCancelled = false;
     this.chained = false;
+    this.finalized = false;
 };
 
 MochiKit.Async.Deferred.prototype = {
     /** @id MochiKit.Async.Deferred.prototype.repr */
     repr: function () {
-        var state;
-        if (this.fired == -1) {
-            state = 'unfired';
-        } else if (this.fired === 0) {
-            state = 'success';
-        } else {
-            state = 'error';
-        }
-        return 'Deferred(' + this.id + ', ' + state + ')';
+        return 'Deferred(' + this.id + ', ' + this.state() + ')';
     },
 
     toString: MochiKit.Base.forwardCall("repr"),
 
     _nextId: MochiKit.Base.counter(),
 
+    /** @id MochiKit.Async.Deferred.prototype.state */
+    state: function () {
+        if (this.fired == -1) {
+            return 'unfired';
+        } else if (this.fired === 0) {
+            return 'success';
+        } else {
+            return 'error';
+        }
+    },
+
     /** @id MochiKit.Async.Deferred.prototype.cancel */
-    cancel: function () {
+    cancel: function (e) {
         var self = MochiKit.Async;
         if (this.fired == -1) {
             if (this.canceller) {
                 this.canceller(this);
             } else {
                 this.silentlyCancelled = true;
             }
             if (this.fired == -1) {
-                this.errback(new self.CancelledError(this));
+                if (typeof(e) === 'string') {
+                    e = new self.GenericError(e);
+                } else if (!(e instanceof Error)) {
+                    e = new self.CancelledError(this);
+                }
+                this.errback(e);
             }
         } else if ((this.fired === 0) && (this.results[0] instanceof self.Deferred)) {
-            this.results[0].cancel();
+            this.results[0].cancel(e);
         }
     },
 
     _resback: function (res) {
         /***
 
         The primitive that means either callback or errback
 
         ***/
         this.fired = ((res instanceof Error) ? 1 : 0);
         this.results[this.fired] = res;
-        this._fire();
+        if (this.paused === 0) {
+            this._fire();
+        }
     },
 
     _check: function () {
         if (this.fired != -1) {
             if (!this.silentlyCancelled) {
                 throw new MochiKit.Async.AlreadyCalledError(this);
             }
             this.silentlyCancelled = false;
             return;
         }
     },
 
     /** @id MochiKit.Async.Deferred.prototype.callback */
     callback: function (res) {
         this._check();
         if (res instanceof MochiKit.Async.Deferred) {
             throw new Error("Deferred instances can only be chained if they are the result of a callback");
         }
         this._resback(res);
     },
 
     /** @id MochiKit.Async.Deferred.prototype.errback */
     errback: function (res) {
         this._check();
         var self = MochiKit.Async;
         if (res instanceof self.Deferred) {
             throw new Error("Deferred instances can only be chained if they are the result of a callback");
         }
         if (!(res instanceof Error)) {
             res = new self.GenericError(res);
         }
         this._resback(res);
     },
 
     /** @id MochiKit.Async.Deferred.prototype.addBoth */
     addBoth: function (fn) {
         if (arguments.length > 1) {
             fn = MochiKit.Base.partial.apply(null, arguments);
         }
         return this.addCallbacks(fn, fn);
     },
 
     /** @id MochiKit.Async.Deferred.prototype.addCallback */
     addCallback: function (fn) {
         if (arguments.length > 1) {
             fn = MochiKit.Base.partial.apply(null, arguments);
         }
         return this.addCallbacks(fn, null);
     },
 
     /** @id MochiKit.Async.Deferred.prototype.addErrback */
     addErrback: function (fn) {
         if (arguments.length > 1) {
             fn = MochiKit.Base.partial.apply(null, arguments);
         }
         return this.addCallbacks(null, fn);
     },
 
     /** @id MochiKit.Async.Deferred.prototype.addCallbacks */
     addCallbacks: function (cb, eb) {
         if (this.chained) {
             throw new Error("Chained Deferreds can not be re-used");
         }
+        if (this.finalized) {
+            throw new Error("Finalized Deferreds can not be re-used");
+        }
         this.chain.push([cb, eb]);
         if (this.fired >= 0) {
             this._fire();
         }
         return this;
     },
 
+    /** @id MochiKit.Async.Deferred.prototype.setFinalizer */
+    setFinalizer: function (fn) {
+        if (this.chained) {
+            throw new Error("Chained Deferreds can not be re-used");
+        }
+        if (this.finalized) {
+            throw new Error("Finalized Deferreds can not be re-used");
+        }
+        if (arguments.length > 1) {
+            fn = MochiKit.Base.partial.apply(null, arguments);
+        }
+        this._finalizer = fn;
+        if (this.fired >= 0) {
+            this._fire();
+        }
+        return this;
+    },
+
     _fire: function () {
         /***
 
         Used internally to exhaust the callback sequence when a result
         is available.
 
         ***/
         var chain = this.chain;
         var fired = this.fired;
         var res = this.results[fired];
         var self = this;
         var cb = null;
         while (chain.length > 0 && this.paused === 0) {
             // Array
             var pair = chain.shift();
             var f = pair[fired];
             if (f === null) {
                 continue;
             }
             try {
                 res = f(res);
                 fired = ((res instanceof Error) ? 1 : 0);
                 if (res instanceof MochiKit.Async.Deferred) {
                     cb = function (res) {
-                        self._resback(res);
                         self.paused--;
-                        if ((self.paused === 0) && (self.fired >= 0)) {
-                            self._fire();
-                        }
+                        self._resback(res);
                     };
                     this.paused++;
                 }
             } catch (err) {
                 fired = 1;
                 if (!(err instanceof Error)) {
                     err = new MochiKit.Async.GenericError(err);
                 }
                 res = err;
             }
         }
         this.fired = fired;
         this.results[fired] = res;
+        if (this.chain.length == 0 && this.paused === 0 && this._finalizer) {
+            this.finalized = true;
+            this._finalizer(res);
+        }
         if (cb && this.paused) {
             // this is for "tail recursion" in case the dependent deferred
             // is already fired
             res.addBoth(cb);
             res.chained = true;
         }
     }
 };
 
 MochiKit.Base.update(MochiKit.Async, {
     /** @id MochiKit.Async.evalJSONRequest */
     evalJSONRequest: function (req) {
         return MochiKit.Base.evalJSON(req.responseText);
     },
 
     /** @id MochiKit.Async.succeed */
     succeed: function (/* optional */result) {
         var d = new MochiKit.Async.Deferred();
         d.callback.apply(d, arguments);
         return d;
     },
 
     /** @id MochiKit.Async.fail */
     fail: function (/* optional */result) {
         var d = new MochiKit.Async.Deferred();
         d.errback.apply(d, arguments);
         return d;
     },
 
     /** @id MochiKit.Async.getXMLHttpRequest */
     getXMLHttpRequest: function () {
         var self = arguments.callee;
         if (!self.XMLHttpRequest) {
             var tryThese = [
                 function () { return new XMLHttpRequest(); },
                 function () { return new ActiveXObject('Msxml2.XMLHTTP'); },
                 function () { return new ActiveXObject('Microsoft.XMLHTTP'); },
                 function () { return new ActiveXObject('Msxml2.XMLHTTP.4.0'); },
                 function () {
                     throw new MochiKit.Async.BrowserComplianceError("Browser does not support XMLHttpRequest");
                 }
             ];
             for (var i = 0; i < tryThese.length; i++) {
                 var func = tryThese[i];
                 try {
                     self.XMLHttpRequest = func;
                     return func();
                 } catch (e) {
                     // pass
                 }
             }
         }
         return self.XMLHttpRequest();
     },
 
     _xhr_onreadystatechange: function (d) {
         // MochiKit.Logging.logDebug('this.readyState', this.readyState);
         var m = MochiKit.Base;
         if (this.readyState == 4) {
             // IE SUCKS
             try {
                 this.onreadystatechange = null;
             } catch (e) {
                 try {
                     this.onreadystatechange = m.noop;
                 } catch (e) {
                 }
             }
             var status = null;
             try {
                 status = this.status;
-                if (!status && m.isNotEmpty(this.responseText)) {
+                if (!status && (this.response || m.isNotEmpty(this.responseText))) {
                     // 0 or undefined seems to mean cached or local
                     status = 304;
                 }
             } catch (e) {
                 // pass
                 // MochiKit.Logging.logDebug('error getting status?', repr(items(e)));
             }
             // 200 is OK, 201 is CREATED, 204 is NO CONTENT
             // 304 is NOT MODIFIED, 1223 is apparently a bug in IE
             if (status == 200 || status == 201 || status == 204 ||
                     status == 304 || status == 1223) {
                 d.callback(this);
             } else {
                 var err = new MochiKit.Async.XMLHttpRequestError(this, "Request failed");
                 if (err.number) {
                     // XXX: This seems to happen on page change
                     d.errback(err);
                 } else {
                     // XXX: this seems to happen when the server is unreachable
                     d.errback(err);
                 }
             }
         }
     },
 
     _xhr_canceller: function (req) {
         // IE SUCKS
         try {
             req.onreadystatechange = null;
         } catch (e) {
             try {
                 req.onreadystatechange = MochiKit.Base.noop;
             } catch (e) {
             }
         }
         req.abort();
     },
 
 
     /** @id MochiKit.Async.sendXMLHttpRequest */
     sendXMLHttpRequest: function (req, /* optional */ sendContent) {
         if (typeof(sendContent) == "undefined" || sendContent === null) {
             sendContent = "";
         }
 
         var m = MochiKit.Base;
         var self = MochiKit.Async;
         var d = new self.Deferred(m.partial(self._xhr_canceller, req));
 
         try {
             req.onreadystatechange = m.bind(self._xhr_onreadystatechange,
                 req, d);
             req.send(sendContent);
         } catch (e) {
             try {
                 req.onreadystatechange = null;
             } catch (ignore) {
                 // pass
             }
             d.errback(e);
         }
 
         return d;
 
     },
 
     /** @id MochiKit.Async.doXHR */
     doXHR: function (url, opts) {
         /*
             Work around a Firefox bug by dealing with XHR during
             the next event loop iteration. Maybe it's this one:
             https://bugzilla.mozilla.org/show_bug.cgi?id=249843
         */
         var self = MochiKit.Async;
         return self.callLater(0, self._doXHR, url, opts);
     },
 
     _doXHR: function (url, opts) {
         var m = MochiKit.Base;
         opts = m.update({
             method: 'GET',
             sendContent: ''
             /*
             queryString: undefined,
             username: undefined,
             password: undefined,
             headers: undefined,
-            mimeType: undefined
+            mimeType: undefined,
+            responseType: undefined
             */
         }, opts);
         var self = MochiKit.Async;
         var req = self.getXMLHttpRequest();
         if (opts.queryString) {
             var qs = m.queryString(opts.queryString);
             if (qs) {
                 url += "?" + qs;
             }
         }
         // Safari will send undefined:undefined, so we have to check.
         // We can't use apply, since the function is native.
         if ('username' in opts) {
             req.open(opts.method, url, true, opts.username, opts.password);
         } else {
             req.open(opts.method, url, true);
         }
         if (req.overrideMimeType && opts.mimeType) {
             req.overrideMimeType(opts.mimeType);
         }
         req.setRequestHeader("X-Requested-With", "XMLHttpRequest");
         if (opts.headers) {
             var headers = opts.headers;
             if (!m.isArrayLike(headers)) {
                 headers = m.items(headers);
             }
             for (var i = 0; i < headers.length; i++) {
                 var header = headers[i];
                 var name = header[0];
                 var value = header[1];
                 req.setRequestHeader(name, value);
             }
         }
+        if ("responseType" in opts && "responseType" in req) {
+            req.responseType = opts.responseType;
+        }
         return self.sendXMLHttpRequest(req, opts.sendContent);
     },
 
     _buildURL: function (url/*, ...*/) {
         if (arguments.length > 1) {
             var m = MochiKit.Base;
             var qs = m.queryString.apply(null, m.extend(null, arguments, 1));
             if (qs) {
                 return url + "?" + qs;
             }
         }
         return url;
     },
 
     /** @id MochiKit.Async.doSimpleXMLHttpRequest */
     doSimpleXMLHttpRequest: function (url/*, ...*/) {
         var self = MochiKit.Async;
         url = self._buildURL.apply(self, arguments);
         return self.doXHR(url);
     },
 
     /** @id MochiKit.Async.loadJSONDoc */
     loadJSONDoc: function (url/*, ...*/) {
         var self = MochiKit.Async;
         url = self._buildURL.apply(self, arguments);
         var d = self.doXHR(url, {
             'mimeType': 'text/plain',
             'headers': [['Accept', 'application/json']]
         });
         d = d.addCallback(self.evalJSONRequest);
         return d;
     },
 
+    /** @id MochiKit.Async.loadScript */
+    loadScript: function (url) {
+        var d = new MochiKit.Async.Deferred();
+        var script = document.createElement("script");
+        script.type = "text/javascript";
+        script.src = url;
+        script.onload = function () {
+            script.onload = null;
+            script.onerror = null;
+            script.onreadystatechange = null;
+            script = null;
+            d.callback();
+        };
+        script.onerror = function (msg) {
+            script.onload = null;
+            script.onerror = null;
+            script.onreadystatechange = null;
+            script = null;
+            msg = "Failed to load script at " + url + ": " + msg;
+            d.errback(new URIError(msg, url));
+        }
+        script.onreadystatechange = function () {
+            if (script.readyState == "loaded" || script.readyState == "complete") {
+                script.onload();
+            } else {
+                // IE doesn't bother to report errors...
+                MochiKit.Async.callLater(10, script.onerror, "Script loading timed out")
+            }
+        };
+        document.getElementsByTagName("head")[0].appendChild(script);
+        return d;
+    },
+
     /** @id MochiKit.Async.wait */
     wait: function (seconds, /* optional */value) {
         var d = new MochiKit.Async.Deferred();
-        var m = MochiKit.Base;
-        if (typeof(value) != 'undefined') {
-            d.addCallback(function () { return value; });
-        }
-        var timeout = setTimeout(
-            m.bind("callback", d),
-            Math.floor(seconds * 1000));
+        var cb = MochiKit.Base.bind("callback", d, value);
+        var timeout = setTimeout(cb, Math.floor(seconds * 1000));
         d.canceller = function () {
             try {
                 clearTimeout(timeout);
             } catch (e) {
                 // pass
             }
         };
         return d;
     },
 
     /** @id MochiKit.Async.callLater */
     callLater: function (seconds, func) {
         var m = MochiKit.Base;
         var pfunc = m.partial.apply(m, m.extend(null, arguments, 1));
         return MochiKit.Async.wait(seconds).addCallback(
             function (res) { return pfunc(); }
         );
     }
 });
 
 
 /** @id MochiKit.Async.DeferredLock */
 MochiKit.Async.DeferredLock = function () {
     this.waiting = [];
     this.locked = false;
     this.id = this._nextId();
 };
 
 MochiKit.Async.DeferredLock.prototype = {
     __class__: MochiKit.Async.DeferredLock,
     /** @id MochiKit.Async.DeferredLock.prototype.acquire */
     acquire: function () {
         var d = new MochiKit.Async.Deferred();
         if (this.locked) {
             this.waiting.push(d);
         } else {
             this.locked = true;
             d.callback(this);
         }
         return d;
     },
     /** @id MochiKit.Async.DeferredLock.prototype.release */
     release: function () {
         if (!this.locked) {
             throw TypeError("Tried to release an unlocked DeferredLock");
         }
         this.locked = false;
         if (this.waiting.length > 0) {
             this.locked = true;
             this.waiting.shift().callback(this);
         }
     },
     _nextId: MochiKit.Base.counter(),
     repr: function () {
         var state;
         if (this.locked) {
             state = 'locked, ' + this.waiting.length + ' waiting';
         } else {
             state = 'unlocked';
         }
         return 'DeferredLock(' + this.id + ', ' + state + ')';
     },
     toString: MochiKit.Base.forwardCall("repr")
 
 };
 
 /** @id MochiKit.Async.DeferredList */
 MochiKit.Async.DeferredList = function (list, /* optional */fireOnOneCallback, fireOnOneErrback, consumeErrors, canceller) {
 
     // call parent constructor
     MochiKit.Async.Deferred.apply(this, [canceller]);
 
     this.list = list;
     var resultList = [];
     this.resultList = resultList;
 
     this.finishedCount = 0;
     this.fireOnOneCallback = fireOnOneCallback;
     this.fireOnOneErrback = fireOnOneErrback;
     this.consumeErrors = consumeErrors;
 
     var cb = MochiKit.Base.bind(this._cbDeferred, this);
     for (var i = 0; i < list.length; i++) {
         var d = list[i];
         resultList.push(undefined);
         d.addCallback(cb, i, true);
         d.addErrback(cb, i, false);
     }
 
     if (list.length === 0 && !fireOnOneCallback) {
         this.callback(this.resultList);
     }
 
 };
 
 MochiKit.Async.DeferredList.prototype = new MochiKit.Async.Deferred();
+MochiKit.Async.DeferredList.prototype.constructor = MochiKit.Async.DeferredList;
 
 MochiKit.Async.DeferredList.prototype._cbDeferred = function (index, succeeded, result) {
     this.resultList[index] = [succeeded, result];
     this.finishedCount += 1;
     if (this.fired == -1) {
         if (succeeded && this.fireOnOneCallback) {
             this.callback([index, result]);
         } else if (!succeeded && this.fireOnOneErrback) {
             this.errback(result);
         } else if (this.finishedCount == this.list.length) {
             this.callback(this.resultList);
         }
     }
     if (!succeeded && this.consumeErrors) {
         result = null;
     }
     return result;
 };
 
 /** @id MochiKit.Async.gatherResults */
 MochiKit.Async.gatherResults = function (deferredList) {
     var d = new MochiKit.Async.DeferredList(deferredList, false, true, false);
     d.addCallback(function (results) {
         var ret = [];
         for (var i = 0; i < results.length; i++) {
             ret.push(results[i][1]);
         }
         return ret;
     });
     return d;
 };
 
 /** @id MochiKit.Async.maybeDeferred */
 MochiKit.Async.maybeDeferred = function (func) {
     var self = MochiKit.Async;
     var result;
     try {
         var r = func.apply(null, MochiKit.Base.extend([], arguments, 1));
         if (r instanceof self.Deferred) {
             result = r;
         } else if (r instanceof Error) {
             result = self.fail(r);
         } else {
             result = self.succeed(r);
         }
     } catch (e) {
         result = self.fail(e);
     }
     return result;
 };
 
 
 MochiKit.Async.__new__ = function () {
     var m = MochiKit.Base;
     var ne = m.partial(m._newNamedError, this);
 
     ne("AlreadyCalledError",
         /** @id MochiKit.Async.AlreadyCalledError */
         function (deferred) {
             /***
 
             Raised by the Deferred if callback or errback happens
             after it was already fired.
 
             ***/
             this.deferred = deferred;
         }
     );
 
     ne("CancelledError",
         /** @id MochiKit.Async.CancelledError */
         function (deferred) {
             /***
 
             Raised by the Deferred cancellation mechanism.
 
             ***/
             this.deferred = deferred;
         }
     );
 
     ne("BrowserComplianceError",
         /** @id MochiKit.Async.BrowserComplianceError */
         function (msg) {
             /***
 
             Raised when the JavaScript runtime is not capable of performing
             the given function.  Technically, this should really never be
             raised because a non-conforming JavaScript runtime probably
             isn't going to support exceptions in the first place.
 
             ***/
             this.message = msg;
         }
     );
 
     ne("GenericError",
         /** @id MochiKit.Async.GenericError */
         function (msg) {
             this.message = msg;
         }
     );
 
     ne("XMLHttpRequestError",
         /** @id MochiKit.Async.XMLHttpRequestError */
         function (req, msg) {
             /***
 
             Raised when an XMLHttpRequest does not complete for any reason.
 
             ***/
             this.req = req;
             this.message = msg;
             try {
                 // Strange but true that this can raise in some cases.
                 this.number = req.status;
             } catch (e) {
                 // pass
             }
         }
     );
 
     m.nameFunctions(this);
 };
 
 MochiKit.Async.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.Async);
diff --git a/frontend/gamma/js/MochiKit/Base.js b/frontend/gamma/js/MochiKit/Base.js
index d33c269..ca1734c 100644
--- a/frontend/gamma/js/MochiKit/Base.js
+++ b/frontend/gamma/js/MochiKit/Base.js
@@ -1,1452 +1,1500 @@
 /***
 
 MochiKit.Base 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-if (typeof(MochiKit) == 'undefined') {
-    MochiKit = {};
-}
+
+// MochiKit module (namespace)
+var MochiKit = MochiKit || {};
 if (typeof(MochiKit.__export__) == "undefined") {
     MochiKit.__export__ = true;
 }
-if (typeof(MochiKit.Base) == 'undefined') {
-    MochiKit.Base = {};
-}
+MochiKit.NAME = "MochiKit";
+MochiKit.VERSION = "1.5";
+MochiKit.__repr__ = function () {
+    return "[" + this.NAME + " " + this.VERSION + "]";
+};
+MochiKit.toString = function () {
+    return this.__repr__();
+};
+
+
+// MochiKit.Base module
+MochiKit.Base = MochiKit.Base || {};
 
 /**
- * Registers a new MochiKit module. This function will insert a new
- * property into the "MochiKit" object, making sure that all
- * dependency modules have already been inserted. It will also make
- * sure that the appropriate properties and default module functions
- * are defined.
+ * Creates a new module in a parent namespace. This function will
+ * create a new empty module object with "NAME", "VERSION",
+ * "toString" and "__repr__" properties. This object will be inserted into the parent object
+ * using the specified name (i.e. parent[name] = module). It will
+ * also verify that all the dependency modules are defined in the
+ * parent, or an error will be thrown.
  *
+ * @param {Object} parent the parent module (use "this" or "window" for
+ *            a global module)
  * @param {String} name the module name, e.g. "Base"
  * @param {String} version the module version, e.g. "1.5"
- * @param {Array} deps the array of module dependencies (as strings)
+ * @param {Array} [deps] the array of module dependencies (as strings)
  */
-MochiKit.Base._module = function (name, version, deps) {
-    if (!(name in MochiKit)) {
-        MochiKit[name] = {};
-    }
-    var module = MochiKit[name];
-    module.NAME = "MochiKit." + name;
+MochiKit.Base.module = function (parent, name, version, deps) {
+    var module = parent[name] = parent[name] || {};
+    var prefix = (parent.NAME ? parent.NAME + "." : "");
+    module.NAME = prefix + name;
     module.VERSION = version;
     module.__repr__ = function () {
         return "[" + this.NAME + " " + this.VERSION + "]";
     };
     module.toString = function () {
         return this.__repr__();
     };
-    for (var i = 0; i < deps.length; i++) {
-        if (!(deps[i] in MochiKit)) {
-            throw 'MochiKit.' + name + ' depends on MochiKit.' + deps[i] + '!';
+    for (var i = 0; deps != null && i < deps.length; i++) {
+        if (!(deps[i] in parent)) {
+            throw module.NAME + ' depends on ' + prefix + deps[i] + '!';
         }
     }
-}
+    return module;
+};
 
-MochiKit.Base._module("Base", "1.5", []);
+MochiKit.Base.module(MochiKit, "Base", "1.5", []);
 
 /** @id MochiKit.Base.update */
 MochiKit.Base.update = function (self, obj/*, ... */) {
     if (self === null || self === undefined) {
         self = {};
     }
     for (var i = 1; i < arguments.length; i++) {
         var o = arguments[i];
         if (typeof(o) != 'undefined' && o !== null) {
             for (var k in o) {
                 self[k] = o[k];
             }
         }
     }
     return self;
 };
 
 MochiKit.Base.update(MochiKit.Base, {
     /** @id MochiKit.Base.camelize */
     camelize: function (selector) {
         /* from dojo.style.toCamelCase */
         var arr = selector.split('-');
         var cc = arr[0];
         for (var i = 1; i < arr.length; i++) {
             cc += arr[i].charAt(0).toUpperCase() + arr[i].substring(1);
         }
         return cc;
     },
 
     /** @id MochiKit.Base.counter */
     counter: function (n/* = 1 */) {
         if (arguments.length === 0) {
             n = 1;
         }
         return function () {
             return n++;
         };
     },
 
     /** @id MochiKit.Base.clone */
     clone: function (obj) {
         var me = arguments.callee;
         if (arguments.length == 1) {
             me.prototype = obj;
             return new me();
         }
     },
     
     _flattenArray: function (res, lst) {
         for (var i = 0; i < lst.length; i++) {
             var o = lst[i];
             if (o instanceof Array) {
                 arguments.callee(res, o);
             } else {
                 res.push(o);
             }
         }
         return res;
     },
 
     /** @id MochiKit.Base.flattenArray */
     flattenArray: function (lst) {
         return MochiKit.Base._flattenArray([], lst);
     },
 
     /** @id MochiKit.Base.flattenArguments */
     flattenArguments: function (lst/* ...*/) {
         var res = [];
         var m = MochiKit.Base;
         var args = m.extend(null, arguments);
         while (args.length) {
             var o = args.shift();
             if (o && typeof(o) == "object" && typeof(o.length) == "number") {
                 for (var i = o.length - 1; i >= 0; i--) {
                     args.unshift(o[i]);
                 }
             } else {
                 res.push(o);
             }
         }
         return res;
     },
 
     /** @id MochiKit.Base.extend */
     extend: function (self, obj, /* optional */skip) {
         // Extend an array with an array-like object starting
         // from the skip index
         if (!skip) {
             skip = 0;
         }
         if (obj) {
             // allow iterable fall-through, but skip the full isArrayLike
             // check for speed, this is called often.
             var l = obj.length;
             if (typeof(l) != 'number' /* !isArrayLike(obj) */) {
                 if (typeof(MochiKit.Iter) != "undefined") {
                     obj = MochiKit.Iter.list(obj);
                     l = obj.length;
                 } else {
                     throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
                 }
             }
             if (!self) {
                 self = [];
             }
             for (var i = skip; i < l; i++) {
                 self.push(obj[i]);
             }
         }
         // This mutates, but it's convenient to return because
         // it's often used like a constructor when turning some
         // ghetto array-like to a real array
         return self;
     },
 
 
     /** @id MochiKit.Base.updatetree */
     updatetree: function (self, obj/*, ...*/) {
         if (self === null || self === undefined) {
             self = {};
         }
         for (var i = 1; i < arguments.length; i++) {
             var o = arguments[i];
             if (typeof(o) != 'undefined' && o !== null) {
                 for (var k in o) {
                     var v = o[k];
                     if (typeof(self[k]) == 'object' && typeof(v) == 'object') {
                         arguments.callee(self[k], v);
                     } else {
                         self[k] = v;
                     }
                 }
             }
         }
         return self;
     },
 
     /** @id MochiKit.Base.setdefault */
     setdefault: function (self, obj/*, ...*/) {
         if (self === null || self === undefined) {
             self = {};
         }
         for (var i = 1; i < arguments.length; i++) {
             var o = arguments[i];
             for (var k in o) {
                 if (!(k in self)) {
                     self[k] = o[k];
                 }
             }
         }
         return self;
     },
 
     /** @id MochiKit.Base.keys */
     keys: function (obj) {
         var rval = [];
         for (var prop in obj) {
             rval.push(prop);
         }
         return rval;
     },
 
     /** @id MochiKit.Base.values */
     values: function (obj) {
         var rval = [];
         for (var prop in obj) {
             rval.push(obj[prop]);
         }
         return rval;
     },
 
      /** @id MochiKit.Base.items */
     items: function (obj) {
         var rval = [];
         var e;
         for (var prop in obj) {
             var v;
             try {
                 v = obj[prop];
             } catch (e) {
                 continue;
             }
             rval.push([prop, v]);
         }
         return rval;
     },
 
 
     _newNamedError: function (module, name, func) {
         func.prototype = new MochiKit.Base.NamedError(module.NAME + "." + name);
+        func.prototype.constructor = func;
         module[name] = func;
     },
 
 
     /** @id MochiKit.Base.operator */
     operator: {
         // unary logic operators
         /** @id MochiKit.Base.truth */
         truth: function (a) { return !!a; },
         /** @id MochiKit.Base.lognot */
         lognot: function (a) { return !a; },
         /** @id MochiKit.Base.identity */
         identity: function (a) { return a; },
 
         // bitwise unary operators
         /** @id MochiKit.Base.not */
         not: function (a) { return ~a; },
         /** @id MochiKit.Base.neg */
         neg: function (a) { return -a; },
 
         // binary operators
         /** @id MochiKit.Base.add */
         add: function (a, b) { return a + b; },
         /** @id MochiKit.Base.sub */
         sub: function (a, b) { return a - b; },
         /** @id MochiKit.Base.div */
         div: function (a, b) { return a / b; },
         /** @id MochiKit.Base.mod */
         mod: function (a, b) { return a % b; },
         /** @id MochiKit.Base.mul */
         mul: function (a, b) { return a * b; },
 
         // bitwise binary operators
         /** @id MochiKit.Base.and */
         and: function (a, b) { return a & b; },
         /** @id MochiKit.Base.or */
         or: function (a, b) { return a | b; },
         /** @id MochiKit.Base.xor */
         xor: function (a, b) { return a ^ b; },
         /** @id MochiKit.Base.lshift */
         lshift: function (a, b) { return a << b; },
         /** @id MochiKit.Base.rshift */
         rshift: function (a, b) { return a >> b; },
         /** @id MochiKit.Base.zrshift */
         zrshift: function (a, b) { return a >>> b; },
 
         // near-worthless built-in comparators
         /** @id MochiKit.Base.eq */
         eq: function (a, b) { return a == b; },
         /** @id MochiKit.Base.ne */
         ne: function (a, b) { return a != b; },
         /** @id MochiKit.Base.gt */
         gt: function (a, b) { return a > b; },
         /** @id MochiKit.Base.ge */
         ge: function (a, b) { return a >= b; },
         /** @id MochiKit.Base.lt */
         lt: function (a, b) { return a < b; },
         /** @id MochiKit.Base.le */
         le: function (a, b) { return a <= b; },
 
         // strict built-in comparators
         seq: function (a, b) { return a === b; },
         sne: function (a, b) { return a !== b; },
 
         // compare comparators
         /** @id MochiKit.Base.ceq */
         ceq: function (a, b) { return MochiKit.Base.compare(a, b) === 0; },
         /** @id MochiKit.Base.cne */
         cne: function (a, b) { return MochiKit.Base.compare(a, b) !== 0; },
         /** @id MochiKit.Base.cgt */
         cgt: function (a, b) { return MochiKit.Base.compare(a, b) == 1; },
         /** @id MochiKit.Base.cge */
         cge: function (a, b) { return MochiKit.Base.compare(a, b) != -1; },
         /** @id MochiKit.Base.clt */
         clt: function (a, b) { return MochiKit.Base.compare(a, b) == -1; },
         /** @id MochiKit.Base.cle */
         cle: function (a, b) { return MochiKit.Base.compare(a, b) != 1; },
 
         // binary logical operators
         /** @id MochiKit.Base.logand */
         logand: function (a, b) { return a && b; },
         /** @id MochiKit.Base.logor */
         logor: function (a, b) { return a || b; },
         /** @id MochiKit.Base.contains */
         contains: function (a, b) { return b in a; }
     },
 
     /** @id MochiKit.Base.forwardCall */
     forwardCall: function (func) {
         return function () {
             return this[func].apply(this, arguments);
         };
     },
 
     /** @id MochiKit.Base.itemgetter */
     itemgetter: function (func) {
         return function (arg) {
             return arg[func];
         };
     },
 
     /** @id MochiKit.Base.bool */
     bool: function (value) {
         if (typeof(value) === "boolean" || value instanceof Boolean) {
             return value.valueOf();
         } else if (typeof(value) === "string" || value instanceof String) {
             return value.length > 0 && value != "false" && value != "null" &&
                    value != "undefined" && value != "0";
         } else if (typeof(value) === "number" || value instanceof Number) {
             return !isNaN(value) && value != 0;
         } else if (value != null && typeof(value.length) === "number") {
-            return value.length !== 0
+            return value.length !== 0;
         } else {
             return value != null;
         }
     },
 
     /** @id MochiKit.Base.typeMatcher */
     typeMatcher: function (/* typ */) {
         var types = {};
         for (var i = 0; i < arguments.length; i++) {
             var typ = arguments[i];
             types[typ] = typ;
         }
         return function () {
             for (var i = 0; i < arguments.length; i++) {
                 if (!(typeof(arguments[i]) in types)) {
                     return false;
                 }
             }
             return true;
         };
     },
 
     /** @id MochiKit.Base.isNull */
     isNull: function (/* ... */) {
         for (var i = 0; i < arguments.length; i++) {
             if (arguments[i] !== null) {
                 return false;
             }
         }
         return true;
     },
 
     /** @id MochiKit.Base.isUndefinedOrNull */
     isUndefinedOrNull: function (/* ... */) {
         for (var i = 0; i < arguments.length; i++) {
             var o = arguments[i];
             if (!(typeof(o) == 'undefined' || o === null)) {
                 return false;
             }
         }
         return true;
     },
 
     /** @id MochiKit.Base.isEmpty */
     isEmpty: function (obj) {
         return !MochiKit.Base.isNotEmpty.apply(this, arguments);
     },
 
     /** @id MochiKit.Base.isNotEmpty */
     isNotEmpty: function (obj) {
         for (var i = 0; i < arguments.length; i++) {
             var o = arguments[i];
             if (!(o && o.length)) {
                 return false;
             }
         }
         return true;
     },
 
     /** @id MochiKit.Base.isArrayLike */
     isArrayLike: function () {
         for (var i = 0; i < arguments.length; i++) {
             var o = arguments[i];
             var typ = typeof(o);
             if (
                 (typ != 'object' && !(typ == 'function' && typeof(o.item) == 'function')) ||
                 o === null ||
                 typeof(o.length) != 'number' ||
                 o.nodeType === 3 ||
                 o.nodeType === 4
             ) {
                 return false;
             }
         }
         return true;
     },
 
     /** @id MochiKit.Base.isDateLike */
     isDateLike: function () {
         for (var i = 0; i < arguments.length; i++) {
             var o = arguments[i];
             if (typeof(o) != "object" || o === null
                     || typeof(o.getTime) != 'function') {
                 return false;
             }
         }
         return true;
     },
 
 
     /** @id MochiKit.Base.xmap */
     xmap: function (fn/*, obj... */) {
         if (fn === null) {
             return MochiKit.Base.extend(null, arguments, 1);
         }
         var rval = [];
         for (var i = 1; i < arguments.length; i++) {
             rval.push(fn(arguments[i]));
         }
         return rval;
     },
 
     /** @id MochiKit.Base.map */
     map: function (fn, lst/*, lst... */) {
         var m = MochiKit.Base;
         var itr = MochiKit.Iter;
         var isArrayLike = m.isArrayLike;
         if (arguments.length <= 2) {
             // allow an iterable to be passed
             if (!isArrayLike(lst)) {
                 if (itr) {
                     // fast path for map(null, iterable)
                     lst = itr.list(lst);
                     if (fn === null) {
                         return lst;
                     }
                 } else {
                     throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
                 }
             }
             // fast path for map(null, lst)
             if (fn === null) {
                 return m.extend(null, lst);
             }
             // disabled fast path for map(fn, lst)
             /*
             if (false && typeof(Array.prototype.map) == 'function') {
                 // Mozilla fast-path
                 return Array.prototype.map.call(lst, fn);
             }
             */
             var rval = [];
             for (var i = 0; i < lst.length; i++) {
                 rval.push(fn(lst[i]));
             }
             return rval;
         } else {
             // default for map(null, ...) is zip(...)
             if (fn === null) {
                 fn = Array;
             }
             var length = null;
             for (var i = 1; i < arguments.length; i++) {
                 // allow iterables to be passed
                 if (!isArrayLike(arguments[i])) {
                     if (itr) {
                         return itr.list(itr.imap.apply(null, arguments));
                     } else {
                         throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
                     }
                 }
                 // find the minimum length
                 var l = arguments[i].length;
                 if (length === null || length > l) {
                     length = l;
                 }
             }
             rval = [];
             for (var i = 0; i < length; i++) {
                 var args = [];
                 for (var j = 1; j < arguments.length; j++) {
                     args.push(arguments[j][i]);
                 }
                 rval.push(fn.apply(this, args));
             }
             return rval;
         }
     },
 
     /** @id MochiKit.Base.xfilter */
     xfilter: function (fn/*, obj... */) {
         var rval = [];
         if (fn === null) {
             fn = MochiKit.Base.operator.truth;
         }
         for (var i = 1; i < arguments.length; i++) {
             var o = arguments[i];
             if (fn(o)) {
                 rval.push(o);
             }
         }
         return rval;
     },
 
     /** @id MochiKit.Base.filter */
     filter: function (fn, lst, self) {
         var rval = [];
         // allow an iterable to be passed
         var m = MochiKit.Base;
         if (!m.isArrayLike(lst)) {
             if (MochiKit.Iter) {
                 lst = MochiKit.Iter.list(lst);
             } else {
                 throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
             }
         }
         if (fn === null) {
             fn = m.operator.truth;
         }
         if (typeof(Array.prototype.filter) == 'function') {
             // Mozilla fast-path
             return Array.prototype.filter.call(lst, fn, self);
         } else if (typeof(self) == 'undefined' || self === null) {
             for (var i = 0; i < lst.length; i++) {
                 var o = lst[i];
                 if (fn(o)) {
                     rval.push(o);
                 }
             }
         } else {
             for (var i = 0; i < lst.length; i++) {
                 o = lst[i];
                 if (fn.call(self, o)) {
                     rval.push(o);
                 }
             }
         }
         return rval;
     },
 
 
     _wrapDumbFunction: function (func) {
         return function () {
             // fast path!
             switch (arguments.length) {
                 case 0: return func();
                 case 1: return func(arguments[0]);
                 case 2: return func(arguments[0], arguments[1]);
                 case 3: return func(arguments[0], arguments[1], arguments[2]);
             }
             var args = [];
             for (var i = 0; i < arguments.length; i++) {
                 args.push("arguments[" + i + "]");
             }
             return eval("(func(" + args.join(",") + "))");
         };
     },
 
     /** @id MochiKit.Base.methodcaller */
     methodcaller: function (func/*, args... */) {
         var args = MochiKit.Base.extend(null, arguments, 1);
         if (typeof(func) == "function") {
             return function (obj) {
                 return func.apply(obj, args);
             };
         } else {
             return function (obj) {
                 return obj[func].apply(obj, args);
             };
         }
     },
 
     /** @id MochiKit.Base.method */
     method: function (self, func) {
         var m = MochiKit.Base;
         return m.bind.apply(this, m.extend([func, self], arguments, 2));
     },
 
     /** @id MochiKit.Base.compose */
     compose: function (f1, f2/*, f3, ... fN */) {
         var fnlist = [];
         var m = MochiKit.Base;
         if (arguments.length === 0) {
             throw new TypeError("compose() requires at least one argument");
         }
         for (var i = 0; i < arguments.length; i++) {
             var fn = arguments[i];
             if (typeof(fn) != "function") {
                 throw new TypeError(m.repr(fn) + " is not a function");
             }
             fnlist.push(fn);
         }
         return function () {
             var args = arguments;
             for (var i = fnlist.length - 1; i >= 0; i--) {
                 args = [fnlist[i].apply(this, args)];
             }
             return args[0];
         };
     },
 
     /** @id MochiKit.Base.bind */
     bind: function (func, self/* args... */) {
         if (typeof(func) == "string") {
             func = self[func];
         }
         var im_func = func.im_func;
         var im_preargs = func.im_preargs;
         var im_self = func.im_self;
         var m = MochiKit.Base;
         if (typeof(func) == "function" && typeof(func.apply) == "undefined") {
             // this is for cases where JavaScript sucks ass and gives you a
             // really dumb built-in function like alert() that doesn't have
             // an apply
             func = m._wrapDumbFunction(func);
         }
         if (typeof(im_func) != 'function') {
             im_func = func;
         }
         if (typeof(self) != 'undefined') {
             im_self = self;
         }
         if (typeof(im_preargs) == 'undefined') {
             im_preargs = [];
         } else  {
             im_preargs = im_preargs.slice();
         }
         m.extend(im_preargs, arguments, 2);
         var newfunc = function () {
             var args = arguments;
             var me = arguments.callee;
             if (me.im_preargs.length > 0) {
                 args = m.concat(me.im_preargs, args);
             }
             var self = me.im_self;
             if (!self) {
                 self = this;
             }
             return me.im_func.apply(self, args);
         };
         newfunc.im_self = im_self;
         newfunc.im_func = im_func;
         newfunc.im_preargs = im_preargs;
+        if (typeof(im_func.NAME) == 'string') {
+            newfunc.NAME = "bind(" + im_func.NAME + ",...)";
+        }
         return newfunc;
     },
 
     /** @id MochiKit.Base.bindLate */
     bindLate: function (func, self/* args... */) {
         var m = MochiKit.Base;
         var args = arguments;
         if (typeof(func) === "string") {
             args = m.extend([m.forwardCall(func)], arguments, 1);
             return m.bind.apply(this, args);
         }
         return m.bind.apply(this, args);
     },
 
     /** @id MochiKit.Base.bindMethods */
     bindMethods: function (self) {
         var bind = MochiKit.Base.bind;
         for (var k in self) {
             var func = self[k];
             if (typeof(func) == 'function') {
                 self[k] = bind(func, self);
             }
         }
     },
 
     /** @id MochiKit.Base.registerComparator */
     registerComparator: function (name, check, comparator, /* optional */ override) {
         MochiKit.Base.comparatorRegistry.register(name, check, comparator, override);
     },
 
     _primitives: {'boolean': true, 'string': true, 'number': true},
 
     /** @id MochiKit.Base.compare */
     compare: function (a, b) {
         if (a == b) {
             return 0;
         }
         var aIsNull = (typeof(a) == 'undefined' || a === null);
         var bIsNull = (typeof(b) == 'undefined' || b === null);
         if (aIsNull && bIsNull) {
             return 0;
         } else if (aIsNull) {
             return -1;
         } else if (bIsNull) {
             return 1;
         }
         var m = MochiKit.Base;
         // bool, number, string have meaningful comparisons
         var prim = m._primitives;
         if (!(typeof(a) in prim && typeof(b) in prim)) {
             try {
                 return m.comparatorRegistry.match(a, b);
             } catch (e) {
                 if (e != m.NotFound) {
                     throw e;
                 }
             }
         }
         if (a < b) {
             return -1;
         } else if (a > b) {
             return 1;
         }
         // These types can't be compared
         var repr = m.repr;
         throw new TypeError(repr(a) + " and " + repr(b) + " can not be compared");
     },
 
     /** @id MochiKit.Base.compareDateLike */
     compareDateLike: function (a, b) {
         return MochiKit.Base.compare(a.getTime(), b.getTime());
     },
 
     /** @id MochiKit.Base.compareArrayLike */
     compareArrayLike: function (a, b) {
         var compare = MochiKit.Base.compare;
         var count = a.length;
         var rval = 0;
         if (count > b.length) {
             rval = 1;
             count = b.length;
         } else if (count < b.length) {
             rval = -1;
         }
         for (var i = 0; i < count; i++) {
             var cmp = compare(a[i], b[i]);
             if (cmp) {
                 return cmp;
             }
         }
         return rval;
     },
 
     /** @id MochiKit.Base.registerRepr */
     registerRepr: function (name, check, wrap, /* optional */override) {
         MochiKit.Base.reprRegistry.register(name, check, wrap, override);
     },
 
     /** @id MochiKit.Base.repr */
     repr: function (o) {
         if (typeof(o) == "undefined") {
             return "undefined";
         } else if (o === null) {
             return "null";
         }
         try {
             if (typeof(o.__repr__) == 'function') {
                 return o.__repr__();
             } else if (typeof(o.repr) == 'function' && o.repr != arguments.callee) {
                 return o.repr();
             }
             return MochiKit.Base.reprRegistry.match(o);
         } catch (e) {
-            if (typeof(o.NAME) == 'string' && (
-                    o.toString == Function.prototype.toString ||
-                    o.toString == Object.prototype.toString
-                )) {
-                return o.NAME;
+            try {
+                if (typeof(o.NAME) == 'string' && (
+                        o.toString == Function.prototype.toString ||
+                        o.toString == Object.prototype.toString
+                    )) {
+                    return o.NAME;
+                }
+            } catch (ignore) {
             }
         }
         try {
             var ostring = (o + "");
         } catch (e) {
             return "[" + typeof(o) + "]";
         }
         if (typeof(o) == "function") {
             ostring = ostring.replace(/^\s+/, "").replace(/\s+/g, " ");
             ostring = ostring.replace(/,(\S)/, ", $1");
             var idx = ostring.indexOf("{");
             if (idx != -1) {
                 ostring = ostring.substr(0, idx) + "{...}";
             }
         }
         return ostring;
     },
 
     /** @id MochiKit.Base.reprArrayLike */
     reprArrayLike: function (o) {
         var m = MochiKit.Base;
         return "[" + m.map(m.repr, o).join(", ") + "]";
     },
 
     /** @id MochiKit.Base.reprString */
     reprString: function (o) {
         return ('"' + o.replace(/(["\\])/g, '\\$1') + '"'
             ).replace(/[\f]/g, "\\f"
             ).replace(/[\b]/g, "\\b"
             ).replace(/[\n]/g, "\\n"
             ).replace(/[\t]/g, "\\t"
             ).replace(/[\v]/g, "\\v"
             ).replace(/[\r]/g, "\\r");
     },
 
     /** @id MochiKit.Base.reprNumber */
     reprNumber: function (o) {
         return o + "";
     },
 
     /** @id MochiKit.Base.registerJSON */
     registerJSON: function (name, check, wrap, /* optional */override) {
         MochiKit.Base.jsonRegistry.register(name, check, wrap, override);
     },
 
 
     /** @id MochiKit.Base.evalJSON */
-    evalJSON: function () {
-        return eval("(" + MochiKit.Base._filterJSON(arguments[0]) + ")");
+    evalJSON: function (jsonText) {
+        return eval("(" + MochiKit.Base._filterJSON(jsonText) + ")");
     },
 
     _filterJSON: function (s) {
         var m = s.match(/^\s*\/\*(.*)\*\/\s*$/);
-        if (m) {
-            return m[1];
-        }
-        return s;
+        return (m) ? m[1] : s;
     },
 
     /** @id MochiKit.Base.serializeJSON */
     serializeJSON: function (o) {
         var objtype = typeof(o);
         if (objtype == "number" || objtype == "boolean") {
             return o + "";
         } else if (o === null) {
             return "null";
         } else if (objtype == "string") {
             var res = "";
             for (var i = 0; i < o.length; i++) {
                 var c = o.charAt(i);
                 if (c == '\"') {
                     res += '\\"';
                 } else if (c == '\\') {
                     res += '\\\\';
                 } else if (c == '\b') {
                     res += '\\b';
                 } else if (c == '\f') {
                     res += '\\f';
                 } else if (c == '\n') {
                     res += '\\n';
                 } else if (c == '\r') {
                     res += '\\r';
                 } else if (c == '\t') {
                     res += '\\t';
                 } else if (o.charCodeAt(i) <= 0x1F) {
                     var hex = o.charCodeAt(i).toString(16);
                     if (hex.length < 2) {
                         hex = '0' + hex;
                     }
                     res += '\\u00' + hex.toUpperCase();
                 } else {
                     res += c;
                 }
             }
             return '"' + res + '"';
         }
         // recurse
         var me = arguments.callee;
         // short-circuit for objects that support "json" serialization
         // if they return "self" then just pass-through...
         var newObj;
+        if (typeof(o.toJSON) == "function") {
+            newObj = o.toJSON();
+            if (o !== newObj) {
+                return me(newObj);
+            }
+        }
         if (typeof(o.__json__) == "function") {
             newObj = o.__json__();
             if (o !== newObj) {
                 return me(newObj);
             }
         }
         if (typeof(o.json) == "function") {
             newObj = o.json();
             if (o !== newObj) {
                 return me(newObj);
             }
         }
         // array
         if (objtype != "function" && typeof(o.length) == "number") {
             var res = [];
             for (var i = 0; i < o.length; i++) {
                 var val = me(o[i]);
                 if (typeof(val) != "string") {
                     // skip non-serializable values
                     continue;
                 }
                 res.push(val);
             }
             return "[" + res.join(", ") + "]";
         }
         // look in the registry
         var m = MochiKit.Base;
         try {
             newObj = m.jsonRegistry.match(o);
             if (o !== newObj) {
                 return me(newObj);
             }
         } catch (e) {
             if (e != m.NotFound) {
                 // something really bad happened
                 throw e;
             }
         }
         // undefined is outside of the spec
         if (objtype == "undefined") {
             throw new TypeError("undefined can not be serialized as JSON");
         }
         // it's a function with no adapter, bad
         if (objtype == "function") {
             return null;
         }
         // generic object code path
         res = [];
         for (var k in o) {
             var useKey;
             if (typeof(k) == "number") {
                 useKey = '"' + k + '"';
             } else if (typeof(k) == "string") {
                 useKey = me(k);
             } else {
                 // skip non-string or number keys
                 continue;
             }
             val = me(o[k]);
             if (typeof(val) != "string") {
                 // skip non-serializable values
                 continue;
             }
             res.push(useKey + ":" + val);
         }
         return "{" + res.join(", ") + "}";
     },
 
 
     /** @id MochiKit.Base.objEqual */
     objEqual: function (a, b) {
         return (MochiKit.Base.compare(a, b) === 0);
     },
 
     /** @id MochiKit.Base.arrayEqual */
     arrayEqual: function (self, arr) {
         if (self.length != arr.length) {
             return false;
         }
         return (MochiKit.Base.compare(self, arr) === 0);
     },
 
     /** @id MochiKit.Base.concat */
     concat: function (/* lst... */) {
         var rval = [];
         var extend = MochiKit.Base.extend;
         for (var i = 0; i < arguments.length; i++) {
             extend(rval, arguments[i]);
         }
         return rval;
     },
 
     /** @id MochiKit.Base.keyComparator */
     keyComparator: function (key/* ... */) {
         // fast-path for single key comparisons
         var m = MochiKit.Base;
         var compare = m.compare;
         if (arguments.length == 1) {
             return function (a, b) {
                 return compare(a[key], b[key]);
             };
         }
         var compareKeys = m.extend(null, arguments);
         return function (a, b) {
             var rval = 0;
             // keep comparing until something is inequal or we run out of
             // keys to compare
             for (var i = 0; (rval === 0) && (i < compareKeys.length); i++) {
                 var key = compareKeys[i];
                 rval = compare(a[key], b[key]);
             }
             return rval;
         };
     },
 
     /** @id MochiKit.Base.reverseKeyComparator */
     reverseKeyComparator: function (key) {
         var comparator = MochiKit.Base.keyComparator.apply(this, arguments);
         return function (a, b) {
             return comparator(b, a);
         };
     },
 
     /** @id MochiKit.Base.partial */
     partial: function (func) {
         var m = MochiKit.Base;
         return m.bind.apply(this, m.extend([func, undefined], arguments, 1));
     },
 
     /** @id MochiKit.Base.listMinMax */
     listMinMax: function (which, lst) {
         if (lst.length === 0) {
             return null;
         }
         var cur = lst[0];
         var compare = MochiKit.Base.compare;
         for (var i = 1; i < lst.length; i++) {
             var o = lst[i];
             if (compare(o, cur) == which) {
                 cur = o;
             }
         }
         return cur;
     },
 
     /** @id MochiKit.Base.objMax */
     objMax: function (/* obj... */) {
         return MochiKit.Base.listMinMax(1, arguments);
     },
 
     /** @id MochiKit.Base.objMin */
     objMin: function (/* obj... */) {
         return MochiKit.Base.listMinMax(-1, arguments);
     },
 
     /** @id MochiKit.Base.findIdentical */
     findIdentical: function (lst, value, start/* = 0 */, /* optional */end) {
         if (typeof(end) == "undefined" || end === null) {
             end = lst.length;
         }
         if (typeof(start) == "undefined" || start === null) {
             start = 0;
         }
         for (var i = start; i < end; i++) {
             if (lst[i] === value) {
                 return i;
             }
         }
         return -1;
     },
 
     /** @id MochiKit.Base.mean */
     mean: function(/* lst... */) {
         /* http://www.nist.gov/dads/HTML/mean.html */
         var sum = 0;
 
         var m = MochiKit.Base;
         var args = m.extend(null, arguments);
         var count = args.length;
 
         while (args.length) {
             var o = args.shift();
             if (o && typeof(o) == "object" && typeof(o.length) == "number") {
                 count += o.length - 1;
                 for (var i = o.length - 1; i >= 0; i--) {
                     sum += o[i];
                 }
             } else {
                 sum += o;
             }
         }
 
         if (count <= 0) {
             throw new TypeError('mean() requires at least one argument');
         }
 
         return sum/count;
     },
 
     /** @id MochiKit.Base.median */
     median: function(/* lst... */) {
         /* http://www.nist.gov/dads/HTML/median.html */
         var data = MochiKit.Base.flattenArguments(arguments);
         if (data.length === 0) {
             throw new TypeError('median() requires at least one argument');
         }
-        data.sort(compare);
+        data.sort(MochiKit.Base.compare);
         if (data.length % 2 == 0) {
             var upper = data.length / 2;
             return (data[upper] + data[upper - 1]) / 2;
         } else {
             return data[(data.length - 1) / 2];
         }
     },
 
     /** @id MochiKit.Base.findValue */
     findValue: function (lst, value, start/* = 0 */, /* optional */end) {
         if (typeof(end) == "undefined" || end === null) {
             end = lst.length;
         }
         if (typeof(start) == "undefined" || start === null) {
             start = 0;
         }
         var cmp = MochiKit.Base.compare;
         for (var i = start; i < end; i++) {
             if (cmp(lst[i], value) === 0) {
                 return i;
             }
         }
         return -1;
     },
 
     /** @id MochiKit.Base.nodeWalk */
     nodeWalk: function (node, visitor) {
         var nodes = [node];
         var extend = MochiKit.Base.extend;
         while (nodes.length) {
             var res = visitor(nodes.shift());
             if (res) {
                 extend(nodes, res);
             }
         }
     },
 
 
     /** @id MochiKit.Base.nameFunctions */
     nameFunctions: function (namespace) {
         var base = namespace.NAME;
         if (typeof(base) == 'undefined') {
             base = '';
         } else {
             base = base + '.';
         }
         for (var name in namespace) {
             var o = namespace[name];
             if (typeof(o) == 'function' && typeof(o.NAME) == 'undefined') {
                 try {
                     o.NAME = base + name;
                 } catch (e) {
                     // pass
                 }
             }
         }
     },
 
 
     /** @id MochiKit.Base.queryString */
     queryString: function (names, values) {
         // check to see if names is a string or a DOM element, and if
         // MochiKit.DOM is available.  If so, drop it like it's a form
         // Ugliest conditional in MochiKit?  Probably!
         if (typeof(MochiKit.DOM) != "undefined" && arguments.length == 1
             && (typeof(names) == "string" || (
                 typeof(names.nodeType) != "undefined" && names.nodeType > 0
             ))
         ) {
             var kv = MochiKit.DOM.formContents(names);
             names = kv[0];
             values = kv[1];
         } else if (arguments.length == 1) {
             // Allow the return value of formContents to be passed directly
             if (typeof(names.length) == "number" && names.length == 2) {
                 return arguments.callee(names[0], names[1]);
             }
             var o = names;
             names = [];
             values = [];
             for (var k in o) {
                 var v = o[k];
                 if (typeof(v) == "function") {
                     continue;
                 } else if (MochiKit.Base.isArrayLike(v)){
                     for (var i = 0; i < v.length; i++) {
                         names.push(k);
                         values.push(v[i]);
                     }
                 } else {
                     names.push(k);
                     values.push(v);
                 }
             }
         }
         var rval = [];
         var len = Math.min(names.length, values.length);
         var urlEncode = MochiKit.Base.urlEncode;
         for (var i = 0; i < len; i++) {
             v = values[i];
             if (typeof(v) != 'undefined' && v !== null) {
                 rval.push(urlEncode(names[i]) + "=" + urlEncode(v));
             }
         }
         return rval.join("&");
     },
 
 
     /** @id MochiKit.Base.parseQueryString */
     parseQueryString: function (encodedString, useArrays) {
         // strip a leading '?' from the encoded string
         var qstr = (encodedString.charAt(0) == "?")
             ? encodedString.substring(1)
             : encodedString;
         var pairs = qstr.replace(/\+/g, "%20").split(/\&amp\;|\&\#38\;|\&#x26;|\&/);
         var o = {};
         var decode;
         if (typeof(decodeURIComponent) != "undefined") {
             decode = decodeURIComponent;
         } else {
             decode = unescape;
         }
         if (useArrays) {
             for (var i = 0; i < pairs.length; i++) {
                 var pair = pairs[i].split("=");
                 var name = decode(pair.shift());
                 if (!name) {
                     continue;
                 }
                 var arr = o[name];
                 if (!(arr instanceof Array)) {
                     arr = [];
                     o[name] = arr;
                 }
                 arr.push(decode(pair.join("=")));
             }
         } else {
             for (var i = 0; i < pairs.length; i++) {
                 pair = pairs[i].split("=");
                 var name = pair.shift();
                 if (!name) {
                     continue;
                 }
                 o[decode(name)] = decode(pair.join("="));
             }
         }
         return o;
     }
 });
 
 /** @id MochiKit.Base.AdapterRegistry */
 MochiKit.Base.AdapterRegistry = function () {
     this.pairs = [];
 };
 
 MochiKit.Base.AdapterRegistry.prototype = {
     /** @id MochiKit.Base.AdapterRegistry.prototype.register */
     register: function (name, check, wrap, /* optional */ override) {
         if (override) {
             this.pairs.unshift([name, check, wrap]);
         } else {
             this.pairs.push([name, check, wrap]);
         }
     },
 
     /** @id MochiKit.Base.AdapterRegistry.prototype.match */
     match: function (/* ... */) {
         for (var i = 0; i < this.pairs.length; i++) {
             var pair = this.pairs[i];
             if (pair[1].apply(this, arguments)) {
                 return pair[2].apply(this, arguments);
             }
         }
         throw MochiKit.Base.NotFound;
     },
 
     /** @id MochiKit.Base.AdapterRegistry.prototype.unregister */
     unregister: function (name) {
         for (var i = 0; i < this.pairs.length; i++) {
             var pair = this.pairs[i];
             if (pair[0] == name) {
                 this.pairs.splice(i, 1);
                 return true;
             }
         }
         return false;
     }
 };
 
-MochiKit.Base._exportSymbols = function (globals, module) {
-    if (MochiKit.__export__ === false || module.__export__ === false) {
-        return;
-    }
-    for (var k in module) {
-        var v = module[k];
-        if (v != null) {
-            var okName = (k[0] !== "_" && k !== "toString");
-            if (v.__export__ === true || (v.__export__ !== false && okName)) {
-                globals[k] = module[k];
+/**
+ * Exports all symbols from one or more modules into the specified
+ * namespace (or scope). This is similar to MochiKit.Base.update(),
+ * except for special handling of the "__export__" flag, contained
+ * sub-modules (exported recursively), and names starting with "_".
+ *
+ * @param {Object} namespace the object or scope to modify
+ * @param {Object} module the module to export
+ */
+MochiKit.Base.moduleExport = function (namespace, module/*, ...*/) {
+    var SKIP = { toString: true, NAME: true, VERSION: true };
+    var mods = MochiKit.Base.extend([], arguments, 1);
+    while ((module = mods.shift()) != null) {
+        for (var k in module) {
+            var v = module[k];
+            if (v != null) {
+                var flagSet = (typeof(v.__export__) == 'boolean');
+                var nameValid = (k[0] !== "_" && !SKIP[k]);
+                if (flagSet ? v.__export__ : nameValid) {
+                    if (typeof(v) == 'object' && v.NAME && v.VERSION) {
+                        mods.push(v);
+                    } else {
+                        namespace[k] = module[k];
+                    }
+                }
             }
         }
     }
+    return namespace;
+};
+
+/**
+ * Identical to moduleExport, but also considers the global and
+ * module-specific "__export__" flag.
+ */
+MochiKit.Base._exportSymbols = function (namespace, module) {
+    if (MochiKit.__export__ !== false && module.__export__ !== false) {
+        MochiKit.Base.moduleExport(namespace, module);
+    }
 };
 
 /**
  * Creates a deprecated function alias in the specified module. The
  * deprecated function will forward all calls and arguments to a
  * target function, while also logging a debug message on the first
  * call (if MochiKit.Logging is loaded). The destination function may
  * be located in another module, which must be loaded, or an
  * exception will be thrown.
  *
  * @param {Object/String} module the source module or module name
  *            (e.g. 'DOM' or 'MochiKit.DOM')
  * @param {String} name the deprecated function name (e.g. 'getStyle')
  * @param {String} target the fully qualified name of the target
  *            function (e.g. 'MochiKit.Style.getStyle')
  * @param {String} version the first version when the source function
  *            was deprecated (e.g. '1.4')
  * @param {Boolean} [exportable] the exportable function flag,
- *            defaults to true
+ *            defaults to false
  */
 MochiKit.Base._deprecated = function (module, name, target, version, exportable) {
     if (typeof(module) === 'string') {
         if (module.indexOf('MochiKit.') === 0) {
             module = module.substring(9);
         }
         module = MochiKit[module];
     }
     var targetModule = target.split('.')[1];
     var targetName = target.split('.')[2];
     var func = function () {
         var self = arguments.callee;
         var msg = module.NAME + '.' + name + ' is deprecated since version ' +
                   version + '. Use ' + target + ' instead.';
         if (self.logged !== true) {
             self.logged = true;
             if (MochiKit.Logging) {
                 MochiKit.Logging.logDebug(msg);
             } else if (console && console.log) {
                 console.log(msg);
             }
         }
         if (!MochiKit[targetModule]) {
             throw new Error(msg);
         }
         return MochiKit[targetModule][targetName].apply(this, arguments);
     };
-    if (exportable === false) {
-        func.__export__ = false;
-    }
+    func.__export__ = (exportable === true);
     module[name] = func;
-}
+};
 
 MochiKit.Base.__new__ = function () {
     var m = this;
 
     /** @id MochiKit.Base.noop */
     m.noop = m.operator.identity;
 
     // Backwards compat
-    m._deprecated(m, 'forward', 'MochiKit.Base.forwardCall', '1.3', false);
-    m._deprecated(m, 'find', 'MochiKit.Base.findValue', '1.3', false);
+    m._deprecated(m, 'forward', 'MochiKit.Base.forwardCall', '1.3');
+    m._deprecated(m, 'find', 'MochiKit.Base.findValue', '1.3');
 
     if (typeof(encodeURIComponent) != "undefined") {
         /** @id MochiKit.Base.urlEncode */
         m.urlEncode = function (unencoded) {
             return encodeURIComponent(unencoded).replace(/\'/g, '%27');
         };
     } else {
         m.urlEncode = function (unencoded) {
             return escape(unencoded
                 ).replace(/\+/g, '%2B'
                 ).replace(/\"/g,'%22'
-                ).rval.replace(/\'/g, '%27');
+                ).replace(/\'/g, '%27');
         };
     }
 
     /** @id MochiKit.Base.NamedError */
     m.NamedError = function (name) {
         this.message = name;
         this.name = name;
     };
     m.NamedError.prototype = new Error();
+    m.NamedError.prototype.constructor = m.NamedError;
     m.update(m.NamedError.prototype, {
         repr: function () {
             if (this.message && this.message != this.name) {
                 return this.name + "(" + m.repr(this.message) + ")";
             } else {
                 return this.name + "()";
             }
         },
         toString: m.forwardCall("repr")
     });
 
     /** @id MochiKit.Base.NotFound */
     m.NotFound = new m.NamedError("MochiKit.Base.NotFound");
 
 
     /** @id MochiKit.Base.listMax */
     m.listMax = m.partial(m.listMinMax, 1);
     /** @id MochiKit.Base.listMin */
     m.listMin = m.partial(m.listMinMax, -1);
 
     /** @id MochiKit.Base.isCallable */
     m.isCallable = m.typeMatcher('function');
     /** @id MochiKit.Base.isUndefined */
     m.isUndefined = m.typeMatcher('undefined');
+    /** @id MochiKit.Base.isValue */
+    m.isValue = m.typeMatcher('boolean', 'number', 'string');
 
     /** @id MochiKit.Base.merge */
     m.merge = m.partial(m.update, null);
     /** @id MochiKit.Base.zip */
     m.zip = m.partial(m.map, null);
 
     /** @id MochiKit.Base.average */
     m.average = m.mean;
 
     /** @id MochiKit.Base.comparatorRegistry */
     m.comparatorRegistry = new m.AdapterRegistry();
     m.registerComparator("dateLike", m.isDateLike, m.compareDateLike);
     m.registerComparator("arrayLike", m.isArrayLike, m.compareArrayLike);
 
     /** @id MochiKit.Base.reprRegistry */
     m.reprRegistry = new m.AdapterRegistry();
     m.registerRepr("arrayLike", m.isArrayLike, m.reprArrayLike);
     m.registerRepr("string", m.typeMatcher("string"), m.reprString);
     m.registerRepr("numbers", m.typeMatcher("number", "boolean"), m.reprNumber);
 
     /** @id MochiKit.Base.jsonRegistry */
     m.jsonRegistry = new m.AdapterRegistry();
 
     m.nameFunctions(this);
 
 };
 
 MochiKit.Base.__new__();
 
 //
 // XXX: Internet Explorer blows
 //
 if (MochiKit.__export__) {
     compare = MochiKit.Base.compare;
     compose = MochiKit.Base.compose;
     serializeJSON = MochiKit.Base.serializeJSON;
     mean = MochiKit.Base.mean;
     median = MochiKit.Base.median;
 }
 
 MochiKit.Base._exportSymbols(this, MochiKit.Base);
diff --git a/frontend/gamma/js/MochiKit/Color.js b/frontend/gamma/js/MochiKit/Color.js
index 27dc2d0..f2a0f67 100644
--- a/frontend/gamma/js/MochiKit/Color.js
+++ b/frontend/gamma/js/MochiKit/Color.js
@@ -1,832 +1,823 @@
 /***
 
 MochiKit.Color 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito and others.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Color', '1.5', ['Base', 'DOM', 'Style']);
+MochiKit.Base.module(MochiKit, 'Color', '1.5', ['Base', 'DOM', 'Style']);
 
 /** @id MochiKit.Color.Color */
 MochiKit.Color.Color = function (red, green, blue, alpha) {
     if (typeof(alpha) == 'undefined' || alpha === null) {
         alpha = 1.0;
     }
     this.rgb = {
         r: red,
         g: green,
         b: blue,
         a: alpha
     };
 };
 
 
 // Prototype methods
 
 MochiKit.Color.Color.prototype = {
 
     __class__: MochiKit.Color.Color,
 
     /** @id MochiKit.Color.Color.prototype.colorWithAlpha */
     colorWithAlpha: function (alpha) {
         var rgb = this.rgb;
         var m = MochiKit.Color;
         return m.Color.fromRGB(rgb.r, rgb.g, rgb.b, alpha);
     },
 
     /** @id MochiKit.Color.Color.prototype.colorWithHue */
     colorWithHue: function (hue) {
         // get an HSL model, and set the new hue...
         var hsl = this.asHSL();
         hsl.h = hue;
         var m = MochiKit.Color;
         // convert back to RGB...
         return m.Color.fromHSL(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.colorWithSaturation */
     colorWithSaturation: function (saturation) {
         // get an HSL model, and set the new hue...
         var hsl = this.asHSL();
         hsl.s = saturation;
         var m = MochiKit.Color;
         // convert back to RGB...
         return m.Color.fromHSL(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.colorWithLightness */
     colorWithLightness: function (lightness) {
         // get an HSL model, and set the new hue...
         var hsl = this.asHSL();
         hsl.l = lightness;
         var m = MochiKit.Color;
         // convert back to RGB...
         return m.Color.fromHSL(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.darkerColorWithLevel */
     darkerColorWithLevel: function (level) {
         var hsl  = this.asHSL();
         hsl.l = Math.max(hsl.l - level, 0);
         var m = MochiKit.Color;
         return m.Color.fromHSL(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.lighterColorWithLevel */
     lighterColorWithLevel: function (level) {
         var hsl  = this.asHSL();
         hsl.l = Math.min(hsl.l + level, 1);
         var m = MochiKit.Color;
         return m.Color.fromHSL(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.blendedColor */
     blendedColor: function (other, /* optional */ fraction) {
         if (typeof(fraction) == 'undefined' || fraction === null) {
             fraction = 0.5;
         }
         var sf = 1.0 - fraction;
         var s = this.rgb;
         var d = other.rgb;
         var df = fraction;
         return MochiKit.Color.Color.fromRGB(
             (s.r * sf) + (d.r * df),
             (s.g * sf) + (d.g * df),
             (s.b * sf) + (d.b * df),
             (s.a * sf) + (d.a * df)
         );
     },
 
     /** @id MochiKit.Color.Color.prototype.compareRGB */
     compareRGB: function (other) {
         var a = this.asRGB();
         var b = other.asRGB();
         return MochiKit.Base.compare(
             [a.r, a.g, a.b, a.a],
             [b.r, b.g, b.b, b.a]
         );
     },
 
     /** @id MochiKit.Color.Color.prototype.isLight */
     isLight: function () {
-        return this.asHSL().b > 0.5;
+        return this.asHSL().l > 0.5;
     },
 
     /** @id MochiKit.Color.Color.prototype.isDark */
     isDark: function () {
         return (!this.isLight());
     },
 
     /** @id MochiKit.Color.Color.prototype.toHSLString */
     toHSLString: function () {
         var c = this.asHSL();
         var ccc = MochiKit.Color.clampColorComponent;
         var rval = this._hslString;
         if (!rval) {
             var mid = (
                 ccc(c.h, 360).toFixed(0)
                 + "," + ccc(c.s, 100).toPrecision(4) + "%"
                 + "," + ccc(c.l, 100).toPrecision(4) + "%"
             );
             var a = c.a;
             if (a >= 1) {
                 a = 1;
                 rval = "hsl(" + mid + ")";
             } else {
                 if (a <= 0) {
                     a = 0;
                 }
                 rval = "hsla(" + mid + "," + a + ")";
             }
             this._hslString = rval;
         }
         return rval;
     },
 
     /** @id MochiKit.Color.Color.prototype.toRGBString */
     toRGBString: function () {
         var c = this.rgb;
         var ccc = MochiKit.Color.clampColorComponent;
         var rval = this._rgbString;
         if (!rval) {
             var mid = (
                 ccc(c.r, 255).toFixed(0)
                 + "," + ccc(c.g, 255).toFixed(0)
                 + "," + ccc(c.b, 255).toFixed(0)
             );
             if (c.a != 1) {
                 rval = "rgba(" + mid + "," + c.a + ")";
             } else {
                 rval = "rgb(" + mid + ")";
             }
             this._rgbString = rval;
         }
         return rval;
     },
 
     /** @id MochiKit.Color.Color.prototype.asRGB */
     asRGB: function () {
         return MochiKit.Base.clone(this.rgb);
     },
 
     /** @id MochiKit.Color.Color.prototype.toHexString */
     toHexString: function () {
         var m = MochiKit.Color;
         var c = this.rgb;
         var ccc = MochiKit.Color.clampColorComponent;
         var rval = this._hexString;
         if (!rval) {
             rval = ("#" +
                 m.toColorPart(ccc(c.r, 255)) +
                 m.toColorPart(ccc(c.g, 255)) +
                 m.toColorPart(ccc(c.b, 255))
             );
             this._hexString = rval;
         }
         return rval;
     },
 
     /** @id MochiKit.Color.Color.prototype.asHSV */
     asHSV: function () {
         var hsv = this.hsv;
         var c = this.rgb;
         if (typeof(hsv) == 'undefined' || hsv === null) {
             hsv = MochiKit.Color.rgbToHSV(this.rgb);
             this.hsv = hsv;
         }
         return MochiKit.Base.clone(hsv);
     },
 
     /** @id MochiKit.Color.Color.prototype.asHSL */
     asHSL: function () {
         var hsl = this.hsl;
         var c = this.rgb;
         if (typeof(hsl) == 'undefined' || hsl === null) {
             hsl = MochiKit.Color.rgbToHSL(this.rgb);
             this.hsl = hsl;
         }
         return MochiKit.Base.clone(hsl);
     },
 
     /** @id MochiKit.Color.Color.prototype.toString */
     toString: function () {
         return this.toRGBString();
     },
 
     /** @id MochiKit.Color.Color.prototype.repr */
     repr: function () {
         var c = this.rgb;
         var col = [c.r, c.g, c.b, c.a];
         return this.__class__.NAME + "(" + col.join(", ") + ")";
     }
 
 };
 
 // Constructor methods
 
 MochiKit.Base.update(MochiKit.Color.Color, {
     /** @id MochiKit.Color.Color.fromRGB */
     fromRGB: function (red, green, blue, alpha) {
         // designated initializer
         var Color = MochiKit.Color.Color;
         if (arguments.length == 1) {
             var rgb = red;
             red = rgb.r;
             green = rgb.g;
             blue = rgb.b;
             if (typeof(rgb.a) == 'undefined') {
                 alpha = undefined;
             } else {
                 alpha = rgb.a;
             }
         }
         return new Color(red, green, blue, alpha);
     },
 
     /** @id MochiKit.Color.Color.fromHSL */
     fromHSL: function (hue, saturation, lightness, alpha) {
         var m = MochiKit.Color;
         return m.Color.fromRGB(m.hslToRGB.apply(m, arguments));
     },
 
     /** @id MochiKit.Color.Color.fromHSV */
     fromHSV: function (hue, saturation, value, alpha) {
         var m = MochiKit.Color;
         return m.Color.fromRGB(m.hsvToRGB.apply(m, arguments));
     },
 
     /** @id MochiKit.Color.Color.fromName */
     fromName: function (name) {
         var Color = MochiKit.Color.Color;
         // Opera 9 seems to "quote" named colors(?!)
         if (name.charAt(0) == '"') {
             name = name.substr(1, name.length - 2);
         }
         var htmlColor = Color._namedColors[name.toLowerCase()];
         if (typeof(htmlColor) == 'string') {
             return Color.fromHexString(htmlColor);
         } else if (name == "transparent") {
             return Color.transparentColor();
         }
         return null;
     },
 
     /** @id MochiKit.Color.Color.fromString */
     fromString: function (colorString) {
         var self = MochiKit.Color.Color;
         var three = colorString.substr(0, 3);
         if (three == "rgb") {
             return self.fromRGBString(colorString);
         } else if (three == "hsl") {
             return self.fromHSLString(colorString);
         } else if (colorString.charAt(0) == "#") {
             return self.fromHexString(colorString);
         }
         return self.fromName(colorString);
     },
 
 
     /** @id MochiKit.Color.Color.fromHexString */
     fromHexString: function (hexCode) {
         if (hexCode.charAt(0) == '#') {
             hexCode = hexCode.substring(1);
         }
         var components = [];
         var i, hex;
         if (hexCode.length == 3) {
             for (i = 0; i < 3; i++) {
                 hex = hexCode.substr(i, 1);
                 components.push(parseInt(hex + hex, 16) / 255.0);
             }
         } else {
             for (i = 0; i < 6; i += 2) {
                 hex = hexCode.substr(i, 2);
                 components.push(parseInt(hex, 16) / 255.0);
             }
         }
         var Color = MochiKit.Color.Color;
         return Color.fromRGB.apply(Color, components);
     },
 
 
     _fromColorString: function (pre, method, scales, colorCode) {
         // parses either HSL or RGB
         if (colorCode.indexOf(pre) === 0) {
             colorCode = colorCode.substring(colorCode.indexOf("(", 3) + 1, colorCode.length - 1);
         }
         var colorChunks = colorCode.split(/\s*,\s*/);
         var colorFloats = [];
         for (var i = 0; i < colorChunks.length; i++) {
             var c = colorChunks[i];
             var val;
             var three = c.substring(c.length - 3);
             if (c.charAt(c.length - 1) == '%') {
                 val = 0.01 * parseFloat(c.substring(0, c.length - 1));
             } else if (three == "deg") {
                 val = parseFloat(c) / 360.0;
             } else if (three == "rad") {
                 val = parseFloat(c) / (Math.PI * 2);
             } else {
                 val = scales[i] * parseFloat(c);
             }
             colorFloats.push(val);
         }
         return this[method].apply(this, colorFloats);
     },
 
     /** @id MochiKit.Color.Color.fromComputedStyle */
     fromComputedStyle: function (elem, style) {
         var d = MochiKit.DOM;
         var cls = MochiKit.Color.Color;
         for (elem = d.getElement(elem); elem; elem = elem.parentNode) {
             var actualColor = MochiKit.Style.getStyle.apply(d, arguments);
             if (!actualColor) {
                 continue;
             }
             var color = cls.fromString(actualColor);
             if (!color) {
                 break;
             }
             if (color.asRGB().a > 0) {
                 return color;
             }
         }
         return null;
     },
 
     /** @id MochiKit.Color.Color.fromBackground */
     fromBackground: function (elem) {
         var cls = MochiKit.Color.Color;
         return cls.fromComputedStyle(
             elem, "backgroundColor", "background-color") || cls.whiteColor();
     },
 
     /** @id MochiKit.Color.Color.fromText */
     fromText: function (elem) {
         var cls = MochiKit.Color.Color;
         return cls.fromComputedStyle(
             elem, "color", "color") || cls.blackColor();
     },
 
     /** @id MochiKit.Color.Color.namedColors */
     namedColors: function () {
         return MochiKit.Base.clone(MochiKit.Color.Color._namedColors);
     }
 });
 
 
 // Module level functions
 
 MochiKit.Base.update(MochiKit.Color, {
     /** @id MochiKit.Color.clampColorComponent */
     clampColorComponent: function (v, scale) {
         v *= scale;
         if (v < 0) {
             return 0;
         } else if (v > scale) {
             return scale;
         } else {
             return v;
         }
     },
 
     _hslValue: function (n1, n2, hue) {
         if (hue > 6.0) {
             hue -= 6.0;
         } else if (hue < 0.0) {
             hue += 6.0;
         }
         var val;
         if (hue < 1.0) {
             val = n1 + (n2 - n1) * hue;
         } else if (hue < 3.0) {
             val = n2;
         } else if (hue < 4.0) {
             val = n1 + (n2 - n1) * (4.0 - hue);
         } else {
             val = n1;
         }
         return val;
     },
 
     /** @id MochiKit.Color.hsvToRGB */
     hsvToRGB: function (hue, saturation, value, alpha) {
         if (arguments.length == 1) {
             var hsv = hue;
             hue = hsv.h;
             saturation = hsv.s;
             value = hsv.v;
             alpha = hsv.a;
         }
         var red;
         var green;
         var blue;
         if (saturation === 0) {
             red = value;
             green = value;
             blue = value;
         } else {
             var i = Math.floor(hue * 6);
             var f = (hue * 6) - i;
             var p = value * (1 - saturation);
             var q = value * (1 - (saturation * f));
             var t = value * (1 - (saturation * (1 - f)));
             switch (i) {
                 case 1: red = q; green = value; blue = p; break;
                 case 2: red = p; green = value; blue = t; break;
                 case 3: red = p; green = q; blue = value; break;
                 case 4: red = t; green = p; blue = value; break;
                 case 5: red = value; green = p; blue = q; break;
                 case 6: // fall through
                 case 0: red = value; green = t; blue = p; break;
             }
         }
         return {
             r: red,
             g: green,
             b: blue,
             a: alpha
         };
     },
 
     /** @id MochiKit.Color.hslToRGB */
     hslToRGB: function (hue, saturation, lightness, alpha) {
         if (arguments.length == 1) {
             var hsl = hue;
             hue = hsl.h;
             saturation = hsl.s;
             lightness = hsl.l;
             alpha = hsl.a;
         }
         var red;
         var green;
         var blue;
         if (saturation === 0) {
             red = lightness;
             green = lightness;
             blue = lightness;
         } else {
             var m2;
             if (lightness <= 0.5) {
                 m2 = lightness * (1.0 + saturation);
             } else {
                 m2 = lightness + saturation - (lightness * saturation);
             }
             var m1 = (2.0 * lightness) - m2;
             var f = MochiKit.Color._hslValue;
             var h6 = hue * 6.0;
             red = f(m1, m2, h6 + 2);
             green = f(m1, m2, h6);
             blue = f(m1, m2, h6 - 2);
         }
         return {
             r: red,
             g: green,
             b: blue,
             a: alpha
         };
     },
 
     /** @id MochiKit.Color.rgbToHSV */
     rgbToHSV: function (red, green, blue, alpha) {
         if (arguments.length == 1) {
             var rgb = red;
             red = rgb.r;
             green = rgb.g;
             blue = rgb.b;
             alpha = rgb.a;
         }
         var max = Math.max(Math.max(red, green), blue);
         var min = Math.min(Math.min(red, green), blue);
         var hue;
         var saturation;
         var value = max;
         if (min == max) {
             hue = 0;
             saturation = 0;
         } else {
             var delta = (max - min);
             saturation = delta / max;
 
             if (red == max) {
                 hue = (green - blue) / delta;
             } else if (green == max) {
                 hue = 2 + ((blue - red) / delta);
             } else {
                 hue = 4 + ((red - green) / delta);
             }
             hue /= 6;
             if (hue < 0) {
                 hue += 1;
             }
             if (hue > 1) {
                 hue -= 1;
             }
         }
         return {
             h: hue,
             s: saturation,
             v: value,
             a: alpha
         };
     },
 
     /** @id MochiKit.Color.rgbToHSL */
     rgbToHSL: function (red, green, blue, alpha) {
         if (arguments.length == 1) {
             var rgb = red;
             red = rgb.r;
             green = rgb.g;
             blue = rgb.b;
             alpha = rgb.a;
         }
         var max = Math.max(red, Math.max(green, blue));
         var min = Math.min(red, Math.min(green, blue));
         var hue;
         var saturation;
         var lightness = (max + min) / 2.0;
         var delta = max - min;
         if (delta === 0) {
             hue = 0;
             saturation = 0;
         } else {
             if (lightness <= 0.5) {
                 saturation = delta / (max + min);
             } else {
                 saturation = delta / (2 - max - min);
             }
             if (red == max) {
                 hue = (green - blue) / delta;
             } else if (green == max) {
                 hue = 2 + ((blue - red) / delta);
             } else {
                 hue = 4 + ((red - green) / delta);
             }
             hue /= 6;
             if (hue < 0) {
                 hue += 1;
             }
             if (hue > 1) {
                 hue -= 1;
             }
 
         }
         return {
             h: hue,
             s: saturation,
             l: lightness,
             a: alpha
         };
     },
 
     /** @id MochiKit.Color.toColorPart */
     toColorPart: function (num) {
         num = Math.round(num);
         var digits = num.toString(16);
         if (num < 16) {
             return '0' + digits;
         }
         return digits;
     },
 
     __new__: function () {
         var m = MochiKit.Base;
         /** @id MochiKit.Color.Color.fromRGBString */
         this.Color.fromRGBString = m.bind(
             this.Color._fromColorString, this.Color, "rgb", "fromRGB",
             [1.0/255.0, 1.0/255.0, 1.0/255.0, 1]
         );
         /** @id MochiKit.Color.Color.fromHSLString */
         this.Color.fromHSLString = m.bind(
             this.Color._fromColorString, this.Color, "hsl", "fromHSL",
             [1.0/360.0, 0.01, 0.01, 1]
         );
 
         var third = 1.0 / 3.0;
         /** @id MochiKit.Color.colors */
         var colors = {
             // NSColor colors plus transparent
             /** @id MochiKit.Color.blackColor */
             black: [0, 0, 0],
             /** @id MochiKit.Color.blueColor */
             blue: [0, 0, 1],
             /** @id MochiKit.Color.brownColor */
             brown: [0.6, 0.4, 0.2],
             /** @id MochiKit.Color.cyanColor */
             cyan: [0, 1, 1],
             /** @id MochiKit.Color.darkGrayColor */
             darkGray: [third, third, third],
             /** @id MochiKit.Color.grayColor */
             gray: [0.5, 0.5, 0.5],
             /** @id MochiKit.Color.greenColor */
             green: [0, 1, 0],
             /** @id MochiKit.Color.lightGrayColor */
             lightGray: [2 * third, 2 * third, 2 * third],
             /** @id MochiKit.Color.magentaColor */
             magenta: [1, 0, 1],
             /** @id MochiKit.Color.orangeColor */
             orange: [1, 0.5, 0],
             /** @id MochiKit.Color.purpleColor */
             purple: [0.5, 0, 0.5],
             /** @id MochiKit.Color.redColor */
             red: [1, 0, 0],
             /** @id MochiKit.Color.transparentColor */
             transparent: [0, 0, 0, 0],
             /** @id MochiKit.Color.whiteColor */
             white: [1, 1, 1],
             /** @id MochiKit.Color.yellowColor */
             yellow: [1, 1, 0]
         };
 
-        var makeColor = function (name, r, g, b, a) {
-            var rval = this.fromRGB(r, g, b, a);
-            this[name] = function () { return rval; };
-            return rval;
-        };
-
         for (var k in colors) {
             var name = k + "Color";
-            var bindArgs = m.concat(
-                [makeColor, this.Color, name],
-                colors[k]
-            );
-            this.Color[name] = m.bind.apply(null, bindArgs);
+            var value = this.Color.fromRGB.apply(this.Color, colors[k]);
+            this.Color[name] = m.partial(m.operator.identity, value);
         }
 
         var isColor = function () {
             for (var i = 0; i < arguments.length; i++) {
                 if (!(arguments[i] instanceof MochiKit.Color.Color)) {
                     return false;
                 }
             }
             return true;
         };
 
         var compareColor = function (a, b) {
             return a.compareRGB(b);
         };
 
         m.nameFunctions(this);
 
         m.registerComparator(this.Color.NAME, isColor, compareColor);
     }
 });
 
 MochiKit.Color.__new__();
 
 // Full table of css3 X11 colors <http://www.w3.org/TR/css3-color/#X11COLORS>
 
 MochiKit.Color.Color._namedColors = {
     aliceblue: "#f0f8ff",
     antiquewhite: "#faebd7",
     aqua: "#00ffff",
     aquamarine: "#7fffd4",
     azure: "#f0ffff",
     beige: "#f5f5dc",
     bisque: "#ffe4c4",
     black: "#000000",
     blanchedalmond: "#ffebcd",
     blue: "#0000ff",
     blueviolet: "#8a2be2",
     brown: "#a52a2a",
     burlywood: "#deb887",
     cadetblue: "#5f9ea0",
     chartreuse: "#7fff00",
     chocolate: "#d2691e",
     coral: "#ff7f50",
     cornflowerblue: "#6495ed",
     cornsilk: "#fff8dc",
     crimson: "#dc143c",
     cyan: "#00ffff",
     darkblue: "#00008b",
     darkcyan: "#008b8b",
     darkgoldenrod: "#b8860b",
     darkgray: "#a9a9a9",
     darkgreen: "#006400",
     darkgrey: "#a9a9a9",
     darkkhaki: "#bdb76b",
     darkmagenta: "#8b008b",
     darkolivegreen: "#556b2f",
     darkorange: "#ff8c00",
     darkorchid: "#9932cc",
     darkred: "#8b0000",
     darksalmon: "#e9967a",
     darkseagreen: "#8fbc8f",
     darkslateblue: "#483d8b",
     darkslategray: "#2f4f4f",
     darkslategrey: "#2f4f4f",
     darkturquoise: "#00ced1",
     darkviolet: "#9400d3",
     deeppink: "#ff1493",
     deepskyblue: "#00bfff",
     dimgray: "#696969",
     dimgrey: "#696969",
     dodgerblue: "#1e90ff",
     firebrick: "#b22222",
     floralwhite: "#fffaf0",
     forestgreen: "#228b22",
     fuchsia: "#ff00ff",
     gainsboro: "#dcdcdc",
     ghostwhite: "#f8f8ff",
     gold: "#ffd700",
     goldenrod: "#daa520",
     gray: "#808080",
     green: "#008000",
     greenyellow: "#adff2f",
     grey: "#808080",
     honeydew: "#f0fff0",
     hotpink: "#ff69b4",
     indianred: "#cd5c5c",
     indigo: "#4b0082",
     ivory: "#fffff0",
     khaki: "#f0e68c",
     lavender: "#e6e6fa",
     lavenderblush: "#fff0f5",
     lawngreen: "#7cfc00",
     lemonchiffon: "#fffacd",
     lightblue: "#add8e6",
     lightcoral: "#f08080",
     lightcyan: "#e0ffff",
     lightgoldenrodyellow: "#fafad2",
     lightgray: "#d3d3d3",
     lightgreen: "#90ee90",
     lightgrey: "#d3d3d3",
     lightpink: "#ffb6c1",
     lightsalmon: "#ffa07a",
     lightseagreen: "#20b2aa",
     lightskyblue: "#87cefa",
     lightslategray: "#778899",
     lightslategrey: "#778899",
     lightsteelblue: "#b0c4de",
     lightyellow: "#ffffe0",
     lime: "#00ff00",
     limegreen: "#32cd32",
     linen: "#faf0e6",
     magenta: "#ff00ff",
     maroon: "#800000",
     mediumaquamarine: "#66cdaa",
     mediumblue: "#0000cd",
     mediumorchid: "#ba55d3",
     mediumpurple: "#9370db",
     mediumseagreen: "#3cb371",
     mediumslateblue: "#7b68ee",
     mediumspringgreen: "#00fa9a",
     mediumturquoise: "#48d1cc",
     mediumvioletred: "#c71585",
     midnightblue: "#191970",
     mintcream: "#f5fffa",
     mistyrose: "#ffe4e1",
     moccasin: "#ffe4b5",
     navajowhite: "#ffdead",
     navy: "#000080",
     oldlace: "#fdf5e6",
     olive: "#808000",
     olivedrab: "#6b8e23",
     orange: "#ffa500",
     orangered: "#ff4500",
     orchid: "#da70d6",
     palegoldenrod: "#eee8aa",
     palegreen: "#98fb98",
     paleturquoise: "#afeeee",
     palevioletred: "#db7093",
     papayawhip: "#ffefd5",
     peachpuff: "#ffdab9",
     peru: "#cd853f",
     pink: "#ffc0cb",
     plum: "#dda0dd",
     powderblue: "#b0e0e6",
     purple: "#800080",
     red: "#ff0000",
     rosybrown: "#bc8f8f",
     royalblue: "#4169e1",
     saddlebrown: "#8b4513",
     salmon: "#fa8072",
     sandybrown: "#f4a460",
     seagreen: "#2e8b57",
     seashell: "#fff5ee",
     sienna: "#a0522d",
     silver: "#c0c0c0",
     skyblue: "#87ceeb",
     slateblue: "#6a5acd",
     slategray: "#708090",
     slategrey: "#708090",
     snow: "#fffafa",
     springgreen: "#00ff7f",
     steelblue: "#4682b4",
     tan: "#d2b48c",
     teal: "#008080",
     thistle: "#d8bfd8",
     tomato: "#ff6347",
     turquoise: "#40e0d0",
     violet: "#ee82ee",
     wheat: "#f5deb3",
     white: "#ffffff",
     whitesmoke: "#f5f5f5",
     yellow: "#ffff00",
     yellowgreen: "#9acd32"
 };
 
 MochiKit.Base._exportSymbols(this, MochiKit.Color);
diff --git a/frontend/gamma/js/MochiKit/DOM.js b/frontend/gamma/js/MochiKit/DOM.js
index af5d46f..944ab78 100644
--- a/frontend/gamma/js/MochiKit/DOM.js
+++ b/frontend/gamma/js/MochiKit/DOM.js
@@ -1,1144 +1,1179 @@
 /***
 
 MochiKit.DOM 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('DOM', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'DOM', '1.5', ['Base']);
 
 MochiKit.Base.update(MochiKit.DOM, {
 
     /** @id MochiKit.DOM.currentWindow */
     currentWindow: function () {
         return MochiKit.DOM._window;
     },
 
     /** @id MochiKit.DOM.currentDocument */
     currentDocument: function () {
         return MochiKit.DOM._document;
     },
 
     /** @id MochiKit.DOM.withWindow */
     withWindow: function (win, func) {
         var self = MochiKit.DOM;
         var oldDoc = self._document;
         var oldWin = self._window;
         var rval;
         try {
             self._window = win;
             self._document = win.document;
             rval = func();
         } catch (e) {
             self._window = oldWin;
             self._document = oldDoc;
             throw e;
         }
         self._window = oldWin;
         self._document = oldDoc;
         return rval;
     },
 
     /** @id MochiKit.DOM.formContents  */
     formContents: function (elem/* = document.body */) {
         var names = [];
         var values = [];
         var m = MochiKit.Base;
         var self = MochiKit.DOM;
         if (typeof(elem) == "undefined" || elem === null) {
             elem = self._document.body;
         } else {
             elem = self.getElement(elem);
         }
         m.nodeWalk(elem, function (elem) {
             var name = elem.name;
             if (m.isNotEmpty(name)) {
                 var tagName = elem.tagName.toUpperCase();
                 if (tagName === "INPUT"
                     && (elem.type == "radio" || elem.type == "checkbox")
                     && !elem.checked
                 ) {
                     return null;
                 }
                 if (tagName === "SELECT") {
                     if (elem.type == "select-one") {
                         if (elem.selectedIndex >= 0) {
                             var opt = elem.options[elem.selectedIndex];
                             var v = opt.value;
                             if (!v) {
                                 var h = opt.outerHTML;
                                 // internet explorer sure does suck.
                                 if (h && !h.match(/^[^>]+\svalue\s*=/i)) {
                                     v = opt.text;
                                 }
                             }
                             names.push(name);
                             values.push(v);
                             return null;
                         }
                         // no form elements?
                         names.push(name);
                         values.push("");
                         return null;
                     } else {
                         var opts = elem.options;
                         if (!opts.length) {
                             names.push(name);
                             values.push("");
                             return null;
                         }
                         for (var i = 0; i < opts.length; i++) {
                             var opt = opts[i];
                             if (!opt.selected) {
                                 continue;
                             }
                             var v = opt.value;
                             if (!v) {
                                 var h = opt.outerHTML;
                                 // internet explorer sure does suck.
                                 if (h && !h.match(/^[^>]+\svalue\s*=/i)) {
                                     v = opt.text;
                                 }
                             }
                             names.push(name);
                             values.push(v);
                         }
                         return null;
                     }
                 }
                 if (tagName === "FORM" || tagName === "P" || tagName === "SPAN"
                     || tagName === "DIV"
                 ) {
                     return elem.childNodes;
                 }
                 names.push(name);
                 values.push(elem.value || '');
                 return null;
             }
             return elem.childNodes;
         });
         return [names, values];
     },
 
     /** @id MochiKit.DOM.withDocument */
     withDocument: function (doc, func) {
         var self = MochiKit.DOM;
         var oldDoc = self._document;
         var rval;
         try {
             self._document = doc;
             rval = func();
         } catch (e) {
             self._document = oldDoc;
             throw e;
         }
         self._document = oldDoc;
         return rval;
     },
 
     /** @id MochiKit.DOM.registerDOMConverter */
     registerDOMConverter: function (name, check, wrap, /* optional */override) {
         MochiKit.DOM.domConverters.register(name, check, wrap, override);
     },
 
     /** @id MochiKit.DOM.coerceToDOM */
     coerceToDOM: function (node, ctx) {
         var m = MochiKit.Base;
         var im = MochiKit.Iter;
         var self = MochiKit.DOM;
         if (im) {
             var iter = im.iter;
             var repeat = im.repeat;
         }
         var map = m.map;
         var domConverters = self.domConverters;
         var coerceToDOM = arguments.callee;
         var NotFound = m.NotFound;
         while (true) {
             if (typeof(node) == 'undefined' || node === null) {
                 return null;
             }
             // this is a safari childNodes object, avoiding crashes w/ attr
             // lookup
             if (typeof(node) == "function" &&
                     typeof(node.length) == "number" &&
                     !(node instanceof Function)) {
                 node = im ? im.list(node) : m.extend(null, node);
             }
             if (typeof(node.nodeType) != 'undefined' && node.nodeType > 0) {
                 return node;
             }
             if (typeof(node) == 'number' || typeof(node) == 'boolean') {
                 node = node.toString();
                 // FALL THROUGH
             }
             if (typeof(node) == 'string') {
                 return self._document.createTextNode(node);
             }
             if (typeof(node.__dom__) == 'function') {
                 node = node.__dom__(ctx);
                 continue;
             }
             if (typeof(node.dom) == 'function') {
                 node = node.dom(ctx);
                 continue;
             }
             if (typeof(node) == 'function') {
                 node = node.apply(ctx, [ctx]);
                 continue;
             }
 
             if (im) {
                 // iterable
                 var iterNodes = null;
                 try {
                     iterNodes = iter(node);
                 } catch (e) {
                     // pass
                 }
                 if (iterNodes) {
                     return map(coerceToDOM, iterNodes, repeat(ctx));
                 }
             } else if (m.isArrayLike(node)) {
                 var func = function (n) { return coerceToDOM(n, ctx); };
                 return map(func, node);
             }
 
             // adapter
             try {
                 node = domConverters.match(node, ctx);
                 continue;
             } catch (e) {
                 if (e != NotFound) {
                     throw e;
                 }
             }
 
             // fallback
             return self._document.createTextNode(node.toString());
         }
         // mozilla warnings aren't too bright
         return undefined;
     },
 
     /** @id MochiKit.DOM.isChildNode */
     isChildNode: function (node, maybeparent) {
         var self = MochiKit.DOM;
         if (typeof(node) == "string") {
             node = self.getElement(node);
         }
         if (typeof(maybeparent) == "string") {
             maybeparent = self.getElement(maybeparent);
         }
         if (typeof(node) == 'undefined' || node === null) {
             return false;
         }
         while (node != null && node !== self._document) {
             if (node === maybeparent) {
                 return true;
             }
             node = node.parentNode;
         }
         return false;
     },
 
     /** @id MochiKit.DOM.setNodeAttribute */
     setNodeAttribute: function (node, attr, value) {
         var o = {};
         o[attr] = value;
         try {
             return MochiKit.DOM.updateNodeAttributes(node, o);
         } catch (e) {
             // pass
         }
         return null;
     },
 
     /** @id MochiKit.DOM.getNodeAttribute */
     getNodeAttribute: function (node, attr) {
         var self = MochiKit.DOM;
         var rename = self.attributeArray.renames[attr];
         var ignoreValue = self.attributeArray.ignoreAttr[attr];
         node = self.getElement(node);
         try {
             if (rename) {
                 return node[rename];
             }
             var value = node.getAttribute(attr);
             if (value != ignoreValue) {
                 return value;
             }
         } catch (e) {
             // pass
         }
         return null;
     },
 
     /** @id MochiKit.DOM.removeNodeAttribute */
     removeNodeAttribute: function (node, attr) {
         var self = MochiKit.DOM;
         var rename = self.attributeArray.renames[attr];
         node = self.getElement(node);
         try {
             if (rename) {
                 return node[rename];
             }
             return node.removeAttribute(attr);
         } catch (e) {
             // pass
         }
         return null;
     },
 
     /** @id MochiKit.DOM.updateNodeAttributes */
     updateNodeAttributes: function (node, attrs) {
         var elem = node;
         var self = MochiKit.DOM;
+        var base = MochiKit.Base;
         if (typeof(node) == 'string') {
             elem = self.getElement(node);
         }
         if (attrs) {
-            var updatetree = MochiKit.Base.updatetree;
             if (self.attributeArray.compliant) {
                 // not IE, good.
                 for (var k in attrs) {
                     var v = attrs[k];
                     if (typeof(v) == 'object' && typeof(elem[k]) == 'object') {
                         if (k == "style" && MochiKit.Style) {
                             MochiKit.Style.setStyle(elem, v);
                         } else {
-                            updatetree(elem[k], v);
+                            base.updatetree(elem[k], v);
                         }
                     } else if (k.substring(0, 2) == "on") {
                         if (typeof(v) == "string") {
                             v = new Function(v);
                         }
                         elem[k] = v;
                     } else {
                         elem.setAttribute(k, v);
                     }
-                    if (typeof(elem[k]) == "string" && elem[k] != v) {
-                        // Also set property for weird attributes (see #302)
+                    if (base.isValue(elem[k]) && elem[k] != v) {
+                        // Also set property for weird attributes (see #302 & #335)
                         elem[k] = v;
                     }
                 }
             } else {
                 // IE is insane in the membrane
                 var renames = self.attributeArray.renames;
                 for (var k in attrs) {
                     v = attrs[k];
                     var renamed = renames[k];
                     if (k == "style" && typeof(v) == "string") {
                         elem.style.cssText = v;
                     } else if (typeof(renamed) == "string") {
                         elem[renamed] = v;
                     } else if (typeof(elem[k]) == 'object'
                             && typeof(v) == 'object') {
                         if (k == "style" && MochiKit.Style) {
                             MochiKit.Style.setStyle(elem, v);
                         } else {
-                            updatetree(elem[k], v);
+                            base.updatetree(elem[k], v);
                         }
                     } else if (k.substring(0, 2) == "on") {
                         if (typeof(v) == "string") {
                             v = new Function(v);
                         }
                         elem[k] = v;
                     } else {
                         elem.setAttribute(k, v);
                     }
-                    if (typeof(elem[k]) == "string" && elem[k] != v) {
-                        // Also set property for weird attributes (see #302)
+                    if (base.isValue(elem[k]) && elem[k] != v) {
+                        // Also set property for weird attributes (see #302 & #335)
                         elem[k] = v;
                     }
                 }
             }
         }
         return elem;
     },
 
     /** @id MochiKit.DOM.appendChildNodes */
     appendChildNodes: function (node/*, nodes...*/) {
         var elem = node;
         var self = MochiKit.DOM;
         if (typeof(node) == 'string') {
             elem = self.getElement(node);
         }
         var nodeStack = [
             self.coerceToDOM(
                 MochiKit.Base.extend(null, arguments, 1),
                 elem
             )
         ];
         var concat = MochiKit.Base.concat;
         while (nodeStack.length) {
             var n = nodeStack.shift();
             if (typeof(n) == 'undefined' || n === null) {
                 // pass
             } else if (typeof(n.nodeType) == 'number') {
                 elem.appendChild(n);
             } else {
                 nodeStack = concat(n, nodeStack);
             }
         }
         return elem;
     },
 
 
     /** @id MochiKit.DOM.insertSiblingNodesBefore */
     insertSiblingNodesBefore: function (node/*, nodes...*/) {
         var elem = node;
         var self = MochiKit.DOM;
         if (typeof(node) == 'string') {
             elem = self.getElement(node);
         }
         var nodeStack = [
             self.coerceToDOM(
                 MochiKit.Base.extend(null, arguments, 1),
                 elem
             )
         ];
         var parentnode = elem.parentNode;
         var concat = MochiKit.Base.concat;
         while (nodeStack.length) {
             var n = nodeStack.shift();
             if (typeof(n) == 'undefined' || n === null) {
                 // pass
             } else if (typeof(n.nodeType) == 'number') {
                 parentnode.insertBefore(n, elem);
             } else {
                 nodeStack = concat(n, nodeStack);
             }
         }
         return parentnode;
     },
 
     /** @id MochiKit.DOM.insertSiblingNodesAfter */
     insertSiblingNodesAfter: function (node/*, nodes...*/) {
         var elem = node;
         var self = MochiKit.DOM;
 
         if (typeof(node) == 'string') {
             elem = self.getElement(node);
         }
         var nodeStack = [
             self.coerceToDOM(
                 MochiKit.Base.extend(null, arguments, 1),
                 elem
             )
         ];
 
         if (elem.nextSibling) {
             return self.insertSiblingNodesBefore(elem.nextSibling, nodeStack);
         }
         else {
             return self.appendChildNodes(elem.parentNode, nodeStack);
         }
     },
 
     /** @id MochiKit.DOM.replaceChildNodes */
     replaceChildNodes: function (node/*, nodes...*/) {
         var elem = node;
         var self = MochiKit.DOM;
         if (typeof(node) == 'string') {
             elem = self.getElement(node);
             arguments[0] = elem;
         }
         var child;
         while ((child = elem.firstChild)) {
             elem.removeChild(child);
         }
         if (arguments.length < 2) {
             return elem;
         } else {
             return self.appendChildNodes.apply(this, arguments);
         }
     },
 
     /** @id MochiKit.DOM.createDOM */
     createDOM: function (name, attrs/*, nodes... */) {
         var elem;
         var self = MochiKit.DOM;
         var m = MochiKit.Base;
         if (typeof(attrs) == "string" || typeof(attrs) == "number") {
             var args = m.extend([name, null], arguments, 1);
             return arguments.callee.apply(this, args);
         }
         if (typeof(name) == 'string') {
             // Internet Explorer is dumb
             var xhtml = self._xhtml;
             if (attrs && !self.attributeArray.compliant) {
                 // http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/name_2.asp
                 var contents = "";
                 if ('name' in attrs) {
                     contents += ' name="' + self.escapeHTML(attrs.name) + '"';
                 }
                 if (name == 'input' && 'type' in attrs) {
                     contents += ' type="' + self.escapeHTML(attrs.type) + '"';
                 }
                 if (contents) {
                     name = "<" + name + contents + ">";
                     xhtml = false;
                 }
             }
             var d = self._document;
             if (xhtml && d === document) {
                 elem = d.createElementNS("http://www.w3.org/1999/xhtml", name);
             } else {
                 elem = d.createElement(name);
             }
         } else {
             elem = name;
         }
         if (attrs) {
             self.updateNodeAttributes(elem, attrs);
         }
         if (arguments.length <= 2) {
             return elem;
         } else {
             var args = m.extend([elem], arguments, 2);
             return self.appendChildNodes.apply(this, args);
         }
     },
 
     /** @id MochiKit.DOM.createDOMFunc */
     createDOMFunc: function (/* tag, attrs, *nodes */) {
         var m = MochiKit.Base;
         return m.partial.apply(
             this,
             m.extend([MochiKit.DOM.createDOM], arguments)
         );
     },
 
     /** @id MochiKit.DOM.removeElement */
     removeElement: function (elem) {
         var self = MochiKit.DOM;
         if (typeof(elem) == "string") {
             elem = self.getElement(elem);
         }
         var e = self.coerceToDOM(elem);
         e.parentNode.removeChild(e);
         return e;
     },
 
     /** @id MochiKit.DOM.swapDOM */
     swapDOM: function (dest, src) {
         var self = MochiKit.DOM;
         dest = self.getElement(dest);
         var parent = dest.parentNode;
         if (src) {
             if (typeof(src) == "string") {
                 src = self.getElement(src);
             }
             src = self.coerceToDOM(src, parent);
             parent.replaceChild(src, dest);
         } else {
             parent.removeChild(dest);
         }
         return src;
     },
 
     /** @id MochiKit.DOM.getElement */
     getElement: function (id) {
         var self = MochiKit.DOM;
         if (arguments.length == 1) {
             return ((typeof(id) == "string") ?
                 self._document.getElementById(id) : id);
         } else {
             return MochiKit.Base.map(self.getElement, arguments);
         }
     },
 
     /** @id MochiKit.DOM.getElementsByTagAndClassName */
     getElementsByTagAndClassName: function (tagName, className,
             /* optional */parent) {
         var self = MochiKit.DOM;
         if (typeof(tagName) == 'undefined' || tagName === null) {
             tagName = '*';
         }
         if (typeof(parent) == 'undefined' || parent === null) {
             parent = self._document;
         }
         parent = self.getElement(parent);
         if (parent == null) {
             return [];
         }
         var children = (parent.getElementsByTagName(tagName)
             || self._document.all);
         if (typeof(className) == 'undefined' || className === null) {
             return MochiKit.Base.extend(null, children);
         }
 
         var elements = [];
         for (var i = 0; i < children.length; i++) {
             var child = children[i];
             var cls = child.className;
             if (typeof(cls) != "string") {
                 cls = child.getAttribute("class");
             }
             if (typeof(cls) == "string") {
                 var classNames = cls.split(' ');
                 for (var j = 0; j < classNames.length; j++) {
                     if (classNames[j] == className) {
                         elements.push(child);
                         break;
                     }
                 }
             }
         }
 
         return elements;
     },
 
     _newCallStack: function (path, once) {
         var rval = function () {
             var callStack = arguments.callee.callStack;
             for (var i = 0; i < callStack.length; i++) {
                 if (callStack[i].apply(this, arguments) === false) {
                     break;
                 }
             }
             if (once) {
                 try {
                     this[path] = null;
                 } catch (e) {
                     // pass
                 }
             }
         };
         rval.callStack = [];
         return rval;
     },
 
     /** @id MochiKit.DOM.addToCallStack */
     addToCallStack: function (target, path, func, once) {
         var self = MochiKit.DOM;
         var existing = target[path];
         var regfunc = existing;
         if (!(typeof(existing) == 'function'
                 && typeof(existing.callStack) == "object"
                 && existing.callStack !== null)) {
             regfunc = self._newCallStack(path, once);
             if (typeof(existing) == 'function') {
                 regfunc.callStack.push(existing);
             }
             target[path] = regfunc;
         }
         regfunc.callStack.push(func);
     },
 
     /** @id MochiKit.DOM.addLoadEvent */
     addLoadEvent: function (func) {
         var self = MochiKit.DOM;
         self.addToCallStack(self._window, "onload", func, true);
 
     },
 
     /** @id MochiKit.DOM.focusOnLoad */
     focusOnLoad: function (element) {
         var self = MochiKit.DOM;
         self.addLoadEvent(function () {
             element = self.getElement(element);
             if (element) {
                 element.focus();
             }
         });
     },
 
     /** @id MochiKit.DOM.setElementClass */
     setElementClass: function (element, className) {
         var self = MochiKit.DOM;
         var obj = self.getElement(element);
         if (self.attributeArray.compliant) {
             obj.setAttribute("class", className);
         } else {
             obj.setAttribute("className", className);
         }
     },
 
     /** @id MochiKit.DOM.toggleElementClass */
     toggleElementClass: function (className/*, element... */) {
         var self = MochiKit.DOM;
         for (var i = 1; i < arguments.length; i++) {
             var obj = self.getElement(arguments[i]);
             if (!self.addElementClass(obj, className)) {
                 self.removeElementClass(obj, className);
             }
         }
     },
 
     /** @id MochiKit.DOM.addElementClass */
     addElementClass: function (element, className) {
         var self = MochiKit.DOM;
         var obj = self.getElement(element);
         var cls = obj.className;
         if (typeof(cls) != "string") {
             cls = obj.getAttribute("class");
         }
         // trivial case, no className yet
         if (typeof(cls) != "string" || cls.length === 0) {
             self.setElementClass(obj, className);
             return true;
         }
         // the other trivial case, already set as the only class
         if (cls == className) {
             return false;
         }
         var classes = cls.split(" ");
         for (var i = 0; i < classes.length; i++) {
             // already present
             if (classes[i] == className) {
                 return false;
             }
         }
         // append class
         self.setElementClass(obj, cls + " " + className);
         return true;
     },
 
     /** @id MochiKit.DOM.removeElementClass */
     removeElementClass: function (element, className) {
         var self = MochiKit.DOM;
         var obj = self.getElement(element);
         var cls = obj.className;
         if (typeof(cls) != "string") {
             cls = obj.getAttribute("class");
         }
         // trivial case, no className yet
         if (typeof(cls) != "string" || cls.length === 0) {
             return false;
         }
         // other trivial case, set only to className
         if (cls == className) {
             self.setElementClass(obj, "");
             return true;
         }
         var classes = cls.split(" ");
         for (var i = 0; i < classes.length; i++) {
             // already present
             if (classes[i] == className) {
                 // only check sane case where the class is used once
                 classes.splice(i, 1);
                 self.setElementClass(obj, classes.join(" "));
                 return true;
             }
         }
         // not found
         return false;
     },
 
     /** @id MochiKit.DOM.swapElementClass */
     swapElementClass: function (element, fromClass, toClass) {
         var obj = MochiKit.DOM.getElement(element);
         var res = MochiKit.DOM.removeElementClass(obj, fromClass);
         if (res) {
             MochiKit.DOM.addElementClass(obj, toClass);
         }
         return res;
     },
 
     /** @id MochiKit.DOM.hasElementClass */
     hasElementClass: function (element, className/*...*/) {
         var obj = MochiKit.DOM.getElement(element);
         if (obj == null) {
             return false;
         }
         var cls = obj.className;
         if (typeof(cls) != "string" && typeof(obj.getAttribute) == "function") {
             cls = obj.getAttribute("class");
         }
         if (typeof(cls) != "string") {
             return false;
         }
         var classes = cls.split(" ");
         for (var i = 1; i < arguments.length; i++) {
             var good = false;
             for (var j = 0; j < classes.length; j++) {
                 if (classes[j] == arguments[i]) {
                     good = true;
                     break;
                 }
             }
             if (!good) {
                 return false;
             }
         }
         return true;
     },
 
     /** @id MochiKit.DOM.escapeHTML */
     escapeHTML: function (s) {
         return s.replace(/&/g, "&amp;"
             ).replace(/"/g, "&quot;"
             ).replace(/</g, "&lt;"
             ).replace(/>/g, "&gt;");
     },
 
     /** @id MochiKit.DOM.toHTML */
     toHTML: function (dom) {
         return MochiKit.DOM.emitHTML(dom).join("");
     },
 
     /** @id MochiKit.DOM.emitHTML */
     emitHTML: function (dom, /* optional */lst) {
         if (typeof(lst) == 'undefined' || lst === null) {
             lst = [];
         }
         // queue is the call stack, we're doing this non-recursively
         var queue = [dom];
         var self = MochiKit.DOM;
         var escapeHTML = self.escapeHTML;
         var attributeArray = self.attributeArray;
         while (queue.length) {
             dom = queue.pop();
             if (typeof(dom) == 'string') {
                 lst.push(dom);
             } else if (dom.nodeType == 1) {
                 // we're not using higher order stuff here
                 // because safari has heisenbugs.. argh.
                 //
                 // I think it might have something to do with
                 // garbage collection and function calls.
                 lst.push('<' + dom.tagName.toLowerCase());
                 var attributes = [];
                 var domAttr = attributeArray(dom);
                 for (var i = 0; i < domAttr.length; i++) {
                     var a = domAttr[i];
                     attributes.push([
                         " ",
                         a.name,
                         '="',
                         escapeHTML(a.value),
                         '"'
                     ]);
                 }
                 attributes.sort();
                 for (i = 0; i < attributes.length; i++) {
                     var attrs = attributes[i];
                     for (var j = 0; j < attrs.length; j++) {
                         lst.push(attrs[j]);
                     }
                 }
                 if (dom.hasChildNodes()) {
                     lst.push(">");
                     // queue is the FILO call stack, so we put the close tag
                     // on first
                     queue.push("</" + dom.tagName.toLowerCase() + ">");
                     var cnodes = dom.childNodes;
                     for (i = cnodes.length - 1; i >= 0; i--) {
                         queue.push(cnodes[i]);
                     }
                 } else {
                     lst.push('/>');
                 }
             } else if (dom.nodeType == 3) {
                 lst.push(escapeHTML(dom.nodeValue));
             }
         }
         return lst;
     },
 
     /** @id MochiKit.DOM.scrapeText */
     scrapeText: function (node, /* optional */asArray) {
         var rval = [];
         (function (node) {
             var cn = node.childNodes;
             if (cn) {
                 for (var i = 0; i < cn.length; i++) {
                     arguments.callee.call(this, cn[i]);
                 }
             }
             var nodeValue = node.nodeValue;
             if (typeof(nodeValue) == 'string') {
                 rval.push(nodeValue);
             }
         })(MochiKit.DOM.getElement(node));
         if (asArray) {
             return rval;
         } else {
             return rval.join("");
         }
     },
 
     /** @id MochiKit.DOM.removeEmptyTextNodes */
     removeEmptyTextNodes: function (element) {
         element = MochiKit.DOM.getElement(element);
         for (var i = 0; i < element.childNodes.length; i++) {
             var node = element.childNodes[i];
             if (node.nodeType == 3 && !/\S/.test(node.nodeValue)) {
                 node.parentNode.removeChild(node);
             }
         }
     },
 
     /** @id MochiKit.DOM.getFirstElementByTagAndClassName */
     getFirstElementByTagAndClassName: function (tagName, className,
             /* optional */parent) {
         var self = MochiKit.DOM;
         if (typeof(tagName) == 'undefined' || tagName === null) {
             tagName = '*';
         }
         if (typeof(parent) == 'undefined' || parent === null) {
             parent = self._document;
         }
         parent = self.getElement(parent);
         if (parent == null) {
             return null;
         }
         var children = (parent.getElementsByTagName(tagName)
             || self._document.all);
         if (children.length <= 0) {
             return null;
         } else if (typeof(className) == 'undefined' || className === null) {
             return children[0];
         }
 
         for (var i = 0; i < children.length; i++) {
             var child = children[i];
             var cls = child.className;
             if (typeof(cls) != "string") {
                 cls = child.getAttribute("class");
             }
             if (typeof(cls) == "string") {
                 var classNames = cls.split(' ');
                 for (var j = 0; j < classNames.length; j++) {
                     if (classNames[j] == className) {
                         return child;
                     }
                 }
             }
         }
         return null;
     },
 
     /** @id MochiKit.DOM.getFirstParentByTagAndClassName */
     getFirstParentByTagAndClassName: function (elem, tagName, className) {
         var self = MochiKit.DOM;
         elem = self.getElement(elem);
         if (typeof(tagName) == 'undefined' || tagName === null) {
             tagName = '*';
         } else {
             tagName = tagName.toUpperCase();
         }
         if (typeof(className) == 'undefined' || className === null) {
             className = null;
         }
         if (elem) {
             elem = elem.parentNode;
         }
         while (elem && elem.tagName) {
             var curTagName = elem.tagName.toUpperCase();
             if ((tagName === '*' || tagName == curTagName) &&
                 (className === null || self.hasElementClass(elem, className))) {
                 return elem;
             }
             elem = elem.parentNode;
         }
         return null;
     },
 
     __new__: function (win) {
 
         var m = MochiKit.Base;
         if (typeof(document) != "undefined") {
             this._document = document;
             var kXULNSURI = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
             this._xhtml = (document.documentElement &&
                 document.createElementNS &&
                 document.documentElement.namespaceURI === kXULNSURI);
         } else if (MochiKit.MockDOM) {
             this._document = MochiKit.MockDOM.document;
         }
         this._window = win;
 
         this.domConverters = new m.AdapterRegistry();
 
         var __tmpElement = this._document.createElement("span");
         var attributeArray;
         if (__tmpElement && __tmpElement.attributes &&
                 __tmpElement.attributes.length > 0) {
             // for braindead browsers (IE) that insert extra junk
             var filter = m.filter;
             attributeArray = function (node) {
                 /***
 
                     Return an array of attributes for a given node,
                     filtering out attributes that don't belong for
                     that are inserted by "Certain Browsers".
 
                 ***/
                 return filter(attributeArray.ignoreAttrFilter, node.attributes);
             };
             attributeArray.ignoreAttr = {};
             var attrs = __tmpElement.attributes;
             var ignoreAttr = attributeArray.ignoreAttr;
             for (var i = 0; i < attrs.length; i++) {
                 var a = attrs[i];
                 ignoreAttr[a.name] = a.value;
             }
             attributeArray.ignoreAttrFilter = function (a) {
                 return (attributeArray.ignoreAttr[a.name] != a.value);
             };
             attributeArray.compliant = false;
             attributeArray.renames = {
                 "class": "className",
                 "checked": "defaultChecked",
                 "usemap": "useMap",
                 "for": "htmlFor",
                 "readonly": "readOnly",
                 "colspan": "colSpan",
+                "rowspan": "rowSpan",
                 "bgcolor": "bgColor",
                 "cellspacing": "cellSpacing",
                 "cellpadding": "cellPadding"
             };
         } else {
             attributeArray = function (node) {
                 return node.attributes;
             };
             attributeArray.compliant = true;
             attributeArray.ignoreAttr = {};
             attributeArray.renames = {};
         }
         attributeArray.__export__ = false;
         this.attributeArray = attributeArray;
 
         // Backwards compatibility aliases
         /** @id MochiKit.DOM.computedStyle  */
-        m._deprecated(this, 'computedStyle', 'MochiKit.Style.getStyle', '1.4');
+        m._deprecated(this, 'computedStyle', 'MochiKit.Style.getStyle', '1.4', true);
         /** @id MochiKit.DOM.elementDimensions  */
         m._deprecated(this, 'elementDimensions', 'MochiKit.Style.getElementDimensions', '1.4');
         /** @id MochiKit.DOM.elementPosition  */
         m._deprecated(this, 'elementPosition', 'MochiKit.Style.getElementPosition', '1.4');
         /** @id MochiKit.DOM.getViewportDimensions */
         m._deprecated(this, 'getViewportDimensions', 'MochiKit.Style.getViewportDimensions', '1.4');
         /** @id MochiKit.DOM.hideElement */
         m._deprecated(this, 'hideElement', 'MochiKit.Style.hideElement', '1.4');
         /** @id MochiKit.DOM.makeClipping */
         m._deprecated(this, 'makeClipping', 'MochiKit.Style.makeClipping', '1.4.1');
         /** @id MochiKit.DOM.makePositioned */
         m._deprecated(this, 'makePositioned', 'MochiKit.Style.makePositioned', '1.4.1');
         /** @id MochiKit.DOM.setElementDimensions */
         m._deprecated(this, 'setElementDimensions', 'MochiKit.Style.setElementDimensions', '1.4');
         /** @id MochiKit.DOM.setElementPosition */
         m._deprecated(this, 'setElementPosition', 'MochiKit.Style.setElementPosition', '1.4');
         /** @id MochiKit.DOM.setDisplayForElement */
         m._deprecated(this, 'setDisplayForElement', 'MochiKit.Style.setDisplayForElement', '1.4');
         /** @id MochiKit.DOM.setOpacity */
         m._deprecated(this, 'setOpacity', 'MochiKit.Style.setOpacity', '1.4');
         /** @id MochiKit.DOM.showElement */
         m._deprecated(this, 'showElement', 'MochiKit.Style.showElement', '1.4');
         /** @id MochiKit.DOM.undoClipping */
         m._deprecated(this, 'undoClipping', 'MochiKit.Style.undoClipping', '1.4.1');
         /** @id MochiKit.DOM.undoPositioned */
         m._deprecated(this, 'undoPositioned', 'MochiKit.Style.undoPositioned', '1.4.1');
         /** @id MochiKit.DOM.Coordinates */
         m._deprecated(this, 'Coordinates', 'MochiKit.Style.Coordinates', '1.4');
         /** @id MochiKit.DOM.Dimensions */
         m._deprecated(this, 'Dimensions', 'MochiKit.Style.Dimensions', '1.4');
 
         // shorthand for createDOM syntax
         var createDOMFunc = this.createDOMFunc;
-        /** @id MochiKit.DOM.UL */
-        this.UL = createDOMFunc("ul");
-        /** @id MochiKit.DOM.OL */
-        this.OL = createDOMFunc("ol");
-        /** @id MochiKit.DOM.LI */
-        this.LI = createDOMFunc("li");
-        /** @id MochiKit.DOM.DL */
-        this.DL = createDOMFunc("dl");
-        /** @id MochiKit.DOM.DT */
-        this.DT = createDOMFunc("dt");
-        /** @id MochiKit.DOM.DD */
-        this.DD = createDOMFunc("dd");
-        /** @id MochiKit.DOM.TD */
-        this.TD = createDOMFunc("td");
-        /** @id MochiKit.DOM.TR */
-        this.TR = createDOMFunc("tr");
-        /** @id MochiKit.DOM.TBODY */
-        this.TBODY = createDOMFunc("tbody");
-        /** @id MochiKit.DOM.THEAD */
-        this.THEAD = createDOMFunc("thead");
-        /** @id MochiKit.DOM.TFOOT */
-        this.TFOOT = createDOMFunc("tfoot");
-        /** @id MochiKit.DOM.TABLE */
-        this.TABLE = createDOMFunc("table");
-        /** @id MochiKit.DOM.TH */
-        this.TH = createDOMFunc("th");
-        /** @id MochiKit.DOM.INPUT */
-        this.INPUT = createDOMFunc("input");
-        /** @id MochiKit.DOM.SPAN */
-        this.SPAN = createDOMFunc("span");
         /** @id MochiKit.DOM.A */
         this.A = createDOMFunc("a");
-        /** @id MochiKit.DOM.DIV */
-        this.DIV = createDOMFunc("div");
-        /** @id MochiKit.DOM.IMG */
-        this.IMG = createDOMFunc("img");
+        /** @id MochiKit.DOM.ARTICLE */
+        this.ARTICLE = createDOMFunc("article");
+        /** @id MochiKit.DOM.ASIDE */
+        this.ASIDE = createDOMFunc("aside");
+        /** @id MochiKit.DOM.BR */
+        this.BR = createDOMFunc("br");
         /** @id MochiKit.DOM.BUTTON */
         this.BUTTON = createDOMFunc("button");
-        /** @id MochiKit.DOM.TT */
-        this.TT = createDOMFunc("tt");
-        /** @id MochiKit.DOM.PRE */
-        this.PRE = createDOMFunc("pre");
+        /** @id MochiKit.DOM.CANVAS */
+        this.CANVAS = createDOMFunc("canvas");
+        /** @id MochiKit.DOM.CAPTION */
+        this.CAPTION = createDOMFunc("caption");
+        /** @id MochiKit.DOM.DD */
+        this.DD = createDOMFunc("dd");
+        /** @id MochiKit.DOM.DIV */
+        this.DIV = createDOMFunc("div");
+        /** @id MochiKit.DOM.DL */
+        this.DL = createDOMFunc("dl");
+        /** @id MochiKit.DOM.DT */
+        this.DT = createDOMFunc("dt");
+        /** @id MochiKit.DOM.FIELDSET */
+        this.FIELDSET = createDOMFunc("fieldset");
+        /** @id MochiKit.DOM.FIGURE */
+        this.FIGURE = createDOMFunc("figure");
+        /** @id MochiKit.DOM.FIGCAPTION */
+        this.FIGCAPTION = createDOMFunc("figcaption");
+        /** @id MochiKit.DOM.FOOTER */
+        this.FOOTER = createDOMFunc("footer");
+        /** @id MochiKit.DOM.FORM */
+        this.FORM = createDOMFunc("form");
         /** @id MochiKit.DOM.H1 */
         this.H1 = createDOMFunc("h1");
         /** @id MochiKit.DOM.H2 */
         this.H2 = createDOMFunc("h2");
         /** @id MochiKit.DOM.H3 */
         this.H3 = createDOMFunc("h3");
         /** @id MochiKit.DOM.H4 */
         this.H4 = createDOMFunc("h4");
         /** @id MochiKit.DOM.H5 */
         this.H5 = createDOMFunc("h5");
         /** @id MochiKit.DOM.H6 */
         this.H6 = createDOMFunc("h6");
-        /** @id MochiKit.DOM.BR */
-        this.BR = createDOMFunc("br");
+        /** @id MochiKit.DOM.HEADER */
+        this.HEADER = createDOMFunc("header");
+        /** @id MochiKit.DOM.HGROUP */
+        this.HGROUP = createDOMFunc("hgroup");
         /** @id MochiKit.DOM.HR */
         this.HR = createDOMFunc("hr");
+        /** @id MochiKit.DOM.IFRAME */
+        this.IFRAME = createDOMFunc("iframe");
+        /** @id MochiKit.DOM.IMG */
+        this.IMG = createDOMFunc("img");
+        /** @id MochiKit.DOM.INPUT */
+        this.INPUT = createDOMFunc("input");
         /** @id MochiKit.DOM.LABEL */
         this.LABEL = createDOMFunc("label");
-        /** @id MochiKit.DOM.TEXTAREA */
-        this.TEXTAREA = createDOMFunc("textarea");
-        /** @id MochiKit.DOM.FORM */
-        this.FORM = createDOMFunc("form");
+        /** @id MochiKit.DOM.LEGEND */
+        this.LEGEND = createDOMFunc("legend");
+        /** @id MochiKit.DOM.LI */
+        this.LI = createDOMFunc("li");
+        /** @id MochiKit.DOM.LINK */
+        this.LINK = createDOMFunc("link");
+        /** @id MochiKit.DOM.MARK */
+        this.MARK = createDOMFunc("mark");
+        /** @id MochiKit.DOM.METER */
+        this.METER = createDOMFunc("meter");
+        /** @id MochiKit.DOM.NAV */
+        this.NAV = createDOMFunc("nav");
+        /** @id MochiKit.DOM.OL */
+        this.OL = createDOMFunc("ol");
+        /** @id MochiKit.DOM.OPTGROUP */
+        this.OPTGROUP = createDOMFunc("optgroup");
+        /** @id MochiKit.DOM.OPTION */
+        this.OPTION = createDOMFunc("option");
         /** @id MochiKit.DOM.P */
         this.P = createDOMFunc("p");
+        /** @id MochiKit.DOM.PRE */
+        this.PRE = createDOMFunc("pre");
+        /** @id MochiKit.DOM.PROGRESS */
+        this.PROGRESS = createDOMFunc("progress");
+        /** @id MochiKit.DOM.SCRIPT */
+        this.SCRIPT = createDOMFunc("script");
+        /** @id MochiKit.DOM.SECTION */
+        this.SECTION = createDOMFunc("section");
         /** @id MochiKit.DOM.SELECT */
         this.SELECT = createDOMFunc("select");
-        /** @id MochiKit.DOM.OPTION */
-        this.OPTION = createDOMFunc("option");
-        /** @id MochiKit.DOM.OPTGROUP */
-        this.OPTGROUP = createDOMFunc("optgroup");
-        /** @id MochiKit.DOM.LEGEND */
-        this.LEGEND = createDOMFunc("legend");
-        /** @id MochiKit.DOM.FIELDSET */
-        this.FIELDSET = createDOMFunc("fieldset");
+        /** @id MochiKit.DOM.SPAN */
+        this.SPAN = createDOMFunc("span");
         /** @id MochiKit.DOM.STRONG */
         this.STRONG = createDOMFunc("strong");
-        /** @id MochiKit.DOM.CANVAS */
-        this.CANVAS = createDOMFunc("canvas");
-
+        /** @id MochiKit.DOM.STYLE */
+        this.STYLE = createDOMFunc("style");
+        /** @id MochiKit.DOM.TABLE */
+        this.TABLE = createDOMFunc("table");
+        /** @id MochiKit.DOM.TBODY */
+        this.TBODY = createDOMFunc("tbody");
+        /** @id MochiKit.DOM.TD */
+        this.TD = createDOMFunc("td");
+        /** @id MochiKit.DOM.TEXTAREA */
+        this.TEXTAREA = createDOMFunc("textarea");
+        /** @id MochiKit.DOM.TFOOT */
+        this.TFOOT = createDOMFunc("tfoot");
+        /** @id MochiKit.DOM.TH */
+        this.TH = createDOMFunc("th");
+        /** @id MochiKit.DOM.THEAD */
+        this.THEAD = createDOMFunc("thead");
+        /** @id MochiKit.DOM.TR */
+        this.TR = createDOMFunc("tr");
+        /** @id MochiKit.DOM.TT */
+        this.TT = createDOMFunc("tt");
+        /** @id MochiKit.DOM.UL */
+        this.UL = createDOMFunc("ul");
+        /** @id MochiKit.DOM.NBSP */
+        this.NBSP = "\u00a0";
         /** @id MochiKit.DOM.$ */
         this.$ = this.getElement;
 
         m.nameFunctions(this);
-
     }
 });
 
 
 MochiKit.DOM.__new__(((typeof(window) == "undefined") ? this : window));
 
 //
 // XXX: Internet Explorer blows
 //
 if (MochiKit.__export__) {
     withWindow = MochiKit.DOM.withWindow;
     withDocument = MochiKit.DOM.withDocument;
 }
 
 MochiKit.Base._exportSymbols(this, MochiKit.DOM);
diff --git a/frontend/gamma/js/MochiKit/DateTime.js b/frontend/gamma/js/MochiKit/DateTime.js
index c7b2d25..658084c 100644
--- a/frontend/gamma/js/MochiKit/DateTime.js
+++ b/frontend/gamma/js/MochiKit/DateTime.js
@@ -1,173 +1,176 @@
 /***
 
 MochiKit.DateTime 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('DateTime', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'DateTime', '1.5', ['Base']);
 
 /** @id MochiKit.DateTime.isoDate */
 MochiKit.DateTime.isoDate = function (str) {
     str = str + "";
     if (typeof(str) != "string" || str.length === 0) {
         return null;
     }
     var iso = str.split('-');
     if (iso.length === 0) {
         return null;
     }
-        var date = new Date(iso[0], iso[1] - 1, iso[2]);
-        date.setFullYear(iso[0]);
-        date.setMonth(iso[1] - 1);
-        date.setDate(iso[2]);
+    var date = new Date(parseInt(iso[0], 10), parseInt(iso[1], 10) - 1, parseInt(iso[2], 10));
+    date.setFullYear(iso[0]);
+    date.setMonth(iso[1] - 1);
+    date.setDate(iso[2]);
     return date;
 };
 
 MochiKit.DateTime._isoRegexp = /(\d{4,})(?:-(\d{1,2})(?:-(\d{1,2})(?:[T ](\d{1,2}):(\d{1,2})(?::(\d{1,2})(?:\.(\d+))?)?(?:(Z)|([+-])(\d{1,2})(?::(\d{1,2}))?)?)?)?)?/;
 
 /** @id MochiKit.DateTime.isoTimestamp */
 MochiKit.DateTime.isoTimestamp = function (str) {
     str = str + "";
     if (typeof(str) != "string" || str.length === 0) {
         return null;
     }
     var res = str.match(MochiKit.DateTime._isoRegexp);
     if (typeof(res) == "undefined" || res === null) {
         return null;
     }
     var year, month, day, hour, min, sec, msec;
     year = parseInt(res[1], 10);
     if (typeof(res[2]) == "undefined" || res[2] === '') {
         return new Date(year);
     }
     month = parseInt(res[2], 10) - 1;
     day = parseInt(res[3], 10);
     if (typeof(res[4]) == "undefined" || res[4] === '') {
         return new Date(year, month, day);
     }
     hour = parseInt(res[4], 10);
     min = parseInt(res[5], 10);
     sec = (typeof(res[6]) != "undefined" && res[6] !== '') ? parseInt(res[6], 10) : 0;
     if (typeof(res[7]) != "undefined" && res[7] !== '') {
         msec = Math.round(1000.0 * parseFloat("0." + res[7]));
     } else {
         msec = 0;
     }
     if ((typeof(res[8]) == "undefined" || res[8] === '') && (typeof(res[9]) == "undefined" || res[9] === '')) {
         return new Date(year, month, day, hour, min, sec, msec);
     }
     var ofs;
     if (typeof(res[9]) != "undefined" && res[9] !== '') {
         ofs = parseInt(res[10], 10) * 3600000;
         if (typeof(res[11]) != "undefined" && res[11] !== '') {
             ofs += parseInt(res[11], 10) * 60000;
         }
         if (res[9] == "-") {
             ofs = -ofs;
         }
     } else {
         ofs = 0;
     }
     return new Date(Date.UTC(year, month, day, hour, min, sec, msec) - ofs);
 };
 
 /** @id MochiKit.DateTime.toISOTime */
 MochiKit.DateTime.toISOTime = function (date, realISO/* = false */) {
     if (typeof(date) == "undefined" || date === null) {
         return null;
     }
-    var hh = date.getHours();
-    var mm = date.getMinutes();
-    var ss = date.getSeconds();
+    var _padTwo = MochiKit.DateTime._padTwo;
+    if (realISO) {
+        // adjust date for UTC timezone
+        date = new Date(date.getTime() + (date.getTimezoneOffset() * 60000));
+    }
     var lst = [
-        ((realISO && (hh < 10)) ? "0" + hh : hh),
-        ((mm < 10) ? "0" + mm : mm),
-        ((ss < 10) ? "0" + ss : ss)
+        (realISO ? _padTwo(date.getHours()) : date.getHours()),
+        _padTwo(date.getMinutes()),
+        _padTwo(date.getSeconds())
     ];
-    return lst.join(":");
+    return lst.join(":") + (realISO ? "Z" : "");
 };
 
 /** @id MochiKit.DateTime.toISOTimeStamp */
 MochiKit.DateTime.toISOTimestamp = function (date, realISO/* = false*/) {
     if (typeof(date) == "undefined" || date === null) {
         return null;
     }
+    var time = MochiKit.DateTime.toISOTime(date, realISO);
     var sep = realISO ? "T" : " ";
-    var foot = realISO ? "Z" : "";
     if (realISO) {
+        // adjust date for UTC timezone
         date = new Date(date.getTime() + (date.getTimezoneOffset() * 60000));
     }
-    return MochiKit.DateTime.toISODate(date) + sep + MochiKit.DateTime.toISOTime(date, realISO) + foot;
+    return MochiKit.DateTime.toISODate(date) + sep + time;
 };
 
 /** @id MochiKit.DateTime.toISODate */
 MochiKit.DateTime.toISODate = function (date) {
     if (typeof(date) == "undefined" || date === null) {
         return null;
     }
     var _padTwo = MochiKit.DateTime._padTwo;
-        var _padFour = MochiKit.DateTime._padFour;
+    var _padFour = MochiKit.DateTime._padFour;
     return [
         _padFour(date.getFullYear()),
         _padTwo(date.getMonth() + 1),
         _padTwo(date.getDate())
     ].join("-");
 };
 
 /** @id MochiKit.DateTime.americanDate */
 MochiKit.DateTime.americanDate = function (d) {
     d = d + "";
     if (typeof(d) != "string" || d.length === 0) {
         return null;
     }
     var a = d.split('/');
     return new Date(a[2], a[0] - 1, a[1]);
 };
 
 MochiKit.DateTime._padTwo = function (n) {
     return (n > 9) ? n : "0" + n;
 };
 
 MochiKit.DateTime._padFour = function(n) {
-        switch(n.toString().length) {
-                case 1: return "000" + n; break;
-                case 2: return "00" + n; break;
-                case 3: return "0" + n; break;
-                case 4:
-                default:
-                        return n;
-        }
+    switch(n.toString().length) {
+        case 1: return "000" + n; break;
+        case 2: return "00" + n; break;
+        case 3: return "0" + n; break;
+        case 4:
+        default:
+            return n;
+    }
 };
 
 /** @id MochiKit.DateTime.toPaddedAmericanDate */
 MochiKit.DateTime.toPaddedAmericanDate = function (d) {
     if (typeof(d) == "undefined" || d === null) {
         return null;
     }
     var _padTwo = MochiKit.DateTime._padTwo;
     return [
         _padTwo(d.getMonth() + 1),
         _padTwo(d.getDate()),
         d.getFullYear()
     ].join('/');
 };
 
 /** @id MochiKit.DateTime.toAmericanDate */
 MochiKit.DateTime.toAmericanDate = function (d) {
     if (typeof(d) == "undefined" || d === null) {
         return null;
     }
     return [d.getMonth() + 1, d.getDate(), d.getFullYear()].join('/');
 };
 
 MochiKit.DateTime.__new__ = function () {
     MochiKit.Base.nameFunctions(this);
 };
 
 MochiKit.DateTime.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.DateTime);
diff --git a/frontend/gamma/js/MochiKit/DragAndDrop.js b/frontend/gamma/js/MochiKit/DragAndDrop.js
index 62777c5..cf84f77 100644
--- a/frontend/gamma/js/MochiKit/DragAndDrop.js
+++ b/frontend/gamma/js/MochiKit/DragAndDrop.js
@@ -1,766 +1,766 @@
 /***
 MochiKit.DragAndDrop 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
     Mochi-ized By Thomas Herve (_firstname_@nimail.org)
 
 ***/
 
-MochiKit.Base._module('DragAndDrop', '1.5', ['Base', 'Iter', 'DOM', 'Signal', 'Visual', 'Position']);
+MochiKit.Base.module(MochiKit, 'DragAndDrop', '1.5', ['Base', 'Iter', 'DOM', 'Signal', 'Visual', 'Position']);
 
 MochiKit.DragAndDrop.Droppables = {
     /***
 
     Manage all droppables. Shouldn't be used, use the Droppable object instead.
 
     ***/
     drops: [],
 
     remove: function (element) {
         this.drops = MochiKit.Base.filter(function (d) {
             return d.element != MochiKit.DOM.getElement(element);
         }, this.drops);
     },
 
     register: function (drop) {
         this.drops.push(drop);
     },
 
     unregister: function (drop) {
         this.drops = MochiKit.Base.filter(function (d) {
             return d != drop;
         }, this.drops);
     },
 
     prepare: function (element) {
         MochiKit.Base.map(function (drop) {
             if (drop.isAccepted(element)) {
                 if (drop.options.activeclass) {
                     MochiKit.DOM.addElementClass(drop.element,
                                                  drop.options.activeclass);
                 }
                 drop.options.onactive(drop.element, element);
             }
         }, this.drops);
     },
 
     findDeepestChild: function (drops) {
         var deepest = drops[0];
 
         for (var i = 1; i < drops.length; ++i) {
             if (MochiKit.DOM.isChildNode(drops[i].element, deepest.element)) {
                 deepest = drops[i];
             }
         }
         return deepest;
     },
 
     show: function (point, element) {
         if (!this.drops.length) {
             return;
         }
         var affected = [];
 
         if (this.last_active) {
             this.last_active.deactivate();
         }
         MochiKit.Iter.forEach(this.drops, function (drop) {
             if (drop.isAffected(point, element)) {
                 affected.push(drop);
             }
         });
         if (affected.length > 0) {
             var drop = this.findDeepestChild(affected);
             MochiKit.Position.within(drop.element, point.page.x, point.page.y);
             drop.options.onhover(element, drop.element,
                 MochiKit.Position.overlap(drop.options.overlap, drop.element));
             drop.activate();
         }
     },
 
     fire: function (event, element) {
         if (!this.last_active) {
             return;
         }
         MochiKit.Position.prepare();
 
         if (this.last_active.isAffected(event.mouse(), element)) {
             this.last_active.options.ondrop(element,
                this.last_active.element, event);
         }
     },
 
     reset: function (element) {
         MochiKit.Base.map(function (drop) {
             if (drop.options.activeclass) {
                 MochiKit.DOM.removeElementClass(drop.element,
                                                 drop.options.activeclass);
             }
             drop.options.ondesactive(drop.element, element);
         }, this.drops);
         if (this.last_active) {
             this.last_active.deactivate();
         }
     }
 };
 
 /** @id MochiKit.DragAndDrop.Droppable */
 MochiKit.DragAndDrop.Droppable = function (element, options) {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls(element, options);
     }
     this.__init__(element, options);
 };
 
 MochiKit.DragAndDrop.Droppable.prototype = {
     /***
 
     A droppable object. Simple use is to create giving an element:
 
         new MochiKit.DragAndDrop.Droppable('myelement');
 
     Generally you'll want to define the 'ondrop' function and maybe the
     'accept' option to filter draggables.
 
     ***/
     __class__: MochiKit.DragAndDrop.Droppable,
 
     __init__: function (element, /* optional */options) {
         var d = MochiKit.DOM;
         var b = MochiKit.Base;
         this.element = d.getElement(element);
         this.options = b.update({
 
             /** @id MochiKit.DragAndDrop.greedy */
             greedy: true,
 
             /** @id MochiKit.DragAndDrop.hoverclass */
             hoverclass: null,
 
             /** @id MochiKit.DragAndDrop.activeclass */
             activeclass: null,
 
             /** @id MochiKit.DragAndDrop.hoverfunc */
             hoverfunc: b.noop,
 
             /** @id MochiKit.DragAndDrop.accept */
             accept: null,
 
             /** @id MochiKit.DragAndDrop.onactive */
             onactive: b.noop,
 
             /** @id MochiKit.DragAndDrop.ondesactive */
             ondesactive: b.noop,
 
             /** @id MochiKit.DragAndDrop.onhover */
             onhover: b.noop,
 
             /** @id MochiKit.DragAndDrop.ondrop */
             ondrop: b.noop,
 
             /** @id MochiKit.DragAndDrop.containment */
             containment: [],
             tree: false
         }, options);
 
         // cache containers
         this.options._containers = [];
         b.map(MochiKit.Base.bind(function (c) {
             this.options._containers.push(d.getElement(c));
         }, this), this.options.containment);
 
         MochiKit.Style.makePositioned(this.element); // fix IE
 
         MochiKit.DragAndDrop.Droppables.register(this);
     },
 
     /** @id MochiKit.DragAndDrop.isContained */
     isContained: function (element) {
         if (this.options._containers.length) {
             var containmentNode;
             if (this.options.tree) {
                 containmentNode = element.treeNode;
             } else {
                 containmentNode = element.parentNode;
             }
             return MochiKit.Iter.some(this.options._containers, function (c) {
                 return containmentNode == c;
             });
         } else {
             return true;
         }
     },
 
     /** @id MochiKit.DragAndDrop.isAccepted */
     isAccepted: function (element) {
         return ((!this.options.accept) || MochiKit.Iter.some(
           this.options.accept, function (c) {
             return MochiKit.DOM.hasElementClass(element, c);
         }));
     },
 
     /** @id MochiKit.DragAndDrop.isAffected */
     isAffected: function (point, element) {
         return ((this.element != element) &&
                 this.isContained(element) &&
                 this.isAccepted(element) &&
                 MochiKit.Position.within(this.element, point.page.x,
                                                        point.page.y));
     },
 
     /** @id MochiKit.DragAndDrop.deactivate */
     deactivate: function () {
         /***
 
         A droppable is deactivate when a draggable has been over it and left.
 
         ***/
         if (this.options.hoverclass) {
             MochiKit.DOM.removeElementClass(this.element,
                                             this.options.hoverclass);
         }
         this.options.hoverfunc(this.element, false);
         MochiKit.DragAndDrop.Droppables.last_active = null;
     },
 
     /** @id MochiKit.DragAndDrop.activate */
     activate: function () {
         /***
 
         A droppable is active when a draggable is over it.
 
         ***/
         if (this.options.hoverclass) {
             MochiKit.DOM.addElementClass(this.element, this.options.hoverclass);
         }
         this.options.hoverfunc(this.element, true);
         MochiKit.DragAndDrop.Droppables.last_active = this;
     },
 
     /** @id MochiKit.DragAndDrop.destroy */
     destroy: function () {
         /***
 
         Delete this droppable.
 
         ***/
         MochiKit.DragAndDrop.Droppables.unregister(this);
     },
 
     /** @id MochiKit.DragAndDrop.repr */
     repr: function () {
         return '[' + this.__class__.NAME + ", options:" + MochiKit.Base.repr(this.options) + "]";
     }
 };
 
 MochiKit.DragAndDrop.Draggables = {
     /***
 
     Manage draggables elements. Not intended to direct use.
 
     ***/
     drags: [],
 
     register: function (draggable) {
         if (this.drags.length === 0) {
             var conn = MochiKit.Signal.connect;
             this.eventMouseUp = conn(document, 'onmouseup', this, this.endDrag);
             this.eventMouseMove = conn(document, 'onmousemove', this,
                                        this.updateDrag);
             this.eventKeypress = conn(document, 'onkeypress', this,
                                       this.keyPress);
         }
         this.drags.push(draggable);
     },
 
     unregister: function (draggable) {
         this.drags = MochiKit.Base.filter(function (d) {
             return d != draggable;
         }, this.drags);
         if (this.drags.length === 0) {
             var disc = MochiKit.Signal.disconnect;
             disc(this.eventMouseUp);
             disc(this.eventMouseMove);
             disc(this.eventKeypress);
         }
     },
 
     activate: function (draggable) {
         // allows keypress events if window is not currently focused
         // fails for Safari
         window.focus();
         this.activeDraggable = draggable;
     },
 
     deactivate: function () {
         this.activeDraggable = null;
     },
 
     updateDrag: function (event) {
         if (!this.activeDraggable) {
             return;
         }
         var pointer = event.mouse();
         // Mozilla-based browsers fire successive mousemove events with
         // the same coordinates, prevent needless redrawing (moz bug?)
-        if (this._lastPointer && (MochiKit.Base.repr(this._lastPointer.page) ==
-                                  MochiKit.Base.repr(pointer.page))) {
+        if (this._lastPointer &&
+            this._lastPointer.page.x == pointer.page.x &&
+            this._lastPointer.page.y == pointer.page.y) {
             return;
         }
         this._lastPointer = pointer;
         this.activeDraggable.updateDrag(event, pointer);
     },
 
     endDrag: function (event) {
         if (!this.activeDraggable) {
             return;
         }
         this._lastPointer = null;
         this.activeDraggable.endDrag(event);
         this.activeDraggable = null;
     },
 
     keyPress: function (event) {
         if (this.activeDraggable) {
             this.activeDraggable.keyPress(event);
         }
     },
 
     notify: function (eventName, draggable, event) {
         MochiKit.Signal.signal(this, eventName, draggable, event);
     }
 };
 
 /** @id MochiKit.DragAndDrop.Draggable */
 MochiKit.DragAndDrop.Draggable = function (element, options) {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls(element, options);
     }
     this.__init__(element, options);
 };
 
 MochiKit.DragAndDrop.Draggable.prototype = {
     /***
 
     A draggable object. Simple instantiate :
 
         new MochiKit.DragAndDrop.Draggable('myelement');
 
     ***/
     __class__ : MochiKit.DragAndDrop.Draggable,
 
     __init__: function (element, /* optional */options) {
         var v = MochiKit.Visual;
         var b = MochiKit.Base;
         options = b.update({
 
             /** @id MochiKit.DragAndDrop.handle */
             handle: false,
 
             /** @id MochiKit.DragAndDrop.starteffect */
             starteffect: function (innerelement) {
                 this._savedOpacity = MochiKit.Style.getStyle(innerelement, 'opacity') || 1.0;
                 new v.Opacity(innerelement, {duration:0.2, from:this._savedOpacity, to:0.7});
             },
             /** @id MochiKit.DragAndDrop.reverteffect */
             reverteffect: function (innerelement, top_offset, left_offset) {
                 var dur = Math.sqrt(Math.abs(top_offset^2) +
                           Math.abs(left_offset^2))*0.02;
                 return new v.Move(innerelement,
                             {x: -left_offset, y: -top_offset, duration: dur});
             },
 
             /** @id MochiKit.DragAndDrop.endeffect */
             endeffect: function (innerelement) {
                 new v.Opacity(innerelement, {duration:0.2, from:0.7, to:this._savedOpacity});
             },
 
             /** @id MochiKit.DragAndDrop.onchange */
             onchange: b.noop,
 
             /** @id MochiKit.DragAndDrop.zindex */
             zindex: 1000,
 
             /** @id MochiKit.DragAndDrop.revert */
             revert: false,
 
             /** @id MochiKit.DragAndDrop.scroll */
             scroll: false,
 
             /** @id MochiKit.DragAndDrop.scrollSensitivity */
             scrollSensitivity: 20,
 
             /** @id MochiKit.DragAndDrop.scrollSpeed */
             scrollSpeed: 15,
             // false, or xy or [x, y] or function (x, y){return [x, y];}
 
             /** @id MochiKit.DragAndDrop.snap */
             snap: false
         }, options);
 
         var d = MochiKit.DOM;
         this.element = d.getElement(element);
 
         if (options.handle && (typeof(options.handle) == 'string')) {
             this.handle = d.getFirstElementByTagAndClassName(null,
                                        options.handle, this.element);
         }
         if (!this.handle) {
             this.handle = d.getElement(options.handle);
         }
         if (!this.handle) {
             this.handle = this.element;
         }
 
         if (options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
             options.scroll = d.getElement(options.scroll);
             this._isScrollChild = MochiKit.DOM.isChildNode(this.element, options.scroll);
         }
 
         MochiKit.Style.makePositioned(this.element);  // fix IE
 
         this.delta = this.currentDelta();
         this.options = options;
         this.dragging = false;
 
         this.eventMouseDown = MochiKit.Signal.connect(this.handle,
                               'onmousedown', this, this.initDrag);
         MochiKit.DragAndDrop.Draggables.register(this);
     },
 
     /** @id MochiKit.DragAndDrop.destroy */
     destroy: function () {
         MochiKit.Signal.disconnect(this.eventMouseDown);
         MochiKit.DragAndDrop.Draggables.unregister(this);
     },
 
     /** @id MochiKit.DragAndDrop.currentDelta */
     currentDelta: function () {
         var s = MochiKit.Style.getStyle;
         return [
-          parseInt(s(this.element, 'left') || '0'),
-          parseInt(s(this.element, 'top') || '0')];
+          parseInt(s(this.element, 'left') || '0', 10),
+          parseInt(s(this.element, 'top') || '0', 10)];
     },
 
     /** @id MochiKit.DragAndDrop.initDrag */
     initDrag: function (event) {
         if (!event.mouse().button.left) {
             return;
         }
         // abort on form elements, fixes a Firefox issue
         var src = event.target();
         var tagName = (src.tagName || '').toUpperCase();
         if (tagName === 'INPUT' || tagName === 'SELECT' ||
             tagName === 'OPTION' || tagName === 'BUTTON' ||
             tagName === 'TEXTAREA') {
             return;
         }
 
         if (this._revert) {
             this._revert.cancel();
             this._revert = null;
         }
 
         var pointer = event.mouse();
         var pos = MochiKit.Position.cumulativeOffset(this.element);
         this.offset = [pointer.page.x - pos.x, pointer.page.y - pos.y];
 
         MochiKit.DragAndDrop.Draggables.activate(this);
         event.stop();
     },
 
     /** @id MochiKit.DragAndDrop.startDrag */
     startDrag: function (event) {
         this.dragging = true;
         if (this.options.selectclass) {
             MochiKit.DOM.addElementClass(this.element,
                                          this.options.selectclass);
         }
         if (this.options.zindex) {
-            this.originalZ = parseInt(MochiKit.Style.getStyle(this.element,
-                                      'z-index') || '0');
+            this.originalZ = MochiKit.Style.getStyle(this.element, 'z-index');
             this.element.style.zIndex = this.options.zindex;
         }
 
         if (this.options.ghosting) {
             this._clone = this.element.cloneNode(true);
             this.ghostPosition = MochiKit.Position.absolutize(this.element);
             this.element.parentNode.insertBefore(this._clone, this.element);
         }
 
         if (this.options.scroll) {
             if (this.options.scroll == window) {
                 var where = this._getWindowScroll(this.options.scroll);
                 this.originalScrollLeft = where.left;
                 this.originalScrollTop = where.top;
             } else {
                 this.originalScrollLeft = this.options.scroll.scrollLeft;
                 this.originalScrollTop = this.options.scroll.scrollTop;
             }
         }
 
         MochiKit.DragAndDrop.Droppables.prepare(this.element);
         MochiKit.DragAndDrop.Draggables.notify('start', this, event);
         if (this.options.starteffect) {
             this.options.starteffect(this.element);
         }
     },
 
     /** @id MochiKit.DragAndDrop.updateDrag */
     updateDrag: function (event, pointer) {
         if (!this.dragging) {
             this.startDrag(event);
         }
         MochiKit.Position.prepare();
         MochiKit.DragAndDrop.Droppables.show(pointer, this.element);
         MochiKit.DragAndDrop.Draggables.notify('drag', this, event);
         this.draw(pointer);
         this.options.onchange(this);
 
         if (this.options.scroll) {
             this.stopScrolling();
             var p, q;
             if (this.options.scroll == window) {
                 var s = this._getWindowScroll(this.options.scroll);
                 p = new MochiKit.Style.Coordinates(s.left, s.top);
                 q = new MochiKit.Style.Coordinates(s.left + s.width,
                                                    s.top + s.height);
             } else {
                 p = MochiKit.Position.page(this.options.scroll);
                 p.x += this.options.scroll.scrollLeft;
                 p.y += this.options.scroll.scrollTop;
                 p.x += (window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0);
                 p.y += (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0);
                 q = new MochiKit.Style.Coordinates(p.x + this.options.scroll.offsetWidth,
                                                    p.y + this.options.scroll.offsetHeight);
             }
             var speed = [0, 0];
             if (pointer.page.x > (q.x - this.options.scrollSensitivity)) {
                 speed[0] = pointer.page.x - (q.x - this.options.scrollSensitivity);
             } else if (pointer.page.x < (p.x + this.options.scrollSensitivity)) {
                 speed[0] = pointer.page.x - (p.x + this.options.scrollSensitivity);
             }
             if (pointer.page.y > (q.y - this.options.scrollSensitivity)) {
                 speed[1] = pointer.page.y - (q.y - this.options.scrollSensitivity);
             } else if (pointer.page.y < (p.y + this.options.scrollSensitivity)) {
                 speed[1] = pointer.page.y - (p.y + this.options.scrollSensitivity);
             }
             this.startScrolling(speed);
         }
 
         // fix AppleWebKit rendering
         if (/AppleWebKit/.test(navigator.appVersion)) {
             window.scrollBy(0, 0);
         }
         event.stop();
     },
 
     /** @id MochiKit.DragAndDrop.finishDrag */
     finishDrag: function (event, success) {
         var dr = MochiKit.DragAndDrop;
         this.dragging = false;
         if (this.options.selectclass) {
             MochiKit.DOM.removeElementClass(this.element,
                                             this.options.selectclass);
         }
 
         if (this.options.ghosting) {
             // XXX: from a user point of view, it would be better to remove
             // the node only *after* the MochiKit.Visual.Move end when used
             // with revert.
             MochiKit.Position.relativize(this.element, this.ghostPosition);
             MochiKit.DOM.removeElement(this._clone);
             this._clone = null;
         }
 
         if (success) {
             dr.Droppables.fire(event, this.element);
         }
         dr.Draggables.notify('end', this, event);
 
         var revert = this.options.revert;
         if (revert && typeof(revert) == 'function') {
             revert = revert(this.element);
         }
 
         var d = this.currentDelta();
         if (revert && this.options.reverteffect) {
             this._revert = this.options.reverteffect(this.element,
                 d[1] - this.delta[1], d[0] - this.delta[0]);
         } else {
             this.delta = d;
         }
 
         if (this.options.zindex) {
             this.element.style.zIndex = this.originalZ;
         }
 
         if (this.options.endeffect) {
             this.options.endeffect(this.element);
         }
 
         dr.Draggables.deactivate();
         dr.Droppables.reset(this.element);
     },
 
     /** @id MochiKit.DragAndDrop.keyPress */
     keyPress: function (event) {
         if (event.key().string != "KEY_ESCAPE") {
             return;
         }
         this.finishDrag(event, false);
         event.stop();
     },
 
     /** @id MochiKit.DragAndDrop.endDrag */
     endDrag: function (event) {
         if (!this.dragging) {
             return;
         }
         this.stopScrolling();
         this.finishDrag(event, true);
         event.stop();
     },
 
     /** @id MochiKit.DragAndDrop.draw */
     draw: function (point) {
         var pos = MochiKit.Position.cumulativeOffset(this.element);
         var d = this.currentDelta();
         pos.x -= d[0];
         pos.y -= d[1];
 
         if (this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
             pos.x -= this.options.scroll.scrollLeft - this.originalScrollLeft;
             pos.y -= this.options.scroll.scrollTop - this.originalScrollTop;
         }
 
         var p = [point.page.x - pos.x - this.offset[0],
                  point.page.y - pos.y - this.offset[1]];
 
         if (this.options.snap) {
             if (typeof(this.options.snap) == 'function') {
                 p = this.options.snap(p[0], p[1]);
             } else {
                 if (this.options.snap instanceof Array) {
                     var i = -1;
                     p = MochiKit.Base.map(MochiKit.Base.bind(function (v) {
                             i += 1;
                             return Math.round(v/this.options.snap[i]) *
                                    this.options.snap[i];
                         }, this), p);
                 } else {
                     p = MochiKit.Base.map(MochiKit.Base.bind(function (v) {
                         return Math.round(v/this.options.snap) *
                                this.options.snap;
                         }, this), p);
                 }
             }
         }
         var style = this.element.style;
         if ((!this.options.constraint) ||
             (this.options.constraint == 'horizontal')) {
             style.left = p[0] + 'px';
         }
         if ((!this.options.constraint) ||
             (this.options.constraint == 'vertical')) {
             style.top = p[1] + 'px';
         }
         if (style.visibility == 'hidden') {
             style.visibility = '';  // fix gecko rendering
         }
     },
 
     /** @id MochiKit.DragAndDrop.stopScrolling */
     stopScrolling: function () {
         if (this.scrollInterval) {
             clearInterval(this.scrollInterval);
             this.scrollInterval = null;
             MochiKit.DragAndDrop.Draggables._lastScrollPointer = null;
         }
     },
 
     /** @id MochiKit.DragAndDrop.startScrolling */
     startScrolling: function (speed) {
         if (!speed[0] && !speed[1]) {
             return;
         }
         this.scrollSpeed = [speed[0] * this.options.scrollSpeed,
                             speed[1] * this.options.scrollSpeed];
         this.lastScrolled = new Date();
         this.scrollInterval = setInterval(MochiKit.Base.bind(this.scroll, this), 10);
     },
 
     /** @id MochiKit.DragAndDrop.scroll */
     scroll: function () {
         var current = new Date();
         var delta = current - this.lastScrolled;
         this.lastScrolled = current;
 
         if (this.options.scroll == window) {
             var s = this._getWindowScroll(this.options.scroll);
             if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
                 var dm = delta / 1000;
                 this.options.scroll.scrollTo(s.left + dm * this.scrollSpeed[0],
                                              s.top + dm * this.scrollSpeed[1]);
             }
         } else {
             this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
             this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
         }
 
         var d = MochiKit.DragAndDrop;
 
         MochiKit.Position.prepare();
         d.Droppables.show(d.Draggables._lastPointer, this.element);
         d.Draggables.notify('drag', this);
         if (this._isScrollChild) {
             d.Draggables._lastScrollPointer = d.Draggables._lastScrollPointer || d.Draggables._lastPointer;
             d.Draggables._lastScrollPointer.x += this.scrollSpeed[0] * delta / 1000;
             d.Draggables._lastScrollPointer.y += this.scrollSpeed[1] * delta / 1000;
             if (d.Draggables._lastScrollPointer.x < 0) {
                 d.Draggables._lastScrollPointer.x = 0;
             }
             if (d.Draggables._lastScrollPointer.y < 0) {
                 d.Draggables._lastScrollPointer.y = 0;
             }
             this.draw(d.Draggables._lastScrollPointer);
         }
 
         this.options.onchange(this);
     },
 
     _getWindowScroll: function (win) {
         var vp, w, h;
         MochiKit.DOM.withWindow(win, function () {
             vp = MochiKit.Style.getViewportPosition(win.document);
         });
         if (win.innerWidth) {
             w = win.innerWidth;
             h = win.innerHeight;
         } else if (win.document.documentElement && win.document.documentElement.clientWidth) {
             w = win.document.documentElement.clientWidth;
             h = win.document.documentElement.clientHeight;
         } else {
             w = win.document.body.offsetWidth;
             h = win.document.body.offsetHeight;
         }
         return {top: vp.y, left: vp.x, width: w, height: h};
     },
 
     /** @id MochiKit.DragAndDrop.repr */
     repr: function () {
         return '[' + this.__class__.NAME + ", options:" + MochiKit.Base.repr(this.options) + "]";
     }
 };
 
 MochiKit.DragAndDrop.__new__ = function () {
     MochiKit.Base.nameFunctions(this);
 };
 
 MochiKit.DragAndDrop.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.DragAndDrop);
diff --git a/frontend/gamma/js/MochiKit/Format.js b/frontend/gamma/js/MochiKit/Format.js
index 122845e..58877e7 100644
--- a/frontend/gamma/js/MochiKit/Format.js
+++ b/frontend/gamma/js/MochiKit/Format.js
@@ -1,309 +1,309 @@
 /***
 
 MochiKit.Format 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Format', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'Format', '1.5', ['Base']);
 
 MochiKit.Format._numberFormatter = function (placeholder, header, footer, locale, isPercent, precision, leadingZeros, separatorAt, trailingZeros) {
     return function (num) {
         num = parseFloat(num);
         if (typeof(num) == "undefined" || num === null || isNaN(num)) {
             return placeholder;
         }
         var curheader = header;
         var curfooter = footer;
         if (num < 0) {
             num = -num;
         } else {
             curheader = curheader.replace(/-/, "");
         }
         var me = arguments.callee;
         var fmt = MochiKit.Format.formatLocale(locale);
         if (isPercent) {
             num = num * 100.0;
             curfooter = fmt.percent + curfooter;
         }
         num = MochiKit.Format.roundToFixed(num, precision);
         var parts = num.split(/\./);
         var whole = parts[0];
         var frac = (parts.length == 1) ? "" : parts[1];
         var res = "";
         while (whole.length < leadingZeros) {
             whole = "0" + whole;
         }
         if (separatorAt) {
             while (whole.length > separatorAt) {
                 var i = whole.length - separatorAt;
                 //res = res + fmt.separator + whole.substring(i, whole.length);
                 res = fmt.separator + whole.substring(i, whole.length) + res;
                 whole = whole.substring(0, i);
             }
         }
         res = whole + res;
         if (precision > 0) {
             while (frac.length < trailingZeros) {
                 frac = frac + "0";
             }
             res = res + fmt.decimal + frac;
         }
         return curheader + res + curfooter;
     };
 };
 
 /** @id MochiKit.Format.numberFormatter */
 MochiKit.Format.numberFormatter = function (pattern, placeholder/* = "" */, locale/* = "default" */) {
     // http://java.sun.com/docs/books/tutorial/i18n/format/numberpattern.html
     // | 0 | leading or trailing zeros
     // | # | just the number
     // | , | separator
     // | . | decimal separator
     // | % | Multiply by 100 and format as percent
     if (typeof(placeholder) == "undefined") {
         placeholder = "";
     }
     var match = pattern.match(/((?:[0#]+,)?[0#]+)(?:\.([0#]+))?(%)?/);
     if (!match) {
         throw TypeError("Invalid pattern");
     }
     var header = pattern.substr(0, match.index);
     var footer = pattern.substr(match.index + match[0].length);
     if (header.search(/-/) == -1) {
         header = header + "-";
     }
     var whole = match[1];
     var frac = (typeof(match[2]) == "string" && match[2] != "") ? match[2] : "";
     var isPercent = (typeof(match[3]) == "string" && match[3] != "");
     var tmp = whole.split(/,/);
     var separatorAt;
     if (typeof(locale) == "undefined") {
         locale = "default";
     }
     if (tmp.length == 1) {
         separatorAt = null;
     } else {
         separatorAt = tmp[1].length;
     }
     var leadingZeros = whole.length - whole.replace(/0/g, "").length;
     var trailingZeros = frac.length - frac.replace(/0/g, "").length;
     var precision = frac.length;
     var rval = MochiKit.Format._numberFormatter(
         placeholder, header, footer, locale, isPercent, precision,
         leadingZeros, separatorAt, trailingZeros
     );
     var m = MochiKit.Base;
     if (m) {
         var fn = arguments.callee;
         var args = m.concat(arguments);
         rval.repr = function () {
             return [
                 self.NAME,
                 "(",
-                map(m.repr, args).join(", "),
+                m.map(m.repr, args).join(", "),
                 ")"
             ].join("");
         };
     }
     return rval;
 };
 
 /** @id MochiKit.Format.formatLocale */
 MochiKit.Format.formatLocale = function (locale) {
     if (typeof(locale) == "undefined" || locale === null) {
         locale = "default";
     }
     if (typeof(locale) == "string") {
         var rval = MochiKit.Format.LOCALE[locale];
         if (typeof(rval) == "string") {
             rval = arguments.callee(rval);
             MochiKit.Format.LOCALE[locale] = rval;
         }
         return rval;
     } else {
         return locale;
     }
 };
 
 /** @id MochiKit.Format.twoDigitAverage */
 MochiKit.Format.twoDigitAverage = function (numerator, denominator) {
     if (denominator) {
         var res = numerator / denominator;
         if (!isNaN(res)) {
             return MochiKit.Format.twoDigitFloat(res);
         }
     }
     return "0";
 };
 
 /** @id MochiKit.Format.twoDigitFloat */
 MochiKit.Format.twoDigitFloat = function (aNumber) {
-    var res = roundToFixed(aNumber, 2);
+    var res = MochiKit.Format.roundToFixed(aNumber, 2);
     if (res.indexOf(".00") > 0) {
         return res.substring(0, res.length - 3);
     } else if (res.charAt(res.length - 1) == "0") {
         return res.substring(0, res.length - 1);
     } else {
         return res;
     }
 };
 
 /** @id MochiKit.Format.lstrip */
 MochiKit.Format.lstrip = function (str, /* optional */chars) {
     str = str + "";
     if (typeof(str) != "string") {
         return null;
     }
     if (!chars) {
         return str.replace(/^\s+/, "");
     } else {
         return str.replace(new RegExp("^[" + chars + "]+"), "");
     }
 };
 
 /** @id MochiKit.Format.rstrip */
 MochiKit.Format.rstrip = function (str, /* optional */chars) {
     str = str + "";
     if (typeof(str) != "string") {
         return null;
     }
     if (!chars) {
         return str.replace(/\s+$/, "");
     } else {
         return str.replace(new RegExp("[" + chars + "]+$"), "");
     }
 };
 
 /** @id MochiKit.Format.strip */
 MochiKit.Format.strip = function (str, /* optional */chars) {
     var self = MochiKit.Format;
     return self.rstrip(self.lstrip(str, chars), chars);
 };
 
 /** @id MochiKit.Format.truncToFixed */
 MochiKit.Format.truncToFixed = function (aNumber, precision) {
     var fixed = MochiKit.Format._numberToFixed(aNumber, precision);
     var fracPos = fixed.indexOf(".");
     if (fracPos > 0 && fracPos + precision + 1 < fixed.length) {
         fixed = fixed.substring(0, fracPos + precision + 1);
         fixed = MochiKit.Format._shiftNumber(fixed, 0);
     }
     return fixed;
-}
+};
 
 /** @id MochiKit.Format.roundToFixed */
 MochiKit.Format.roundToFixed = function (aNumber, precision) {
     var fixed = MochiKit.Format._numberToFixed(aNumber, precision);
     var fracPos = fixed.indexOf(".");
     if (fracPos > 0 && fracPos + precision + 1 < fixed.length) {
         var str = MochiKit.Format._shiftNumber(fixed, precision);
         str = MochiKit.Format._numberToFixed(Math.round(parseFloat(str)), 0);
         fixed = MochiKit.Format._shiftNumber(str, -precision);
     }
     return fixed;
-}
+};
 
 /**
  * Converts a number to a fixed format string. This function handles
  * conversion of exponents by shifting the decimal point to the left
  * or the right. It also guarantees a specified minimum number of
  * fractional digits (but no maximum).
  *
  * @param {Number} aNumber the number to convert
  * @param {Number} precision the minimum number of decimal digits
  *
  * @return {String} the fixed format number string
  */
 MochiKit.Format._numberToFixed = function (aNumber, precision) {
     var str = aNumber.toString();
     var parts = str.split(/[eE]/);
-    var exp = (parts.length === 1) ? 0 : parseInt(parts[1]) || 0;
+    var exp = (parts.length === 1) ? 0 : parseInt(parts[1], 10) || 0;
     var fixed = MochiKit.Format._shiftNumber(parts[0], exp);
     parts = fixed.split(/\./);
     var whole = parts[0];
     var frac = (parts.length === 1) ? "" : parts[1];
     while (frac.length < precision) {
         frac += "0";
     }
     if (frac.length > 0) {
         return whole + "." + frac;
     } else {
         return whole;
     }
-}
+};
 
 /**
  * Shifts the decimal dot location in a fixed format number string.
  * This function handles negative values and will add and remove
  * leading and trailing zeros as needed.
  *
  * @param {String} num the fixed format number string
  * @param {Number} exp the base-10 exponent to apply
  *
  * @return {String} the new fixed format number string
  */
 MochiKit.Format._shiftNumber = function (num, exp) {
     var pos = num.indexOf(".");
     if (pos < 0) {
         pos = num.length;
     } else {
         num = num.substring(0, pos) + num.substring(pos + 1);
     }
     pos += exp;
     while (pos <= 0 || (pos <= 1 && num.charAt(0) === "-")) {
         if (num.charAt(0) === "-") {
             num = "-0" + num.substring(1);
         } else {
             num = "0" + num;
         }
         pos++;
     }
     while (pos > num.length) {
         num += "0";
     }
     if (pos < num.length) {
         num = num.substring(0, pos) + "." + num.substring(pos);
     }
     while (/^0[^.]/.test(num)) {
         num = num.substring(1);
     }
     while (/^-0[^.]/.test(num)) {
         num = "-" + num.substring(2);
     }
     return num;
-}
+};
 
 /** @id MochiKit.Format.percentFormat */
 MochiKit.Format.percentFormat = function (aNumber) {
     return MochiKit.Format.twoDigitFloat(100 * aNumber) + '%';
 };
 
 MochiKit.Format.LOCALE = {
     en_US: {separator: ",", decimal: ".", percent: "%"},
     de_DE: {separator: ".", decimal: ",", percent: "%"},
     pt_BR: {separator: ".", decimal: ",", percent: "%"},
     fr_FR: {separator: " ", decimal: ",", percent: "%"},
     "default": "en_US",
     __export__: false
 };
 
 MochiKit.Format.__new__ = function () {
     MochiKit.Base.nameFunctions(this);
     var base = this.NAME + ".";
     var k, v, o;
     for (k in this.LOCALE) {
         o = this.LOCALE[k];
         if (typeof(o) == "object") {
             o.repr = function () { return this.NAME; };
             o.NAME = base + "LOCALE." + k;
         }
     }
 };
 
 MochiKit.Format.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.Format);
diff --git a/frontend/gamma/js/MochiKit/Iter.js b/frontend/gamma/js/MochiKit/Iter.js
index 524b2bc..77623bc 100644
--- a/frontend/gamma/js/MochiKit/Iter.js
+++ b/frontend/gamma/js/MochiKit/Iter.js
@@ -1,790 +1,788 @@
 /***
 
 MochiKit.Iter 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Iter', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'Iter', '1.5', ['Base']);
 
 MochiKit.Base.update(MochiKit.Iter, {
     /** @id MochiKit.Iter.registerIteratorFactory */
     registerIteratorFactory: function (name, check, iterfactory, /* optional */ override) {
         MochiKit.Iter.iteratorRegistry.register(name, check, iterfactory, override);
     },
 
     /** @id MochiKit.Iter.isIterable */
     isIterable: function(o) {
         return o != null &&
                (typeof(o.next) == "function" || typeof(o.iter) == "function");
     },
 
     /** @id MochiKit.Iter.iter */
     iter: function (iterable, /* optional */ sentinel) {
         var self = MochiKit.Iter;
         if (arguments.length == 2) {
             return self.takewhile(
                 function (a) { return a != sentinel; },
                 iterable
             );
         }
         if (typeof(iterable.next) == 'function') {
             return iterable;
         } else if (typeof(iterable.iter) == 'function') {
             return iterable.iter();
         /*
         }  else if (typeof(iterable.__iterator__) == 'function') {
             //
             // XXX: We can't support JavaScript 1.7 __iterator__ directly
             //      because of Object.prototype.__iterator__
             //
             return iterable.__iterator__();
         */
         }
 
         try {
             return self.iteratorRegistry.match(iterable);
         } catch (e) {
             var m = MochiKit.Base;
             if (e == m.NotFound) {
                 e = new TypeError(typeof(iterable) + ": " + m.repr(iterable) + " is not iterable");
             }
             throw e;
         }
     },
 
     /** @id MochiKit.Iter.count */
     count: function (n) {
         if (!n) {
             n = 0;
         }
         var m = MochiKit.Base;
         return {
             repr: function () { return "count(" + n + ")"; },
             toString: m.forwardCall("repr"),
             next: m.counter(n)
         };
     },
 
     /** @id MochiKit.Iter.cycle */
     cycle: function (p) {
         var self = MochiKit.Iter;
         var m = MochiKit.Base;
         var lst = [];
         var iterator = self.iter(p);
         return {
             repr: function () { return "cycle(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 try {
                     var rval = iterator.next();
                     lst.push(rval);
                     return rval;
                 } catch (e) {
                     if (e != self.StopIteration) {
                         throw e;
                     }
                     if (lst.length === 0) {
                         this.next = function () {
                             throw self.StopIteration;
                         };
                     } else {
                         var i = -1;
                         this.next = function () {
                             i = (i + 1) % lst.length;
                             return lst[i];
                         };
                     }
                     return this.next();
                 }
             }
         };
     },
 
     /** @id MochiKit.Iter.repeat */
     repeat: function (elem, /* optional */n) {
         var m = MochiKit.Base;
         if (typeof(n) == 'undefined') {
             return {
                 repr: function () {
                     return "repeat(" + m.repr(elem) + ")";
                 },
                 toString: m.forwardCall("repr"),
                 next: function () {
                     return elem;
                 }
             };
         }
         return {
             repr: function () {
                 return "repeat(" + m.repr(elem) + ", " + n + ")";
             },
             toString: m.forwardCall("repr"),
             next: function () {
                 if (n <= 0) {
                     throw MochiKit.Iter.StopIteration;
                 }
                 n -= 1;
                 return elem;
             }
         };
     },
 
     /** @id MochiKit.Iter.next */
     next: function (iterator) {
         return iterator.next();
     },
 
     /** @id MochiKit.Iter.izip */
     izip: function (p, q/*, ...*/) {
         var m = MochiKit.Base;
         var self = MochiKit.Iter;
         var next = self.next;
         var iterables = m.map(self.iter, arguments);
         return {
             repr: function () { return "izip(...)"; },
             toString: m.forwardCall("repr"),
             next: function () { return m.map(next, iterables); }
         };
     },
 
     /** @id MochiKit.Iter.ifilter */
     ifilter: function (pred, seq) {
         var m = MochiKit.Base;
         seq = MochiKit.Iter.iter(seq);
         if (pred === null) {
             pred = m.operator.truth;
         }
         return {
             repr: function () { return "ifilter(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 while (true) {
                     var rval = seq.next();
                     if (pred(rval)) {
                         return rval;
                     }
                 }
                 // mozilla warnings aren't too bright
                 return undefined;
             }
         };
     },
 
     /** @id MochiKit.Iter.ifilterfalse */
     ifilterfalse: function (pred, seq) {
         var m = MochiKit.Base;
         seq = MochiKit.Iter.iter(seq);
         if (pred === null) {
             pred = m.operator.truth;
         }
         return {
             repr: function () { return "ifilterfalse(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 while (true) {
                     var rval = seq.next();
                     if (!pred(rval)) {
                         return rval;
                     }
                 }
                 // mozilla warnings aren't too bright
                 return undefined;
             }
         };
     },
 
     /** @id MochiKit.Iter.islice */
     islice: function (seq/*, [start,] stop[, step] */) {
         var self = MochiKit.Iter;
         var m = MochiKit.Base;
         seq = self.iter(seq);
         var start = 0;
         var stop = 0;
         var step = 1;
         var i = -1;
         if (arguments.length == 2) {
             stop = arguments[1];
         } else if (arguments.length == 3) {
             start = arguments[1];
             stop = arguments[2];
         } else {
             start = arguments[1];
             stop = arguments[2];
             step = arguments[3];
         }
         return {
             repr: function () {
                 return "islice(" + ["...", start, stop, step].join(", ") + ")";
             },
             toString: m.forwardCall("repr"),
             next: function () {
+                if (start >= stop) {
+                    throw self.StopIteration;
+                }
+
                 var rval;
                 while (i < start) {
                     rval = seq.next();
                     i++;
                 }
-                if (start >= stop) {
-                    throw self.StopIteration;
-                }
                 start += step;
                 return rval;
             }
         };
     },
 
     /** @id MochiKit.Iter.imap */
     imap: function (fun, p, q/*, ...*/) {
         var m = MochiKit.Base;
         var self = MochiKit.Iter;
         var iterables = m.map(self.iter, m.extend(null, arguments, 1));
         var map = m.map;
         var next = self.next;
         return {
             repr: function () { return "imap(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 return fun.apply(this, map(next, iterables));
             }
         };
     },
 
     /** @id MochiKit.Iter.applymap */
     applymap: function (fun, seq, self) {
         seq = MochiKit.Iter.iter(seq);
         var m = MochiKit.Base;
         return {
             repr: function () { return "applymap(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 return fun.apply(self, seq.next());
             }
         };
     },
 
     /** @id MochiKit.Iter.chain */
     chain: function (p, q/*, ...*/) {
         // dumb fast path
         var self = MochiKit.Iter;
         var m = MochiKit.Base;
         if (arguments.length == 1) {
             return self.iter(arguments[0]);
         }
         var argiter = m.map(self.iter, arguments);
         return {
             repr: function () { return "chain(...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 while (argiter.length > 1) {
                     try {
-                        var result = argiter[0].next();
-                        return result;
+                        return argiter[0].next();
                     } catch (e) {
                         if (e != self.StopIteration) {
                             throw e;
                         }
                         argiter.shift();
-                        var result = argiter[0].next();
-                        return result;
                     }
                 }
                 if (argiter.length == 1) {
                     // optimize last element
                     var arg = argiter.shift();
                     this.next = m.bind("next", arg);
                     return this.next();
                 }
                 throw self.StopIteration;
             }
         };
     },
 
     /** @id MochiKit.Iter.takewhile */
     takewhile: function (pred, seq) {
         var self = MochiKit.Iter;
         seq = self.iter(seq);
         return {
             repr: function () { return "takewhile(...)"; },
             toString: MochiKit.Base.forwardCall("repr"),
             next: function () {
                 var rval = seq.next();
                 if (!pred(rval)) {
                     this.next = function () {
                         throw self.StopIteration;
                     };
                     this.next();
                 }
                 return rval;
             }
         };
     },
 
     /** @id MochiKit.Iter.dropwhile */
     dropwhile: function (pred, seq) {
         seq = MochiKit.Iter.iter(seq);
         var m = MochiKit.Base;
         var bind = m.bind;
         return {
             "repr": function () { return "dropwhile(...)"; },
             "toString": m.forwardCall("repr"),
             "next": function () {
                 while (true) {
                     var rval = seq.next();
                     if (!pred(rval)) {
                         break;
                     }
                 }
                 this.next = bind("next", seq);
                 return rval;
             }
         };
     },
 
     _tee: function (ident, sync, iterable) {
         sync.pos[ident] = -1;
         var m = MochiKit.Base;
         var listMin = m.listMin;
         return {
             repr: function () { return "tee(" + ident + ", ...)"; },
             toString: m.forwardCall("repr"),
             next: function () {
                 var rval;
                 var i = sync.pos[ident];
 
                 if (i == sync.max) {
                     rval = iterable.next();
                     sync.deque.push(rval);
                     sync.max += 1;
                     sync.pos[ident] += 1;
                 } else {
                     rval = sync.deque[i - sync.min];
                     sync.pos[ident] += 1;
                     if (i == sync.min && listMin(sync.pos) != sync.min) {
                         sync.min += 1;
                         sync.deque.shift();
                     }
                 }
                 return rval;
             }
         };
     },
 
     /** @id MochiKit.Iter.tee */
     tee: function (iterable, n/* = 2 */) {
         var rval = [];
         var sync = {
             "pos": [],
             "deque": [],
             "max": -1,
             "min": -1
         };
         if (arguments.length == 1 || typeof(n) == "undefined" || n === null) {
             n = 2;
         }
         var self = MochiKit.Iter;
         iterable = self.iter(iterable);
         var _tee = self._tee;
         for (var i = 0; i < n; i++) {
             rval.push(_tee(i, sync, iterable));
         }
         return rval;
     },
 
     /** @id MochiKit.Iter.list */
     list: function (iterable) {
         // Fast-path for Array and Array-like
         var rval;
         if (iterable instanceof Array) {
             return iterable.slice();
         } 
         // this is necessary to avoid a Safari crash
         if (typeof(iterable) == "function" &&
                 !(iterable instanceof Function) &&
                 typeof(iterable.length) == 'number') {
             rval = [];
             for (var i = 0; i < iterable.length; i++) {
                 rval.push(iterable[i]);
             }
             return rval;
         }
 
         var self = MochiKit.Iter;
         iterable = self.iter(iterable);
-        var rval = [];
+        rval = [];
         var a_val;
         try {
             while (true) {
                 a_val = iterable.next();
                 rval.push(a_val);
             }
         } catch (e) {
             if (e != self.StopIteration) {
                 throw e;
             }
             return rval;
         }
         // mozilla warnings aren't too bright
         return undefined;
     },
 
 
     /** @id MochiKit.Iter.reduce */
     reduce: function (fn, iterable, /* optional */initial) {
         var i = 0;
         var x = initial;
         var self = MochiKit.Iter;
         iterable = self.iter(iterable);
         if (arguments.length < 3) {
             try {
                 x = iterable.next();
             } catch (e) {
                 if (e == self.StopIteration) {
                     e = new TypeError("reduce() of empty sequence with no initial value");
                 }
                 throw e;
             }
             i++;
         }
         try {
             while (true) {
                 x = fn(x, iterable.next());
             }
         } catch (e) {
             if (e != self.StopIteration) {
                 throw e;
             }
         }
         return x;
     },
 
     /** @id MochiKit.Iter.range */
     range: function (/* [start,] stop[, step] */) {
         var start = 0;
         var stop = 0;
         var step = 1;
         if (arguments.length == 1) {
             stop = arguments[0];
         } else if (arguments.length == 2) {
             start = arguments[0];
             stop = arguments[1];
         } else if (arguments.length == 3) {
             start = arguments[0];
             stop = arguments[1];
             step = arguments[2];
         } else {
             throw new TypeError("range() takes 1, 2, or 3 arguments!");
         }
         if (step === 0) {
             throw new TypeError("range() step must not be 0");
         }
         return {
             next: function () {
                 if ((step > 0 && start >= stop) || (step < 0 && start <= stop)) {
                     throw MochiKit.Iter.StopIteration;
                 }
                 var rval = start;
                 start += step;
                 return rval;
             },
             repr: function () {
                 return "range(" + [start, stop, step].join(", ") + ")";
             },
             toString: MochiKit.Base.forwardCall("repr")
         };
     },
 
     /** @id MochiKit.Iter.sum */
     sum: function (iterable, start/* = 0 */) {
         if (typeof(start) == "undefined" || start === null) {
             start = 0;
         }
         var x = start;
         var self = MochiKit.Iter;
         iterable = self.iter(iterable);
         try {
             while (true) {
                 x += iterable.next();
             }
         } catch (e) {
             if (e != self.StopIteration) {
                 throw e;
             }
         }
         return x;
     },
 
     /** @id MochiKit.Iter.exhaust */
     exhaust: function (iterable) {
         var self = MochiKit.Iter;
         iterable = self.iter(iterable);
         try {
             while (true) {
                 iterable.next();
             }
         } catch (e) {
             if (e != self.StopIteration) {
                 throw e;
             }
         }
     },
 
     /** @id MochiKit.Iter.forEach */
     forEach: function (iterable, func, /* optional */obj) {
         var m = MochiKit.Base;
         var self = MochiKit.Iter;
         if (arguments.length > 2) {
             func = m.bind(func, obj);
         }
         // fast path for array
         if (m.isArrayLike(iterable) && !self.isIterable(iterable)) {
             try {
                 for (var i = 0; i < iterable.length; i++) {
                     func(iterable[i]);
                 }
             } catch (e) {
                 if (e != self.StopIteration) {
                     throw e;
                 }
             }
         } else {
             self.exhaust(self.imap(func, iterable));
         }
     },
 
     /** @id MochiKit.Iter.every */
     every: function (iterable, func) {
         var self = MochiKit.Iter;
         try {
             self.ifilterfalse(func, iterable).next();
             return false;
         } catch (e) {
             if (e != self.StopIteration) {
                 throw e;
             }
             return true;
         }
     },
 
     /** @id MochiKit.Iter.sorted */
     sorted: function (iterable, /* optional */cmp) {
         var rval = MochiKit.Iter.list(iterable);
         if (arguments.length == 1) {
             cmp = MochiKit.Base.compare;
         }
         rval.sort(cmp);
         return rval;
     },
 
     /** @id MochiKit.Iter.reversed */
     reversed: function (iterable) {
         var rval = MochiKit.Iter.list(iterable);
         rval.reverse();
         return rval;
     },
 
     /** @id MochiKit.Iter.some */
     some: function (iterable, func) {
         var self = MochiKit.Iter;
         try {
             self.ifilter(func, iterable).next();
             return true;
         } catch (e) {
             if (e != self.StopIteration) {
                 throw e;
             }
             return false;
         }
     },
 
     /** @id MochiKit.Iter.iextend */
     iextend: function (lst, iterable) {
         var m = MochiKit.Base;
         var self = MochiKit.Iter;
         if (m.isArrayLike(iterable) && !self.isIterable(iterable)) {
             // fast-path for array-like
             for (var i = 0; i < iterable.length; i++) {
                 lst.push(iterable[i]);
             }
         } else {
             iterable = self.iter(iterable);
             try {
                 while (true) {
                     lst.push(iterable.next());
                 }
             } catch (e) {
                 if (e != self.StopIteration) {
                     throw e;
                 }
             }
         }
         return lst;
     },
 
     /** @id MochiKit.Iter.groupby */
     groupby: function(iterable, /* optional */ keyfunc) {
         var m = MochiKit.Base;
         var self = MochiKit.Iter;
         if (arguments.length < 2) {
             keyfunc = m.operator.identity;
         }
         iterable = self.iter(iterable);
 
         // shared
         var pk = undefined;
         var k = undefined;
         var v;
 
         function fetch() {
             v = iterable.next();
             k = keyfunc(v);
         };
 
         function eat() {
             var ret = v;
             v = undefined;
             return ret;
         };
 
         var first = true;
         var compare = m.compare;
         return {
             repr: function () { return "groupby(...)"; },
             next: function() {
                 // iterator-next
 
                 // iterate until meet next group
                 while (compare(k, pk) === 0) {
                     fetch();
                     if (first) {
                         first = false;
                         break;
                     }
                 }
                 pk = k;
                 return [k, {
                     next: function() {
                         // subiterator-next
                         if (v == undefined) { // Is there something to eat?
                             fetch();
                         }
                         if (compare(k, pk) !== 0) {
                             throw self.StopIteration;
                         }
                         return eat();
                     }
                 }];
             }
         };
     },
 
     /** @id MochiKit.Iter.groupby_as_array */
     groupby_as_array: function (iterable, /* optional */ keyfunc) {
         var m = MochiKit.Base;
         var self = MochiKit.Iter;
         if (arguments.length < 2) {
             keyfunc = m.operator.identity;
         }
 
         iterable = self.iter(iterable);
         var result = [];
         var first = true;
         var prev_key;
         var compare = m.compare;
         while (true) {
             try {
                 var value = iterable.next();
                 var key = keyfunc(value);
             } catch (e) {
                 if (e == self.StopIteration) {
                     break;
                 }
                 throw e;
             }
             if (first || compare(key, prev_key) !== 0) {
                 var values = [];
                 result.push([key, values]);
             }
             values.push(value);
             first = false;
             prev_key = key;
         }
         return result;
     },
 
     /** @id MochiKit.Iter.arrayLikeIter */
     arrayLikeIter: function (iterable) {
         var i = 0;
         return {
             repr: function () { return "arrayLikeIter(...)"; },
             toString: MochiKit.Base.forwardCall("repr"),
             next: function () {
                 if (i >= iterable.length) {
                     throw MochiKit.Iter.StopIteration;
                 }
                 return iterable[i++];
             }
         };
     },
 
     /** @id MochiKit.Iter.hasIterateNext */
     hasIterateNext: function (iterable) {
         return (iterable && typeof(iterable.iterateNext) == "function");
     },
 
     /** @id MochiKit.Iter.iterateNextIter */
     iterateNextIter: function (iterable) {
         return {
             repr: function () { return "iterateNextIter(...)"; },
             toString: MochiKit.Base.forwardCall("repr"),
             next: function () {
                 var rval = iterable.iterateNext();
                 if (rval === null || rval === undefined) {
                     throw MochiKit.Iter.StopIteration;
                 }
                 return rval;
             }
         };
     }
 });
 
 
 MochiKit.Iter.__new__ = function () {
     var m = MochiKit.Base;
     // Re-use StopIteration if exists (e.g. SpiderMonkey)
     if (typeof(StopIteration) != "undefined") {
         this.StopIteration = StopIteration;
     } else {
         /** @id MochiKit.Iter.StopIteration */
         this.StopIteration = new m.NamedError("StopIteration");
     }
     this.iteratorRegistry = new m.AdapterRegistry();
     // Register the iterator factory for arrays
     this.registerIteratorFactory(
         "arrayLike",
         m.isArrayLike,
         this.arrayLikeIter
     );
 
     this.registerIteratorFactory(
         "iterateNext",
         this.hasIterateNext,
         this.iterateNextIter
     );
 
     m.nameFunctions(this);
 
 };
 
 MochiKit.Iter.__new__();
 
 //
 // XXX: Internet Explorer blows
 //
 if (MochiKit.__export__) {
     reduce = MochiKit.Iter.reduce;
 }
 
 MochiKit.Base._exportSymbols(this, MochiKit.Iter);
diff --git a/frontend/gamma/js/MochiKit/Logging.js b/frontend/gamma/js/MochiKit/Logging.js
index f00996b..8b06e0b 100644
--- a/frontend/gamma/js/MochiKit/Logging.js
+++ b/frontend/gamma/js/MochiKit/Logging.js
@@ -1,262 +1,262 @@
 /***
 
 MochiKit.Logging 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Logging', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'Logging', '1.5', ['Base']);
 
     /** @id MochiKit.Logging.LogMessage */
 MochiKit.Logging.LogMessage = function (num, level, info) {
     this.num = num;
     this.level = level;
     this.info = info;
     this.timestamp = new Date();
 };
 
 MochiKit.Logging.LogMessage.prototype = {
      /** @id MochiKit.Logging.LogMessage.prototype.repr */
     repr: function () {
         var m = MochiKit.Base;
         return 'LogMessage(' +
             m.map(
                 m.repr,
                 [this.num, this.level, this.info]
             ).join(', ') + ')';
     },
     /** @id MochiKit.Logging.LogMessage.prototype.toString */
     toString: MochiKit.Base.forwardCall("repr")
 };
 
 MochiKit.Base.update(MochiKit.Logging, {
     /** @id MochiKit.Logging.logLevelAtLeast */
     logLevelAtLeast: function (minLevel) {
         var self = MochiKit.Logging;
         if (typeof(minLevel) == 'string') {
             minLevel = self.LogLevel[minLevel];
         }
         return function (msg) {
             var msgLevel = msg.level;
             if (typeof(msgLevel) == 'string') {
                 msgLevel = self.LogLevel[msgLevel];
             }
             return msgLevel >= minLevel;
         };
     },
 
     /** @id MochiKit.Logging.isLogMessage */
     isLogMessage: function (/* ... */) {
         var LogMessage = MochiKit.Logging.LogMessage;
         for (var i = 0; i < arguments.length; i++) {
             if (!(arguments[i] instanceof LogMessage)) {
                 return false;
             }
         }
         return true;
     },
 
     /** @id MochiKit.Logging.compareLogMessage */
     compareLogMessage: function (a, b) {
         return MochiKit.Base.compare([a.level, a.info], [b.level, b.info]);
     },
 
     /** @id MochiKit.Logging.alertListener */
     alertListener: function (msg) {
         alert(
             "num: " + msg.num +
             "\nlevel: " +  msg.level +
             "\ninfo: " + msg.info.join(" ")
         );
     }
 
 });
 
 /** @id MochiKit.Logging.Logger */
 MochiKit.Logging.Logger = function (/* optional */maxSize) {
     this.counter = 0;
     if (typeof(maxSize) == 'undefined' || maxSize === null) {
         maxSize = -1;
     }
     this.maxSize = maxSize;
     this._messages = [];
     this.listeners = {};
     this.useNativeConsole = false;
 };
 
 MochiKit.Logging.Logger.prototype = {
     /** @id MochiKit.Logging.Logger.prototype.clear */
     clear: function () {
         this._messages.splice(0, this._messages.length);
     },
 
     /** @id MochiKit.Logging.Logger.prototype.logToConsole */
     logToConsole: function (msg) {
         if (typeof(window) != "undefined" && window.console
                 && window.console.log) {
             // Safari and FireBug 0.4
             // Percent replacement is a workaround for cute Safari crashing bug
             window.console.log(msg.replace(/%/g, '\uFF05'));
         } else if (typeof(opera) != "undefined" && opera.postError) {
             // Opera
             opera.postError(msg);
         } else if (typeof(Debug) != "undefined" && Debug.writeln) {
             // IE Web Development Helper (?)
             // http://www.nikhilk.net/Entry.aspx?id=93
             Debug.writeln(msg);
         } else if (typeof(debug) != "undefined" && debug.trace) {
             // Atlas framework (?)
             // http://www.nikhilk.net/Entry.aspx?id=93
             debug.trace(msg);
         }
     },
 
     /** @id MochiKit.Logging.Logger.prototype.dispatchListeners */
     dispatchListeners: function (msg) {
         for (var k in this.listeners) {
             var pair = this.listeners[k];
             if (pair.ident != k || (pair[0] && !pair[0](msg))) {
                 continue;
             }
             pair[1](msg);
         }
     },
 
     /** @id MochiKit.Logging.Logger.prototype.addListener */
     addListener: function (ident, filter, listener) {
         if (typeof(filter) == 'string') {
             filter = MochiKit.Logging.logLevelAtLeast(filter);
         }
         var entry = [filter, listener];
         entry.ident = ident;
         this.listeners[ident] = entry;
     },
 
     /** @id MochiKit.Logging.Logger.prototype.removeListener */
     removeListener: function (ident) {
         delete this.listeners[ident];
     },
 
     /** @id MochiKit.Logging.Logger.prototype.baseLog */
     baseLog: function (level, message/*, ...*/) {
         if (typeof(level) == "number") {
             if (level >= MochiKit.Logging.LogLevel.FATAL) {
                 level = 'FATAL';
             } else if (level >= MochiKit.Logging.LogLevel.ERROR) {
                 level = 'ERROR';
             } else if (level >= MochiKit.Logging.LogLevel.WARNING) {
                 level = 'WARNING';
             } else if (level >= MochiKit.Logging.LogLevel.INFO) {
                 level = 'INFO';
             } else {
                 level = 'DEBUG';
             }
         }
         var msg = new MochiKit.Logging.LogMessage(
             this.counter,
             level,
             MochiKit.Base.extend(null, arguments, 1)
         );
         this._messages.push(msg);
         this.dispatchListeners(msg);
         if (this.useNativeConsole) {
             this.logToConsole(msg.level + ": " + msg.info.join(" "));
         }
         this.counter += 1;
         while (this.maxSize >= 0 && this._messages.length > this.maxSize) {
             this._messages.shift();
         }
     },
 
     /** @id MochiKit.Logging.Logger.prototype.getMessages */
     getMessages: function (howMany) {
         var firstMsg = 0;
         if (!(typeof(howMany) == 'undefined' || howMany === null)) {
             firstMsg = Math.max(0, this._messages.length - howMany);
         }
         return this._messages.slice(firstMsg);
     },
 
     /** @id MochiKit.Logging.Logger.prototype.getMessageText */
     getMessageText: function (howMany) {
         if (typeof(howMany) == 'undefined' || howMany === null) {
             howMany = 30;
         }
         var messages = this.getMessages(howMany);
         if (messages.length) {
-            var lst = map(function (m) {
+            var lst = MochiKit.Base.map(function (m) {
                 return '\n  [' + m.num + '] ' + m.level + ': ' + m.info.join(' ');
             }, messages);
             lst.unshift('LAST ' + messages.length + ' MESSAGES:');
             return lst.join('');
         }
         return '';
     },
 
     /** @id MochiKit.Logging.Logger.prototype.debuggingBookmarklet */
     debuggingBookmarklet: function (inline) {
         if (typeof(MochiKit.LoggingPane) == "undefined") {
             alert(this.getMessageText());
         } else {
             MochiKit.LoggingPane.createLoggingPane(inline || false);
         }
     }
 };
 
 MochiKit.Logging.__new__ = function () {
     this.LogLevel = {
         ERROR: 40,
         FATAL: 50,
         WARNING: 30,
         INFO: 20,
         DEBUG: 10
     };
 
     var m = MochiKit.Base;
     m.registerComparator("LogMessage",
         this.isLogMessage,
         this.compareLogMessage
     );
 
     var partial = m.partial;
 
     var Logger = this.Logger;
     var baseLog = Logger.prototype.baseLog;
     m.update(this.Logger.prototype, {
         debug: partial(baseLog, 'DEBUG'),
         log: partial(baseLog, 'INFO'),
         error: partial(baseLog, 'ERROR'),
         fatal: partial(baseLog, 'FATAL'),
         warning: partial(baseLog, 'WARNING')
     });
 
     // indirectly find logger so it can be replaced
     var self = this;
     var connectLog = function (name) {
         return function () {
             self.logger[name].apply(self.logger, arguments);
         };
     };
 
     /** @id MochiKit.Logging.log */
     this.log = connectLog('log');
     /** @id MochiKit.Logging.logError */
     this.logError = connectLog('error');
     /** @id MochiKit.Logging.logDebug */
     this.logDebug = connectLog('debug');
     /** @id MochiKit.Logging.logFatal */
     this.logFatal = connectLog('fatal');
     /** @id MochiKit.Logging.logWarning */
     this.logWarning = connectLog('warning');
     this.logger = new Logger();
     this.logger.useNativeConsole = true;
 
     m.nameFunctions(this);
 };
 
 MochiKit.Logging.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.Logging);
diff --git a/frontend/gamma/js/MochiKit/LoggingPane.js b/frontend/gamma/js/MochiKit/LoggingPane.js
index c960c21..b7ea120 100644
--- a/frontend/gamma/js/MochiKit/LoggingPane.js
+++ b/frontend/gamma/js/MochiKit/LoggingPane.js
@@ -1,327 +1,330 @@
 /***
 
 MochiKit.LoggingPane 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('LoggingPane', '1.5', ['Base', 'Logging']);
+MochiKit.Base.module(MochiKit, 'LoggingPane', '1.5', ['Base', 'Logging']);
 
 /** @id MochiKit.LoggingPane.createLoggingPane */
 MochiKit.LoggingPane.createLoggingPane = function (inline/* = false */) {
     var m = MochiKit.LoggingPane;
     inline = !(!inline);
     if (m._loggingPane && m._loggingPane.inline != inline) {
         m._loggingPane.closePane();
         m._loggingPane = null;
     }
     if (!m._loggingPane || m._loggingPane.closed) {
         m._loggingPane = new m.LoggingPane(inline, MochiKit.Logging.logger);
     }
     return m._loggingPane;
 };
 
-/** @id MochiKit.LoggingPane.LoggingPane */
+/**
+ * @id MochiKit.LoggingPane.LoggingPane
+ * @constructor
+ */
 MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = MochiKit.Logging.logger */) {
 
     /* Use a div if inline, pop up a window if not */
     /* Create the elements */
     if (typeof(logger) == "undefined" || logger === null) {
         logger = MochiKit.Logging.logger;
     }
     this.logger = logger;
     var update = MochiKit.Base.update;
     var updatetree = MochiKit.Base.updatetree;
     var bind = MochiKit.Base.bind;
     var clone = MochiKit.Base.clone;
     var win = window;
     var uid = "_MochiKit_LoggingPane";
     if (typeof(MochiKit.DOM) != "undefined") {
         win = MochiKit.DOM.currentWindow();
     }
     if (!inline) {
         // name the popup with the base URL for uniqueness
         var url = win.location.href.split("?")[0].replace(/[#:\/.><&%-]/g, "_");
         var name = uid + "_" + url;
         var nwin = win.open("", name, "dependent,resizable,height=200");
         if (!nwin) {
             alert("Not able to open debugging window due to pop-up blocking.");
             return undefined;
         }
         nwin.document.write(
             '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" '
             + '"http://www.w3.org/TR/html4/loose.dtd">'
             + '<html><head><title>[MochiKit.LoggingPane]</title></head>'
             + '<body></body></html>'
         );
         nwin.document.close();
         nwin.document.title += ' ' + win.document.title;
         win = nwin;
     }
     var doc = win.document;
     this.doc = doc;
 
     // Connect to the debug pane if it already exists (i.e. in a window orphaned by the page being refreshed)
     var debugPane = doc.getElementById(uid);
     var existing_pane = !!debugPane;
     if (debugPane && typeof(debugPane.loggingPane) != "undefined") {
         debugPane.loggingPane.logger = this.logger;
         debugPane.loggingPane.buildAndApplyFilter();
         return debugPane.loggingPane;
     }
 
     if (existing_pane) {
         // clear any existing contents
         var child;
         while ((child = debugPane.firstChild)) {
             debugPane.removeChild(child);
         }
     } else {
         debugPane = doc.createElement("div");
         debugPane.id = uid;
     }
     debugPane.loggingPane = this;
     var levelFilterField = doc.createElement("input");
     var infoFilterField = doc.createElement("input");
     var filterButton = doc.createElement("button");
     var loadButton = doc.createElement("button");
     var clearButton = doc.createElement("button");
     var closeButton = doc.createElement("button");
     var logPaneArea = doc.createElement("div");
     var logPane = doc.createElement("div");
 
     /* Set up the functions */
     var listenerId = uid + "_Listener";
     this.colorTable = clone(this.colorTable);
     var messages = [];
     var messageFilter = null;
 
     /** @id MochiKit.LoggingPane.messageLevel */
     var messageLevel = function (msg) {
         var level = msg.level;
         if (typeof(level) == "number") {
             level = MochiKit.Logging.LogLevel[level];
         }
         return level;
     };
 
     /** @id MochiKit.LoggingPane.messageText */
     var messageText = function (msg) {
         return msg.info.join(" ");
     };
 
     /** @id MochiKit.LoggingPane.addMessageText */
     var addMessageText = bind(function (msg) {
         var level = messageLevel(msg);
         var text = messageText(msg);
         var c = this.colorTable[level];
         var p = doc.createElement("span");
         p.className = "MochiKit-LogMessage MochiKit-LogLevel-" + level;
         p.style.cssText = "margin: 0px; white-space: -moz-pre-wrap; white-space: -o-pre-wrap; white-space: pre-wrap; white-space: pre-line; word-wrap: break-word; wrap-option: emergency; color: " + c;
         p.appendChild(doc.createTextNode(level + ": " + text));
         logPane.appendChild(p);
         logPane.appendChild(doc.createElement("br"));
         if (logPaneArea.offsetHeight > logPaneArea.scrollHeight) {
             logPaneArea.scrollTop = 0;
         } else {
             logPaneArea.scrollTop = logPaneArea.scrollHeight;
         }
     }, this);
 
     /** @id MochiKit.LoggingPane.addMessage */
     var addMessage = function (msg) {
         messages[messages.length] = msg;
         addMessageText(msg);
     };
 
     /** @id MochiKit.LoggingPane.buildMessageFilter */
     var buildMessageFilter = function () {
         var levelre, infore;
         try {
             /* Catch any exceptions that might arise due to invalid regexes */
             levelre = new RegExp(levelFilterField.value);
             infore = new RegExp(infoFilterField.value);
         } catch(e) {
             /* If there was an error with the regexes, do no filtering */
-            logDebug("Error in filter regex: " + e.message);
+            MochiKit.Logging.logDebug("Error in filter regex: " + e.message);
             return null;
         }
 
         return function (msg) {
             return (
                 levelre.test(messageLevel(msg)) &&
                 infore.test(messageText(msg))
             );
         };
     };
 
     /** @id MochiKit.LoggingPane.clearMessagePane */
     var clearMessagePane = function () {
         while (logPane.firstChild) {
             logPane.removeChild(logPane.firstChild);
         }
     };
 
     /** @id MochiKit.LoggingPane.clearMessages */
     var clearMessages = function () {
         messages = [];
         clearMessagePane();
     };
 
     /** @id MochiKit.LoggingPane.closePane */
     var closePane = bind(function () {
         if (this.closed) {
             return;
         }
         this.closed = true;
         if (MochiKit.LoggingPane._loggingPane == this) {
             MochiKit.LoggingPane._loggingPane = null;
         }
         this.logger.removeListener(listenerId);
         try {
             try {
               debugPane.loggingPane = null;
-            } catch(e) { logFatal("Bookmarklet was closed incorrectly."); }
+            } catch(e) { MochiKit.Logging.logFatal("Bookmarklet was closed incorrectly."); }
             if (inline) {
                 debugPane.parentNode.removeChild(debugPane);
             } else {
                 this.win.close();
             }
         } catch(e) {}
     }, this);
 
     /** @id MochiKit.LoggingPane.filterMessages */
     var filterMessages = function () {
         clearMessagePane();
 
         for (var i = 0; i < messages.length; i++) {
             var msg = messages[i];
             if (messageFilter === null || messageFilter(msg)) {
                 addMessageText(msg);
             }
         }
     };
 
     this.buildAndApplyFilter = function () {
         messageFilter = buildMessageFilter();
 
         filterMessages();
 
         this.logger.removeListener(listenerId);
         this.logger.addListener(listenerId, messageFilter, addMessage);
     };
 
 
     /** @id MochiKit.LoggingPane.loadMessages */
     var loadMessages = bind(function () {
         messages = this.logger.getMessages();
         filterMessages();
     }, this);
 
     /** @id MochiKit.LoggingPane.filterOnEnter */
     var filterOnEnter = bind(function (event) {
         event = event || window.event;
-        key = event.which || event.keyCode;
+        var key = event.which || event.keyCode;
         if (key == 13) {
             this.buildAndApplyFilter();
         }
     }, this);
 
     /* Create the debug pane */
     var style = "display: block; z-index: 1000; left: 0px; bottom: 0px; position: fixed; width: 100%; background-color: white; font: " + this.logFont;
     if (inline) {
         style += "; height: 10em; border-top: 2px solid black";
     } else {
         style += "; height: 100%;";
     }
     debugPane.style.cssText = style;
 
     if (!existing_pane) {
         doc.body.appendChild(debugPane);
     }
 
     /* Create the filter fields */
     style = {"cssText": "width: 33%; display: inline; font: " + this.logFont};
 
     updatetree(levelFilterField, {
         "value": "FATAL|ERROR|WARNING|INFO|DEBUG",
         "onkeypress": filterOnEnter,
         "style": style
     });
     debugPane.appendChild(levelFilterField);
 
     updatetree(infoFilterField, {
         "value": ".*",
         "onkeypress": filterOnEnter,
         "style": style
     });
     debugPane.appendChild(infoFilterField);
 
     /* Create the buttons */
     style = "width: 8%; display:inline; font: " + this.logFont;
 
     filterButton.appendChild(doc.createTextNode("Filter"));
     filterButton.onclick = bind("buildAndApplyFilter", this);
     filterButton.style.cssText = style;
     debugPane.appendChild(filterButton);
 
     loadButton.appendChild(doc.createTextNode("Load"));
     loadButton.onclick = loadMessages;
     loadButton.style.cssText = style;
     debugPane.appendChild(loadButton);
 
     clearButton.appendChild(doc.createTextNode("Clear"));
     clearButton.onclick = clearMessages;
     clearButton.style.cssText = style;
     debugPane.appendChild(clearButton);
 
     closeButton.appendChild(doc.createTextNode("Close"));
     closeButton.onclick = closePane;
     closeButton.style.cssText = style;
     debugPane.appendChild(closeButton);
 
     /* Create the logging pane */
     logPaneArea.style.cssText = "overflow: auto; width: 100%";
     logPane.style.cssText = "width: 100%; height: " + (inline ? "8em" : "100%");
 
     logPaneArea.appendChild(logPane);
     debugPane.appendChild(logPaneArea);
 
     this.buildAndApplyFilter();
     loadMessages();
 
     if (inline) {
         this.win = undefined;
     } else {
         this.win = win;
     }
     this.inline = inline;
     this.closePane = closePane;
     this.closed = false;
 
 
     return this;
 };
 
 MochiKit.LoggingPane.LoggingPane.prototype = {
     "logFont": "8pt Verdana,sans-serif",
     "colorTable": {
         "ERROR": "red",
         "FATAL": "darkred",
         "WARNING": "blue",
         "INFO": "black",
         "DEBUG": "green"
     }
 };
 
 MochiKit.LoggingPane.__new__ = function () {
     MochiKit.Base.nameFunctions(this);
     MochiKit.LoggingPane._loggingPane = null;
 };
 
 MochiKit.LoggingPane.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.LoggingPane);
diff --git a/frontend/gamma/js/MochiKit/MochiKit.js b/frontend/gamma/js/MochiKit/MochiKit.js
index 8e5be68..511e075 100644
--- a/frontend/gamma/js/MochiKit/MochiKit.js
+++ b/frontend/gamma/js/MochiKit/MochiKit.js
@@ -1,136 +1,133 @@
 /***
 
 MochiKit.MochiKit 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-if (typeof(MochiKit) == 'undefined') {
-    MochiKit = {};
-}
+var MochiKit = MochiKit || {};
 
-if (typeof(MochiKit.MochiKit) == 'undefined') {
-    /** @id MochiKit.MochiKit */
-    MochiKit.MochiKit = {};
-}
+/** @id MochiKit.MochiKit */
+MochiKit.MochiKit = MochiKit.MochiKit || {};
 
 MochiKit.MochiKit.NAME = "MochiKit.MochiKit";
 MochiKit.MochiKit.VERSION = "1.5";
+MochiKit.MochiKit.__export__ = false;
 MochiKit.MochiKit.__repr__ = function () {
     return "[" + this.NAME + " " + this.VERSION + "]";
 };
 
 /** @id MochiKit.MochiKit.toString */
 MochiKit.MochiKit.toString = function () {
     return this.__repr__();
 };
 
 /** @id MochiKit.MochiKit.SUBMODULES */
 MochiKit.MochiKit.SUBMODULES = [
     "Base",
     "Iter",
     "Logging",
     "DateTime",
     "Format",
     "Text",
     "Async",
     "DOM",
     "Selector",
     "Style",
     "LoggingPane",
     "Color",
     "Signal",
     "Position",
     "Visual",
     "DragAndDrop",
     "Sortable"
 ];
 
 (function () {
     if (typeof(document) == "undefined") {
         return;
     }
     var scripts = document.getElementsByTagName("script");
     var kXHTMLNSURI = "http://www.w3.org/1999/xhtml";
     var kSVGNSURI = "http://www.w3.org/2000/svg";
     var kXLINKNSURI = "http://www.w3.org/1999/xlink";
     var kXULNSURI = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
     var base = null;
     var baseElem = null;
     var allScripts = {};
     var i;
     var src;
     for (i = 0; i < scripts.length; i++) {
         src = null;
         switch (scripts[i].namespaceURI) {
             case kSVGNSURI:
                 src = scripts[i].getAttributeNS(kXLINKNSURI, "href");
                 break;
             /*
             case null: // HTML
             case '': // HTML
             case kXHTMLNSURI:
             case kXULNSURI:
             */
             default:
                 src = scripts[i].getAttribute("src");
                 break;
         }
         if (!src) {
             continue;
         }
         allScripts[src] = true;
         if (src.match(/MochiKit.js(\?.*)?$/)) {
             base = src.substring(0, src.lastIndexOf('MochiKit.js'));
             baseElem = scripts[i];
         }
     }
     if (base === null) {
         return;
     }
     var modules = MochiKit.MochiKit.SUBMODULES;
     for (var i = 0; i < modules.length; i++) {
         if (MochiKit[modules[i]]) {
             continue;
         }
         var uri = base + modules[i] + '.js';
         if (uri in allScripts) {
             continue;
         }
         if (baseElem.namespaceURI == kSVGNSURI ||
             baseElem.namespaceURI == kXULNSURI) {
             // SVG, XUL
             /*
                 SVG does not support document.write, so if Safari wants to
                 support SVG tests it should fix its deferred loading bug
                 (see following below).
             */
             var s = document.createElementNS(baseElem.namespaceURI, 'script');
             s.setAttribute("id", "MochiKit_" + base + modules[i]);
             if (baseElem.namespaceURI == kSVGNSURI) {
                 s.setAttributeNS(kXLINKNSURI, 'href', uri);
             } else {
                 s.setAttribute('src', uri);
             }
             s.setAttribute("type", "application/x-javascript");
             baseElem.parentNode.appendChild(s);
         } else {
             // HTML, XHTML
             /*
                 DOM can not be used here because Safari does
                 deferred loading of scripts unless they are
                 in the document or inserted with document.write
 
                 This is not XHTML compliant.  If you want XHTML
                 compliance then you must use the packed version of MochiKit
                 or include each script individually (basically unroll
                 these document.write calls into your XHTML source)
             */
             document.write('<' + baseElem.nodeName + ' src="' + uri +
                 '" type="text/javascript"></script>');
         }
     };
 })();
diff --git a/frontend/gamma/js/MochiKit/MockDOM.js b/frontend/gamma/js/MochiKit/MockDOM.js
index abdb54a..7e6d60b 100644
--- a/frontend/gamma/js/MochiKit/MockDOM.js
+++ b/frontend/gamma/js/MochiKit/MockDOM.js
@@ -1,115 +1,112 @@
 /***
 
 MochiKit.MockDOM 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-if (typeof(MochiKit) == "undefined") {
-    MochiKit = {};
-}
+var MochiKit = MochiKit || {};
 
-if (typeof(MochiKit.MockDOM) == "undefined") {
-    MochiKit.MockDOM = {};
-}
+MochiKit.MockDOM = MochiKit.MockDOM || {};
 
 MochiKit.MockDOM.NAME = "MochiKit.MockDOM";
 MochiKit.MockDOM.VERSION = "1.5";
+MochiKit.MockDOM.__export__ = false;
 
 MochiKit.MockDOM.__repr__ = function () {
     return "[" + this.NAME + " " + this.VERSION + "]";
 };
 
 /** @id MochiKit.MockDOM.toString */
 MochiKit.MockDOM.toString = function () {
     return this.__repr__();
 };
 
 /** @id MochiKit.MockDOM.createDocument */
 MochiKit.MockDOM.createDocument = function () {
     var doc = new MochiKit.MockDOM.MockElement("DOCUMENT");
     doc.body = doc.createElement("BODY");
     doc.appendChild(doc.body);
     return doc;
 };
 
 /** @id MochiKit.MockDOM.MockElement */
 MochiKit.MockDOM.MockElement = function (name, data, ownerDocument) {
     this.tagName = this.nodeName = name.toUpperCase();
     this.ownerDocument = ownerDocument || null;
     if (name == "DOCUMENT") {
         this.nodeType = 9;
         this.childNodes = [];
     } else if (typeof(data) == "string") {
         this.nodeValue = data;
         this.nodeType = 3;
     } else {
         this.nodeType = 1;
         this.childNodes = [];
     }
     if (name.substring(0, 1) == "<") {
         var nameattr = name.substring(
             name.indexOf('"') + 1, name.lastIndexOf('"'));
         name = name.substring(1, name.indexOf(" "));
         this.tagName = this.nodeName = name.toUpperCase();
         this.setAttribute("name", nameattr);
     }
 };
 
 MochiKit.MockDOM.MockElement.prototype = {
     /** @id MochiKit.MockDOM.MockElement.prototype.createElement */
     createElement: function (tagName) {
         return new MochiKit.MockDOM.MockElement(tagName, null, this.nodeType == 9 ? this : this.ownerDocument);
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.createTextNode */
     createTextNode: function (text) {
         return new MochiKit.MockDOM.MockElement("text", text, this.nodeType == 9 ? this : this.ownerDocument);
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.setAttribute */
     setAttribute: function (name, value) {
         this[name] = value;
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.getAttribute */
     getAttribute: function (name) {
         return this[name];
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.appendChild */
     appendChild: function (child) {
         this.childNodes.push(child);
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.toString */
     toString: function () {
         return "MockElement(" + this.tagName + ")";
     },
     /** @id MochiKit.MockDOM.MockElement.prototype.getElementsByTagName */
     getElementsByTagName: function (tagName) {
         var foundElements = [];
         MochiKit.Base.nodeWalk(this, function(node){
             if (tagName == '*' || tagName == node.tagName) {
                 foundElements.push(node);
                 return node.childNodes;
             }
         });
         return foundElements;
     }
 };
 
     /** @id MochiKit.MockDOM.EXPORT_OK */
 MochiKit.MockDOM.EXPORT_OK = [
     "mockElement",
     "createDocument"
 ];
 
     /** @id MochiKit.MockDOM.EXPORT */
 MochiKit.MockDOM.EXPORT = [
     "document"
 ];
 
 MochiKit.MockDOM.__new__ = function () {
     this.document = this.createDocument();
 };
 
 MochiKit.MockDOM.__new__();
diff --git a/frontend/gamma/js/MochiKit/Position.js b/frontend/gamma/js/MochiKit/Position.js
index 6bc5b39..2680507 100644
--- a/frontend/gamma/js/MochiKit/Position.js
+++ b/frontend/gamma/js/MochiKit/Position.js
@@ -1,218 +1,218 @@
 /***
 
 MochiKit.Position 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005-2006 Bob Ippolito and others.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Position', '1.5', ['Base', 'DOM', 'Style']);
+MochiKit.Base.module(MochiKit, 'Position', '1.5', ['Base', 'DOM', 'Style']);
 
 MochiKit.Base.update(MochiKit.Position, {
     // Don't export from this module
     __export__: false,
 
     // set to true if needed, warning: firefox performance problems
     // NOT neeeded for page scrolling, only if draggable contained in
     // scrollable elements
     includeScrollOffsets: false,
 
     /** @id MochiKit.Position.prepare */
     prepare: function () {
         var deltaX =  window.pageXOffset
                    || document.documentElement.scrollLeft
                    || document.body.scrollLeft
                    || 0;
         var deltaY =  window.pageYOffset
                    || document.documentElement.scrollTop
                    || document.body.scrollTop
                    || 0;
         this.windowOffset = new MochiKit.Style.Coordinates(deltaX, deltaY);
     },
 
     /** @id MochiKit.Position.cumulativeOffset */
     cumulativeOffset: function (element) {
         var valueT = 0;
         var valueL = 0;
         do {
             valueT += element.offsetTop  || 0;
             valueL += element.offsetLeft || 0;
             element = element.offsetParent;
         } while (element);
         return new MochiKit.Style.Coordinates(valueL, valueT);
     },
 
     /** @id MochiKit.Position.realOffset */
     realOffset: function (element) {
         var valueT = 0;
         var valueL = 0;
         do {
             valueT += element.scrollTop  || 0;
             valueL += element.scrollLeft || 0;
             element = element.parentNode;
         } while (element);
         return new MochiKit.Style.Coordinates(valueL, valueT);
     },
 
     /** @id MochiKit.Position.within */
     within: function (element, x, y) {
         if (this.includeScrollOffsets) {
             return this.withinIncludingScrolloffsets(element, x, y);
         }
         this.xcomp = x;
         this.ycomp = y;
         this.offset = this.cumulativeOffset(element);
         if (element.style.position == "fixed") {
             this.offset.x += this.windowOffset.x;
             this.offset.y += this.windowOffset.y;
         }
 
         return (y >= this.offset.y &&
                 y <  this.offset.y + element.offsetHeight &&
                 x >= this.offset.x &&
                 x <  this.offset.x + element.offsetWidth);
     },
 
     /** @id MochiKit.Position.withinIncludingScrolloffsets */
     withinIncludingScrolloffsets: function (element, x, y) {
         var offsetcache = this.realOffset(element);
 
         this.xcomp = x + offsetcache.x - this.windowOffset.x;
         this.ycomp = y + offsetcache.y - this.windowOffset.y;
         this.offset = this.cumulativeOffset(element);
 
         return (this.ycomp >= this.offset.y &&
                 this.ycomp <  this.offset.y + element.offsetHeight &&
                 this.xcomp >= this.offset.x &&
                 this.xcomp <  this.offset.x + element.offsetWidth);
     },
 
     // within must be called directly before
     /** @id MochiKit.Position.overlap */
     overlap: function (mode, element) {
         if (!mode) {
             return 0;
         }
         if (mode == 'vertical') {
           return ((this.offset.y + element.offsetHeight) - this.ycomp) /
                  element.offsetHeight;
         }
         if (mode == 'horizontal') {
           return ((this.offset.x + element.offsetWidth) - this.xcomp) /
                  element.offsetWidth;
         }
     },
 
     /** @id MochiKit.Position.absolutize */
     absolutize: function (element) {
         element = MochiKit.DOM.getElement(element);
         if (element.style.position == 'absolute') {
             return;
         }
         MochiKit.Position.prepare();
 
         var offsets = MochiKit.Position.positionedOffset(element);
         var width = element.clientWidth;
         var height = element.clientHeight;
 
         var oldStyle = {
             'position': element.style.position,
             'left': offsets.x - parseFloat(element.style.left  || 0),
             'top': offsets.y - parseFloat(element.style.top || 0),
             'width': element.style.width,
             'height': element.style.height
         };
 
         element.style.position = 'absolute';
         element.style.top = offsets.y + 'px';
         element.style.left = offsets.x + 'px';
         element.style.width = width + 'px';
         element.style.height = height + 'px';
 
         return oldStyle;
     },
 
     /** @id MochiKit.Position.positionedOffset */
     positionedOffset: function (element) {
         var valueT = 0, valueL = 0;
         do {
             valueT += element.offsetTop  || 0;
             valueL += element.offsetLeft || 0;
             element = element.offsetParent;
             if (element) {
                 var p = MochiKit.Style.getStyle(element, 'position');
                 if (p == 'relative' || p == 'absolute') {
                     break;
                 }
             }
         } while (element);
         return new MochiKit.Style.Coordinates(valueL, valueT);
     },
 
     /** @id MochiKit.Position.relativize */
     relativize: function (element, oldPos) {
         element = MochiKit.DOM.getElement(element);
         if (element.style.position == 'relative') {
             return;
         }
         MochiKit.Position.prepare();
 
         var top = parseFloat(element.style.top || 0) -
                   (oldPos['top'] || 0);
         var left = parseFloat(element.style.left || 0) -
                    (oldPos['left'] || 0);
 
         element.style.position = oldPos['position'];
         element.style.top = top + 'px';
         element.style.left = left + 'px';
         element.style.width = oldPos['width'];
         element.style.height = oldPos['height'];
     },
 
     /** @id MochiKit.Position.clone */
     clone: function (source, target) {
         source = MochiKit.DOM.getElement(source);
         target = MochiKit.DOM.getElement(target);
         target.style.position = 'absolute';
         var offsets = this.cumulativeOffset(source);
         target.style.top = offsets.y + 'px';
         target.style.left = offsets.x + 'px';
         target.style.width = source.offsetWidth + 'px';
         target.style.height = source.offsetHeight + 'px';
     },
 
     /** @id MochiKit.Position.page */
     page: function (forElement) {
         var valueT = 0;
         var valueL = 0;
 
         var element = forElement;
         do {
             valueT += element.offsetTop  || 0;
             valueL += element.offsetLeft || 0;
 
             // Safari fix
             if (element.offsetParent == document.body && MochiKit.Style.getStyle(element, 'position') == 'absolute') {
                 break;
             }
         } while (element = element.offsetParent);
 
         element = forElement;
         do {
             valueT -= element.scrollTop  || 0;
             valueL -= element.scrollLeft || 0;
         } while (element = element.parentNode);
 
         return new MochiKit.Style.Coordinates(valueL, valueT);
     }
 });
 
 MochiKit.Position.__new__ = function (win) {
     MochiKit.Base.nameFunctions(this);
 };
 
 MochiKit.Position.__new__(this);
 
 MochiKit.Base._exportSymbols(this, MochiKit.Position);
diff --git a/frontend/gamma/js/MochiKit/Selector.js b/frontend/gamma/js/MochiKit/Selector.js
index 6aec892..3187fe9 100644
--- a/frontend/gamma/js/MochiKit/Selector.js
+++ b/frontend/gamma/js/MochiKit/Selector.js
@@ -1,387 +1,393 @@
 /***
 
 MochiKit.Selector 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito and others.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Selector', '1.5', ['Base', 'DOM', 'Iter']);
+MochiKit.Base.module(MochiKit, 'Selector', '1.5', ['Base', 'DOM', 'Iter']);
 
 MochiKit.Selector.Selector = function (expression) {
     this.params = {classNames: [], pseudoClassNames: []};
     this.expression = expression.toString().replace(/(^\s+|\s+$)/g, '');
     this.parseExpression();
     this.compileMatcher();
 };
 
 MochiKit.Selector.Selector.prototype = {
     /***
 
     Selector class: convenient object to make CSS selections.
 
     ***/
     __class__: MochiKit.Selector.Selector,
 
     /** @id MochiKit.Selector.Selector.prototype.parseExpression */
     parseExpression: function () {
         function abort(message) {
             throw 'Parse error in selector: ' + message;
         }
 
         if (this.expression == '')  {
             abort('empty expression');
         }
 
         var repr = MochiKit.Base.repr;
         var params = this.params;
         var expr = this.expression;
         var match, modifier, clause, rest;
         while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!^$*]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
             params.attributes = params.attributes || [];
             params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
             expr = match[1];
         }
 
         if (expr == '*') {
             return this.params.wildcard = true;
         }
 
         while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+(?:\([^)]*\))?)(.*)/i)) {
             modifier = match[1];
             clause = match[2];
             rest = match[3];
             switch (modifier) {
                 case '#':
                     params.id = clause;
                     break;
                 case '.':
                     params.classNames.push(clause);
                     break;
                 case ':':
                     params.pseudoClassNames.push(clause);
                     break;
                 case '':
                 case undefined:
                     params.tagName = clause.toUpperCase();
                     break;
                 default:
                     abort(repr(expr));
             }
             expr = rest;
         }
 
         if (expr.length > 0) {
             abort(repr(expr));
         }
     },
 
     /** @id MochiKit.Selector.Selector.prototype.buildMatchExpression */
     buildMatchExpression: function () {
         var repr = MochiKit.Base.repr;
         var params = this.params;
         var conditions = [];
         var clause, i;
 
         function childElements(element) {
             return "MochiKit.Base.filter(function (node) { return node.nodeType == 1; }, " + element + ".childNodes)";
         }
 
         if (params.wildcard) {
             conditions.push('true');
         }
         if (clause = params.id) {
             conditions.push('element.id == ' + repr(clause));
         }
         if (clause = params.tagName) {
             conditions.push('element.tagName.toUpperCase() == ' + repr(clause));
         }
         if ((clause = params.classNames).length > 0) {
             for (i = 0; i < clause.length; i++) {
                 conditions.push('MochiKit.DOM.hasElementClass(element, ' + repr(clause[i]) + ')');
             }
         }
         if ((clause = params.pseudoClassNames).length > 0) {
             for (i = 0; i < clause.length; i++) {
                 var match = clause[i].match(/^([^(]+)(?:\((.*)\))?$/);
                 var pseudoClass = match[1];
                 var pseudoClassArgument = match[2];
                 switch (pseudoClass) {
                     case 'root':
                         conditions.push('element.nodeType == 9 || element === element.ownerDocument.documentElement'); break;
                     case 'nth-child':
                     case 'nth-last-child':
                     case 'nth-of-type':
                     case 'nth-last-of-type':
                         match = pseudoClassArgument.match(/^((?:(\d+)n\+)?(\d+)|odd|even)$/);
                         if (!match) {
                             throw "Invalid argument to pseudo element nth-child: " + pseudoClassArgument;
                         }
                         var a, b;
                         if (match[0] == 'odd') {
                             a = 2;
                             b = 1;
                         } else if (match[0] == 'even') {
                             a = 2;
                             b = 0;
                         } else {
-                            a = match[2] && parseInt(match) || null;
-                            b = parseInt(match[3]);
+                            a = match[2] && parseInt(match, 10) || null;
+                            b = parseInt(match[3], 10);
                         }
                         conditions.push('this.nthChild(element,' + a + ',' + b
                                         + ',' + !!pseudoClass.match('^nth-last')    // Reverse
                                         + ',' + !!pseudoClass.match('of-type$')     // Restrict to same tagName
                                         + ')');
                         break;
                     case 'first-child':
                         conditions.push('this.nthChild(element, null, 1)');
                         break;
                     case 'last-child':
                         conditions.push('this.nthChild(element, null, 1, true)');
                         break;
                     case 'first-of-type':
                         conditions.push('this.nthChild(element, null, 1, false, true)');
                         break;
                     case 'last-of-type':
                         conditions.push('this.nthChild(element, null, 1, true, true)');
                         break;
                     case 'only-child':
                         conditions.push(childElements('element.parentNode') + '.length == 1');
                         break;
                     case 'only-of-type':
                         conditions.push('MochiKit.Base.filter(function (node) { return node.tagName == element.tagName; }, ' + childElements('element.parentNode') + ').length == 1');
                         break;
                     case 'empty':
                         conditions.push('element.childNodes.length == 0');
                         break;
                     case 'enabled':
                         conditions.push('(this.isUIElement(element) && element.disabled === false)');
                         break;
                     case 'disabled':
                         conditions.push('(this.isUIElement(element) && element.disabled === true)');
                         break;
                     case 'checked':
                         conditions.push('(this.isUIElement(element) && element.checked === true)');
                         break;
                     case 'not':
                         var subselector = new MochiKit.Selector.Selector(pseudoClassArgument);
-                        conditions.push('!( ' + subselector.buildMatchExpression() + ')')
+                        conditions.push('!( ' + subselector.buildMatchExpression() + ')');
                         break;
                 }
             }
         }
         if (clause = params.attributes) {
             MochiKit.Base.map(function (attribute) {
                 var value = 'MochiKit.DOM.getNodeAttribute(element, ' + repr(attribute.name) + ')';
                 var splitValueBy = function (delimiter) {
                     return value + '.split(' + repr(delimiter) + ')';
-                }
+                };
                 conditions.push(value + ' != null');
                 switch (attribute.operator) {
                     case '=':
                         conditions.push(value + ' == ' + repr(attribute.value));
                         break;
                     case '~=':
                         conditions.push('MochiKit.Base.findValue(' + splitValueBy(' ') + ', ' + repr(attribute.value) + ') > -1');
                         break;
                     case '^=':
                         conditions.push(value + '.substring(0, ' + attribute.value.length + ') == ' + repr(attribute.value));
                         break;
                     case '$=':
                         conditions.push(value + '.substring(' + value + '.length - ' + attribute.value.length + ') == ' + repr(attribute.value));
                         break;
                     case '*=':
                         conditions.push(value + '.match(' + repr(attribute.value) + ')');
                         break;
                     case '|=':
                         conditions.push(splitValueBy('-') + '[0].toUpperCase() == ' + repr(attribute.value.toUpperCase()));
                         break;
                     case '!=':
                         conditions.push(value + ' != ' + repr(attribute.value));
                         break;
                     case '':
                     case undefined:
                         // Condition already added above
                         break;
                     default:
                         throw 'Unknown operator ' + attribute.operator + ' in selector';
                 }
             }, clause);
         }
 
         return conditions.join(' && ');
     },
 
     /** @id MochiKit.Selector.Selector.prototype.compileMatcher */
     compileMatcher: function () {
         var code = 'return (!element.tagName) ? false : ' +
                    this.buildMatchExpression() + ';';
         this.match = new Function('element', code);
     },
 
     /** @id MochiKit.Selector.Selector.prototype.nthChild */
     nthChild: function (element, a, b, reverse, sametag){
         var siblings = MochiKit.Base.filter(function (node) {
             return node.nodeType == 1;
         }, element.parentNode.childNodes);
         if (sametag) {
             siblings = MochiKit.Base.filter(function (node) {
                 return node.tagName == element.tagName;
             }, siblings);
         }
         if (reverse) {
             siblings = MochiKit.Iter.reversed(siblings);
         }
         if (a) {
             var actualIndex = MochiKit.Base.findIdentical(siblings, element);
             return ((actualIndex + 1 - b) / a) % 1 == 0;
         } else {
             return b == MochiKit.Base.findIdentical(siblings, element) + 1;
         }
     },
 
     /** @id MochiKit.Selector.Selector.prototype.isUIElement */
     isUIElement: function (element) {
         return MochiKit.Base.findValue(['input', 'button', 'select', 'option', 'textarea', 'object'],
                 element.tagName.toLowerCase()) > -1;
     },
 
     /** @id MochiKit.Selector.Selector.prototype.findElements */
     findElements: function (scope, axis) {
         var element;
 
         if (axis == undefined) {
             axis = "";
         }
 
         function inScope(element, scope) {
             if (axis == "") {
                 return MochiKit.DOM.isChildNode(element, scope);
             } else if (axis == ">") {
                 return element.parentNode === scope;
             } else if (axis == "+") {
                 return element === nextSiblingElement(scope);
             } else if (axis == "~") {
                 var sibling = scope;
                 while (sibling = nextSiblingElement(sibling)) {
                     if (element === sibling) {
                         return true;
                     }
                 }
                 return false;
             } else {
                 throw "Invalid axis: " + axis;
             }
         }
 
         if (element = MochiKit.DOM.getElement(this.params.id)) {
             if (this.match(element)) {
                 if (!scope || inScope(element, scope)) {
                     return [element];
                 }
             }
         }
 
         function nextSiblingElement(node) {
             node = node.nextSibling;
             while (node && node.nodeType != 1) {
                 node = node.nextSibling;
             }
             return node;
         }
 
         if (axis == "") {
             scope = (scope || MochiKit.DOM.currentDocument()).getElementsByTagName(this.params.tagName || '*');
         } else if (axis == ">") {
             if (!scope) {
                 throw "> combinator not allowed without preceeding expression";
             }
             scope = MochiKit.Base.filter(function (node) {
                 return node.nodeType == 1;
             }, scope.childNodes);
         } else if (axis == "+") {
             if (!scope) {
                 throw "+ combinator not allowed without preceeding expression";
             }
             scope = nextSiblingElement(scope) && [nextSiblingElement(scope)];
         } else if (axis == "~") {
             if (!scope) {
                 throw "~ combinator not allowed without preceeding expression";
             }
             var newscope = [];
             while (nextSiblingElement(scope)) {
                 scope = nextSiblingElement(scope);
                 newscope.push(scope);
             }
             scope = newscope;
         }
 
         if (!scope) {
             return [];
         }
 
         var results = MochiKit.Base.filter(MochiKit.Base.bind(function (scopeElt) {
             return this.match(scopeElt);
         }, this), scope);
 
         return results;
     },
 
     /** @id MochiKit.Selector.Selector.prototype.repr */
     repr: function () {
         return 'Selector(' + this.expression + ')';
     },
 
     toString: MochiKit.Base.forwardCall("repr")
 };
 
 MochiKit.Base.update(MochiKit.Selector, {
 
     /** @id MochiKit.Selector.findChildElements */
     findChildElements: function (element, expressions) {
         element = MochiKit.DOM.getElement(element);
         var uniq = function(arr) {
             var res = [];
             for (var i = 0; i < arr.length; i++) {
                 if (MochiKit.Base.findIdentical(res, arr[i]) < 0) {
                     res.push(arr[i]);
                 }
             }
             return res;
         };
         return MochiKit.Base.flattenArray(MochiKit.Base.map(function (expression) {
+            try {
+                var res = element.querySelectorAll(expression);
+                return Array.prototype.slice.call(res, 0);
+            } catch (ignore) {
+                // No querySelectorAll or extended expression syntax used
+            }
             var nextScope = "";
             var reducer = function (results, expr) {
                 var match = expr.match(/^[>+~]$/);
                 if (match) {
                     nextScope = match[0];
                     return results;
                 } else {
                     var selector = new MochiKit.Selector.Selector(expr);
                     var elements = MochiKit.Iter.reduce(function (elements, result) {
                         return MochiKit.Base.extend(elements, selector.findElements(result || element, nextScope));
                     }, results, []);
                     nextScope = "";
                     return elements;
                 }
             };
             var exprs = expression.replace(/(^\s+|\s+$)/g, '').split(/\s+/);
             return uniq(MochiKit.Iter.reduce(reducer, exprs, [null]));
         }, expressions));
     },
 
     findDocElements: function () {
         return MochiKit.Selector.findChildElements(MochiKit.DOM.currentDocument(), arguments);
     },
 
     __new__: function () {
         this.$$ = this.findDocElements;
         MochiKit.Base.nameFunctions(this);
     }
 });
 
 MochiKit.Selector.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.Selector);
diff --git a/frontend/gamma/js/MochiKit/Signal.js b/frontend/gamma/js/MochiKit/Signal.js
index 7df5619..11590c1 100644
--- a/frontend/gamma/js/MochiKit/Signal.js
+++ b/frontend/gamma/js/MochiKit/Signal.js
@@ -1,888 +1,901 @@
 /***
 
 MochiKit.Signal 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2006 Jonathan Gardner, Beau Hartshorne, Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Signal', '1.5', ['Base', 'DOM', 'Style']);
+MochiKit.Base.module(MochiKit, 'Signal', '1.5', ['Base', 'DOM']);
 
 MochiKit.Signal._observers = [];
 
 /** @id MochiKit.Signal.Event */
 MochiKit.Signal.Event = function (src, e) {
     this._event = e || window.event;
     this._src = src;
 };
 MochiKit.Signal.Event.__export__ = false;
 
 MochiKit.Base.update(MochiKit.Signal.Event.prototype, {
 
     __repr__: function () {
         var repr = MochiKit.Base.repr;
         var str = '{event(): ' + repr(this.event()) +
             ', src(): ' + repr(this.src()) +
             ', type(): ' + repr(this.type()) +
             ', target(): ' + repr(this.target());
 
         if (this.type() &&
             this.type().indexOf('key') === 0 ||
             this.type().indexOf('mouse') === 0 ||
             this.type().indexOf('click') != -1 ||
             this.type() == 'contextmenu') {
             str += ', modifier(): ' + '{alt: ' + repr(this.modifier().alt) +
             ', ctrl: ' + repr(this.modifier().ctrl) +
             ', meta: ' + repr(this.modifier().meta) +
             ', shift: ' + repr(this.modifier().shift) +
             ', any: ' + repr(this.modifier().any) + '}';
         }
 
         if (this.type() && this.type().indexOf('key') === 0) {
             str += ', key(): {code: ' + repr(this.key().code) +
                 ', string: ' + repr(this.key().string) + '}';
         }
 
         if (this.type() && (
             this.type().indexOf('mouse') === 0 ||
             this.type().indexOf('click') != -1 ||
             this.type() == 'contextmenu')) {
 
             str += ', mouse(): {page: ' + repr(this.mouse().page) +
                 ', client: ' + repr(this.mouse().client);
 
             if (this.type() != 'mousemove' && this.type() != 'mousewheel') {
                 str += ', button: {left: ' + repr(this.mouse().button.left) +
                     ', middle: ' + repr(this.mouse().button.middle) +
                     ', right: ' + repr(this.mouse().button.right) + '}';
             }
             if (this.type() == 'mousewheel') {
                 str += ', wheel: ' + repr(this.mouse().wheel);
             }
             str += '}';
         }
         if (this.type() == 'mouseover' || this.type() == 'mouseout' || 
             this.type() == 'mouseenter' || this.type() == 'mouseleave') {
             str += ', relatedTarget(): ' + repr(this.relatedTarget());
         }
         str += '}';
         return str;
     },
 
      /** @id MochiKit.Signal.Event.prototype.toString */
     toString: function () {
         return this.__repr__();
     },
 
     /** @id MochiKit.Signal.Event.prototype.src */
     src: function () {
         return this._src;
     },
 
     /** @id MochiKit.Signal.Event.prototype.event  */
     event: function () {
         return this._event;
     },
 
     /** @id MochiKit.Signal.Event.prototype.type */
     type: function () {
         if (this._event.type === "DOMMouseScroll") {
             return "mousewheel";
         } else {
             return this._event.type || undefined;
         }
     },
 
     /** @id MochiKit.Signal.Event.prototype.target */
     target: function () {
         return this._event.target || this._event.srcElement;
     },
 
     _relatedTarget: null,
     /** @id MochiKit.Signal.Event.prototype.relatedTarget */
     relatedTarget: function () {
         if (this._relatedTarget !== null) {
             return this._relatedTarget;
         }
 
         var elem = null;
         if (this.type() == 'mouseover' || this.type() == 'mouseenter') {
             elem = (this._event.relatedTarget ||
                 this._event.fromElement);
         } else if (this.type() == 'mouseout' || this.type() == 'mouseleave') {
             elem = (this._event.relatedTarget ||
                 this._event.toElement);
         }
         try {
             if (elem !== null && elem.nodeType !== null) {
                 this._relatedTarget = elem;
                 return elem;
             }
         } catch (ignore) {
             // Firefox 3 throws a permission denied error when accessing
             // any property on XUL elements (e.g. scrollbars)...
         }
 
         return undefined;
     },
 
     _modifier: null,
     /** @id MochiKit.Signal.Event.prototype.modifier */
     modifier: function () {
         if (this._modifier !== null) {
             return this._modifier;
         }
         var m = {};
         m.alt = this._event.altKey;
         m.ctrl = this._event.ctrlKey;
         m.meta = this._event.metaKey || false; // IE and Opera punt here
         m.shift = this._event.shiftKey;
         m.any = m.alt || m.ctrl || m.shift || m.meta;
         this._modifier = m;
         return m;
     },
 
     _key: null,
     /** @id MochiKit.Signal.Event.prototype.key */
     key: function () {
         if (this._key !== null) {
             return this._key;
         }
         var k = {};
         if (this.type() && this.type().indexOf('key') === 0) {
 
             /*
 
                 If you're looking for a special key, look for it in keydown or
                 keyup, but never keypress. If you're looking for a Unicode
                 chracter, look for it with keypress, but never keyup or
                 keydown.
 
                 Notes:
 
                 FF key event behavior:
                 key     event   charCode    keyCode
                 DOWN    ku,kd   0           40
                 DOWN    kp      0           40
                 ESC     ku,kd   0           27
                 ESC     kp      0           27
                 a       ku,kd   0           65
                 a       kp      97          0
                 shift+a ku,kd   0           65
                 shift+a kp      65          0
                 1       ku,kd   0           49
                 1       kp      49          0
                 shift+1 ku,kd   0           0
                 shift+1 kp      33          0
 
                 IE key event behavior:
                 (IE doesn't fire keypress events for special keys.)
                 key     event   keyCode
                 DOWN    ku,kd   40
                 DOWN    kp      undefined
                 ESC     ku,kd   27
                 ESC     kp      27
                 a       ku,kd   65
                 a       kp      97
                 shift+a ku,kd   65
                 shift+a kp      65
                 1       ku,kd   49
                 1       kp      49
                 shift+1 ku,kd   49
                 shift+1 kp      33
 
                 Safari key event behavior:
                 (Safari sets charCode and keyCode to something crazy for
                 special keys.)
                 key     event   charCode    keyCode
                 DOWN    ku,kd   63233       40
                 DOWN    kp      63233       63233
                 ESC     ku,kd   27          27
                 ESC     kp      27          27
                 a       ku,kd   97          65
                 a       kp      97          97
                 shift+a ku,kd   65          65
                 shift+a kp      65          65
                 1       ku,kd   49          49
                 1       kp      49          49
                 shift+1 ku,kd   33          49
                 shift+1 kp      33          33
 
             */
 
             /* look for special keys here */
             if (this.type() == 'keydown' || this.type() == 'keyup') {
                 k.code = this._event.keyCode;
                 k.string = (MochiKit.Signal._specialKeys[k.code] ||
                     'KEY_UNKNOWN');
                 this._key = k;
                 return k;
 
             /* look for characters here */
             } else if (this.type() == 'keypress') {
 
                 /*
 
                     Special key behavior:
 
                     IE: does not fire keypress events for special keys
                     FF: sets charCode to 0, and sets the correct keyCode
                     Safari: sets keyCode and charCode to something stupid
 
                 */
 
                 k.code = 0;
                 k.string = '';
 
                 if (typeof(this._event.charCode) != 'undefined' &&
                     this._event.charCode !== 0 &&
                     !MochiKit.Signal._specialMacKeys[this._event.charCode]) {
                     k.code = this._event.charCode;
                     k.string = String.fromCharCode(k.code);
                 } else if (this._event.keyCode &&
                     typeof(this._event.charCode) == 'undefined') { // IE
                     k.code = this._event.keyCode;
                     k.string = String.fromCharCode(k.code);
                 }
 
                 this._key = k;
                 return k;
             }
         }
         return undefined;
     },
 
     _mouse: null,
     /** @id MochiKit.Signal.Event.prototype.mouse */
     mouse: function () {
         if (this._mouse !== null) {
             return this._mouse;
         }
 
         var m = {};
         var e = this._event;
 
         if (this.type() && (
             this.type().indexOf('mouse') === 0 ||
+            this.type().indexOf('drag') === 0 ||
             this.type().indexOf('click') != -1 ||
             this.type() == 'contextmenu')) {
 
-            m.client = new MochiKit.Style.Coordinates(0, 0);
+            m.client = { x: 0, y: 0 };
             if (e.clientX || e.clientY) {
                 m.client.x = (!e.clientX || e.clientX < 0) ? 0 : e.clientX;
                 m.client.y = (!e.clientY || e.clientY < 0) ? 0 : e.clientY;
             }
 
-            m.page = new MochiKit.Style.Coordinates(0, 0);
+            m.page = { x: 0, y: 0 };
             if (e.pageX || e.pageY) {
                 m.page.x = (!e.pageX || e.pageX < 0) ? 0 : e.pageX;
                 m.page.y = (!e.pageY || e.pageY < 0) ? 0 : e.pageY;
             } else {
                 /*
 
                     The IE shortcut can be off by two. We fix it. See:
                     http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/getboundingclientrect.asp
 
                     This is similar to the method used in
                     MochiKit.Style.getElementPosition().
 
                 */
                 var de = MochiKit.DOM._document.documentElement;
                 var b = MochiKit.DOM._document.body;
 
                 m.page.x = e.clientX +
                     (de.scrollLeft || b.scrollLeft) -
                     (de.clientLeft || 0);
 
                 m.page.y = e.clientY +
                     (de.scrollTop || b.scrollTop) -
                     (de.clientTop || 0);
 
             }
             if (this.type() != 'mousemove' && this.type() != 'mousewheel') {
                 m.button = {};
                 m.button.left = false;
                 m.button.right = false;
                 m.button.middle = false;
 
                 /* we could check e.button, but which is more consistent */
                 if (e.which) {
                     m.button.left = (e.which == 1);
                     m.button.middle = (e.which == 2);
                     m.button.right = (e.which == 3);
 
                     /*
 
                         Mac browsers and right click:
 
                             - Safari doesn't fire any click events on a right
                               click:
                               http://bugs.webkit.org/show_bug.cgi?id=6595
 
                             - Firefox fires the event, and sets ctrlKey = true
 
                             - Opera fires the event, and sets metaKey = true
 
                         oncontextmenu is fired on right clicks between
                         browsers and across platforms.
 
                     */
 
                 } else {
                     m.button.left = !!(e.button & 1);
                     m.button.right = !!(e.button & 2);
                     m.button.middle = !!(e.button & 4);
                 }
             }
             if (this.type() == 'mousewheel') {
-                m.wheel = new MochiKit.Style.Coordinates(0, 0);
+                m.wheel = { x: 0, y: 0 };
                 if (e.wheelDeltaX || e.wheelDeltaY) {
                     m.wheel.x = e.wheelDeltaX / -40 || 0;
                     m.wheel.y = e.wheelDeltaY / -40 || 0;
                 } else if (e.wheelDelta) {
                     m.wheel.y = e.wheelDelta / -40;
                 } else {
                     m.wheel.y = e.detail || 0;
                 }
             }
             this._mouse = m;
             return m;
         }
         return undefined;
     },
 
     /** @id MochiKit.Signal.Event.prototype.stop */
     stop: function () {
         this.stopPropagation();
         this.preventDefault();
     },
 
     /** @id MochiKit.Signal.Event.prototype.stopPropagation */
     stopPropagation: function () {
         if (this._event.stopPropagation) {
             this._event.stopPropagation();
         } else {
             this._event.cancelBubble = true;
         }
     },
 
     /** @id MochiKit.Signal.Event.prototype.preventDefault */
     preventDefault: function () {
         if (this._event.preventDefault) {
             this._event.preventDefault();
         } else if (this._confirmUnload === null) {
             this._event.returnValue = false;
         }
     },
 
     _confirmUnload: null,
 
     /** @id MochiKit.Signal.Event.prototype.confirmUnload */
     confirmUnload: function (msg) {
         if (this.type() == 'beforeunload') {
             this._confirmUnload = msg;
             this._event.returnValue = msg;
         }
     }
 });
 
 /* Safari sets keyCode to these special values onkeypress. */
 MochiKit.Signal._specialMacKeys = {
     3: 'KEY_ENTER',
     63289: 'KEY_NUM_PAD_CLEAR',
     63276: 'KEY_PAGE_UP',
     63277: 'KEY_PAGE_DOWN',
     63275: 'KEY_END',
     63273: 'KEY_HOME',
     63234: 'KEY_ARROW_LEFT',
     63232: 'KEY_ARROW_UP',
     63235: 'KEY_ARROW_RIGHT',
     63233: 'KEY_ARROW_DOWN',
     63302: 'KEY_INSERT',
     63272: 'KEY_DELETE'
 };
 
 /* for KEY_F1 - KEY_F12 */
 (function () {
     var _specialMacKeys = MochiKit.Signal._specialMacKeys;
     for (var i = 63236; i <= 63242; i++) {
         // no F0
         _specialMacKeys[i] = 'KEY_F' + (i - 63236 + 1);
     }
 })();
 
 /* Standard keyboard key codes. */
 MochiKit.Signal._specialKeys = {
     8: 'KEY_BACKSPACE',
     9: 'KEY_TAB',
     12: 'KEY_NUM_PAD_CLEAR', // weird, for Safari and Mac FF only
     13: 'KEY_ENTER',
     16: 'KEY_SHIFT',
     17: 'KEY_CTRL',
     18: 'KEY_ALT',
     19: 'KEY_PAUSE',
     20: 'KEY_CAPS_LOCK',
     27: 'KEY_ESCAPE',
     32: 'KEY_SPACEBAR',
     33: 'KEY_PAGE_UP',
     34: 'KEY_PAGE_DOWN',
     35: 'KEY_END',
     36: 'KEY_HOME',
     37: 'KEY_ARROW_LEFT',
     38: 'KEY_ARROW_UP',
     39: 'KEY_ARROW_RIGHT',
     40: 'KEY_ARROW_DOWN',
     44: 'KEY_PRINT_SCREEN',
     45: 'KEY_INSERT',
     46: 'KEY_DELETE',
     59: 'KEY_SEMICOLON', // weird, for Safari and IE only
     91: 'KEY_WINDOWS_LEFT',
     92: 'KEY_WINDOWS_RIGHT',
     93: 'KEY_SELECT',
     106: 'KEY_NUM_PAD_ASTERISK',
     107: 'KEY_NUM_PAD_PLUS_SIGN',
     109: 'KEY_NUM_PAD_HYPHEN-MINUS',
     110: 'KEY_NUM_PAD_FULL_STOP',
     111: 'KEY_NUM_PAD_SOLIDUS',
     144: 'KEY_NUM_LOCK',
     145: 'KEY_SCROLL_LOCK',
     186: 'KEY_SEMICOLON',
     187: 'KEY_EQUALS_SIGN',
     188: 'KEY_COMMA',
     189: 'KEY_HYPHEN-MINUS',
     190: 'KEY_FULL_STOP',
     191: 'KEY_SOLIDUS',
     192: 'KEY_GRAVE_ACCENT',
     219: 'KEY_LEFT_SQUARE_BRACKET',
     220: 'KEY_REVERSE_SOLIDUS',
     221: 'KEY_RIGHT_SQUARE_BRACKET',
     222: 'KEY_APOSTROPHE'
     // undefined: 'KEY_UNKNOWN'
 };
 
 (function () {
     /* for KEY_0 - KEY_9 */
     var _specialKeys = MochiKit.Signal._specialKeys;
     for (var i = 48; i <= 57; i++) {
         _specialKeys[i] = 'KEY_' + (i - 48);
     }
 
     /* for KEY_A - KEY_Z */
     for (i = 65; i <= 90; i++) {
         _specialKeys[i] = 'KEY_' + String.fromCharCode(i);
     }
 
     /* for KEY_NUM_PAD_0 - KEY_NUM_PAD_9 */
     for (i = 96; i <= 105; i++) {
         _specialKeys[i] = 'KEY_NUM_PAD_' + (i - 96);
     }
 
     /* for KEY_F1 - KEY_F12 */
     for (i = 112; i <= 123; i++) {
         // no F0
         _specialKeys[i] = 'KEY_F' + (i - 112 + 1);
     }
 })();
 
 /* Internal object to keep track of created signals. */
 MochiKit.Signal.Ident = function (ident) {
     this.source = ident.source;
     this.signal = ident.signal;
     this.listener = ident.listener;
     this.isDOM = ident.isDOM;
     this.objOrFunc = ident.objOrFunc;
     this.funcOrStr = ident.funcOrStr;
     this.connected = ident.connected;
 };
 MochiKit.Signal.Ident.__export__ = false;
 MochiKit.Signal.Ident.prototype = {};
 
 MochiKit.Base.update(MochiKit.Signal, {
 
     _unloadCache: function () {
         var self = MochiKit.Signal;
         var observers = self._observers;
 
         for (var i = 0; i < observers.length; i++) {
             if (observers[i].signal !== 'onload' && observers[i].signal !== 'onunload') {
                 self._disconnect(observers[i]);
             }
         }
     },
 
     _listener: function (src, sig, func, obj, isDOM) {
         var self = MochiKit.Signal;
         var E = self.Event;
         if (!isDOM) {
             /* We don't want to re-bind already bound methods */
             if (typeof(func.im_self) == 'undefined') {
                 return MochiKit.Base.bindLate(func, obj);
             } else {
                 return func;
             }
         }
         obj = obj || src;
         if (typeof(func) == "string") {
             if (sig === 'onload' || sig === 'onunload') {
                 return function (nativeEvent) {
                     obj[func].apply(obj, [new E(src, nativeEvent)]);
                     
                     var ident = new MochiKit.Signal.Ident({
                         source: src, signal: sig, objOrFunc: obj, funcOrStr: func});
                     
                     MochiKit.Signal._disconnect(ident);
                 };
             } else {
                 return function (nativeEvent) {
                     obj[func].apply(obj, [new E(src, nativeEvent)]);
                 };
             }
         } else {
             if (sig === 'onload' || sig === 'onunload') {
                 return function (nativeEvent) {
                     func.apply(obj, [new E(src, nativeEvent)]);
                     
                     var ident = new MochiKit.Signal.Ident({
                         source: src, signal: sig, objOrFunc: func});
                     
                     MochiKit.Signal._disconnect(ident);
                 };
             } else {
                 return function (nativeEvent) {
                     func.apply(obj, [new E(src, nativeEvent)]);
                 };
             }
         }
     },
 
     _browserAlreadyHasMouseEnterAndLeave: function () {
         return /MSIE/.test(navigator.userAgent);
     },
 
     _browserLacksMouseWheelEvent: function () {
         return /Gecko\//.test(navigator.userAgent);
     },
 
     _mouseEnterListener: function (src, sig, func, obj) {
         var E = MochiKit.Signal.Event;
         return function (nativeEvent) {
             var e = new E(src, nativeEvent);
             try {
                 e.relatedTarget().nodeName;
             } catch (err) {
                 /* probably hit a permission denied error; possibly one of
                  * firefox's screwy anonymous DIVs inside an input element.
                  * Allow this event to propogate up.
                  */
                 return;
             }
             e.stop();
             if (MochiKit.DOM.isChildNode(e.relatedTarget(), src)) {
                 /* We've moved between our node and a child. Ignore. */
                 return;
             }
             e.type = function () { return sig; };
             if (typeof(func) == "string") {
                 return obj[func].apply(obj, [e]);
             } else {
                 return func.apply(obj, [e]);
             }
         };
     },
 
     _getDestPair: function (objOrFunc, funcOrStr) {
         var obj = null;
         var func = null;
         if (typeof(funcOrStr) != 'undefined') {
             obj = objOrFunc;
             func = funcOrStr;
             if (typeof(funcOrStr) == 'string') {
                 if (typeof(objOrFunc[funcOrStr]) != "function") {
                     throw new Error("'funcOrStr' must be a function on 'objOrFunc'");
                 }
             } else if (typeof(funcOrStr) != 'function') {
                 throw new Error("'funcOrStr' must be a function or string");
             }
         } else if (typeof(objOrFunc) != "function") {
             throw new Error("'objOrFunc' must be a function if 'funcOrStr' is not given");
         } else {
             func = objOrFunc;
         }
         return [obj, func];
     },
 
     /** @id MochiKit.Signal.connect */
     connect: function (src, sig, objOrFunc/* optional */, funcOrStr) {
         if (typeof(src) == "string") {
             src = MochiKit.DOM.getElement(src);
         }
         var self = MochiKit.Signal;
 
         if (typeof(sig) != 'string') {
             throw new Error("'sig' must be a string");
         }
 
         var destPair = self._getDestPair(objOrFunc, funcOrStr);
         var obj = destPair[0];
         var func = destPair[1];
         if (typeof(obj) == 'undefined' || obj === null) {
             obj = src;
         }
 
         var isDOM = !!(src.addEventListener || src.attachEvent);
         if (isDOM && (sig === "onmouseenter" || sig === "onmouseleave")
                   && !self._browserAlreadyHasMouseEnterAndLeave()) {
             var listener = self._mouseEnterListener(src, sig.substr(2), func, obj);
             if (sig === "onmouseenter") {
                 sig = "onmouseover";
             } else {
                 sig = "onmouseout";
             }
         } else if (isDOM && sig == "onmousewheel" && self._browserLacksMouseWheelEvent()) {
             var listener = self._listener(src, sig, func, obj, isDOM);
             sig = "onDOMMouseScroll";
         } else {
             var listener = self._listener(src, sig, func, obj, isDOM);
         }
 
         if (src.addEventListener) {
             src.addEventListener(sig.substr(2), listener, false);
         } else if (src.attachEvent) {
             src.attachEvent(sig, listener); // useCapture unsupported
         }
 
         var ident = new MochiKit.Signal.Ident({
             source: src, 
             signal: sig, 
             listener: listener, 
             isDOM: isDOM, 
             objOrFunc: objOrFunc, 
             funcOrStr: funcOrStr, 
             connected: true
         });
         self._observers.push(ident);
 
         if (!isDOM && typeof(src.__connect__) == 'function') {
             var args = MochiKit.Base.extend([ident], arguments, 1);
             src.__connect__.apply(src, args);
         }
 
         return ident;
     },
 
+    /** @id MochiKit.Signal.connectOnce */
+    connectOnce: function (src, sig, objOrFunc/* optional */, funcOrStr) {
+        var self = MochiKit.Signal;
+        var ident1 = self.connect(src, sig, objOrFunc, funcOrStr);
+        var ident2;
+        ident2 = self.connect(src, sig, function() {
+            self.disconnect(ident1);
+            self.disconnect(ident2);
+        });
+        return ident1;
+    },
+
     _disconnect: function (ident) {
         // already disconnected
         if (!ident.connected) {
             return;
         }
         ident.connected = false;
         var src = ident.source;
         var sig = ident.signal;
         var listener = ident.listener;
         // check isDOM
         if (!ident.isDOM) {
             if (typeof(src.__disconnect__) == 'function') {
                 src.__disconnect__(ident, sig, ident.objOrFunc, ident.funcOrStr);
             }
             return;
         }
         if (src.removeEventListener) {
             src.removeEventListener(sig.substr(2), listener, false);
         } else if (src.detachEvent) {
             src.detachEvent(sig, listener); // useCapture unsupported
         } else {
             throw new Error("'src' must be a DOM element");
         }
     },
 
      /** @id MochiKit.Signal.disconnect */
     disconnect: function (ident) {
         var self = MochiKit.Signal;
         var observers = self._observers;
         var m = MochiKit.Base;
         if (arguments.length > 1) {
             // compatibility API
             var src = arguments[0];
             if (typeof(src) == "string") {
                 src = MochiKit.DOM.getElement(src);
             }
             var sig = arguments[1];
             var obj = arguments[2];
             var func = arguments[3];
             for (var i = observers.length - 1; i >= 0; i--) {
                 var o = observers[i];
                 if (o.source === src && o.signal === sig && o.objOrFunc === obj && o.funcOrStr === func) {
                     self._disconnect(o);
-                    if (!self._lock) {
+                    if (self._lock === 0) {
                         observers.splice(i, 1);
                     } else {
                         self._dirty = true;
                     }
                     return true;
                 }
             }
         } else {
             var idx = m.findIdentical(observers, ident);
             if (idx >= 0) {
                 self._disconnect(ident);
-                if (!self._lock) {
+                if (self._lock === 0) {
                     observers.splice(idx, 1);
                 } else {
                     self._dirty = true;
                 }
                 return true;
             }
         }
         return false;
     },
 
     /** @id MochiKit.Signal.disconnectAllTo */
     disconnectAllTo: function (objOrFunc, /* optional */funcOrStr) {
         var self = MochiKit.Signal;
         var observers = self._observers;
         var disconnect = self._disconnect;
-        var locked = self._lock;
+        var lock = self._lock;
         var dirty = self._dirty;
         if (typeof(funcOrStr) === 'undefined') {
             funcOrStr = null;
         }
         for (var i = observers.length - 1; i >= 0; i--) {
             var ident = observers[i];
             if (ident.objOrFunc === objOrFunc &&
                     (funcOrStr === null || ident.funcOrStr === funcOrStr)) {
                 disconnect(ident);
-                if (locked) {
-                    dirty = true;
-                } else {
+                if (lock === 0) {
                     observers.splice(i, 1);
+                } else {
+                    dirty = true;
                 }
             }
         }
         self._dirty = dirty;
     },
 
     /** @id MochiKit.Signal.disconnectAll */
     disconnectAll: function (src/* optional */, sig) {
         if (typeof(src) == "string") {
             src = MochiKit.DOM.getElement(src);
         }
         var m = MochiKit.Base;
         var signals = m.flattenArguments(m.extend(null, arguments, 1));
         var self = MochiKit.Signal;
         var disconnect = self._disconnect;
         var observers = self._observers;
         var i, ident;
-        var locked = self._lock;
+        var lock = self._lock;
         var dirty = self._dirty;
         if (signals.length === 0) {
             // disconnect all
             for (i = observers.length - 1; i >= 0; i--) {
                 ident = observers[i];
                 if (ident.source === src) {
                     disconnect(ident);
-                    if (!locked) {
+                    if (lock === 0) {
                         observers.splice(i, 1);
                     } else {
                         dirty = true;
                     }
                 }
             }
         } else {
             var sigs = {};
             for (i = 0; i < signals.length; i++) {
                 sigs[signals[i]] = true;
             }
             for (i = observers.length - 1; i >= 0; i--) {
                 ident = observers[i];
                 if (ident.source === src && ident.signal in sigs) {
                     disconnect(ident);
-                    if (!locked) {
+                    if (lock === 0) {
                         observers.splice(i, 1);
                     } else {
                         dirty = true;
                     }
                 }
             }
         }
         self._dirty = dirty;
     },
 
     /** @id MochiKit.Signal.signal */
     signal: function (src, sig) {
         var self = MochiKit.Signal;
         var observers = self._observers;
         if (typeof(src) == "string") {
             src = MochiKit.DOM.getElement(src);
         }
         var args = MochiKit.Base.extend(null, arguments, 2);
         var errors = [];
-        self._lock = true;
+        self._lock++;
         for (var i = 0; i < observers.length; i++) {
             var ident = observers[i];
             if (ident.source === src && ident.signal === sig &&
                     ident.connected) {
                 try {
                     if (ident.isDOM && ident.funcOrStr != null) {
                         var obj = ident.objOrFunc;
                         obj[ident.funcOrStr].apply(obj, args);
                     } else if (ident.isDOM) {
                         ident.objOrFunc.apply(src, args);
                     } else {
                         ident.listener.apply(src, args);
                     }
                 } catch (e) {
                     errors.push(e);
                 }
             }
         }
-        self._lock = false;
-        if (self._dirty) {
+        self._lock--;
+        if (self._lock === 0 && self._dirty) {
             self._dirty = false;
             for (var i = observers.length - 1; i >= 0; i--) {
                 if (!observers[i].connected) {
                     observers.splice(i, 1);
                 }
             }
         }
         if (errors.length == 1) {
             throw errors[0];
         } else if (errors.length > 1) {
             var e = new Error("Multiple errors thrown in handling 'sig', see errors property");
             e.errors = errors;
             throw e;
         }
     }
 
 });
 
 MochiKit.Signal.__new__ = function (win) {
     var m = MochiKit.Base;
     this._document = document;
     this._window = win;
-    this._lock = false;
+    this._lock = 0;
     this._dirty = false;
 
     try {
         this.connect(window, 'onunload', this._unloadCache);
     } catch (e) {
         // pass: might not be a browser
     }
 
     m.nameFunctions(this);
 };
 
 MochiKit.Signal.__new__(this);
 
 //
 // XXX: Internet Explorer blows
 //
 if (MochiKit.__export__) {
     connect = MochiKit.Signal.connect;
     disconnect = MochiKit.Signal.disconnect;
     disconnectAll = MochiKit.Signal.disconnectAll;
     signal = MochiKit.Signal.signal;
 }
 
 MochiKit.Base._exportSymbols(this, MochiKit.Signal);
diff --git a/frontend/gamma/js/MochiKit/Sortable.js b/frontend/gamma/js/MochiKit/Sortable.js
index 863b506..ca9db21 100644
--- a/frontend/gamma/js/MochiKit/Sortable.js
+++ b/frontend/gamma/js/MochiKit/Sortable.js
@@ -1,569 +1,569 @@
 /***
 Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
     Mochi-ized By Thomas Herve (_firstname_@nimail.org)
 
 See scriptaculous.js for full license.
 
 ***/
 
-MochiKit.Base._module('Sortable', '1.5', ['Base', 'Iter', 'DOM', 'Position', 'DragAndDrop']);
+MochiKit.Base.module(MochiKit, 'Sortable', '1.5', ['Base', 'Iter', 'DOM', 'Position', 'DragAndDrop']);
 
 MochiKit.Base.update(MochiKit.Sortable, {
     __export__: false,
 
     /***
 
     Manage sortables. Mainly use the create function to add a sortable.
 
     ***/
     sortables: {},
 
     _findRootElement: function (element) {
         while (element.tagName.toUpperCase() != "BODY") {
             if (element.id && MochiKit.Sortable.sortables[element.id]) {
                 return element;
             }
             element = element.parentNode;
         }
     },
 
     _createElementId: function(element) {
         if (element.id == null || element.id == "") {
             var d = MochiKit.DOM;
             var id;
             var count = 1;
             while (d.getElement(id = "sortable" + count) != null) {
                 count += 1;
             }
             d.setNodeAttribute(element, "id", id);
         }
     },
 
     /** @id MochiKit.Sortable.options */
     options: function (element) {
         element = MochiKit.Sortable._findRootElement(MochiKit.DOM.getElement(element));
         if (!element) {
             return;
         }
         return MochiKit.Sortable.sortables[element.id];
     },
 
     /** @id MochiKit.Sortable.destroy */
     destroy: function (element){
         var s = MochiKit.Sortable.options(element);
         var b = MochiKit.Base;
         var d = MochiKit.DragAndDrop;
 
         if (s) {
             MochiKit.Signal.disconnect(s.startHandle);
             MochiKit.Signal.disconnect(s.endHandle);
             b.map(function (dr) {
                 d.Droppables.remove(dr);
             }, s.droppables);
             b.map(function (dr) {
                 dr.destroy();
             }, s.draggables);
 
             delete MochiKit.Sortable.sortables[s.element.id];
         }
     },
 
     /** @id MochiKit.Sortable.create */
     create: function (element, options) {
         element = MochiKit.DOM.getElement(element);
         var self = MochiKit.Sortable;
         self._createElementId(element);
 
         /** @id MochiKit.Sortable.options */
         options = MochiKit.Base.update({
 
             /** @id MochiKit.Sortable.element */
             element: element,
 
             /** @id MochiKit.Sortable.tag */
             tag: 'li',  // assumes li children, override with tag: 'tagname'
 
             /** @id MochiKit.Sortable.dropOnEmpty */
             dropOnEmpty: false,
 
             /** @id MochiKit.Sortable.tree */
             tree: false,
 
             /** @id MochiKit.Sortable.treeTag */
             treeTag: 'ul',
 
             /** @id MochiKit.Sortable.overlap */
             overlap: 'vertical',  // one of 'vertical', 'horizontal'
 
             /** @id MochiKit.Sortable.constraint */
             constraint: 'vertical',  // one of 'vertical', 'horizontal', false
             // also takes array of elements (or ids); or false
 
             /** @id MochiKit.Sortable.containment */
             containment: [element],
 
             /** @id MochiKit.Sortable.handle */
             handle: false,  // or a CSS class
 
             /** @id MochiKit.Sortable.only */
             only: false,
 
             /** @id MochiKit.Sortable.hoverclass */
             hoverclass: null,
 
             /** @id MochiKit.Sortable.ghosting */
             ghosting: false,
 
             /** @id MochiKit.Sortable.scroll */
             scroll: false,
 
             /** @id MochiKit.Sortable.scrollSensitivity */
             scrollSensitivity: 20,
 
             /** @id MochiKit.Sortable.scrollSpeed */
             scrollSpeed: 15,
 
             /** @id MochiKit.Sortable.format */
             format: /^[^_]*_(.*)$/,
 
             /** @id MochiKit.Sortable.onChange */
             onChange: MochiKit.Base.noop,
 
             /** @id MochiKit.Sortable.onUpdate */
             onUpdate: MochiKit.Base.noop,
 
             /** @id MochiKit.Sortable.accept */
             accept: null
         }, options);
 
         // clear any old sortable with same element
         self.destroy(element);
 
         // build options for the draggables
         var options_for_draggable = {
             revert: true,
             ghosting: options.ghosting,
             scroll: options.scroll,
             scrollSensitivity: options.scrollSensitivity,
             scrollSpeed: options.scrollSpeed,
             constraint: options.constraint,
             handle: options.handle
         };
 
         if (options.starteffect) {
             options_for_draggable.starteffect = options.starteffect;
         }
 
         if (options.reverteffect) {
             options_for_draggable.reverteffect = options.reverteffect;
         } else if (options.ghosting) {
             options_for_draggable.reverteffect = function (innerelement) {
                 innerelement.style.top = 0;
                 innerelement.style.left = 0;
             };
         }
 
         if (options.endeffect) {
             options_for_draggable.endeffect = options.endeffect;
         }
 
         if (options.zindex) {
             options_for_draggable.zindex = options.zindex;
         }
 
         // build options for the droppables
         var options_for_droppable = {
             overlap: options.overlap,
             containment: options.containment,
             hoverclass: options.hoverclass,
             onhover: self.onHover,
             tree: options.tree,
             accept: options.accept
-        }
+        };
 
         var options_for_tree = {
             onhover: self.onEmptyHover,
             overlap: options.overlap,
             containment: options.containment,
             hoverclass: options.hoverclass,
             accept: options.accept
-        }
+        };
 
         // fix for gecko engine
         MochiKit.DOM.removeEmptyTextNodes(element);
 
         options.draggables = [];
         options.droppables = [];
 
         // drop on empty handling
         if (options.dropOnEmpty || options.tree) {
             new MochiKit.DragAndDrop.Droppable(element, options_for_tree);
             options.droppables.push(element);
         }
         MochiKit.Base.map(function (e) {
             // handles are per-draggable
             var handle = options.handle ?
                 MochiKit.DOM.getFirstElementByTagAndClassName(null,
                     options.handle, e) : e;
             options.draggables.push(
                 new MochiKit.DragAndDrop.Draggable(e,
                     MochiKit.Base.update(options_for_draggable,
                                          {handle: handle})));
             new MochiKit.DragAndDrop.Droppable(e, options_for_droppable);
             if (options.tree) {
                 e.treeNode = element;
             }
             options.droppables.push(e);
         }, (self.findElements(element, options) || []));
 
         if (options.tree) {
             MochiKit.Base.map(function (e) {
                 new MochiKit.DragAndDrop.Droppable(e, options_for_tree);
                 e.treeNode = element;
                 options.droppables.push(e);
             }, (self.findTreeElements(element, options) || []));
         }
 
         // keep reference
         self.sortables[element.id] = options;
 
         options.lastValue = self.serialize(element);
         options.startHandle = MochiKit.Signal.connect(MochiKit.DragAndDrop.Draggables, 'start',
                                 MochiKit.Base.partial(self.onStart, element));
         options.endHandle = MochiKit.Signal.connect(MochiKit.DragAndDrop.Draggables, 'end',
                                 MochiKit.Base.partial(self.onEnd, element));
     },
 
     /** @id MochiKit.Sortable.onStart */
     onStart: function (element, draggable) {
         var self = MochiKit.Sortable;
         var options = self.options(element);
         options.lastValue = self.serialize(options.element);
     },
 
     /** @id MochiKit.Sortable.onEnd */
     onEnd: function (element, draggable) {
         var self = MochiKit.Sortable;
         self.unmark();
         var options = self.options(element);
         if (options.lastValue != self.serialize(options.element)) {
             options.onUpdate(options.element);
         }
     },
 
     // return all suitable-for-sortable elements in a guaranteed order
 
     /** @id MochiKit.Sortable.findElements */
     findElements: function (element, options) {
         return MochiKit.Sortable.findChildren(element, options.only, options.tree, options.tag);
     },
 
     /** @id MochiKit.Sortable.findTreeElements */
     findTreeElements: function (element, options) {
         return MochiKit.Sortable.findChildren(
             element, options.only, options.tree ? true : false, options.treeTag);
     },
 
     /** @id MochiKit.Sortable.findChildren */
     findChildren: function (element, only, recursive, tagName) {
         if (!element.hasChildNodes()) {
             return null;
         }
         tagName = tagName.toUpperCase();
         if (only) {
             only = MochiKit.Base.flattenArray([only]);
         }
         var elements = [];
         MochiKit.Base.map(function (e) {
             if (e.tagName &&
                 e.tagName.toUpperCase() == tagName &&
                (!only ||
                 MochiKit.Iter.some(only, function (c) {
                     return MochiKit.DOM.hasElementClass(e, c);
                 }))) {
                 elements.push(e);
             }
             if (recursive) {
                 var grandchildren = MochiKit.Sortable.findChildren(e, only, recursive, tagName);
                 if (grandchildren && grandchildren.length > 0) {
                     elements = elements.concat(grandchildren);
                 }
             }
         }, element.childNodes);
         return elements;
     },
 
     /** @id MochiKit.Sortable.onHover */
     onHover: function (element, dropon, overlap) {
         if (MochiKit.DOM.isChildNode(dropon, element)) {
             return;
         }
         var self = MochiKit.Sortable;
 
         if (overlap > .33 && overlap < .66 && self.options(dropon).tree) {
             return;
         } else if (overlap > 0.5) {
             self.mark(dropon, 'before');
             if (dropon.previousSibling != element) {
                 var oldParentNode = element.parentNode;
                 element.style.visibility = 'hidden';  // fix gecko rendering
                 dropon.parentNode.insertBefore(element, dropon);
                 if (dropon.parentNode != oldParentNode) {
                     self.options(oldParentNode).onChange(element);
                 }
                 self.options(dropon.parentNode).onChange(element);
             }
         } else {
             self.mark(dropon, 'after');
             var nextElement = dropon.nextSibling || null;
             if (nextElement != element) {
                 var oldParentNode = element.parentNode;
                 element.style.visibility = 'hidden';  // fix gecko rendering
                 dropon.parentNode.insertBefore(element, nextElement);
                 if (dropon.parentNode != oldParentNode) {
                     self.options(oldParentNode).onChange(element);
                 }
                 self.options(dropon.parentNode).onChange(element);
             }
         }
     },
 
     _offsetSize: function (element, type) {
         if (type == 'vertical' || type == 'height') {
             return element.offsetHeight;
         } else {
             return element.offsetWidth;
         }
     },
 
     /** @id MochiKit.Sortable.onEmptyHover */
     onEmptyHover: function (element, dropon, overlap) {
         var oldParentNode = element.parentNode;
         var self = MochiKit.Sortable;
         var droponOptions = self.options(dropon);
 
         if (!MochiKit.DOM.isChildNode(dropon, element)) {
             var index;
 
             var children = self.findElements(dropon, {tag: droponOptions.tag,
                                                       only: droponOptions.only});
             var child = null;
 
             if (children) {
                 var offset = self._offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
 
                 for (index = 0; index < children.length; index += 1) {
                     if (offset - self._offsetSize(children[index], droponOptions.overlap) >= 0) {
                         offset -= self._offsetSize(children[index], droponOptions.overlap);
                     } else if (offset - (self._offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
                         child = index + 1 < children.length ? children[index + 1] : null;
                         break;
                     } else {
                         child = children[index];
                         break;
                     }
                 }
             }
 
             dropon.insertBefore(element, child);
 
             self.options(oldParentNode).onChange(element);
             droponOptions.onChange(element);
         }
     },
 
     /** @id MochiKit.Sortable.unmark */
     unmark: function () {
         var m = MochiKit.Sortable._marker;
         if (m) {
             MochiKit.Style.hideElement(m);
         }
     },
 
     /** @id MochiKit.Sortable.mark */
     mark: function (dropon, position) {
         // mark on ghosting only
         var d = MochiKit.DOM;
         var self = MochiKit.Sortable;
         var sortable = self.options(dropon.parentNode);
         if (sortable && !sortable.ghosting) {
             return;
         }
 
         if (!self._marker) {
             self._marker = d.getElement('dropmarker') ||
                         document.createElement('DIV');
             MochiKit.Style.hideElement(self._marker);
             d.addElementClass(self._marker, 'dropmarker');
             self._marker.style.position = 'absolute';
             document.getElementsByTagName('body').item(0).appendChild(self._marker);
         }
         var offsets = MochiKit.Position.cumulativeOffset(dropon);
         self._marker.style.left = offsets.x + 'px';
         self._marker.style.top = offsets.y + 'px';
 
         if (position == 'after') {
             if (sortable.overlap == 'horizontal') {
                 self._marker.style.left = (offsets.x + dropon.clientWidth) + 'px';
             } else {
                 self._marker.style.top = (offsets.y + dropon.clientHeight) + 'px';
             }
         }
         MochiKit.Style.showElement(self._marker);
     },
 
     _tree: function (element, options, parent) {
         var self = MochiKit.Sortable;
         var children = self.findElements(element, options) || [];
 
         for (var i = 0; i < children.length; ++i) {
             var match = children[i].id.match(options.format);
 
             if (!match) {
                 continue;
             }
 
             var child = {
                 id: encodeURIComponent(match ? match[1] : null),
                 element: element,
                 parent: parent,
                 children: [],
                 position: parent.children.length,
                 container: self._findChildrenElement(children[i], options.treeTag.toUpperCase())
-            }
+            };
 
             /* Get the element containing the children and recurse over it */
             if (child.container) {
-                self._tree(child.container, options, child)
+                self._tree(child.container, options, child);
             }
 
             parent.children.push (child);
         }
 
         return parent;
     },
 
     /* Finds the first element of the given tag type within a parent element.
        Used for finding the first LI[ST] within a L[IST]I[TEM].*/
     _findChildrenElement: function (element, containerTag) {
         if (element && element.hasChildNodes) {
             containerTag = containerTag.toUpperCase();
             for (var i = 0; i < element.childNodes.length; ++i) {
                 if (element.childNodes[i].tagName.toUpperCase() == containerTag) {
                     return element.childNodes[i];
                 }
             }
         }
         return null;
     },
 
     /** @id MochiKit.Sortable.tree */
     tree: function (element, options) {
         element = MochiKit.DOM.getElement(element);
         var sortableOptions = MochiKit.Sortable.options(element);
         options = MochiKit.Base.update({
             tag: sortableOptions.tag,
             treeTag: sortableOptions.treeTag,
             only: sortableOptions.only,
             name: element.id,
             format: sortableOptions.format
         }, options || {});
 
         var root = {
             id: null,
             parent: null,
             children: new Array,
             container: element,
             position: 0
-        }
+        };
 
         return MochiKit.Sortable._tree(element, options, root);
     },
 
     /**
      * Specifies the sequence for the Sortable.
      * @param {Node} element    Element to use as the Sortable.
      * @param {Object} newSequence    New sequence to use.
      * @param {Object} options    Options to use fro the Sortable.
      */
     setSequence: function (element, newSequence, options) {
         var self = MochiKit.Sortable;
         var b = MochiKit.Base;
         element = MochiKit.DOM.getElement(element);
         options = b.update(self.options(element), options || {});
 
         var nodeMap = {};
         b.map(function (n) {
             var m = n.id.match(options.format);
             if (m) {
                 nodeMap[m[1]] = [n, n.parentNode];
             }
             n.parentNode.removeChild(n);
         }, self.findElements(element, options));
 
         b.map(function (ident) {
             var n = nodeMap[ident];
             if (n) {
                 n[1].appendChild(n[0]);
                 delete nodeMap[ident];
             }
         }, newSequence);
     },
 
     /* Construct a [i] index for a particular node */
     _constructIndex: function (node) {
         var index = '';
         do {
             if (node.id) {
                 index = '[' + node.position + ']' + index;
             }
         } while ((node = node.parent) != null);
         return index;
     },
 
     /** @id MochiKit.Sortable.sequence */
     sequence: function (element, options) {
         element = MochiKit.DOM.getElement(element);
         var self = MochiKit.Sortable;
         var options = MochiKit.Base.update(self.options(element), options || {});
 
         return MochiKit.Base.map(function (item) {
             return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
         }, MochiKit.DOM.getElement(self.findElements(element, options) || []));
     },
 
     /**
      * Serializes the content of a Sortable. Useful to send this content through a XMLHTTPRequest.
      * These options override the Sortable options for the serialization only.
      * @param {Node} element    Element to serialize.
      * @param {Object} options    Serialization options.
      */
     serialize: function (element, options) {
         element = MochiKit.DOM.getElement(element);
         var self = MochiKit.Sortable;
         options = MochiKit.Base.update(self.options(element), options || {});
         var name = encodeURIComponent(options.name || element.id);
 
         if (options.tree) {
             return MochiKit.Base.flattenArray(MochiKit.Base.map(function (item) {
                 return [name + self._constructIndex(item) + "[id]=" +
                 encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
             }, self.tree(element, options).children)).join('&');
         } else {
             return MochiKit.Base.map(function (item) {
                 return name + "[]=" + encodeURIComponent(item);
             }, self.sequence(element, options)).join('&');
         }
     }
 });
 
 // trunk compatibility
 MochiKit.Sortable.Sortable = MochiKit.Sortable;
 
 MochiKit.Sortable.__new__ = function () {
     MochiKit.Base.nameFunctions(this);
 };
 
 MochiKit.Sortable.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.Sortable);
diff --git a/frontend/gamma/js/MochiKit/Style.js b/frontend/gamma/js/MochiKit/Style.js
index 7f10117..740fd2f 100644
--- a/frontend/gamma/js/MochiKit/Style.js
+++ b/frontend/gamma/js/MochiKit/Style.js
@@ -1,558 +1,561 @@
 /***
 
 MochiKit.Style 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005-2006 Bob Ippolito, Beau Hartshorne.  All rights Reserved.
 
+The MochiKit.Style.getElementPosition function is adapted from
+YAHOO.util.Dom.getXY v0.9.0. which is copyrighted by Yahoo! Inc.
+
 ***/
 
-MochiKit.Base._module('Style', '1.5', ['Base', 'DOM']);
+MochiKit.Base.module(MochiKit, 'Style', '1.5', ['Base', 'DOM']);
 
 
 /** @id MochiKit.Style.Dimensions */
 MochiKit.Style.Dimensions = function (w, h) {
     if (!(this instanceof MochiKit.Style.Dimensions)) {
         return new MochiKit.Style.Dimensions(w, h);
     }
     this.w = w;
     this.h = h;
 };
 
 MochiKit.Style.Dimensions.prototype.__repr__ = function () {
     var repr = MochiKit.Base.repr;
     return '{w: '  + repr(this.w) + ', h: ' + repr(this.h) + '}';
 };
 
 MochiKit.Style.Dimensions.prototype.toString = function () {
     return this.__repr__();
 };
 
 
 /** @id MochiKit.Style.Coordinates */
 MochiKit.Style.Coordinates = function (x, y) {
     if (!(this instanceof MochiKit.Style.Coordinates)) {
         return new MochiKit.Style.Coordinates(x, y);
     }
     this.x = x;
     this.y = y;
 };
 
 MochiKit.Style.Coordinates.prototype.__repr__ = function () {
     var repr = MochiKit.Base.repr;
     return '{x: '  + repr(this.x) + ', y: ' + repr(this.y) + '}';
 };
 
 MochiKit.Style.Coordinates.prototype.toString = function () {
     return this.__repr__();
 };
 
 
 MochiKit.Base.update(MochiKit.Style, {
 
     /** @id MochiKit.Style.getStyle */
     getStyle: function (elem, cssProperty) {
         var dom = MochiKit.DOM;
         var d = dom._document;
 
         elem = dom.getElement(elem);
         cssProperty = MochiKit.Base.camelize(cssProperty);
 
         if (!elem || elem == d) {
             return undefined;
         }
         if (cssProperty == 'opacity' && typeof(elem.filters) != 'undefined') {
             var opacity = (MochiKit.Style.getStyle(elem, 'filter') || '').match(/alpha\(opacity=(.*)\)/);
             if (opacity && opacity[1]) {
                 return parseFloat(opacity[1]) / 100;
             }
             return 1.0;
         }
         if (cssProperty == 'float' || cssProperty == 'cssFloat' || cssProperty == 'styleFloat') {
             if (elem.style["float"]) {
                 return elem.style["float"];
             } else if (elem.style.cssFloat) {
                 return elem.style.cssFloat;
             } else if (elem.style.styleFloat) {
                 return elem.style.styleFloat;
             } else {
                 return "none";
             }
         }
         var value = elem.style ? elem.style[cssProperty] : null;
         if (!value) {
             if (d.defaultView && d.defaultView.getComputedStyle) {
                 var css = d.defaultView.getComputedStyle(elem, null);
                 cssProperty = cssProperty.replace(/([A-Z])/g, '-$1'
                     ).toLowerCase(); // from dojo.style.toSelectorCase
                 value = css ? css.getPropertyValue(cssProperty) : null;
             } else if (elem.currentStyle) {
                 value = elem.currentStyle[cssProperty];
                 if (/^\d/.test(value) && !/px$/.test(value) && cssProperty != 'fontWeight') {
                     /* Convert to px using an hack from Dean Edwards */
                     var left = elem.style.left;
                     var rsLeft = elem.runtimeStyle.left;
                     elem.runtimeStyle.left = elem.currentStyle.left;
                     elem.style.left = value || 0;
                     value = elem.style.pixelLeft + "px";
                     elem.style.left = left;
                     elem.runtimeStyle.left = rsLeft;
                 }
             }
         }
         if (cssProperty == 'opacity') {
             value = parseFloat(value);
         }
 
         if (/Opera/.test(navigator.userAgent) && (MochiKit.Base.findValue(['left', 'top', 'right', 'bottom'], cssProperty) != -1)) {
             if (MochiKit.Style.getStyle(elem, 'position') == 'static') {
                 value = 'auto';
             }
         }
 
         return value == 'auto' ? null : value;
     },
 
     /** @id MochiKit.Style.setStyle */
     setStyle: function (elem, style) {
         elem = MochiKit.DOM.getElement(elem);
         for (var name in style) {
             switch (name) {
             case 'opacity':
                 MochiKit.Style.setOpacity(elem, style[name]);
                 break;
             case 'float':
             case 'cssFloat':
             case 'styleFloat':
                 if (typeof(elem.style["float"]) != "undefined") {
                     elem.style["float"] = style[name];
                 } else if (typeof(elem.style.cssFloat) != "undefined") {
                     elem.style.cssFloat = style[name];
                 } else {
                     elem.style.styleFloat = style[name];
                 }
                 break;
             default:
                 elem.style[MochiKit.Base.camelize(name)] = style[name];
             }
         }
     },
 
     /** @id MochiKit.Style.setOpacity */
     setOpacity: function (elem, o) {
         elem = MochiKit.DOM.getElement(elem);
         var self = MochiKit.Style;
         if (o == 1) {
             var toSet = /Gecko/.test(navigator.userAgent) && !(/Konqueror|AppleWebKit|KHTML/.test(navigator.userAgent));
             elem.style["opacity"] = toSet ? 0.999999 : 1.0;
             if (/MSIE/.test(navigator.userAgent)) {
                 elem.style['filter'] =
                     self.getStyle(elem, 'filter').replace(/alpha\([^\)]*\)/gi, '');
             }
         } else {
             if (o < 0.00001) {
                 o = 0;
             }
             elem.style["opacity"] = o;
             if (/MSIE/.test(navigator.userAgent)) {
                 elem.style['filter'] =
                     self.getStyle(elem, 'filter').replace(/alpha\([^\)]*\)/gi, '') + 'alpha(opacity=' + o * 100 + ')';
             }
         }
     },
 
     /*
 
         getElementPosition is adapted from YAHOO.util.Dom.getXY v0.9.0.
         Copyright: Copyright (c) 2006, Yahoo! Inc. All rights reserved.
         License: BSD, http://developer.yahoo.net/yui/license.txt
 
     */
 
     /** @id MochiKit.Style.getElementPosition */
     getElementPosition: function (elem, /* optional */relativeTo) {
         var self = MochiKit.Style;
         var dom = MochiKit.DOM;
         var isCoordinates = function (o) {
             return o != null &&
                    o.nodeType == null &&
                    typeof(o.x) == "number" &&
                    typeof(o.y) == "number";
-        }
+        };
 
         if (typeof(elem) == "string") {
             elem = dom.getElement(elem);
         }
         if (elem == null ||
             (!isCoordinates(elem) && self.getStyle(elem, 'display') == 'none')) {
             return undefined;
         }
 
         var c = new self.Coordinates(0, 0);
         var box = null;
         var parent = null;
 
         var d = MochiKit.DOM._document;
         var de = d.documentElement;
         var b = d.body;
 
-        if (!elem.parentNode && elem.x && elem.y) {
+        if (isCoordinates(elem)) {
             /* it's just a MochiKit.Style.Coordinates object */
             c.x += elem.x || 0;
             c.y += elem.y || 0;
         } else if (elem.getBoundingClientRect) { // IE shortcut
             /*
 
                 The IE shortcut can be off by two. We fix it. See:
                 http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/getboundingclientrect.asp
 
                 This is similar to the method used in
                 MochiKit.Signal.Event.mouse().
 
             */
             box = elem.getBoundingClientRect();
 
             c.x += box.left +
                 (de.scrollLeft || b.scrollLeft) -
                 (de.clientLeft || 0);
 
             c.y += box.top +
                 (de.scrollTop || b.scrollTop) -
                 (de.clientTop || 0);
 
         } else if (elem.offsetParent) {
             c.x += elem.offsetLeft;
             c.y += elem.offsetTop;
             parent = elem.offsetParent;
 
             if (parent != elem) {
                 while (parent) {
-                    c.x += parseInt(parent.style.borderLeftWidth) || 0;
-                    c.y += parseInt(parent.style.borderTopWidth) || 0;
+                    c.x += parseInt(parent.style.borderLeftWidth, 10) || 0;
+                    c.y += parseInt(parent.style.borderTopWidth, 10) || 0;
                     c.x += parent.offsetLeft;
                     c.y += parent.offsetTop;
                     parent = parent.offsetParent;
                 }
             }
 
             /*
 
                 Opera < 9 and old Safari (absolute) incorrectly account for
                 body offsetTop and offsetLeft.
 
             */
             var ua = navigator.userAgent.toLowerCase();
             if ((typeof(opera) != 'undefined' &&
                 parseFloat(opera.version()) < 9) ||
                 (ua.indexOf('AppleWebKit') != -1 &&
                 self.getStyle(elem, 'position') == 'absolute')) {
 
                 c.x -= b.offsetLeft;
                 c.y -= b.offsetTop;
 
             }
 
             // Adjust position for strange Opera scroll bug
             if (elem.parentNode) {
                 parent = elem.parentNode;
             } else {
                 parent = null;
             }
             while (parent) {
                 var tagName = parent.tagName.toUpperCase();
                 if (tagName === 'BODY' || tagName === 'HTML') {
                     break;
                 }
                 var disp = self.getStyle(parent, 'display');
                 // Handle strange Opera bug for some display
                 if (disp.search(/^inline|table-row.*$/i)) {
                     c.x -= parent.scrollLeft;
                     c.y -= parent.scrollTop;
                 }
                 if (parent.parentNode) {
                     parent = parent.parentNode;
                 } else {
                     parent = null;
                 }
             }
         }
 
         if (relativeTo) {
             relativeTo = arguments.callee(relativeTo);
             if (relativeTo) {
                 c.x -= (relativeTo.x || 0);
                 c.y -= (relativeTo.y || 0);
             }
         }
 
         return c;
     },
 
     /** @id MochiKit.Style.setElementPosition */
     setElementPosition: function (elem, newPos/* optional */, units) {
         elem = MochiKit.DOM.getElement(elem);
         if (typeof(units) == 'undefined') {
             units = 'px';
         }
         var newStyle = {};
         var isUndefNull = MochiKit.Base.isUndefinedOrNull;
         if (!isUndefNull(newPos.x)) {
             newStyle['left'] = newPos.x + units;
         }
         if (!isUndefNull(newPos.y)) {
             newStyle['top'] = newPos.y + units;
         }
         MochiKit.DOM.updateNodeAttributes(elem, {'style': newStyle});
     },
 
     /** @id MochiKit.Style.makePositioned */
     makePositioned: function (element) {
         element = MochiKit.DOM.getElement(element);
         var pos = MochiKit.Style.getStyle(element, 'position');
         if (pos == 'static' || !pos) {
             element.style.position = 'relative';
             // Opera returns the offset relative to the positioning context,
             // when an element is position relative but top and left have
             // not been defined
             if (/Opera/.test(navigator.userAgent)) {
                 element.style.top = 0;
                 element.style.left = 0;
             }
         }
     },
 
     /** @id MochiKit.Style.undoPositioned */
     undoPositioned: function (element) {
         element = MochiKit.DOM.getElement(element);
         if (element.style.position == 'relative') {
             element.style.position = element.style.top = element.style.left = element.style.bottom = element.style.right = '';
         }
     },
 
     /** @id MochiKit.Style.makeClipping */
     makeClipping: function (element) {
         element = MochiKit.DOM.getElement(element);
         var s = element.style;
         var oldOverflow = { 'overflow': s.overflow,
                             'overflow-x': s.overflowX,
                             'overflow-y': s.overflowY };
         if ((MochiKit.Style.getStyle(element, 'overflow') || 'visible') != 'hidden') {
             element.style.overflow = 'hidden';
             element.style.overflowX = 'hidden';
             element.style.overflowY = 'hidden';
         }
         return oldOverflow;
     },
 
     /** @id MochiKit.Style.undoClipping */
     undoClipping: function (element, overflow) {
         element = MochiKit.DOM.getElement(element);
         if (typeof(overflow) == 'string') {
             element.style.overflow = overflow;
         } else if (overflow != null) {
             element.style.overflow = overflow['overflow'];
             element.style.overflowX = overflow['overflow-x'];
             element.style.overflowY = overflow['overflow-y'];
         }
     },
 
     /** @id MochiKit.Style.getElementDimensions */
     getElementDimensions: function (elem, contentSize/*optional*/) {
         var self = MochiKit.Style;
         var dom = MochiKit.DOM;
         if (typeof(elem.w) == 'number' || typeof(elem.h) == 'number') {
             return new self.Dimensions(elem.w || 0, elem.h || 0);
         }
         elem = dom.getElement(elem);
         if (!elem) {
             return undefined;
         }
         var disp = self.getStyle(elem, 'display');
         // display can be empty/undefined on WebKit/KHTML
         if (disp == 'none' || disp == '' || typeof(disp) == 'undefined') {
             var s = elem.style;
             var originalVisibility = s.visibility;
             var originalPosition = s.position;
             var originalDisplay = s.display;
             s.visibility = 'hidden';
             s.position = 'absolute';
             s.display = self._getDefaultDisplay(elem);
             var originalWidth = elem.offsetWidth;
             var originalHeight = elem.offsetHeight;
             s.display = originalDisplay;
             s.position = originalPosition;
             s.visibility = originalVisibility;
         } else {
             originalWidth = elem.offsetWidth || 0;
             originalHeight = elem.offsetHeight || 0;
         }
         if (contentSize) {
             var tableCell = 'colSpan' in elem && 'rowSpan' in elem;
             var collapse = (tableCell && elem.parentNode && self.getStyle(
-                    elem.parentNode, 'borderCollapse') == 'collapse')
+                    elem.parentNode, 'borderCollapse') == 'collapse');
             if (collapse) {
                 if (/MSIE/.test(navigator.userAgent)) {
                     var borderLeftQuota = elem.previousSibling? 0.5 : 1;
                     var borderRightQuota = elem.nextSibling? 0.5 : 1;
                 }
                 else {
                     var borderLeftQuota = 0.5;
                     var borderRightQuota = 0.5;
                 }
             } else {
                 var borderLeftQuota = 1;
                 var borderRightQuota = 1;
             }
             originalWidth -= Math.round(
                 (parseFloat(self.getStyle(elem, 'paddingLeft')) || 0)
               + (parseFloat(self.getStyle(elem, 'paddingRight')) || 0)
               + borderLeftQuota *
                 (parseFloat(self.getStyle(elem, 'borderLeftWidth')) || 0)
               + borderRightQuota *
                 (parseFloat(self.getStyle(elem, 'borderRightWidth')) || 0)
             );
             if (tableCell) {
                 if (/Gecko|Opera/.test(navigator.userAgent)
                     && !/Konqueror|AppleWebKit|KHTML/.test(navigator.userAgent)) {
                     var borderHeightQuota = 0;
                 } else if (/MSIE/.test(navigator.userAgent)) {
                     var borderHeightQuota = 1;
                 } else {
                     var borderHeightQuota = collapse? 0.5 : 1;
                 }
             } else {
                 var borderHeightQuota = 1;
             }
             originalHeight -= Math.round(
                 (parseFloat(self.getStyle(elem, 'paddingTop')) || 0)
               + (parseFloat(self.getStyle(elem, 'paddingBottom')) || 0)
               + borderHeightQuota * (
                 (parseFloat(self.getStyle(elem, 'borderTopWidth')) || 0)
               + (parseFloat(self.getStyle(elem, 'borderBottomWidth')) || 0))
             );
         }
         return new self.Dimensions(originalWidth, originalHeight);
     },
 
     /** @id MochiKit.Style.setElementDimensions */
     setElementDimensions: function (elem, newSize/* optional */, units) {
         elem = MochiKit.DOM.getElement(elem);
         if (typeof(units) == 'undefined') {
             units = 'px';
         }
         var newStyle = {};
         var isUndefNull = MochiKit.Base.isUndefinedOrNull;
         if (!isUndefNull(newSize.w)) {
             newStyle['width'] = newSize.w + units;
         }
         if (!isUndefNull(newSize.h)) {
             newStyle['height'] = newSize.h + units;
         }
         MochiKit.DOM.updateNodeAttributes(elem, {'style': newStyle});
     },
 
     _getDefaultDisplay: function (elem) {
         var self = MochiKit.Style;
         var dom = MochiKit.DOM;
         elem = dom.getElement(elem);
         if (!elem) {
             return undefined;
         }
         var tagName = elem.tagName.toUpperCase();
         return self._defaultDisplay[tagName] || 'block';
     },
 
     /** @id MochiKit.Style.setDisplayForElement */
     setDisplayForElement: function (display, element/*, ...*/) {
         var elements = MochiKit.Base.extend(null, arguments, 1);
         var getElement = MochiKit.DOM.getElement;
         for (var i = 0; i < elements.length; i++) {
             element = getElement(elements[i]);
             if (element) {
                 element.style.display = display;
             }
         }
     },
 
     /** @id MochiKit.Style.getViewportDimensions */
     getViewportDimensions: function () {
         var d = new MochiKit.Style.Dimensions();
         var w = MochiKit.DOM._window;
         var b = MochiKit.DOM._document.body;
         if (w.innerWidth) {
             d.w = w.innerWidth;
             d.h = w.innerHeight;
         } else if (b && b.parentElement && b.parentElement.clientWidth) {
             d.w = b.parentElement.clientWidth;
             d.h = b.parentElement.clientHeight;
         } else if (b && b.clientWidth) {
             d.w = b.clientWidth;
             d.h = b.clientHeight;
         }
         return d;
     },
 
     /** @id MochiKit.Style.getViewportPosition */
     getViewportPosition: function () {
         var c = new MochiKit.Style.Coordinates(0, 0);
         var d = MochiKit.DOM._document;
         var de = d.documentElement;
         var db = d.body;
         if (de && (de.scrollTop || de.scrollLeft)) {
             c.x = de.scrollLeft;
             c.y = de.scrollTop;
         } else if (db) {
             c.x = db.scrollLeft;
             c.y = db.scrollTop;
         }
         return c;
     },
 
     __new__: function () {
         var m = MochiKit.Base;
 
         var inlines = ['A','ABBR','ACRONYM','B','BASEFONT','BDO','BIG','BR',
                        'CITE','CODE','DFN','EM','FONT','I','IMG','KBD','LABEL',
                        'Q','S','SAMP','SMALL','SPAN','STRIKE','STRONG','SUB',
                        'SUP','TEXTAREA','TT','U','VAR'];
         this._defaultDisplay = { 'TABLE': 'table',
                                  'THEAD': 'table-header-group',
                                  'TBODY': 'table-row-group',
                                  'TFOOT': 'table-footer-group',
                                  'COLGROUP': 'table-column-group',
                                  'COL': 'table-column',
                                  'TR': 'table-row',
                                  'TD': 'table-cell',
                                  'TH': 'table-cell',
                                  'CAPTION': 'table-caption',
                                  'LI': 'list-item',
                                  'INPUT': 'inline-block',
                                  'SELECT': 'inline-block' };
         // CSS 'display' support in IE6/7 is just broken...
         if (/MSIE/.test(navigator.userAgent)) {
             for (var k in this._defaultDisplay) {
                 var v = this._defaultDisplay[k];
                 if (v.indexOf('table') == 0) {
                     this._defaultDisplay[k] = 'block';
                 }
             }
         }
         for (var i = 0; i < inlines.length; i++) {
             this._defaultDisplay[inlines[i]] = 'inline';
         }
 
         // Backwards compatibility aliases
-        m._deprecated(this, 'elementPosition', 'MochiKit.Style.getElementPosition', '1.3');
-        m._deprecated(this, 'elementDimensions', 'MochiKit.Style.getElementDimensions', '1.3');
+        m._deprecated(this, 'elementPosition', 'MochiKit.Style.getElementPosition', '1.3', true);
+        m._deprecated(this, 'elementDimensions', 'MochiKit.Style.getElementDimensions', '1.3', true);
 
         this.hideElement = m.partial(this.setDisplayForElement, 'none');
         // TODO: showElement could be improved by using getDefaultDisplay.
         this.showElement = m.partial(this.setDisplayForElement, 'block');
 
         m.nameFunctions(this);
     }
 });
 
 MochiKit.Style.__new__();
 MochiKit.Base._exportSymbols(this, MochiKit.Style);
diff --git a/frontend/gamma/js/MochiKit/Test.js b/frontend/gamma/js/MochiKit/Test.js
index 9520ab2..f29670f 100644
--- a/frontend/gamma/js/MochiKit/Test.js
+++ b/frontend/gamma/js/MochiKit/Test.js
@@ -1,144 +1,144 @@
 /***
 
 MochiKit.Test 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Test', '1.5', ['Base']);
+MochiKit.Base.module(MochiKit, 'Test', '1.5', ['Base']);
 
 MochiKit.Test.runTests = function (obj) {
     if (typeof(obj) == "string") {
         // TODO: Remove this temporary API change advertisement
         throw new TypeError("Automatic module import not supported, call runTests() with proper object: " + obj);
     }
     var suite = new MochiKit.Test.Suite();
     suite.run(obj);
 };
 
 MochiKit.Test.Suite = function () {
     this.testIndex = 0;
     MochiKit.Base.bindMethods(this);
 };
 
 MochiKit.Test.Suite.prototype = {
     run: function (obj) {
         try {
             obj(this);
         } catch (e) {
             this.traceback(e);
         }
     },
     traceback: function (e) {
         var items = MochiKit.Iter.sorted(MochiKit.Base.items(e));
         print("not ok " + this.testIndex + " - Error thrown");
         for (var i = 0; i < items.length; i++) {
             var kv = items[i];
             if (kv[0] == "stack") {
                 kv[1] = kv[1].split(/\n/)[0];
             }
             this.print("# " + kv.join(": "));
         }
     },
     print: function (s) {
         print(s);
     },
     is: function (got, expected, /* optional */message) {
         var res = 1;
         var msg = null;
         try {
             res = MochiKit.Base.compare(got, expected);
         } catch (e) {
             msg = "Can not compare " + typeof(got) + ":" + typeof(expected);
         }
         if (res) {
             msg = "Expected value did not compare equal";
         }
         if (!res) {
             return this.testResult(true, message);
         }
         return this.testResult(false, message,
             [[msg], ["got:", got], ["expected:", expected]]);
     },
 
     testResult: function (pass, msg, failures) {
         this.testIndex += 1;
         if (pass) {
             this.print("ok " + this.testIndex + " - " + msg);
             return;
         }
         this.print("not ok " + this.testIndex + " - " + msg);
         if (failures) {
             for (var i = 0; i < failures.length; i++) {
                 this.print("# " + failures[i].join(" "));
             }
         }
     },
 
     isDeeply: function (got, expected, /* optional */message) {
         var m = MochiKit.Base;
         var res = 1;
         try {
             res = m.compare(got, expected);
         } catch (e) {
             // pass
         }
         if (res === 0) {
             return this.ok(true, message);
         }
         var gk = m.keys(got);
         var ek = m.keys(expected);
         gk.sort();
         ek.sort();
         if (m.compare(gk, ek)) {
             // differing keys
             var cmp = {};
             var i;
             for (i = 0; i < gk.length; i++) {
                 cmp[gk[i]] = "got";
             }
             for (i = 0; i < ek.length; i++) {
                 if (ek[i] in cmp) {
                     delete cmp[ek[i]];
                 } else {
                     cmp[ek[i]] = "expected";
                 }
             }
             var diffkeys = m.keys(cmp);
             diffkeys.sort();
             var gotkeys = [];
             var expkeys = [];
             while (diffkeys.length) {
                 var k = diffkeys.shift();
                 if (k in Object.prototype) {
                     continue;
                 }
                 (cmp[k] == "got" ? gotkeys : expkeys).push(k);
             }
 
 
         }
 
         return this.testResult((!res), msg,
             (msg ? [["got:", got], ["expected:", expected]] : undefined)
         );
     },
 
     ok: function (res, message) {
         return this.testResult(res, message);
     }
 };
 
 MochiKit.Test.__new__ = function () {
     var m = MochiKit.Base;
     this.Suite.__export__ = false;
     m.nameFunctions(this);
 
 };
 
 MochiKit.Test.__new__();
 
 MochiKit.Base._exportSymbols(this, MochiKit.Test);
diff --git a/frontend/gamma/js/MochiKit/Text.js b/frontend/gamma/js/MochiKit/Text.js
index a44f7e4..ff6366d 100644
--- a/frontend/gamma/js/MochiKit/Text.js
+++ b/frontend/gamma/js/MochiKit/Text.js
@@ -1,577 +1,546 @@
 /***
 
 MochiKit.Text 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2008 Per Cederberg.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Text', '1.5', ['Base', 'Format']);
+MochiKit.Base.module(MochiKit, 'Text', '1.5', ['Base', 'Format']);
 
 /**
  * Checks if a text string starts with the specified substring. If
  * either of the two strings is null, false will be returned.
  *
  * @param {String} substr the substring to search for
  * @param {String} str the string to search in
  *
  * @return {Boolean} true if the string starts with the substring, or
  *         false otherwise
  */
 MochiKit.Text.startsWith = function (substr, str) {
     return str != null && substr != null && str.indexOf(substr) == 0;
-}
+};
 
 /**
  * Checks if a text string ends with the specified substring. If
  * either of the two strings is null, false will be returned.
  *
  * @param {String} substr the substring to search for
  * @param {String} str the string to search in
  *
  * @return {Boolean} true if the string ends with the substring, or
  *         false otherwise
  */
 MochiKit.Text.endsWith = function (substr, str) {
     return str != null && substr != null &&
            str.lastIndexOf(substr) == Math.max(str.length - substr.length, 0);
-}
+};
 
 /**
  * Checks if a text string contains the specified substring. If
  * either of the two strings is null, false will be returned.
  *
  * @param {String} substr the substring to search for
  * @param {String} str the string to search in
  *
  * @return {Boolean} true if the string contains the substring, or
  *         false otherwise
  */
 MochiKit.Text.contains = function (substr, str) {
     return str != null && substr != null && str.indexOf(substr) >= 0;
-}
+};
 
 /**
  * Adds a character to the left-hand side of a string until it
  * reaches the specified minimum length.
  *
  * @param {String} str the string to process
  * @param {Number} minLength the requested minimum length
  * @param {String} fillChar the padding character to add, defaults
  *            to a space
  *
  * @return {String} the padded string
  */
 MochiKit.Text.padLeft = function (str, minLength, fillChar) {
     str = str || "";
     fillChar = fillChar || " ";
     while (str.length < minLength) {
         str = fillChar + str;
     }
     return str;
-}
+};
 
 /**
  * Adds a character to the right-hand side of a string until it
  * reaches the specified minimum length.
  *
  * @param {String} str the string to process
  * @param {Number} minLength the requested minimum length
  * @param {String} fillChar the padding character to add, defaults
  *            to a space
  *
  * @return {String} the padded string
  */
 MochiKit.Text.padRight = function (str, minLength, fillChar) {
     str = str || "";
     fillChar = fillChar || " ";
     while (str.length < minLength) {
         str += fillChar;
     }
     return str;
-}
+};
 
 /**
  * Returns a truncated copy of a string. If the string is shorter
  * than the specified maximum length, the object will be returned
  * unmodified. If an optional tail string is specified, additional
  * elements will be removed in order to accomodate the tail (that
  * will be appended). This function also works on arrays.
  *
  * @param {String} str the string to truncate
  * @param {Number} maxLength the maximum length
  * @param {String} [tail] the tail to append on truncation
  *
  * @return {String} the truncated string
  */
 MochiKit.Text.truncate = function (str, maxLength, tail) {
     if (str == null || str.length <= maxLength || maxLength < 0) {
         return str;
     } else if (tail != null) {
         str = str.slice(0, Math.max(0, maxLength - tail.length));
         if (typeof(str) == "string") {
             return str + tail;
         } else {
             return MochiKit.Base.extend(str, tail);
         }
     } else {
         return str.slice(0, maxLength);
     }
-}
+};
 
 /**
- * Splits a text string, applies a function and joins the results
- * back together again. This is a convenience function for calling
- * split(), map() and join() separately. It can be used to easily
- * trim each line in a text string (using the strip function), or to
- * translate a text word-by-word.
+ * Splits a text string using separator as the split point
+ * If max is given, at most max splits are done, giving at most
+ * max + 1 elements in the returned list.
  *
- * @param {Function} func the function to apply
  * @param {String} str the string to split
- * @param {String} [separator] the separator character to use,
+ * @param {String/RegExp} [separator] the separator char or regexp to use,
  *            defaults to newline
+ * @param {Number} [max] the maximum number of parts to return
+ * @return {Array} an array of parts of the string
+ */
+MochiKit.Text.split = function (str, separator, max) {
+    if (str == null) {
+        return str;
+    }
+    separator = separator || '\n';
+    var bits = str.split(separator);
+    if ((typeof(max) == "undefined") || max >= bits.length - 1) {
+        return bits;
+    }
+    bits.splice(max, bits.length, bits.slice(max, bits.length).join(separator));
+    return bits;
+};
+
+/**
+ * Splits a text string using separator as the split point
+ * If max is given, at most max splits are done,
+ * using splits from the right
  *
- * @return {String} a string with the joined up results
+ * @param {String} str the string to split
+ * @param {String/RegExp} [separator] the separator char or regexp to use,
+ *            defaults to newline
+ * @param {Number} [max] the maximum number of parts to return
+ * @return {Array} an array of parts of the string
  */
-MochiKit.Text.splitJoin = function (func, str, separator) {
-    if (str == null || str.length == 0) {
+MochiKit.Text.rsplit = function (str, separator, max) {
+    if (str == null) {
         return str;
     }
-    separator = separator || '\n'
-    return MochiKit.Base.map(func, str.split(separator)).join(separator);
-}
+    separator = separator || '\n';
+    var bits = str.split(separator);
+    if ((typeof(max) == "undefined") || max >= bits.length - 1){
+        return bits;
+    }
+    bits.splice(0, bits.length-max, bits.slice(0, bits.length-max).join(separator));
+    return bits;
+};
 
 /**
  * Creates a formatter function for the specified formatter pattern
  * and locale. The returned function takes as many arguments as the
  * formatter pattern requires. See separate documentation for
  * information about the formatter pattern syntax.
  *
  * @param {String} pattern the formatter pattern string
  * @param {Object} [locale] the locale to use, defaults to
  *            LOCALE.en_US
  *
  * @return {Function} the formatter function created
  *
  * @throws FormatPatternError if the format pattern was invalid
  */
 MochiKit.Text.formatter = function (pattern, locale) {
-    if (typeof(locale) == "undefined") {
+    if (locale == null) {
         locale = MochiKit.Format.formatLocale();
     } else if (typeof(locale) == "string") {
         locale = MochiKit.Format.formatLocale(locale);
     }
     var parts = MochiKit.Text._parsePattern(pattern);
     return function() {
         var values = MochiKit.Base.extend([], arguments);
         var res = [];
         for (var i = 0; i < parts.length; i++) {
             if (typeof(parts[i]) == "string") {
                 res.push(parts[i]);
             } else {
                 res.push(MochiKit.Text.formatValue(parts[i], values, locale));
             }
         }
         return res.join("");
-    }
-}
+    };
+};
 
 /**
  * Formats the specified arguments according to a formatter pattern.
  * See separate documentation for information about the formatter
  * pattern syntax.
  *
  * @param {String} pattern the formatter pattern string
  * @param {Object} [...] the optional values to format
  *
  * @return {String} the formatted output string
  *
  * @throws FormatPatternError if the format pattern was invalid
  */
 MochiKit.Text.format = function (pattern/*, ...*/) {
     var func = MochiKit.Text.formatter(pattern);
     return func.apply(this, MochiKit.Base.extend([], arguments, 1));
-}
+};
 
 /**
  * Format a value with the specified format specifier.
  *
  * @param {String/Object} spec the format specifier string or parsed
  *            format specifier object
  * @param {Object} value the value to format
  * @param {Object} [locale] the locale to use, defaults to
  *            LOCALE.en_US
  *
  * @return {String} the formatted output string
+ *
+ * @throws FormatPatternError if the format specifier was invalid
  */
 MochiKit.Text.formatValue = function (spec, value, locale) {
     var self = MochiKit.Text;
     if (typeof(spec) === "string") {
-        spec = self._parseFormatFlags(spec, 0, spec.length - 1);
+        spec = self._parseFormatFlags(spec, 0, spec.length);
     }
     for (var i = 0; spec.path != null && i < spec.path.length; i++) {
         if (value != null) {
             value = value[spec.path[i]];
         }
     }
-    if (typeof(locale) == "undefined") {
+    if (locale == null) {
         locale = MochiKit.Format.formatLocale();
     } else if (typeof(locale) == "string") {
         locale = MochiKit.Format.formatLocale(locale);
     }
     var str = "";
-    if (spec.numeric) {
+    if (spec.type == "number") {
+        if (value instanceof Number) {
+            value = value.valueOf();
+        }
         if (typeof(value) != "number" || isNaN(value)) {
             str = "";
         } else if (value === Number.POSITIVE_INFINITY) {
             str = "\u221e";
         } else if (value === Number.NEGATIVE_INFINITY) {
             str = "-\u221e";
         } else {
-            var sign = (spec.sign === "-") ? "" : spec.sign;
-            sign = (value < 0) ? "-" : sign;
+            var sign = (value < 0) ? "-" : spec.sign;
             value = Math.abs(value);
             if (spec.format === "%") {
                 str = self._truncToPercent(value, spec.precision);
             } else if (spec.format === "d") {
                 str = MochiKit.Format.roundToFixed(value, 0);
             } else if (spec.radix != 10) {
                 str = Math.floor(value).toString(spec.radix);
                 if (spec.format === "x") {
                     str = str.toLowerCase();
                 } else if (spec.format === "X") {
                     str = str.toUpperCase();
                 }
             } else if (spec.precision >= 0) {
                 str = MochiKit.Format.roundToFixed(value, spec.precision);
             } else {
                 str = value.toString();
             }
             if (spec.padding === "0" && spec.format === "%") {
                 str = self.padLeft(str, spec.width - sign.length - 1, "0");
             } else if (spec.padding == "0") {
                 str = self.padLeft(str, spec.width - sign.length, "0");
             }
-            str = self._localizeNumber(str, locale, spec.grouping);
+            str = self._localizeNumber(str, locale, spec.group);
             str = sign + str;
         }
         if (str !== "" && spec.format === "%") {
             str = str + locale.percent;
         }
     } else {
         if (spec.format == "r") {
             str = MochiKit.Base.repr(value);
         } else {
-            str = (value == null) ? "null" : value.toString();
+            str = (value == null) ? "" : value.toString();
         }
         str = self.truncate(str, spec.precision);
     }
     if (spec.align == "<") {
         str = self.padRight(str, spec.width);
     } else {
         str = self.padLeft(str, spec.width);
     }
     return str;
-}
+};
 
 /**
  * Adjust an already formatted numeric string for locale-specific
  * grouping and decimal separators. The grouping is optional and
  * will attempt to keep the number string length intact by removing
  * padded zeros (if possible).
  *
  * @param {String} num the formatted number string
  * @param {Object} locale the formatting locale to use
- * @param {Boolean} grouping the grouping flag
+ * @param {Boolean} group the grouping flag
  *
  * @return {String} the localized number string
  */
-MochiKit.Text._localizeNumber = function (num, locale, grouping) {
+MochiKit.Text._localizeNumber = function (num, locale, group) {
     var parts = num.split(/\./);
     var whole = parts[0];
     var frac = (parts.length == 1) ? "" : parts[1];
     var res = (frac.length > 0) ? locale.decimal : "";
-    while (grouping && frac.length > 3) {
+    while (group && frac.length > 3) {
         res = res + frac.substring(0, 3) + locale.separator;
         frac = frac.substring(3);
         if (whole.charAt(0) == "0") {
             whole = whole.substring(1);
         }
     }
     if (frac.length > 0) {
-        res += frac;
+        res = res + frac;
     }
-    while (grouping && whole.length > 3) {
+    while (group && whole.length > 3) {
         var pos = whole.length - 3;
         res = locale.separator + whole.substring(pos) + res;
         whole = whole.substring((whole.charAt(0) == "0") ? 1 : 0, pos);
     }
     return whole + res;
-}
+};
 
 /**
  * Parses a format pattern and returns an array of constant strings
  * and format info objects.
  *
  * @param {String} pattern the format pattern to analyze
  *
  * @return {Array} an array of strings and format info objects
  *
  * @throws FormatPatternError if the format pattern was invalid
  */
 MochiKit.Text._parsePattern = function (pattern) {
     var self = MochiKit.Text;
     var parts = [];
-    var start = 0;
-    var pos = 0;
-    for (pos = 0; pos < pattern.length; pos++) {
-        if (pattern.charAt(pos) == "{") {
-            if (pos + 1 >= pattern.length) {
-                var msg = "unescaped { char, should be escaped as {{";
-                throw new self.FormatPatternError(pattern, pos, msg);
-            } else if (pattern.charAt(pos + 1) == "{") {
-                parts.push(pattern.substring(start, pos + 1));
-                start = pos + 2;
-                pos++;
-            } else {
-                if (start < pos) {
-                    parts.push(pattern.substring(start, pos));
-                }
-                start = pattern.indexOf("}", pos) + 1;
-                if (start <= 0) {
-                    var msg = "unmatched { char, not followed by a } char";
-                    throw new self.FormatPatternError(pattern, pos, msg);
-                }
-                parts.push(self._parseFormat(pattern, pos + 1, start - 1));
-                pos = start - 1;
-            }
-        } else if (pattern.charAt(pos) == "}") {
-            if (pos + 1 >= pattern.length || pattern.charAt(pos + 1) != "}") {
-                var msg = "unescaped } char, should be escaped as }}";
-                throw new self.FormatPatternError(pattern, pos, msg);
-            }
-            parts.push(pattern.substring(start, pos + 1));
-            start = pos + 2;
-            pos++;
+    var re = /{[^{}]*}|{{?|}}?/g;
+    var lastPos = re.lastIndex = 0;
+    var m;
+    while ((m = re.exec(pattern)) != null) {
+        if (lastPos < m.index) {
+            parts.push(pattern.substring(lastPos, m.index))
+        }
+        var str = m[0];
+        lastPos = m.index + str.length;
+        if (self.startsWith("{", str) && self.endsWith("}", str)) {
+            parts.push(self._parseFormat(pattern, m.index + 1, lastPos - 1));
+        } else if (self.startsWith("{{", str) || self.startsWith("}}", str)) {
+            parts.push(str.substring(1));
+        } else if (self.startsWith("{", str)) {
+            var msg = "unescaped { char, should be escaped as {{";
+            throw new self.FormatPatternError(pattern, m.index, msg);
+        } else if (self.startsWith("}", str)) {
+            var msg = "unescaped } char, should be escaped as }}";
+            throw new self.FormatPatternError(pattern, m.index, msg);
         }
     }
-    if (start < pos) {
-        parts.push(pattern.substring(start, pos));
+    if (lastPos < pattern.length) {
+        parts.push(pattern.substring(lastPos));
     }
     return parts;
-}
+};
 
 /**
  * Parses a format instruction and returns a format info object.
  *
  * @param {String} pattern the format pattern string
  * @param {Number} startPos the first index of the format instruction
  * @param {Number} endPos the last index of the format instruction
  *
  * @return {Object} the format info object
  *
  * @throws FormatPatternError if the format pattern was invalid
  */
 MochiKit.Text._parseFormat = function (pattern, startPos, endPos) {
     var self = MochiKit.Text;
     var text = pattern.substring(startPos, endPos);
-    var info;
-    var pos = text.indexOf(":");
-    if (pos == 0) {
-        info = self._parseFormatFlags(pattern, startPos + 1, endPos);
-        info.path = [0];
-    } else if (pos > 0) {
-        info = self._parseFormatFlags(pattern, startPos + pos + 1, endPos);
-        info.path = text.substring(0, pos).split(".");
-    } else {
-        info = self._parseFormatFlags(pattern, endPos, endPos);
-        info.path = text.split(".");
-    }
-    var DIGITS = /^\d+$/;
+    var parts = self.split(text, ":", 1);
+    var path = parts[0];
+    var flagsPos = startPos + path.length + ((parts.length == 1) ? 0 : 1);
+    var info = self._parseFormatFlags(pattern, flagsPos, endPos);
+    info.path = (path == "") ? [] : path.split(".");
     for (var i = 0; i < info.path.length; i++) {
-        var e = info.path[i];
-        if (typeof(e) == "string") {
-            // TODO: replace with MochiKit.Format.strip?
-            e = e.replace(/^\s+/, "").replace(/\s+$/, "");
-            if (e == "" && info.path.length == 1) {
-                e = 0;
-            } else if (e == "") {
-                var msg = "format value path contains blanks";
-                throw new self.FormatPatternError(pattern, startPos, msg);
-            } else if (DIGITS.test(e)) {
-                e = parseInt(e);
-            }
+        var v = info.path[i];
+        // TODO: replace with MochiKit.Format.strip?
+        v = v.replace(/^\s+/, "").replace(/\s+$/, "");
+        if (v == "" && info.path.length == 1) {
+            v = 0;
+        } else if (v == "") {
+            var msg = "format value path contains blanks";
+            throw new self.FormatPatternError(pattern, startPos, msg);
+        } else if (/^\d+$/.test(v)) {
+            v = parseInt(v, 10);
         }
-        info.path[i] = e;
+        info.path[i] = v;
     }
-    if (info.path.length < 0 || typeof(info.path[0]) != "number") {
+    if (info.path.length <= 0 || typeof(info.path[0]) != "number") {
         info.path.unshift(0);
     }
     return info;
-}
+};
 
 /**
  * Parses a string with format flags and returns a format info object.
  *
  * @param {String} pattern the format pattern string
  * @param {Number} startPos the first index of the format instruction
  * @param {Number} endPos the last index of the format instruction
  *
  * @return {Object} the format info object
  *
  * @throws FormatPatternError if the format pattern was invalid
  */
 MochiKit.Text._parseFormatFlags = function (pattern, startPos, endPos) {
-    var self = MochiKit.Text;
-    var info = { numeric: false, format: "s", width: 0, precision: -1,
-                 align: ">", sign: "-", padding: " ", grouping: false };
+    var update = MochiKit.Base.update;
+    var info = { type: "string", format: "s", width: 0, precision: -1,
+                 align: ">", sign: "", padding: " ", group: false };
     // TODO: replace with MochiKit.Format.rstrip?
-    var flags = pattern.substring(startPos, endPos).replace(/\s+$/, "");
-    while (flags.length > 0) {
-        switch (flags.charAt(0)) {
-        case ">":
-        case "<":
-            info.align = flags.charAt(0);
-            flags = flags.substring(1);
-            break;
-        case "+":
-        case "-":
-        case " ":
-            info.sign = flags.charAt(0);
-            flags = flags.substring(1);
-            break;
-        case ",":
-            info.grouping = true;
-            flags = flags.substring(1);
-            break;
-        case ".":
-            var chars = /^\d*/.exec(flags.substring(1))[0];
-            info.precision = parseInt(chars);
-            flags = flags.substring(1 + chars.length);
-            break;
-        case "0":
-            info.padding = flags.charAt(0);
-            flags = flags.substring(1);
-            break;
-        case "1":
-        case "2":
-        case "3":
-        case "4":
-        case "5":
-        case "6":
-        case "7":
-        case "8":
-        case "9":
-            var chars = /^\d*/.exec(flags)[0];
-            info.width = parseInt(chars);
-            flags = flags.substring(chars.length);
-            break;
-        case "s":
-        case "r":
-            info.format = flags.charAt(0);
-            flags = flags.substring(1);
-            break;
-        case "b":
-        case "d":
-        case "o":
-        case "x":
-        case "X":
-        case "f":
-        case "%":
-            info.numeric = true;
-            info.format = flags.charAt(0);
-            info.radix = 10;
-            if (info.format === "b") {
-                info.radix = 2;
-            } else if (info.format === "o") {
-                info.radix = 8;
-            } else if (info.format === "x" || info.format === "X") {
-                info.radix = 16;
-            }
-            flags = flags.substring(1);
-            break;
-        default:
-            var msg = "unsupported format flag: " + flags.charAt(0);
-            throw new self.FormatPatternError(pattern, startPos, msg);
+    var text = pattern.substring(startPos, endPos).replace(/\s+$/, "");
+    var m = /^([<>+ 0,-]+)?(\d+)?(\.\d*)?([srbdoxXf%])?(.*)$/.exec(text);
+    var flags = m[1];
+    var width = m[2];
+    var precision = m[3];
+    var type = m[4];
+    var unmatched = m[5];
+    for (var i = 0; flags && i < flags.length; i++) {
+        var chr = flags.charAt(i);
+        if (chr == "<" || chr == ">") {
+            info.align = chr;
+        } else if (chr == "+" || chr == "-" || chr == " ") {
+            info.sign = (chr == "-") ? "" : chr;
+        } else if (chr == "0") {
+            info.padding = chr;
+        } else if (chr == ",") {
+            info.group = true;
         }
     }
+    if (width) {
+        info.width = parseInt(width, 10);
+    }
+    if (precision && precision.length > 1) {
+        info.precision = parseInt(precision.substring(1), 10);
+    }
+    if (type == "s" || type == "r") {
+        info.format = type;
+    } else if (type == "b") {
+        update(info, { type: "number", format: type, radix: 2 });
+    } else if (type == "o") {
+        update(info, { type: "number", format: type, radix: 8 });
+    } else if (type == "x" || type == "X") {
+        update(info, { type: "number", format: type, radix: 16 });
+    } else if (type == "d" || type == "f" || type == "%") {
+        update(info, { type: "number", format: type, radix: 10 });
+    }
+    if (unmatched) {
+        var msg = "unsupported format flag: " + unmatched.charAt(0);
+        throw new MochiKit.Text.FormatPatternError(pattern, startPos, msg);
+    }
     return info;
-}
+};
 
 /**
  * Formats a value as a percentage. This method avoids multiplication
  * by 100 since it leads to weird numeric rounding errors. Instead it
  * just move the decimal separator in the text string. It is ugly,
  * but works...
  *
  * @param {Number} value the value to format
  * @param {Number} precision the number of precision digits
  */
 MochiKit.Text._truncToPercent = function (value, precision) {
-    // TODO: This can be simplified by using the same helper function
-    //       as roundToFixed now does.
+    // TODO: This can be simplified by using MochiKit.Format._shiftNumber
+    //       as roundToFixed does.
     var str;
     if (precision >= 0) {
         str = MochiKit.Format.roundToFixed(value, precision + 2);
     } else {
         str = (value == null) ? "0" : value.toString();
     }
-    var fracPos = str.indexOf(".");
-    if (fracPos < 0) {
-        str = str + "00";
-    } else if (fracPos + 3 >= str.length) {
-        var fraction = str.substring(fracPos + 1);
-        while (fraction.length < 2) {
-            fraction = fraction + "0";
-        }
-        str = str.substring(0, fracPos) + fraction;
-    } else {
-        var fraction = str.substring(fracPos + 1);
-        str = str.substring(0, fracPos) + fraction.substring(0, 2) +
-              "." + fraction.substring(2);
-    }
-    while (str.length > 1 && str.charAt(0) == "0" && str.charAt(1) != ".") {
-        str = str.substring(1);
+    var arr = MochiKit.Text.split(str, ".", 2);
+    var frac = MochiKit.Text.padRight(arr[1], 2, "0");
+    var whole = arr[0] + frac.substring(0, 2);
+    frac = frac.substring(2);
+    while (/^0[0-9]/.test(whole)) {
+        whole = whole.substring(1);
     }
-    return str;
-}
+    return (frac.length <= 0) ? whole : whole + "." + frac;
+};
 
 /**
  * Creates a new format pattern error.
  *
  * @param {String} pattern the format pattern string
  * @param {Number} pos the position of the error
  * @param {String} message the error message text
  *
  * @return {Error} the format pattern error
  *
  * @class The format pattern error class. This error is thrown when
  *     a syntax error is encountered inside a format string.
  * @property {String} pattern The format pattern string.
  * @property {Number} pos The position of the error.
  * @property {String} message The error message text.
  * @extends MochiKit.Base.NamedError
  */
 MochiKit.Text.FormatPatternError = function (pattern, pos, message) {
     this.pattern = pattern;
     this.pos = pos;
     this.message = message;
-}
-MochiKit.Text.FormatPatternError.prototype =
-    new MochiKit.Base.NamedError("MochiKit.Text.FormatPatternError");
+};
 
+MochiKit.Text.FormatPatternError.prototype = new MochiKit.Base.NamedError("MochiKit.Text.FormatPatternError");
+MochiKit.Text.FormatPatternError.constructor = MochiKit.Text.FormatPatternError;
 
 //
-//XXX: Internet Explorer exception handling blows
+//XXX: Internet Explorer export fix
 //
 if (MochiKit.__export__) {
     formatter = MochiKit.Text.formatter;
     format = MochiKit.Text.format;
     formatValue = MochiKit.Text.formatValue;
 }
 
 
 MochiKit.Base.nameFunctions(MochiKit.Text);
 MochiKit.Base._exportSymbols(this, MochiKit.Text);
diff --git a/frontend/gamma/js/MochiKit/Visual.js b/frontend/gamma/js/MochiKit/Visual.js
index 648d82a..372d99a 100644
--- a/frontend/gamma/js/MochiKit/Visual.js
+++ b/frontend/gamma/js/MochiKit/Visual.js
@@ -1,1050 +1,1064 @@
 /***
 
 MochiKit.Visual 1.5
 
 See <http://mochikit.com/> for documentation, downloads, license, etc.
 
 (c) 2005 Bob Ippolito and others.  All rights Reserved.
 
 ***/
 
-MochiKit.Base._module('Visual', '1.5', ['Base', 'DOM', 'Style', 'Color', 'Position']);
+MochiKit.Base.module(MochiKit, 'Visual', '1.5', ['Base', 'DOM', 'Style', 'Color', 'Position']);
 
 MochiKit.Visual._RoundCorners = function (e, options) {
     e = MochiKit.DOM.getElement(e);
     this._setOptions(options);
     if (this.options.__unstable__wrapElement) {
         e = this._doWrap(e);
     }
 
     var color = this.options.color;
     var C = MochiKit.Color.Color;
     if (this.options.color === "fromElement") {
         color = C.fromBackground(e);
     } else if (!(color instanceof C)) {
         color = C.fromString(color);
     }
     this.isTransparent = (color.asRGB().a <= 0);
 
     var bgColor = this.options.bgColor;
     if (this.options.bgColor === "fromParent") {
         bgColor = C.fromBackground(e.offsetParent);
     } else if (!(bgColor instanceof C)) {
         bgColor = C.fromString(bgColor);
     }
 
     this._roundCornersImpl(e, color, bgColor);
 };
 
 MochiKit.Visual._RoundCorners.prototype = {
     _doWrap: function (e) {
         var parent = e.parentNode;
         var doc = MochiKit.DOM.currentDocument();
         if (typeof(doc.defaultView) === "undefined"
             || doc.defaultView === null) {
             return e;
         }
         var style = doc.defaultView.getComputedStyle(e, null);
         if (typeof(style) === "undefined" || style === null) {
             return e;
         }
         var wrapper = MochiKit.DOM.DIV({"style": {
             display: "block",
             // convert padding to margin
             marginTop: style.getPropertyValue("padding-top"),
             marginRight: style.getPropertyValue("padding-right"),
             marginBottom: style.getPropertyValue("padding-bottom"),
             marginLeft: style.getPropertyValue("padding-left"),
             // remove padding so the rounding looks right
             padding: "0px"
             /*
             paddingRight: "0px",
             paddingLeft: "0px"
             */
         }});
         wrapper.innerHTML = e.innerHTML;
         e.innerHTML = "";
         e.appendChild(wrapper);
         return e;
     },
 
     _roundCornersImpl: function (e, color, bgColor) {
         if (this.options.border) {
             this._renderBorder(e, bgColor);
         }
         if (this._isTopRounded()) {
             this._roundTopCorners(e, color, bgColor);
         }
         if (this._isBottomRounded()) {
             this._roundBottomCorners(e, color, bgColor);
         }
     },
 
     _renderBorder: function (el, bgColor) {
         var borderValue = "1px solid " + this._borderColor(bgColor);
         var borderL = "border-left: "  + borderValue;
         var borderR = "border-right: " + borderValue;
         var style = "style='" + borderL + ";" + borderR +  "'";
         el.innerHTML = "<div " + style + ">" + el.innerHTML + "</div>";
     },
 
     _roundTopCorners: function (el, color, bgColor) {
         var corner = this._createCorner(bgColor);
         for (var i = 0; i < this.options.numSlices; i++) {
             corner.appendChild(
                 this._createCornerSlice(color, bgColor, i, "top")
             );
         }
         el.style.paddingTop = 0;
         el.insertBefore(corner, el.firstChild);
     },
 
     _roundBottomCorners: function (el, color, bgColor) {
         var corner = this._createCorner(bgColor);
         for (var i = (this.options.numSlices - 1); i >= 0; i--) {
             corner.appendChild(
                 this._createCornerSlice(color, bgColor, i, "bottom")
             );
         }
         el.style.paddingBottom = 0;
         el.appendChild(corner);
     },
 
     _createCorner: function (bgColor) {
         var dom = MochiKit.DOM;
         return dom.DIV({style: {backgroundColor: bgColor.toString()}});
     },
 
     _createCornerSlice: function (color, bgColor, n, position) {
         var slice = MochiKit.DOM.SPAN();
 
         var inStyle = slice.style;
         inStyle.backgroundColor = color.toString();
         inStyle.display = "block";
         inStyle.height = "1px";
         inStyle.overflow = "hidden";
         inStyle.fontSize = "1px";
 
         var borderColor = this._borderColor(color, bgColor);
         if (this.options.border && n === 0) {
             inStyle.borderTopStyle = "solid";
             inStyle.borderTopWidth = "1px";
             inStyle.borderLeftWidth = "0px";
             inStyle.borderRightWidth = "0px";
             inStyle.borderBottomWidth = "0px";
             // assumes css compliant box model
             inStyle.height = "0px";
             inStyle.borderColor = borderColor.toString();
         } else if (borderColor) {
             inStyle.borderColor = borderColor.toString();
             inStyle.borderStyle = "solid";
             inStyle.borderWidth = "0px 1px";
         }
 
         if (!this.options.compact && (n == (this.options.numSlices - 1))) {
             inStyle.height = "2px";
         }
 
         this._setMargin(slice, n, position);
         this._setBorder(slice, n, position);
 
         return slice;
     },
 
     _setOptions: function (options) {
         this.options = {
             corners: "all",
             color: "fromElement",
             bgColor: "fromParent",
             blend: true,
             border: false,
             compact: false,
             __unstable__wrapElement: false
         };
         MochiKit.Base.update(this.options, options);
 
         this.options.numSlices = (this.options.compact ? 2 : 4);
     },
 
     _whichSideTop: function () {
         var corners = this.options.corners;
         if (this._hasString(corners, "all", "top")) {
             return "";
         }
 
         var has_tl = (corners.indexOf("tl") != -1);
         var has_tr = (corners.indexOf("tr") != -1);
         if (has_tl && has_tr) {
             return "";
         }
         if (has_tl) {
             return "left";
         }
         if (has_tr) {
             return "right";
         }
         return "";
     },
 
     _whichSideBottom: function () {
         var corners = this.options.corners;
         if (this._hasString(corners, "all", "bottom")) {
             return "";
         }
 
         var has_bl = (corners.indexOf('bl') != -1);
         var has_br = (corners.indexOf('br') != -1);
         if (has_bl && has_br) {
             return "";
         }
         if (has_bl) {
             return "left";
         }
         if (has_br) {
             return "right";
         }
         return "";
     },
 
     _borderColor: function (color, bgColor) {
         if (color == "transparent") {
             return bgColor;
         } else if (this.options.border) {
             return this.options.border;
         } else if (this.options.blend) {
             return bgColor.blendedColor(color);
         }
         return "";
     },
 
 
     _setMargin: function (el, n, corners) {
         var marginSize = this._marginSize(n) + "px";
         var whichSide = (
             corners == "top" ? this._whichSideTop() : this._whichSideBottom()
         );
         var style = el.style;
 
         if (whichSide == "left") {
             style.marginLeft = marginSize;
             style.marginRight = "0px";
         } else if (whichSide == "right") {
             style.marginRight = marginSize;
             style.marginLeft = "0px";
         } else {
             style.marginLeft = marginSize;
             style.marginRight = marginSize;
         }
     },
 
     _setBorder: function (el, n, corners) {
         var borderSize = this._borderSize(n) + "px";
         var whichSide = (
             corners == "top" ? this._whichSideTop() : this._whichSideBottom()
         );
 
         var style = el.style;
         if (whichSide == "left") {
             style.borderLeftWidth = borderSize;
             style.borderRightWidth = "0px";
         } else if (whichSide == "right") {
             style.borderRightWidth = borderSize;
             style.borderLeftWidth = "0px";
         } else {
             style.borderLeftWidth = borderSize;
             style.borderRightWidth = borderSize;
         }
     },
 
     _marginSize: function (n) {
         if (this.isTransparent) {
             return 0;
         }
 
         var o = this.options;
         if (o.compact && o.blend) {
             var smBlendedMarginSizes = [1, 0];
             return smBlendedMarginSizes[n];
         } else if (o.compact) {
             var compactMarginSizes = [2, 1];
             return compactMarginSizes[n];
         } else if (o.blend) {
             var blendedMarginSizes = [3, 2, 1, 0];
             return blendedMarginSizes[n];
         } else {
             var marginSizes = [5, 3, 2, 1];
             return marginSizes[n];
         }
     },
 
     _borderSize: function (n) {
         var o = this.options;
         var borderSizes;
         if (o.compact && (o.blend || this.isTransparent)) {
             return 1;
         } else if (o.compact) {
             borderSizes = [1, 0];
         } else if (o.blend) {
             borderSizes = [2, 1, 1, 1];
         } else if (o.border) {
             borderSizes = [0, 2, 0, 0];
         } else if (this.isTransparent) {
             borderSizes = [5, 3, 2, 1];
         } else {
             return 0;
         }
         return borderSizes[n];
     },
 
     _hasString: function (str) {
         for (var i = 1; i< arguments.length; i++) {
             if (str.indexOf(arguments[i]) != -1) {
                 return true;
             }
         }
         return false;
     },
 
     _isTopRounded: function () {
         return this._hasString(this.options.corners,
             "all", "top", "tl", "tr"
         );
     },
 
     _isBottomRounded: function () {
         return this._hasString(this.options.corners,
             "all", "bottom", "bl", "br"
         );
     },
 
     _hasSingleTextChild: function (el) {
         return (el.childNodes.length == 1 && el.childNodes[0].nodeType == 3);
     }
 };
 
 /** @id MochiKit.Visual.roundElement */
 MochiKit.Visual.roundElement = function (e, options) {
     new MochiKit.Visual._RoundCorners(e, options);
 };
 
 /** @id MochiKit.Visual.roundClass */
 MochiKit.Visual.roundClass = function (tagName, className, options) {
     var elements = MochiKit.DOM.getElementsByTagAndClassName(
         tagName, className
     );
     for (var i = 0; i < elements.length; i++) {
         MochiKit.Visual.roundElement(elements[i], options);
     }
 };
 
 /** @id MochiKit.Visual.tagifyText */
 MochiKit.Visual.tagifyText = function (element, /* optional */tagifyStyle) {
     /***
 
     Change a node text to character in tags.
 
     @param tagifyStyle: the style to apply to character nodes, default to
     'position: relative'.
 
     ***/
     tagifyStyle = tagifyStyle || 'position:relative';
     if (/MSIE/.test(navigator.userAgent)) {
         tagifyStyle += ';zoom:1';
     }
     element = MochiKit.DOM.getElement(element);
     var ma = MochiKit.Base.map;
     ma(function (child) {
         if (child.nodeType == 3) {
             ma(function (character) {
                 element.insertBefore(
                     MochiKit.DOM.SPAN({style: tagifyStyle},
                         character == ' ' ? String.fromCharCode(160) : character), child);
             }, child.nodeValue.split(''));
             MochiKit.DOM.removeElement(child);
         }
     }, element.childNodes);
 };
 
 MochiKit.Visual._forceRerendering = function (element) {
     try {
         element = MochiKit.DOM.getElement(element);
         var n = document.createTextNode(' ');
         element.appendChild(n);
         element.removeChild(n);
     } catch(e) {
     }
 };
 
 /** @id MochiKit.Visual.multiple */
 MochiKit.Visual.multiple = function (elements, effect, /* optional */options) {
     /***
 
     Launch the same effect subsequently on given elements.
 
     ***/
     options = MochiKit.Base.update({
         speed: 0.1, delay: 0.0
     }, options);
     var masterDelay = options.delay;
     var index = 0;
     MochiKit.Base.map(function (innerelement) {
         options.delay = index * options.speed + masterDelay;
         new effect(innerelement, options);
         index += 1;
     }, elements);
 };
 
 MochiKit.Visual.PAIRS = {
     'slide': ['slideDown', 'slideUp'],
     'blind': ['blindDown', 'blindUp'],
     'appear': ['appear', 'fade'],
     'size': ['grow', 'shrink']
 };
 
 /** @id MochiKit.Visual.toggle */
 MochiKit.Visual.toggle = function (element, /* optional */effect, /* optional */options) {
     /***
 
     Toggle an item between two state depending of its visibility, making
     a effect between these states. Default  effect is 'appear', can be
     'slide' or 'blind'.
 
     ***/
     element = MochiKit.DOM.getElement(element);
     effect = (effect || 'appear').toLowerCase();
     options = MochiKit.Base.update({
         queue: {position: 'end', scope: (element.id || 'global'), limit: 1}
     }, options);
     var v = MochiKit.Visual;
     v[MochiKit.Style.getStyle(element, 'display') != 'none' ?
       v.PAIRS[effect][1] : v.PAIRS[effect][0]](element, options);
 };
 
 /***
 
 Transitions: define functions calculating variations depending of a position.
 
 ***/
 
 MochiKit.Visual.Transitions = { __export__: false };
 
 /** @id MochiKit.Visual.Transitions.linear */
 MochiKit.Visual.Transitions.linear = function (pos) {
     return pos;
 };
 
 /** @id MochiKit.Visual.Transitions.sinoidal */
 MochiKit.Visual.Transitions.sinoidal = function (pos) {
     return 0.5 - Math.cos(pos*Math.PI)/2;
 };
 
 /** @id MochiKit.Visual.Transitions.reverse */
 MochiKit.Visual.Transitions.reverse = function (pos) {
     return 1 - pos;
 };
 
 /** @id MochiKit.Visual.Transitions.flicker */
 MochiKit.Visual.Transitions.flicker = function (pos) {
     return 0.25 - Math.cos(pos*Math.PI)/4 + Math.random()/2;
 };
 
 /** @id MochiKit.Visual.Transitions.wobble */
 MochiKit.Visual.Transitions.wobble = function (pos) {
     return 0.5 - Math.cos(9*pos*Math.PI)/2;
 };
 
 /** @id MochiKit.Visual.Transitions.pulse */
 MochiKit.Visual.Transitions.pulse = function (pos, pulses) {
     if (pulses) {
         pos *= 2 * pulses;
     } else {
         pos *= 10;
     }
     var decimals = pos - Math.floor(pos);
     return (Math.floor(pos) % 2 == 0) ? decimals : 1 - decimals;
 };
 
 /** @id MochiKit.Visual.Transitions.parabolic */
 MochiKit.Visual.Transitions.parabolic = function (pos) {
    return pos * pos;
 };
 
+/** @id MochiKit.Visual.Transitions.spring */
+MochiKit.Visual.Transitions.spring = function (pos) {
+   return 1 - (Math.cos(pos * 2.5 * Math.PI) * Math.exp(-pos * 6));
+};
+
 /** @id MochiKit.Visual.Transitions.none */
 MochiKit.Visual.Transitions.none = function (pos) {
     return 0;
 };
 
 /** @id MochiKit.Visual.Transitions.full */
 MochiKit.Visual.Transitions.full = function (pos) {
     return 1;
 };
 
 /***
 
 Core effects
 
 ***/
 
 MochiKit.Visual.ScopedQueue = function () {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls();
     }
     this.__init__();
 };
 MochiKit.Visual.ScopedQueue.__export__ = false;
 
 MochiKit.Base.update(MochiKit.Visual.ScopedQueue.prototype, {
     __init__: function () {
         this.effects = [];
         this.interval = null;
     },
 
     /** @id MochiKit.Visual.ScopedQueue.prototype.add */
     add: function (effect) {
         var timestamp = new Date().getTime();
 
         var position = (typeof(effect.options.queue) == 'string') ?
             effect.options.queue : effect.options.queue.position;
 
         var ma = MochiKit.Base.map;
         switch (position) {
             case 'front':
                 // move unstarted effects after this effect
                 ma(function (e) {
                     if (e.state == 'idle') {
                         e.startOn += effect.finishOn;
                         e.finishOn += effect.finishOn;
                     }
                 }, this.effects);
                 break;
             case 'end':
                 var finish;
                 // start effect after last queued effect has finished
                 ma(function (e) {
                     var i = e.finishOn;
                     if (i >= (finish || i)) {
                         finish = i;
                     }
                 }, this.effects);
                 timestamp = finish || timestamp;
                 break;
             case 'break':
                 ma(function (e) {
                     e.finalize();
                 }, this.effects);
                 break;
+            case 'replace':
+                ma(function (e) {
+                    e.cancel();
+                }, this.effects);
+                break;
         }
 
         effect.startOn += timestamp;
         effect.finishOn += timestamp;
         if (!effect.options.queue.limit ||
             this.effects.length < effect.options.queue.limit) {
             this.effects.push(effect);
         }
 
         if (!this.interval) {
             this.interval = this.startLoop(MochiKit.Base.bind(this.loop, this),
                                         40);
         }
     },
 
     /** @id MochiKit.Visual.ScopedQueue.prototype.startLoop */
     startLoop: function (func, interval) {
         return setInterval(func, interval);
     },
 
     /** @id MochiKit.Visual.ScopedQueue.prototype.remove */
     remove: function (effect) {
         this.effects = MochiKit.Base.filter(function (e) {
             return e != effect;
         }, this.effects);
         if (!this.effects.length) {
             this.stopLoop(this.interval);
             this.interval = null;
         }
     },
 
     /** @id MochiKit.Visual.ScopedQueue.prototype.stopLoop */
     stopLoop: function (interval) {
         clearInterval(interval);
     },
 
     /** @id MochiKit.Visual.ScopedQueue.prototype.loop */
     loop: function () {
         var timePos = new Date().getTime();
         MochiKit.Base.map(function (effect) {
             effect.loop(timePos);
         }, this.effects);
     }
 });
 
 MochiKit.Visual.Queues = {
     __export__: false,
     instances: {},
     get: function (queueName) {
         if (typeof(queueName) != 'string') {
             return queueName;
         }
 
         if (!this.instances[queueName]) {
             this.instances[queueName] = new MochiKit.Visual.ScopedQueue();
         }
         return this.instances[queueName];
     }
 };
 
 MochiKit.Visual.Queue = MochiKit.Visual.Queues.get('global');
 MochiKit.Visual.Queue.__export__ = false;
 
 MochiKit.Visual.DefaultOptions = {
     __export__: false,
     transition: MochiKit.Visual.Transitions.sinoidal,
     duration: 1.0,  // seconds
     fps: 25.0,  // max. 25fps due to MochiKit.Visual.Queue implementation
     sync: false,  // true for combining
     from: 0.0,
     to: 1.0,
     delay: 0.0,
     queue: 'parallel'
 };
 
 MochiKit.Visual.Base = function () {};
 
 MochiKit.Visual.Base.prototype = {
     /***
 
     Basic class for all Effects. Define a looping mechanism called for each step
     of an effect. Don't instantiate it, only subclass it.
 
     ***/
 
     __class__ : MochiKit.Visual.Base,
 
     /** @id MochiKit.Visual.Base.prototype.start */
     start: function (options) {
         var v = MochiKit.Visual;
         this.options = MochiKit.Base.setdefault(options,
                                                 v.DefaultOptions);
         this.currentFrame = 0;
         this.state = 'idle';
         this.startOn = this.options.delay*1000;
         this.finishOn = this.startOn + (this.options.duration*1000);
         this.event('beforeStart');
         if (!this.options.sync) {
             v.Queues.get(typeof(this.options.queue) == 'string' ?
                 'global' : this.options.queue.scope).add(this);
         }
     },
 
     /** @id MochiKit.Visual.Base.prototype.loop */
     loop: function (timePos) {
         if (timePos >= this.startOn) {
             if (timePos >= this.finishOn) {
                 return this.finalize();
             }
             var pos = (timePos - this.startOn) / (this.finishOn - this.startOn);
             var frame =
                 Math.round(pos * this.options.fps * this.options.duration);
             if (frame > this.currentFrame) {
                 this.render(pos);
                 this.currentFrame = frame;
             }
         }
     },
 
     /** @id MochiKit.Visual.Base.prototype.render */
     render: function (pos) {
         if (this.state == 'idle') {
             this.state = 'running';
             this.event('beforeSetup');
             this.setup();
             this.event('afterSetup');
         }
         if (this.state == 'running') {
-            if (this.options.transition) {
-                pos = this.options.transition(pos);
+            var trans = this.options.transition;
+            if (typeof(trans) == "string") {
+                trans = MochiKit.Visual.Transitions[trans];
+            }
+            if (typeof(trans) == "function") {
+                pos = trans(pos);
             }
             pos *= (this.options.to - this.options.from);
             pos += this.options.from;
             this.event('beforeUpdate');
             this.update(pos);
             this.event('afterUpdate');
         }
     },
 
     /** @id MochiKit.Visual.Base.prototype.cancel */
     cancel: function () {
         if (!this.options.sync) {
             MochiKit.Visual.Queues.get(typeof(this.options.queue) == 'string' ?
                 'global' : this.options.queue.scope).remove(this);
         }
         this.state = 'finished';
     },
 
     /** @id MochiKit.Visual.Base.prototype.finalize */
     finalize: function () {
         this.render(1.0);
         this.cancel();
         this.event('beforeFinish');
         this.finish();
         this.event('afterFinish');
     },
 
     setup: function () {
     },
 
     finish: function () {
     },
 
     update: function (position) {
     },
 
     /** @id MochiKit.Visual.Base.prototype.event */
     event: function (eventName) {
         if (this.options[eventName + 'Internal']) {
             this.options[eventName + 'Internal'](this);
         }
         if (this.options[eventName]) {
             this.options[eventName](this);
         }
     },
 
     /** @id MochiKit.Visual.Base.prototype.repr */
     repr: function () {
         return '[' + this.__class__.NAME + ', options:' +
                MochiKit.Base.repr(this.options) + ']';
     }
 };
 
 /** @id MochiKit.Visual.Parallel */
 MochiKit.Visual.Parallel = function (effects, options) {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls(effects, options);
     }
 
     this.__init__(effects, options);
 };
 
 MochiKit.Visual.Parallel.prototype = new MochiKit.Visual.Base();
 
 MochiKit.Base.update(MochiKit.Visual.Parallel.prototype, {
     /***
 
     Run multiple effects at the same time.
 
     ***/
 
     __class__ : MochiKit.Visual.Parallel,
 
     __init__: function (effects, options) {
         this.effects = effects || [];
         this.start(options);
     },
 
     /** @id MochiKit.Visual.Parallel.prototype.update */
     update: function (position) {
         MochiKit.Base.map(function (effect) {
             effect.render(position);
         }, this.effects);
     },
 
     /** @id MochiKit.Visual.Parallel.prototype.finish */
     finish: function () {
         MochiKit.Base.map(function (effect) {
             effect.finalize();
         }, this.effects);
     }
 });
 
 /** @id MochiKit.Visual.Sequence */
 MochiKit.Visual.Sequence = function (effects, options) {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls(effects, options);
     }
     this.__init__(effects, options);
 };
 
 MochiKit.Visual.Sequence.prototype = new MochiKit.Visual.Base();
 
 MochiKit.Base.update(MochiKit.Visual.Sequence.prototype, {
 
     __class__ : MochiKit.Visual.Sequence,
 
     __init__: function (effects, options) {
         var defs = { transition: MochiKit.Visual.Transitions.linear,
                      duration: 0 };
         this.effects = effects || [];
         MochiKit.Base.map(function (effect) {
             defs.duration += effect.options.duration;
         }, this.effects);
         MochiKit.Base.setdefault(options, defs);
         this.start(options);
     },
 
     /** @id MochiKit.Visual.Sequence.prototype.update */
     update: function (position) {
         var time = position * this.options.duration;
         for (var i = 0; i < this.effects.length; i++) {
             var effect = this.effects[i];
             if (time <= effect.options.duration) {
                 effect.render(time / effect.options.duration);
                 break;
             } else {
                 time -= effect.options.duration;
             }
         }
     },
 
     /** @id MochiKit.Visual.Sequence.prototype.finish */
     finish: function () {
         MochiKit.Base.map(function (effect) {
             effect.finalize();
         }, this.effects);
     }
 });
 
 /** @id MochiKit.Visual.Opacity */
 MochiKit.Visual.Opacity = function (element, options) {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls(element, options);
     }
     this.__init__(element, options);
 };
 
 MochiKit.Visual.Opacity.prototype = new MochiKit.Visual.Base();
 
 MochiKit.Base.update(MochiKit.Visual.Opacity.prototype, {
     /***
 
     Change the opacity of an element.
 
     @param options: 'from' and 'to' change the starting and ending opacities.
     Must be between 0.0 and 1.0. Default to current opacity and 1.0.
 
     ***/
 
     __class__ : MochiKit.Visual.Opacity,
 
     __init__: function (element, /* optional */options) {
         var b = MochiKit.Base;
         var s = MochiKit.Style;
         this.element = MochiKit.DOM.getElement(element);
         // make this work on IE on elements without 'layout'
         if (this.element.currentStyle &&
             (!this.element.currentStyle.hasLayout)) {
             s.setStyle(this.element, {zoom: 1});
         }
         options = b.update({
             from: s.getStyle(this.element, 'opacity') || 0.0,
             to: 1.0
         }, options);
         this.start(options);
     },
 
     /** @id MochiKit.Visual.Opacity.prototype.update */
     update: function (position) {
         MochiKit.Style.setStyle(this.element, {'opacity': position});
     }
 });
 
 /**  @id MochiKit.Visual.Move.prototype */
 MochiKit.Visual.Move = function (element, options) {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls(element, options);
     }
     this.__init__(element, options);
 };
 
 MochiKit.Visual.Move.prototype = new MochiKit.Visual.Base();
 
 MochiKit.Base.update(MochiKit.Visual.Move.prototype, {
     /***
 
     Move an element between its current position to a defined position
 
     @param options: 'x' and 'y' for final positions, default to 0, 0.
 
     ***/
 
     __class__ : MochiKit.Visual.Move,
 
     __init__: function (element, /* optional */options) {
         this.element = MochiKit.DOM.getElement(element);
         options = MochiKit.Base.update({
             x: 0,
             y: 0,
             mode: 'relative'
         }, options);
         this.start(options);
     },
 
     /** @id MochiKit.Visual.Move.prototype.setup */
     setup: function () {
         // Bug in Opera: Opera returns the 'real' position of a static element
         // or relative element that does not have top/left explicitly set.
         // ==> Always set top and left for position relative elements in your
         // stylesheets (to 0 if you do not need them)
         MochiKit.Style.makePositioned(this.element);
 
         var s = this.element.style;
         var originalVisibility = s.visibility;
         var originalDisplay = s.display;
         if (originalDisplay == 'none') {
             s.visibility = 'hidden';
             s.display = '';
         }
 
         this.originalLeft = parseFloat(MochiKit.Style.getStyle(this.element, 'left') || '0');
         this.originalTop = parseFloat(MochiKit.Style.getStyle(this.element, 'top') || '0');
 
         if (this.options.mode == 'absolute') {
             // absolute movement, so we need to calc deltaX and deltaY
             this.options.x -= this.originalLeft;
             this.options.y -= this.originalTop;
         }
         if (originalDisplay == 'none') {
             s.visibility = originalVisibility;
             s.display = originalDisplay;
         }
     },
 
     /** @id MochiKit.Visual.Move.prototype.update */
     update: function (position) {
         MochiKit.Style.setStyle(this.element, {
             left: Math.round(this.options.x * position + this.originalLeft) + 'px',
             top: Math.round(this.options.y * position + this.originalTop) + 'px'
         });
     }
 });
 
 /** @id MochiKit.Visual.Scale */
 MochiKit.Visual.Scale = function (element, percent, options) {
     var cls = arguments.callee;
     if (!(this instanceof cls)) {
         return new cls(element, percent, options);
     }
     this.__init__(element, percent, options);
 };
 
 MochiKit.Visual.Scale.prototype = new MochiKit.Visual.Base();
 
 MochiKit.Base.update(MochiKit.Visual.Scale.prototype, {
     /***
 
     Change the size of an element.
 
     @param percent: final_size = percent*original_size
 
     @param options: several options changing scale behaviour
 
     ***/
 
     __class__ : MochiKit.Visual.Scale,
 
     __init__: function (element, percent, /* optional */options) {
         this.element = MochiKit.DOM.getElement(element);
         options = MochiKit.Base.update({
             scaleX: true,
             scaleY: true,
             scaleContent: true,
             scaleFromCenter: false,
             scaleMode: 'box',  // 'box' or 'contents' or {} with provided values
             scaleFrom: 100.0,
             scaleTo: percent
         }, options);
         this.start(options);
     },
 
     /** @id MochiKit.Visual.Scale.prototype.setup */
     setup: function () {
         this.restoreAfterFinish = this.options.restoreAfterFinish || false;
         this.elementPositioning = MochiKit.Style.getStyle(this.element,
                                                         'position');
 
         var ma = MochiKit.Base.map;
         var b = MochiKit.Base.bind;
         this.originalStyle = {};
         ma(b(function (k) {
                 this.originalStyle[k] = this.element.style[k];
             }, this), ['top', 'left', 'width', 'height', 'fontSize']);
 
         this.originalTop = this.element.offsetTop;
         this.originalLeft = this.element.offsetLeft;
 
         var fontSize = MochiKit.Style.getStyle(this.element,
                                              'font-size') || '100%';
         ma(b(function (fontSizeType) {
             if (fontSize.indexOf(fontSizeType) > 0) {
                 this.fontSize = parseFloat(fontSize);
                 this.fontSizeType = fontSizeType;
             }
         }, this), ['em', 'px', '%']);
 
         this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
 
         if (/^content/.test(this.options.scaleMode)) {
             this.dims = [this.element.scrollHeight, this.element.scrollWidth];
         } else if (this.options.scaleMode == 'box') {
             this.dims = [this.element.offsetHeight, this.element.offsetWidth];
         } else {
             this.dims = [this.options.scaleMode.originalHeight,
                          this.options.scaleMode.originalWidth];
         }
     },
 
     /** @id MochiKit.Visual.Scale.prototype.update */
     update: function (position) {
         var currentScale = (this.options.scaleFrom/100.0) +
                            (this.factor * position);
         if (this.options.scaleContent && this.fontSize) {
             MochiKit.Style.setStyle(this.element, {
                 fontSize: this.fontSize * currentScale + this.fontSizeType
             });
         }
         this.setDimensions(this.dims[0] * currentScale,
                            this.dims[1] * currentScale);
     },
 
     /** @id MochiKit.Visual.Scale.prototype.finish */
     finish: function () {
         if (this.restoreAfterFinish) {
             MochiKit.Style.setStyle(this.element, this.originalStyle);
         }
     },
 
     /** @id MochiKit.Visual.Scale.prototype.setDimensions */
     setDimensions: function (height, width) {
         var d = {};
         var r = Math.round;
         if (/MSIE/.test(navigator.userAgent)) {
             r = Math.ceil;
         }
         if (this.options.scaleX) {
             d.width = r(width) + 'px';
         }
         if (this.options.scaleY) {
             d.height = r(height) + 'px';
         }
         if (this.options.scaleFromCenter) {
             var topd = (height - this.dims[0])/2;
             var leftd = (width - this.dims[1])/2;
             if (this.elementPositioning == 'absolute') {
                 if (this.options.scaleY) {
                     d.top = this.originalTop - topd + 'px';
                 }
                 if (this.options.scaleX) {
                     d.left = this.originalLeft - leftd + 'px';
                 }
             } else {
                 if (this.options.scaleY) {
                     d.top = -topd + 'px';
                 }
                 if (this.options.scaleX) {
                     d.left = -leftd + 'px';
                 }
             }
@@ -1305,671 +1319,658 @@ MochiKit.Visual.fade = function (element, /* optional */ options) {
     @param options: 'to' and 'from' to change opacity.
 
     ***/
     var s = MochiKit.Style;
     var oldOpacity = s.getStyle(element, 'opacity');
     options = MochiKit.Base.update({
         from: s.getStyle(element, 'opacity') || 1.0,
         to: 0.0,
         afterFinishInternal: function (effect) {
             if (effect.options.to !== 0) {
                 return;
             }
             s.hideElement(effect.element);
             s.setStyle(effect.element, {'opacity': oldOpacity});
         }
     }, options);
     return new MochiKit.Visual.Opacity(element, options);
 };
 
 /** @id MochiKit.Visual.appear */
 MochiKit.Visual.appear = function (element, /* optional */ options) {
     /***
 
     Make an element appear.
 
     @param options: 'to' and 'from' to change opacity.
 
     ***/
     var s = MochiKit.Style;
     var v = MochiKit.Visual;
     options = MochiKit.Base.update({
         from: (s.getStyle(element, 'display') == 'none' ? 0.0 :
                s.getStyle(element, 'opacity') || 0.0),
         to: 1.0,
         // force Safari to render floated elements properly
         afterFinishInternal: function (effect) {
             v._forceRerendering(effect.element);
         },
         beforeSetupInternal: function (effect) {
             s.setStyle(effect.element, {'opacity': effect.options.from});
             s.showElement(effect.element);
         }
     }, options);
     return new v.Opacity(element, options);
 };
 
 /** @id MochiKit.Visual.puff */
 MochiKit.Visual.puff = function (element, /* optional */ options) {
     /***
 
     'Puff' an element: grow it to double size, fading it and make it hidden.
 
     ***/
     var s = MochiKit.Style;
     var v = MochiKit.Visual;
     element = MochiKit.DOM.getElement(element);
     var elementDimensions = MochiKit.Style.getElementDimensions(element, true);
     var oldStyle = {
         position: s.getStyle(element, 'position'),
         top: element.style.top,
         left: element.style.left,
         width: element.style.width,
         height: element.style.height,
         opacity: s.getStyle(element, 'opacity')
     };
     options = MochiKit.Base.update({
         beforeSetupInternal: function (effect) {
             MochiKit.Position.absolutize(effect.effects[0].element);
         },
         afterFinishInternal: function (effect) {
             s.hideElement(effect.effects[0].element);
             s.setStyle(effect.effects[0].element, oldStyle);
         },
         scaleContent: true,
         scaleFromCenter: true
     }, options);
     return new v.Parallel(
         [new v.Scale(element, 200,
             {sync: true, scaleFromCenter: options.scaleFromCenter,
              scaleMode: {originalHeight: elementDimensions.h,
                          originalWidth: elementDimensions.w},
              scaleContent: options.scaleContent, restoreAfterFinish: true}),
          new v.Opacity(element, {sync: true, to: 0.0 })],
         options);
 };
 
 /** @id MochiKit.Visual.blindUp */
 MochiKit.Visual.blindUp = function (element, /* optional */ options) {
     /***
 
     Blind an element up: change its vertical size to 0.
 
     ***/
     var d = MochiKit.DOM;
     var s = MochiKit.Style;
     element = d.getElement(element);
     var elementDimensions = s.getElementDimensions(element, true);
     var elemClip = s.makeClipping(element);
     options = MochiKit.Base.update({
         scaleContent: false,
         scaleX: false,
         scaleMode: {originalHeight: elementDimensions.h,
                     originalWidth: elementDimensions.w},
         restoreAfterFinish: true,
         afterFinishInternal: function (effect) {
             s.hideElement(effect.element);
             s.undoClipping(effect.element, elemClip);
         }
     }, options);
     return new MochiKit.Visual.Scale(element, 0, options);
 };
 
 /** @id MochiKit.Visual.blindDown */
 MochiKit.Visual.blindDown = function (element, /* optional */ options) {
     /***
 
     Blind an element down: restore its vertical size.
 
     ***/
     var d = MochiKit.DOM;
     var s = MochiKit.Style;
     element = d.getElement(element);
     var elementDimensions = s.getElementDimensions(element, true);
     var elemClip;
     options = MochiKit.Base.update({
         scaleContent: false,
         scaleX: false,
         scaleFrom: 0,
         scaleMode: {originalHeight: elementDimensions.h,
                     originalWidth: elementDimensions.w},
         restoreAfterFinish: true,
         afterSetupInternal: function (effect) {
             elemClip = s.makeClipping(effect.element);
             s.setStyle(effect.element, {height: '0px'});
             s.showElement(effect.element);
         },
         afterFinishInternal: function (effect) {
             s.undoClipping(effect.element, elemClip);
         }
     }, options);
     return new MochiKit.Visual.Scale(element, 100, options);
 };
 
 /** @id MochiKit.Visual.switchOff */
 MochiKit.Visual.switchOff = function (element, /* optional */ options) {
     /***
 
     Apply a switch-off-like effect.
 
     ***/
     var d = MochiKit.DOM;
     var s = MochiKit.Style;
     element = d.getElement(element);
     var elementDimensions = s.getElementDimensions(element, true);
     var oldOpacity = s.getStyle(element, 'opacity');
     var elemClip;
     options = MochiKit.Base.update({
         duration: 0.7,
         restoreAfterFinish: true,
         beforeSetupInternal: function (effect) {
             s.makePositioned(element);
             elemClip = s.makeClipping(element);
         },
         afterFinishInternal: function (effect) {
             s.hideElement(element);
             s.undoClipping(element, elemClip);
             s.undoPositioned(element);
             s.setStyle(element, {'opacity': oldOpacity});
         }
     }, options);
     var v = MochiKit.Visual;
     return new v.Sequence(
         [new v.appear(element,
                       { sync: true, duration: 0.57 * options.duration,
                         from: 0, transition: v.Transitions.flicker }),
          new v.Scale(element, 1,
                      { sync: true, duration: 0.43 * options.duration,
                        scaleFromCenter: true, scaleX: false,
                        scaleMode: {originalHeight: elementDimensions.h,
                                    originalWidth: elementDimensions.w},
                        scaleContent: false, restoreAfterFinish: true })],
         options);
 };
 
 /** @id MochiKit.Visual.dropOut */
 MochiKit.Visual.dropOut = function (element, /* optional */ options) {
     /***
 
     Make an element fall and disappear.
 
     ***/
     var d = MochiKit.DOM;
     var s = MochiKit.Style;
     element = d.getElement(element);
     var oldStyle = {
         top: s.getStyle(element, 'top'),
         left: s.getStyle(element, 'left'),
         opacity: s.getStyle(element, 'opacity')
     };
 
     options = MochiKit.Base.update({
         duration: 0.5,
         distance: 100,
         beforeSetupInternal: function (effect) {
             s.makePositioned(effect.effects[0].element);
         },
         afterFinishInternal: function (effect) {
             s.hideElement(effect.effects[0].element);
             s.undoPositioned(effect.effects[0].element);
             s.setStyle(effect.effects[0].element, oldStyle);
         }
     }, options);
     var v = MochiKit.Visual;
     return new v.Parallel(
         [new v.Move(element, {x: 0, y: options.distance, sync: true}),
          new v.Opacity(element, {sync: true, to: 0.0})],
         options);
 };
 
 /** @id MochiKit.Visual.shake */
 MochiKit.Visual.shake = function (element, /* optional */ options) {
     /***
 
     Move an element from left to right several times.
 
     ***/
     var d = MochiKit.DOM;
     var v = MochiKit.Visual;
     var s = MochiKit.Style;
     element = d.getElement(element);
     var oldStyle = {
         top: s.getStyle(element, 'top'),
         left: s.getStyle(element, 'left')
     };
     options = MochiKit.Base.update({
         duration: 0.5,
         afterFinishInternal: function (effect) {
             s.undoPositioned(element);
             s.setStyle(element, oldStyle);
         }
     }, options);
     return new v.Sequence(
         [new v.Move(element, { sync: true, duration: 0.1 * options.duration,
                                x: 20, y: 0 }),
          new v.Move(element, { sync: true, duration: 0.2 * options.duration,
                                x: -40, y: 0 }),
          new v.Move(element, { sync: true, duration: 0.2 * options.duration,
                                x: 40, y: 0 }),
          new v.Move(element, { sync: true, duration: 0.2 * options.duration,
                                x: -40, y: 0 }),
          new v.Move(element, { sync: true, duration: 0.2 * options.duration,
                                x: 40, y: 0 }),
          new v.Move(element, { sync: true, duration: 0.1 * options.duration,
                                x: -20, y: 0 })],
         options);
 };
 
 /** @id MochiKit.Visual.slideDown */
 MochiKit.Visual.slideDown = function (element, /* optional */ options) {
     /***
 
     Slide an element down.
     It needs to have the content of the element wrapped in a container
     element with fixed height.
 
     ***/
     var d = MochiKit.DOM;
     var b = MochiKit.Base;
     var s = MochiKit.Style;
     element = d.getElement(element);
     if (!element.firstChild) {
         throw new Error("MochiKit.Visual.slideDown must be used on a element with a child");
     }
     d.removeEmptyTextNodes(element);
     var oldInnerBottom = s.getStyle(element.firstChild, 'bottom') || 0;
     var elementDimensions = s.getElementDimensions(element, true);
     var elemClip;
     options = b.update({
         scaleContent: false,
         scaleX: false,
         scaleFrom: 0,
         scaleMode: {originalHeight: elementDimensions.h,
                     originalWidth: elementDimensions.w},
         restoreAfterFinish: true,
         afterSetupInternal: function (effect) {
             s.makePositioned(effect.element);
             s.makePositioned(effect.element.firstChild);
             if (/Opera/.test(navigator.userAgent)) {
                 s.setStyle(effect.element, {top: ''});
             }
             elemClip = s.makeClipping(effect.element);
             s.setStyle(effect.element, {height: '0px'});
             s.showElement(effect.element);
         },
         afterUpdateInternal: function (effect) {
             var elementDimensions = s.getElementDimensions(effect.element, true);
             s.setStyle(effect.element.firstChild,
                {bottom: (effect.dims[0] - elementDimensions.h) + 'px'});
         },
         afterFinishInternal: function (effect) {
             s.undoClipping(effect.element, elemClip);
             // IE will crash if child is undoPositioned first
             if (/MSIE/.test(navigator.userAgent)) {
                 s.undoPositioned(effect.element);
                 s.undoPositioned(effect.element.firstChild);
             } else {
                 s.undoPositioned(effect.element.firstChild);
                 s.undoPositioned(effect.element);
             }
             s.setStyle(effect.element.firstChild, {bottom: oldInnerBottom});
         }
     }, options);
 
     return new MochiKit.Visual.Scale(element, 100, options);
 };
 
 /** @id MochiKit.Visual.slideUp */
 MochiKit.Visual.slideUp = function (element, /* optional */ options) {
     /***
 
     Slide an element up.
     It needs to have the content of the element wrapped in a container
     element with fixed height.
 
     ***/
     var d = MochiKit.DOM;
     var b = MochiKit.Base;
     var s = MochiKit.Style;
     element = d.getElement(element);
     if (!element.firstChild) {
         throw new Error("MochiKit.Visual.slideUp must be used on a element with a child");
     }
     d.removeEmptyTextNodes(element);
     var oldInnerBottom = s.getStyle(element.firstChild, 'bottom');
     var elementDimensions = s.getElementDimensions(element, true);
     var elemClip;
     options = b.update({
         scaleContent: false,
         scaleX: false,
         scaleMode: {originalHeight: elementDimensions.h,
                     originalWidth: elementDimensions.w},
         scaleFrom: 100,
         restoreAfterFinish: true,
         beforeStartInternal: function (effect) {
             s.makePositioned(effect.element);
             s.makePositioned(effect.element.firstChild);
             if (/Opera/.test(navigator.userAgent)) {
                 s.setStyle(effect.element, {top: ''});
             }
             elemClip = s.makeClipping(effect.element);
             s.showElement(effect.element);
         },
         afterUpdateInternal: function (effect) {
             var elementDimensions = s.getElementDimensions(effect.element, true);
             s.setStyle(effect.element.firstChild,
                 {bottom: (effect.dims[0] - elementDimensions.h) + 'px'});
         },
         afterFinishInternal: function (effect) {
             s.hideElement(effect.element);
             s.undoClipping(effect.element, elemClip);
             s.undoPositioned(effect.element.firstChild);
             s.undoPositioned(effect.element);
             s.setStyle(effect.element.firstChild, {bottom: oldInnerBottom});
         }
     }, options);
     return new MochiKit.Visual.Scale(element, 0, options);
 };
 
 // Bug in opera makes the TD containing this element expand for a instance
 // after finish
 /** @id MochiKit.Visual.squish */
 MochiKit.Visual.squish = function (element, /* optional */ options) {
     /***
 
     Reduce an element and make it disappear.
 
     ***/
     var d = MochiKit.DOM;
     var b = MochiKit.Base;
     var s = MochiKit.Style;
     var elementDimensions = s.getElementDimensions(element, true);
     var elemClip;
     options = b.update({
         restoreAfterFinish: true,
-        scaleMode: {originalHeight: elementDimensions.w,
-                    originalWidth: elementDimensions.h},
+        scaleMode: {originalHeight: elementDimensions.h,
+                    originalWidth: elementDimensions.w},
         beforeSetupInternal: function (effect) {
             elemClip = s.makeClipping(effect.element);
         },
         afterFinishInternal: function (effect) {
             s.hideElement(effect.element);
             s.undoClipping(effect.element, elemClip);
         }
     }, options);
 
     return new MochiKit.Visual.Scale(element, /Opera/.test(navigator.userAgent) ? 1 : 0, options);
 };
 
 /** @id MochiKit.Visual.grow */
 MochiKit.Visual.grow = function (element, /* optional */ options) {
     /***
 
     Grow an element to its original size. Make it zero-sized before
     if necessary.
 
     ***/
     var d = MochiKit.DOM;
     var v = MochiKit.Visual;
     var s = MochiKit.Style;
     element = d.getElement(element);
     options = MochiKit.Base.update({
         direction: 'center',
         moveTransition: v.Transitions.sinoidal,
         scaleTransition: v.Transitions.sinoidal,
         opacityTransition: v.Transitions.full,
         scaleContent: true,
         scaleFromCenter: false
     }, options);
     var oldStyle = {
         top: element.style.top,
         left: element.style.left,
         height: element.style.height,
         width: element.style.width,
         opacity: s.getStyle(element, 'opacity')
     };
     var dims = s.getElementDimensions(element, true);
     var initialMoveX, initialMoveY;
     var moveX, moveY;
 
     switch (options.direction) {
         case 'top-left':
             initialMoveX = initialMoveY = moveX = moveY = 0;
             break;
         case 'top-right':
             initialMoveX = dims.w;
             initialMoveY = moveY = 0;
             moveX = -dims.w;
             break;
         case 'bottom-left':
             initialMoveX = moveX = 0;
             initialMoveY = dims.h;
             moveY = -dims.h;
             break;
         case 'bottom-right':
             initialMoveX = dims.w;
             initialMoveY = dims.h;
             moveX = -dims.w;
             moveY = -dims.h;
             break;
         case 'center':
             initialMoveX = dims.w / 2;
             initialMoveY = dims.h / 2;
             moveX = -dims.w / 2;
             moveY = -dims.h / 2;
             break;
     }
 
     var optionsParallel = MochiKit.Base.update({
         beforeSetupInternal: function (effect) {
             s.setStyle(effect.effects[0].element, {height: '0px'});
             s.showElement(effect.effects[0].element);
         },
         afterFinishInternal: function (effect) {
             s.undoClipping(effect.effects[0].element);
             s.undoPositioned(effect.effects[0].element);
             s.setStyle(effect.effects[0].element, oldStyle);
         }
     }, options);
 
     return new v.Move(element, {
         x: initialMoveX,
         y: initialMoveY,
         duration: 0.01,
         beforeSetupInternal: function (effect) {
             s.hideElement(effect.element);
             s.makeClipping(effect.element);
             s.makePositioned(effect.element);
         },
         afterFinishInternal: function (effect) {
             new v.Parallel(
                 [new v.Opacity(effect.element, {
                     sync: true, to: 1.0, from: 0.0,
                     transition: options.opacityTransition
                  }),
                  new v.Move(effect.element, {
                      x: moveX, y: moveY, sync: true,
                      transition: options.moveTransition
                  }),
                  new v.Scale(effect.element, 100, {
                         scaleMode: {originalHeight: dims.h,
                                     originalWidth: dims.w},
                         sync: true,
                         scaleFrom: /Opera/.test(navigator.userAgent) ? 1 : 0,
                         transition: options.scaleTransition,
                         scaleContent: options.scaleContent,
                         scaleFromCenter: options.scaleFromCenter,
                         restoreAfterFinish: true
                 })
                 ], optionsParallel
             );
         }
     });
 };
 
 /** @id MochiKit.Visual.shrink */
 MochiKit.Visual.shrink = function (element, /* optional */ options) {
     /***
 
     Shrink an element and make it disappear.
 
     ***/
     var d = MochiKit.DOM;
     var v = MochiKit.Visual;
     var s = MochiKit.Style;
     element = d.getElement(element);
     options = MochiKit.Base.update({
         direction: 'center',
         moveTransition: v.Transitions.sinoidal,
         scaleTransition: v.Transitions.sinoidal,
         opacityTransition: v.Transitions.none,
         scaleContent: true,
         scaleFromCenter: false
     }, options);
     var oldStyle = {
         top: element.style.top,
         left: element.style.left,
         height: element.style.height,
         width: element.style.width,
         opacity: s.getStyle(element, 'opacity')
     };
 
     var dims = s.getElementDimensions(element, true);
     var moveX, moveY;
 
     switch (options.direction) {
         case 'top-left':
             moveX = moveY = 0;
             break;
         case 'top-right':
             moveX = dims.w;
             moveY = 0;
             break;
         case 'bottom-left':
             moveX = 0;
             moveY = dims.h;
             break;
         case 'bottom-right':
             moveX = dims.w;
             moveY = dims.h;
             break;
         case 'center':
             moveX = dims.w / 2;
             moveY = dims.h / 2;
             break;
     }
     var elemClip;
 
     var optionsParallel = MochiKit.Base.update({
         beforeStartInternal: function (effect) {
             s.makePositioned(effect.effects[0].element);
             elemClip = s.makeClipping(effect.effects[0].element);
         },
         afterFinishInternal: function (effect) {
             s.hideElement(effect.effects[0].element);
             s.undoClipping(effect.effects[0].element, elemClip);
             s.undoPositioned(effect.effects[0].element);
             s.setStyle(effect.effects[0].element, oldStyle);
         }
     }, options);
 
     return new v.Parallel(
         [new v.Opacity(element, {
             sync: true, to: 0.0, from: 1.0,
             transition: options.opacityTransition
          }),
          new v.Scale(element, /Opera/.test(navigator.userAgent) ? 1 : 0, {
              scaleMode: {originalHeight: dims.h, originalWidth: dims.w},
              sync: true, transition: options.scaleTransition,
              scaleContent: options.scaleContent,
              scaleFromCenter: options.scaleFromCenter,
              restoreAfterFinish: true
          }),
          new v.Move(element, {
              x: moveX, y: moveY, sync: true, transition: options.moveTransition
          })
         ], optionsParallel
     );
 };
 
 /** @id MochiKit.Visual.pulsate */
 MochiKit.Visual.pulsate = function (element, /* optional */ options) {
     /***
 
     Pulse an element between appear/fade.
 
     ***/
     var d = MochiKit.DOM;
     var v = MochiKit.Visual;
     var b = MochiKit.Base;
     var oldOpacity = MochiKit.Style.getStyle(element, 'opacity');
     options = b.update({
         duration: 3.0,
         from: 0,
         afterFinishInternal: function (effect) {
             MochiKit.Style.setStyle(effect.element, {'opacity': oldOpacity});
         }
     }, options);
     var transition = options.transition || v.Transitions.sinoidal;
     options.transition = function (pos) {
         return transition(1 - v.Transitions.pulse(pos, options.pulses));
     };
     return new v.Opacity(element, options);
 };
 
 /** @id MochiKit.Visual.fold */
 MochiKit.Visual.fold = function (element, /* optional */ options) {
     /***
 
     Fold an element, first vertically, then horizontally.
 
     ***/
     var d = MochiKit.DOM;
     var v = MochiKit.Visual;
     var s = MochiKit.Style;
     element = d.getElement(element);
     var elementDimensions = s.getElementDimensions(element, true);
     var oldStyle = {
         top: element.style.top,
         left: element.style.left,
         width: element.style.width,
         height: element.style.height
     };
     var elemClip = s.makeClipping(element);
     options = MochiKit.Base.update({
         scaleContent: false,
         scaleX: false,
         scaleMode: {originalHeight: elementDimensions.h,
                     originalWidth: elementDimensions.w},
         afterFinishInternal: function (effect) {
             new v.Scale(element, 1, {
                 scaleContent: false,
                 scaleY: false,
                 scaleMode: {originalHeight: elementDimensions.h,
                             originalWidth: elementDimensions.w},
                 afterFinishInternal: function (effect) {
                     s.hideElement(effect.element);
                     s.undoClipping(effect.element, elemClip);
                     s.setStyle(effect.element, oldStyle);
                 }
             });
         }
     }, options);
     return new v.Scale(element, 5, options);
 };
 
 
-/* end of Rico adaptation */
-
-MochiKit.Visual.__new__ = function () {
-    var m = MochiKit.Base;
-
-    // Backwards compatibility aliases
-    m._deprecated(this, 'Color', 'MochiKit.Color.Color', '1.1');
-    m._deprecated(this, 'getElementsComputedStyle', 'MochiKit.Style.getStyle', '1.1');
-
-    m.nameFunctions(this);
-};
-
-MochiKit.Visual.__new__();
-
+MochiKit.Base.nameFunctions(MochiKit.Visual);
 MochiKit.Base._exportSymbols(this, MochiKit.Visual);
diff --git a/frontend/gamma/js/MochiKit/__package__.js b/frontend/gamma/js/MochiKit/__package__.js
deleted file mode 100644
index 8d644b1..0000000
--- a/frontend/gamma/js/MochiKit/__package__.js
+++ b/dev/null
@@ -1,18 +0,0 @@
-dojo.kwCompoundRequire({
-    "common": [
-        "MochiKit.Base",
-        "MochiKit.Iter",
-        "MochiKit.Logging",
-        "MochiKit.DateTime",
-        "MochiKit.Format",
-        "MochiKit.Async",
-        "MochiKit.DOM",
-        "MochiKit.Style",
-        "MochiKit.LoggingPane",
-        "MochiKit.Color",
-        "MochiKit.Signal",
-        "MochiKit.Position",
-        "MochiKit.Visual"
-    ]
-});
-dojo.provide("MochiKit.*");
diff --git a/frontend/gamma/js/main.js b/frontend/gamma/js/main.js
index a9fd65e..934b325 100644
--- a/frontend/gamma/js/main.js
+++ b/frontend/gamma/js/main.js
@@ -1,93 +1,93 @@
 /*
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 */
 
 function _pm_logEvent(anEvent) {
         //console.log("####", anEvent);
         
         anEvent.preventDefault();
 }
 
 function handleGenericDeferredError(anError) {
         var result;
         
         if (anError instanceof MochiKit.Async.CancelledError) {
                 result = anError;
         } else {
 MochiKit.Logging.logError("## MainController - GENERIC ERROR" + "\n" + "==>> " + anError + " <<==\n" + anError.stack);
 //console.log(anError);
                 result = new MochiKit.Async.CancelledError(anError);
         }
 
         return result;
 }
 
 
 Clipperz.PM.RunTime = {};
 
 
 function run() {
         var shouldShowRegistrationForm;
         var useCompactDesign;
         var controllerParameters;
 
         controllerParameters = {};
 
         //MochiKit.DOM.removeElement('javaScriptAlert');
         Clipperz.PM.Strings.Languages.initSetup();
 
         if (window.location.search.indexOf('registration') != -1) {
                 shouldShowRegistrationForm = true;
         } else {
                 shouldShowRegistrationForm = false;
         }
 
         if (window.location.search.indexOf('autocomplete') != -1) {
                 controllerParameters['autocomplete'] = 'on'
         }
 
         if (window.location.search.indexOf('compact') != -1) {
                 useCompactDesign = true;
         } else {
                 useCompactDesign = false;
         }
         
         if (useCompactDesign == true) {
                 Clipperz.PM.RunTime.mainController = new Clipperz.PM.UI.Compact.Controllers.MainController(controllerParameters);
         } else {
                 Clipperz.PM.RunTime.mainController = new Clipperz.PM.UI.Web.Controllers.MainController(controllerParameters);
         }
 
         Clipperz.PM.RunTime.mainController.run(shouldShowRegistrationForm);
 
-//Clipperz.log("HASH: " + window.location.hash);
-if (window.location.hash != "") {
-        window.location.hash = ""
-}
-//Clipperz.log("HASH cleaned");
+        //Clipperz.log("HASH: " + window.location.hash);
+        //if (window.location.hash != "") {
+        //      window.location.hash = ""
+        //}
+        //Clipperz.log("HASH cleaned");
         //#credentials=base64encoded({username:'joe', passphrase:'clipperz'})
         //MochiKit.Signal.signal(Clipperz.Signal.NotificationCenter, 'doLogin', {username:'joe', passphrase:'clipperz'});
 }
 
 MochiKit.DOM.addLoadEvent(run);
diff --git a/frontend/gamma/properties/gamma.properties.json b/frontend/gamma/properties/gamma.properties.json
index 8f2d98e..0a513e8 100644
--- a/frontend/gamma/properties/gamma.properties.json
+++ b/frontend/gamma/properties/gamma.properties.json
@@ -1,188 +1,191 @@
 {
         "copyright.values": {             
-                "mochikit.repository": "http://svn.mochikit.com/mochikit/trunk/",
-                "mochikit.version": "1506"
+                "mochikit.repository": "https://github.com/mochi/mochikit.git",
+                "mochikit.version": "fe8d17bb9ac0a4e5ad4a8d5c2c94a6fac1c92d75"
         },
+
+        "html.template": "index_template.html",
+
         "js": [
                 "MochiKit/Base.js",
                 "MochiKit/Iter.js",
                 "MochiKit/Logging.js",
                 "-- MochiKit/DateTime.js",
                 "MochiKit/Format.js",
                 "MochiKit/Async.js",
                 "MochiKit/DOM.js",
                 "MochiKit/Style.js",
                 "MochiKit/LoggingPane.js",
                 "MochiKit/Color.js",
                 "MochiKit/Signal.js",
                 "MochiKit/Position.js",
                 "MochiKit/Selector.js",
                 "MochiKit/Visual.js",
 
                 "JSON/json2.js",
 
                 "Clipperz/YUI/Utils.js",
                 "Clipperz/YUI/DomHelper.js",
 
                 "Clipperz/ByteArray.js",
                 "Clipperz/Base.js",
                 "Clipperz/Async.js",
                 "Clipperz/CSVProcessor.js",
                 "Clipperz/KeePassExportProcessor.js",
                 "Clipperz/Date.js",
                 "Clipperz/DOM.js",
                 "Clipperz/Logging.js",
                 "Clipperz/Signal.js",
                 "Clipperz/Style.js",
                 "Clipperz/Visual.js",
                 "Clipperz/Set.js",
                 "-- Clipperz/Profile.js",
                 "Clipperz/KeyValueObjectStore.js",
 
                 "Clipperz/Crypto/SHA.js",
                 "Clipperz/Crypto/AES.js",
                 "Clipperz/Crypto/PRNG.js",
                 "Clipperz/Crypto/BigInt.js",
                 "Clipperz/Crypto/Base.js",
                 "Clipperz/Crypto/SRP.js",
                 "Clipperz/Crypto/RSA.js",
 
                 "Clipperz/PM/Strings/Strings_defaults.js",
                 "Clipperz/PM/Strings/Strings_en-US.js",
                 "-- # Clipperz/PM/Strings/Strings_en-GB.js",
                 "-- # Clipperz/PM/Strings/Strings_en-CA.js",
                 "-- Clipperz/PM/Strings/Strings_it-IT.js",
                 "-- Clipperz/PM/Strings/Strings_pt-BR.js",
                 "-- # Clipperz/PM/Strings/Strings_pt-PT.js",
                 "-- Clipperz/PM/Strings/Strings_ja-JP.js",
                 "-- Clipperz/PM/Strings/Strings_zh-CN.js",
                 "-- Clipperz/PM/Strings/Strings_es-ES.js",
                 "-- Clipperz/PM/Strings/Strings_fr-FR.js",
                 "-- # Clipperz/PM/Strings/Strings_de-DE.js",
                 "-- # Clipperz/PM/Strings/Strings_el-GR.js",
                 "-- # Clipperz/PM/Strings/Strings_ru-RU.js",
                 "-- # Clipperz/PM/Strings/Strings_he-IL.js",
                 "Clipperz/PM/Strings.js",
                 "-- Clipperz/PM/Strings/MessagePanelConfigurations.js",
 
                 "Clipperz/PM/Date.js",
 
                 "Clipperz/PM/Toll.js",
                 "Clipperz/PM/Proxy.js",
                 "Clipperz/PM/Proxy/Proxy.JSON.js",
                 "Clipperz/PM/Proxy/Proxy.Offline.js",
                 "Clipperz/PM/Proxy/Proxy.Offline.DataStore.js",
                 "Clipperz/PM/Connection.js",
                 "Clipperz/PM/Crypto.js",
                 "Clipperz/PM/BookmarkletProcessor.js",
 
                 "Clipperz/PM/DataModel/EncryptedRemoteObject.js",
                 "Clipperz/PM/DataModel/User.js",
                 "Clipperz/PM/DataModel/User.Header.Legacy.js",
                 "Clipperz/PM/DataModel/User.Header.RecordIndex.js",
                 "Clipperz/PM/DataModel/User.Header.Preferences.js",
                 "Clipperz/PM/DataModel/User.Header.OneTimePasswords.js",
                 "Clipperz/PM/DataModel/Record.js",
                 "Clipperz/PM/DataModel/Record.Version.js",
                 "Clipperz/PM/DataModel/Record.Version.Field.js",
                 "Clipperz/PM/DataModel/DirectLogin.js",
                 "Clipperz/PM/DataModel/DirectLoginInput.js",
                 "Clipperz/PM/DataModel/DirectLoginBinding.js",
                 "Clipperz/PM/DataModel/DirectLoginFormValue.js",
                 "Clipperz/PM/DataModel/OneTimePassword.js",
 
                 "Clipperz/PM/UI/Canvas/Marks/exclamationMark.js",
                 "Clipperz/PM/UI/Canvas/Marks/questionMark.js",
                 "Clipperz/PM/UI/Canvas/Marks/info.js",
 
                 "Clipperz/PM/UI/Canvas/Features/store.js",
                 "Clipperz/PM/UI/Canvas/Features/protect.js",
                 "Clipperz/PM/UI/Canvas/Features/directLogin.js",
                 "Clipperz/PM/UI/Canvas/Features/share.js",
 
                 "Clipperz/PM/UI/Canvas/Star/normal.js",
 
                 "Clipperz/PM/UI/Canvas/CoverActions/look.js",
                 "Clipperz/PM/UI/Canvas/CoverActions/download.js",
 
                 "Clipperz/PM/UI/Canvas/Tips/open.js",
                 "Clipperz/PM/UI/Canvas/Tips/close.js",
 
                 "Clipperz/PM/UI/Canvas/RegisterButton/normal.js",
 
                 "Clipperz/PM/UI/Canvas/Logo/normal.js",
 
                 "Clipperz/PM/UI/Canvas/GraphicFunctions.js",
 
                 "Clipperz/PM/UI/Common/Components/BaseComponent.js",
                 "Clipperz/PM/UI/Common/Components/Button.js",
                 "Clipperz/PM/UI/Common/Components/ComponentSlot.js",
                 "Clipperz/PM/UI/Common/Components/FaviconComponent.js",
                 "Clipperz/PM/UI/Common/Components/PasswordEntropyDisplay.js",
                 "Clipperz/PM/UI/Common/Components/ProgressBar.js",
                 "Clipperz/PM/UI/Common/Components/SimpleMessagePanel.js",
                 "Clipperz/PM/UI/Common/Components/MessagePanelWithProgressBar.js",
                 "Clipperz/PM/UI/Common/Components/TabPanelComponent.js",
                 "Clipperz/PM/UI/Common/Components/Tooltip.js",
                 "Clipperz/PM/UI/Common/Components/TranslatorWidget.js",
 
                 "Clipperz/PM/UI/Common/Controllers/DirectLoginRunner.js",
                 "Clipperz/PM/UI/Common/Controllers/ProgressBarController.js",
                 "Clipperz/PM/UI/Common/Controllers/TabPanelController.js",
                 "Clipperz/PM/UI/Common/Controllers/WizardController.js",
 
                 "Clipperz/PM/UI/Web/Components/Page.js",
                 "Clipperz/PM/UI/Web/Components/PageHeader.js",
                 "Clipperz/PM/UI/Web/Components/PageFooter.js",
                 "Clipperz/PM/UI/Web/Components/LoginPage.js",
                 "Clipperz/PM/UI/Web/Components/LoginForm.js",
                 "Clipperz/PM/UI/Web/Components/LoginProgress.js",
                 "Clipperz/PM/UI/Web/Components/AppPage.js",
                 "Clipperz/PM/UI/Web/Components/UserInfoBox.js",
                 "Clipperz/PM/UI/Web/Components/TabSidePanel.js",
                 "Clipperz/PM/UI/Web/Components/GridComponent.js",
 
                 "Clipperz/PM/UI/Web/Components/ColumnManager.js",
                 "Clipperz/PM/UI/Web/Components/TextColumnManager.js",
                 "Clipperz/PM/UI/Web/Components/FaviconColumnManager.js",
                 "Clipperz/PM/UI/Web/Components/ImageColumnManager.js",
                 "Clipperz/PM/UI/Web/Components/DateColumnManager.js",
                 "Clipperz/PM/UI/Web/Components/LinkColumnManager.js",
                 "Clipperz/PM/UI/Web/Components/DirectLoginColumnManager.js",
                 "Clipperz/PM/UI/Web/Components/DirectLoginsColumnManager.js",
                 "Clipperz/PM/UI/Web/Components/DeleteObjectColumnManager.js",
                 "Clipperz/PM/UI/Web/Components/CreateNewCardSplashComponent.js",
 
                 "Clipperz/PM/UI/Web/Components/AccountPanel.js",
                 "Clipperz/PM/UI/Web/Components/DataPanel.js",
                 "Clipperz/PM/UI/Web/Components/ToolsPanel.js",
                 "Clipperz/PM/UI/Web/Components/RulerComponent.js",
                 "Clipperz/PM/UI/Web/Components/CardDialogComponent.js",
                 "Clipperz/PM/UI/Web/Components/CardDialogRecordFieldComponent.js",
                 "Clipperz/PM/UI/Web/Components/CardDialogRecordDirectLoginComponent.js",
                 "Clipperz/PM/UI/Web/Components/DirectLoginEditingComponent.js",
                 "Clipperz/PM/UI/Web/Components/DirectLoginEditingBindingComponent.js",
                 "Clipperz/PM/UI/Web/Components/DirectLoginEditingFormValueComponent.js",
                 "Clipperz/PM/UI/Web/Components/BookmarkletComponent.js",
                 "Clipperz/PM/UI/Web/Components/UnlockPasswordComponent.js",
                 "Clipperz/PM/UI/Web/Components/NewUserCreationComponent.js",
                 "Clipperz/PM/UI/Web/Components/PasswordTooltip.js",
 
                 "Clipperz/PM/UI/Web/Controllers/MainController.js",
                 "Clipperz/PM/UI/Web/Controllers/LoginController.js",
                 "Clipperz/PM/UI/Web/Controllers/AppController.js",
                 "Clipperz/PM/UI/Web/Controllers/FilterController.js",
                 "Clipperz/PM/UI/Web/Controllers/GridController.js",
                 "Clipperz/PM/UI/Web/Controllers/CardsController.js",
                 "Clipperz/PM/UI/Web/Controllers/DirectLoginsController.js",
                 "Clipperz/PM/UI/Web/Controllers/CardDialogController.js",
                 "Clipperz/PM/UI/Web/Controllers/DirectLoginWizardController.js",
                 "Clipperz/PM/UI/Web/Controllers/NewUserWizardController.js",
 
                 "main.js"
         ],
 
         "css": [
                 "web.css"
         ]
 }
\ No newline at end of file
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/AES.html b/frontend/gamma/tests/tests/Clipperz/Crypto/AES.html
index 828ccb8..16f64d0 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/AES.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/AES.html
@@ -1,289 +1,288 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <title>Clipperz.Crypto.AES_v3 - TEST</title>
         
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../../js/JSON/json2.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/DomHelper.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/AES.js'></script>
 
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 
 try {
         var block;
         var keyValue;
                 varkey;
         var encryptedBlock;
         var startTime, endTime;
         
         startTime = new Date();
         
         keyValue = new Clipperz.ByteArray("0x00010203050607080a0b0c0d0f10111214151617191a1b1c1e1f202123242526");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
         block = new Clipperz.ByteArray("0x834eadfccac7e1b30664b1aba44815ab");
         encryptedBlock = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(key, block.arrayValues()));
         is(encryptedBlock.toHexString(), "0x1946dabf6a03a2a2c3d0b05080aed6fc", "Test 1");
         
         keyValue = new Clipperz.ByteArray("0x28292a2b2d2e2f30323334353738393a3c3d3e3f41424344464748494b4c4d4e");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
         block = new Clipperz.ByteArray("0xd9dc4dba3021b05d67c0518f72b62bf1");
         encryptedBlock = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(key, block.arrayValues()));
         is(encryptedBlock.toHexString(), "0x5ed301d747d3cc715445ebdec62f2fb4", "Test 2");
 
         keyValue = new Clipperz.ByteArray("0x50515253555657585a5b5c5d5f60616264656667696a6b6c6e6f707173747576");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
         block = new Clipperz.ByteArray("0xa291d86301a4a739f7392173aa3c604c");
         encryptedBlock = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(key, block.arrayValues()));
         is(encryptedBlock.toHexString(), "0x6585c8f43d13a6beab6419fc5935b9d0", "Test 3");
 
         keyValue = new Clipperz.ByteArray("0x78797a7b7d7e7f80828384858788898a8c8d8e8f91929394969798999b9c9d9e");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
         block = new Clipperz.ByteArray("0x4264b2696498de4df79788a9f83e9390");
         encryptedBlock = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(key, block.arrayValues()));
         is(encryptedBlock.toHexString(), "0x2a5b56a596680fcc0e05f5e0f151ecae", "Test 4");
 
         keyValue = new Clipperz.ByteArray("0xa0a1a2a3a5a6a7a8aaabacadafb0b1b2b4b5b6b7b9babbbcbebfc0c1c3c4c5c6");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
         block = new Clipperz.ByteArray("0xee9932b3721804d5a83ef5949245b6f6");
         encryptedBlock = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(key, block.arrayValues()));
         is(encryptedBlock.toHexString(), "0xf5d6ff414fd2c6181494d20c37f2b8c4", "Test 5");
 
         keyValue = new Clipperz.ByteArray("0xc8c9cacbcdcecfd0d2d3d4d5d7d8d9dadcdddedfe1e2e3e4e6e7e8e9ebecedee");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
         block = new Clipperz.ByteArray("0xe6248f55c5fdcbca9cbbb01c88a2ea77");
         encryptedBlock = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(key, block.arrayValues()));
         is(encryptedBlock.toHexString(), "0x85399c01f59fffb5204f19f8482f00b8", "Test 6");
 
         keyValue = new Clipperz.ByteArray("0xf0f1f2f3f5f6f7f8fafbfcfdfe01000204050607090a0b0c0e0f101113141516");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
         block = new Clipperz.ByteArray("0xb8358e41b9dff65fd461d55a99266247");
         encryptedBlock = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(key, block.arrayValues()));
         is(encryptedBlock.toHexString(), "0x92097b4c88a041ddf98144bc8d22e8e7", "Test 7");
 
         keyValue = new Clipperz.ByteArray("0x18191a1b1d1e1f20222324252728292a2c2d2e2f31323334363738393b3c3d3e");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
         block = new Clipperz.ByteArray("0xf0e2d72260af58e21e015ab3a4c0d906");
         encryptedBlock = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(key, block.arrayValues()));
         is(encryptedBlock.toHexString(), "0x89bd5b73b356ab412aef9f76cea2d65c", "Test 8");
 
         keyValue = new Clipperz.ByteArray("0x40414243454647484a4b4c4d4f50515254555657595a5b5c5e5f606163646566");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
         block = new Clipperz.ByteArray("0x475b8b823ce8893db3c44a9f2a379ff7");
         encryptedBlock = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(key, block.arrayValues()));
         is(encryptedBlock.toHexString(), "0x2536969093c55ff9454692f2fac2f530", "Test 9");
 
         keyValue = new Clipperz.ByteArray("0x68696a6b6d6e6f70727374757778797a7c7d7e7f81828384868788898b8c8d8e");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
         block = new Clipperz.ByteArray("0x688f5281945812862f5f3076cf80412f");
         encryptedBlock = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(key, block.arrayValues()));
         is(encryptedBlock.toHexString(), "0x07fc76a872843f3f6e0081ee9396d637", "Test 10");
 
         //-------------------------------------------------------------------------
         //
                 //      Key expansion
         //
         //-------------------------------------------------------------------------
                 //test vector: http://en.wikipedia.org/wiki/Rijndael_key_schedule#Test_vectors
 
         keyValue = new Clipperz.ByteArray("0x0000000000000000000000000000000012345678");
         try {
                 key = new Clipperz.Crypto.AES.Key({key:keyValue});
                 is(true, false, "Unsupported key size");
         } catch (exception) {
                 is(true, true, "Unsupported key size");
         }
         
         keyValue = new Clipperz.ByteArray("0x00000000000000000000000000000000");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
                 is(key.stretchedKey().toHexString(),
                         "0x" +"00000000000000000000000000000000" +
                                 "62636363626363636263636362636363" +
                                 "9b9898c9f9fbfbaa9b9898c9f9fbfbaa" +
                                 "90973450696ccffaf2f457330b0fac99" +
                                 "ee06da7b876a1581759e42b27e91ee2b" +
                                 "7f2e2b88f8443e098dda7cbbf34b9290" +
                                 "ec614b851425758c99ff09376ab49ba7" +
                                 "217517873550620bacaf6b3cc61bf09b" +
                                 "0ef903333ba9613897060a04511dfa9f" +
                                 "b1d4d8e28a7db9da1d7bb3de4c664941" +
                                 "b4ef5bcb3e92e21123e951cf6f8f188e",
                 "Stretched empty key");
 
         
         keyValue = new Clipperz.ByteArray("0x0000000000000000000000000000000000000000000000000000000000000000");
         key = new Clipperz.Crypto.AES.Key({key:keyValue});
                 is(key.stretchedKey().toHexString(),
                         "0x" +"00000000000000000000000000000000" +
                                 "00000000000000000000000000000000" +
                                 "62636363626363636263636362636363" +
                                 "aafbfbfbaafbfbfbaafbfbfbaafbfbfb" +
                                 "6f6c6ccf0d0f0fac6f6c6ccf0d0f0fac" +
                                 "7d8d8d6ad77676917d8d8d6ad7767691" +
                                 "5354edc15e5be26d31378ea23c38810e" +
                                 "968a81c141fcf7503c717a3aeb070cab" +
                                 "9eaa8f28c0f16d45f1c6e3e7cdfe62e9" +
                                 "2b312bdf6acddc8f56bca6b5bdbbaa1e" +
                                 "6406fd52a4f79017553173f098cf1119" +
                                 "6dbba90b0776758451cad331ec71792f" +
                                 "e7b0e89c4347788b16760b7b8eb91a62" +
                                 "74ed0ba1739b7e252251ad14ce20d43b" +
                                 "10f80a1753bf729c45c979e7cb706385",
                 "Stretched empty key");
 
         var roundIndex;
 
         roundIndex = 0;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x00000000000000000000000000000000", "empty key, subKeyAtRound(0)");
         roundIndex = 1;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x00000000000000000000000000000000", "empty key, subKeyAtRound(1)");
         roundIndex = 2;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x62636363626363636263636362636363", "empty key, subKeyAtRound(2)");
         roundIndex = 3;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0xaafbfbfbaafbfbfbaafbfbfbaafbfbfb", "empty key, subKeyAtRound(3)");
         roundIndex = 4;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x6f6c6ccf0d0f0fac6f6c6ccf0d0f0fac", "empty key, subKeyAtRound(4)");
         roundIndex = 5;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x7d8d8d6ad77676917d8d8d6ad7767691", "empty key, subKeyAtRound(5)");
         roundIndex = 6;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x5354edc15e5be26d31378ea23c38810e", "empty key, subKeyAtRound(6)");
         roundIndex = 7;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x968a81c141fcf7503c717a3aeb070cab", "empty key, subKeyAtRound(7)");
         roundIndex = 8;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x9eaa8f28c0f16d45f1c6e3e7cdfe62e9", "empty key, subKeyAtRound(8)");
         roundIndex = 9;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x2b312bdf6acddc8f56bca6b5bdbbaa1e", "empty key, subKeyAtRound(9)");
         roundIndex = 10;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x6406fd52a4f79017553173f098cf1119", "empty key, subKeyAtRound(10)");
         roundIndex = 11;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x6dbba90b0776758451cad331ec71792f", "empty key, subKeyAtRound(11)");
         roundIndex = 12;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0xe7b0e89c4347788b16760b7b8eb91a62", "empty key, subKeyAtRound(12)");
         roundIndex = 13;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x74ed0ba1739b7e252251ad14ce20d43b", "empty key, subKeyAtRound(13)");
         roundIndex = 14;
         is(key.stretchedKey().split(roundIndex*16, roundIndex*16 + 16).toHexString(), "0x10f80a1753bf729c45c979e7cb706385", "empty key, subKeyAtRound(14)");
 
 
         //-------------------------------------------------------------------------
         //
                 //      Encrypt / decrypt
         //
         //-------------------------------------------------------------------------
                 //      Test vectors:http://www.zvon.org/tmRFC/RFC3686/Output/chapter6.html
                 //                              http://www.cs.utsa.edu/~wagner/laws/AEStestRuns.html
                 //                              http://www.ietf.org/rfc/rfc3686.txt
 
         {
                 //
                         //      http://www.cs.utsa.edu/~wagner/laws/AEStestRuns.html    
                 //
                 var key;
                 var plainText;
                 var cipherText;
                 var result;
 
                 //
                         //256-bit key size
                 //
                 
                         //Gladman's Test Data, 256-bit key - encrypt
                 key = new Clipperz.ByteArray("0x2b7e151628aed2a6abf7158809cf4f3c762e7160f38b4da56a784d9045190cfe", 16);
                 plainText = new Clipperz.ByteArray("0x3243f6a8885a308d313198a2e0370734", 16);
                 cipherText = new Clipperz.ByteArray("0x1a6e6c2c662e7da6501ffb62bc9e93f3", 16);
 
                 result = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(new Clipperz.Crypto.AES.Key({key:key}), plainText.arrayValues()));
                 is(result.toHexString(), cipherText.toHexString(), "Gladman's Test Data, 256-bit key - encrypt");
 
                         //AES Specification Test Data, 256-bit key - encrypt
                 key = new Clipperz.ByteArray("0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", 16);
                 plainText = new Clipperz.ByteArray("0x00112233445566778899aabbccddeeff", 16);
                 cipherText = new Clipperz.ByteArray("0x8ea2b7ca516745bfeafc49904b496089", 16);
 
                 result = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(new Clipperz.Crypto.AES.Key({key:key}), plainText.arrayValues()));
                 is(result.toHexString(), cipherText.toHexString(), "AES Specification Test Data, 256-bit key - encrypt");
 
                 //
                         //128-bit key size
                 //
 
                         //Gladman's Test Data, 128-bit key - encrypt
                 key = new Clipperz.ByteArray("0x2b7e151628aed2a6abf7158809cf4f3c", 16);
                 plainText = new Clipperz.ByteArray("0x3243f6a8885a308d313198a2e0370734", 16);
                 cipherText = new Clipperz.ByteArray("0x3925841d02dc09fbdc118597196a0b32", 16);
 
                 result = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(new Clipperz.Crypto.AES.Key({key:key}), plainText.arrayValues()));
                 is(result.toHexString(), cipherText.toHexString(), "Gladman's Test Data, 128-bit key - encrypt");
 
                         //AES Specification Test Data, 128-bit key - encrypt
                 key = new Clipperz.ByteArray("0x000102030405060708090a0b0c0d0e0f", 16);
                 plainText = new Clipperz.ByteArray("0x00112233445566778899aabbccddeeff", 16);
                 cipherText = new Clipperz.ByteArray("0x69c4e0d86a7b0430d8cdb78070b4c55a", 16);
 
                 result = new Clipperz.ByteArray(Clipperz.Crypto.AES.encryptBlock(new Clipperz.Crypto.AES.Key({key:key}), plainText.arrayValues()));
                 is(result.toHexString(), cipherText.toHexString(), "AES Specification Test Data, 128-bit key - encrypt");
                 
         }
 
 
         endTime = new Date();
         MochiKit.Logging.logDebug("elapsed time: " + (endTime - startTime));
         
 //#############################################################################
  
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
         if (!o[k]) {
             s +=  k + ": " + err[k] + "\n";
             o[k] = err[k];
         }
     }
     ok ( false, s );
 }
 
 </script>
 </pre>
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/AES.performance.html b/frontend/gamma/tests/tests/Clipperz/Crypto/AES.performance.html
index 4817096..a90d815 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/AES.performance.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/AES.performance.html
@@ -1,341 +1,340 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <title>Clipperz.Crypto.AES_performance - TEST</title>
         
         <script>
                 jslog_config_enabled = true;
         </script>
         
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
         <script type='text/javascript' src='../../../../js/JSON/json2.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/DomHelper.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Logging.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/AES.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/PRNG.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/Connection.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/Crypto.js'></script>
 
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 Clipperz.Crypto.PRNG.defaultRandomGenerator().fastEntropyAccumulationForTestingPurpose();
 
 try {
 
         var password;
                 varplainText;
                 varencryptedText;
         var decryptedText;
         /*
         password = "trustno1";
         plainText = "The quick brown fox jumps over the lazy dog";
 //console.profile("encrypt");
         encryptedText = Clipperz.PM.Crypto.encryptingFunctions.versions['0.2'].encrypt(password, plainText);
 //console.profileEnd();
 //console.profile("decrypt");
         decryptedText = Clipperz.PM.Crypto.encryptingFunctions.versions['0.2'].decrypt(password, encryptedText);
 //console.profileEnd();
         is(decryptedText, plainText, "simple string encrypted/decrypted");
 */
 
         password = "L7bd9fQMhborMbYcHtlr";
         plainText = {"records":{"f1aac97154a0e52c5e33508afa82df5a9d6dcde24883a240b8c072a3238da0b6":{"label":"imap4all [no]", "key":"f54b5033d1152456acb67974c45ee6771f8411e300c9533359dfacacf60dcbbd", "notes":""}, "c9dae2b7a60b300008306f5ec731b60050250df8f8ff34f7d9cce92762121b99":{"label":"Il manifesto", "key":"6e0ef134503110e72f444e7d102a4b1cc6ae28f2e0b1287c2b1875ff052fc16c", "notes":""}, "70d536c89a86b1aa9e077d6f9c717306a5d6c8d5549789e42dfb4f981484f116":{"label":"OmniGroup applications", "key":"7b432b7dae39ff5951db31947fa721dc012af0da4055760c6df3b02e776ef22c", "notes":"url: http://www.omnigroup.com\n\nLicence owner: Giulio Cesare Solaroli\n\nOmniWeb: EQGP-EMKH-LKWP-MUHQ-OUHL-LDF\nOmniGraffle:\nOmniOutliner:\nOmniDiskSweeper:"}, "111855cedd650dfcbbce597d764583c6b040df4b71f5fa0161fb8d10514ee48f":{"label":"R@cine", "key":"57295772c84669b0a224f435e9b75c797ae5999a2d9473ab50f9384ae54f49d6", "notes":""}, "378a790452de46e1079a99eba2e15094a096b418cccd0262b8b20244eb94d2df":{"label":"NewsGator", "key":"6ee16f6932ee02000c49dbcc685c84074b40d7956e5f4bc1100030a0f9a41f1a", "notes":""}, "30c4f575799fc6908765fc8b54f4a9a483cb32e12aa89feae545976870a9102e":{"label":"GMail - giulio.cesare", "key":"0395efd852b00700bcf78b65350ec15932430df71201d2c53a11b0269b557d1a", "notes":""}, "b2836a864ff081b6f053c3f5f13dfb29c81af33d25a316cdd82af747ea71bea0":{"label":"GMail - clipperz.com", "key":"90d6ae70d89c8211404b6f9d6c70b6b9c113fff74f474a67b34acd9c1c048d1f", "notes":""}, "6ad2cda35f97743cfddf2133cdf3142fe6419e683484531f1ef1e67431f44284":{"label":"Aruba - hosting", "key":"5c7472d24d57391c63ea99ed1fc9de179d225abd335fa65702018cfea6083d47", "notes":""}, "741ce1d21839c69db754309b04ce02fbb4104f6cb87572c056ae4af918420700":{"label":"Aruba - sql hosting", "key":"f6bd942ac3b0b7065771e5197c7499b345a10f7a4843d00c3ba3809d0ea059dc", "notes":""}, "1cef440eecea59f47554aa04b94e18c1d9fc761246b911f89a7da72d544cac48":{"label":"Amazon", "key":"1ae022b4d14b642f113703b2a98931bd892dec2da785ab5ff6fc1d0aac7537f1", "notes":""}, "d34c13773b5d8154355c2605024a1dfaf66279ba0fbe3ac19fc1cbc642278fe4":{"label":"YouTube [no]", "key":"4c6593d4f6448137939b364b84c81501fadb60f7871fe5fa63c93e97bb5c4648", "notes":""}, "5054f0b94cd97610a1bc0ed8671b6fb5b25bf7a5582677059fcaaea75fac27bc":{"label":"DynDns - gcsolaroli", "key":"f8ed9e7a3630deed046eda37ebc63ecb4d63668a2f97224d7628fdc53b242467", "notes":""}, "73fb52ed51533657d6ebb020d5026fb4deb601dadce802de58f7fff4b56e1495":{"label":"DynDns - clipperz", "key":"d8bc295177383a523e67b61b166e0ca956ab4c2ee86800559a009d2716064f6d", "notes":""}, "48d4c0546c032be26ecce4da41e020129afa7fc34cfe164ea72e1c9953d2e6bb":{"label":"Bol.it", "key":"cada5dadeebd8d12190954d21f1a944c8799d034f028be195b448935fcf970c7", "notes":""}, "d62d420db34720ccc054df06b88725ea79020ffa9389ca15e70137fb4dfd0883":{"label":"Freenigma - clipperz.com", "key":"f09cb3790c1110794b834702b8c487c1a42b2508fbe6450a8468477d93790b2e", "notes":""}, "ccd44ae294e7694ea53009c7198506cc0fe3121ad5d9fe2635d247e2afdab2ae":{"label":"Freenigma", "key":"4b05738f6faebc147eac5e425054a91d3cc59dd63844e82d1f0864c0ac8efec7", "notes":""}, "bd5a587bb977a2c728fcd0fa6093dd63a4e62138cf89721115fe45e0396ba5d2":{"label":"clipperz.com - blog", "key":"9cc24328bbce18e8713962428d8123e309a12f7e1d9537bc252e134501734003", "notes":""}, "c2b99939e40d100218baa3ed1cb2a25a5cf726485b0336a0989b104a94157b5f":{"label":"Apple", "key":"75f2651af400629c4e5dd8bcdc3a6c691150d23d6e1a4eb263ff810926d1228f", "notes":""}, "b5bd38d8eb5e23b1354884cc519e05580864fadf74d0a19d2c691cd0c7054d77":{"label":".mac", "key":"5934ae96d2e01282effb368d9086c2ba5d1d856ad91dd6f04f5bace26a1c0cbe", "notes":""}, "ff79a2282cf246add520a3c06e835cf6ffaaae95067d45e8e2e8f44da2501380":{"label":"3nity", "key":"33d84c4a91ab053cbf8115c689ede7e504b81199884de449acc257bea534f57f", "notes":""}, "7b2f2a59ebb34b5a49f20b99b546f08b9f4f62cbefdce9699f8ef7e74aeb0552":{"label":"ACM", "key":"b4976bb0892baba81d628513d191de100d89acd58efbb07c823a5bb4abe48a7a", "notes":""}, "b83a6bac0da3a27eb909d34cbad183e77088952f01d8d5321613b7b01635a020":{"label":"Adobe", "key":"d162bc404994a79ec97e0106c3a4edf2f83aca25def130242e11e95e74bd0aaa", "notes":""}, "befc571e9cda1a7dfb1d15200240ca5170386280ee7be6a12716904cb6d0ea44":{"label":"Adobe Photoshop Elements 3", "key":"18a62c3c2065399819707322f467ff4be030d7939acbe5182c8194599845c428", "notes":"Photoshop Elements 2:\n1057-4312-5223-2206-9509-6837"}, "0424f72608fedc969d64a6d5b4a16dd3ce860a230cd6d87d936439f4dd2aafc7":{"label":"Agatra", "key":"c35158a21b2af75d414232b742ab738d042314e00209f8fca94c8c704c891f23", "notes":""}, "e5e17c29fd598acb4f4c7d621dbdcb045d4d0cabf7d8a19e24420c440cdc3935":{"label":"AIM", "key":"8561ac421d845921978387b5e6b362750b57ed08feda8ec12b9378b69f67ceff", "notes":""}, "de890eb76a4b0cabd4ffd490adad1ff1b73238c7b5ee6dde1a2aeab2d03ebe93":{"label":"Anna Vespignani", "key":"79a970af0d2d30643dc2db4d16757395c1f22c311919036c2a22b7581982144a", "notes":""}, "0dc8d3989d0b35d672c012057d3eb7b111f16e79329e08a9ffb31ac7accbab21":{"label":"Bloglines", "key":"fe81f4df8c42fd81c830f9af408e9b074e77fd430e26d0ee285844fe3b092aec", "notes":""}, "85a40a322a59c80cb46519900269dcc7cf6947213d03dfc9371dd1930373a65b":{"label":"Bow.it", "key":"64a1a9fec99c9238dc8180a01484a1ccf5f50fcd6e9a95a52b8b49fb9ca00bdc", "notes":""}, "60308062a1848a301641a74712d220eef191a280ba0a8355992f0e61ed793811":{"label":"GMail - feedback", "key":"fad310cb2e6152c3faf78b7183c99f3044f5d31ee364068b80580c271a7784ef", "notes":""}, "257ac2da79ee1cd46dfa214d91f5ece213b6bbade28d1ee71495c81a3d7e033a":{"label":"Fineco", "key":"8f99de2635b5dad7987180bc0bff49947eb37cc75d6a5d1ee1f13ed7567465a3", "notes":""}, "78261622810232b6da5efcd52b1c9b0bd87c62517bf4df25323ca6a0b49d84ec":{"label":"mon.itor.us", "key":"d2aa7164007c5deac8bb73580a6ab0d051f747e801ecd30284eff725d0ffaba2", "notes":""}, "4b78dc0376d07e57d77b4c7318d2f222956adb6ff7360b73e60b8bb8b85f3d11":{"label":"Lamba Probe - forum", "key":"f73906817fddba4d8f816334cb2fd0cd5ae91bc29bce6a69fdd5cf98fc96911f", "notes":""}, "78ca2c85908275d788c2f7dd0306ca5e03b83637bb3812272b697e12e9dbf941":{"label":"MeasureMap", "key":"2385ce9536ebb7863b6a4c8b1f5c428587e4d6420a4bbcd31b935cb00bbd768e", "notes":""}, "4c2c7f0d733b647e6f388c9a4590a2a864cd2de259b66aba9b3cf92bdc3cf9bc":{"label":"NGI - Squillo", "key":"96f20c212be02fb38c8b2dfc83d8e864dd84dcb95297a7fecf9280e1e4dcffe3", "notes":""}, "eaeadf6d36f8ee6916c33b9e5bf480b663dc90c0c7f370ff5a1f2fd998cf1143":{"label":"NGI - F5", "key":"00347769244b208647c24e6a64f8fa4213e97eb2135ecfcb277b341c28616a59", "notes":""}, "19654392222206d60547073209672dde1c743ea371ddc20a2bd8254e561a4ec0":{"label":"CVSdude", "key":"ed0ab5080a29eb1b20927142d21ab8f67b61c2c7b19623bb610af030dfd42c02", "notes":""}, "6b10514d50e745f1dab5a40e8629ecf1a8c78a5d6e3895f3637fb67d2d3f9993":{"label":"Yahoo", "key":"6380a7655cd790d1f1e6f482e92ae04201568ff0cab887e65102e9396df1b86e", "notes":"note"}}, "directLogins":{"eac496e0b1ec75ea403f821fedc7f51f98dac639713ebe577f969f607a8943f5":{"record":"111855cedd650dfcbbce597d764583c6b040df4b71f5fa0161fb8d10514ee48f", "label":"R@cine - WebMail", "favicon":"http://www.racine.ra.it/favicon.ico"}, "ef564a022630d4395a9ecac854f3b127b3518cec362323ccc605079c0749c152":{"record":"1cef440eecea59f47554aa04b94e18c1d9fc761246b911f89a7da72d544cac48", "label":"Amazon sign in", "favicon":"http://www.amazon.com/favicon.ico"}, "4f14b88a4055ff23a00d625382650888ce9284fe869304775e43e3e33ee5bbb6":{"record":"6ad2cda35f97743cfddf2133cdf3142fe6419e683484531f1ef1e67431f44284", "label":"Aruba - hosting", "favicon":"http://hosting.aruba.it/favicon.ico"}, "e94c0d12d1db0badc31a8bbbbc4b08d2065a39f458462bbff9756f7b5eb7fedf":{"record":"741ce1d21839c69db754309b04ce02fbb4104f6cb87572c056ae4af918420700", "label":"Aruba - sql hosting", "favicon":"http://mysql.aruba.it/favicon.ico"}, "7299249153ef93a44e2f248ca3a73badde56e71d70919bb5637093c2abbe2c9a":{"record":"bd5a587bb977a2c728fcd0fa6093dd63a4e62138cf89721115fe45e0396ba5d2", "label":"clipperz.com - blog", "favicon":"http://www.clipperz.com/favicon.ico"}, "66876dbae68778d4c104bc12f01adcb21d47d9eace8db30ef95f74f461afcb59":{"record":"73fb52ed51533657d6ebb020d5026fb4deb601dadce802de58f7fff4b56e1495", "label":"DynDns - clipperz", "favicon":"http://www.dyndns.com/favicon.ico"}, "a60c65030a1797abde3e2089c3e5de9648f66bf71cebf0b58c26e729ad8d6a45":{"record":"5054f0b94cd97610a1bc0ed8671b6fb5b25bf7a5582677059fcaaea75fac27bc", "label":"DynDns - gcsolaroli", "favicon":"http://www.dyndns.com/favicon.ico"}, "08d6c5dff9fed4a2f237c32dd0a93ac46b2c45370d07f56fa76064be3b8fecbf":{"record":"30c4f575799fc6908765fc8b54f4a9a483cb32e12aa89feae545976870a9102e", "label":"GMail - giulio.cesare", "favicon":"http://www.google.com/favicon.ico"}, "9e75e12f0f52f248cc7ae517869dd7b02303037d32d9fb4fa0ab0e013923c304":{"record":"c9dae2b7a60b300008306f5ec731b60050250df8f8ff34f7d9cce92762121b99", "label":"Il manifesto", "favicon":"http://abbonati.ilmanifesto.it/favicon.ico"}, "935bf9553fbcb85b8bd5b98c6901d7cccb2566b395f192cbea71e7822979aaf2":{"record":"f1aac97154a0e52c5e33508afa82df5a9d6dcde24883a240b8c072a3238da0b6", "label":"Imap4All.com - account", "favicon":"http://www.imap4all.com/favicon.ico"}, "9504205ec29b89e6ccd0f3afc7a447d8891da0c71a0222f1860f98a8f8bc6677":{"record":"f1aac97154a0e52c5e33508afa82df5a9d6dcde24883a240b8c072a3238da0b6", "label":"Imap4all.com - WebMail", "favicon":"http://webmail.imap4all.com/favicon.ico"}, "3d8dd32d2290ca98789c914580ac2436ece97234217a07d752726d2ac48a4ebf":{"record":"d34c13773b5d8154355c2605024a1dfaf66279ba0fbe3ac19fc1cbc642278fe4", "label":"YouTube [no]", "favicon":"http://www.youtube.com/favicon.ico"}, "7c4b6b5a16984c43ed6d99b04ddfa7e00b624de729ec8aaa3d0f539fb67587e2":{"record":"c2b99939e40d100218baa3ed1cb2a25a5cf726485b0336a0989b104a94157b5f", "label":"Apple Store - Italia", "favicon":"http://store.apple.com/favicon.ico"}, "0b9a98262b50f0ebae5af077467bc627619738873690238fd61093ce9922c9f9":{"record":"ff79a2282cf246add520a3c06e835cf6ffaaae95067d45e8e2e8f44da2501380", "label":"3nity", "favicon":"http://www.3nity.de/favicon.ico"}, "aadeb3388629cfc3b15954f26cf284f52e084191dcdf75752dc4c53d2006c5be":{"record":"7b2f2a59ebb34b5a49f20b99b546f08b9f4f62cbefdce9699f8ef7e74aeb0552", "label":"ACM Web Account", "favicon":"http://portal.acm.org/favicon.ico"}, "3d21c71f2e284ec76f1ae0bb990b683979918f758635bb7d008150f4d7b1447d":{"record":"b83a6bac0da3a27eb909d34cbad183e77088952f01d8d5321613b7b01635a020", "label":"Adobe - Sign In", "favicon":"http://www.adobe.com/favicon.ico"}, "e61a331c998804d46044d4c2acaf96c2fce806f6549e1e16c7d2334872a70953":{"record":"0424f72608fedc969d64a6d5b4a16dd3ce860a230cd6d87d936439f4dd2aafc7", "label":"Agatra [no]", "favicon":"http://www.agatra.com/favicon.ico"}, "9bcd99564fda778061246439fa098dcc79de75b16c542f61e6de7d36dbaf97dc":{"record":"e5e17c29fd598acb4f4c7d621dbdcb045d4d0cabf7d8a19e24420c440cdc3935", "label":"AIM [no]", "favicon":"http://my.screenname.aol.com/favicon.ico"}, "c7093f4663c6e0eba941c557cb86da83fc68cbea36c922e168d0867e6cabe9fe":{"record":"0dc8d3989d0b35d672c012057d3eb7b111f16e79329e08a9ffb31ac7accbab21", "label":"Bloglines", "favicon":"http://www.bloglines.com/favicon.ico"}, "915f2e9460f6e54c6137f3876f9179fc8d2162c59f26e12899c2db6b0e70a68f":{"record":"85a40a322a59c80cb46519900269dcc7cf6947213d03dfc9371dd1930373a65b", "label":"Bow.it", "favicon":"http://www.bow.it/favicon.ico"}, "779701af1beb2a91735ba1a2e471b948f0d985bb0df256f5e089291ce3405bd2":{"record":"b2836a864ff081b6f053c3f5f13dfb29c81af33d25a316cdd82af747ea71bea0", "label":"GMail - Clipperz", "favicon":"http://www.google.com/favicon.ico"}, "1c300539a98c874d52134b6b5a591172acc00c0947692f3da284447f7d511eaf":{"record":"60308062a1848a301641a74712d220eef191a280ba0a8355992f0e61ed793811", "label":"GMail - feedback", "favicon":"http://www.google.com/favicon.ico"}, "f9dccdf7a98735fd7a6b5d04c09177005c0de14f8f92b04007f06a281ecdf31e":{"record":"30c4f575799fc6908765fc8b54f4a9a483cb32e12aa89feae545976870a9102e", "label":"Blogger", "favicon":"http://www.google.com/favicon.ico"}, "48497a89f3bfd567758977e1c32b4497d28c843880667ee52fa4cfcb53c5f9e4":{"record":"378a790452de46e1079a99eba2e15094a096b418cccd0262b8b20244eb94d2df", "label":"NewsGator", "favicon":"http://www.newsgator.com/favicon.ico"}, "134cd28f150df4f2a089f4807bb7a35fb7ece22ec41244f72e63f8b43637a4cd":{"record":"4b78dc0376d07e57d77b4c7318d2f222956adb6ff7360b73e60b8bb8b85f3d11", "label":"Lambda Probe - forum", "favicon":"http://www.lambdaprobe.org/favicon.ico"}, "2ab6106a81513b70f1ba0d7c5c3ef54fa6f4bcadf01d2eeaa2b31b9299551398":{"record":"78ca2c85908275d788c2f7dd0306ca5e03b83637bb3812272b697e12e9dbf941", "label":"Measure Map", "favicon":"http://alpha.measuremap.com/favicon.ico"}, "53ccdc41b43da9b018847f9faa8effb35e7a6c6e78a54e9ee7816fc02f0ea63b":{"record":"4c2c7f0d733b647e6f388c9a4590a2a864cd2de259b66aba9b3cf92bdc3cf9bc", "label":"NGI - Squillo", "favicon":"http://www.ngi.it/favicon.ico"}, "ca520e7081fba1df3ef79c3d00266cffc8e4567def29d67ae812b7ed6283fb12":{"record":"eaeadf6d36f8ee6916c33b9e5bf480b663dc90c0c7f370ff5a1f2fd998cf1143", "label":"NGI - F5", "favicon":"http://www.ngi.it/favicon.ico"}, "80e63e135d7abd2b2990f42af4f8d1f8e8b1146aed44dc36975061fbf360a983":{"record":"6b10514d50e745f1dab5a40e8629ecf1a8c78a5d6e3895f3637fb67d2d3f9993", "label":"Yahoo! Mail", "favicon":"http://login.yahoo.com/favicon.ico"}}, "preferences":{"preferredLanguage":"en-US"}};
 /* */
         plainText = {
                 "records": {
                         "1": {
                                 "label":"imap4all [no]",
                                 "key":"f54b5033d1152456acb67974c45ee6771f8411e300c9533359dfacacf60dcbbd",
                                 "notes":""
                         },
                         "2": {
                                 "label":"Il manifesto",
                                 "key":"6e0ef134503110e72f444e7d102a4b1cc6ae28f2e0b1287c2b1875ff052fc16c",
                                 "notes":""
                         },
                         "3": {
                                 "label": "OmniGroup applications",
                                 "key": "7b432b7dae39ff5951db31947fa721dc012af0da4055760c6df3b02e776ef22c",
                                 "notes": "url: http://www.omnigroup.com\n\nLicence owner: Giulio Cesare Solaroli\n\nOmniWeb: EQGP-EMKH-LKWP-MUHQ-OUHL-LDF\nOmniGraffle:\nOmniOutliner:\nOmniDiskSweeper:"
                         },
                         "4": {
                                 "label": "R@cine",
                                 "key": "57295772c84669b0a224f435e9b75c797ae5999a2d9473ab50f9384ae54f49d6",
                                 "notes": ""
                         },
                         "5": {
                                 "label": "NewsGator",
                                 "key": "6ee16f6932ee02000c49dbcc685c84074b40d7956e5f4bc1100030a0f9a41f1a",
                                 "notes": ""
                         },
                         "6": {
                                 "label": "GMail - giulio.cesare",
                                 "key": "0395efd852b00700bcf78b65350ec15932430df71201d2c53a11b0269b557d1a",
                                 "notes": ""
                         },
                         "7": {
                                 "label": "GMail - clipperz.com",
                                 "key": "90d6ae70d89c8211404b6f9d6c70b6b9c113fff74f474a67b34acd9c1c048d1f",
                                 "notes": ""
                         },
                         "8": {
                                 "label": "Aruba - hosting",
                                 "key": "5c7472d24d57391c63ea99ed1fc9de179d225abd335fa65702018cfea6083d47",
                                 "notes": ""
                         },
                         "9": {
                                 "label": "Aruba - sql hosting",
                                 "key": "f6bd942ac3b0b7065771e5197c7499b345a10f7a4843d00c3ba3809d0ea059dc",
                                 "notes": ""
                         },
                         "10": {
                                 "label": "Amazon",
                                 "key": "1ae022b4d14b642f113703b2a98931bd892dec2da785ab5ff6fc1d0aac7537f1",
                                 "notes": ""
                         },
                         "11": {
                                 "label": "YouTube [no]",
                                 "key": "4c6593d4f6448137939b364b84c81501fadb60f7871fe5fa63c93e97bb5c4648",
                                 "notes": ""
                         },
                         "12": {
                                 "label": "DynDns - gcsolaroli",
                                 "key": "f8ed9e7a3630deed046eda37ebc63ecb4d63668a2f97224d7628fdc53b242467",
                                 "notes": ""
                         },
                         "13": {
                                 "label": "DynDns - clipperz",
                                 "key": "d8bc295177383a523e67b61b166e0ca956ab4c2ee86800559a009d2716064f6d",
                                 "notes": ""
                         },
                         "14": {
                                 "label": "Bol.it",
                                 "key": "cada5dadeebd8d12190954d21f1a944c8799d034f028be195b448935fcf970c7",
                                 "notes": ""
                         },
                         "15": {
                                 "label": "Freenigma - clipperz.com",
                                 "key": "f09cb3790c1110794b834702b8c487c1a42b2508fbe6450a8468477d93790b2e",
                                 "notes": ""
                         },
                         "16": {
                                 "label": "Freenigma",
                                 "key": "4b05738f6faebc147eac5e425054a91d3cc59dd63844e82d1f0864c0ac8efec7",
                                 "notes": ""
                         },
                         "17": {
                                 "label": "clipperz.com - blog",
                                 "key": "9cc24328bbce18e8713962428d8123e309a12f7e1d9537bc252e134501734003",
                                 "notes": ""
                         },
                         "18": {
                                 "label": "Apple",
                                 "key": "75f2651af400629c4e5dd8bcdc3a6c691150d23d6e1a4eb263ff810926d1228f",
                                 "notes": ""
                         },
                         "19": {
                                 "label": ".mac",
                                 "key": "5934ae96d2e01282effb368d9086c2ba5d1d856ad91dd6f04f5bace26a1c0cbe",
                                 "notes": ""
                         },
                         "20": {
                                 "label": "3nity",
                                 "key": "33d84c4a91ab053cbf8115c689ede7e504b81199884de449acc257bea534f57f",
                                 "notes": ""
                         },
                         "21": {
                                 "label": "ACM",
                                 "key": "b4976bb0892baba81d628513d191de100d89acd58efbb07c823a5bb4abe48a7a",
                                 "notes": ""
                         },
                         "22": {
                                 "label": "Adobe",
                                 "key": "d162bc404994a79ec97e0106c3a4edf2f83aca25def130242e11e95e74bd0aaa",
                                 "notes": ""
                         },
                         "23": {
                                 "label": "Adobe Photoshop Elements 3",
                                 "key": "18a62c3c2065399819707322f467ff4be030d7939acbe5182c8194599845c428",
                                 "notes": "Photoshop Elements 2:\n1057-4312-5223-2206-9509-6837"
                         },
                         "24": {
                                 "label": "Agatra",
                                 "key": "c35158a21b2af75d414232b742ab738d042314e00209f8fca94c8c704c891f23",
                                 "notes": ""
                         },
                         "25": {
                                 "label": "AIM",
                                 "key": "8561ac421d845921978387b5e6b362750b57ed08feda8ec12b9378b69f67ceff",
                                 "notes": ""
                         },
                         "26": {
                                 "label": "Anna Vespignani",
                                 "key": "79a970af0d2d30643dc2db4d16757395c1f22c311919036c2a22b7581982144a",
                                 "notes": ""
                         },
                         "27": {
                                 "label": "Bloglines",
                                 "key": "fe81f4df8c42fd81c830f9af408e9b074e77fd430e26d0ee285844fe3b092aec",
                                 "notes": ""
                         },
                         "28": {
                                 "label": "Bow.it",
                                 "key": "64a1a9fec99c9238dc8180a01484a1ccf5f50fcd6e9a95a52b8b49fb9ca00bdc",
                                 "notes": ""
                         },
                         "29": {
                                 "label": "GMail - feedback",
                                 "key": "fad310cb2e6152c3faf78b7183c99f3044f5d31ee364068b80580c271a7784ef",
                                 "notes": ""
                         },
                         "30": {
                                 "label": "Fineco",
                                 "key": "8f99de2635b5dad7987180bc0bff49947eb37cc75d6a5d1ee1f13ed7567465a3",
                                 "notes": ""
                         },
                         "31": {
                                 "label": "mon.itor.us",
                                 "key": "d2aa7164007c5deac8bb73580a6ab0d051f747e801ecd30284eff725d0ffaba2",
                                 "notes": ""
                         },
                         "32": {
                                 "label": "Lamba Probe - forum",
                                 "key": "f73906817fddba4d8f816334cb2fd0cd5ae91bc29bce6a69fdd5cf98fc96911f",
                                 "notes": ""
                         },
                         "33": {
                                 "label": "MeasureMap",
                                 "key": "2385ce9536ebb7863b6a4c8b1f5c428587e4d6420a4bbcd31b935cb00bbd768e",
                                 "notes": ""
                         },
                         "34": {
                                 "label": "NGI - Squillo",
                                 "key": "96f20c212be02fb38c8b2dfc83d8e864dd84dcb95297a7fecf9280e1e4dcffe3",
                                 "notes": ""
                         },
                         "35": {
                                 "label": "NGI - F5",
                                 "key": "00347769244b208647c24e6a64f8fa4213e97eb2135ecfcb277b341c28616a59",
                                 "notes": ""
                         },
                         "36": {
                                 "label": "CVSdude",
                                 "key": "ed0ab5080a29eb1b20927142d21ab8f67b61c2c7b19623bb610af030dfd42c02",
                                 "notes": ""
                         },
                         "37": {
                                 "label": "Yahoo",
                                 "key": "6380a7655cd790d1f1e6f482e92ae04201568ff0cab887e65102e9396df1b86e",
                                 "notes": "note"
                         }
                 },
                 "directLogins": {
                         "1": { "record": "1", "label": "R@cine - WebMail", "favicon": "http://www.racine.ra.it/favicon.ico" },
                         "2": { "record": "2", "label": "Amazon sign in", "favicon": "http://www.amazon.com/favicon.ico" },
                         "3": { "record": "3", "label": "Aruba - hosting", "favicon": "http://hosting.aruba.it/favicon.ico" },
                         "4": { "record": "4", "label": "Aruba - sql hosting", "favicon":"http://mysql.aruba.it/favicon.ico" },
                         "5": { "record": "5", "label":"clipperz.com - blog", "favicon":"http://www.clipperz.com/favicon.ico" },
                         "6": { "record":"6", "label":"DynDns - clipperz", "favicon":"http://www.dyndns.com/favicon.ico" },
                         "7": { "record":"7", "label":"DynDns - gcsolaroli", "favicon":"http://www.dyndns.com/favicon.ico" },
                         "8":{"record":"8", "label":"GMail - giulio.cesare", "favicon":"http://www.google.com/favicon.ico" },
                         "9":{"record":"9", "label":"Il manifesto", "favicon":"http://abbonati.ilmanifesto.it/favicon.ico" },
                         "10":{"record":"10", "label":"Imap4All.com - account", "favicon":"http://www.imap4all.com/favicon.ico" },
                         "11":{"record":"12", "label":"Imap4all.com - WebMail", "favicon":"http://webmail.imap4all.com/favicon.ico" },
                         "13":{"record":"13", "label":"YouTube [no]", "favicon":"http://www.youtube.com/favicon.ico" },
                         "14":{"record":"14", "label":"Apple Store - Italia", "favicon":"http://store.apple.com/favicon.ico" },
                         "15":{"record":"15", "label":"3nity", "favicon":"http://www.3nity.de/favicon.ico" },
                         "16":{"record":"16", "label":"ACM Web Account", "favicon":"http://portal.acm.org/favicon.ico" },
                         "17":{"record":"17", "label":"Adobe - Sign In", "favicon":"http://www.adobe.com/favicon.ico" },
                         "18":{"record":"18", "label":"Agatra [no]", "favicon":"http://www.agatra.com/favicon.ico" },
                         "19":{"record":"19", "label":"AIM [no]", "favicon":"http://my.screenname.aol.com/favicon.ico" },
                         "20":{"record":"20", "label":"Bloglines", "favicon":"http://www.bloglines.com/favicon.ico" },
                         "21":{"record":"21", "label":"Bow.it", "favicon":"http://www.bow.it/favicon.ico" },
                         "22":{"record":"22", "label":"GMail - Clipperz", "favicon":"http://www.google.com/favicon.ico" },
                         "23":{"record":"23", "label":"GMail - feedback", "favicon":"http://www.google.com/favicon.ico" },
                         "24":{"record":"24", "label":"Blogger", "favicon":"http://www.google.com/favicon.ico" },
                         "25":{"record":"25", "label":"NewsGator", "favicon":"http://www.newsgator.com/favicon.ico" },
                         "26":{"record":"26", "label":"Lambda Probe - forum", "favicon":"http://www.lambdaprobe.org/favicon.ico" },
                         "27":{"record":"27", "label":"Measure Map", "favicon":"http://alpha.measuremap.com/favicon.ico" },
                         "28":{"record":"28", "label":"NGI - Squillo", "favicon":"http://www.ngi.it/favicon.ico" },
                         "29":{"record":"29", "label":"NGI - F5", "favicon":"http://www.ngi.it/favicon.ico" },
                         "30":{"record":"30", "label":"Yahoo! Mail", "favicon":"http://login.yahoo.com/favicon.ico"}
                 },
                 "preferences":{"preferredLanguage":"en-US"}
         }
 /* */
 
 //console.profile("encrypt 0.2");
         encryptedText = Clipperz.PM.Crypto.encryptingFunctions.versions['0.2'].encrypt(password, plainText);
 //console.profileEnd();
 //console.profile("decrypt");
         //decryptedText = Clipperz.PM.Crypto.encryptingFunctions.versions['0.2'].decrypt(password, encryptedText);
 //console.profileEnd();
         //is(MochiKit.Base.serializeJSON(decryptedText), MochiKit.Base.serializeJSON(plainText), "complex structure encrypted/decrypted");
 
 //console.profile("encrypt 0.3");
         encryptedText = Clipperz.PM.Crypto.encryptingFunctions.versions['0.3'].encrypt(password, plainText);
 //console.profileEnd();
         decryptedText = Clipperz.PM.Crypto.encryptingFunctions.versions['0.3'].decrypt(password, encryptedText);
         is(MochiKit.Base.serializeJSON(decryptedText), MochiKit.Base.serializeJSON(plainText), "complex structure encrypted/decrypted");
 
 
 //#############################################################################
  
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
         if (!o[k]) {
             s +=  k + ": " + err[k] + "\n";
             o[k] = err[k];
         }
     }
     ok ( false, s );
 }
 
 </script>
 </pre>
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/Base.html b/frontend/gamma/tests/tests/Clipperz/Crypto/Base.html
index 0ffcdb8..83f0766 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/Base.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/Base.html
@@ -1,413 +1,412 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
         <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Functions.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
 
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 try {
         var secretKey;
                 varpublicKey;
                 varplainString;
                 varencryptedString;
 
 
         secretKey = "s3cr37k39";
         plainString = "The Quick Brown Fox Jumps Over The Lazy Dog";
         encryptedString = Clipperz.Crypto.Base.encryptUsingSecretKey(secretKey, plainString);
 
         //-------------------------------------------------------------------------
         //
                 //Secret key encryption / decryption
         //
         is (isUndefinedOrNull(encryptedString), false, "An encrypted string should not be empty");
         is (plainString, Clipperz.Crypto.Base.decryptUsingSecretKey(secretKey, encryptedString), "I should be able to encrypt and then decrypt safely");
 
     try {
                         vardecryptedText;
 
         decryptedText = Clipperz.Crypto.Base.decryptUsingSecretKey("anotherKey", encryptedString);
                 ok( false, "It should not be possible to decrypt a text with a different passphrase (decrypted text: " + decryptedText + ")" );
     } catch (e) {
                 ok( e instanceof Error, "Trying to decrypt a message with the wrong passphrase raised an error" );
     }
 
         is (encryptedString == Clipperz.Crypto.Base.encryptUsingSecretKey(secretKey, plainString), false, "Two consecutive encryption of the same text should return different values");
 
         secretKey = "trustno1";
         plainString = "59fed719f8959a468de367f77a33a7536d53b8e4d25ed49ccc89a94cd6899da90415623fb73386e9635034fb65ad5f248445a1c66703f760d64a8271ad342b1";
         encryptedString = Clipperz.Crypto.Base.encryptUsingSecretKey(secretKey, plainString);
         is (plainString, Clipperz.Crypto.Base.decryptUsingSecretKey(secretKey, encryptedString), "I should be able to encrypt and then decrypt safely");
 
         secretKey = "trustno1";
         plainString = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed pede. Curabitur a mi id nisi euismod rutrum. Phasellus gravida. Ut luctus. Praesent quis leo sit amet orci imperdiet malesuada. Aenean molestie mauris euismod odio. Suspendisse ullamcorper facilisis nisl. Fusce vestibulum consectetuer risus. Curabitur ut turpis eget arcu facilisis ultricies. Morbi elementum, erat vitae dictum imperdiet, nisi purus rutrum odio, eget ornare ipsum nisl in tortor. Duis vestibulum, nulla et bibendum volutpat, mauris metus facilisis elit, vel gravida tortor leo at enim. Vivamus pulvinar lorem vitae tortor. Morbi rhoncus suscipit urna. Praesent placerat tempus augue. Fusce varius dui a nisi consequat ultricies. Curabitur at nisi. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos hymenaeos. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas.";
         encryptedString = Clipperz.Crypto.Base.encryptUsingSecretKey(secretKey, plainString);
         is (plainString, Clipperz.Crypto.Base.decryptUsingSecretKey(secretKey, encryptedString), "I should be able to encrypt and then decrypt safely");
 
         secretKey = "trustno1";
         plainString = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed pede. Curabitur a mi id nisi euismod rutrum. Phasellus gravida. Ut luctus. Praesent quis leo sit amet orci imperdiet malesuada. Aenean molestie mauris euismod odio. Suspendisse ullamcorper facilisis nisl. Fusce vestibulum consectetuer risus. Curabitur ut turpis eget arcu facilisis ultricies. Morbi elementum, erat vitae dictum imperdiet, nisi purus rutrum odio, eget ornare ipsum nisl in tortor. Duis vestibulum, nulla et bibendum volutpat, mauris metus facilisis elit, vel gravida tortor leo at enim. Vivamus pulvinar lorem vitae tortor. Morbi rhoncus suscipit urna. Praesent placerat tempus augue. Fusce varius dui a nisi consequat ultricies. Curabitur at nisi. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos hymenaeos. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas./n/n/nMorbi vel leo non justo condimentum convallis. Vestibulum posuere aliquam nunc. Donec magna magna, euismod nec, pharetra fringilla, tristique mattis, turpis. Duis condimentum lacus eu felis. Sed ultricies. Nullam lacinia ante id diam. Ut quis enim. Fusce at felis quis neque vehicula tempor. Sed feugiat sodales sem. Duis cursus massa in ligula. Vestibulum volutpat, risus in ornare porta, tortor orci vestibulum felis, et eleifend risus odio nec eros. Integer lorem turpis, imperdiet eu, tempor eu, ultricies nec, est. Ut congue. Morbi lacinia vehicula pede. Cras neque sapien, feugiat ac, eleifend eget, mattis et, nisl. Morbi at augue vitae massa laoreet gravida./n/n/nSuspendisse vehicula convallis sem. Sed vel urna. Proin dolor diam, malesuada in, aliquet a, sagittis et, magna. Cras at dui eu mi porta fermentum. Donec pharetra purus sed velit. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Quisque euismod ornare neque. In odio nisi, bibendum non, vulputate ut, tincidunt a, ante. Sed risus arcu, tempus laoreet, euismod id, laoreet mollis, arcu. Ut tempor orci in nibh. Suspendisse potenti. Maecenas accumsan augue at nisl. Donec elementum diam nec metus. Sed vitae lacus sed libero varius semper. Aenean hendrerit tristique arcu. Praesent adipiscing ornare purus. Vestibulum quis eros nec risus accumsan laoreet. Duis consequat ante ut turpis. Curabitur aliquam suscipit ligula. Vivamus adipiscing./n/n/nCurabitur facilisis neque sit amet erat. Aliquam odio augue, vulputate lobortis, rutrum ut, tristique id, leo. Vivamus eu magna. Maecenas et libero. Integer porta, lorem at mollis ullamcorper, purus metus vestibulum erat, ut fringilla dui ante id mi. Morbi vitae ligula. Praesent ornare sapien sed massa. Mauris rhoncus fermentum dolor. Mauris gravida, justo et mollis malesuada, dolor erat fermentum nulla, vel suscipit leo ligula vel augue. Praesent magna enim, dignissim sed, aliquet quis, fermentum viverra, nisi. Vivamus condimentum, nisi quis posuere viverra, enim nunc faucibus lectus, mollis aliquam ipsum enim vel lacus. Suspendisse eget ligula. Aliquam ut metus et justo consectetuer ornare. Donec dapibus tristique pede. Vestibulum interdum ultricies tortor./n/n/nNunc nonummy dictum tortor. Quisque at elit a arcu nonummy elementum. Quisque auctor, risus et sodales euismod, turpis tellus consectetuer ante, quis egestas justo enim quis mi. Nunc fermentum sodales felis. Vivamus odio mi, dignissim vitae, auctor nec, tempus eget, lacus. Ut sapien massa, hendrerit eget, sagittis at, eleifend condimentum, arcu. Curabitur purus orci, facilisis vel, dapibus id, varius rutrum, tortor. Fusce accumsan viverra sem. Quisque tincidunt venenatis risus. Sed tortor justo, volutpat malesuada, sodales ut, vehicula id, magna. Nunc placerat, nibh et imperdiet ultricies, urna nulla luctus sapien, et porta mi odio ac neque. Morbi dignissim. Sed risus pede, adipiscing gravida, pharetra sit amet, convallis non, orci. Morbi adipiscing mauris id massa. Nullam fermentum. Suspendisse eget est";
         encryptedString = Clipperz.Crypto.Base.encryptUsingSecretKey(secretKey, plainString);
         is (plainString, Clipperz.Crypto.Base.decryptUsingSecretKey(secretKey, encryptedString), "I should be able to encrypt and then decrypt safely");
 
         //secretKey = "trustno1";
         //plainString = "{}";
         //      plainString = "{'tags': {'personal': ['ref_1', 'ref_3'], 'business': ['ref_2', 'ref_3']}, 'records': {'ref_1': {'label': 'record_1', 'key': 'key_1'}, 'ref_2': {'label': 'record_2', 'key': 'key_2'}, 'ref_3': {'label': 'record_3', 'key': 'key_3'}}}";
         //plainString = "{'tags': {}, 'records': {'07a5a92fcb334f757998ba14f3251f126d038318b3ac5e584bd712804c548084': {'label': 'Un bel record', 'key': '2a3f261c20a6a98dcc82b13fba013130b759f20602b4b13c5760879e087482a4'}}}";
         //encryptedString = Clipperz.Crypto.Base.encryptUsingSecretKey(secretKey, plainString);
         //is(encryptedString, "{}", "encrypted value");
 
 
         //secretKey = "trustno1";
         //encryptedString = "0d43a4544424ffa519f2e43b7a46f703884fd94ff9879479563f6f252a573b253d3e77bc4f5f30f17bd11d2907718921ab8c9e1faccbe4314793fa323eb85eaf1bfbce5f7deea601e15b781782181cbff3c649dafef39abb70e8573e4f9be220f2286b01c3bd51d5c4a79b9d44a27be3b0994667302e301ca3dc074fb1bc7abc03d12b9e58ba0249435a120858c96e8ae99570718541499ab958a8fb92b63390be070ff61fc6ef107061693ab14c1915118cc6671ab7cf99b9cca553d6b5a7c314bffcd933e0a59f056d842a47cfe8571110b4764c5225443210d99b43b80a23c20fe953de3e1329d72cfb20139fe1ca";
         //plainString = Clipperz.Crypto.Base.decryptUsingSecretKey(secretKey, encryptedString);
         //is(plainString, "{}", "decrypted value");
 
         //-------------------------------------------------------------------------
         //
                 //Java secret key encryption / JavaScript decryption
         //
         secretKey = "s3cr37k39";
         plainString = "The Quick Brown Fox Jumps Over The Lazy Dog";
         encryptedString = "9be538c3dde4dfab9384c0ef71dc624299fbbe71be8d1fe8991fd6cae88a883cf459d7cd56913a2b69815782cf74d7ce5c2c08034661f7f8aa59cf420e913086896840ebb45102d44d733d32de2a7dc8";
         is (plainString, Clipperz.Crypto.Base.decryptUsingSecretKey(secretKey, encryptedString), "I should be able to encrypt and then decrypt safely");
 
         //-------------------------------------------------------------------------
         //
                 //Public key encryption -> Private key decryption
         //
         {
                         varcleanKey;
                         vart1, t2;
 /*
                 //
                         //      128
                 //
                         cleanKey = "248d6a61d20638b8e5c026930c3e6039";  //a33ce45964ff2167f6ecedd419db06c1";
                 publicKey = Clipperz.Crypto.Base.publicKeyWithValues(
                                                 "10001",
                                                 "202700adbd85e2d7182720c3a0ee19c1",
                                                 "30db31542ace0f7d37a629ee5eba28cb"
                 );
                 encryptedString = Clipperz.Crypto.Base.encryptUsingPublicKey(publicKey, cleanKey);
 
                 is (isUndefinedOrNull(encryptedString), false, "An encrypted string is not empty - PUBLIC 128");
                 is (cleanKey, Clipperz.Crypto.Base.decryptUsingPrivateKey(publicKey, encryptedString), "I can encrypt and then decrypt safely  - PUBLIC 128");
                 isnt (cleanKey, Clipperz.Crypto.Base.decryptUsingPublicKey(publicKey, encryptedString), "I should not be able to decrypt using again th public key - PUBLIC 128");
 */
 /*
                 //
                         //      256
                 //
                 cleanKey = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1";
                 cleanKey = "a3c2863242653caf566b02d8be5d6eb6c816ac212378bcec7ff2bdce8e2ec709";
                 publicKey = Clipperz.Crypto.Base.publicKeyWithValues(
                                                 "10001",
                                                 "8064edb1f26944f6bec2b68789db7ffd08b074d0953b76feca71dc8265c60e9",
                                                 "2687f5ac6c70f9cab32fcbded7059502f4c7cc95fc3e09a560c68975ac4bf5e3"
                 );
                 encryptedString = Clipperz.Crypto.Base.encryptUsingPublicKey(publicKey, cleanKey);
 
                 is (isUndefinedOrNull(encryptedString), false, "An encrypted string is not empty - PUBLIC 256");
                 is (cleanKey, Clipperz.Crypto.Base.decryptUsingPrivateKey(publicKey, encryptedString), "I can encrypt and then decrypt safely  - PUBLIC 256");
                 isnt (cleanKey, Clipperz.Crypto.Base.decryptUsingPublicKey(publicKey, encryptedString), "I should not be able to decrypt using again th public key - PUBLIC 256");
 */
 /*
                 //
                         //512
                 //
                 cleanKey = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1";
                 publicKey = Clipperz.Crypto.Base.publicKeyWithValues(
                                                 "10001",
                                                 "59fed719f8959a468de367f77a33a7536d53b8e4d25ed49ccc89a94cd6899da90415623fb73386e9635034fb65ad5f248445a1c66703f760d64a8271ad342b1",
                                                 "8de7066f67be16fcacd05d319b6729cd85fe698c07cec504776146eb7a041d9e3cacbf0fcd86441981c0083eed1f8f1b18393f0b186e47ce1b7b4981417b491"
                 );
 t1 = new Date().getTime();
                 encryptedString = Clipperz.Crypto.Base.encryptUsingPublicKey(publicKey, cleanKey);
 t2 = new Date().getTime();
 //is("Encrypting with public key (512)", (t2 - t1));
 
                 is (isUndefinedOrNull(encryptedString), false, "An encrypted string is not empty - PUBLIC 512");
 t1 = new Date().getTime();
                 is (cleanKey, Clipperz.Crypto.Base.decryptUsingPrivateKey(publicKey, encryptedString), "I can encrypt and then decrypt safely  - PUBLIC 512");
 t2 = new Date().getTime();
 //is("Decrypting with private key (512)", (t2 - t1));
                 isnt (cleanKey, Clipperz.Crypto.Base.decryptUsingPublicKey(publicKey, encryptedString), "I should not be able to decrypt using again th public key - PUBLIC 512");
 */
 /*
                 //
                         //1024
                 //
                 cleanKey = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1";
                 publicKey = Clipperz.Crypto.Base.publicKeyWithValues(
                                                 "10001",
                                                 "12e8da920d4599458e84ec5ef1656161807f427d05eb79182b7418259d6f6c14364d1f5caf9130c8d9d9d6ea71d1bdbc87781a46a16bcb9e672814fed3b9c96ddffe0a1b0955ae68055c8f92fef518a04fc32a2ea8390e617cc5556a251f9ae9eee70a32e579cb3e9f298848a9b3aaf634f5930ffbf74473f7cb6c0cefee1751",
                                                 "130ebebd67b16a9ab2c53a437badbf8f01a80c750095a7fcfe95742c3d5ed1abb318babc5cb5d9350fee4da65ee074f65e1758117e6945f0fcfc8137528053ce9d1da8618890dee24e5e0bf8c87795bb1d09eddd544640824ee0dd0ea9fd908d27b0f8a1ae5c37f3647fbf2f5795500ad76c195b3387d0458a8f51b701472301"
                 );
 t1 = new Date().getTime();
                 encryptedString = Clipperz.Crypto.Base.encryptUsingPublicKey(publicKey, cleanKey);
 t2 = new Date().getTime();
 is("Encrypting with public key (1024)", (t2 - t1));
 
                 is (isUndefinedOrNull(encryptedString), false, "An encrypted string is not empty - PUBLIC 1024");
 t1 = new Date().getTime();
                 is (cleanKey, Clipperz.Crypto.Base.decryptUsingPrivateKey(publicKey, encryptedString), "I can encrypt and then decrypt safely  - PUBLIC 1024");
 t2 = new Date().getTime();
 is("Decrypting with private key (1024)", (t2 - t1));
                 isnt (cleanKey, Clipperz.Crypto.Base.decryptUsingPublicKey(publicKey, encryptedString), "I should not be able to decrypt using again th public key - PUBLIC 1024");
 */
 /*
                 //
                         //2048
                 //
                 cleanKey = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1";
                 publicKey = Clipperz.Crypto.Base.publicKeyWithValues(
                                                 "10001",
                                                 "409c6fe2b6474762b5c07f4e55ef80d174814dc1fb0fb58e979691116fb3dc433f759ff8a88d1a0f0666862b0b3758c54b7355fa87ee827369381e1f97c5d74944e032c7186b51a956fb49d6deb3aee0b2c7e65fc53bfd46d217764850667ed0363de143f3f3d06d5a0018693ad3dacdf78a18d037ceeccb7508776f27b30852b8b505666a8dca5bfbb455d2f85918f8b5295061c97673c78802c5f5cf4581c7215dc32af8dfb6fc10e9ba51fb5a88abab94157ccecf615e104a91a45e9bee072fe7b388344c1bbad4a8f7d5daeccbadf778d59eff2a491a067bba5343c5a094c61b575fe367ecfcc01c3d208c2f8c05b9496a929b2b72e70160d07d07f248f1",
                                                 "9800012b1e533c2c28187424e1289fd4f7fe67487058f5ac7f27f18476c6c93db20b6d2c63d04ff310c1e7211cf8014adc006176529abc53fd1780274fc2629cf51d627c7465c3cbf4f110c3560e2128b97c4ea8a431f0b2a326fc31899790515ad45874ca75c68ee6695558736490ea895d598b8525bccab3156104d360b115ae25e99e9d899a2219136bad0336eeee0c6d725aa9c3b6b923c1ad95a9057b9deb7b563e05614acc800d9d8ec5de405d74feea722c5146feb80829508180ab5c80bf792b83f07c04c73ce0b3cf0d9f74aa92a4704819d103e58f5d4b8ca750148ba1cbab8eb55f92775b18da427c3a0b592809f3853274841a44b7129ec6a623"
                 );
 t1 = new Date().getTime();
                 encryptedString = Clipperz.Crypto.Base.encryptUsingPublicKey(publicKey, cleanKey);
 t2 = new Date().getTime();
 is("Encrypting with public key (2048)", (t2 - t1));
 
                 is (isUndefinedOrNull(encryptedString), false, "An encrypted string is not empty - PUBLIC 2048");
 t1 = new Date().getTime();
                 is (cleanKey, Clipperz.Crypto.Base.decryptUsingPrivateKey(publicKey, encryptedString), "I can encrypt and then decrypt safely  - PUBLIC 2048");
 t2 = new Date().getTime();
 is("Decrypting with private key (2048)", (t2 - t1));
                 isnt (cleanKey, Clipperz.Crypto.Base.decryptUsingPublicKey(publicKey, encryptedString), "I should not be able to decrypt using again th public key - PUBLIC 2048");
 */
         }
         
         //-------------------------------------------------------------------------
         //
                 //Private key encryption -> Public key decryption
         //
         {
                         varcleanKey;
                         vart1, t2;
 /*
                 //
                         //      128
                 //
                         cleanKey = "248d6a61d20638b8e5c026930c3e6039";  //a33ce45964ff2167f6ecedd419db06c1";
                 publicKey = Clipperz.Crypto.Base.publicKeyWithValues(
                                                 "10001",
                                                 "202700adbd85e2d7182720c3a0ee19c1",
                                                 "30db31542ace0f7d37a629ee5eba28cb"
                 );
                 encryptedString = Clipperz.Crypto.Base.encryptUsingPrivateKey(publicKey, cleanKey);
 
                 is (isUndefinedOrNull(encryptedString), false, "An encrypted string is not empty - PRIVATE 128");
                 is (cleanKey, Clipperz.Crypto.Base.decryptUsingPublicKey(publicKey, encryptedString), "I can encrypt and then decrypt safely - PRIVATE 128");
                 isnt (cleanKey, Clipperz.Crypto.Base.decryptUsingPrivateKey(publicKey, encryptedString), "I should not be able to decrypt using again the private key - PRIVATE 128");
 */
 /*
                 //
                         //      256
                 //
                 cleanKey = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1";
                 cleanKey = "a3c2863242653caf566b02d8be5d6eb6c816ac212378bcec7ff2bdce8e2ec709";
                 publicKey = Clipperz.Crypto.Base.publicKeyWithValues(
                                                 "10001",
                                                 "8064edb1f26944f6bec2b68789db7ffd08b074d0953b76feca71dc8265c60e9",
                                                 "2687f5ac6c70f9cab32fcbded7059502f4c7cc95fc3e09a560c68975ac4bf5e3"
                 );
                 encryptedString = Clipperz.Crypto.Base.encryptUsingPrivateKey(publicKey, cleanKey);
 
                 is (isUndefinedOrNull(encryptedString), false, "An encrypted string is not empty - PRIVATE 256");
                 is (cleanKey, Clipperz.Crypto.Base.decryptUsingPublicKey(publicKey, encryptedString), "I can encrypt and then decrypt safely - PRIVATE 256");
                 isnt (cleanKey, Clipperz.Crypto.Base.decryptUsingPrivateKey(publicKey, encryptedString), "I should not be able to decrypt using again the private key - PRIVATE 256");
 */
 /*
                 //
                         //512
                 //
                 cleanKey = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1";
                 publicKey = Clipperz.Crypto.Base.publicKeyWithValues(
                                                 "10001",
                                                 "59fed719f8959a468de367f77a33a7536d53b8e4d25ed49ccc89a94cd6899da90415623fb73386e9635034fb65ad5f248445a1c66703f760d64a8271ad342b1",
                                                 "8de7066f67be16fcacd05d319b6729cd85fe698c07cec504776146eb7a041d9e3cacbf0fcd86441981c0083eed1f8f1b18393f0b186e47ce1b7b4981417b491"
                 );
 t1 = new Date().getTime();
                 encryptedString = Clipperz.Crypto.Base.encryptUsingPrivateKey(publicKey, cleanKey);
 t2 = new Date().getTime();
 //is("Encrypting with private key (512)", (t2 - t1));
 
                 is (isUndefinedOrNull(encryptedString), false, "An encrypted string is not empty - PRIVATE 512");
 t1 = new Date().getTime();
                 is (cleanKey, Clipperz.Crypto.Base.decryptUsingPublicKey(publicKey, encryptedString), "I can encrypt and then decrypt safely - PRIVATE 512");
 t2 = new Date().getTime();
 //is("Decrypting with public key (512)", (t2 - t1));
                 isnt (cleanKey, Clipperz.Crypto.Base.decryptUsingPrivateKey(publicKey, encryptedString), "I should not be able to decrypt using again th public key - PRIVATE 512");
 */
 /*
                 //
                         //1024
                 //
                 cleanKey = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1";
                 publicKey = Clipperz.Crypto.Base.publicKeyWithValues(
                                                 "10001",
                                                 "12e8da920d4599458e84ec5ef1656161807f427d05eb79182b7418259d6f6c14364d1f5caf9130c8d9d9d6ea71d1bdbc87781a46a16bcb9e672814fed3b9c96ddffe0a1b0955ae68055c8f92fef518a04fc32a2ea8390e617cc5556a251f9ae9eee70a32e579cb3e9f298848a9b3aaf634f5930ffbf74473f7cb6c0cefee1751",
                                                 "130ebebd67b16a9ab2c53a437badbf8f01a80c750095a7fcfe95742c3d5ed1abb318babc5cb5d9350fee4da65ee074f65e1758117e6945f0fcfc8137528053ce9d1da8618890dee24e5e0bf8c87795bb1d09eddd544640824ee0dd0ea9fd908d27b0f8a1ae5c37f3647fbf2f5795500ad76c195b3387d0458a8f51b701472301"
                 );
 t1 = new Date().getTime();
                 encryptedString = Clipperz.Crypto.Base.encryptUsingPrivateKey(publicKey, cleanKey);
 t2 = new Date().getTime();
 is("Encrypting with private key (1024)", (t2 - t1));
 
                 is (isUndefinedOrNull(encryptedString), false, "An encrypted string is not empty - PRIVATE 1024");
 t1 = new Date().getTime();
                 is (cleanKey, Clipperz.Crypto.Base.decryptUsingPublicKey(publicKey, encryptedString), "I can encrypt and then decrypt safely - PRIVATE 1024");
 t2 = new Date().getTime();
 is("Decrypting with public key (1024)", (t2 - t1));
                 isnt (cleanKey, Clipperz.Crypto.Base.decryptUsingPrivateKey(publicKey, encryptedString), "I should not be able to decrypt using again th public key - PRIVATE 1024");
 */
 /*
                 //
                         //2048
                 //
                 cleanKey = "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1";
                 publicKey = Clipperz.Crypto.Base.publicKeyWithValues(
                                                 "10001",
                                                 "409c6fe2b6474762b5c07f4e55ef80d174814dc1fb0fb58e979691116fb3dc433f759ff8a88d1a0f0666862b0b3758c54b7355fa87ee827369381e1f97c5d74944e032c7186b51a956fb49d6deb3aee0b2c7e65fc53bfd46d217764850667ed0363de143f3f3d06d5a0018693ad3dacdf78a18d037ceeccb7508776f27b30852b8b505666a8dca5bfbb455d2f85918f8b5295061c97673c78802c5f5cf4581c7215dc32af8dfb6fc10e9ba51fb5a88abab94157ccecf615e104a91a45e9bee072fe7b388344c1bbad4a8f7d5daeccbadf778d59eff2a491a067bba5343c5a094c61b575fe367ecfcc01c3d208c2f8c05b9496a929b2b72e70160d07d07f248f1",
                                                 "9800012b1e533c2c28187424e1289fd4f7fe67487058f5ac7f27f18476c6c93db20b6d2c63d04ff310c1e7211cf8014adc006176529abc53fd1780274fc2629cf51d627c7465c3cbf4f110c3560e2128b97c4ea8a431f0b2a326fc31899790515ad45874ca75c68ee6695558736490ea895d598b8525bccab3156104d360b115ae25e99e9d899a2219136bad0336eeee0c6d725aa9c3b6b923c1ad95a9057b9deb7b563e05614acc800d9d8ec5de405d74feea722c5146feb80829508180ab5c80bf792b83f07c04c73ce0b3cf0d9f74aa92a4704819d103e58f5d4b8ca750148ba1cbab8eb55f92775b18da427c3a0b592809f3853274841a44b7129ec6a623"
                 );
 t1 = new Date().getTime();
                 encryptedString = Clipperz.Crypto.Base.encryptUsingPrivateKey(publicKey, cleanKey);
 t2 = new Date().getTime();
 is("Encrypting with private key (2048)", (t2 - t1));
 
                 is (isUndefinedOrNull(encryptedString), false, "An encrypted string is not empty - PRIVATE 2048");
 t1 = new Date().getTime();
                 is (cleanKey, Clipperz.Crypto.Base.decryptUsingPublicKey(publicKey, encryptedString), "I can encrypt and then decrypt safely - PRIVATE 2048");
 t2 = new Date().getTime();
 is("Decrypting with public key (2048)", (t2 - t1));
                 isnt (cleanKey, Clipperz.Crypto.Base.decryptUsingPrivateKey(publicKey, encryptedString), "I should not be able to decrypt using again th public key - PRIVATE 2048");
 */
         }
 
                 varoriginalMessage;
                 varprocessedMessage;
         var expectedResult;
 
         //-------------------------------------------------------------------------
         //
                 //      HashSHA-256
         //
         
         originalMessage = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
         expectedResult =  "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1";
         processedMessage = Clipperz.Crypto.Base.computeHashValue(originalMessage);
         is(processedMessage, expectedResult, "");
 
         originalMessage = "";
         expectedResult =  "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
         processedMessage = Clipperz.Crypto.Base.computeHashValue(originalMessage);
         is(processedMessage, expectedResult, "");
         
         originalMessage = "abc";
         expectedResult =  "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad";
         processedMessage = Clipperz.Crypto.Base.computeHashValue(originalMessage);
         is(processedMessage, expectedResult, "");
 
         originalMessage = "message digest";
         expectedResult =  "f7846f55cf23e14eebeab5b4e1550cad5b509e3348fbc4efa3a1413d393cb650";
         processedMessage = Clipperz.Crypto.Base.computeHashValue(originalMessage);
         is(processedMessage, expectedResult, "");
 
         originalMessage = "secure hash algorithm";
         expectedResult =  "f30ceb2bb2829e79e4ca9753d35a8ecc00262d164cc077080295381cbd643f0d";
         processedMessage = Clipperz.Crypto.Base.computeHashValue(originalMessage);
         is(processedMessage, expectedResult, "");
 
         originalMessage = "SHA256 is considered to be safe";
         expectedResult =  "6819d915c73f4d1e77e4e1b52d1fa0f9cf9beaead3939f15874bd988e2a23630";
         processedMessage = Clipperz.Crypto.Base.computeHashValue(originalMessage);
         is(processedMessage, expectedResult, "");
 
         originalMessage = "For this sample, this 63-byte string will be used as input data";
         expectedResult =  "f08a78cbbaee082b052ae0708f32fa1e50c5c421aa772ba5dbb406a2ea6be342";
         processedMessage = Clipperz.Crypto.Base.computeHashValue(originalMessage);
         is(processedMessage, expectedResult, "");
 
         originalMessage = "This is exactly 64 bytes long, not counting the terminating byte";
         expectedResult =  "ab64eff7e88e2e46165e29f2bce41826bd4c7b3552f6b382a9e7d3af47c245f8";
         processedMessage = Clipperz.Crypto.Base.computeHashValue(originalMessage);
         is(processedMessage, expectedResult, "");
 
         originalMessage = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Ut urna diam, vulputate quis, tempus vel, pretium in, mauris. Mauris aliquet sem a elit. Nunc molestie rutrum sem.";
         expectedResult =  "528059709af4087fb8cd4427e291d89f24d8c0429b2a3b6fd152c32ce5b4680f";
         processedMessage = Clipperz.Crypto.Base.computeHashValue(originalMessage);
         is(processedMessage, expectedResult, "");
 
         //-------------------------------------------------------------------------
         //
                 //      HashMD5
         //
         originalMessage = "59fed719f8959a468de367f77a33a7536d53b8e4d25ed49ccc89a94cd6899da9";
         expectedResult =  "fde790d7da7d0d54a8db4ac500f1bbdb";
         processedMessage = Clipperz.Crypto.Base.computeMD5HashValue(originalMessage);
         is(processedMessage, expectedResult, "");
 
 
 
 
         //-------------------------------------------------------------------------
         //
                 //Random seed
         //
                 varrandomSeed;
         
         randomSeed = Clipperz.Crypto.Base.generateRandomSeed();
         is(randomSeed.length, 64, "");
 
         ok(randomSeed != Clipperz.Crypto.Base.generateRandomSeed(), "");
 
 //#############################################################################
  
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/BigInt.html b/frontend/gamma/tests/tests/Clipperz/Crypto/BigInt.html
index b970a9a..f4db3b7 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/BigInt.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/BigInt.html
@@ -1,413 +1,412 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/DomHelper.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Functions.js'></script>
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 try {
                 varbigInt_1;
                 varbigInt_2;
                 varresult;
                 varexpectedResult;
         
         //
                 //Constructur and equality test
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("110");
         is (bigInt_1.equals(bigInt_1), true, "");
         
         bigInt_1 = new Clipperz.Crypto.BigInt("110");
         bigInt_2 = new Clipperz.Crypto.BigInt("110", 10);
         is (bigInt_1.equals(bigInt_2), true, "");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("110");
         bigInt_2 = new Clipperz.Crypto.BigInt(110);
         is (bigInt_1.equals(bigInt_2), true, "");
 
         bigInt_1 = new Clipperz.Crypto.BigInt(6);
         bigInt_2 = new Clipperz.Crypto.BigInt("110", 2);
         is (bigInt_1.equals(bigInt_2), true, "");
 
         bigInt_1 = new Clipperz.Crypto.BigInt(6);
         bigInt_2 = new Clipperz.Crypto.BigInt("110", 3);
         is (bigInt_1.equals(bigInt_2), false, "");
 
 
         //
                 //Addition test
         //
         bigInt_1 = new Clipperz.Crypto.BigInt(6);
         bigInt_2 = new Clipperz.Crypto.BigInt(110);
         result = bigInt_1.add(bigInt_2);
         expectedResult = new Clipperz.Crypto.BigInt(116);
         is (result.equals(expectedResult), true, "");
         is (result.equals(Clipperz.Crypto.BigInt.add(bigInt_1, bigInt_2)), true, "instance method === static function");
         
         bigInt_1 = new Clipperz.Crypto.BigInt(6);
         result = bigInt_1.add(6);
         expectedResult = new Clipperz.Crypto.BigInt(12);
         is (result.equals(expectedResult), true, "");
 
                 bigInt_1 =              new Clipperz.Crypto.BigInt("16161616161616161616161616161616161616161616161616161");
                 bigInt_2 =              new Clipperz.Crypto.BigInt("42424242424242424242424242424242424242424242424242424");
         result = bigInt_1.add(bigInt_2);
                 expectedResult = new Clipperz.Crypto.BigInt("58585858585858585858585858585858585858585858585858585");
         is (result.equals(expectedResult), true, "");
 
                 bigInt_1 =              new Clipperz.Crypto.BigInt("16161616161616161616161616161616161616161616161616161");
                 bigInt_2 =              new Clipperz.Crypto.BigInt("42424242424242424242424242424242424242424242424242424");
         result = bigInt_1.add(bigInt_2);
                 expectedResult = new Clipperz.Crypto.BigInt("58585858585858585858585851585858585858585858585858585");
         is (result.equals(expectedResult), false, "");
 
                 bigInt_1 =              new Clipperz.Crypto.BigInt("86161616161616161616161616161616161616161616161616161");
                 bigInt_2 =              new Clipperz.Crypto.BigInt("42424242424242424242424242424242424242424242424242424");
         result = bigInt_1.add(bigInt_2);
                 expectedResult = new Clipperz.Crypto.BigInt("128585858585858585858585858585858585858585858585858585");
         is (result.equals(expectedResult), true, "");
 
                 bigInt_1 =                      new Clipperz.Crypto.BigInt("6541652165410321654063516540621063540654" + 
                                                                                                         "0654065106540654165416521654103216540635" +
                                                                                                         "1654062106354065406540651065406541");
                 bigInt_2 =                      new Clipperz.Crypto.BigInt("3046540351035403510354035103510351351351" +
                                                                                                         "0351350435103213540634132135401351035403" +
                                                                                                         "5403540354103540");
         result = bigInt_1.add(bigInt_2);
                 expectedResult =        new Clipperz.Crypto.BigInt("6541652165410321657110056891656467051008" +
                                                                                                         "1005100210054167675767872089206430081269" +
                                                                                                         "2975416119864419441944191419510081");
         is (result.equals(expectedResult), true, "");
 
 
         //
                 //Moltiplication test
         //
         bigInt_1 = new Clipperz.Crypto.BigInt(6);
         bigInt_2 = new Clipperz.Crypto.BigInt(110);
         result = bigInt_1.multiply(bigInt_2);
         expectedResult = new Clipperz.Crypto.BigInt(660);
         is (result.equals(expectedResult), true, "");
 
         bigInt_1 = new Clipperz.Crypto.BigInt(6);
         result = bigInt_1.multiply(5);
         expectedResult = new Clipperz.Crypto.BigInt(30);
         is (result.equals(expectedResult), true, "");
         
                 bigInt_1 = new Clipperz.Crypto.BigInt("5465465165465465132743540354354032135463" +
                                                                                         "5435135403513516843052413543054035");
                 bigInt_2 = new Clipperz.Crypto.BigInt("3543513543543213543032135435413054365430" +
                                                                                         "5130513540351354354305435403");
         result = bigInt_1.multiply(bigInt_2);
                 expectedResult = new Clipperz.Crypto.BigInt("1936694983559052629352223965314822970014" +
                                                                                                 "6364423657014976098029153153101751605574" +
                                                                                                 "5077086464435601381095664357540911830059" +
                                                                                                 "9503335163757031001105");
         is (result.equals(expectedResult), true, "");
 
         //
                 //Module test
         //
         bigInt_1 = new Clipperz.Crypto.BigInt(106);
         bigInt_2 = new Clipperz.Crypto.BigInt(10);
         result = bigInt_1.module(bigInt_2);
         expectedResult = new Clipperz.Crypto.BigInt(6);
         is (result.equals(expectedResult), true, "");
 
         bigInt_1 = new Clipperz.Crypto.BigInt(106);
         result = bigInt_1.module(10);
         expectedResult = new Clipperz.Crypto.BigInt(6);
         is (result.equals(expectedResult), true, "");
 
                 bigInt_1 = new Clipperz.Crypto.BigInt("5465465465468468465468463541358438543513" +
                                                                                         "8543135435135423545624354235123512531235" +
                                                                                         "1356463543840351351305135435121354305413" +
                                                                                         "543");
                                                                                         
 
                 bigInt_2 = new Clipperz.Crypto.BigInt("3543543213543213540543545463542354385768" +
                                                                                         "512584354354215");
         result = bigInt_1.module(bigInt_2);
         expectedResult = new Clipperz.Crypto.BigInt("52689987206612998786765715819079250963638640081836513");
         is (result.equals(expectedResult), true, "");
 
         //
                 //Power (Module) test
         //
         bigInt_1 = new Clipperz.Crypto.BigInt(6);
         bigInt_2 = new Clipperz.Crypto.BigInt(3);
         result = bigInt_1.powerModule(bigInt_2, new Clipperz.Crypto.BigInt(1000));
         expectedResult = new Clipperz.Crypto.BigInt(216);
         is (result.equals(expectedResult), true, "");
 
         bigInt_1 = new Clipperz.Crypto.BigInt(6);
         result = bigInt_1.powerModule(3, 1000);
         expectedResult = new Clipperz.Crypto.BigInt(216);
         is (result.equals(expectedResult), true, "");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("354354354354687638546846846846846576876468746846846846");
         bigInt_2 = new Clipperz.Crypto.BigInt("354");
         result = bigInt_1.powerModule(bigInt_2, new Clipperz.Crypto.BigInt("3543541354354354354354351354354351354354354354354354"));
         expectedResult = new Clipperz.Crypto.BigInt("1957028940698171231089373321334263118681605242465644");
         is (result.equals(expectedResult), true, "");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("e0f6c73cf1d3715a0d77dc3a4eb9c66c01d913c91bc22d9672d83958445424a1", 16);
         //is(bigInt_1.toString(16), "e0f6c73cf1d3715a0d77dc3a4eb9c66c01d913c91bc22d9672d83958445424a1", "IE bug");
         is(bigInt_1.asString(16), "e0f6c73cf1d3715a0d77dc3a4eb9c66c01d913c91bc22d9672d83958445424a1", "fix for IE bug");
 
 
         bigInt_1 = new Clipperz.Crypto.BigInt("000108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1", 16);
         is(bigInt_1.asString(16, 64), "000108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1", "fix to ensure the string representation has a minimum fixed length");
 
 /*
         //
                 //Comparison
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("0", 10);
         bigInt_2 = new Clipperz.Crypto.BigInt("0", 10);
         is (bigInt_1.equals(bigInt_2), true, "bigInt(0) = bigInt(0)");
         is (bigInt_1.equals(0), true, "bigInt(0) = 0");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("000108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1", 16);
         is (bigInt_1.equals(bigInt_2), false, "bigInt(xxxxxx) != bigInt(0)");
         is (bigInt_1.equals(0), false, "bigInt(xxxxx) != 0");
         
         bigInt_1 = new Clipperz.Crypto.BigInt("000108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1", 16);
         bigInt_2 = new Clipperz.Crypto.BigInt("0", 16);
         is(bigInt_1.compare(bigInt_2), 1, "bigInt(xxxxxx) > bigInt(0)");
         is(bigInt_2.compare(bigInt_1), -1, "bigInt(0) < bigInt(xxxx)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("000108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1", 16);
         bigInt_2 = new Clipperz.Crypto.BigInt("05", 16);
         is(bigInt_1.compare(bigInt_2), 1, "bigInt(xxxxxx) > bigInt(05)");
         is(bigInt_2.compare(bigInt_1), -1, "bigInt(05) < bigInt(xxxx)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("-10", 10);
         bigInt_2 = new Clipperz.Crypto.BigInt("10", 10);
         is(bigInt_1.equals(bigInt_2), true, "bigInt(-10) - bigInt(10). No negative number are managed");
         
         //
                 //XOR
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         bigInt_2 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         result = bigInt_1.xor(bigInt_2);
         expectedResult = new Clipperz.Crypto.BigInt(0);
         is(result.asString(16), expectedResult.asString(16), "a xor a = 0");
 
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         bigInt_2 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b935ca495991b7852b855", 16);
         result = bigInt_1.xor(bigInt_2);
         expectedResult = new Clipperz.Crypto.BigInt('295147905179352825856');
         is(result.asString(16), expectedResult.asString(16), "single bit difference");
 
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("01", 16);
         bigInt_2 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b935ca495991b7852b855", 16);
         result = bigInt_1.xor(bigInt_2);
         expectedResult = new Clipperz.Crypto.BigInt('102987336249554097029535212322581322789799900648198034993674544906295017912404');
         is(result.asString(16), expectedResult.asString(16), "01 xor value");
 
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         bigInt_2 = new Clipperz.Crypto.BigInt("f3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         result = bigInt_1.xor(bigInt_2);
         expectedResult = new Clipperz.Crypto.BigInt('7237005577332262213973186563042994240829374041602535252466099000494570602496');
         is(result.asString(16), expectedResult.asString(16), "first bit difference xor");
         
 
         //
                 //isBitSet
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("ff", 16);
         result = bigInt_1.isBitSet(1);
         expectedResult = true;
         is(result, expectedResult, "'ff'.isBitSet(1)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("f0", 16);
         result = bigInt_1.isBitSet(1);
         expectedResult = false;
         is(result, expectedResult, "'f0'.isBitSet(1)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("f0", 16);
         result = bigInt_1.isBitSet(3);
         expectedResult = false;
         is(result, expectedResult, "'f0'.isBitSet(3)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("f0", 16);
         result = bigInt_1.isBitSet(4);
         expectedResult = true;
         is(result, expectedResult, "'f0'.isBitSet(4)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("ff00", 16);
         result = bigInt_1.isBitSet(7);
         expectedResult = false;
         is(result, expectedResult, "'ff00'.isBitSet(7)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("ff00", 16);
         result = bigInt_1.isBitSet(8);
         expectedResult = true;
         is(result, expectedResult, "'ff00'.isBitSet(8)");
 
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("05000000000000", 16);
         result = bigInt_1.isBitSet(47);
         expectedResult = false;
         is(result, expectedResult, "'05000000000000'.isBitSet(47)");
 
         result = bigInt_1.isBitSet(48);
         expectedResult = true;
         is(result, expectedResult, "'05000000000000'.isBitSet(48)");
 
         result = bigInt_1.isBitSet(49);
         expectedResult = false;
         is(result, expectedResult, "'05000000000000'.isBitSet(49)");
 
         result = bigInt_1.isBitSet(50);
         expectedResult = true;
         is(result, expectedResult, "'05000000000000'.isBitSet(50)");
 
         result = bigInt_1.isBitSet(51);
         expectedResult = false;
         is(result, expectedResult, "'05000000000000'.isBitSet(51)");
 
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
 
         result = bigInt_1.isBitSet(52);
         expectedResult = true;
         is(result, expectedResult, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(52)");
 
         result = bigInt_1.isBitSet(53);
         expectedResult = false;
         is(result, expectedResult, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(53)");
 
         result = bigInt_1.isBitSet(54);
         expectedResult = false;
         is(result, expectedResult, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(54)");
 
         result = bigInt_1.isBitSet(55);
         expectedResult = true;
         is(result, expectedResult, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(55)");
 
         result = bigInt_1.isBitSet(56);
         expectedResult = false;
         is(result, expectedResult, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(56)");
 
         result = bigInt_1.isBitSet(57);
         expectedResult = false;
         is(result, expectedResult, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(57)");
 
         result = bigInt_1.isBitSet(58);
         expectedResult = true;
         is(result, expectedResult, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(58)");
 
         result = bigInt_1.isBitSet(59);
         expectedResult = false;
         is(result, expectedResult, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(59)");
 
         result = bigInt_1.isBitSet(60);
         expectedResult = false;
         is(result, expectedResult, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(60)");
         
         //
                 //shiftLeft
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("7f", 16);
         result = bigInt_1.shiftLeft(1);
         expectedResult = new Clipperz.Crypto.BigInt('fe', 16);
         is(result.asString(16), expectedResult.asString(16), "'7f'.shiftLeft(1)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("ff", 16);
         result = bigInt_1.shiftLeft(1);
         expectedResult = new Clipperz.Crypto.BigInt('01fe', 16);
         is(result.asString(16), expectedResult.asString(16), "'ff'.shiftLeft(1)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         result = bigInt_1.shiftLeft(2);
         expectedResult = new Clipperz.Crypto.BigInt('411949344998216388118140849290325291159199602592792139973517588004462660346196', 10);
         is(result.asString(16), expectedResult.asString(16), "bigInt.shiftLeft(10)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         result = bigInt_1.shiftLeft(8);
         expectedResult = new Clipperz.Crypto.BigInt('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b85500', 16);
         is(result.asString(16), expectedResult.asString(16), "bigInt.shiftLeft(8)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         result = bigInt_1.shiftLeft(10);
         expectedResult = new Clipperz.Crypto.BigInt('105459032319543395358244057418323274536755098263754787833220502529142441048626176', 10);
         is(result.asString(16), expectedResult.asString(16), "bigInt.shiftLeft(10)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("ff", 16);
         result = bigInt_1.shiftLeft(4096);
         expectedResult = new Clipperz.Crypto.BigInt('266319164760353889206396941232739217557890883507082863997979538237408246532747151496450837043424377376926977212182012023686831226737377369852125202402098145876219029018646049576792205484267848170179157853023266287725961304046416750146445344507869587461686016719979944538177432428730245324189334334817497396705169439104855885416460935698516539852892760625369984672271807592980051379072961966267124963131928067770749329011150668180796667192392027523071601150548205543997146350727148885425131890513407882508735446345822174200042918879518190588482963417582471561436215675823872015307629566605147920139961896995509627341070659007877630760561618021922340198636222738900413041589858099507891702174848695380017286939422770656819923801325579542295611580916900945707539132241939193098989585491346846486694653352501301851631933610655701026861715541355665900384634131852357081890301147104554877895768806174478161952060916705243614916310627428392386264214492834954273769685672081818149530274447979003153864646452529328518204716201193108795473912970645455457215455929896570875795325190705652768977680951535622436287312272907838194995042100153360373621439300266297151905265332115434133380301670205335338558744799343198526203012170200626802804318535680', 10);
         is(result.asString(16), expectedResult.asString(16), "bigInt.shiftLeft(4096)");
 
         bigInt_1 = new Clipperz.Crypto.BigInt("ff", 16);
         result = bigInt_1.shiftLeft(5000);
         expectedResult = new Clipperz.Crypto.BigInt('36017909319555363939297846508911757008556852467205798478749046189356513330989041570231272721076143922520578818149998351104871978707844731275672652360293180474918203352225676748028889909508585302690242044220987556901043359920075229167479636668489487021705618421769517884399224788393498408327257966673365451264730932480701037648195190724361287852846952667257156204462064385766889505990099642052739974651257588866645027017486311782036674195285521311468922365736517586569614071211079825802088151607502649165228246449902253708785396560087430392277977851200155957347440614508171640900912431375050142178348130480158080696562512167652410483775588091117019722112093545783277082149415339867358805673644654236371762589715111732737686904860620316822561292797144756685380676343141118415434643259498221414744450502163805872581378284735047416230112208369784803081434462030568662742790926051825877463257023387907801068796855629691810029349692983890802136654401365294584656484852908751516361546884362396124203127393434938355516740711953765305060269622960662047729516459906444429108776596594293559927265789943280929098971285454533928986078946124455350540187565506016643147748500262510780357259199808936108629893209819473029835119866186316144675107047007737043503194737001430981972314376700993832503282107582239603281145093446879837002884732470988727066207277180181469885503549870618810897831820650576980763622189213611885522245978572420535750015505830146119605502167931087454823309031494727688701857532561113118183883936890880', 10);
         is(result.asString(16), expectedResult.asString(16), "bigInt.shiftLeft(4096)");
         
         
         //
                 //BigInt compare vs ByteArray compare
         //
         var bigInt_byteArray_1;
         var bigInt_byteArray_2;
 
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         bigInt_2 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         bitInt_byteArray_1 = bigInt_1.asByteArray();
         bitInt_byteArray_2 = bigInt_2.asByteArray();
         
         result = bigInt_1.compare(bigInt_2);
         expectedResult = bitInt_byteArray_1.compare(bitInt_byteArray_2);
         is(result, expectedResult, "equal compare");
 
         //
         bigInt_1 = new Clipperz.Crypto.BigInt("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         bigInt_2 = new Clipperz.Crypto.BigInt("f3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         bitInt_byteArray_1 = bigInt_1.asByteArray();
         bitInt_byteArray_2 = bigInt_2.asByteArray();
         
         result = bigInt_1.compare(bigInt_2);
         expectedResult = bitInt_byteArray_1.compare(bitInt_byteArray_2);
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.FiniteField.B283.html b/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.FiniteField.B283.html
index 6024021..93d8695 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.FiniteField.B283.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.FiniteField.B283.html
@@ -1,206 +1,205 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
 <!--<script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC.js'></script>-->
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/Value.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/Point.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/FiniteField.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/Curve.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Functions.js'></script>
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 try {
         //
                 //ECC.BinaryFiniteField
         //
                 varf2m;
                 varf2m_improved;
         var a, a1, b;
         var result;
         var result_improved;
         var expectedResul;
 
         f2m = new Clipperz.Crypto.ECC.BinaryField.FiniteField({modulus:new Clipperz.Crypto.ECC.BinaryField.Value('08000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 000010a1', 16)})
         f2m_improved = Clipperz.Crypto.ECC.StandardCurves.B283().finiteField();
         a = new Clipperz.Crypto.ECC.BinaryField.Value("05c91e41 d9ca17ef 9d8a33c1 a44eba6d 368fde02 1c492077 1a46eb01 a481e5f7 f430749d", 16);
         b = new Clipperz.Crypto.ECC.BinaryField.Value("07377071 2de7d57b a803f65f 45786c06 876b8066 db75ec47 81c053b0 a0f78e2c a6ab5187", 16);
 
         //
                 //addition
         //
         result = f2m.add(a, b);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("2fe6e30f42dc2943589c59ee136d66bb1e45e64c73ccc309b86b8b104766bdb529b251a", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.add");
 
 
         //
                 //negation
         //
         result = f2m.negate(a);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("5c91e41d9ca17ef9d8a33c1a44eba6d368fde021c4920771a46eb01a481e5f7f430749d", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.negate");
 
 
         //
                 //multiplication
         //
         result = f2m.multiply(a, b);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("2bacb89668741f6d1f7fd7d3df2f045814086adba11d8bb5f12f3f9851e3b66fbe283cb", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.multiply");
 
 
         //
                 //fast multiplication
         //
         result = f2m.fastMultiply(a, b);
         expectedResult = f2m.multiply(a, b);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.fastMultiply");
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("2fe6e30f42dc2943589c59ee136d66bb1e45e64c73ccc309b86b8b104766bdb529b251a", 16);
         b = new Clipperz.Crypto.ECC.BinaryField.Value("5c91e41d9ca17ef9d8a33c1a44eba6d368fde021c4920771a46eb01a481e5f7f430749d", 16);
         result = f2m.fastMultiply(a, b);
         expectedResult = f2m.multiply(a, b);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.B283.fastMultiply");
 
         //
                 //square
         //
         a = new Clipperz.Crypto.ECC.BinaryField.Value("1111", 16);
         result = f2m.square(a);
         expectedResult = f2m.multiply(a, a);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.square");
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("11111111", 16);
         result = f2m.square(a);
         expectedResult = f2m.multiply(a, a);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.square");
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("5c91e41d9ca17ef9d8a33c1a44eba6d368fde021c4920771a46eb01a481e5f7f430749d", 16);
         result = f2m.square(a);
         expectedResult = f2m.multiply(a, a);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.square");
 
 
         //
                 //inverse
         //
         a = new Clipperz.Crypto.ECC.BinaryField.Value("2fe6e30f42dc2943589c59ee136d66bb1e45e64c73ccc309b86b8b104766bdb529b251a", 16);
         result = f2m.inverse(a);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("3812fc574f3728c60384e141c0e2a808e21adec22dcd407b9e25dd13c6d1bf22defd84a", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.inverse");
 
 
         //
                 //module
         //
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("015655ebcb09fac51945162a0775f42df6151169826efdc55dea5d17c22adb92e6b1a6ae8311545ad7e0f46f09a5b960855e673db1e803a5b94562161213204ca1f24792e81f060a0aa6c29a492f106cc6d0b0ff4617b736dab590590a8cff9f807a15282544404e6b35841703c9fb00a9cad1d6878d601efc25368bdc51d5ff14a81610f4fe62cb2f452aee520a16", 16);
         a1 = new Clipperz.Crypto.ECC.BinaryField.Value("015655ebcb09fac51945162a0775f42df6151169826efdc55dea5d17c22adb92e6b1a6ae8311545ad7e0f46f09a5b960855e673db1e803a5b94562161213204ca1f24792e81f060a0aa6c29a492f106cc6d0b0ff4617b736dab590590a8cff9f807a15282544404e6b35841703c9fb00a9cad1d6878d601efc25368bdc51d5ff14a81610f4fe62cb2f452aee520a16", 16);
         result = f2m.module(a);
         result_improved = f2m_improved.module(a1);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("2bacb89668741f6d1f7fd7d3df2f045814086adba11d8bb5f12f3f9851e3b66fbe283cb", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFiniteField.module");
         is(result_improved.asString(16), expectedResult.asString(16), "ECC.BinaryFiniteField.module (improved)");
         is(result.asString(16), result_improved.asString(16), "standard vs improved 'module' methods");
 
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067112f5c97e74737b38925fafe22cea3e12b868d4ddea5b3341db8fc2e788cab74f0a7a3cc27087a89365945369938650a99217d566e13f80dc87f08273f7411b6b01ef1d399c772a", 16);
         a1 = new Clipperz.Crypto.ECC.BinaryField.Value("1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067112f5c97e74737b38925fafe22cea3e12b868d4ddea5b3341db8fc2e788cab74f0a7a3cc27087a89365945369938650a99217d566e13f80dc87f08273f7411b6b01ef1d399c772a", 16);
         result = f2m.module(a);
         result_improved = f2m_improved.module(a1);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("15e2097d116e745ac47480807cb5eb99dad902728aaf5692241063bc70a5b372dbce798", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFiniteField.module (2)");
         is(result_improved.asString(16), expectedResult.asString(16), "ECC.BinaryFiniteField.module (improved) (2)");
         is(result.asString(16), result_improved.asString(16), "standard vs improved 'module' methods (2)");
 
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("112f5c97e74737b38925fafe22cea3e12b868d4ddea5b3341db8fc2e788cab74f0a7a3cc27087a89365945369938650a99217d566e13f80dc87f08273f7411b6b01ef1d399c772a1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067", 16);
         a1 = new Clipperz.Crypto.ECC.BinaryField.Value("112f5c97e74737b38925fafe22cea3e12b868d4ddea5b3341db8fc2e788cab74f0a7a3cc27087a89365945369938650a99217d566e13f80dc87f08273f7411b6b01ef1d399c772a1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067", 16);
         result = f2m.module(a);
         result_improved = f2m_improved.module(a1);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("40f04cec8fe9caedf82adeff7e1aa06dcb9d08e097db8be2ad54b2ddc2e752152395623", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFiniteField.module (3)");
         is(result_improved.asString(16), expectedResult.asString(16), "ECC.BinaryFiniteField.module (improved) (3)");
         is(result.asString(16), result_improved.asString(16), "standard vs improved 'module' methods (3)");
 
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("02f4bf57710a7e0826a80a339e59e34476c343e75452e4bf4355847e6b41e655ecb08f4c418b172d7963c525c26fdc84ac294a348d3907652f0fcbff3e4c8e2238a478e4277489ce", 16);
         is(a.asString(16), "02f4bf57710a7e0826a80a339e59e34476c343e75452e4bf4355847e6b41e655ecb08f4c418b172d7963c525c26fdc84ac294a348d3907652f0fcbff3e4c8e2238a478e4277489ce", "ECC.BinaryFiniteField - original value as expected (4)")
         a1 = new Clipperz.Crypto.ECC.BinaryField.Value("02f4bf57710a7e0826a80a339e59e34476c343e75452e4bf4355847e6b41e655ecb08f4c418b172d7963c525c26fdc84ac294a348d3907652f0fcbff3e4c8e2238a478e4277489ce", 16);
         result = f2m.module(a);
         result_improved = f2m_improved.module(a1);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("ba35032a24eb81238251d85824998bebae3b3e09f4d3845256c87585cf62416ee43191", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFiniteField.module (4)");
         is(result_improved.asString(16), expectedResult.asString(16), "ECC.BinaryFiniteField.module (improved) (4)");
         is(result_improved.asString(16), "ba35032a24eb81238251d85824998bebae3b3e09f4d3845256c87585cf62416ee43191", "ECC.BinaryFinetField.module (static check) (4)");
         is(result.asString(16), result_improved.asString(16), "standard vs improved 'module' methods (4)");
 
         is(a.asString(16),  "02f4bf57710a7e0826a80a339e59e34476c343e75452e4bf4355847e6b41e655ecb08f4c418b172d7963c525c26fdc84ac294a348d3907652f0fcbff3e4c8e2238a478e4277489ce", "ECC.BinaryFiniteField - original value preserved by standard method (4)")
         is(a1.asString(16), "02f4bf57710a7e0826a80a339e59e34476c343e75452e4bf4355847e6b41e655ecb08f4c418b172d7963c525c26fdc84ac294a348d3907652f0fcbff3e4c8e2238a478e4277489ce", "ECC.BinaryFiniteField - original value preserved by improved method (4)")
 
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("2f4bf57710a7e0826a80a339e59e34476c343e75452e4bf4355847e6b41e655ecb08f4c418b172d7963c525c26fdc84ac294a348d3907652f0fcbff3e4c8e2238a478e4277489ce", 16);
         result_improved = f2m_improved.module(a);
         result = f2m.module(a);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("ba35032a24eb81238251d85824998bebae3b3e09f4d3845256c87585cf62416ee43191", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFiniteField.module (5)");
         is(result_improved.asString(16), expectedResult.asString(16), "ECC.BinaryFiniteField.module (improved) (5)");
         is(result_improved.asString(16), "ba35032a24eb81238251d85824998bebae3b3e09f4d3845256c87585cf62416ee43191", "ECC.BinaryFinetField.module (static check) (5)");
         is(result.asString(16), result_improved.asString(16), "standard vs improved 'module' methods (5)");
 
         //-------------------------------------------------------------------------
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
         if (!o[k]) {
             s +=  k + ": " + err[k] + "\n";
             o[k] = err[k];
         }
     }
     ok ( false, s );
 }
 
 </script>
 </pre>
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.FiniteField.html b/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.FiniteField.html
index 5a7a4f7..658c402 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.FiniteField.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.FiniteField.html
@@ -1,180 +1,179 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
 <!--<script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC.js'></script>-->
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/Value.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/Point.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/FiniteField.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/Curve.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Functions.js'></script>
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 try {
         //
                 //ECC.BinaryFiniteField
         //
                 varf2m;
                 varf2m_improved;
         var a, b;
         var result;
         var result_improved;
         var expectedResul;
 
         f2m = new Clipperz.Crypto.ECC.BinaryField.FiniteField({modulus:new Clipperz.Crypto.ECC.BinaryField.Value('80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000425', 16)})
         f2m_improved = Clipperz.Crypto.ECC.StandardCurves.B571().finiteField();
         a = new Clipperz.Crypto.ECC.BinaryField.Value("01401ca8 7b8f1446 84a2c58a e9308c23 7789e4bf 1f36dd11 7c150b7d 6076dd1d a6197fe4 c5225a06 4db0e422 2589d5ca 50eb6bb6 b7147a03 f6152843 8a8767c6 a6c4a688 3fd6f067", 16);
         b = new Clipperz.Crypto.ECC.BinaryField.Value("0112f5c9 7e74737b 38925faf e22cea3e 12b868d4 ddea5b33 41db8fc2 e788cab7 4f0a7a3c c27087a8 93659453 69938650 a99217d5 66e13f80 dc87f082 73f7411b 6b01ef1d 399c772a", 16);
 
         //
                 //addition
         //
         result = f2m.add(a, b);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("52e96105fb673dbc309a250b1c661d65318c6bc2dc86223dce84bf87fe17aae91305d80752ddaeded570714c1a539af9797c63d1f545832a92d8c1f97026ddcdc54995064a874d", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.add");
 
 
         //
                 //negation
         //
         result = f2m.negate(a);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.negate");
 
 
         //
                 //multiplication
         //
         result = f2m.multiply(a, b);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("4f8e4c0ae7664b284d3b4cb1b3f9568a1ce6e6e96b5381e184fe0822cb3d5c3a3f01ffd0206355d9e5c4853472bb33cf6b2d861d6b48c39d33a360e9a63ad2f7102f92e68a12312", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.multiply");
 
 
         //
                 //fast multiplication
         //
         result = f2m.fastMultiply(a, b);
         expectedResult = f2m.multiply(a, b);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.fastMultiply");
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("52e96105fb673dbc309a250b1c661d65318c6bc2dc86223dce84bf87fe17aae91305d80752ddaeded570714c1a539af9797c63d1f545832a92d8c1f97026ddcdc54995064a874d", 16);
         b = new Clipperz.Crypto.ECC.BinaryField.Value("1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067", 16);
         result = f2m.fastMultiply(a, b);
         expectedResult = f2m.multiply(a, b);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.fastMultiply");
 
         //
                 //square
         //
         a = new Clipperz.Crypto.ECC.BinaryField.Value("1111", 16);
         result = f2m.square(a);
         expectedResult = f2m.multiply(a, a);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.square");
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("11111111", 16);
         result = f2m.square(a);
         expectedResult = f2m.multiply(a, a);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.square");
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067", 16);
         result = f2m.square(a);
         expectedResult = f2m.multiply(a, a);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.square");
 
 
         //
                 //inverse
         //
         a = new Clipperz.Crypto.ECC.BinaryField.Value("1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067", 16);
         result = f2m.inverse(a);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("1f898c60983c4e807e619b9cbe528585fc33aaae419d5e5cb2107269ccdcf21d5ad5b5d78d37fa435a0d0a8a75f2506240c325c6a2eee1a03008f9e1b9c6c0a511b730cdaf9b97e", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.inverse");
 
 
         //
                 //module
         //
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("015655ebcb09fac51945162a0775f42df6151169826efdc55dea5d17c22adb92e6b1a6ae8311545ad7e0f46f09a5b960855e673db1e803a5b94562161213204ca1f24792e81f060a0aa6c29a492f106cc6d0b0ff4617b736dab590590a8cff9f807a15282544404e6b35841703c9fb00a9cad1d6878d601efc25368bdc51d5ff14a81610f4fe62cb2f452aee520a16", 16);
         a1 = new Clipperz.Crypto.ECC.BinaryField.Value("015655ebcb09fac51945162a0775f42df6151169826efdc55dea5d17c22adb92e6b1a6ae8311545ad7e0f46f09a5b960855e673db1e803a5b94562161213204ca1f24792e81f060a0aa6c29a492f106cc6d0b0ff4617b736dab590590a8cff9f807a15282544404e6b35841703c9fb00a9cad1d6878d601efc25368bdc51d5ff14a81610f4fe62cb2f452aee520a16", 16);
         result = f2m.module(a);
         result_improved = f2m_improved.module(a1);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("4f8e4c0ae7664b284d3b4cb1b3f9568a1ce6e6e96b5381e184fe0822cb3d5c3a3f01ffd0206355d9e5c4853472bb33cf6b2d861d6b48c39d33a360e9a63ad2f7102f92e68a12312", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.module");
         is(result_improved.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.module (improved)");
         //is(result.asString(16), result_improved.asString(16), "standard vs improved 'module' methods");
 
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067112f5c97e74737b38925fafe22cea3e12b868d4ddea5b3341db8fc2e788cab74f0a7a3cc27087a89365945369938650a99217d566e13f80dc87f08273f7411b6b01ef1d399c772a", 16);
         a1 = new Clipperz.Crypto.ECC.BinaryField.Value("1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067112f5c97e74737b38925fafe22cea3e12b868d4ddea5b3341db8fc2e788cab74f0a7a3cc27087a89365945369938650a99217d566e13f80dc87f08273f7411b6b01ef1d399c772a", 16);
         result = f2m.module(a);
         result_improved = f2m_improved.module(a1);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("1704018ce75dc462a5ccd1eb18b8002ecb8536c616ec625f440f6888f8c32387e53a5cb3b6050688e9b64a32215a385ee98c518d6a484d5ac0ceeafa825743c84b075bdfabc341b", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.module (2)");
         is(result_improved.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.module (improved) (2)");
         is(a.asString(16), "1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067112f5c97e74737b38925fafe22cea3e12b868d4ddea5b3341db8fc2e788cab74f0a7a3cc27087a89365945369938650a99217d566e13f80dc87f08273f7411b6b01ef1d399c772a", "ECC.BinaryFinetField.module (2)");
         is(a1.asString(16), "1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067112f5c97e74737b38925fafe22cea3e12b868d4ddea5b3341db8fc2e788cab74f0a7a3cc27087a89365945369938650a99217d566e13f80dc87f08273f7411b6b01ef1d399c772a", "ECC.BinaryFinetField.module (2)");
 
 
         a = new Clipperz.Crypto.ECC.BinaryField.Value("112f5c97e74737b38925fafe22cea3e12b868d4ddea5b3341db8fc2e788cab74f0a7a3cc27087a89365945369938650a99217d566e13f80dc87f08273f7411b6b01ef1d399c772a1401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067", 16);
         result = f2m.module(a);
         result_improved = f2m_improved.module(a);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("e160dd4a436e63877e1343d06576beaa66e06863ffe4335be38d6a37460a62d11133584a5bc6ac0590e18942e1fa88bb64a4d9fc6c1fd7b55d7e57b50b70a9e7cb2ed904ad77f4", 16);
         is(result.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.module (2)");
         is(result_improved.asString(16), expectedResult.asString(16), "ECC.BinaryFinetField.module (improved) (2)");
 
         //-------------------------------------------------------------------------
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
         if (!o[k]) {
             s +=  k + ": " + err[k] + "\n";
             o[k] = err[k];
         }
     }
     ok ( false, s );
 }
 
 </script>
 </pre>
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.Value.html b/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.Value.html
index c58cf42..0d0903d 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.Value.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/ECC.BinaryField.Value.html
@@ -1,413 +1,412 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
 <!--<script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC.js'></script>-->
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/Value.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/Point.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/FiniteField.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/ECC/BinaryField/Curve.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Functions.js'></script>
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 try {
         var value_1;
         var value_2;
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("a", 16);
         is(value_1.asString(16), "0a");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("ffff", 16);
         is(value_1.asString(16), "ffff");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("7fff", 16);
         is(value_1.asString(16), "7fff");
 
         is(parseInt("ffff", 16), 65535);
         is(parseInt("ffffff", 16), 16777215);
         is(parseInt("ffffffff", 16), 4294967295);
         is(parseInt("ffffffffff", 16), 1099511627775);
         is(parseInt("ffffffffffff", 16), 281474976710655);
         is(parseInt("ffffffffffffff", 16), 72057594037927940);
         is(parseInt("ffffffffffffffff", 16), 18446744073709552000);
         is(parseInt("10000000000000000", 16), 18446744073709552001);
         is(parseInt("10000000000000001", 16), 18446744073709552002);
         is(parseInt("10000000000000009", 16), 18446744073709552010);
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("000108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1", 16);
         is(value_1.wordSize(), 8, "check the number of words of a 64 char hex string using the 'wordSize' method");
 
         //      000108cb bacda1f0 3ea93603 01045434 ec7d82ba 150936df 08a229cb b4832ce1
         is(value_1.value()[0], parseInt("b4832ce1", 16), "word[0]");
         is(value_1.value()[1], parseInt("08a229cb", 16), "word[1]");
         is(value_1.value()[2], parseInt("150936df", 16), "word[2]");
         is(value_1.value()[3], parseInt("ec7d82ba", 16), "word[3]");
         is(value_1.value()[4], parseInt("01045434", 16), "word[4]");
         is(value_1.value()[5], parseInt("3ea93603", 16), "word[5]");
         is(value_1.value()[6], parseInt("bacda1f0", 16), "word[6]");
         is(value_1.value()[7], parseInt("000108cb", 16), "word[7]");
         
         is(value_1.asString(16), "0108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1", "asString(16)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value('10 00000000 00000000', 16);
         is(value_1.wordSize(), 3, "check the number of words of a value with only a bit set on the first slot of byte at position 17");
         is(value_1.value()[0], parseInt("00000000", 16), "word[0]");
         is(value_1.value()[1], parseInt("00000000", 16), "word[1]");
         is(value_1.value()[2], parseInt("10", 16), "word[2]");
         is(value_1.asString(16), "100000000000000000", "2^17 asString(16)");
 
         //
                 //XOR
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 16);
         result = value_1.xor(value_2);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value('0', 16);
         is(result.asString(16), expectedResult.asString(16), "a xor a = 0");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value('e3b0c442 98fc1c14 9afbf4c8 996fb924 27ae41e4 649b934c a495991b 7852b855', 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value('e3b0c442 98fc1c14 9afbf4c8 996fb924 27ae41e4 649b935c a495991b 7852b855', 16);
         result = value_1.xor(value_2);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value('10 00000000 00000000', 16);
         is(result.asString(16), expectedResult.asString(16), "single bit difference");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("01", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b935ca495991b7852b855', 16);
         result = value_1.xor(value_2);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b935ca495991b7852b854', 16);
         is(result.asString(16), expectedResult.asString(16), "01 xor value");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value('f3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 16);
         result = value_1.xor(value_2);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value('1000000000000000000000000000000000000000000000000000000000000000', 16);
         is(result.asString(16), expectedResult.asString(16), "first bit difference xor");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value('84a2c58a', 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value('38925faf', 16);
         result = value_1.xor(value_2);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value('bc309a25', 16);
         is(result.asString(16), expectedResult.asString(16), "84a2c58a XOR 38925faf = bc309a25");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("01401ca87b8f144684a2c58ae9308c237789e4bf1f36dd117c150b7d6076dd1da6197fe4c5225a064db0e4222589d5ca50eb6bb6b7147a03f61528438a8767c6a6c4a6883fd6f067", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("0112f5c97e74737b38925fafe22cea3e12b868d4ddea5b3341db8fc2e788cab74f0a7a3cc27087a89365945369938650a99217d566e13f80dc87f08273f7411b6b01ef1d399c772a", 16);
         result = value_1.xor(value_2);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value('0052e96105fb673dbc309a250b1c661d65318c6bc2dc86223dce84bf87fe17aae91305d80752ddaeded570714c1a539af9797c63d1f545832a92d8c1f97026ddcdc54995064a874d', 16);
         is(result.asString(16), expectedResult.asString(16), "xor");
 
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000425", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("01ebcb09fac51945162a0775f42df6151169826efdc55dea5d17c22adb92e6b1a6ae8311545ad7e0f46f09a5b960855e673db1e803a5b94562161213204ca1f24792e81f06a4f816429a492f106cc6d0b0ff4617b736dab590590a8cff9f807a15282544404e6b35841703c9fb00a9cad1d6878d601efc25368bdc51d5ff14a81610f4fe62cb2f452aee520a16", 16);
         result = value_2.xor(value_1.shiftLeft(value_2.bitSize() - value_1.bitSize()));
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("ebcb09fac51945162a0775f42df6151169826efdc55dea5d17c22adb92e6b1a6ae8311545ad7e0f46f09a5b960855e673db1e803a5b94562161213204ca1f24792e81f06a4f892e29a492f106cc6d0b0ff4617b736dab590590a8cff9f807a15282544404e6b35841703c9fb00a9cad1d6878d601efc25368bdc51d5ff14a81610f4fe62cb2f452aee520a16", 16);
         is(result.asString(16), expectedResult.asString(16), "xor");
         is(result.bitSize(), 1120, "xor.bitSize");
         is(result.wordSize(), 35, "result wordSize");
         is(expectedResult.bitSize(), 1120, "xor.bitSize");
         is(expectedResult.wordSize(), 35, "expectedResult wordSize");
         is(result.compare(expectedResult), 0, "compare");
 
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000425", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("ebcb09fac51945162a0775f42df6151169826efdc55dea5d17c22adb92e6b1a6ae8311545ad7e0f46f09a5b960855e673db1e803a5b94562161213204ca1f24792e81f06a4f892e29a492f106cc6d0b0ff4617b736dab590590a8cff9f807a15282544404e6b35841703c9fb00a9cad1d6878d601efc25368bdc51d5ff14a81610f4fe62cb2f452aee520a16", 16);
         result = value_2.xor(value_1.shiftLeft(value_2.bitSize() - value_1.bitSize()));
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("6bcb09fac51945162a0775f42df6151169826efdc55dea5d17c22adb92e6b1a6ae8311545ad7e0f46f09a5b960855e673db1e803a5b94562161213204ca1f24792e81f06a4f8d0b29a492f106cc6d0b0ff4617b736dab590590a8cff9f807a15282544404e6b35841703c9fb00a9cad1d6878d601efc25368bdc51d5ff14a81610f4fe62cb2f452aee520a16", 16);
         is(result.asString(16), expectedResult.asString(16), "xor");
         is(result.bitSize(), 1119, "xor.bitSize");
         is(expectedResult.bitSize(), 1119, "xor.bitSize");
         is(result.compare(expectedResult), 0, "compare");
         //value_1 = 
         //value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 16);
 
 
         value_1 = (new Clipperz.Crypto.ECC.BinaryField.Value("10101010 01010101 00000000", 16)).value();
         value_2 = (new Clipperz.Crypto.ECC.BinaryField.Value("10101010", 16)).value();
         result = new Clipperz.Crypto.ECC.BinaryField.Value(Clipperz.Crypto.ECC.BinaryField.Value._xor(value_1, value_2, 2));
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("01010101 00000000", 16);
         is(result.asString(16), expectedResult.asString(16), "xor with offset 2");
 
                 value_1 =       (new Clipperz.Crypto.ECC.BinaryField.Value("         10101010 01010101 00000000", 16)).value();
                 value_2 =       (new Clipperz.Crypto.ECC.BinaryField.Value("10101010 10101010", 16)).value();
         result = new Clipperz.Crypto.ECC.BinaryField.Value(Clipperz.Crypto.ECC.BinaryField.Value._xor(value_1, value_2, 2));
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value("10101010 00000000 01010101 00000000", 16);
         is(result.asString(16), expectedResult.asString(16), "xor with offset 2 (2)");
         
         //
                 //isZero
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value('0', 16);
         is(value_1.isZero(), true, "0.isZero() == true");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value('1', 16);
         is(value_1.isZero(), false, "1.isZero() == false");
 
         //
                 //Comparison
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("0", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("0", 16);
         is (value_1.compare(value_2), 0, "BinaryField.value(0) = BinaryField.value(0)");
         //is (value_1.compare(0), 0, "BinaryField.value(0) = 0");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("000108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1", 16);
         is (value_1.compare(value_2), 1, "BinaryField.value(xxxxxx) != BinaryField.value(0)");
         
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("000108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("0", 16);
         is(value_1.compare(value_2), 1, "BinaryField.value(xxxxxx) > BinaryField.value(0)");
         is(value_2.compare(value_1), -1, "BinaryField.value(0) < BinaryField.value(xxxx)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("000108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("05", 16);
         is(value_1.compare(value_2), 1, "BinaryField.value(xxxxxx) > BinaryField.value(05)");
         is(value_2.compare(value_1), -1, "BinaryField.value(05) < BinaryField.value(xxxx)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("-10", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("10", 16);
         is(value_1.compare(value_2), -1, "BinaryField.value(-10) - BinaryField.value(10). No negative number are managed");
 
         //
                 //more comparison
         //
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         result = value_1.compare(value_2);
         is(result, 0, "equal compare");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c442", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("f3b0c442", 16);
         result = value_1.compare(value_2);
         is(result, -1, "second term with one more bit at the leftmost - compare (1)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c442 98fc1c14", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("f3b0c442 98fc1c14", 16);
         result = value_1.compare(value_2);
         is(result, -1, "second term with one more bit at the leftmost - compare (2)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c442 98fc1c14 9afbf4c8", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("f3b0c442 98fc1c14 9afbf4c8", 16);
         result = value_1.compare(value_2);
         is(result, -1, "second term with one more bit at the leftmost - compare (3)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c442 98fc1c14 9afbf4c8 996fb924 27ae41e4 649b934c a495991b 7852b855", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("f3b0c442 98fc1c14 9afbf4c8 996fb924 27ae41e4 649b934c a495991b 7852b855", 16);
         result = value_1.compare(value_2);
         is(result, -1, "second term with one more bit at the leftmost - compare (n)");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("f3b0c442", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c442", 16);
         result = value_1.compare(value_2);
         is(result, 1, "first term with one more bit at the leftmost - compare (1)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("f3b0c442 98fc1c14", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c442 98fc1c14", 16);
         result = value_1.compare(value_2);
         is(result, 1, "first term with one more bit at the leftmost - compare (2)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("f3b0c442 98fc1c14 9afbf4c8 996fb924 27ae41e4 649b934c a495991b 7852b855", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c442 98fc1c14 9afbf4c8 996fb924 27ae41e4 649b934c a495991b 7852b855", 16);
         result = value_1.compare(value_2);
         is(result, 1, "first term with one more bit at the leftmost - compare (n)");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c44298fc1c149afbf4c8996fb92427af41e4649b934ca495991b7852b855", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         result = value_1.compare(value_2);
         is(result, 1, "first term with one more bit in the middle - compare");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c44298fc1c149afbf4c8996fb92427af41e4649b934ca495991b7852b855", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c44298fc1c149afbf4c8996fb92427aeffffffffffffffffffffffffffff", 16);
         result = value_1.compare(value_2);
         is(result, 1, "first term with one more bit in the middle - compare");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
         value_2 = new Clipperz.Crypto.ECC.BinaryField.Value("05", 16);
         result = value_1.compare(value_2);
         is(result, 1, "equal compare");
 
 
 
         //
                 //isBitSet
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("ff", 16);
         result = value_1.isBitSet(1);
         expectedResult = true;
         is(result, expectedResult, "'ff'.isBitSet(1)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("f0", 16);
         result =value_1.isBitSet(1);
         expectedResult = false;
         is(result, expectedResult, "'f0'.isBitSet(1)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("f0", 16);
         result = value_1.isBitSet(3);
         expectedResult = false;
         is(result, expectedResult, "'f0'.isBitSet(3)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("f0", 16);
         result = value_1.isBitSet(4);
         expectedResult = true;
         is(result, expectedResult, "'f0'.isBitSet(4)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("ff00", 16);
         result = value_1.isBitSet(7);
         expectedResult = false;
         is(result, expectedResult, "'ff00'.isBitSet(7)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("ff00", 16);
         result = value_1.isBitSet(8);
         expectedResult = true;
         is(result, expectedResult, "'ff00'.isBitSet(8)");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("05000000000000", 16);
         result = value_1.isBitSet(47);
         expectedResult = false;
         is(result, expectedResult, "'05000000000000'.isBitSet(47)");
 
         result = value_1.isBitSet(48);
         expectedResult = true;
         is(result, expectedResult, "'05000000000000'.isBitSet(48)");
 
         result = value_1.isBitSet(49);
         expectedResult = false;
         is(result, expectedResult, "'05000000000000'.isBitSet(49)");
 
         result = value_1.isBitSet(50);
         expectedResult = true;
         is(result, expectedResult, "'05000000000000'.isBitSet(50)");
 
         result = value_1.isBitSet(51);
         expectedResult = false;
         is(result, expectedResult, "'05000000000000'.isBitSet(51)");
 
         //
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
 
         result = value_1.isBitSet(52);
         is(result, true, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(52)");
 
         result = value_1.isBitSet(53);
         is(result, false, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(53)");
 
         result = value_1.isBitSet(54);
         is(result, false, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(54)");
 
         result = value_1.isBitSet(55);
         is(result, true, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(55)");
 
         result = value_1.isBitSet(56);
         is(result, false, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(56)");
 
         result = value_1.isBitSet(57);
         is(result, false, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(57)");
 
         result = value_1.isBitSet(58);
         is(result, true, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(58)");
 
         result = value_1.isBitSet(59);
         is(result, false, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(59)");
 
         result = value_1.isBitSet(60);
         is(result, false, "'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'.isBitSet(60)");
 
 
         //
                 //shiftLeft
         //
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("7f", 16);
         result = value_1.shiftLeft(1);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value('fe', 16);
         is(result.asString(16), expectedResult.asString(16), "'7f'.shiftLeft(1)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("ff", 16);
         result = value_1.shiftLeft(1);
         expectedResult = new Clipperz.Crypto.ECC.BinaryField.Value('01fe', 16);
         is(result.asString(16), expectedResult.asString(16), "'ff'.shiftLeft(1)");
 
                 value_1 =               new Clipperz.Crypto.ECC.BinaryField.Value(  'ffff', 16);
                 expectedResult =new Clipperz.Crypto.ECC.BinaryField.Value('ffff00', 16);
         result = value_1.shiftLeft(8);
         is(result.asString(16), expectedResult.asString(16), "ffff.shiftLeft(8)");
 
                 value_1 =               new Clipperz.Crypto.ECC.BinaryField.Value(  '80000000', 16);
                 expectedResult =new Clipperz.Crypto.ECC.BinaryField.Value('1 00000000', 16);
         result = value_1.shiftLeft(1);
         is(result.compare(expectedResult) == 0, true, '8000000.shiftLeft(1).compare');
         is(result.asString(16), expectedResult.asString(16), "80000000.shiftLeft(1)");
 
                 value_1 =               new Clipperz.Crypto.ECC.BinaryField.Value('20000000', 16);
                 expectedResult =new Clipperz.Crypto.ECC.BinaryField.Value('40000000', 16);
         result = value_1.shiftLeft(1);
         is(result.compare(expectedResult) == 0, true, '2000000.shiftLeft(1).compare');
         is(result.asString(16), expectedResult.asString(16), "20000000.shiftLeft(1)");
 
                 value_1 =               new Clipperz.Crypto.ECC.BinaryField.Value('40000000', 16);
                 expectedResult =new Clipperz.Crypto.ECC.BinaryField.Value('80000000', 16);
         result = value_1.shiftLeft(1);
         is(result.compare(expectedResult) == 0, true, '4000000.shiftLeft(1).compare');
         is(result.asString(16), expectedResult.asString(16), "40000000.shiftLeft(1)");
 
                 value_1 =               new Clipperz.Crypto.ECC.BinaryField.Value(   'ff7fffff', 16);
                 expectedResult =new Clipperz.Crypto.ECC.BinaryField.Value('ff 7fffff00', 16);
         result = value_1.shiftLeft(8);
         is(result.asString(16), expectedResult.asString(16), "ff7fffff.shiftLeft(8)");
 
                 value_1 =               new Clipperz.Crypto.ECC.BinaryField.Value(   'ffffffff', 16);
                 expectedResult =new Clipperz.Crypto.ECC.BinaryField.Value('ff ffffff00', 16);
         result = value_1.shiftLeft(8);
         is(result.asString(16), expectedResult.asString(16), "ffffffff.shiftLeft(8)");
 
                 value_1 =               new Clipperz.Crypto.ECC.BinaryField.Value(  "e3b0c442 98fc1c14 9afbf4c8 996fb924 27ae41e4 649b934c a495991b 7852b855", 16);
                 expectedResult =new Clipperz.Crypto.ECC.BinaryField.Value('3 8ec3110a 63f07052 6befd322 65bee490 9eb90791 926e4d32 9256646d e14ae154', 16);
         result = value_1.shiftLeft(2);
         is(result.asString(16), expectedResult.asString(16), "Value.shiftLeft(10)");
 
         value_1 = new Clipperz.Crypto.ECC.BinaryField.Value("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", 16);
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/PRNG.html b/frontend/gamma/tests/tests/Clipperz/Crypto/PRNG.html
index 438d96f..61aa1c2 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/PRNG.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/PRNG.html
@@ -1,114 +1,113 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <script> jslog_config_enabled = true; </script>
         
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/DomHelper.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Logging.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/DOM.js'></script>
 
 <!--<script type='text/javascript' src='../../../../js/Clipperz/Crypto/Statistics.js'></script>-->
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/AES.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/PRNG.js'></script>
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 test_PRNG = function() {
                 varrand1, rand2;
         var i,c;
         
         c = 10;
         for (i=0; i<c; i++) {
         //      jslog.debug(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(32).toHexString());
         }
         
         rand1 = Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(1);
         is(rand1.byteAtIndex(0) <= 255, true, "getRandomByte returns always a single byte");
 
         rand2 = Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(1);
         is(rand1.equals(rand2), false, "getRandomByte should almost always return two different values when called into sequence");
 
 
         rand1 = Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(32);
         rand2 = Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(32);
         is(rand1.equals(rand2), false, "getRandomByte should almost always return two different values when called into sequence");
         is(rand1.split(0,1).equals(rand2.split(0,1)), false, "getRandomByte should almost always return two different values when called into sequence");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 1", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 2", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 3", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 4", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 5", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 6", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 7", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 8", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 9", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 10", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 11", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 12", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 13", "Value for random test");
         //is(Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(10000).toHexString(), "rand 14", "Value for random test");
 //jslog.debug(rand1.toHexString());
 //jslog.debug(rand2.toHexString());
 
         SimpleTest.finish();
 }
 
 try {
         MochiKit.Signal.connect(Clipperz.Crypto.PRNG.defaultRandomGenerator(), 'readyToGenerateRandomBytes', test_PRNG);
         Clipperz.Crypto.PRNG.defaultRandomGenerator().fastEntropyAccumulationForTestingPurpose();
         SimpleTest.waitForExplicitFinish();
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
         if (!o[k]) {
             s +=  k + ": " + err[k] + "\n";
             o[k] = err[k];
         }
     }
     ok ( false, s );
 }
 
 </script>
 </pre>
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/RSA.html b/frontend/gamma/tests/tests/Clipperz/Crypto/RSA.html
index f29f894..4c7fd86 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/RSA.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/RSA.html
@@ -1,87 +1,86 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/DOM.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/RSA.js'></script>
 
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 try {
                 varrsaPublicKey;
                 varrandomValue;
                 varpublicEncryptedValue;
         var privateEncryptedValue;
 
                 varstartTime;
                 varendTime;
 
 
 startTime=new Date();
         rsaPublicKey = Clipperz.Crypto.RSA.generatePublicKey(512);
 
 endTime=new Date();
 is(true, true, 'Time to generate the RSA public key (size 512 bit): '+(endTime.getTime()-startTime.getTime())/1000.0);
 
         randomValue = Clipperz.Crypto.Base.generateRandomSeed();
         publicEncryptedValue = Clipperz.Crypto.RSA.encryptUsingPublicKey(rsaPublicKey, randomValue);
         privateEncryptedValue = Clipperz.Crypto.RSA.encryptUsingPrivateKey(rsaPublicKey, randomValue);
         
         is(publicEncryptedValue == privateEncryptedValue, false);
         is(Clipperz.Crypto.RSA.decryptUsingPrivateKey(rsaPublicKey, publicEncryptedValue), randomValue);
         is(Clipperz.Crypto.RSA.decryptUsingPublicKey(rsaPublicKey, privateEncryptedValue), randomValue);
 
         //-------------------------------------------------------------------------
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
         if (!o[k]) {
             s +=  k + ": " + err[k] + "\n";
             o[k] = err[k];
         }
     }
     ok ( false, s );
 }
 
 </script>
 </pre>
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/SHA.html b/frontend/gamma/tests/tests/Clipperz/Crypto/SHA.html
index a580491..a2f6c04 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/SHA.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/SHA.html
@@ -1,172 +1,171 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <title>Clipperz.Crypto.SHA - TEST</title>
 
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../js/JSON/json2.js'></script>
                                         
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/DomHelper.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Logging.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Async.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
 
 
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.Async.js"></script>
 
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript" src="SHA.test.js"></script>
 </pre>
 </body>
 </html>
 
 
 
 <!-- html>
 <head>
         <script>
                 jslog_config_enabled = true;
                 clipperz_profiling_enabled = true;
         </script>
         
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/DomHelper.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 
 try {
                 varbyteArray;
                 varhash;
         var longText;
         var startTime, endTime;
         
         longText = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Donec nunc sapien, condimentum vitae, varius vel, pharetra in, augue. Mauris quam magna, pretium sit amet, accumsan id, volutpat lobortis, nibh. Fusce sagittis. Aenean justo. Curabitur euismod pede. Morbi at ante. Proin nisl leo, ultrices sed, facilisis et, nonummy sit amet, lorem. Praesent mauris tellus, pulvinar sed, nonummy vitae, rhoncus non, nunc. Proin placerat malesuada nisl. Nunc id enim. Maecenas commodo enim ac nibh. Sed condimentum, urna sit amet euismod gravida, mi urna varius odio, luctus pretium lectus justo nec felis. Ut in augue et est malesuada rhoncus. Sed vel orci. Mauris suscipit.  Praesent cursus velit non turpis. Donec tristique dolor ac est. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Nulla est sapien, vulputate eget, bibendum id, pharetra nec, mauris. Aliquam faucibus tincidunt dui. Proin iaculis. Maecenas sagittis. Integer et augue. Donec vitae urna in orci aliquet commodo. Vestibulum lorem sem, suscipit ac, placerat nec, mollis in, felis. Donec laoreet odio a mauris. Integer rutrum, sapien id varius molestie, mauris odio egestas orci, non bibendum sem felis in metus.  Phasellus consectetuer lectus adipiscing mauris. Ut magna tellus, euismod ac, suscipit tincidunt, ullamcorper adipiscing, massa. Etiam orci. Phasellus a urna. Cras neque quam, laoreet at, tempus eget, euismod nec, nibh. Etiam hendrerit. Aenean vel lorem. Ut ligula lacus, congue eu, lobortis sit amet, venenatis in, magna. Nullam cursus felis quis est. Sed sem est, condimentum eu, vestibulum a, mattis vel, diam. Curabitur tincidunt pede quis pede. Sed neque diam, convallis vel, luctus at, porta id, nisl. Suspendisse potenti. Sed volutpat lobortis orci. Praesent mi. In interdum. Suspendisse suscipit ipsum eget dolor. Curabitur et tellus sed velit hendrerit varius. Cras sit amet est.  Donec arcu nulla, vehicula et, pretium in, placerat id, felis. Integer mollis auctor lectus. Integer ultrices elementum sapien. Nam et erat. Nam pulvinar porta tortor. Nam at risus. Quisque nulla. Integer vestibulum, lacus id bibendum laoreet, ligula mi pharetra lorem, sit amet pharetra felis mauris quis justo. Aliquam ultricies. Duis a pede eget lorem dapibus rhoncus. Aenean eu elit non libero consectetuer viverra. Maecenas velit mi, eleifend vel, malesuada vel, condimentum quis, odio. Mauris tempus augue sed turpis. Pellentesque condimentum, lacus vitae pellentesque ultricies, risus tellus posuere nisi, et dictum turpis pede nec elit. Sed eu lectus eu justo sagittis euismod. Vestibulum lobortis, urna id mollis rhoncus, orci quam euismod ligula, at malesuada lacus magna vitae massa. Phasellus mattis fermentum velit.  Nulla vulputate consequat enim. Maecenas quis neque. Curabitur sagittis facilisis neque. In elementum, eros non porttitor rhoncus, libero turpis sodales odio, vitae porta tellus purus et ante. Nullam molestie sollicitudin metus. Donec a elit. Morbi ut lacus. Donec at arcu. Quisque velit diam, interdum a, lacinia at, varius et, odio. Cras neque magna, ornare id, sollicitudin id, consequat a, est. Phasellus vestibulum est at leo. Nam facilisis, nulla dapibus condimentum pellentesque, est magna viverra ligula, at sollicitudin urna augue ut sapien. Fusce justo.";
 
         //-------------------------------------------------------------------------
         //
                 //Test of SHA-256 algorithm
         //
         //-------------------------------------------------------------------------
 
         byteArray = new Clipperz.ByteArray();
         hash = Clipperz.Crypto.SHA.sha256(byteArray);
         is(hash.toHexString(), "0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "sha256('')");
 
         byteArray = new Clipperz.ByteArray("0xbd");
         hash = Clipperz.Crypto.SHA.sha256(byteArray);
         is(hash.toHexString(), "0x68325720aabd7c82f30f554b313d0570c95accbb7dc4b5aae11204c08ffe732b", "sha256('0xbd')");
 
         byteArray = new Clipperz.ByteArray("0x5fd4");
         hash = Clipperz.Crypto.SHA.sha256(byteArray);
         is(hash.toHexString(), "0x7c4fbf484498d21b487b9d61de8914b2eadaf2698712936d47c3ada2558f6788", "sha256('0x5fd4')");
 
         byteArray = new Clipperz.ByteArray("0xc98c8e55");
         hash = Clipperz.Crypto.SHA.sha256(byteArray);
         is(hash.toHexString(), "0x7abc22c0ae5af26ce93dbb94433a0e0b2e119d014f8e7f65bd56c61ccccd9504", "sha256('0xc98c8e55')");
 
         byteArray = new Clipperz.ByteArray("0x0df1cd526b5a4edd");
         hash = Clipperz.Crypto.SHA.sha256(byteArray);
         is(hash.toHexString(), "0x47f527210d6e8f940b5082fec01b7305908fa2b49ea3ae597c19a3986097153c", "sha256('0x0df1cd526b5a4edd')");
 
         byteArray = new Clipperz.ByteArray("0xfdf4700984ee11b70af1880d0e0fefd4");
         hash = Clipperz.Crypto.SHA.sha256(byteArray);
                 is(hash.toHexString(),
                 "0xb01ae16eed3b4a770f127b98469ba26fe3d8e9f59d8a2983214afe6cff0e6b6c",
                 "sha256('0xfdf4700984ee11b70af1880d0e0fefd4')");
 
         byteArray = new Clipperz.ByteArray("0x8cf53d90077df9a043bf8d10b470b144784411c93a4d504556834dae3ea4a5bb");
         hash = Clipperz.Crypto.SHA.sha256(byteArray);
                 is(hash.toHexString(),
                 "0x56059e8cb3c2978b198208bf5ca1e1ea5659b737a506324b7cec75b5ebaf057d",
                 "sha256('0x8cf53d90077df9a043bf8d10b470b144784411c93a4d504556834dae3ea4a5bb')");
 
         byteArray = new Clipperz.ByteArray("0xeebcf5cd6b12c90db64ff71a0e08ccd956e170a50dad769480d6b1fb3eff4934cde90f9e9b930ee637a66285c10f4e8a");
         hash = Clipperz.Crypto.SHA.sha256(byteArray);
                 is(hash.toHexString(),
                 "0xc117b9dce689c399ec99008788cd5d24d8396fab7d96315c4f3fe6d56da63bb3",
                 "sha256('0xeebcf5cd6b12c90db64ff71a0e08ccd956e170a50dad769480d6b1fb3eff4934cde90f9e9b930ee637a66285c10f4e8a')");
 
         byteArray = new Clipperz.ByteArray("0x3592ecfd1eac618fd390e7a9c24b656532509367c21a0eac1212ac83c0b20cd896eb72b801c4d212c5452bbbf09317b50c5c9fb1997553d2bbc29bb42f5748ad");
         hash = Clipperz.Crypto.SHA.sha256(byteArray);
                 is(hash.toHexString(),
                 "0x105a60865830ac3a371d3843324d4bb5fa8ec0e02ddaa389ad8da4f10215c454",
                 "sha256('0x3592ecfd1eac618fd390e7a9c24b656532509367c21a0eac1212ac83c0b20cd896eb72b801c4d212c5452bbbf09317b50c5c9fb1997553d2bbc29bb42f5748ad')");
 
 
         byteArray = new Clipperz.ByteArray(longText);
 startTime = new Date();
 //console.profile("SHA256");
         hash = Clipperz.Crypto.SHA.sha256(byteArray);
 //console.profileEnd("SHA256");
 endTime = new Date();
                 is(hash.toHexString(),
                 "0xf6fac13c06784e0fbc61a3d25c41c9984840a8b617a2beb57cf6fa3e5e4a8949",
                 "sha256(longText)");
         is((endTime - startTime) < 500, true, "Long text hash performance (" + (endTime - startTime) + ")");
         MochiKit.Logging.logDebug("elapsed time: " + (endTime - startTime));
 
 //#############################################################################
  
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
         if (!o[k]) {
             s +=  k + ": " + err[k] + "\n";
             o[k] = err[k];
         }
     }
     ok ( false, s );
 }
 
 </script>
 </pre>
 </body>
 </html -->
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/SRP.html b/frontend/gamma/tests/tests/Clipperz/Crypto/SRP.html
index d0ee153..ba842a9 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/SRP.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/SRP.html
@@ -1,158 +1,157 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/DomHelper.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/AES.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/PRNG.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SRP.js'></script>
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 hashString = function(aValue) {
                 return Clipperz.Crypto.SHA.sha256(new Clipperz.ByteArray(aValue)).toHexString().substring(2)
 }
 try {
                 varusername;
                 varpassphrase;
         
         var C;
         var P;
         var encryptedText_1;
         var encryptedText_2;
                 varsalt;
                 varx;
         var v;
         var v1;
         
         username = "giulio.cesare";
         passphrase = "trustno1";
         
         C = hashString(username);
         is (C, "bde3c7b5fdcd9d6ce72782ca1ae912fc4397d668fcb3a73a04e5d47852670c4a", "C");
         
         P  = hashString(passphrase + username);
         is (P, "d79f5c5a04e91e1c85fb64cb6ee9481cb52c181047f69da02cd6c3ce6d058a76", "P");
 
         salt = "cf1fa93393ade60318b8276f1f39420098419445005a7dc9117975fe1f8d9988";
 
         x = hashString(salt + P);
         is(x, "21fe88a158e420aade86e00b5eb12a4c19bf15482fa34c542c90b1afdbd5b5fd", "x");
         
         v = Clipperz.Crypto.SRP.g().powerModule(new Clipperz.Crypto.BigInt(x, 16), Clipperz.Crypto.SRP.n());
         is(v.asString(10), "33816467430011076413789931449607305355248467973000153409872503376381719918118", "v");
         is(v.asString(16), "4ac37139dbf32ebabd2c43f91dd085066d3c457d059efd5902d32ed247fcb626", "v (base 16)");
 
         //encryptedText_1 = Clipperz.Crypto.Base.encryptUsingSecretKey(passphrase, username);
         //encryptedText_2 = Clipperz.Crypto.Base.encryptUsingSecretKey(passphrase, username);
         //is (encryptedText_1 != encryptedText_2, true, "Two round of encryption (with random padding bits) should NOT produce the same result");
 
         //-------------------------------------------------------------------------
 
         username = "giulio.cesare.debug";
         passphrase = "trustno1";
         
         C = hashString(username);
         is (C, "fa1af609123b97a10d676158ed538d4657a89ac33a102b22bd9a66712039e208", "C");
 
         P  = hashString(passphrase + username);
         is (P, "e1bfba03dd626b12f29458a6ad63fb2c01b4765548504e1e2f6b1503c82e4253", "P");
 
         salt = "cf1fa93393ade60318b8276f1f39420098419445005a7dc9117975fe1f8d9988";
 
         x = hashString(salt + P);
         is(x, "93d4af3cdcd2447a745d309826dff3161feed4b15f32db8e909ff032a2bc8fb8", "x");
         
         v = Clipperz.Crypto.SRP.g().powerModule(new Clipperz.Crypto.BigInt(x, 16), Clipperz.Crypto.SRP.n());
         is(v.asString(10), "115049747015252903452664067168789229427785288458366249918596663144588656606556", "v");
 
         //encryptedText_1 = Clipperz.Crypto.Base.encryptUsingSecretKey(passphrase, username);
         //encryptedText_2 = Clipperz.Crypto.Base.encryptUsingSecretKey(passphrase, username);
         //is (encryptedText_1 != encryptedText_2, true, "Two round of encryption (with random padding bits) should NOT produce the same result");
         
         //-------------------------------------------------------------------------
 
         var srpConnection;
         var C, P, salt;
         
                 C = "da8602c2f847306f4eb9acdaad925277d1fad1408f173f128a078aea15e60b1e";
                 P =     "77643559beca49dd21c1c31db10bb0a9009662cb504413dc3fa3b7303c7e02ba";
                 salt ="000108cbbacda1f03ea9360301045434ec7d82ba150936df08a229cbb4832ce1";
         
         srpConnection = new Clipperz.Crypto.SRP.Connection({C:C, P:P, hash:Clipperz.Crypto.SHA.sha_d256});
         srpConnection._a = new Clipperz.Crypto.BigInt("37532428169486597638072888476611365392249575518156687476805936694442691012367", 10);
         srpConnection.set_s(new Clipperz.Crypto.BigInt(salt, 16));
         is (srpConnection.s().asString(16, 64), salt, "salt read/write is coherent");
         srpConnection.set_B(new Clipperz.Crypto.BigInt("123541032067854367017620977654446651448957899464139861291542193929199957895435", 10));
 
                 is(srpConnection.serverSideCredentialsWithSalt(salt).v,
                 "c73169c8236d37bf9ef11a2349e3064b7dc6e883a58d64443ea9235677520030",
                 "server side credentials - v"
         )
         is(srpConnection.S(), "84134227508133659832466942692590826994401065200828529664948840490489960952050", "Server side 'S'");
 //MochiKit.Logging.logDebug("=== serverSideCredentials: " + MochiKit.Base.serializeJSON(srpConnection.serverSideCredentialsWithSalt(salt)));
 
         srpConnection = new Clipperz.Crypto.SRP.Connection({C:C, P:P, hash:Clipperz.Crypto.SHA.sha_d256});
         try {
                 srpConnection.set_B(new Clipperz.Crypto.BigInt("0", 10));
                 ok(false, "Setting B to 0 should raise an exception");
         } catch(e) {
                 ok(true, "Setting B to 0 should raise an exception");
         }
         //-------------------------------------------------------------------------
 
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
         if (!o[k]) {
             s +=  k + ": " + err[k] + "\n";
             o[k] = err[k];
         }
     }
     ok ( false, s );
 }
 
 </script>
 </pre>
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/Crypto/Usage.html b/frontend/gamma/tests/tests/Clipperz/Crypto/Usage.html
index 8920915..4e7ad3d 100644
--- a/frontend/gamma/tests/tests/Clipperz/Crypto/Usage.html
+++ b/frontend/gamma/tests/tests/Clipperz/Crypto/Usage.html
@@ -1,119 +1,118 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <title>Clipperz.Crypto.Usage - TEST</title>
         
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../../js/JSON/json2.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/DomHelper.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Logging.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/AES.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Crypto/PRNG.js'></script>
 
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 Clipperz.Crypto.PRNG.defaultRandomGenerator().fastEntropyAccumulationForTestingPurpose();
 
 MochiKit.Base.update(Clipperz, {
         'PM': {
                 'Crypto': {
                         'passwordEntropy': function(aValue) {
                                 var result;
                                         varbitPerChar;
 
                                 bitPerChar = 4;
                                 if (/[a-z]/.test(aValue)) {
                                         bitPerChar ++;
                                 }
                                 if (/[A-Z]/.test(aValue)) {
                                         bitPerChar ++;
                                 }
                                 if (/[^a-zA-Z0-9]/.test(aValue)) {
                                         bitPerChar ++;
                                 }
                                 //MochiKit.Logging.logDebug("--- bitPerChar: " + bitPerChar);
 
                                 result = aValue.length * bitPerChar;
 
                                 return result;
                         }
                 }
         }
 })
 
 try {
         var keyValue;
         var keyEntropy;
                 varkey;
         var plainText;
         var cypherText;
         var randomBytes;
         var hashedValue;
         
         key = Clipperz.Crypto.SHA.sha256(new Clipperz.ByteArray("This is my long and complex passphrase"));
         keyEntropy = Clipperz.PM.Crypto.passwordEntropy(key);
 
         cypherText = Clipperz.Crypto.AES.encrypt(key, new Clipperz.ByteArray("some text to encrypt"));
         plainText = Clipperz.Crypto.AES.decrypt(key, cypherText).asString();
         is(plainText, "some text to encrypt");
 
         randomBytes = Clipperz.Crypto.PRNG.defaultRandomGenerator().getRandomBytes(256/8);
         hashedValue = Clipperz.Crypto.SHA.sha256(new Clipperz.ByteArray("text to hash"));
 
 //#############################################################################
  
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
         if (!o[k]) {
             s +=  k + ": " + err[k] + "\n";
             o[k] = err[k];
         }
     }
     ok ( false, s );
 }
 
 </script>
 </pre>
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/PM/Date.html b/frontend/gamma/tests/tests/Clipperz/PM/Date.html
index a606ca4..7b87185 100644
--- a/frontend/gamma/tests/tests/Clipperz/PM/Date.html
+++ b/frontend/gamma/tests/tests/Clipperz/PM/Date.html
@@ -1,56 +1,55 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <title>Clipperz.PM.Date - test</title>
 
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <!-- script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script -->
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../../js/JSON/json2.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Logging.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Async.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/KeyValueObjectStore.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Date.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/Strings.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/Date.js'></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.Async.js"></script>
 
 </head>
 <body>
 <pre id="test">
         <script type="text/javascript" src="Date.test.js"></script>
 </pre>
 
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/PM/Proxy.html b/frontend/gamma/tests/tests/Clipperz/PM/Proxy.html
index 8dc533f..8177285 100644
--- a/frontend/gamma/tests/tests/Clipperz/PM/Proxy.html
+++ b/frontend/gamma/tests/tests/Clipperz/PM/Proxy.html
@@ -1,62 +1,61 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <title>Clipperz.PM.Proxy - TEST</title>
 
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Logging.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Async.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/KeyValueObjectStore.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/AES.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/PRNG.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SRP.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Connection.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Crypto.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/Toll.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy.js'></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.Async.js"></script>
 
 </head>
 <body>
 <pre id="test">
         <script type="text/javascript" src="Proxy.test.js"></script>
 </pre>
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/PM/Toll.html b/frontend/gamma/tests/tests/Clipperz/PM/Toll.html
index 9baf167..6c2e000 100644
--- a/frontend/gamma/tests/tests/Clipperz/PM/Toll.html
+++ b/frontend/gamma/tests/tests/Clipperz/PM/Toll.html
@@ -1,59 +1,58 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <title>Clipperz.PM.Toll - test</title>
 
         <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Logging.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Async.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/KeyValueObjectStore.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/AES.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/PRNG.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SRP.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/PM/Toll.js'></script>
     <script type="text/javascript" src="../../../SimpleTest/SimpleTest.Async.js"></script>
 
 </head>
 <body>
 <pre id="test">
         <script type="text/javascript" src="Toll.test.js"></script>
 </pre>
 
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/PM/UI/Web/Controllers/MainController.html b/frontend/gamma/tests/tests/Clipperz/PM/UI/Web/Controllers/MainController.html
index 04f0e70..1eea01b 100644
--- a/frontend/gamma/tests/tests/Clipperz/PM/UI/Web/Controllers/MainController.html
+++ b/frontend/gamma/tests/tests/Clipperz/PM/UI/Web/Controllers/MainController.html
@@ -1,61 +1,60 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <title>Clipperz.PM.UI.Web.MainController - test</title>
 
         <script type="text/javascript" src="../../../../../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../../../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../../../../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../../../../../SimpleTest/test.css">
 
     <script type='text/javascript' src='../../../../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../../../../js/Clipperz/Base.js'></script>
     <script type='text/javascript' src='../../../../../../../js/Clipperz/ByteArray.js'></script>
     <script type='text/javascript' src='../../../../../../../js/Clipperz/Logging.js'></script>
     <script type='text/javascript' src='../../../../../../../js/Clipperz/Async.js'></script>
     <script type='text/javascript' src='../../../../../../../js/Clipperz/KeyValueObjectStore.js'></script>
 
     <script type='text/javascript' src='../../../../../../../js/Clipperz/Crypto/Base.js'></script>
     <script type='text/javascript' src='../../../../../../../js/Clipperz/Crypto/BigInt.js'></script>
     <script type='text/javascript' src='../../../../../../../js/Clipperz/Crypto/AES.js'></script>
     <script type='text/javascript' src='../../../../../../../js/Clipperz/Crypto/SHA.js'></script>
     <script type='text/javascript' src='../../../../../../../js/Clipperz/Crypto/PRNG.js'></script>
     <script type='text/javascript' src='../../../../../../../js/Clipperz/Crypto/SRP.js'></script>
 
     <script type='text/javascript' src='../../../../../../../js/Clipperz/Signal.js'></script>
                                             
         <script type='text/javascript' src='../../../../../../../js/Clipperz/PM/UI/Web/Controllers/MainController.js'></script>
     <script type="text/javascript" src="../../../../../../SimpleTest/SimpleTest.Async.js"></script>
 
 </head>
 <body>
 <pre id="test">
         <script type="text/javascript" src="MainController.test.js"></script>
 </pre>
 
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Clipperz/RoboFormExportProcessor.html b/frontend/gamma/tests/tests/Clipperz/RoboFormExportProcessor.html
index 87cde0f..b4500e3 100644
--- a/frontend/gamma/tests/tests/Clipperz/RoboFormExportProcessor.html
+++ b/frontend/gamma/tests/tests/Clipperz/RoboFormExportProcessor.html
@@ -1,207 +1,206 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <script type="text/javascript" src="../../../js/MochiKit/MochiKit.js"></script>
-        <script type="text/javascript" src="../../../js/JSLog/jslog.js"></script>
     <script type="text/javascript" src="../../SimpleTest/SimpleTest.js"></script>
     <link rel="stylesheet" type="text/css" href="../../SimpleTest/test.css">
 
         <script type='text/javascript' src='../../../js/Clipperz/YUI/Utils.js'></script>
         <script type='text/javascript' src='../../../js/Clipperz/Base.js'></script>
         <script type='text/javascript' src='../../../js/Clipperz/Async.js'></script>
         <script type='text/javascript' src='../../../js/Clipperz/KeePassExportProcessor.js'></script>
 
     <script type="text/javascript" src="../../SimpleTest/SimpleTest.Async.js"></script>
 </head>
 <body>
 <pre id="test">
 <script type="text/javascript">
 try {
         var deferredResult;
                 varkeePassProcessor;
 
         keePassProcessor = new Clipperz.KeePassExportProcessor();
         
         deferredResult = new MochiKit.Async.Deferred();
 
         deferredResult.addCallback(function(aResult) { return "[Gmail]\nGroup: General\nUserName: joe.clipperz\nURL: http://www.gmail.com\nPassword: NHy08ZCMYsqUeLQCawR7\n\n[del.icio.us]\nGroup: General\nUserName: joe69\nURL: http://del.icio.us\nPassword: tS1cIEeqp5y0wkU\n\n[Amazon]\nGroup: General\nUserName: jclipperz\nURL: http://www.amazon.com\nPassword: wvpkqNPIsqlI5g6XE9Tz\n\n[Paypal]\nGroup: General\nUserName: joeclipperz\nURL: http://www.paypal.com\nPassword: 24T4wIcvHnM28T3L\n\n[Technorati]\nGroup: General\nUserName: jclipperz\nURL: http://www.technorati.com\nPassword: UcVeNqF\n\n[American Airlines]\nGroup: General\nUserName: joe.clipperz\nURL: http://www.aa.com\nPassword: AtrYbmi7lmSjR\n" });
         deferredResult.addCallback(MochiKit.Base.method(keePassProcessor, 'deferredParse'));
         deferredResult.addCallback(function(aResult) { is(MochiKit.Base.serializeJSON(aResult), "[{\"Title\":\"Gmail\", \"Group\":\"General\", \"UserName\":\"joe.clipperz\", \"URL\":\"http://www.gmail.com\", \"Password\":\"NHy08ZCMYsqUeLQCawR7\"}, {\"Title\":\"del.icio.us\", \"Group\":\"General\", \"UserName\":\"joe69\", \"URL\":\"http://del.icio.us\", \"Password\":\"tS1cIEeqp5y0wkU\"}, {\"Title\":\"Amazon\", \"Group\":\"General\", \"UserName\":\"jclipperz\", \"URL\":\"http://www.amazon.com\", \"Password\":\"wvpkqNPIsqlI5g6XE9Tz\"}, {\"Title\":\"Paypal\", \"Group\":\"General\", \"UserName\":\"joeclipperz\", \"URL\":\"http://www.paypal.com\", \"Password\":\"24T4wIcvHnM28T3L\"}, {\"Title\":\"Technorati\", \"Group\":\"General\", \"UserName\":\"jclipperz\", \"URL\":\"http://www.technorati.com\", \"Password\":\"UcVeNqF\"}, {\"Title\":\"American Airlines\", \"Group\":\"General\", \"UserName\":\"joe.clipperz\", \"URL\":\"http://www.aa.com\", \"Password\":\"AtrYbmi7lmSjR\"}]", "first test"); });
         deferredResult.addErrback(function(anError) { is("ERROR", anError) });
 
         deferredResult.addCallback(function(aResult) { return "[Gmail]\nGroup: General\nUserName: joe.clipperz\nURL: http://www.gmail.com\nPassword: NHy08ZCMYsqUeLQCawR7\nNotes: Personal account\n\n[del.icio.us]\nGroup: General\nUserName: joe69\nURL: http://del.icio.us\nPassword: tS1cIEeqp5y0wkU\nNotes: social bookmarking site\n\n[Amazon]\nGroup: General\nUserName: jclipperz\nURL: http://www.amazon.com\nPassword: wvpkqNPIsqlI5g6XE9Tz\nNotes: The US online store\n\n[Paypal]\nGroup: General\nUserName: joeclipperz\nURL: http://www.paypal.com\nPassword: 24T4wIcvHnM28T3L\nNotes: Linked to my savings account\n\n[Technorati]\nGroup: General\nUserName: jclipperz\nURL: http://www.technorati.com\nPassword: UcVeNqF\nNotes: Blog ranking and searching\n\n[American Airlines]\nGroup: General\nUserName: joe.clipperz\nURL: http://www.aa.com\nPassword: AtrYbmi7lmSjR\nNotes: Adavantages card n. 795495\n" });
         deferredResult.addCallback(MochiKit.Base.method(keePassProcessor, 'deferredParse'));
         deferredResult.addCallback(function(aResult) { is(MochiKit.Base.serializeJSON(aResult), "[{\"Title\":\"Gmail\", \"Group\":\"General\", \"UserName\":\"joe.clipperz\", \"URL\":\"http://www.gmail.com\", \"Password\":\"NHy08ZCMYsqUeLQCawR7\", \"Notes\":\"Personal account\"}, {\"Title\":\"del.icio.us\", \"Group\":\"General\", \"UserName\":\"joe69\", \"URL\":\"http://del.icio.us\", \"Password\":\"tS1cIEeqp5y0wkU\", \"Notes\":\"social bookmarking site\"}, {\"Title\":\"Amazon\", \"Group\":\"General\", \"UserName\":\"jclipperz\", \"URL\":\"http://www.amazon.com\", \"Password\":\"wvpkqNPIsqlI5g6XE9Tz\", \"Notes\":\"The US online store\"}, {\"Title\":\"Paypal\", \"Group\":\"General\", \"UserName\":\"joeclipperz\", \"URL\":\"http://www.paypal.com\", \"Password\":\"24T4wIcvHnM28T3L\", \"Notes\":\"Linked to my savings account\"}, {\"Title\":\"Technorati\", \"Group\":\"General\", \"UserName\":\"jclipperz\", \"URL\":\"http://www.technorati.com\", \"Password\":\"UcVeNqF\", \"Notes\":\"Blog ranking and searching\"}, {\"Title\":\"American Airlines\", \"Group\":\"General\", \"UserName\":\"joe.clipperz\", \"URL\":\"http://www.aa.com\", \"Password\":\"AtrYbmi7lmSjR\", \"Notes\":\"Adavantages card n. 795495\"}]", "second test"); });
         deferredResult.addErrback(function(anError) { is("ERROR", anError) });
 
         deferredResult.addCallback(function(aResult) { return "[Gmail]\nGroup: General\nUserName: joe.clipperz\nURL: http://www.gmail.com\nPassword: NHy08ZCMYsqUeLQCawR7\nNotes: Personal account\nwith some notes stored\non multiple lines\n\n[del.icio.us]\nGroup: General\nUserName: joe69\nURL: http://del.icio.us\nPassword: tS1cIEeqp5y0wkU\nNotes: social bookmarking site\n\n[Amazon]\nGroup: General\nUserName: jclipperz\nURL: http://www.amazon.com\nPassword: wvpkqNPIsqlI5g6XE9Tz\nNotes: The US online store\n\n[Paypal]\nGroup: General\nUserName: joeclipperz\nURL: http://www.paypal.com\nPassword: 24T4wIcvHnM28T3L\nNotes: Linked to my savings account\n\n[Technorati]\nGroup: General\nUserName: jclipperz\nURL: http://www.technorati.com\nPassword: UcVeNqF\nNotes: Blog ranking and searching\n\n[American Airlines]\nGroup: General\nUserName: joe.clipperz\nURL: http://www.aa.com\nPassword: AtrYbmi7lmSjR\nNotes: Adavantages card n. 795495\n" });
         deferredResult.addCallback(MochiKit.Base.method(keePassProcessor, 'deferredParse'));
         deferredResult.addCallback(function(aResult) { is(MochiKit.Base.serializeJSON(aResult), "[{\"Title\":\"Gmail\", \"Group\":\"General\", \"UserName\":\"joe.clipperz\", \"URL\":\"http://www.gmail.com\", \"Password\":\"NHy08ZCMYsqUeLQCawR7\", \"Notes\":\"Personal account\\nwith some notes stored\\non multiple lines\\n\"}, {\"Title\":\"del.icio.us\", \"Group\":\"General\", \"UserName\":\"joe69\", \"URL\":\"http://del.icio.us\", \"Password\":\"tS1cIEeqp5y0wkU\", \"Notes\":\"social bookmarking site\"}, {\"Title\":\"Amazon\", \"Group\":\"General\", \"UserName\":\"jclipperz\", \"URL\":\"http://www.amazon.com\", \"Password\":\"wvpkqNPIsqlI5g6XE9Tz\", \"Notes\":\"The US online store\"}, {\"Title\":\"Paypal\", \"Group\":\"General\", \"UserName\":\"joeclipperz\", \"URL\":\"http://www.paypal.com\", \"Password\":\"24T4wIcvHnM28T3L\", \"Notes\":\"Linked to my savings account\"}, {\"Title\":\"Technorati\", \"Group\":\"General\", \"UserName\":\"jclipperz\", \"URL\":\"http://www.technorati.com\", \"Password\":\"UcVeNqF\", \"Notes\":\"Blog ranking and searching\"}, {\"Title\":\"American Airlines\", \"Group\":\"General\", \"UserName\":\"joe.clipperz\", \"URL\":\"http://www.aa.com\", \"Password\":\"AtrYbmi7lmSjR\", \"Notes\":\"Adavantages card n. 795495\"}]", "third test"); });
         deferredResult.addErrback(function(anError) { is("ERROR", anError) });
 
 
 
         deferredResult.addBoth(SimpleTest.finish);
         deferredResult.callback();
         
 /*
         var set;
                 varobject1;
                 varobject2;
         var object3;
         
         set = new Clipperz.Set();
 
         object1 = new Object();
         object2 = new Object();
         object3 = new Object();
         
         object1.label = "object 1";
         object2.label = "object 2";
         object3.label = "object 3";
         
         is(set.size(), 0, "A new set should be empty");
 
         set.add(object1);
         is(set.size(), 1);
         is(set.contains(object1), true);
         is(set.contains(object2), false);
 
         set.add(object1);
         is(set.size(), 1, "Adding the same object twice does not change the set content");
         is(set.contains(object1), true);
         is(set.contains(object2), false);
 
         set.add(object2);
         is(set.size(), 2);
         is(set.contains(object1), true);
         is(set.contains(object2), true);
         is(set.contains(object3), false);
 
         set.remove(object1);
         is(set.size(), 1, "Size check after removing an object");
         is(set.contains(object1), false);
         is(set.contains(object2), true);
         is(set.contains(object3), false);
 
         set.remove(object1);
         is(set.size(), 1, "Removing twice the same object does not change the set content");
         is(set.contains(object1), false);
         is(set.contains(object2), true);
         is(set.contains(object3), false);
 
         set.empty();
         is(set.size(), 0);
         
         {
                         varitems;
                         varpopulatedSet;
                 
                 items = ["item1", "item2", "item3"];
                 
                 populatedSet = new Clipperz.Set({'items': items});
                 is(populatedSet.size(), 3);
                 is(populatedSet.contains("item1"), true);
                 is(populatedSet.contains("item4"), false);
                 
                 items.splice(0, items.length);
                 is(populatedSet.size(), 3);
         }
         
         {
                         varitems;
                         vardeletedItems;
                 
                 items = ["item1", "item2", "item3"];
                 
                 set = new Clipperz.Set({'items': items});
                 deletedItems = ["item1"];
                 set.remove(deletedItems);
                 is(set.size(), 2, "here I am");
                 is(set.contains("item1"), false);
                 is(set.contains("item2"), true);
 
                 set = new Clipperz.Set({'items': items});
                 deletedItems = ["item1", "item2"];
                 set.remove(deletedItems);
                 is(set.size(), 1);
                 is(set.contains("item1"), false);
                 is(set.contains("item2"), false);
 
                 set = new Clipperz.Set({'items': items});
                 deletedItems = ["item1", "item4"];
                 set.remove(deletedItems);
                 is(set.size(), 2);
                 is(set.contains("item1"), false);
                 is(set.contains("item2"), true);
         }
 
         {
                 var items;
                 var poppedItem;
                 
                 items = ["item1", "item2", "item3"];
                 set = new Clipperz.Set({'items': items});
 
                 poppedItem = set.popAnItem();
                 ok(poppedItem != null, "test popAnItem - 1");
                 is(set.size(), 2, "test popAnItem - 2");
 
                 poppedItem = set.popAnItem();
                 ok(poppedItem != null, "test popAnItem - 3");
                 is(set.size(), 1, "test popAnItem - 4");
 
                 poppedItem = set.popAnItem();
                 ok(poppedItem != null, "test popAnItem - 5");
                 is(set.size(), 0, "test popAnItem - 6");
 
                 poppedItem = set.popAnItem();
                 ok(poppedItem == null, "test popAnItem - 7");
         }
 */
 
         SimpleTest.waitForExplicitFinish();
 
 } catch (err) {
     
     var s = "test suite failure!\n";
     var o = {};
     var k = null;
     for (k in err) {
         // ensure unique keys?!
         if (!o[k]) {
             s +=  k + ": " + err[k] + "\n";
             o[k] = err[k];
         }
     }
     ok ( false, s );
 }
 
 </script>
 </pre>
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Components/CardDialogNew/index.html b/frontend/gamma/tests/tests/Components/CardDialogNew/index.html
index 2d502b4..64f9e4d 100644
--- a/frontend/gamma/tests/tests/Components/CardDialogNew/index.html
+++ b/frontend/gamma/tests/tests/Components/CardDialogNew/index.html
@@ -1,114 +1,112 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <title>Card Dialog NEW - test</title>
     <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
     <script type='text/javascript' src='../../../../js/JSON/json2.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/DomHelper.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Date.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/DOM.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Logging.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Async.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Signal.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Style.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Visual.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Set.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/KeyValueObjectStore.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/AES.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/PRNG.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SRP.js'></script>
                                                     
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Toll.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy/Proxy.Offline.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy/Proxy.Test.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy/Proxy.Offline.DataStore.js'></script>
                                                     
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Connection.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Crypto.js'></script>
                                                     
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Strings.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Strings/Strings_en-US.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Date.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/EncryptedRemoteObject.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/Record.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/Record.Version.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/Record.Version.Field.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/DirectLogin.js'></script>
     <!-- script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/Record.Field.js'></script -->
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/User.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/User.Header.Legacy.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/User.Header.RecordIndex.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/BaseComponent.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/Button.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/ComponentSlot.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/PasswordEntropyDisplay.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/ProgressBar.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/SimpleMessagePanel.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/TabPanelComponent.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/Tooltip.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/TranslatorWidget.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Web/Components/CardDialogComponent.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Web/Components/CardDialogRecordFieldComponent.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Controllers/ProgressBarController.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Controllers/TabPanelController.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Web/Controllers/CardDialogController.js'></script>
 
     <script type='text/javascript' src='./User.data.js'></script>
     <script type='text/javascript' src='./cardDialogNew_test.js'></script>
 <script>
         Clipperz_IEisBroken = false;
 </script>
 
 <!--[if IE]><script>
 Clipperz_IEisBroken = true;
 </script><![endif]-->
 
-        <link rel="stylesheet" type="text/css" href="../../../../css/clipperz/clipperz.css" />
-        <link rel="stylesheet" type="text/css" href="../../../../css/clipperz/compact.css" />
-        <link rel="stylesheet" type="text/css" href="../../../../css/clipperz/ytheme-clipperz.css" />
+        <link rel="stylesheet" type="text/css" href="../../../../css/web.css" />
 
 </head>
 <body>
 
 <div id="tableWrapper"></div>
 
 </body>
 </html>
diff --git a/frontend/gamma/tests/tests/Components/Tooltips/index.html b/frontend/gamma/tests/tests/Components/Tooltips/index.html
index 02c6c34..3772227 100644
--- a/frontend/gamma/tests/tests/Components/Tooltips/index.html
+++ b/frontend/gamma/tests/tests/Components/Tooltips/index.html
@@ -1,140 +1,138 @@
 <!--
 
 Copyright 2008-2011 Clipperz Srl
 
 This file is part of Clipperz Community Edition.
 Clipperz Community Edition is an online password manager.
 For further information about its features and functionalities please
 refer to http://www.clipperz.com.
 
 * Clipperz Community Edition is free software: you can redistribute
   it and/or modify it under the terms of the GNU Affero General Public
   License as published by the Free Software Foundation, either version
   3 of the License, or (at your option) any later version.
 
 * Clipperz Community Edition is distributed in the hope that it will
   be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the GNU Affero General Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
   License along with Clipperz Community Edition.  If not, see
   <http://www.gnu.org/licenses/>.
 
 -->
 
 <html>
 <head>
         <title>TOOLTIPS - test</title>
     <script type="text/javascript" src="../../../../js/MochiKit/MochiKit.js"></script>
     <script type='text/javascript' src='../../../../js/JSON/json2.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/Utils.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/YUI/DomHelper.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Base.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Date.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/DOM.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/ByteArray.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Logging.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Async.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/Signal.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Style.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Visual.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/Set.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/KeyValueObjectStore.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/Base.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/BigInt.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/AES.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SHA.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/PRNG.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/Crypto/SRP.js'></script>
                                                     
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Toll.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy/Proxy.Offline.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy/Proxy.Test.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Proxy/Proxy.Offline.DataStore.js'></script>
                                                     
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Connection.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Crypto.js'></script>
                                                     
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Strings.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Strings/Strings_en-US.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/Date.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/EncryptedRemoteObject.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/Record.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/Record.Version.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/Record.Version.Field.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/DirectLogin.js'></script>
     <!-- script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/Record.Field.js'></script -->
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/User.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/User.Header.Legacy.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/DataModel/User.Header.RecordIndex.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/BaseComponent.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/ComponentSlot.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/PasswordEntropyDisplay.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/ProgressBar.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/SimpleMessagePanel.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/TabPanelComponent.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/Tooltip.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Components/TranslatorWidget.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Web/Components/CardDialogComponent.js'></script>
     <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Web/Components/CardDialogRecordFieldComponent.js'></script>
 
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Controllers/ProgressBarController.js'></script>
         <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Common/Controllers/TabPanelController.js'></script>
 
     <script type='text/javascript' src='../../../../js/Clipperz/PM/UI/Web/Controllers/CardDialogController.js'></script>
 
     <script type='text/javascript' src='./tooltips_test.js'></script>
 <script>
         Clipperz_IEisBroken = false;
 </script>
 
 <!--[if IE]><script>
 Clipperz_IEisBroken = true;
 </script><![endif]-->
 
-        <link rel="stylesheet" type="text/css" href="../../../../css/clipperz/clipperz.css" />
-        <link rel="stylesheet" type="text/css" href="../../../../css/clipperz/compact.css" />
-        <link rel="stylesheet" type="text/css" href="../../../../css/clipperz/ytheme-clipperz.css" />
+        <link rel="stylesheet" type="text/css" href="../../../../css/web.css" />
 
 <style>
 
 div.leftColumn {
         float:left;
 }
 
 div.rightColumn {
         float:left;
 }
 
 div.boxWrapper {
         padding: 70px 200px;
 }
 
 div.box {
         width: 100px;
         height: 30px;
         border: 1px solid red;
 }
 </style>
 
 </head>
 <body>
 
 <div class="leftColumn">
         <div class="boxWrapper"><div id="ABOVE" class="box">above</div></div>
         <div class="boxWrapper"><div id="BELOW" class="box">below</div></div>
 </div>
 <div class="rightColumn">
         <div class="boxWrapper"><div id="LEFT" class="box">left</div></div>
         <div class="boxWrapper"><div id="RIGHT" class="box">right</div></div>
 </div>
 
 </body>
 </html>