1 files changed, 7 insertions, 9 deletions

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,107 +1,107 @@
 /***
 
 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 */
@@ -129,384 +129,382 @@ MochiKit.Base.update(MochiKit.Iter, {
                 }
                 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) {