[ tor-browser ].git.dasho

Base.js (41910B)
      1 /***
      2 
      3 MochiKit.Base 1.4
      4 
      5 See <http://mochikit.com/> for documentation, downloads, license, etc.
      6 
      7 (c) 2005 Bob Ippolito.  All rights Reserved.
      8 
      9 ***/
     10 
     11 if (typeof(dojo) != 'undefined') {
     12    dojo.provide("MochiKit.Base");
     13 }
     14 if (typeof(MochiKit) == 'undefined') {
     15    MochiKit = {};
     16 }
     17 if (typeof(MochiKit.Base) == 'undefined') {
     18    MochiKit.Base = {};
     19 }
     20 if (typeof(MochiKit.__export__) == "undefined") {
     21    MochiKit.__export__ = (MochiKit.__compat__  ||
     22        (typeof(JSAN) == 'undefined' && typeof(dojo) == 'undefined')
     23    );
     24 }
     25 
     26 MochiKit.Base.VERSION = "1.4";
     27 MochiKit.Base.NAME = "MochiKit.Base";
     28 /** @id MochiKit.Base.update */
     29 MochiKit.Base.update = function (self, obj/*, ... */) {
     30    if (self === null) {
     31        self = {};
     32    }
     33    for (var i = 1; i < arguments.length; i++) {
     34        var o = arguments[i];
     35        if (typeof(o) != 'undefined' && o !== null) {
     36            for (var k in o) {
     37                self[k] = o[k];
     38            }
     39        }
     40    }
     41    return self;
     42 };
     43 
     44 MochiKit.Base.update(MochiKit.Base, {
     45    __repr__: function () {
     46        return "[" + this.NAME + " " + this.VERSION + "]";
     47    },
     48 
     49    toString: function () {
     50        return this.__repr__();
     51    },
     52 
     53    /** @id MochiKit.Base.camelize */
     54    camelize: function (selector) {
     55        /* from dojo.style.toCamelCase */
     56        var arr = selector.split('-');
     57        var cc = arr[0];
     58        for (var i = 1; i < arr.length; i++) {
     59            cc += arr[i].charAt(0).toUpperCase() + arr[i].substring(1);
     60        }
     61        return cc;
     62    },
     63 
     64    /** @id MochiKit.Base.counter */
     65    counter: function (n/* = 1 */) {
     66        if (arguments.length === 0) {
     67            n = 1;
     68        }
     69        return function () {
     70            return n++;
     71        };
     72    },
     73 
     74    /** @id MochiKit.Base.clone */
     75    clone: function (obj) {
     76        var me = arguments.callee;
     77        if (arguments.length == 1) {
     78            me.prototype = obj;
     79            return new me();
     80        }
     81    },
     82 
     83    _flattenArray: function (res, lst) {
     84        for (var i = 0; i < lst.length; i++) {
     85            var o = lst[i];
     86            if (o instanceof Array) {
     87                arguments.callee(res, o);
     88            } else {
     89                res.push(o);
     90            }
     91        }
     92        return res;
     93    },
     94 
     95    /** @id MochiKit.Base.flattenArray */
     96    flattenArray: function (lst) {
     97        return MochiKit.Base._flattenArray([], lst);
     98    },
     99 
    100    /** @id MochiKit.Base.flattenArguments */
    101    flattenArguments: function (lst/* ...*/) {
    102        var res = [];
    103        var m = MochiKit.Base;
    104        var args = m.extend(null, arguments);
    105        while (args.length) {
    106            var o = args.shift();
    107            if (o && typeof(o) == "object" && typeof(o.length) == "number") {
    108                for (var i = o.length - 1; i >= 0; i--) {
    109                    args.unshift(o[i]);
    110                }
    111            } else {
    112                res.push(o);
    113            }
    114        }
    115        return res;
    116    },
    117 
    118    /** @id MochiKit.Base.extend */
    119    extend: function (self, obj, /* optional */skip) {
    120        // Extend an array with an array-like object starting
    121        // from the skip index
    122        if (!skip) {
    123            skip = 0;
    124        }
    125        if (obj) {
    126            // allow iterable fall-through, but skip the full isArrayLike
    127            // check for speed, this is called often.
    128            var l = obj.length;
    129            if (typeof(l) != 'number' /* !isArrayLike(obj) */) {
    130                if (typeof(MochiKit.Iter) != "undefined") {
    131                    obj = MochiKit.Iter.list(obj);
    132                    l = obj.length;
    133                } else {
    134                    throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
    135                }
    136            }
    137            if (!self) {
    138                self = [];
    139            }
    140            for (var i = skip; i < l; i++) {
    141                self.push(obj[i]);
    142            }
    143        }
    144        // This mutates, but it's convenient to return because
    145        // it's often used like a constructor when turning some
    146        // ghetto array-like to a real array
    147        return self;
    148    },
    149 
    150 
    151    /** @id MochiKit.Base.updatetree */
    152    updatetree: function (self, obj/*, ...*/) {
    153        if (self === null) {
    154            self = {};
    155        }
    156        for (var i = 1; i < arguments.length; i++) {
    157            var o = arguments[i];
    158            if (typeof(o) != 'undefined' && o !== null) {
    159                for (var k in o) {
    160                    var v = o[k];
    161                    if (typeof(self[k]) == 'object' && typeof(v) == 'object') {
    162                        arguments.callee(self[k], v);
    163                    } else {
    164                        self[k] = v;
    165                    }
    166                }
    167            }
    168        }
    169        return self;
    170    },
    171 
    172    /** @id MochiKit.Base.setdefault */
    173    setdefault: function (self, obj/*, ...*/) {
    174        if (self === null) {
    175            self = {};
    176        }
    177        for (var i = 1; i < arguments.length; i++) {
    178            var o = arguments[i];
    179            for (var k in o) {
    180                if (!(k in self)) {
    181                    self[k] = o[k];
    182                }
    183            }
    184        }
    185        return self;
    186    },
    187 
    188    /** @id MochiKit.Base.keys */
    189    keys: function (obj) {
    190        var rval = [];
    191        for (var prop in obj) {
    192            rval.push(prop);
    193        }
    194        return rval;
    195    },
    196 
    197    /** @id MochiKit.Base.values */
    198    values: function (obj) {
    199        var rval = [];
    200        for (var prop in obj) {
    201            rval.push(obj[prop]);
    202        }
    203        return rval;
    204    },
    205 
    206     /** @id MochiKit.Base.items */
    207    items: function (obj) {
    208        var rval = [];
    209        var e;
    210        for (var prop in obj) {
    211            var v;
    212            try {
    213                v = obj[prop];
    214            } catch (e) {
    215                continue;
    216            }
    217            rval.push([prop, v]);
    218        }
    219        return rval;
    220    },
    221 
    222 
    223    _newNamedError: function (module, name, func) {
    224        func.prototype = new MochiKit.Base.NamedError(module.NAME + "." + name);
    225        module[name] = func;
    226    },
    227 
    228 
    229    /** @id MochiKit.Base.operator */
    230    operator: {
    231        // unary logic operators
    232        /** @id MochiKit.Base.truth */
    233        truth: function (a) { return !!a; },
    234        /** @id MochiKit.Base.lognot */
    235        lognot: function (a) { return !a; },
    236        /** @id MochiKit.Base.identity */
    237        identity: function (a) { return a; },
    238 
    239        // bitwise unary operators
    240        /** @id MochiKit.Base.not */
    241        not: function (a) { return ~a; },
    242        /** @id MochiKit.Base.neg */
    243        neg: function (a) { return -a; },
    244 
    245        // binary operators
    246        /** @id MochiKit.Base.add */
    247        add: function (a, b) { return a + b; },
    248        /** @id MochiKit.Base.sub */
    249        sub: function (a, b) { return a - b; },
    250        /** @id MochiKit.Base.div */
    251        div: function (a, b) { return a / b; },
    252        /** @id MochiKit.Base.mod */
    253        mod: function (a, b) { return a % b; },
    254        /** @id MochiKit.Base.mul */
    255        mul: function (a, b) { return a * b; },
    256 
    257        // bitwise binary operators
    258        /** @id MochiKit.Base.and */
    259        and: function (a, b) { return a & b; },
    260        /** @id MochiKit.Base.or */
    261        or: function (a, b) { return a | b; },
    262        /** @id MochiKit.Base.xor */
    263        xor: function (a, b) { return a ^ b; },
    264        /** @id MochiKit.Base.lshift */
    265        lshift: function (a, b) { return a << b; },
    266        /** @id MochiKit.Base.rshift */
    267        rshift: function (a, b) { return a >> b; },
    268        /** @id MochiKit.Base.zrshift */
    269        zrshift: function (a, b) { return a >>> b; },
    270 
    271        // near-worthless built-in comparators
    272        /** @id MochiKit.Base.eq */
    273        eq: function (a, b) { return a == b; },
    274        /** @id MochiKit.Base.ne */
    275        ne: function (a, b) { return a != b; },
    276        /** @id MochiKit.Base.gt */
    277        gt: function (a, b) { return a > b; },
    278        /** @id MochiKit.Base.ge */
    279        ge: function (a, b) { return a >= b; },
    280        /** @id MochiKit.Base.lt */
    281        lt: function (a, b) { return a < b; },
    282        /** @id MochiKit.Base.le */
    283        le: function (a, b) { return a <= b; },
    284 
    285        // strict built-in comparators
    286        seq: function (a, b) { return a === b; },
    287        sne: function (a, b) { return a !== b; },
    288 
    289        // compare comparators
    290        /** @id MochiKit.Base.ceq */
    291        ceq: function (a, b) { return MochiKit.Base.compare(a, b) === 0; },
    292        /** @id MochiKit.Base.cne */
    293        cne: function (a, b) { return MochiKit.Base.compare(a, b) !== 0; },
    294        /** @id MochiKit.Base.cgt */
    295        cgt: function (a, b) { return MochiKit.Base.compare(a, b) == 1; },
    296        /** @id MochiKit.Base.cge */
    297        cge: function (a, b) { return MochiKit.Base.compare(a, b) != -1; },
    298        /** @id MochiKit.Base.clt */
    299        clt: function (a, b) { return MochiKit.Base.compare(a, b) == -1; },
    300        /** @id MochiKit.Base.cle */
    301        cle: function (a, b) { return MochiKit.Base.compare(a, b) != 1; },
    302 
    303        // binary logical operators
    304        /** @id MochiKit.Base.logand */
    305        logand: function (a, b) { return a && b; },
    306        /** @id MochiKit.Base.logor */
    307        logor: function (a, b) { return a || b; },
    308        /** @id MochiKit.Base.contains */
    309        contains: function (a, b) { return b in a; }
    310    },
    311 
    312    /** @id MochiKit.Base.forwardCall */
    313    forwardCall: function (func) {
    314        return function () {
    315            return this[func].apply(this, arguments);
    316        };
    317    },
    318 
    319    /** @id MochiKit.Base.itemgetter */
    320    itemgetter: function (func) {
    321        return function (arg) {
    322            return arg[func];
    323        };
    324    },
    325 
    326    /** @id MochiKit.Base.typeMatcher */
    327    typeMatcher: function (/* typ */) {
    328        var types = {};
    329        for (var i = 0; i < arguments.length; i++) {
    330            var typ = arguments[i];
    331            types[typ] = typ;
    332        }
    333        return function () {
    334            for (var i = 0; i < arguments.length; i++) {
    335                if (!(typeof(arguments[i]) in types)) {
    336                    return false;
    337                }
    338            }
    339            return true;
    340        };
    341    },
    342 
    343    /** @id MochiKit.Base.isNull */
    344    isNull: function (/* ... */) {
    345        for (var i = 0; i < arguments.length; i++) {
    346            if (arguments[i] !== null) {
    347                return false;
    348            }
    349        }
    350        return true;
    351    },
    352 
    353    /** @id MochiKit.Base.isUndefinedOrNull */
    354    isUndefinedOrNull: function (/* ... */) {
    355        for (var i = 0; i < arguments.length; i++) {
    356            var o = arguments[i];
    357            if (!(typeof(o) == 'undefined' || o === null)) {
    358                return false;
    359            }
    360        }
    361        return true;
    362    },
    363 
    364    /** @id MochiKit.Base.isEmpty */
    365    isEmpty: function (obj) {
    366        return !MochiKit.Base.isNotEmpty.apply(this, arguments);
    367    },
    368 
    369    /** @id MochiKit.Base.isNotEmpty */
    370    isNotEmpty: function (obj) {
    371        for (var i = 0; i < arguments.length; i++) {
    372            var o = arguments[i];
    373            if (!(o && o.length)) {
    374                return false;
    375            }
    376        }
    377        return true;
    378    },
    379 
    380    /** @id MochiKit.Base.isArrayLike */
    381    isArrayLike: function () {
    382        for (var i = 0; i < arguments.length; i++) {
    383            var o = arguments[i];
    384            var typ = typeof(o);
    385            if (
    386                (typ != 'object' && !(typ == 'function' && typeof(o.item) == 'function')) ||
    387                o === null ||
    388                typeof(o.length) != 'number' ||
    389                o.nodeType === 3
    390            ) {
    391                return false;
    392            }
    393        }
    394        return true;
    395    },
    396 
    397    /** @id MochiKit.Base.isDateLike */
    398    isDateLike: function () {
    399        for (var i = 0; i < arguments.length; i++) {
    400            var o = arguments[i];
    401            if (typeof(o) != "object" || o === null
    402                    || typeof(o.getTime) != 'function') {
    403                return false;
    404            }
    405        }
    406        return true;
    407    },
    408 
    409 
    410    /** @id MochiKit.Base.xmap */
    411    xmap: function (fn/*, obj... */) {
    412        if (fn === null) {
    413            return MochiKit.Base.extend(null, arguments, 1);
    414        }
    415        var rval = [];
    416        for (var i = 1; i < arguments.length; i++) {
    417            rval.push(fn(arguments[i]));
    418        }
    419        return rval;
    420    },
    421 
    422    /** @id MochiKit.Base.map */
    423    map: function (fn, lst/*, lst... */) {
    424        var m = MochiKit.Base;
    425        var itr = MochiKit.Iter;
    426        var isArrayLike = m.isArrayLike;
    427        if (arguments.length <= 2) {
    428            // allow an iterable to be passed
    429            if (!isArrayLike(lst)) {
    430                if (itr) {
    431                    // fast path for map(null, iterable)
    432                    lst = itr.list(lst);
    433                    if (fn === null) {
    434                        return lst;
    435                    }
    436                } else {
    437                    throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
    438                }
    439            }
    440            // fast path for map(null, lst)
    441            if (fn === null) {
    442                return m.extend(null, lst);
    443            }
    444            // disabled fast path for map(fn, lst)
    445            /*
    446            if (false && typeof(Array.prototype.map) == 'function') {
    447                // Mozilla fast-path
    448                return Array.prototype.map.call(lst, fn);
    449            }
    450            */
    451            var rval = [];
    452            for (var i = 0; i < lst.length; i++) {
    453                rval.push(fn(lst[i]));
    454            }
    455            return rval;
    456        } else {
    457            // default for map(null, ...) is zip(...)
    458            if (fn === null) {
    459                fn = Array;
    460            }
    461            var length = null;
    462            for (i = 1; i < arguments.length; i++) {
    463                // allow iterables to be passed
    464                if (!isArrayLike(arguments[i])) {
    465                    if (itr) {
    466                        return itr.list(itr.imap.apply(null, arguments));
    467                    } else {
    468                        throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
    469                    }
    470                }
    471                // find the minimum length
    472                var l = arguments[i].length;
    473                if (length === null || length > l) {
    474                    length = l;
    475                }
    476            }
    477            rval = [];
    478            for (i = 0; i < length; i++) {
    479                var args = [];
    480                for (var j = 1; j < arguments.length; j++) {
    481                    args.push(arguments[j][i]);
    482                }
    483                rval.push(fn.apply(this, args));
    484            }
    485            return rval;
    486        }
    487    },
    488 
    489    /** @id MochiKit.Base.xfilter */
    490    xfilter: function (fn/*, obj... */) {
    491        var rval = [];
    492        if (fn === null) {
    493            fn = MochiKit.Base.operator.truth;
    494        }
    495        for (var i = 1; i < arguments.length; i++) {
    496            var o = arguments[i];
    497            if (fn(o)) {
    498                rval.push(o);
    499            }
    500        }
    501        return rval;
    502    },
    503 
    504    /** @id MochiKit.Base.filter */
    505    filter: function (fn, lst, self) {
    506        var rval = [];
    507        // allow an iterable to be passed
    508        var m = MochiKit.Base;
    509        if (!m.isArrayLike(lst)) {
    510            if (MochiKit.Iter) {
    511                lst = MochiKit.Iter.list(lst);
    512            } else {
    513                throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
    514            }
    515        }
    516        if (fn === null) {
    517            fn = m.operator.truth;
    518        }
    519        if (typeof(Array.prototype.filter) == 'function') {
    520            // Mozilla fast-path
    521            return Array.prototype.filter.call(lst, fn, self);
    522        } else if (typeof(self) == 'undefined' || self === null) {
    523            for (var i = 0; i < lst.length; i++) {
    524                var o = lst[i];
    525                if (fn(o)) {
    526                    rval.push(o);
    527                }
    528            }
    529        } else {
    530            for (i = 0; i < lst.length; i++) {
    531                o = lst[i];
    532                if (fn.call(self, o)) {
    533                    rval.push(o);
    534                }
    535            }
    536        }
    537        return rval;
    538    },
    539 
    540 
    541    _wrapDumbFunction: function (func) {
    542        return function () {
    543            // fast path!
    544            switch (arguments.length) {
    545                case 0: return func();
    546                case 1: return func(arguments[0]);
    547                case 2: return func(arguments[0], arguments[1]);
    548                case 3: return func(arguments[0], arguments[1], arguments[2]);
    549            }
    550            var args = [];
    551            for (var i = 0; i < arguments.length; i++) {
    552                args.push("arguments[" + i + "]");
    553            }
    554            return eval("(func(" + args.join(",") + "))");
    555        };
    556    },
    557 
    558    /** @id MochiKit.Base.methodcaller */
    559    methodcaller: function (func/*, args... */) {
    560        var args = MochiKit.Base.extend(null, arguments, 1);
    561        if (typeof(func) == "function") {
    562            return function (obj) {
    563                return func.apply(obj, args);
    564            };
    565        } else {
    566            return function (obj) {
    567                return obj[func].apply(obj, args);
    568            };
    569        }
    570    },
    571 
    572    /** @id MochiKit.Base.method */
    573    method: function (self, func) {
    574        var m = MochiKit.Base;
    575        return m.bind.apply(this, m.extend([func, self], arguments, 2));
    576    },
    577 
    578    /** @id MochiKit.Base.compose */
    579    compose: function (f1, f2/*, f3, ... fN */) {
    580        var fnlist = [];
    581        var m = MochiKit.Base;
    582        if (arguments.length === 0) {
    583            throw new TypeError("compose() requires at least one argument");
    584        }
    585        for (var i = 0; i < arguments.length; i++) {
    586            var fn = arguments[i];
    587            if (typeof(fn) != "function") {
    588                throw new TypeError(m.repr(fn) + " is not a function");
    589            }
    590            fnlist.push(fn);
    591        }
    592        return function () {
    593            var args = arguments;
    594            for (var i = fnlist.length - 1; i >= 0; i--) {
    595                args = [fnlist[i].apply(this, args)];
    596            }
    597            return args[0];
    598        };
    599    },
    600 
    601    /** @id MochiKit.Base.bind */
    602    bind: function (func, self/* args... */) {
    603        if (typeof(func) == "string") {
    604            func = self[func];
    605        }
    606        var im_func = func.im_func;
    607        var im_preargs = func.im_preargs;
    608        var im_self = func.im_self;
    609        var m = MochiKit.Base;
    610        if (typeof(func) == "function" && typeof(func.apply) == "undefined") {
    611            // this is for cases where JavaScript sucks ass and gives you a
    612            // really dumb built-in function like alert() that doesn't have
    613            // an apply
    614            func = m._wrapDumbFunction(func);
    615        }
    616        if (typeof(im_func) != 'function') {
    617            im_func = func;
    618        }
    619        if (typeof(self) != 'undefined') {
    620            im_self = self;
    621        }
    622        if (typeof(im_preargs) == 'undefined') {
    623            im_preargs = [];
    624        } else  {
    625            im_preargs = im_preargs.slice();
    626        }
    627        m.extend(im_preargs, arguments, 2);
    628        var newfunc = function () {
    629            var args = arguments;
    630            var me = arguments.callee;
    631            if (me.im_preargs.length > 0) {
    632                args = m.concat(me.im_preargs, args);
    633            }
    634            var self = me.im_self;
    635            if (!self) {
    636                self = this;
    637            }
    638            return me.im_func.apply(self, args);
    639        };
    640        newfunc.im_self = im_self;
    641        newfunc.im_func = im_func;
    642        newfunc.im_preargs = im_preargs;
    643        return newfunc;
    644    },
    645 
    646    /** @id MochiKit.Base.bindMethods */
    647    bindMethods: function (self) {
    648        var bind = MochiKit.Base.bind;
    649        for (var k in self) {
    650            var func = self[k];
    651            if (typeof(func) == 'function') {
    652                self[k] = bind(func, self);
    653            }
    654        }
    655    },
    656 
    657    /** @id MochiKit.Base.registerComparator */
    658    registerComparator: function (name, check, comparator, /* optional */ override) {
    659        MochiKit.Base.comparatorRegistry.register(name, check, comparator, override);
    660    },
    661 
    662    _primitives: {'boolean': true, 'string': true, 'number': true},
    663 
    664    /** @id MochiKit.Base.compare */
    665    compare: function (a, b) {
    666        if (a == b) {
    667            return 0;
    668        }
    669        var aIsNull = (typeof(a) == 'undefined' || a === null);
    670        var bIsNull = (typeof(b) == 'undefined' || b === null);
    671        if (aIsNull && bIsNull) {
    672            return 0;
    673        } else if (aIsNull) {
    674            return -1;
    675        } else if (bIsNull) {
    676            return 1;
    677        }
    678        var m = MochiKit.Base;
    679        // bool, number, string have meaningful comparisons
    680        var prim = m._primitives;
    681        if (!(typeof(a) in prim && typeof(b) in prim)) {
    682            try {
    683                return m.comparatorRegistry.match(a, b);
    684            } catch (e) {
    685                if (e != m.NotFound) {
    686                    throw e;
    687                }
    688            }
    689        }
    690        if (a < b) {
    691            return -1;
    692        } else if (a > b) {
    693            return 1;
    694        }
    695        // These types can't be compared
    696        var repr = m.repr;
    697        throw new TypeError(repr(a) + " and " + repr(b) + " can not be compared");
    698    },
    699 
    700    /** @id MochiKit.Base.compareDateLike */
    701    compareDateLike: function (a, b) {
    702        return MochiKit.Base.compare(a.getTime(), b.getTime());
    703    },
    704 
    705    /** @id MochiKit.Base.compareArrayLike */
    706    compareArrayLike: function (a, b) {
    707        var compare = MochiKit.Base.compare;
    708        var count = a.length;
    709        var rval = 0;
    710        if (count > b.length) {
    711            rval = 1;
    712            count = b.length;
    713        } else if (count < b.length) {
    714            rval = -1;
    715        }
    716        for (var i = 0; i < count; i++) {
    717            var cmp = compare(a[i], b[i]);
    718            if (cmp) {
    719                return cmp;
    720            }
    721        }
    722        return rval;
    723    },
    724 
    725    /** @id MochiKit.Base.registerRepr */
    726    registerRepr: function (name, check, wrap, /* optional */override) {
    727        MochiKit.Base.reprRegistry.register(name, check, wrap, override);
    728    },
    729 
    730    /** @id MochiKit.Base.repr */
    731    repr: function (o) {
    732        if (typeof(o) == "undefined") {
    733            return "undefined";
    734        } else if (o === null) {
    735            return "null";
    736        }
    737        try {
    738            if (typeof(o.__repr__) == 'function') {
    739                return o.__repr__();
    740            } else if (typeof(o.repr) == 'function' && o.repr != arguments.callee) {
    741                return o.repr();
    742            }
    743            return MochiKit.Base.reprRegistry.match(o);
    744        } catch (e) {
    745            if (typeof(o.NAME) == 'string' && (
    746                    o.toString == Function.prototype.toString ||
    747                    o.toString == Object.prototype.toString
    748                )) {
    749                return o.NAME;
    750            }
    751        }
    752        try {
    753            var ostring = (o + "");
    754        } catch (e) {
    755            return "[" + typeof(o) + "]";
    756        }
    757        if (typeof(o) == "function") {
    758            o = ostring.replace(/^\s+/, "");
    759            var idx = o.indexOf("{");
    760            if (idx != -1) {
    761                o = o.substr(0, idx) + "{...}";
    762            }
    763        }
    764        return ostring;
    765    },
    766 
    767    /** @id MochiKit.Base.reprArrayLike */
    768    reprArrayLike: function (o) {
    769        var m = MochiKit.Base;
    770        return "[" + m.map(m.repr, o).join(", ") + "]";
    771    },
    772 
    773    /** @id MochiKit.Base.reprString */
    774    reprString: function (o) {
    775        return ('"' + o.replace(/(["\\])/g, '\\$1') + '"'
    776            ).replace(/[\f]/g, "\\f"
    777            ).replace(/[\b]/g, "\\b"
    778            ).replace(/[\n]/g, "\\n"
    779            ).replace(/[\t]/g, "\\t"
    780            ).replace(/[\r]/g, "\\r");
    781    },
    782 
    783    /** @id MochiKit.Base.reprNumber */
    784    reprNumber: function (o) {
    785        return o + "";
    786    },
    787 
    788    /** @id MochiKit.Base.registerJSON */
    789    registerJSON: function (name, check, wrap, /* optional */override) {
    790        MochiKit.Base.jsonRegistry.register(name, check, wrap, override);
    791    },
    792 
    793 
    794    /** @id MochiKit.Base.evalJSON */
    795    evalJSON: function () {
    796        return eval("(" + MochiKit.Base._filterJSON(arguments[0]) + ")");
    797    },
    798 
    799    _filterJSON: function (s) {
    800        var m = s.match(/^\s*\/\*(.*)\*\/\s*$/);
    801        if (m) {
    802            return m[1];
    803        }
    804        return s;
    805    },
    806 
    807    /** @id MochiKit.Base.serializeJSON */
    808    serializeJSON: function (o) {
    809        var objtype = typeof(o);
    810        if (objtype == "number" || objtype == "boolean") {
    811            return o + "";
    812        } else if (o === null) {
    813            return "null";
    814        }
    815        var m = MochiKit.Base;
    816        var reprString = m.reprString;
    817        if (objtype == "string") {
    818            return reprString(o);
    819        }
    820        // recurse
    821        var me = arguments.callee;
    822        // short-circuit for objects that support "json" serialization
    823        // if they return "self" then just pass-through...
    824        var newObj;
    825        if (typeof(o.__json__) == "function") {
    826            newObj = o.__json__();
    827            if (o !== newObj) {
    828                return me(newObj);
    829            }
    830        }
    831        if (typeof(o.json) == "function") {
    832            newObj = o.json();
    833            if (o !== newObj) {
    834                return me(newObj);
    835            }
    836        }
    837        // array
    838        if (objtype != "function" && typeof(o.length) == "number") {
    839            var res = [];
    840            for (var i = 0; i < o.length; i++) {
    841                var val = me(o[i]);
    842                if (typeof(val) != "string") {
    843                    val = "undefined";
    844                }
    845                res.push(val);
    846            }
    847            return "[" + res.join(", ") + "]";
    848        }
    849        // look in the registry
    850        try {
    851            newObj = m.jsonRegistry.match(o);
    852            if (o !== newObj) {
    853                return me(newObj);
    854            }
    855        } catch (e) {
    856            if (e != m.NotFound) {
    857                // something really bad happened
    858                throw e;
    859            }
    860        }
    861        // undefined is outside of the spec
    862        if (objtype == "undefined") {
    863            throw new TypeError("undefined can not be serialized as JSON");
    864        }
    865        // it's a function with no adapter, bad
    866        if (objtype == "function") {
    867            return null;
    868        }
    869        // generic object code path
    870        res = [];
    871        for (var k in o) {
    872            var useKey;
    873            if (typeof(k) == "number") {
    874                useKey = '"' + k + '"';
    875            } else if (typeof(k) == "string") {
    876                useKey = reprString(k);
    877            } else {
    878                // skip non-string or number keys
    879                continue;
    880            }
    881            val = me(o[k]);
    882            if (typeof(val) != "string") {
    883                // skip non-serializable values
    884                continue;
    885            }
    886            res.push(useKey + ":" + val);
    887        }
    888        return "{" + res.join(", ") + "}";
    889    },
    890 
    891 
    892    /** @id MochiKit.Base.objEqual */
    893    objEqual: function (a, b) {
    894        return (MochiKit.Base.compare(a, b) === 0);
    895    },
    896 
    897    /** @id MochiKit.Base.arrayEqual */
    898    arrayEqual: function (self, arr) {
    899        if (self.length != arr.length) {
    900            return false;
    901        }
    902        return (MochiKit.Base.compare(self, arr) === 0);
    903    },
    904 
    905    /** @id MochiKit.Base.concat */
    906    concat: function (/* lst... */) {
    907        var rval = [];
    908        var extend = MochiKit.Base.extend;
    909        for (var i = 0; i < arguments.length; i++) {
    910            extend(rval, arguments[i]);
    911        }
    912        return rval;
    913    },
    914 
    915    /** @id MochiKit.Base.keyComparator */
    916    keyComparator: function (key/* ... */) {
    917        // fast-path for single key comparisons
    918        var m = MochiKit.Base;
    919        var compare = m.compare;
    920        if (arguments.length == 1) {
    921            return function (a, b) {
    922                return compare(a[key], b[key]);
    923            };
    924        }
    925        var compareKeys = m.extend(null, arguments);
    926        return function (a, b) {
    927            var rval = 0;
    928            // keep comparing until something is inequal or we run out of
    929            // keys to compare
    930            for (var i = 0; (rval === 0) && (i < compareKeys.length); i++) {
    931                var key = compareKeys[i];
    932                rval = compare(a[key], b[key]);
    933            }
    934            return rval;
    935        };
    936    },
    937 
    938    /** @id MochiKit.Base.reverseKeyComparator */
    939    reverseKeyComparator: function (key) {
    940        var comparator = MochiKit.Base.keyComparator.apply(this, arguments);
    941        return function (a, b) {
    942            return comparator(b, a);
    943        };
    944    },
    945 
    946    /** @id MochiKit.Base.partial */
    947    partial: function (func) {
    948        var m = MochiKit.Base;
    949        return m.bind.apply(this, m.extend([func, undefined], arguments, 1));
    950    },
    951 
    952    /** @id MochiKit.Base.listMinMax */
    953    listMinMax: function (which, lst) {
    954        if (lst.length === 0) {
    955            return null;
    956        }
    957        var cur = lst[0];
    958        var compare = MochiKit.Base.compare;
    959        for (var i = 1; i < lst.length; i++) {
    960            var o = lst[i];
    961            if (compare(o, cur) == which) {
    962                cur = o;
    963            }
    964        }
    965        return cur;
    966    },
    967 
    968    /** @id MochiKit.Base.objMax */
    969    objMax: function (/* obj... */) {
    970        return MochiKit.Base.listMinMax(1, arguments);
    971    },
    972 
    973    /** @id MochiKit.Base.objMin */
    974    objMin: function (/* obj... */) {
    975        return MochiKit.Base.listMinMax(-1, arguments);
    976    },
    977 
    978    /** @id MochiKit.Base.findIdentical */
    979    findIdentical: function (lst, value, start/* = 0 */, /* optional */end) {
    980        if (typeof(end) == "undefined" || end === null) {
    981            end = lst.length;
    982        }
    983        if (typeof(start) == "undefined" || start === null) {
    984            start = 0;
    985        }
    986        for (var i = start; i < end; i++) {
    987            if (lst[i] === value) {
    988                return i;
    989            }
    990        }
    991        return -1;
    992    },
    993 
    994    /** @id MochiKit.Base.mean */
    995    mean: function(/* lst... */) {
    996        /* http://www.nist.gov/dads/HTML/mean.html */
    997        var sum = 0;
    998 
    999        var m = MochiKit.Base;
   1000        var args = m.extend(null, arguments);
   1001        var count = args.length;
   1002 
   1003        while (args.length) {
   1004            var o = args.shift();
   1005            if (o && typeof(o) == "object" && typeof(o.length) == "number") {
   1006                count += o.length - 1;
   1007                for (var i = o.length - 1; i >= 0; i--) {
   1008                    sum += o[i];
   1009                }
   1010            } else {
   1011                sum += o;
   1012            }
   1013        }
   1014 
   1015        if (count <= 0) {
   1016            throw new TypeError('mean() requires at least one argument');
   1017        }
   1018 
   1019        return sum/count;
   1020    },
   1021 
   1022    /** @id MochiKit.Base.median */
   1023    median: function(/* lst... */) {
   1024        /* http://www.nist.gov/dads/HTML/median.html */
   1025        var data = MochiKit.Base.flattenArguments(arguments);
   1026        if (data.length === 0) {
   1027            throw new TypeError('median() requires at least one argument');
   1028        }
   1029        data.sort(compare);
   1030        if (data.length % 2 == 0) {
   1031            var upper = data.length / 2;
   1032            return (data[upper] + data[upper - 1]) / 2;
   1033        } else {
   1034            return data[(data.length - 1) / 2];
   1035        }
   1036    },
   1037 
   1038    /** @id MochiKit.Base.findValue */
   1039    findValue: function (lst, value, start/* = 0 */, /* optional */end) {
   1040        if (typeof(end) == "undefined" || end === null) {
   1041            end = lst.length;
   1042        }
   1043        if (typeof(start) == "undefined" || start === null) {
   1044            start = 0;
   1045        }
   1046        var cmp = MochiKit.Base.compare;
   1047        for (var i = start; i < end; i++) {
   1048            if (cmp(lst[i], value) === 0) {
   1049                return i;
   1050            }
   1051        }
   1052        return -1;
   1053    },
   1054 
   1055    /** @id MochiKit.Base.nodeWalk */
   1056    nodeWalk: function (node, visitor) {
   1057        var nodes = [node];
   1058        var extend = MochiKit.Base.extend;
   1059        while (nodes.length) {
   1060            var res = visitor(nodes.shift());
   1061            if (res) {
   1062                extend(nodes, res);
   1063            }
   1064        }
   1065    },
   1066 
   1067 
   1068    /** @id MochiKit.Base.nameFunctions */
   1069    nameFunctions: function (namespace) {
   1070        var base = namespace.NAME;
   1071        if (typeof(base) == 'undefined') {
   1072            base = '';
   1073        } else {
   1074            base = base + '.';
   1075        }
   1076        for (var name in namespace) {
   1077            var o = namespace[name];
   1078            if (typeof(o) == 'function' && typeof(o.NAME) == 'undefined') {
   1079                try {
   1080                    o.NAME = base + name;
   1081                } catch (e) {
   1082                    // pass
   1083                }
   1084            }
   1085        }
   1086    },
   1087 
   1088 
   1089    /** @id MochiKit.Base.queryString */
   1090    queryString: function (names, values) {
   1091        // check to see if names is a string or a DOM element, and if
   1092        // MochiKit.DOM is available.  If so, drop it like it's a form
   1093        // Ugliest conditional in MochiKit?  Probably!
   1094        if (typeof(MochiKit.DOM) != "undefined" && arguments.length == 1
   1095            && (typeof(names) == "string" || (
   1096                typeof(names.nodeType) != "undefined" && names.nodeType > 0
   1097            ))
   1098        ) {
   1099            var kv = MochiKit.DOM.formContents(names);
   1100            names = kv[0];
   1101            values = kv[1];
   1102        } else if (arguments.length == 1) {
   1103            // Allow the return value of formContents to be passed directly
   1104            if (typeof(names.length) == "number" && names.length == 2) {
   1105                return arguments.callee(names[0], names[1]);
   1106            }
   1107            var o = names;
   1108            names = [];
   1109            values = [];
   1110            for (var k in o) {
   1111                var v = o[k];
   1112                if (typeof(v) == "function") {
   1113                    continue;
   1114                } else if (typeof(v) != "string" &&
   1115                        typeof(v.length) == "number") {
   1116                    for (var i = 0; i < v.length; i++) {
   1117                        names.push(k);
   1118                        values.push(v[i]);
   1119                    }
   1120                } else {
   1121                    names.push(k);
   1122                    values.push(v);
   1123                }
   1124            }
   1125        }
   1126        var rval = [];
   1127        var len = Math.min(names.length, values.length);
   1128        var urlEncode = MochiKit.Base.urlEncode;
   1129        for (var i = 0; i < len; i++) {
   1130            v = values[i];
   1131            if (typeof(v) != 'undefined' && v !== null) {
   1132                rval.push(urlEncode(names[i]) + "=" + urlEncode(v));
   1133            }
   1134        }
   1135        return rval.join("&");
   1136    },
   1137 
   1138 
   1139    /** @id MochiKit.Base.parseQueryString */
   1140    parseQueryString: function (encodedString, useArrays) {
   1141        // strip a leading '?' from the encoded string
   1142        var qstr = (encodedString.charAt(0) == "?")
   1143            ? encodedString.substring(1)
   1144            : encodedString;
   1145        var pairs = qstr.replace(/\+/g, "%20").split(/(\&amp\;|\&\#38\;|\&#x26;|\&)/);
   1146        var o = {};
   1147        var decode;
   1148        if (typeof(decodeURIComponent) != "undefined") {
   1149            decode = decodeURIComponent;
   1150        } else {
   1151            decode = unescape;
   1152        }
   1153        if (useArrays) {
   1154            for (var i = 0; i < pairs.length; i++) {
   1155                var pair = pairs[i].split("=");
   1156                var name = decode(pair.shift());
   1157                if (!name) {
   1158                    continue;
   1159                }
   1160                var arr = o[name];
   1161                if (!(arr instanceof Array)) {
   1162                    arr = [];
   1163                    o[name] = arr;
   1164                }
   1165                arr.push(decode(pair.join("=")));
   1166            }
   1167        } else {
   1168            for (i = 0; i < pairs.length; i++) {
   1169                pair = pairs[i].split("=");
   1170                var name = pair.shift();
   1171                if (!name) {
   1172                    continue;
   1173                }
   1174                o[decode(name)] = decode(pair.join("="));
   1175            }
   1176        }
   1177        return o;
   1178    }
   1179 });
   1180 
   1181 /** @id MochiKit.Base.AdapterRegistry */
   1182 MochiKit.Base.AdapterRegistry = function () {
   1183    this.pairs = [];
   1184 };
   1185 
   1186 MochiKit.Base.AdapterRegistry.prototype = {
   1187    /** @id MochiKit.Base.AdapterRegistry.prototype.register */
   1188    register: function (name, check, wrap, /* optional */ override) {
   1189        if (override) {
   1190            this.pairs.unshift([name, check, wrap]);
   1191        } else {
   1192            this.pairs.push([name, check, wrap]);
   1193        }
   1194    },
   1195 
   1196    /** @id MochiKit.Base.AdapterRegistry.prototype.match */
   1197    match: function (/* ... */) {
   1198        for (var i = 0; i < this.pairs.length; i++) {
   1199            var pair = this.pairs[i];
   1200            if (pair[1].apply(this, arguments)) {
   1201                return pair[2].apply(this, arguments);
   1202            }
   1203        }
   1204        throw MochiKit.Base.NotFound;
   1205    },
   1206 
   1207    /** @id MochiKit.Base.AdapterRegistry.prototype.unregister */
   1208    unregister: function (name) {
   1209        for (var i = 0; i < this.pairs.length; i++) {
   1210            var pair = this.pairs[i];
   1211            if (pair[0] == name) {
   1212                this.pairs.splice(i, 1);
   1213                return true;
   1214            }
   1215        }
   1216        return false;
   1217    }
   1218 };
   1219 
   1220 
   1221 MochiKit.Base.EXPORT = [
   1222    "flattenArray",
   1223    "noop",
   1224    "camelize",
   1225    "counter",
   1226    "clone",
   1227    "extend",
   1228    "update",
   1229    "updatetree",
   1230    "setdefault",
   1231    "keys",
   1232    "values",
   1233    "items",
   1234    "NamedError",
   1235    "operator",
   1236    "forwardCall",
   1237    "itemgetter",
   1238    "typeMatcher",
   1239    "isCallable",
   1240    "isUndefined",
   1241    "isUndefinedOrNull",
   1242    "isNull",
   1243    "isEmpty",
   1244    "isNotEmpty",
   1245    "isArrayLike",
   1246    "isDateLike",
   1247    "xmap",
   1248    "map",
   1249    "xfilter",
   1250    "filter",
   1251    "methodcaller",
   1252    "compose",
   1253    "bind",
   1254    "bindMethods",
   1255    "NotFound",
   1256    "AdapterRegistry",
   1257    "registerComparator",
   1258    "compare",
   1259    "registerRepr",
   1260    "repr",
   1261    "objEqual",
   1262    "arrayEqual",
   1263    "concat",
   1264    "keyComparator",
   1265    "reverseKeyComparator",
   1266    "partial",
   1267    "merge",
   1268    "listMinMax",
   1269    "listMax",
   1270    "listMin",
   1271    "objMax",
   1272    "objMin",
   1273    "nodeWalk",
   1274    "zip",
   1275    "urlEncode",
   1276    "queryString",
   1277    "serializeJSON",
   1278    "registerJSON",
   1279    "evalJSON",
   1280    "parseQueryString",
   1281    "findValue",
   1282    "findIdentical",
   1283    "flattenArguments",
   1284    "method",
   1285    "average",
   1286    "mean",
   1287    "median"
   1288 ];
   1289 
   1290 MochiKit.Base.EXPORT_OK = [
   1291    "nameFunctions",
   1292    "comparatorRegistry",
   1293    "reprRegistry",
   1294    "jsonRegistry",
   1295    "compareDateLike",
   1296    "compareArrayLike",
   1297    "reprArrayLike",
   1298    "reprString",
   1299    "reprNumber"
   1300 ];
   1301 
   1302 MochiKit.Base._exportSymbols = function (globals, module) {
   1303    if (!MochiKit.__export__) {
   1304        return;
   1305    }
   1306    var all = module.EXPORT_TAGS[":all"];
   1307    for (var i = 0; i < all.length; i++) {
   1308        globals[all[i]] = module[all[i]];
   1309    }
   1310 };
   1311 
   1312 MochiKit.Base.__new__ = function () {
   1313    // A singleton raised when no suitable adapter is found
   1314    var m = this;
   1315 
   1316    // convenience
   1317    /** @id MochiKit.Base.noop */
   1318    m.noop = m.operator.identity;
   1319 
   1320    // Backwards compat
   1321    m.forward = m.forwardCall;
   1322    m.find = m.findValue;
   1323 
   1324    if (typeof(encodeURIComponent) != "undefined") {
   1325        /** @id MochiKit.Base.urlEncode */
   1326        m.urlEncode = function (unencoded) {
   1327            return encodeURIComponent(unencoded).replace(/\'/g, '%27');
   1328        };
   1329    } else {
   1330        m.urlEncode = function (unencoded) {
   1331            return escape(unencoded
   1332                ).replace(/\+/g, '%2B'
   1333                ).replace(/\"/g,'%22'
   1334                ).rval.replace(/\'/g, '%27');
   1335        };
   1336    }
   1337 
   1338    /** @id MochiKit.Base.NamedError */
   1339    m.NamedError = function (name) {
   1340        this.message = name;
   1341        this.name = name;
   1342    };
   1343    m.NamedError.prototype = new Error();
   1344    m.update(m.NamedError.prototype, {
   1345        repr: function () {
   1346            if (this.message && this.message != this.name) {
   1347                return this.name + "(" + m.repr(this.message) + ")";
   1348            } else {
   1349                return this.name + "()";
   1350            }
   1351        },
   1352        toString: m.forwardCall("repr")
   1353    });
   1354 
   1355    /** @id MochiKit.Base.NotFound */
   1356    m.NotFound = new m.NamedError("MochiKit.Base.NotFound");
   1357 
   1358 
   1359    /** @id MochiKit.Base.listMax */
   1360    m.listMax = m.partial(m.listMinMax, 1);
   1361    /** @id MochiKit.Base.listMin */
   1362    m.listMin = m.partial(m.listMinMax, -1);
   1363 
   1364    /** @id MochiKit.Base.isCallable */
   1365    m.isCallable = m.typeMatcher('function');
   1366    /** @id MochiKit.Base.isUndefined */
   1367    m.isUndefined = m.typeMatcher('undefined');
   1368 
   1369    /** @id MochiKit.Base.merge */
   1370    m.merge = m.partial(m.update, null);
   1371    /** @id MochiKit.Base.zip */
   1372    m.zip = m.partial(m.map, null);
   1373 
   1374    /** @id MochiKit.Base.average */
   1375    m.average = m.mean;
   1376 
   1377    /** @id MochiKit.Base.comparatorRegistry */
   1378    m.comparatorRegistry = new m.AdapterRegistry();
   1379    m.registerComparator("dateLike", m.isDateLike, m.compareDateLike);
   1380    m.registerComparator("arrayLike", m.isArrayLike, m.compareArrayLike);
   1381 
   1382    /** @id MochiKit.Base.reprRegistry */
   1383    m.reprRegistry = new m.AdapterRegistry();
   1384    m.registerRepr("arrayLike", m.isArrayLike, m.reprArrayLike);
   1385    m.registerRepr("string", m.typeMatcher("string"), m.reprString);
   1386    m.registerRepr("numbers", m.typeMatcher("number", "boolean"), m.reprNumber);
   1387 
   1388    /** @id MochiKit.Base.jsonRegistry */
   1389    m.jsonRegistry = new m.AdapterRegistry();
   1390 
   1391    var all = m.concat(m.EXPORT, m.EXPORT_OK);
   1392    m.EXPORT_TAGS = {
   1393        ":common": m.concat(m.EXPORT_OK),
   1394        ":all": all
   1395    };
   1396 
   1397    m.nameFunctions(this);
   1398 
   1399 };
   1400 
   1401 MochiKit.Base.__new__();
   1402 
   1403 //
   1404 // XXX: Internet Explorer blows
   1405 //
   1406 if (MochiKit.__export__) {
   1407    compare = MochiKit.Base.compare;
   1408    compose = MochiKit.Base.compose;
   1409    serializeJSON = MochiKit.Base.serializeJSON;
   1410 }
   1411 
   1412 MochiKit.Base._exportSymbols(this, MochiKit.Base);
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE