// vim: et:ts=4:sw=4:sts=4:ft=js

// OxJS (c) 2011 Ox2620, dual-licensed GPL/MIT, see http://oxjs.org for details

/*
Some conventions:
    Functions
        - only one var statement, in the first line of the function
        - return only once, from the last line of the function body
    Variable names
        arg         argument
        args        arguments
        arr         array
        callback    callback function
        col         collection (array, string or object)
        date        date
        fn          function
        hasFoo      boolean
        i           index (integer key)
        isFoo       boolean
        k           key (of a key/value pair)
        key         key (of a key/value pair)
        max         maximum value
        min         minumum value
        num         number
        obj         object
        re          regexp
        ret         return value
        v           value (of a key/value pair)
        val         value (of a key/value pair)
*/

// todo: check http://ejohn.org/blog/ecmascript-5-strict-mode-json-and-more/
// also see https://github.com/tlrobinson/narwhal/blob/master/lib/util.js

//@ Core -----------------------------------------------------------------------

/*@
Ox <f> The <code>Ox</code> object
    See <code>Ox.wrap</code> for details.
    (value) -> <o> wrapped value
    value <*> Any value
@*/

Ox = function(val) {
    return Ox.wrap(val);
};

/*@
Ox.load <f> Loads a module
    (module, callback)          -> <u> undefined
    (module, options, callback) -> <u> undefined
    module   <s> Module name
    options  <o> Module options
    callback <f> Callback function
        success <b> If true, the module has been loaded successfully
@*/

Ox.load = function(module, options, callback) {
    // fixme: no way to load multiple modules
    // problem: where do multiple options go?
    // [{name: "", options: {}}, {name: "", options: {}}] isn't pretty
    callback = arguments[arguments.length - 1];
    options = arguments.length == 3 ? arguments[1] : {};
    Ox.loadFile(Ox.PATH + 'Ox.' + module + '/Ox.' + module + '.js', function() {
        Ox.load[module](options, callback);
    });
};

/*@
Ox.print <f> Prints its arguments to the console
    (arg, ...) -> <s> String
        The string contains the timestamp, the name of the caller function, and
        any arguments, separated by spaces
    arg <*> any value
    > Ox.print('foo').split(' ').pop()
    "foo"
@*/

Ox.print = function() {
    var args = Ox.makeArray(arguments),
        date = new Date();
    args.unshift(
        Ox.formatDate(date, '%H:%M:%S.') + (+date).toString().substr(-3),
        (arguments.callee.caller && arguments.callee.caller.name) ||
        '(anonymous)'
    );
    window.console && window.console.log.apply(window.console, args);
    return args.join(' ');
};

/*@
Ox.uid <f> Returns a unique id
    () -> <n> Unique id
    > Ox.uid() != Ox.uid()
    true
@*/
Ox.uid = (function() {
    var uid = 0;
    return function() {
        return uid++;
    };
}());

/*@
Ox.wrap <f> Wraps a value so that one can directly call any Ox function on it
    (value) -> <o> wrapped value
        chain <f> wrap the return value to allow chaining
        value <f> unwrap the value wrapped by <code>chain()</chain>
    value <*> Any value
    > Ox.wrap("foobar").repeat(2)
    "foobarfoobar"
    > Ox.wrap("foobar").chain().reverse().toTitleCase().value()
    "Raboof"
    > Ox.wrap("foobar").value()
    "foobar"
@*/

Ox.wrap = function(val, chained) {
    // somewhat inspired by underscore.js
    var wrapper = {
        chain: function() {
            wrapper.chained = true;
            return wrapper;
        },
        chained: chained || false,
        value: function() {
            return val;
        }
    };
    Object.getOwnPropertyNames(Ox).forEach(function(name) {
        if (name[0] == name[0].toLowerCase() && Ox.isFunction(Ox[name])) {
            wrapper[name] = function() {
                var args = Array.prototype.slice.call(arguments), ret;
                args.unshift(val);
                ret = Ox[name].apply(Ox, args);
                return wrapper.chained ? Ox.wrap(ret, true) : ret;
            };
        }
    });
    return wrapper;
};

//@ Array ----------------------------------------------------------------------

/*@
Ox.compact <f> Returns an array w/o <code>null</code> or <code>undefined</code>
    > Ox.compact([null,,1,,2,,3])
    [1, 2, 3]
@*/

Ox.compact = function(arr) {
    /***
    returns an array without null or undefined values
    ***/
    return Ox.map(arr, function(val) {
        return Ox.isUndefined(val) ? null : val;
    });
};

/*@
    Ox.flatten <f> Flattens an array
    > Ox.flatten([1, [2, [3], 2], 1])
    [1, 2, 3, 2, 1]
@*/
Ox.flatten = function(arr) {
    // fixme: can this work for objects too?
    var ret = [];
    arr.forEach(function(v) {
        if (Ox.isArray(v)) {
            Ox.flatten(v).forEach(function(v) {
                ret.push(v);
            });
        } else {
            ret.push(v);
        }
    });
    return ret;
};

/*@ 
Ox.merge <f> Merges an array with one or more other arrays
    > Ox.merge([1], [2, 3, 2], [1])
    [1, 2, 3, 2, 1]
@*/
Ox.merge = function(arr) {
    Ox.forEach(Array.prototype.slice.call(arguments, 1), function(arg) {
        Ox.forEach(arg, function(val) {
            arr.push(val);
        });
    });
    return arr;
};

/*@
Ox.sort <f> Sorts an array, handling leading digits and ignoring capitalization
    > Ox.sort(['10', '9', 'B', 'a'])
    ['9', '10', 'a', 'B']
@*/
Ox.sort = function(arr) {
    var len, matches = {}, sort = {};
    // find leading numbers
    arr.forEach(function(val, i) {
        var match = /^\d+/(val);
        matches[val] = match ? match[0] : '';
    });
    // get length of longest leading number
    len = Ox.max(Ox.map(matches, function(val) {
        return val.length;
    }));
    // pad leading numbers, and make lower case
    arr.forEach(function(val) {
        sort[val] = (
            matches[val] ?
            Ox.pad(matches[val], len) + val.toString().substr(matches[val].length) :
            val
        ).toLowerCase();
    });
    return arr.sort(function(a, b) {
        var ret = 0;
        if (sort[a] < sort[b]) {
            ret = -1;
        } else if (sort[a] > sort[b]) {
            ret = 1;
        }
        return ret;
    });
};

/*@
Ox.unique <f> Returns an array without duplicate values
    > Ox.unique([1, 2, 3, 2, 1])
    [1, 2, 3]
@*/

Ox.unique = function(arr) {
    var unique = [];
    Ox.forEach(arr, function(val) {
        unique.indexOf(val) == -1 && unique.push(val);
    });
    return unique;
};

/*@
Ox.zip <f> Zips an array of arrays
    > Ox.zip([[0, 1], [2, 3], [4, 5]])
    [[0, 2, 4], [1, 3, 5]]
    > Ox.zip([0, 1, 2], [3, 4, 5])
    [[0, 3], [1, 4], [2, 5]]
@*/
Ox.zip = function() {
    var args = arguments.length == 1 ? arguments[0] : Ox.makeArray(arguments),
        arr = [];
    args[0].forEach(function(v, i) {
        arr[i] = [];
        args.forEach(function(v_, i_) {
            arr[i].push(v_[i]);
        });
    });
    return arr;
};

//@ Collections ----------------------------------------------------------------

/*@
Ox.avg <f> Returns the average of an array's values, or an object's properties
    (collection) -> <n> Average value
    collection <[n]|o> Array or object with numerical values
    > Ox.avg([-1, 0, 1])
    0
    > Ox.avg({a: 1, b: 2, c: 3})
    2
@*/

Ox.avg = function(obj) {
    return Ox.sum(obj) / Ox.len(obj);
};

/*@
Ox.clone <f> Returns a (shallow) copy or an object or array
    > (function() { a = ['val']; b = Ox.clone(a); a[0] = null; return b[0]; }())
    'val'
    > (function() { a = {key: 'val'}; b = Ox.clone(a); a.key = null; return b.key; }())
    'val'
@*/

Ox.clone = function(obj) {
    return Ox.isArray(obj) ? obj.slice() : Ox.extend({}, obj);
};

/*@
Ox.contains <f> Tests if a collection contains a value
    > Ox.contains(['foo', 'bar'], 'foo')
    true
    > Ox.contains({foo: 'bar'}, 'bar')
    true
    > Ox.contains({foo: 'bar'}, 'foo')
    false
    > Ox.contains("foobar", "bar")
    true
@*/ 
Ox.contains = function(col, val) {
    /*
    // fixme: rename to Ox.has or Ox.isIn?
    // then it'd become convenient for arrays
    */
    return (Ox.isObject(col) ? Ox.values(col) : col).indexOf(val) > -1;
};

/*@
Ox.count <f> Counts the occurences of values in a collection
    > Ox.count(['f', 'o', 'o'])
    {f: 1, o: 2}
    > Ox.count({a: 'f', b: 'o', c: 'o'})
    {f: 1, o: 2}
    > Ox.count('foo')
    {f: 1, o: 2}
@*/
Ox.count = function(arr) {
    var obj = {};
    Ox.forEach(arr, function(v) {
        obj[v] = (obj[v] || 0) + 1;
    });
    return obj;
};

//@ Ox.each <f> (deprecated)
Ox.each = function(obj, fn) {
    // fixme: deprecate!
    /*
    Ox.each() works for arrays, objects and strings,
    like $.each(), unlike [].forEach()
    >>> Ox.each([0, 1, 2], function(i, v) {})
    [0, 1, 2]
    >>> Ox.each({a: 1, b: 2, c: 3}, function(k, v) {}).a
    1
    >>> Ox.each('foo', function(i, v) {})
    'foo'
    */
    var i, isArray = Ox.isArray(obj);
    for (i in obj) {
        i = isArray ? parseInt(i) : i;
        // fixme: should be (v, k), like [].forEach()
        if (fn(i, obj[i]) === false) {
            break;
        }
    }
    return obj;
};

/*@
Ox.every <f> Tests if every element of a collection satisfies a given condition
    Unlike <code>[].every()</code>, <code>Ox.every()</code> works for arrays,
    objects and strings.
    > Ox.every([0, 1, 2], function(v, i) { return i == v; })
    true
    > Ox.every({a: 1, b: 2, c: 3}, function(v) { return v == 1; })
    false
    > Ox.every("foo", function(v) { return v == 'f'; })
    false
    > Ox.every([true, true, true])
    true
@*/
Ox.every = function(obj, fn) {
    return Ox.filter(Ox.values(obj), fn || function(v) {
        return v;
    }).length == Ox.len(obj);
};

/*@
Ox.filter <f> Filters a collection by a given condition
    Unlike <code>[].filter()</code>, <code>Ox.filter()</code> works for arrays,
    objects and strings.
    > Ox.filter([2, 1, 0], function(v, i) { return v == i; })
    [1]
    > Ox.keys(Ox.filter({a: 'c', b: 'b', c: 'a'}, function(v, k) { return v == k; }))
    ['b']
    > Ox.filter(' foo bar ', function(v) { return v != ' '; })
    'foobar'
@*/

Ox.filter = function(obj, fn) {
    var type = Ox.typeOf(obj),
        ret = type == 'array' ? [] : type == 'object' ? {} : '';
    Ox.forEach(obj, function(v, k) {
        if (fn(v, k)) {
            if (type == 'array') {
                ret.push(v);
            } else if (type == 'object') {
                ret[k] = v;
            } else {
                ret += v;
            }
        }
    });
    return ret;
};

/*@
Ox.find <f> Returns array elements that match a string
    Returns an array of two arrays, the first containing leading matches
    (exact match first), the second containing non-leading matches
    > Ox.find(['foo', 'bar', 'foobar', 'barfoo'], 'foo')
    [['foo', 'foobar'], ['barfoo']]
@*/
Ox.find = function(arr, str) {
    var ret = [[], []];
    str = str.toLowerCase();
    arr.map(function(v) {
        return v.toLowerCase();
    }).forEach(function(v, i) {
        var index = v.indexOf(str);
        index > -1 && ret[index == 0 ? 0 : 1][v == str ? 'unshift' : 'push'](arr[i]);
    });
    return ret;
};

/*@
Ox.forEach <f> forEach loop
    <code>Ox.forEach()</code> loops over arrays, objects and strings.
    Returning <code>false</code> from the iterator function acts like a
    <code>break</code> statement (unlike <code>[].forEach()</code>, like
    <code>$.each()</code>). The arguments of the iterator function are
    <code>(value, key)</code> (like <code>[].forEach()</code>, unlike
    <code>$.each()</code>).
    (collection, callback) <a|o|s> The collection
    collection <a|o|s> An array, object or string
    callback <f> Callback function
        value <*> Value
        key <n|s> Key
    <script>
        Ox.test.string = "";
        Ox.forEach(["f", "o", "o"], function(v, i) { Ox.test.string += i; });
        Ox.forEach({a: "f", b: "o", c: "o"}, function(v, k) { Ox.test.string += k; });
        Ox.forEach("foo", function(v) { Ox.test.string += v; });
    </script>
    > Ox.test.string
    "012abcfoo"
@*/
Ox.forEach = function(obj, fn) {
    var isObject = Ox.isObject(obj), key;
    if (Ox.isArguments(obj)) {
        // Safari will not loop through an arguments array
        obj = Ox.makeArray(obj);
    }
    for (key in obj) {
        key = isObject ? key : parseInt(key);
        if (/*hasOwnProperty.call(obj, key) && */fn(obj[key], key) === false) {
            break;
        }
    }
    return obj;
};

/*@
Ox.getObjectById <f> Returns an array element with a given id
    > Ox.getObjectById([{id: "foo", title: "Foo"}, {id: "bar", title: "Bar"}], "foo")
    {id: "foo", title: "Foo"}
@*/
// fixme: shouldn't this be getElementById() ?
Ox.getObjectById = function(arr, id) {
    var ret = null;
    Ox.forEach(arr, function(v) {
        if (v.id == id) {
            ret = v;
            return false;
        }
    });
    return ret;
};

/*@
Ox.getPositionById <f> Returns the index of an array element with a given id
    > Ox.getPositionById([{id: "foo", title: "Foo"}, {id: "bar", title: "Bar"}], "foo")
    0
@*/
// fixme: shouldn't this be getIndexById() ?
Ox.getPositionById = function(arr, id) {
    var ret = -1;
    Ox.forEach(arr, function(v, i) {
        if (v.id == id) {
            ret = i;
            return false;
        }
    });
    return ret;
};

// fixme: and what about getElementBy() and getIndexBy() ?

/*@
Ox.getset <f> Generic getter and setter function
    See examples for details.
    # Usage --------------------------------------------------------------------
    Ox.getset(options, args=[])                              -> <o> all options
    Ox.getset(options, args=[key])                           -> <*> options[key]
    Ox.getset(options, args=[key, value], callback, context) -> <f|o> context
        sets options[key] to value and calls fn(key, value)
        if the key/value pair was added or modified
    Ox.getset(options, args=[{key: value}], callback, context) -> <f|o> context
        sets multiple options and calls fn(key, value)
        for every key/value pair that was added or modified
    # Arguments ----------------------------------------------------------------
    options  <obj> Options object (key/value pairs)
    args     <arr> The arguments "array" of the caller function
    callback <fun> Callback function 
        The callback is called for every key/value pair that was added or
        modified.
        key      <s> Key
        value    <*> Value
    context  <obj> The parent object of the caller function (for chaining)
    # Examples -----------------------------------------------------------------
    <script>
        Ox.test.object = new function() {
            var options = {},
                setOption = function(key, value) {},
                that = this;
            that.options = function() {
                return Ox.getset(options, arguments, setOption, that);
            };
            return that;
        };
    </script>
    > Ox.test.object.options("key", "val").options("key")
    "val"
    > Ox.test.object.options({foo: "foo", bar: "bar"}).options()
    {"key": "val", "foo": "foo", "bar": "bar"}
@*/

Ox.getset = function(obj, args, callback, context) {
    var obj_ = Ox.clone(obj), ret;
    if (args.length == 0) {
        // getset([])
        ret = obj;
    } else if (args.length == 1 && !Ox.isObject(args[0])) {
        // getset([key])
        ret = obj[args[0]];
    } else {
        // getset([key, val]) or getset([{key: val, ...}])
        args = Ox.makeObject(args);
        obj = Ox.extend(obj, args);
        Ox.forEach(args, function(val, key) {
            if (!obj_ || !Ox.isEqual(obj_[key], val)) {
                callback && callback(key, val);
            }
        });
        ret = context;                            
    }
    return ret;
}

/*@
Ox.isEmpty <f> Returns true if a collection is empty
    > Ox.isEmpty([])
    true
    > Ox.isEmpty({})
    true
    > Ox.isEmpty('')
    true
    > Ox.isEmpty(function() {})
    true
@*/
Ox.isEmpty = function(val) {
    return Ox.len(val) == 0;
};

/*@
Ox.keys <f> Returns the keys of a collection
    Unlike <code>Object.keys()</code>, <code>Ox.keys()</code> works for arrays,
    objects and strings.
    > Ox.keys([1, 2, 3])
    [0, 1, 2]
    > Ox.keys([1,,3])
    [0, 2]
    > Ox.keys([,])
    [0]
    > Ox.keys({a: 1, b: 2, c: 3})
    ['a', 'b', 'c']
    > Ox.keys('abc')
    [0, 1, 2]
@*/

// fixme: is this really needed? arrays... ok... but strings??
Ox.keys = function(obj) {
    var keys = [];
    Ox.forEach(obj, function(v, k) {
        keys.push(k);
    });
    return keys.sort();
};

/*@
Ox.last <f> Gets or sets the last element of an array
    Unlike <code>foobarbaz[foobarbaz.length - 1]</code>,
    <code>Ox.last(foobarbaz)</code> is short.
    <script>
        Ox.test.array = [1, 2, 3];
    </script>
    > Ox.last(Ox.test.array)
    3
    > Ox.last(Ox.test.array, 4)
    [1, 2, 4]
    > Ox.test.array
    [1, 2, 4]
@*/
Ox.last = function(arr, val) {
    var ret;
    if (arguments.length == 1) {
        ret = arr[arr.length - 1];
    } else {
        arr[arr.length - 1] = val;
        ret = arr;
    }
    return ret;
};

/*@
Ox.len <f> Returns the length of an array, function, object or string
    Not to be confused with <code>Ox.length</code>, which is the
    <code>length</code> property of the <code>Ox</code> function
    (<code>1</code).
    > Ox.len([1, 2, 3])
    3
    > Ox.len([,])
    1
    > Ox.len({a: 1, b: 2, c: 3})
    3
    > Ox.len(function(x, y, z) { return x + y + z; })
    3
    > Ox.len('abc')
    3
@*/
Ox.len = function(obj) {
    return Ox.isObject(obj) ? Ox.values(obj).length : obj.length;
};

/*@
Ox.loop <f> For-loop, functional-style
    Returning <code>false</code> from the iterator function acts like a
    <code>break</code> statement. Unlike a <code>for</code> loop,
    <code>Ox.loop</code> doesn't leak its counter variable to the outer scope,
    but returns it.
    (stop, callback) -> <n> Next value
        equivalent to <code>for (var i = 0; i < stop; i++)</code>
    (start, stop, callback) -> <n> Next value
        equivalent to <code>for (var i = start; i < stop; i++)</code> or,
        if <code>start</code> is larger than <code>stop</code>,
        <code>for (var i = start; i > stop; i--)</code>
    (start, stop, step, callback) -> <n> Next value
        equivalent to <code>for (var i = start; i < stop; i += step)</code> or,
        if <code>step</code> is negative,
        <code>for (var i = start; i > stop; i += step)</code>
    start <n> Start value
    stop <n> Stop value (exclusive)
    step <n> Step value
    callback <f> Iterator function
        i <n> Counter value
    > Ox.loop(0, 3, 2, function() {})
    4
    > Ox.loop(10, function(i) { return i != 4; })
    4
@*/
Ox.loop = function() {
    var length = arguments.length,
        start = length > 2 ? arguments[0] : 0,
        stop = arguments[length > 2 ? 1 : 0],
        step = length == 4 ? arguments[2] : (start <= stop ? 1 : -1),
        callback = arguments[length - 1],
        i;
    for (i = start; step > 0 ? i < stop : i > stop; i += step) {
        if (callback(i) === false) {
            break;
        };
    }
    return i;
};

/*@
Ox.makeArray <f> Takes an array-like object and returns a true array
    Alias for <code>Array.prototype.slice.call</code>
    (value) -> <a> True array
    value <*> Array-like object
    > (function() { return Ox.makeArray(arguments); }("foo", "bar"))
    ["foo", "bar"]
    > Ox.makeArray("foo")
    ["f", "o", "o"]
    > Ox.makeArray({0: "f", 1: "o", 2: "o", length: 3})
    ["f", "o", "o"]
@*/

Ox.makeArray = function(obj) {
    return Array.prototype.slice.call(obj);
}

/*@
Ox.makeObject <f> Takes an array and returns an object
    <code>Ox.makeObject</code> is a helper for functions with two alternative
    signatures like <code>('key', 'val')</code> and <code>({key: 'val'})</code>.
    > (function() { return Ox.makeObject(arguments); }({foo: 1, bar: 2}))
    {foo: 1, bar: 2}
    > (function() { return Ox.makeObject(arguments); }('foo', 1))
    {foo: 1}
    > (function() { return Ox.makeObject(arguments); }('foo'))
    {}
    > (function() { return Ox.makeObject(arguments); }())
    {}
@*/
Ox.makeObject = function(obj) {
    var ret = {};
    if (Ox.isObject(obj[0])) {
        // ({foo: 'bar'})
        ret = obj[0];
    } else if (obj.length) {
        // ('foo', 'bar')
        ret[obj[0]] = obj[1]
    }
    return ret;
};

/*@
Ox.map <f> Transforms the values of an array, object or string
    Unlike <code>[].map()</code>, <code>Ox.map()</code> works for arrays,
    objects and strings. Returning <code>null</code> from the iterator
    function will remove the element from the collection.
    > Ox.map([0, 0, 0], function(v, i) { return v == i; })
    [true, false, false]
    > Ox.map({a: 'a', b: 'a', c: 'a'}, function(v, k) { return v == k; })
    {a: true, b: false, c: false}
    > Ox.map("000", function(v, i) { return v == i; })
    [true, false, false]
    > Ox.map([0, 1, 2, 4], function(v, i) { return v ? i == v : null; })
    [true, true, false]
    > Ox.map([,], function(v, i) { return i; })
    [0]
@*/

Ox.map = function(obj, fn) {
    // fixme: return null to filter out is a bit esoteric
    var isObject = Ox.isObject(obj),
        ret = isObject ? {} : [];
    Ox.forEach(obj, function(val, key) {
        if ((v = fn(val, key)) !== null) {
            ret[isObject ? key : ret.length] = v;
        }
    });
    return ret;
};

/*@
Ox.max <f> Returns the maximum value of a collection
    > Ox.max([1, 2, 3])
    3
    > Ox.max({a: 1, b: 2, c: 3})
    3
    > Ox.max('123')
    3
@*/
Ox.max = function(obj) {
    return Math.max.apply(Math, Ox.values(obj));
};

/*@
Ox.min <f> Returns the minimum value of a collection
    > Ox.min([1, 2, 3])
    1
    > Ox.min({a: 1, b: 2, c: 3})
    1
    > Ox.min('123')
    1
@*/
Ox.min = function(obj) {
    return Math.min.apply(Math, Ox.values(obj));
};

/*@
Ox.range <f> Python-style range
    (stop) -> <[n]> range
        Returns an array of integers from <code>0</code> (inclusive) to
        <code>stop</code> (exclusive).
    (start, stop) -> <[n]> range
        Returns an array of integers from <code>start</code> (inclusive) to
        <code>stop</code> (exclusive).
    (start, stop, step) -> <[n]> range
        Returns an array of numbers from <code>start</code> (inclusive) to
        <code>stop</code> (exclusive), incrementing by <code>step</step>.
    start <n> Start value
    stop <n> Stop value
    step <n> Step value
    > Ox.range(3)
    [0, 1, 2]
    > Ox.range(1, 4)
    [1, 2, 3]
    > Ox.range(3, 0)
    [3, 2, 1]
    > Ox.range(1, 2, 0.5)
    [1, 1.5]
    > Ox.range(-1, -2, -0.5)
    [-1, -1.5]
@*/
Ox.range = function() {
    var args = Ox.makeArray(arguments),
        arr = [];
    args.push(function(i) {
        arr.push(i);
    });
    Ox.loop.apply(null, args);
    return arr;
};

/*@
Ox.setPropertyOnce <f> Sets a property once
    Given a array of objects, each of which has a property with a boolean
    value, this sets exactly one of these to true, and returns the index
    of the object whose property is true.
    > Ox.setPropertyOnce([{selected: false}, {selected: false}], 'selected')
    0
    > Ox.setPropertyOnce([{selected: false}, {selected: true}], 'selected')
    1
    > Ox.setPropertyOnce([{selected: true}, {selected: true}], 'selected')
    0    
@*/
// fixme: strange name, and shouldn't it return the full array?
Ox.setPropertyOnce = function(arr, str) {
    var pos = -1;
    Ox.forEach(arr, function(v, i) {
        if (pos == -1 && arr[i][str]) {
            pos = i;
        } else if (pos > -1 && arr[i][str]) {
            delete arr[i][str];
        }
    });
    if (pos == -1) {
        arr[0][str] = true;
        pos = 0;
    }
    return pos;
};

/*@
Ox.shuffle <f> Randomizes the order of values within a collection
    > Ox.shuffle([1, 2, 3]).length
    3
    > Ox.len(Ox.shuffle({a: 1, b: 2, c: 3}))
    3
    > Ox.shuffle('123').length
    3
@*/

Ox.shuffle = function(col) {
    var keys, ret, type = Ox.typeOf(col), values;
    function sort() {
        return Math.random() - 0.5;
    }
    if (type == 'array') {
        ret = col.sort(sort);
    } else if (type == 'object') {
        keys = Object.keys(col);
        values = Ox.values(col).sort(sort);
        ret = {};
        keys.forEach(function(key, i) {
            ret[key] = values[i]
        });
    } else if (type == 'string') {
        ret = col.split('').sort(sort).join('');
    }
    return ret;
};

/*@
Ox.some <f> Tests if one or more elements of a collection satisfy a given condition
    Unlike <code>[].some()</code>, <code>Ox.some()</code> works for arrays,
    objects and strings.
    > Ox.some([2, 1, 0], function(i, v) { return i == v; })
    true
    > Ox.some({a: 1, b: 2, c: 3}, function(v) { return v == 1; })
    true
    > Ox.some("foo", function(v) { return v == 'f'; })
    true
@*/
Ox.some = function(obj, fn) {
    return Ox.filter(Ox.values(obj), fn).length > 0;
};

/*@
Ox.sum <f> Returns the sum of the values of a collection
    > Ox.sum(1, 2, 3)
    6
    > Ox.sum([1, 2, 3])
    6
    > Ox.sum({a: 1, b: 2, c: 3})
    6
    > Ox.sum('123')
    6
    > Ox.sum('123foo')
    6
    > Ox.sum('08', -2, 'foo')
    6
@*/
Ox.sum = function(col) {
    var sum = 0;
    col = arguments.length > 1 ? Ox.makeArray(arguments) : col;
    Ox.forEach(col, function(val) {
        val = +val;
        sum += Ox.isNumber(val) ? val : 0;
    });
    return sum;
};

Ox.toArray = function(obj) {
    // fixme: can this be thrown out?
    /*
    >>> Ox.toArray('foo')
    ['foo']
    >>> Ox.toArray(['foo'])
    ['foo']
    */
    var arr;
    if (Ox.isArray(obj)) {
        arr = obj;
    } else if (Ox.isArguments(obj)) {
        arr = Ox.makeArray(obj);
    } else {
        arr = [obj];
    }
    return arr;
};

/*@
Ox.values <f> Returns the values of a collection
    > Ox.values([1, 2, 3])
    [1, 2, 3]
    > Ox.values({a: 1, b: 2, c: 3})
    [1, 2, 3]
    > Ox.values('abc')
    ['a', 'b', 'c']
    > Ox.values([1,,3])
    [1, 3]
@*/
Ox.values = function(col) {
    // Ox.values(str) is identical to str.split('')
    var values = [];
    Ox.forEach(col, function(val) {
        values.push(val);
    });
    return values;
};

/*@
Ox.walk <f> Recursively walk a tree-like key/value store
    <script>
        Ox.test.number = 0;
        Ox.walk({a: 1, b: {c: 2, d: 3}}, function (v) {
            Ox.test.number += Ox.isNumber(v) ? v : 0;
        });
    </script>
    > Ox.test.number
    6
@*/
Ox.walk = function(obj, fn) {
    Ox.forEach(obj, function(val, key) {
        fn(val, key, obj);
        Ox.walk(obj[key], fn);
    });
};

//@ Color ----------------------------------------------------------------------

/*@
Ox.hsl <f> Takes RGB values and returns HSL values
    (rgb) <[n]> HSL values
    rgb <[n]> RGB values
    > Ox.hsl([0, 0, 0])
    [0, 0, 0]
    > Ox.hsl([255, 255, 255])
    [0, 0, 1]
    > Ox.hsl([0, 255, 0])
    [120, 1, 0.5]
@*/
Ox.hsl = function(rgb) {
    rgb = rgb.map(function(v) {
        return v / 255;
    });
    var max = Ox.max(rgb),
        min = Ox.min(rgb),
        hsl = [0, 0, 0];
    hsl[2] = 0.5 * (max + min);
    if (max == min) {
        hsl[0] = 0;
        hsl[1] = 0;
    } else {
        if (max == rgb[0]) {
            hsl[0] = (60 * (rgb[1] - rgb[2]) / (max - min) + 360) % 360;
        } else if (max == rgb[1]) {
            hsl[0] = 60 * (rgb[2] - rgb[0]) / (max - min) + 120;
        } else if (max == rgb[2]) {
            hsl[0] = 60 * (rgb[0] - rgb[1]) / (max - min) + 240;
        }
        if (hsl[2] <= 0.5) {
            hsl[1] = (max - min) / (2 * hsl[2]);
        } else {
            hsl[1] = (max - min) / (2 - 2 * hsl[2]);
        }
    }
    return hsl;
};

/*@
Ox.rgb <f> Takes HSL values and returns RGB values
    (hsl) <[n]> RGB values
    hsl <[n]> HSL values
    > Ox.rgb([0, 0, 0])
    [0, 0, 0]
    > Ox.rgb([0, 0, 1])
    [255, 255, 255]
    > Ox.rgb([120, 1, 0.5])
    [0, 255, 0]
@*/

Ox.rgb = function(hsl) {
    hsl[0] /= 360;
    var rgb = [0, 0, 0],
        v1, v2, v3;
    if (hsl[1] == 0) {
        rgb = [hsl[2], hsl[2], hsl[2]];
    } else {
        if (hsl[2] < 0.5) {
            v2 = hsl[2] * (1 + hsl[1]); 
        } else {
            v2 = hsl[1] + hsl[2] - (hsl[1] * hsl[2]);
        }
        v1 = 2 * hsl[2] - v2;
        rgb.forEach(function(v, i) {
            v3 = hsl[0] + (1 - i) * 1/3;
            if (v3 < 0) {
                v3++;
            } else if (v3 > 1) {
                v3--;
            }
            if (v3 < 1/6) {
                rgb[i] = v1 + ((v2 - v1) * 6 * v3);
            } else if (v3 < 0.5) {
                rgb[i] = v2;
            } else if (v3 < 2/3) {
                rgb[i] = v1 + ((v2 - v1) * 6 * (2/3 - v3));
            } else {
                rgb[i] = v1;
            }
        });
    }
    return rgb.map(function(v) {
        return v * 255;
    });
};

//@ Constants ------------------------------------------------------------------

//@ Ox.AMPM <[str]> ['AM', 'PM']
Ox.AMPM = ['AM', 'PM'];
//@ Ox.DURATIONS <[str]> ['year', 'month', 'day', 'minute', 'second']
Ox.DURATIONS = ['year', 'month', 'day', 'minute', 'second'];
//@ Ox.EARTH_RADIUS <number> Radius of the earth in meters
// see http://en.wikipedia.org/wiki/WGS-84
Ox.EARTH_RADIUS = 6378137;
//@ Ox.EARTH_CIRCUMFERENCE <num> Circumference of the earth in meters
Ox.EARTH_CIRCUMFERENCE = Ox.EARTH_RADIUS * 2 * Math.PI;
//@ Ox.HTML_ENTITIES <object> HTML entities for ... (FIXME)
Ox.HTML_ENTITIES = {
    '"': '&quot;', '&': '&amp;', "'": '&apos;', '<': '&lt;', '>': '&gt;'
};
//@ Ox.KEYS <object> Names for key codes
// The dot notation ('0.numpad') allows for namespaced events ('key_0.numpad'),
// so that binding to 'key_0' will catch both 'key_0' and 'key_0.numpad'.
Ox.KEYS = {
    0: 'section', 8: 'backspace', 9: 'tab', 12: 'clear', 13: 'enter',
    16: 'shift', 17: 'control', 18: 'alt', 20: 'capslock', 27: 'escape',
    32: 'space', 33: 'pageup', 34: 'pagedown', 35: 'end', 36: 'home',
    37: 'left', 38: 'up', 39: 'right', 40: 'down',
    45: 'insert', 46: 'delete', 47: 'help',
    48: '0', 49: '1', 50: '2', 51: '3', 52: '4',
    53: '5', 54: '6', 55: '7', 56: '8', 57: '9',
    65: 'a', 66: 'b', 67: 'c', 68: 'd', 69: 'e',
    70: 'f', 71: 'g', 72: 'h', 73: 'i', 74: 'j',
    75: 'k', 76: 'l', 77: 'm', 78: 'n', 79: 'o',
    80: 'p', 81: 'q', 82: 'r', 83: 's', 84: 't',
    85: 'u', 86: 'v', 87: 'w', 88: 'x', 89: 'y', 90: 'z',
    // fixme: this is usually 91: window.left, 92: window.right, 93: select
    91: 'meta.left', 92: 'meta.right', 93: 'meta.right',
    96: '0.numpad', 97: '1.numpad', 98: '2.numpad',
    99: '3.numpad', 100: '4.numpad', 101: '5.numpad',
    102: '6.numpad', 103: '7.numpad', 104: '8.numpad', 105: '9.numpad',
    106: 'asterisk.numpad', 107: 'plus.numpad', 109: 'minus.numpad',
    108: 'enter.numpad', 110: 'dot.numpad', 111: 'slash.numpad',
    112: 'f1', 113: 'f2', 114: 'f3', 115: 'f4', 116: 'f5',
    117: 'f6', 118: 'f7', 119: 'f8', 120: 'f9', 121: 'f10',
    122: 'f11', 123: 'f12', 124: 'f13', 125: 'f14', 126: 'f15', 127: 'f16',
    144: 'numlock', 145: 'scrolllock',
    186: 'semicolon', 187: 'equal', 188: 'comma', 189: 'minus',
    190: 'dot', 191: 'slash', 192: 'backtick', 219: 'openbracket',
    220: 'backslash', 221: 'closebracket', 222: 'quote', 224: 'meta'
    // see dojo, for ex.
},
Ox.MAP_TILE_SIZE = 256; // fixme: definitely not needed here
//@ Ox.MODIFIER_KEYS <obj> Names for modifier keys
// meta comes last so that one can differentiate between
// alt_control_shift_meta.left and alt_control_shift_meta.right
Ox.MODIFIER_KEYS = {
    altKey: 'alt', // Mac: option
    ctrlKey: 'control',
    shiftKey: 'shift',
    metaKey: 'meta', // Mac: command
}
//@ Ox.MONTHS <[str]> Names of months
Ox.MONTHS = [
    'January', 'February', 'March', 'April', 'May', 'June',
    'July', 'August', 'September', 'October', 'November', 'December'
];
//@ Ox.SHORT_MONTHS <[str]> Short names of months
Ox.SHORT_MONTHS = Ox.MONTHS.map(function(val) {
    return val.substr(0, 3);
});
//@ Ox.PATH <str> Path of Ox.js
Ox.PATH = Array.prototype.slice.apply(
    document.getElementsByTagName('script')
).filter(function(element) {
    return /Ox\.js$/.test(element.src);
})[0].src.replace('Ox.js', '');
//@ Ox.PREFIXES <[str]> <code>['K', 'M', 'G', 'T', 'P']</code>
Ox.PREFIXES = ['K', 'M', 'G', 'T', 'P'];
//@ Ox.SYMBOLS <obj> Unicode characters for symbols
Ox.SYMBOLS = {
    DOLLAR: '\u0024', 
    CENT: '\u00A2', POUND: '\u00A3', CURRENCY: '\u00A4', YEN: '\u00A5',
    BULLET: '\u2022', ELLIPSIS: '\u2026', PERMILLE: '\u2030',
    COLON: '\u20A1', CRUZEIRO: '\u20A2', FRANC: '\u20A3', LIRA: '\u20A4',
    NAIRA: '\u20A6',  PESETA: '\u20A7', WON: '\u20A9', SHEQEL: '\u20AA',
    DONG: '\u20AB', EURO: '\u20AC', KIP: '\u20AD', TUGRIK: '\u20AE',
    DRACHMA: '\u20AF', PESO: '\u20B1', GUARANI: '\u20B2', AUSTRAL: '\u20B3',
    HRYVNIA: '\u20B4', CEDI: '\u20B5', TENGE: '\u20B8', RUPEE: '\u20B9',
    CELSIUS: '\u2103', FAHRENHEIT: '\u2109', POUNDS: '\u2114', OUNCE: '\u2125',
    OHM: '\u2126', KELVIN: '\u212A', ANGSTROM: '\u212B', INFO: '\u2139',
    LEFT: '\u2190', UP: '\u2191', RIGHT: '\u2192', DOWN: '\u2193',
    HOME: '\u2196', END: '\u2198', RETURN: '\u21A9',
    REDO: '\u21BA', UNDO: '\u21BB', PAGEUP: '\u21DE', PAGEDOWN: '\u21DF',
    CAPSLOCK: '\u21EA', TAB: '\u21E5', SHIFT: '\u21E7', INFINITY: '\u221E',
    CONTROL: '\u2303', COMMAND: '\u2318', ENTER: '\u2324', ALT: '\u2325',
    DELETE: '\u2326', CLEAR:'\u2327',BACKSPACE: '\u232B', OPTION: '\u2387',
    NAVIGATE: '\u2388', ESCAPE: '\u238B', EJECT: '\u23CF',
    SPACE: '\u2423', DIAMOND: '\u25C6',
    STAR: '\u2605', SOUND: '\u266B', TRASH: '\u267A', FLAG: '\u2691',
    ANCHOR: '\u2693', GEAR: '\u2699', ATOM: '\u269B', WARNING: '\u26A0',
    CUT: '\u2702', BACKUP: '\u2707', FLY: '\u2708', CHECK: '\u2713',
    CLOSE: '\u2715', BALLOT: '\u2717', WINDOWS: '\u2756',
    EDIT: '\uF802', CLICK: '\uF803', APPLE: '\uF8FF'
};
//@ Ox.TYPES <[str]> list of types, as returned by <code>Ox.type()</code>
Ox.TYPES = [
    'Arguments', 'Array', 'Boolean', 'Date', 'Element', 'Function', 'Infinity',
    'NaN', 'Null', 'Number', 'Object', 'RegExp', 'String', 'Undefined'
];
//@ Ox.VERSION <str> OxJS version number
Ox.VERSION = '0.1.2';
//@ Ox.WEEKDAYS <[str]> Names of weekdays
Ox.WEEKDAYS = [
    'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'
];
//@ Ox.SHORT_WEEKDAYS <[str]> Short names of weekdays
Ox.SHORT_WEEKDAYS = Ox.WEEKDAYS.map(function(val) {
    return val.substr(0, 3);
});

//@ Date -----------------------------------------------------------------------

//@ Ox.getDate <f> Get the day of a date, optionally UTC
// see Ox.setSeconds for source code

/*@
Ox.getDateInWeek <f> Get the date that falls on a given weekday in the same week
    # Usage
    (date, weekday)      -> <dat> Date
    (date, weekday, utc) -> <dat> Date
    # Arguments
    date    <d> Date
    weekday <n|s> 1-7 (Monday-Sunday) or name, full ("Monday") or short ("Sun")
    utc     <b> If true, all dates are UTC
    # Examples
    > Ox.formatDate(Ox.getDateInWeek(new Date("January 1 2000"), "Sunday"), "%A, %B %e, %Y")
    "Sunday, January  2, 2000"
    > Ox.formatDate(Ox.getDateInWeek(new Date("Jan 1 2000"), "Fri"), "%A, %B %e, %Y")
    "Friday, December 31, 1999"
    > Ox.formatDate(Ox.getDateInWeek(new Date("1/1/2000"), 1), "%A, %B %e, %Y")
    "Monday, December 27, 1999"
@*/
// fixme: why is this Monday first? shouldn't it then be "getDateInISOWeek"??
Ox.getDateInWeek = function(date, weekday, utc) {
    /*
    */
    date = Ox.makeDate(date);
    Ox.print(date, Ox.getDate(date, utc), Ox.formatDate(date, '%u', utc), date)
    var sourceWeekday = Ox.getISODay(date, utc),
        targetWeekday = Ox.isNumber(weekday) ? weekday :
            Ox.map(Ox.WEEKDAYS, function(v, i) {
                return v.substr(0, 3) == weekday.substr(0, 3) ? i + 1 : null;
            })[0];
    Ox.print(date, Ox.getDate(date, utc), sourceWeekday, targetWeekday)
    return Ox.setDate(date, Ox.getDate(date, utc) - sourceWeekday + targetWeekday, utc);
}

//@ Ox.getDay <f> Get the weekday of a date, optionally UTC
// see Ox.setSeconds for source code

/*@
Ox.getDayOfTheYear <f> Get the day of the year for a given date
    # Usage
    (date)      -> <d> Date
    (date, utc) -> <d> Date
    # Arguments
    date <d> Date
    utc  <b> If true, all dates are UTC
    # Examples
    > Ox.getDayOfTheYear(new Date("12/31/2000"))
    366
    > Ox.getDayOfTheYear(new Date("12/31/2002"))
    365
    > Ox.getDayOfTheYear(new Date("12/31/2004"))
    366
@*/

Ox.getDayOfTheYear = function(date, utc) {
    date = Ox.makeDate(date);
    var month = Ox.getMonth(date, utc),
        year = Ox.getFullYear(date, utc);
    return Ox.sum(Ox.map(Ox.range(month), function(i) {
        return Ox.getDaysInMonth(year, i + 1);
    })) + Ox.getDate(date, utc);
};

/*@
Ox.getDaysInMonth <f> Get the number of days in a given month
    > Ox.getDaysInMonth(2000, 2)
    29
    > Ox.getDaysInMonth("2002", "Feb")
    28
    > Ox.getDaysInMonth(new Date('01/01/2004'), "February")
    29
@*/
Ox.getDaysInMonth = function(year, month, utc) {
    /*
    */
    year = Ox.makeYear(year);
    month = Ox.isNumber(month) ? month :
        Ox.map(Ox.MONTHS, function(v, i) {
            return v.substr(0, 3) == month.substr(0, 3) ? i + 1 : null;
        })[0];
    return new Date(year, month, 0).getDate();
}

/*
Ox.getDaysInYear <f> Get the number of days in a given year
    > Ox.getDaysInYear(1900)
    365
    > Ox.getDaysInYear('2000')
    366
    > Ox.getDaysInYear(new Date('01/01/2004'))
    366
*/
Ox.getDaysInYear = function(year, utc) {
    return 365 + Ox.isLeapYear(Ox.makeYear(year, utc));
};

/*@
Ox.getFirstDayOfTheYear <f> Get the weekday of the first day of a given year
    Returns the decimal weekday of January 1 (0-6, Sunday as first day)
    > Ox.getFirstDayOfTheYear(new Date('01/01/2000'))
    6
@*/
Ox.getFirstDayOfTheYear = function(date, utc) {
    date = Ox.makeDate(date);
    date = Ox.setMonth(date, 0, utc);
    date = Ox.setDate(date, 1, utc);
    return Ox.getDay(date, utc)
};

//@ Ox.getFullYear <f> Get the year of a date, optionally UTC
// see Ox.setSeconds for source code
//@ Ox.getHours <f> Get the hours of a date, optionally UTC
// see Ox.setSeconds for source code

/*@
Ox.getISODate <f> Get the ISO date string for a given date
    > Ox.getISODate(new Date('01/01/2000'))
    '2000-01-01T00:00:00Z'
@*/
Ox.getISODate = function(date, utc) {
    return Ox.formatDate(Ox.makeDate(date), '%FT%TZ', utc);
};

/*@
Ox.getISODay <f> Get the ISO weekday of a given date
    Returns the decimal weekday (1-7, Monday as first day)
    > Ox.getISODay(new Date('01/01/2000'))
    6
    > Ox.getISODay(new Date('01/02/2000'))
    7
    > Ox.getISODay(new Date('01/03/2000'))
    1
@*/
Ox.getISODay = function(date, utc) {
    return Ox.getDay(Ox.makeDate(date), utc) || 7;
};

/*@
Ox.getISOWeek <f> Get the ISO week of a given date
    See <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>
    > Ox.getISOWeek(new Date('01/01/2000'))
    52
    > Ox.getISOWeek(new Date('01/02/2000'))
    52
    > Ox.getISOWeek(new Date('01/03/2000'))
    1
@*/

Ox.getISOWeek = function(date, utc) {
    date = Ox.makeDate(date);
    // set date to Thursday of the same week
    return Math.floor((Ox.getDayOfTheYear(Ox.setDate(
        date, Ox.getDate(date, utc) - Ox.getISODay(date, utc) + 4, utc
    ), utc) - 1) / 7) + 1;
};

/*@
Ox.getISOYear <f> Get the ISO year of a given date
    See <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>
    > Ox.getISOYear(new Date("01/01/2000"))
    1999
    > Ox.getISOYear(new Date("01/02/2000"))
    1999
    > Ox.getISOYear(new Date("01/03/2000"))
    2000
@*/

Ox.getISOYear = function(date, utc) {
    date = Ox.makeDate(date);
    // set date to Thursday of the same week
    return Ox.getFullYear(Ox.setDate(
        date, Ox.getDate(date, utc) - Ox.getISODay(date, utc) + 4, utc
    ));
};

//@ Ox.getMilliseconds <f> Get the milliseconds of a date
// see Ox.setSeconds for source code
//@ Ox.getMinutes <f> Get the minutes of a date, optionally UTC
// see Ox.setSeconds for source code
//@ Ox.getMonth <f> Get the month of a date, optionally UTC
// see Ox.setSeconds for source code
//@ Ox.getSeconds <f> Get the seconds of a date
// see Ox.setSeconds for source code

//@ Ox.getTime <f> Alias for <code>+new Date()</code> (deprecated)
Ox.getTime = function() {
    // fixme: needed?
    return +new Date();
};

/*@
Ox.getTimezoneOffset <f> Get the local time zone offset in milliseconds
@*/
Ox.getTimezoneOffset = function() {
    return new Date().getTimezoneOffset() * 60000;
};

/*@
Ox.getTimezoneOffsetString <f> Get the local time zone offset as a string
    Returns a time zone offset string (from around '-1200' to around '+1200').
    > Ox.getTimezoneOffsetString(new Date('01/01/2000')).length
    5
@*/
Ox.getTimezoneOffsetString = function(date) {
    var offset = (Ox.makeDate(date)).getTimezoneOffset();
    return (offset < 0 ? '+' : '-') +
        Ox.pad(Math.floor(Math.abs(offset) / 60), 2) +
        Ox.pad(Math.abs(offset) % 60, 2);
};

/*@
Ox.getWeek <f> Get the week of a given day
    Returns the week of the year (0-53, Sunday as first day)
    > Ox.getWeek(new Date('01/01/2000'))
    0
    > Ox.getWeek(new Date('01/02/2000'))
    1
    > Ox.getWeek(new Date('01/03/2000'))
    1
@*/
Ox.getWeek = function(date, utc) {
    date = Ox.makeDate(date);
    return Math.floor((Ox.getDayOfTheYear(date, utc) +
        Ox.getFirstDayOfTheYear(date, utc) - 1) / 7);
};

/*@
Ox.isLeapYear <f> Returns true if a given year is a leap year
    > Ox.isLeapYear(1900)
    false
    > Ox.isLeapYear('2000')
    true
    > Ox.isLeapYear(new Date('01/01/2004'))
    true
@*/
Ox.isLeapYear = function(year, utc) {
    year = Ox.makeYear(year, utc);
    return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
};

/*@
Ox.makeDate <f> Takes a date, number or string, returns a date
    > Ox.formatDate(Ox.makeDate(new Date('01/01/1970')), '%m/%d/%Y')
    '01/01/1970'
    > Ox.formatDate(Ox.makeDate(0), '%m/%d/%Y')
    '01/01/1970'
    > Ox.formatDate(Ox.makeDate('01/01/1970'), '%m/%d/%Y')
    '01/01/1970'
@*/
Ox.makeDate = function(date) {
    return Ox.isDate(date) ? date :
        Ox.isUndefined(date) ? new Date() : new Date(date);
};

/*@
Ox.makeYear <f> Takes a date, number or string, returns a year
    > Ox.makeYear(new Date('01/01/1970'))
    1970
    > Ox.makeYear(1970)
    1970
    > Ox.makeYear('1970')
    1970
@*/
Ox.makeYear = function(date, utc) {
    return Ox.isDate(date) ? Ox.getFullYear(date, utc) : parseInt(date);
};

//@ Ox.setDate <f> Set the day of a date, optionally UTC
// see Ox.setSeconds for source code
//@ Ox.setDay <f> Set the weekday of a date, optionally UTC
// see Ox.setSeconds for source code
//@ Ox.setFullYear <f> Set the year of a date, optionally UTC
// see Ox.setSeconds for source code
//@ Ox.setHours <f> Set the hours of a date, optionally UTC
// see Ox.setSeconds for source code
//@ Ox.setMilliseconds <f> Set the milliseconds of a date
// see Ox.setSeconds for source code
//@ Ox.setMinutes <f> Set the minutes of a date, optionally UTC
// see Ox.setSeconds for source code
//@ Ox.setMonth <f> Set the month of a date, optionally UTC
// see Ox.setSeconds for source code
//@ Ox.setSeconds <f> Set the seconds of a date

[
    'FullYear', 'Month', 'Date', 'Day',
    'Hours', 'Minutes', 'Seconds', 'Milliseconds'
].forEach(function(noun) {
    Ox['get' + noun] = function(date, utc) {
        return Ox.makeDate(date)['get' + (utc ? 'UTC' : '') + noun]()
    }
    Ox['set' + noun] = function(date, num, utc) {
        // new Date(date) makes a clone, so that
        // setSomething() doesn't have side effects
        return new Date(
            Ox.makeDate(date)
        )['set' + (utc ? 'UTC' : '') + noun](num);
        // fixme: maybe we _want_ set to have side effects?
    }
});

//@ DOM ------------------------------------------------------------------------

/*@
Ox.canvas <function> Generic canvas object
    Returns an object with the properties: <code>canvas</code>,
    <code>context</code>, <code>data</code> and <code>imageData</code>.
    # Usage --------------------------------------------------------------------
    Ox.canvas(width, height) -> <object> canvas
    Ox.canvas(image)         -> <object> canvas
    # Arguments ----------------------------------------------------------------
    width  <n> Width in px
    height <n> Height in px
    image  <e> Image object
@*/

Ox.canvas = function() {
    var c = {}, isImage = arguments.length == 1,
        image = isImage ? arguments[0] : {
            width: arguments[0], height: arguments[1]
        };
    c.context = (c.canvas = Ox.element('<canvas>').attr({
        width: image.width, height: image.height
    })[0]).getContext('2d');
    isImage && c.context.drawImage(image, 0, 0);
    c.data = (c.imageData = c.context.getImageData(
        0, 0, image.width, image.height
    )).data;
    return c;
};

/*@
Ox.documentReady <function> Calls a callback function once the DOM is ready
    (callback) -> <boolean> If true, the document was ready
    callback <function> Callback function
@*/
Ox.documentReady = (function() {
    var callbacks = [];
    document.onreadystatechange = function() {
        if (document.readyState == 'complete') {
            //Ox.print('document has become ready', callbacks);
            callbacks.forEach(function(callback) {
                callback();
            });
            delete callbacks;
        }
    };
    return function(callback) {
        if (document.readyState == 'complete') {
            callback();
            return true;
        } else {
            callbacks.push(callback);
            return false;
        }
    }
}());

/*@
Ox.element <f> Generic HTML element, mimics jQuery
    (str) -> <o> Element object
    str <s> Tagname ('<tagname>') or selector ('tagname', '.classname', '#id')
    > Ox.element("<div>").addClass("red").addClass("red")[0].className
    "red"
    > Ox.element("<div>").attr({id: "red"}).attr("id")
    "red"
    > Ox.element("<div>").css("color", "red").css("color")
    "red"
    > Ox.element("<div>").html("red").html()
    "red"
@*/
Ox.element = function(str) {
    return {
        //@ 0 <e> The DOM element itself
        0: str[0] == '<' ? document.createElement(str.substr(1, str.length - 2)) :
            str[0] == '.' ? document.getElementsByClassName(str.substr(1))[0] :
            str[0] == '#' ? document.getElementById(str.substr(1)) :
            document.getElementsByTagName(str)[0],
        /*@
        addClass <f> Adds a class name
            (className) -> <o> This element
            className <s> Class name
        @*/
        addClass: function(str) {
            this[0].className = this[0].className ? Ox.unique(
                (this[0].className + ' ' + str).split(' ')
            ) : str;
            return this;
        },
        /*@
        append <f> Appends another element to this element
            (element) -> <o> This element
            element <o> Another element
        @*/
        append: function(element) {
            this[0].appendChild(element[0]);
            return this;
        },
        /*@
        appendTo <f> appends this element object to another element object
            (element) -> <o> This element
            element <o> Another element
        @*/
        appendTo: function(element) {
            element[0].appendChild(this[0]);
            return this;
        },
        /*@
        attr <f> Gets or sets an attribute
            (key)          -> <s> Value
            (key, value)   -> <o> This element
            ({key, value}) -> <o> This element
            key   <str> Attribute name
            value <str> Attribute value
        @*/
        attr: function() {
            var ret, that = this;
            if (arguments.length == 1 && Ox.isString(arguments[0])) {
                ret = this[0].getAttribute(arguments[0]);
            } else {
                Ox.forEach(Ox.makeObject(arguments), function(v, k) {
                    that[0].setAttribute(k, v);
                });
                ret = this;
            }
            return ret;
        },
        /*@
        css <f> Gets or sets a CSS attribute
            (key)          -> <s> Value
            (key, value)   -> <o> This element
            ({key, value}) -> <o> This element
            key   <str> Attribute name
            value <str> Attribute value
        @*/
        css: function() {
            var ret, that = this;
            if (arguments.length == 1 && Ox.isString(arguments[0])) {
                ret = this[0].style[arguments[0]];
            } else {
                Ox.forEach(Ox.makeObject(arguments), function(v, k) {
                    that[0].style[k] = v;
                });
                ret = this;
            }
            return ret;
        },
        /*@
        html <f> Gets or sets the inner HTML
            ()     -> <s> The inner HTML
            (html) -> <o> This element
            html <s> The inner HTML
        @*/
        html: function(str) {
            var ret;
            if (Ox.isUndefined(str)) {
                ret = this[0].innerHTML;
            } else {
                this[0].innerHTML = str;
                ret = this;
            }
            return ret;
        },
        /*@
        mousedown <f> Binds a function to the mousedown event
            (callback) -> <o> This element
            callback <f> Callback function
                event <o> The DOM event
        @*/
        mousedown: function(callback) {
            this[0].onmousedown = callback;
            return this;
        },
        /*@
        removeClass <f> Removes a class name
            (className) -> <o> This element
            className <s> Class name
        @*/
        removeClass: function(str) {
            this[0].className = Ox.filter(
                this[0].className.split(' '), function(className) {
                    return className != str;
                }
            ).join(' ');
            return this;
        }
    }
};

//@ Encoding -------------------------------------------------------------------

(function() {

    var aliases = {'I': '1', 'L': '1', 'O': '0', 'U': 'V'},
        digits = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';

    function cap(width, height) {
        // returns maximum encoding capacity of an image
        return parseInt(width * height * 3/8) - 4;
    }

    function seek(data, px) {
        // returns this, or the next, opaque pixel
        while (data[px * 4 + 3] < 255) {
            if (++px * 4 == data.length) {
                throwPNGError('de');
            }
        }
        return px;
    }

    function xor(byte) {
        // returns "1"-bits-in-byte % 2
        var xor = 0;
        Ox.range(8).forEach(function(i) {
            xor ^= byte >> i & 1;
        });
        return xor;
    }

    function throwPNGError(str) {
        throw new RangeError(
            'PNG codec can\'t ' +
            (str == 'en' ? 'encode data' : 'decode image')
        );
    }

    function throwUTF8Error(byte, pos) {
        throw new RangeError(
            'UTF-8 codec can\'t decode byte 0x' +
            byte.toString(16).toUpperCase() + ' at position ' + pos
        );
    }

    /*@
    Ox.encodeBase32 <b> Encode a number as base32
        See <a href="http://www.crockford.com/wrmg/base32.html">Base 32</a>.
        > Ox.encodeBase32(15360)
        'F00'
        > Ox.encodeBase32(33819)
        '110V'
    @*/
    Ox.encodeBase32 = function(num) {
        return Ox.map(num.toString(32), function(char) {
            return digits[parseInt(char, 32)];
        }).join('');
    }

    /*@
    Ox.decodeBase32 <f> Decodes a base32-encoded number
        See <a href="http://www.crockford.com/wrmg/base32.html">Base 32</a>.
        > Ox.decodeBase32('foo')
        15360
        > Ox.decodeBase32('ILOU')
        33819
        > Ox.decodeBase32('?').toString()
        'NaN'
    @*/
    Ox.decodeBase32 = function(str) {
        return parseInt(Ox.map(str.toUpperCase(), function(char) {
            var index = digits.indexOf(aliases[char] || char);
            return (index == -1 ? ' ' : index).toString(32);
        }).join(''), 32);
    }

    /*@
    Ox.encodeBase64 <f> Encode a number as base64
        > Ox.encodeBase64(32394)
        'foo'
    @*/
    Ox.encodeBase64 = function(num) {
        return btoa(Ox.encodeBase256(num)).replace(/=/g, '');
    }

    /*@
    Ox.decodeBase64 <f> Decodes a base64-encoded number
        > Ox.decodeBase64('foo')
        32394
    @*/
    Ox.decodeBase64 = function(str) {
        return Ox.decodeBase256(atob(str));
    }

    /*@
    Ox.encodeBase128 <f> Encode a number as base128
        > Ox.encodeBase128(1685487)
        'foo'
    @*/
    Ox.encodeBase128 = function(num) {
        var str = '';
        while (num) {
            str = Ox.char(num & 127) + str;
            num >>= 7;
        }
        return str;
    }

    /*@
    Ox.decodeBase128 <f> Decode a base128-encoded number
        > Ox.decodeBase128('foo')
        1685487
    @*/
    Ox.decodeBase128 = function(str) {
        var num = 0, len = str.length;
        Ox.forEach(str, function(char, i) {
            num += char.charCodeAt(0) << (len - i - 1) * 7;
        });
        return num;
    }

    /*@
    Ox.encodeBase256 <f> Encode a number as base256
        > Ox.encodeBase256(6713199)
        'foo'
    @*/
    Ox.encodeBase256 = function(num) {
        var str = '';
        while (num) {
            str = Ox.char(num & 255) + str;
            num >>= 8;
        }
        return str;
    }

    /*@
    Ox.decodeBase256 <f> Decode a base256-encoded number
        > Ox.decodeBase256('foo')
        6713199
    @*/
    Ox.decodeBase256 = function(str) {
        var num = 0, len = str.length;
        Ox.forEach(str, function(char, i) {
            num += char.charCodeAt(0) << (len - i - 1) * 8;
        });
        return num;
    }

    //@ Ox.encodeDeflate <f> (undocumented)
    Ox.encodeDeflate = function(str) {
        // encodes string, using deflate
        /*
        in fact, the string is written to the rgb channels of a canvas element,
        then the dataURL is decoded from base64, and some head and tail cut off
        */
        str = Ox.encodeUTF8(str);
        var len = str.length, c = Ox.canvas(Math.ceil((4 + len) / 3), 1), data;
        str = Ox.pad(Ox.encodeBase256(len), 4, Ox.char(0)) + str +
                Ox.repeat('\u00FF', (4 - len % 4) % 4); // simpler? Ox.pad()?
        /* fixme: why does map not work here?
        c.data = $.map(c.data, function(v, i) {
            return i % 4 < 3 ? str.charCodeAt(i - parseInt(i / 4)) : 255;
        });
        */
        for (i = 0; i < c.data.length; i += 1) {
            c.data[i] = i % 4 < 3 ? str.charCodeAt(i - parseInt(i / 4)) : 255;
        }
        c.context.putImageData(c.imageData, 0, 0);
        Ox.print(c.canvas.toDataURL())
        data = atob(c.canvas.toDataURL().split(',')[1]);
        Ox.print('data', data);
        return data.substr(8, data.length - 20);
    }

    //@ Ox.decodeDeflate <f> (undocumented)
    Ox.decodeDeflate = function(str) {
        var image = new Image();
        image.src = 'data:image/png;base64,' + btoa('\u0089PNG\r\n\u001A\n' +
                str + Ox.repeat('\u0000', 4) + 'IEND\u00AEB`\u0082');
        Ox.print(image.src);
        while (!image.width) {} // block until image data is available
        str = Ox.map(Ox.canvas(image).data, function(v, i) {
            return i % 4 < 3 ? Ox.char(v) : '';
        }).join('');
        return Ox.decodeUTF8(str.substr(4, Ox.decodeBase256(str.substr(0, 4))));
    }

    /*@
    Ox.encodeHTML <f> HTML-encodes a string
        > Ox.encodeHTML('\'<"&">\'')
        '&apos;&lt;&quot;&amp;&quot;&gt;&apos;'
        > Ox.encodeHTML('äbçdê')
        '&#x00E4;b&#x00E7;d&#x00EA;'
    @*/
    Ox.encodeHTML = function(str) {
        return Ox.map(str.toString(), function(v) {
            var code = v.charCodeAt(0);
            return code < 128 ? (v in Ox.HTML_ENTITIES ? Ox.HTML_ENTITIES[v] : v) :
                '&#x' + Ox.pad(code.toString(16).toUpperCase(), 4) + ';';
        }).join('');
    };

    /*@
    Ox.decodeHTML <f> Decodes an HTML-encoded string
        > Ox.decodeHTML('&apos;&lt;&quot;&amp;&quot;&gt;&apos;')
        '\'<"&">\''
        > Ox.decodeHTML('&#x0027;&#x003C;&#x0022;&#x0026;&#x0022;&#x003E;&#x0027;')
        '\'<"&">\''
        > Ox.decodeHTML('&auml;b&ccedil;d&ecirc;')
        'äbçdê'
        > Ox.decodeHTML('&#x00E4;b&#x00E7;d&#x00EA;')
        'äbçdê'
    @*/
    Ox.decodeHTML = function(str) {
        // relies on dom, but shorter than using this:
        // http://www.w3.org/TR/html5/named-character-references.html 
        return Ox.element('<div>').html(str)[0].childNodes[0].nodeValue;
    };

    //@ Ox.encodePNG <f> Encodes a string into an image, returns a new image URL
    Ox.encodePNG = function(img, str) {
        /*
        the message is compressed with deflate (by proxy of canvas),
        then the string (four bytes length) + (length bytes message)
        is encoded bitwise into the r/g/b bytes of all opaque pixels
        by flipping, if necessary, the least significant bit, so that
        (number of "1"-bits of the byte) % 2 is the bit of the string
        wishlist:
        - only use deflate if it actually shortens the message
        - in deflate, strip and later re-insert the chunk types
        - encode a decoy message into the least significant bit
          (and flip the second least significant bit, if at all)
        - write an extra png chunk containing some key
        */
        //str = Ox.encodeDeflate(str); currently broken
        str = Ox.encodeUTF8(str);
        var c = Ox.canvas(img), len = str.length, px = 0;
        if (len == 0 || len > cap(img.width, img.height)) {
            throwPNGError('en')
        }
        len = Ox.pad(Ox.encodeBase256(len), 4, Ox.char(0));
        Ox.forEach(Ox.map(len + str, function(byte) {
            return Ox.map(Ox.range(8), function(i) {
                return byte.charCodeAt(0) >> 7 - i & 1;
            }).join('');
        }).join(''), function(bit, i) {
            var index = parseInt((px = seek(c.data, px)) * 4 + i % 3),
                byte = c.data[index];
            c.data[index] = bit == xor(byte) ? byte :
                    byte & 254 | !(byte & 1);
            px += i % 3 == 2;
        });
        c.context.putImageData(c.imageData, 0, 0);
        return c.canvas.toDataURL();
    }

    //@ Ox.decodePNG <f> Decodes an image, returns a string
    Ox.decodePNG = function(img) {
        var bits = '', data = Ox.canvas(img).data, flag = false, i = 0,
            len = 4, max = cap(img.width, img.height), px = 0, str = '';
        do {
            bits += xor(data[parseInt((px = seek(data, px)) * 4 + i % 3)]);
            px += i % 3 == 2;
            if (++i % 8 == 0) {
                str += Ox.char(parseInt(bits, 2));
                bits = '';
                len--;
                if (len == 0 && !flag) {
                    len = Ox.decodeBase256(str);
                    if (len <= 0 || len > max) {
                        Ox.print(len);
                        throwPNGError('de');
                    }
                    str = '';
                    flag = true;
                }
            }
        } while (len);
        try {
            //return Ox.decodeDeflate(str); currently broken
            return Ox.decodeUTF8(str);
        } catch(e) {
            Ox.print(e.toString());
            throwPNGError('de');
        }
    }

    /*@
    Ox.encodeUTF8 <f> Encodes a string as UTF-8
        see http://en.wikipedia.org/wiki/UTF-8
        (string) -> <s> UTF-8 encoded string
        string <s> Any string
        > Ox.encodeUTF8("foo")
        "foo"
        > Ox.encodeUTF8("¥€$")
        "\u00C2\u00A5\u00E2\u0082\u00AC\u0024"
    @*/
    Ox.encodeUTF8 = function(str) {
        /*
        */
        return Ox.map(str, function(chr) {
            var code = chr.charCodeAt(0),
                str = '';
            if (code < 128) {
                str = chr;
            } else if (code < 2048) {
                str = String.fromCharCode(code >> 6 | 192) +
                    String.fromCharCode(code & 63 | 128);
            } else {
                str = String.fromCharCode(code >> 12 | 224) +
                    String.fromCharCode(code >> 6 & 63 | 128) +
                    String.fromCharCode(code & 63 | 128);
            }
            return str;
        }).join('');
    }

    /*@
    Ox.decodeUTF8 <f> Decodes an UTF-8-encoded string
        see http://en.wikipedia.org/wiki/UTF-8
        (utf8) -> <s> string
        utf8 <s> Any UTF-8-encoded string
        > Ox.decodeUTF8('foo')
        'foo'
        > Ox.decodeUTF8('\u00C2\u00A5\u00E2\u0082\u00AC\u0024')
        '¥€$'
    @*/
    Ox.decodeUTF8 = function(str) {
        /*
        */
        var bytes = Ox.map(str, function(v) {
                return v.charCodeAt(0);
            }),
            i = 0,
            len = str.length,
            str = '';
        while (i < len) {
            if (bytes[i] <= 128) {
                str += String.fromCharCode(bytes[i]);
                i++;
            } else if (
                bytes[i] >= 192 && bytes[i] < 240 &&
                i < len - (bytes[i] < 224 ? 1 : 2)
            ) {
                if (bytes[i + 1] >= 128 && bytes[i + 1] < 192) {
                    if (bytes[i] < 224) {
                        str += String.fromCharCode((bytes[i] & 31) << 6 |
                            bytes[i + 1] & 63);
                        i += 2;
                    } else if (bytes[i + 2] >= 128 && bytes[i + 2] < 192) {
                        str += String.fromCharCode((bytes[i] & 15) << 12 |
                            (bytes[i + 1] & 63) << 6 | bytes[i + 2] & 63);
                        i += 3;
                    } else {
                        throwUTF8Error(bytes[i + 2], i + 2);
                    }
                } else {
                    throwUTF8Error(bytes[i + 1], i + 1);
                }
            } else {
                throwUTF8Error(bytes[i], i);
            }
        }
        return str;
    };

})();

//@ Format ---------------------------------------------------------------------

/*@
Ox.formatArea <f> Formats a number of meters as square kilometers
    > Ox.formatArea(1000000)
    '1 km\u00B2'
@*/

Ox.formatArea = function(num, dec) {
    return Ox.formatNumber(Ox.round(num / 1000000, dec)) + ' km\u00B2';
}

/*@
Ox.formatColor <f> (not implemented)
@*/
Ox.formatColor = function() {
    
};

/*@
Ox.formatCurrency <f> Formats a number with a currency symbol
    > Ox.formatCurrency(1000, '$', 2)
    '$1,000.00'
@*/

Ox.formatCurrency = function(num, str, dec) {
    return str + Ox.formatNumber(num, dec);
};

/*@
Ox.formatDate <f> Formats a date according to a format string
    See 
    <a href="http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/strftime.3.html">strftime</a>
    and <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>.
    <script>
        Ox.test.date = new Date('2005-01-02 00:03:04');
    </script>
    > Ox.formatDate(Ox.test.date, '%A') // Full weekday
    'Sunday'
    > Ox.formatDate(Ox.test.date, '%a') // Abbreviated weekday
    'Sun'
    > Ox.formatDate(Ox.test.date, '%B') // Full month
    'January'
    > Ox.formatDate(Ox.test.date, '%b') // Abbreviated month
    'Jan'
    > Ox.formatDate(Ox.test.date, '%C') // Century
    '20'
    > Ox.formatDate(Ox.test.date, '%c') // US time and date
    '01/02/05 12:03:04 AM'
    > Ox.formatDate(Ox.test.date, '%D') // US date
    '01/02/05'
    > Ox.formatDate(Ox.test.date, '%d') // Zero-padded day of the month
    '02'
    > Ox.formatDate(Ox.test.date, '%e') // Space-padded day of the month
    ' 2'
    > Ox.formatDate(Ox.test.date, '%F') // Date
    '2005-01-02'
    > Ox.formatDate(Ox.test.date, '%G') // Full ISO-8601 year
    '2004'
    > Ox.formatDate(Ox.test.date, '%g') // Abbreviated ISO-8601 year
    '04'
    > Ox.formatDate(Ox.test.date, '%H') // Zero-padded hour (24-hour clock)
    '00'
    > Ox.formatDate(Ox.test.date, '%h') // Abbreviated month
    'Jan'
    > Ox.formatDate(Ox.test.date, '%I') // Zero-padded hour (12-hour clock)
    '12'
    > Ox.formatDate(Ox.test.date, '%j') // Zero-padded day of the year
    '002'
    > Ox.formatDate(Ox.test.date, '%k') // Space-padded hour (24-hour clock)
    ' 0'
    > Ox.formatDate(Ox.test.date, '%l') // Space-padded hour (12-hour clock)
    '12'
    > Ox.formatDate(Ox.test.date, '%M') // Zero-padded minute
    '03'
    > Ox.formatDate(Ox.test.date, '%m') // Zero-padded month
    '01'
    > Ox.formatDate(Ox.test.date, '%n') // Newline
    '\n'
    > Ox.formatDate(Ox.test.date, '%p') // AM or PM
    'AM'
    > Ox.formatDate(Ox.test.date, '%Q') // Quarter of the year
    '1'
    > Ox.formatDate(Ox.test.date, '%R') // Zero-padded hour and minute
    '00:03'
    > Ox.formatDate(Ox.test.date, '%r') // US time
    '12:03:04 AM'
    > Ox.formatDate(Ox.test.date, '%S') // Zero-padded second
    '04'
    > Ox.formatDate(Ox.test.date, '%s', true) // Number of seconds since the Epoch
    '1104620584'
    > Ox.formatDate(Ox.test.date, '%T') // Time
    '00:03:04'
    > Ox.formatDate(Ox.test.date, '%t') // Tab
    '\t'
    > Ox.formatDate(Ox.test.date, '%U') // Zero-padded week of the year (00-53, Sunday as first day)
    '01'
    > Ox.formatDate(Ox.test.date, '%u') // Decimal weekday (1-7, Monday as first day)
    '7'
    > Ox.formatDate(Ox.test.date, '%V') // Zero-padded ISO-8601 week of the year
    '53'
    > Ox.formatDate(Ox.test.date, '%v') // Formatted date
    ' 2-Jan-2005'
    > Ox.formatDate(Ox.test.date, '%W') // Zero-padded week of the year (00-53, Monday as first day)
    '00'
    > Ox.formatDate(Ox.test.date, '%w') // Decimal weekday (0-6, Sunday as first day)
    '0'
    > Ox.formatDate(Ox.test.date, '%X') // US time
    '12:03:04 AM'
    > Ox.formatDate(Ox.test.date, '%x') // US date
    '01/02/05'
    > Ox.formatDate(Ox.test.date, '%Y') // Full year
    '2005'
    > Ox.formatDate(Ox.test.date, '%y') // Abbreviated year
    '05'
    > Ox.formatDate(Ox.test.date, '%Z', true) // Time zone name
    'UTC'
    > Ox.formatDate(Ox.test.date, '%z', true) // Time zone offset
    '+0000'
    > Ox.formatDate(Ox.test.date, '%+', true) // Formatted date and time
    'Sun Jan  2 00:03:04 CET 2005'
    > Ox.formatDate(Ox.test.date, '%%')
    '%'
@*/

Ox.formatDate = function(date, str, utc) {
    // fixme: date and utc are optional, date can be date, number or string
    date = Ox.makeDate(date);
    var format = [
        ['%', function() {return '%{%}';}],
        ['c', function() {return '%x %X';}],
        ['X', function() {return '%r';}],
        ['x', function() {return '%D';}],
        ['D', function() {return '%m/%d/%y';}],
        ['F', function() {return '%Y-%m-%d';}],
        ['h', function() {return '%b';}],
        ['R', function() {return '%H:%M';}],
        ['r', function() {return '%I:%M:%S %p';}],
        ['T', function() {return '%H:%M:%S';}],
        ['v', function() {return '%e-%b-%Y';}],
        ['\\+', function() {return '%a %b %e %H:%M:%S %Z %Y';}],
        ['A', function(d) {return Ox.WEEKDAYS[(Ox.getDay(d, utc) + 6) % 7];}],
        ['a', function(d) {return Ox.SHORT_WEEKDAYS[(Ox.getDay(d, utc) + 6) % 7];}],
        ['B', function(d) {return Ox.MONTHS[Ox.getMonth(d, utc)];}],
        ['b', function(d) {return Ox.SHORT_MONTHS[Ox.getMonth(d, utc)];}],
        ['C', function(d) {return Math.floor(Ox.getFullYear(d, utc) / 100).toString();}],
        ['d', function(d) {return Ox.pad(Ox.getDate(d, utc), 2);}],
        ['e', function(d) {return Ox.pad(Ox.getDate(d, utc), 2, ' ');}],
        ['G', function(d) {return Ox.getISOYear(d, utc);}],
        ['g', function(d) {return Ox.getISOYear(d, utc).toString().substr(-2);}],
        ['H', function(d) {return Ox.pad(Ox.getHours(d, utc), 2);}],
        ['I', function(d) {return Ox.pad((Ox.getHours(d, utc) + 11) % 12 + 1, 2);}],
        ['j', function(d) {return Ox.pad(Ox.getDayOfTheYear(d, utc), 3);}],
        ['k', function(d) {return Ox.pad(Ox.getHours(d, utc), 2, ' ');}],
        ['l', function(d) {return Ox.pad(((Ox.getHours(d, utc) + 11) % 12 + 1), 2, ' ');}],
        ['M', function(d) {return Ox.pad(Ox.getMinutes(d, utc), 2);}],
        ['m', function(d) {return Ox.pad((Ox.getMonth(d, utc) + 1), 2);}],
        ['p', function(d) {return Ox.AMPM[Math.floor(Ox.getHours(d, utc) / 12)];}],
        ['Q', function(d) {return Math.floor(Ox.getMonth(d, utc) / 4) + 1;}],
        ['S', function(d) {return Ox.pad(Ox.getSeconds(d, utc), 2);}],
        ['s', function(d) {return Math.floor(d.getTime() / 1000);}],
        ['U', function(d) {return Ox.pad(Ox.getWeek(d, utc), 2);}],
        ['u', function(d) {return Ox.getISODay(d, utc);}],
        ['V', function(d) {return Ox.pad(Ox.getISOWeek(d, utc), 2);}],
        ['W', function(d) {return Ox.pad(Math.floor((Ox.getDayOfTheYear(d, utc) +
            (Ox.getFirstDayOfTheYear(d, utc) || 7) - 2) / 7), 2);}],
        ['w', function(d) {return Ox.getDay(d, utc);}],
        ['Y', function(d) {return Ox.getFullYear(d, utc);}],
        ['y', function(d) {return Ox.getFullYear(d, utc).toString().substr(-2);}],
        ['Z', function(d) {return d.toString().split('(')[1].replace(')', '');}],
        ['z', function(d) {return Ox.getTimezoneOffsetString(d);}],
        ['n', function() {return '\n';}],
        ['t', function() {return '\t';}],
        ['\\{%\\}', function() {return '%';}]
    ];
    format.forEach(function(v) {
        var regexp = new RegExp('%' + v[0], 'g');
        if (regexp.test(str)) {
            str = str.replace(regexp, v[1](date));
        }
    });
    return str;
};

/*@
Ox.formatDuration <f> Formats a duration as a string
    > Ox.formatDuration(123456.789, 3)
    "1:10:17:36.789"
    > Ox.formatDuration(12345.6789)
    "03:25:46"
    > Ox.formatDuration(12345.6789, true)
    "0:03:25:46"
    > Ox.formatDuration(3599.999, 3)
    "00:59:59.999"
    > Ox.formatDuration(3599.999)
    "01:00:00"
@*/
Ox.formatDuration = function(sec, dec, format) {
    var format = arguments.length == 3 ? format : (Ox.isString(dec) ? dec : "short"),
        dec = (arguments.length == 3 || Ox.isNumber(dec)) ? dec : 0,
        sec = dec ? sec : Math.round(sec),
        val = [
            Math.floor(sec / 31536000),
            Math.floor(sec % 31536000 / 86400),
            Math.floor(sec % 86400 / 3600),
            Math.floor(sec % 3600 / 60),
            format == "short" ? Ox.formatNumber(sec % 60, dec) : sec % 60
        ],
        str = {
            medium: ["y", "d", "h", "m", "s"],
            long: ["year", "day", "hour", "minute", "second"]
        },
        pad = [0, 3, 2, 2, dec ? dec + 3 : 2];
    while (!val[0] && val.length > (format == "short" ? 3 : 1)) {
        val.shift();
        str.medium.shift();
        str.long.shift();
        pad.shift();
    }
    while (format != "short" && !val[val.length - 1] && val.length > 1) {
        val.pop();
        str.medium.pop();
        str.long.pop();
    }
    return Ox.map(val, function(v, i) {
        return format == "short" ? Ox.pad(v, pad[i]) :
                v + (format == "long" ? " " : "") + str[format][i] +
                (format == "long" && v != 1 ? "s" : "");
    }).join(format == "short" ? ":" : " ");
};

/*@
Ox.formatNumber <f> Formats a number with thousands separators
    > Ox.formatNumber(123456789, 3)
    "123,456,789.000"
    > Ox.formatNumber(-2000000 / 3, 3)
    "-666,666.667"
    > Ox.formatNumber(666666.666)
    "666,667"
@*/
Ox.formatNumber = function(num, dec) {
    // fixme: specify decimal and thousands separators
    var str = Math.abs(num).toFixed(dec || 0),
        spl = str.split('.'),
        arr = [];
    while (spl[0]) {
        arr.unshift(spl[0].substr(-3));
        spl[0] = spl[0].substr(0, spl[0].length - 3);
    }
    spl[0] = arr.join(',');
    return (num < 0 ? '-' : '') + spl.join('.');
};

/*@
Ox.formatOrdinal <f> Formats a number as an ordinal
    > Ox.formatOrdinal(1)
    "1st"
    > Ox.formatOrdinal(2)
    "2nd"
    > Ox.formatOrdinal(3)
    "3rd"
    > Ox.formatOrdinal(4)
    "4th"
    > Ox.formatOrdinal(11)
    "11th"
    > Ox.formatOrdinal(12)
    "12th"
    > Ox.formatOrdinal(13)
    "13th"
@*/
Ox.formatOrdinal = function(num) {
    var str = num.toString(),
        end = str[str.length - 1],
        ten = str.length > 1 && str[str.length - 2] == '1';
    if (end == '1' && !ten) {
        str += 'st';
    } else if (end == '2' && !ten) {
        str += 'nd';
    } else if (end == '3' && !ten) {
        str += 'rd';
    } else {
        str += 'th';
    }
    return str;
};

/*@
Ox.formatPercent <f> Formats the relation of two numbers as a percentage
    > Ox.formatPercent(1, 1000, 2)
    "0.10%"
@*/
Ox.formatPercent = function(num, total, dec) {
    return Ox.formatNumber(num / total * 100, dec) + '%'
};

/*@
Ox.formatResolution <f> Formats two values as a resolution
    > Ox.formatResolution([1920, 1080], 'px')
    "1920 x 1080 px"
@*/
// fixme: should be formatDimensions
Ox.formatResolution = function(arr, str) {
    return arr[0] + ' x ' + arr[1] + (str ? ' ' + str : '');
}

/*@ 
Ox.formatString <f> Basic string formatting
    > Ox.formatString('{0}{1}', ['foo', 'bar'])
    'foobar'
    > Ox.formatString('{a}{b}', {a: 'foo', b: 'bar'})
    'foobar'
@*/

Ox.formatString = function (str, obj) {
    return str.replace(/\{([^}]+)\}/g, function(str, match) {
        return obj[match];
    });
}

/*@
Ox.formatValue <f> Formats a numerical value
    > Ox.formatValue(0, "B")
    "0 KB"
    > Ox.formatValue(123456789, "B")
    "123.5 MB"
    > Ox.formatValue(1234567890, "B", true)
    "1.15 GiB"
@*/
// fixme: is this the best name?
Ox.formatValue = function(num, str, bin) {
    var base = bin ? 1024 : 1000,
        len = Ox.PREFIXES.length,
        val;
    Ox.forEach(Ox.PREFIXES, function(chr, i) {
        if (num < Math.pow(base, i + 2) || i == len - 1) {
            val = Ox.formatNumber(num / Math.pow(base, i + 1), i) +
                ' ' + chr + (bin ? 'i' : '') + str;
            return false;
        }
    });
    return val;
};

/*@
Ox.formatUnit <f> Formats a number with a unit
@*/
Ox.formatUnit = function(num, str) {
    return num + ' ' + str;
};

//@ Geo ------------------------------------------------------------------------

(function() {

    // fixme: make all this work with different types of "points"
    // i.e. {lat, lng}, [lat, lng]

    function rad(point) {
        return {
            lat: Ox.rad(point.lat),
            lng: Ox.rad(point.lng)
        };
    }

    /*@
    Ox.crossesDateline <f> Returns true if a given rectangle crosses the dateline
    @*/
    Ox.crossesDateline = function(point0, point1) {
        return point0.lng > point1.lng;
    }

    /*@
    Ox.getArea <f> Returns the area in square meters of a given rectancle
    @*/
    Ox.getArea = function(point0, point1) {
        /*
            area of a ring between two latitudes:
            2 * PI * r^2 * abs(sin(lat0) - sin(lat1))
            see http://mathforum.org/library/drmath/view/63767.html
        */
        /*
        2 * Math.PI *
        Math.pow(Ox.EARTH_RADIUS, 2) *
        Math.abs(Math.sin(Ox.rad(0)) - Math.sin(Ox.rad(1))) *
        Math.abs(Ox.rad(0) - Ox.rad(1)) /
        (2 * Math.PI)
        */
        if (Ox.crossesDateline(point0, point1)) {
            point1.lng += 360;
        }
        var point0 = rad(point0),
            point1 = rad(point1);
        return Math.pow(Ox.EARTH_RADIUS, 2) *
            Math.abs(Math.sin(point0.lat) - Math.sin(point1.lat)) *
            Math.abs(point0.lng - point1.lng);
    };

    /*@
    Ox.getBearing <f> Returns the bearing from one point to another
        > Ox.getBearing({lat: -45, lng: 0}, {lat: 45, lng: 0})
        0
    @*/
    Ox.getBearing = function(point0, point1) {
        var point0 = rad(point0),
            point1 = rad(point1),
            x = Math.cos(point0.lat) * Math.sin(point1.lat) -
                Math.sin(point0.lat) * Math.cos(point1.lat) *
                Math.cos(point1.lng - point0.lng),
            y = Math.sin(point1.lng - point0.lng) *
                Math.cos(point1.lat);
        return (Ox.deg(Math.atan2(y, x)) + 360) % 360;
    };

    /*@
    Ox.getCenter <f> Returns the center of a recangle on a spehre
        > Ox.getCenter({lat: -45, lng: -90}, {lat: 45, lng: 90})
        {lat: 0, lng: 0}
    @*/
    Ox.getCenter = function(point0, point1) {
        var point0 = rad(point0),
            point1 = rad(point1),
            x = Math.cos(point1.lat) *
                Math.cos(point1.lng - point0.lng),
            y = Math.cos(point1.lat) *
                Math.sin(point1.lng - point0.lng),
            d = Math.sqrt(
                Math.pow(Math.cos(point0.lat) + x, 2) + Math.pow(y, 2)
            ),
            lat = Ox.deg(
                Math.atan2(Math.sin(point0.lat) + Math.sin(point1.lat), d)
            ),
            lng = Ox.deg(
                point0.lng + Math.atan2(y, Math.cos(point0.lat) + x)
            );
        return {lat: lat, lng: lng};
    };

    /*@
    Ox.getDegreesPerMeter <f> Returns degrees per meter at a given latitude
        > 360 / Ox.getDegreesPerMeter(0)
        Ox.EARTH_CIRCUMFERENCE
    @*/
    Ox.getDegreesPerMeter = function(lat) {
        return 360 / Ox.EARTH_CIRCUMFERENCE / Math.cos(lat * Math.PI / 180);
    };

    /*@
    Ox.getDistance <f> Returns the distance in meters between two points
        > Ox.getDistance({lat: -45, lng: -90}, {lat: 45, lng: 90}) * 2
        Ox.EARTH_CIRCUMFERENCE
    @*/
    Ox.getDistance = function(point0, point1) {
        var point0 = rad(point0),
            point1 = rad(point1);
        return Math.acos(
    	    Math.sin(point0.lat) * Math.sin(point1.lat) + 
    	    Math.cos(point0.lat) * Math.cos(point1.lat) *
    	    Math.cos(point1.lng - point0.lng)
    	) * Ox.EARTH_RADIUS;
    };

    /*@
    Ox.getLatLngByXY <f> Returns lat/lng for a given x/y on a 1x1 mercator projection
        > Ox.values(Ox.getLatLngByXY({x: 0.5, y: 0.5}))
        {lat: 0, lng: 0}
    @*/
    Ox.getLatLngByXY = function(xy) {
        function getVal(val) {
            return (val - 0.5) * 2 * Math.PI;
        }
        return {
            lat: -Ox.deg(Math.atan(Ox.sinh(getVal(xy.y)))),
            lng: Ox.deg(getVal(xy.x))
        }
    };

    /*@
    Ox.getMetersPerDegree <f> Returns meters per degree at a given latitude
        > Ox.getMetersPerDegree(0) * 360
        Ox.EARTH_CIRCUMFERENCE
    @*/
    Ox.getMetersPerDegree = function(lat) {
        return Math.cos(lat * Math.PI / 180) * Ox.EARTH_CIRCUMFERENCE / 360;
    };

    /*@
    Ox.getXYByLatLng <f> Returns x/y on a 1x1 mercator projection for a given lat/lng
        > Ox.getXYByLatLng({lat: 0, lng: 0})
        {x: 0.5, y: 0.5}
    @*/
    Ox.getXYByLatLng = function(latlng) {
        function getVal(val) {
            return (val / (2 * Math.PI) + 0.5)
        }
        return {
            x: getVal(Ox.rad(latlng.lng)),
            y: getVal(Ox.asinh(Math.tan(Ox.rad(-latlng.lat))))
        };
    };

}());

//@ Ox.Line <f> (undocumented)
Ox.Line = function(point0, point1) {

    var self = {
            points: [point0, point1]
        },
        that = this;

    function rad() {
        return self.points.map(function(point) {
            return {
                lat: Ox.rad(point.lat()),
                lng: Ox.rad(point.lng())
            };
        });
    }

    that.getArea = function() {
        
    };

    that.getBearing = function() {
    };

    that.getDistance = function() {
        var points = rad();
        return Math.acos(
    	    Math.sin(point[0].lat) * Math.sin(point[1].lat) + 
    	    Math.cos(point[0].lat) * Math.cos(point[1].lat) *
    	    Math.cos(point[1].lng - point[0].lng)
    	) * Ox.EARTH_RADIUS; 
    };

    that.getMidpoint = function() {
        var points = rad(),
            x = Math.cos(point[1].lat) *
                Math.cos(point[1].lng - point[0].lng),
            y = Math.cos(point[1].lat) *
                Math.sin(point[1].lng - point[0].lng),
            d = Math.sqrt(
                Math.pow(Math.cos(point[0].lat) + x, 2) + Math.pow(y, 2)
            ),
            lat = Ox.deg(
                Math.atan2(Math.sin(points[0].lat) + Math.sin(points[1].lat), d)
            ),
            lng = Ox.deg(
                points[0].lng + Math.atan2(y, math.cos(points[0].lat) + x)
            );
        return new Point(lat, lng);
    };

    that.points = function() {
        
    };

    return that;

};

//@ Ox.Point <f> (undocumented)
Ox.Point = function(lat, lng) {

    var self = {lat: lat, lng: lng},
        that = this;

    that.lat = function() {
        
    };

    that.latlng = function() {
        
    };

    that.lng = function() {
        
    };

    that.getMetersPerDegree = function() {
        return Math.cos(self.lat * Math.PI / 180) *
            Ox.EARTH_CIRCUMFERENCE / 360;
    }

    that.getXY = function() {
        return [
            getXY(Ox.rad(self.lng)),
            getXY(Ox.asinh(Math.tan(Ox.rad(-self.lat))))
        ];
    };

    return that;

};

//@ Ox.Rectangle <f> (undocumented)
Ox.Rectangle = function(point0, point1) {

    var self = {
            points: [
                new Point(
                    Math.min(point0.lat(), point1.lat()),
                    point0.lng()
                ),
                new Point(
                    Math.max(point0.lat(), point1.lat()),
                    point1.lng()
                )
            ]
        },
        that = this;

    that.contains = function(rectangle) {
        
    }

    that.crossesDateline = function() {
        return self.points[0].lng > self.points[1].lng;
    }

    that.getCenter = function() {
        return new Ox.Line(self.points[0], self.points[1]).getMidpoint();
    };

    that.intersects = function(rectangle) {
        
    };

    return that;

};

//@ HTML -----------------------------------------------------------------------

/*@
Ox.parseEmailAddresses <f> Takes HTML and turns e-mail addresses into links
@*/
// fixme: no tests
Ox.parseEmailAddresses = function(html) {
    return html.replace(
        /\b([0-9A-Z\.\+\-_]+@(?:[0-9A-Z\-]+\.)+[A-Z]{2,6})\b/gi,
        '<a href="mailto:$1" title="mailto:$1">$1</a>'
    );
};

/*@
Ox.parseHTML <f> Takes HTML from an untrusted source and returns something sane
    > Ox.parseHTML('http://foo.com, bar')
    '<a href="http://foo.com" title="http://foo.com">foo.com</a>, bar'
    > Ox.parseHTML('(see: www.foo.com)')
    '(see: <a href="http://www.foo.com" title="http://www.foo.com">www.foo.com</a>)'
    > Ox.parseHTML('foo@bar.com')
    '<a href="mailto:foo@bar.com" title="mailto:foo@bar.com">foo@bar.com</a>'
    > Ox.parseHTML('<a href="http://foo.com" onmouseover="alert()">foo</a>')
    '<a href="http://foo.com" title="http://foo.com">foo</a>'
    > Ox.parseHTML('<a href="javascript:alert()">foo</a>')
    '&lt;a href=&quot;javascript:alert()&quot;&gt;foo&lt;/a&gt;'
    > Ox.parseHTML('[http://foo.com foo]')
    '<a href="http://foo.com" title="http://foo.com">foo</a>'
    > Ox.parseHTML('<rtl>foo</rtl>')
    '<div style="direction: rtl">foo</div>'
    > Ox.parseHTML('<script>alert()</script>')
    '&lt;script&gt;alert()&lt;/script&gt;'    
@*/
Ox.parseHTML = (function() {
    var defaultTags = [
            'a', 'b', 'blockquote', 'cite', 'code',
            'del', 'em', 'i', 'img', 'ins',
            'li', 'ol', 'q', 'rtl', 's',
            'strong', 'sub', 'sup', 'ul', '[]'
        ],
        parse = {
            a: {
                '<a [^<>]*?href="(https?:\/\/.+?)".*?>': '<a href="{1}" title="{1}">',
                '<\/a>': '</a>'
            },
            img: {
                '<img [^<>]*?src="(https?:\/\/.+?)".*?>': '<img src="{1}">'
            },
            rtl: {
                '<rtl>': '<div style="direction: rtl">',
                '<\/rtl>': '</div>'
            },
            '*': function(tag) {
                var ret = {};
                ret['<(/?' + tag + ')>'] = '<{1}>';
                return ret;
            }
        },
        tab = '\t';

    return function(html, tags, wikilinks) {
        var matches = [],
            tags = tags || defaultTags;
        // html = Ox.clean(html); fixme: can this be a parameter?
        if (tags.indexOf('[]') > -1) {
            html = html.replace(/\[(https?:\/\/.+?) (.+?)\]/gi, '<a href="$1">$2</a>');
            tags = tags.filter(function(tag) {
                return tag != '[]';
            });
        }
        tags.forEach(function(tag) {
            var p = parse[tag] || parse['*'](tag);
            Ox.forEach(p, function(replace, regexp) {
                html = html.replace(new RegExp(regexp, 'gi'), function() {
                    matches.push(Ox.formatString(replace, arguments));
                    return tab + (matches.length - 1) + tab; 
                });
            });
        });
        html = Ox.encodeHTML(html);
        html = Ox.parseURLs(html);
        html = Ox.parseEmailAddresses(html);
        matches.forEach(function(match, i) {
            html = html.replace(new RegExp(tab + i + tab, 'gi'), match);
        });
        html = html.replace(/\n/g, '<br/>\n')
        // close extra opening (and remove extra closing) tags
        // return $('<div>').html(html).html();
        // fixme: this converts '&quot;' to '"' 
        return Ox.element('<div>').html(html).html();
    }

}());

/*@
Ox.parseURL <f> Takes a URL, returns its components
    (url) -> <o> URL components
    url <s> URL
    <script>
        Ox.test.object = Ox.parseURL('http://www.foo.com:8080/bar/index.html?a=0&b=1#c');
    </script>
    > Ox.test.object.hash
    '#c'
    > Ox.test.object.host
    'www.foo.com:8080'
    > Ox.test.object.hostname
    'www.foo.com'
    > Ox.test.object.origin
    'http://www.foo.com:8080'
    > Ox.test.object.pathname
    '/bar/index.html'
    > Ox.test.object.port
    '8080'
    > Ox.test.object.protocol
    'http:'
    > Ox.test.object.search
    '?a=0&b=1'
@*/
Ox.parseURL = (function() {
    // fixme: leak memory, like now, or create every time? ... benchmark??
    var a = document.createElement('a'),
        keys = ['hash', 'host', 'hostname', 'origin',
            'pathname', 'port', 'protocol', 'search'];
    return function(str) {
        var ret = {};
        a.href = str;
        keys.forEach(function(key) {
            ret[key] = a[key];
        });
        return ret;
    };
}());

/*@
Ox.parseURLs <f> Takes HTML and turns URLs into links
@*/
// fixme: is parseURLs the right name?
// fixme: no tests
Ox.parseURLs = function(html) {
    return html.replace(
        /\b((https?:\/\/|www\.).+?)([\.,:;!\?\)\]]*?(\s|$))/gi,
        function(str, url, pre, end) {
            url = (pre == 'www.' ? 'http://' : '' ) + url;
            return Ox.formatString(
                '<a href="{url}" title="{url}">{host}</a>{end}',
                {
                    end: end,
                    host: Ox.parseURL(url).hostname,
                    url: url
                }
            );
        }
    );
};

//@ JavaScript -----------------------------------------------------------------

/*@
Ox.doc <f> Generates documentation for annotated JavaScript
    (file, callback) -> <u> undefined
    file <s> JavaScript file
    callback <f> Callback function
        doc <[o]> Array of doc objects
            arguments <[o]|u> Arguments (array of doc objects)
                Present if the <code>type</code> of the item is
                <code>"function"</code>.
            description <s|u> Multi-line description with optional markup
                See Ox.parseHTML for details
            events <[o]|u> Events (array of doc objects)
                Present if the item fires any events
            file <s> File name
            line <n> Line number
            name <s> Name of the item
            properties <[o]|u> Properties (array of doc objects)
                Present if the <code>type</code> of the item is
                <code>"event"</code>, <code>"function"</code>
                or <code>"object"</code>.
            section <s|u> Section in the file
            source <[o]> Source code (array of tokens)
                length <n> Length of the token
                offset <n> Offset of the token
                type <s> Type of the token
                    See Ox.tokenize for list of types
            summary <s> One-line summary
            usage <[o]> Usage (array of doc objects)
                Present if the <code>type</code> of the item is
                <code>"function"</code>.
            type <s> Type of the item
            
    (source) <a> Array of documentation objects
    source <s> JavaScript source code
    # > Ox.doc("//@ Ox.foo <string> just some string")
    # [{"name": "Ox.foo", "summary": "just some string", "type": "string"}]
@*/

Ox.doc = (function() {
    // fixme: dont require the trailing '@'
    var re = {
            item: /^(.+?) <(.+?)> (.+)$/,
            multiline: /^\/\*\@.*?\n([\w\W]+)\n.*?\@\*\/$/,
            script: /\n(\s*<script>s*\n[\w\W]+\n\s*<\/script>s*)/g,
            singleline: /^\/\/@\s*(.*?)\s*$/,
            test: /\n(\s*> .+\n.+?)/g,
            usage: /\(.*?\)/
        },
        types = {
            a: 'array', b: 'boolean', d: 'date',
            e: 'element', f: 'function', n: 'number',
            o: 'object', r: 'regexp', s: 'string',
            u: 'undefined', '*': 'any', '!': 'event'
        };
    function decodeLinebreaks(match, submatch) {
        return (submatch || match).replace(/\u21A9/g, '\n');
    }
    function encodeLinebreaks(match, submatch) {
        return '\n' + (submatch || match).replace(/\n/g, '\u21A9');
    }
    function getIndent(str) {
        var indent = -1;
        while (str[++indent] == ' ') {}
        return indent;
    }
    function parseItem(str) {
        var matches = re.item(str);
        // to tell a variable with default value, like
        //     name <string|'<a href="...">foo</a>'> summary
        // from a line of description with tags, like
        //     some <a href="...">description</a> text
        // we need to check if there is either no forward slash
        // or if the second last char is a single or double quote
        return matches && (
            matches[2].indexOf('/') == -1 ||
            '\'"'.indexOf(matches[2].substr(-2, 1)) > -1
        ) ? Ox.extend({
            name: parseName(matches[1].trim()),
            summary: matches[3].trim()
        }, parseType(matches[2])) : null;
    }
    function parseName(str) {
        var matches = re.usage(str);
        return matches ? matches[0] : str;
    }
    function parseNode(node) {
        var item = parseItem(node.line), subitem;
        node.nodes && node.nodes.forEach(function(node) {
            var key, line = node.line, subitem;
            if (!/^#/.test(node.line)) {
                if (/^<script>/.test(line)) {
                    item.examples = [parseScript(line)];
                } else if (/^>/.test(line)) {
                    item.examples = item.examples || [];
                    item.examples.push(parseTest(line));
                } else if ((subitem = parseItem(line))) {
                    if (/^\(/.test(subitem.name)) {
                        item.usage = item.usage || [];
                        item.usage.push(parseNode(node));
                    } else if (subitem.types[0] == 'event') {
                        item.events = item.events || [];
                        item.events.push(parseNode(node));                            
                    } else {
                        key = item.types[0] == 'function' ?
                            'arguments' : 'properties'
                        item[key] = item[key] || [];
                        item[key].push(parseNode(node));                            
                    }
                } else {
                    item.description = item.description ?
                        item.description + ' ' + line : line
                }
            }
        });
        return item;
    }
    function parseScript(str) {
        // remove script tags and extra indentation
        var lines = decodeLinebreaks(str).split('\n'),
            indent = getIndent(lines[1]);
        return {
            statement: Ox.map(lines, function(line, i) {
                return i && i < lines.length - 1 ?
                    line.substr(indent) : null;
            }).join('\n')
        };
    }
    function parseTest(str) {
        var lines = decodeLinebreaks(str).split('\n');
        return {
            statement: lines[0].substr(2),
            result: lines[1].trim()
        };
    }
    function parseTokens(tokens, includeLeading) {
        // fixme: do not strip whitespace from the beginning of the first line of the items' source
        var leading = [],
            tokens_ = [];
        tokens.forEach(function(token) {
            if (['linebreak', 'whitespace'].indexOf(token.type) > -1) {
                includeLeading && leading.push(token);
            } else {
                tokens_ = Ox.merge(tokens_, leading, [token]);
                leading = [];
                includeLeading = true;
            }
        });
        return tokens_;
    }
    function parseTree(lines) {
        // parses indented lines into a tree structure, like
        // {line: "...", nodes: [{line: "...", nodes: [...]}]}
        var branches = [],
            indent,
            node = {
                // chop the root line
                line: lines.shift().trim()
            };
        if (lines.length) {
            indent = getIndent(lines[0]);
            lines.forEach(function(line) {
                if (getIndent(line) == indent) {
                    // line is a child,
                    // make it the root line of a new branch
                    branches.push([line]);
                } else {
                    // line is a descendant of the last child,
                    // add it to the last branch
                    branches[branches.length - 1].push(line);
                }
            });
            node.nodes = branches.map(function(lines) {
                return parseTree(lines);
            });
        }
        return node;
    }
    function parseType(str) {
        // returns {types: [""]}
        // or {types: [""], default: ""}
        // or {types: [""], parent: ""}
        var isArray,
            ret = {types: []},
            split,
            type;
        // only split by ':' if there is no default string value
        if ('\'"'.indexOf(str.substr(-2, 1)) == -1) {
            split = str.split(':');
            str = split[0];
            if (split.length == 2) {
                ret.parent = split[1];
            }
        }
        str.split('|').forEach(function(str) {
            var unwrapped = unwrap(str);
            if (unwrapped in types) {
                ret.types.push(wrap(types[unwrapped]))
            } else if (
                (type = Ox.filter(Ox.values(types), function(type) {
                    return Ox.startsWith(type, unwrapped);
                })).length
            ) {
                ret.types.push(wrap(type[0]));
            } else {
                ret['default'] = str;
            }
        });
        function unwrap(str) {
            return (isArray = /^\[.+\]$/.test(str)) ?
                str = str.substr(1, str.length - 2) : str;
        }
        function wrap(str) {
            return isArray ?
                'array[' + str + (str != 'any' ? 's' : '') + ']' : str;
        }
        return ret;
    }
    return function(file, callback) {
        Ox.get(file, function(source) {
            var blocks = [],
                items = [],
                section = '',
                tokens = [];
            Ox.tokenize(source).forEach(function(token) {
                var match;
                token.source = source.substr(token.offset, token.length);
                if (token.type == 'comment' && (match =
                    re.multiline(token.source) || re.singleline(token.source)
                )) {
                    blocks.push(match[1]);
                    tokens.push([]);
                } else if (tokens.length) {
                    tokens[tokens.length - 1].push(token);
                }
            });
            /*
            var blocks = Ox.map(Ox.tokenize(source), function(token) {
                    // filter out tokens that are not comments
                    // or don't match the doc comment pattern
                    var match;
                    token.source = source.substr(token.offset, token.length);
                    return token.type == 'comment' && (match = 
                        re.multiline(token.source) || re.singleline(token.source)
                    ) ? match[1] : null;
                }),
                items = [];
            */
            blocks.forEach(function(block, i) {
                var item, lastItem,
                    lines = block
                        .replace(re.script, encodeLinebreaks)
                        .replace(re.test, encodeLinebreaks)
                        .split('\n'),
                    tree = parseTree(lines);
                if (re.item.test(tree.line)) {
                    // parse the tree's root node
                    item = parseNode(tree);
                    item.file = file;
                    if (section) {
                        item.section = section;
                    }
                    if (/^[A-Z]/.test(item.name)) {
                        // main item
                        item.source = parseTokens(tokens[i]);
                        item.line = source.substr(0, item.source[0].offset)
                            .split('\n').length;
                        items.push(item);
                    } else {
                        // property of a function item
                        lastItem = items[items.length - 1];
                        lastItem.properties = lastItem.properties || [];
                        lastItem.properties.push(item);
                        // include leading linebreaks and whitespace
                        lastItem.source = Ox.merge(
                            lastItem.source, parseTokens(tokens[i], true)
                        );
                    }
                } else {
                    section = tree.line.split(' ')[0]
                }
            });
            callback(items);
        });
    }
}());

/*@
Ox.minify <f> Minifies JavaScript (experimental!)
@*/
Ox.minify = function(source) {
    var tokens = Ox.tokenize(source)
    return Ox.map(tokens, function(token, i) {
        var ret = source.substr(token.offset, token.type == 'whitespace' ? 1 : token.length);
        if (token.type == 'comment') {
            ret = null;
        } else if (
            token.type == 'linebreak' && (
                i == 0 || i == tokens.length - 1 ||
                tokens[i - 1].type == 'linebreak' ||
                tokens[i + 1].type == 'linebreak'
            )
        ) {
            ret = null;
        } else if (
            token.type == 'whitespace' && (
                i == 0 || i == tokens.length - 1 ||
                tokens[i - 1].type != 'keyword' || (
                    tokens[i + 1].type == 'operator'
                )
            )
        ) {
            ret = null;
        }
        return ret;
    }).join('');
};

/*@
Ox.test <f> Takes JavaScript, runs inline tests, returns results
@*/
Ox.test = function(file, callback) {
    Ox.doc(file, function(items) {
        var tests = [];
        items.forEach(function(item) {
            item.examples && item.examples.forEach(function(example) {
                var actual = eval(example.statement);
                if (example.result) {
                    tests.push({
                        actual: JSON.stringify(actual),
                        expected: example.result,
                        name: item.name,
                        section: item.section,
                        statement: example.statement,
                        success: Ox.isEqual(eval('Ox.test.result = ' + example.result), actual)
                    });
                }
            });
        });
        callback(tests);
    });
};

/*@
Ox.tokenize <f> Tokenizes JavaScript
    (source) -> <[o]> Array of tokens
        length <n> Length of the token
        offset <n> Offset of the token
        type <s> Type of the token
            Type can be <code>"comment"</code>, <code>"constant"</code>,
            <code>"identifier"</code>, <code>"keyword"</code>,
            <code>"linebreak"</code>, <code>"method"</code>,
            <code>"number"</code>, <code>"object"</code>, 
            <code>"operator"</code>, <code>"property"</code>,
            <code>"regexp"</code>, <code>"string"</code>
            or <code>"whitespace"</code>
    source <s> JavaScript source code
@*/
Ox.tokenize = (function() {

    // see https://github.com/mozilla/narcissus/blob/master/lib/jslex.js
    // and https://developer.mozilla.org/en/JavaScript/Reference

    var identifier = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_',
        linebreak = '\n\r',
        number = '0123456789',
        operator = [
            // arithmetic
            '+', '-', '*', '/', '%', '++', '--',
            // assignment
            '=', '+=', '-=', '*=', '/=', '%=',
            '&=', '|=', '^=', '<<=', '>>=', '>>>=',
            // bitwise
            '&', '|', '^', '~', '<<', '>>', '>>>',
            // comparison
            '==', '!=', '===', '!==', '>', '>=', '<', '<=',
            // conditional
            '?', ':',
            // grouping
            '(', ')', '[', ']', '{', '}',
            // logical
            '&&', '||', '!',
            // other
            '.', ',', ';'
        ],
        whitespace = ' \t',
        word = {
            constant: [
                // Math
                'E', 'LN2', 'LN10', 'LOG2E', 'LOG10E', 'PI', 'SQRT1_2', 'SQRT2',
                // Number
                'MAX_VALUE', 'MIN_VALUE', 'NEGATIVE_INFINITY', 'POSITIVE_INFINITY'
            ],
            keyword: [
                'break',
                'case', 'catch', 'class', 'const', 'continue',
                'debugger', 'default', 'delete', 'do',
                'else', 'enum', 'export', 'extends',
                'false', 'finally', 'for', 'function',
                'if', 'implements', 'import', 'in', 'instanceof', 'interface',
                'let', 'module',
                'new', 'null',
                'package', 'private', 'protected', 'public',
                'return',
                'super', 'switch', 'static',
                'this', 'throw', 'true', 'try', 'typeof',
                'var', 'void',
                'yield',
                'while', 'with',
            ],
            method: [
                // Array
                'concat',
                'every',
                'filter', 'forEach',
                'join',
                'lastIndexOf',
                'indexOf', 'isArray',
                'map',
                'pop', 'push',
                'reduce', 'reduceRight', 'reverse',
                'shift', 'slice', 'some', 'sort', 'splice',
                'unshift',
                // Date
                'getDate', 'getDay', 'getFullYear', 'getHours',
                'getMilliseconds', 'getMinutes', 'getMonth', 'getSeconds',
                'getTime', 'getTimezoneOffset',
                'getUTCDate', 'getUTCDay', 'getUTCFullYear', 'getUTCHours',
                'getUTCMilliseconds', 'getUTCMinutes', 'getUTCMonth', 'getUTCSeconds',
                'now',
                'parse',
                'setDate', 'setFullYear', 'setHours', 'setMilliseconds',
                'setMinutes', 'setMonth', 'setSeconds', 'setTime',
                'setUTCDate', 'setUTCFullYear', 'setUTCHours', 'setUTCMilliseconds',
                'setUTCMinutes', 'setUTCMonth', 'setUTCSeconds',
                'toDateString', 'toJSON', 'toLocaleDateString', 'toLocaleString',
                'toLocaleTimeString', 'toTimeString', 'toUTCString',
                'UTC',
                // Function
                'apply', 'bind', 'call', 'isGenerator',
                // JSON
                'parse', 'stringify',
                // Math
                'abs', 'acos', 'asin', 'atan', 'atan2',
                'ceil', 'cos',
                'exp',
                'floor',
                'log',
                'max', 'min',
                'pow',
                'random', 'round',
                'sin', 'sqrt',
                'tan',
                // Number
                'toExponential', 'toFixed', 'toLocaleString', 'toPrecision',
                // Object
                'create',
                'defineProperty', 'defineProperties',
                'freeze',
                'getOwnPropertyDescriptor', 'getOwnPropertyNames', 'getPrototypeOf',
                'hasOwnProperty',
                'isExtensible', 'isFrozen', 'isPrototypeOf', 'isSealed',
                'keys',
                'preventExtensions', 'propertyIsEnumerable',
                'seal',
                'toLocaleString', 'toString',
                'valueOf',
                // RegExp
                'exec', 'test',
                // String
                'charAt', 'charCodeAt', 'concat',
                'fromCharCode',
                'indexOf',
                'lastIndexOf', 'localeCompare',
                'match',
                'replace',
                'search', 'slice', 'split', 'substr', 'substring',
                'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toUpperCase', 'trim',
                // Window
                'addEventListener', 'alert', 'atob',
                'blur', 'btoa',
                'clearInterval', 'clearTimeout', 'close', 'confirm',
                'dispatchEvent',
                'escape',
                'find', 'focus',
                'getComputedStyle', 'getSelection',
                'moveBy', 'moveTo',
                'open',
                'postMessage', 'print', 'prompt',
                'removeEventListener', 'resizeBy', 'resizeTo',
                'scroll', 'scrollBy', 'scrollTo',
                'setCursor', 'setInterval', 'setTimeout', 'stop',
                'unescape'
            ],
            object: [
                'Array',
                'Boolean',
                'Date', 'decodeURI', 'decodeURIComponent',
                'encodeURI', 'encodeURIComponent', 'Error', 'eval', 'EvalError',
                'Function',
                'Infinity', 'isFinite', 'isNaN',
                'JSON',
                'Math',
                'NaN', 'Number',
                'Object',
                'parseFloat', 'parseInt',
                'RangeError', 'ReferenceError', 'RegExp',
                'String', 'SyntaxError',
                'TypeError',
                'undefined', 'URIError',
                'window'
            ],
            property: [
                // Function
                'constructor', 'length', 'prototype',
                // RegExp
                'global', 'ignoreCase', 'lastIndex', 'multiline', 'source',
                // Window
                'applicationCache',
                'closed', 'content', 'crypto',
                'defaultStatus', 'document',
                'frameElement', 'frames',
                'history',
                'innerHeight', 'innerWidth',
                'length', 'location', 'locationbar', 'localStorage',
                'menubar',
                'name', 'navigator',
                'opener', 'outerHeight', 'outerWidth',
                'pageXOffset', 'pageYOffset', 'parent', 'personalbar',
                'screen', 'screenX', 'screenY', 'scrollbars', 'scrollX', 'scrollY',
                'self', 'sessionStorage', 'status', 'statusbar',
                'toolbar', 'top'
            ]
            // Window stuff? 'atob', 'btoa', 'console', 'document' ...
        };

    return function(source) {

        //source = source.replace(/\r\n/g, '\n').replace(/\r/g, '\n');

        var cursor = 0,
            tokenize = {
                comment: function() {
                    while (char = source[++cursor]) {
                        if (next == '/' && char == '\n') {
                            break;
                        } else if (next == '*' && char == '*' && source[cursor + 1] == '/') {
                            cursor += 2;
                            break;
                        }
                    }
                },
                identifier: function() {
                    var str;
                    while ((identifier + number).indexOf(source[++cursor]) > -1) {}
                    str = source.substring(start, cursor);
                    Ox.forEach(word, function(value, key) {
                        if (value.indexOf(str) > -1) {
                            type = key;
                            return false;
                        }
                    });
                },
                linebreak: function() {
                    while (linebreak.indexOf(source[++cursor]) > -1) {}
                },
                number: function() {
                    while ((number + '.').indexOf(source[++cursor]) > -1) {}
                },
                operator: function() {
                    if (operator.indexOf(char + source[++cursor]) > -1) {
                        if (operator.indexOf(char + next + source[++cursor]) > 1) {
                            ++cursor;
                        }
                    }
                },
                regexp: function() {
                    while ((char = source[++cursor]) != '/') {
                        char == '\\' && ++cursor;
                        if (cursor == source.length) {
                            break;
                        }
                    }
                    while (identifier.indexOf(source[++cursor]) > -1) {}
                },
                string: function() {
                    var delimiter = char;
                    while ((char = source[++cursor]) != delimiter) {
                        char == '\\' &&  ++cursor;
                        if (cursor == source.length) {
                            break;
                        }
                    }
                    ++cursor;
                },
                whitespace: function() {
                    while (whitespace.indexOf(source[++cursor]) > -1) {}
                }
            },
            tokens = [],
            type;

        while (cursor < source.length) {
            var char = source[cursor],
                next = source[cursor + 1],
                start = cursor;
            if (char == '/' && (next == '/' || next == '*')) {
                type = 'comment';
            } else if (identifier.indexOf(char) > -1) {
                type = 'identifier';
            } else if (linebreak.indexOf(char) > -1) {
                type = 'linebreak';
            } else if (number.indexOf(char) > -1) {
                type = 'number';
            } else if (char == "'" || char == '"') {
                type = 'string';
            } else if (whitespace.indexOf(char) > -1) {
                type = 'whitespace';
            } else if (char == '/') {
                type = isRegExp() ? 'regexp' : 'operator';
            } else if (operator.indexOf(char) > -1) {
                type = 'operator';
            }
            tokenize[type]();
            tokens.push({
                length: cursor - start,
                offset: start,
                type: type,
            });
        }

        function isRegExp() {
            // checks if a forward slash is the beginning of a regexp,
            // as opposed to the beginning of an operator
            // see http://www.mozilla.org/js/language/js20-2000-07/rationale/syntax.html#regular-expressions
            var index = tokens.length,
                isRegExp = false
                offset = 0;
            // scan back to the previous significant token,
            // or the beginning of the source
            while (
                typeof tokens[--index] != 'undefined' &&
                ['comment', 'linebreak', 'whitespace'].indexOf(tokens[index].type) > -1
            ) {
                offset += tokens[index].length;
            }
            if (typeof tokens[index] == 'undefined') {
                // source begins with forward slash
                isRegExp = true;
            } else {
                prevToken = tokens[index];
                prevString = source.substr(cursor - prevToken.length - offset, prevToken.length);
                isRegExp = (
                    prevToken.type == 'keyword' &&
                    ['false', 'null', 'true'].indexOf(prevString) == -1
                ) || (
                    prevToken.type == 'operator' && 
                    ['++', '--', ')', ']', '}'].indexOf(prevString) == -1
                );
            }
            return isRegExp;
        }

        return tokens;

    };

}());

//@ Math -----------------------------------------------------------------------

/*@
Ox.asinh <f> Inverse hyperbolic sine
    Strangely missing from <code>Math</code>.
@*/
Ox.asinh = function(x) {
    // fixme: no test
    return Math.log(x + Math.sqrt(x * x + 1));
};

/*@
Ox.deg <f> Takes radians, returns degrees
    Strangely missing from <code>Math</code>.
    > Ox.deg(2 * Math.PI)
    360
@*/
Ox.deg = function(rad) {
    return rad * 180 / Math.PI;
};

/*@
Ox.divideInt <f> Divides a number by another and returns an array of integers
    <code>Ox.divideInt(num, by)</code> returns an array of "as equal as
    possible" integers that has a sum of <code>num</code> and a length of
    <code>by</code>.
    > Ox.divideInt(100, 3)
    [33, 33, 34]
    > Ox.divideInt(100, 6)
    [16, 16, 17, 17, 17, 17]
@*/
Ox.divideInt = function(num, by) {
    // fixme: for loops are so C ;)
    var arr = [],
        div = parseInt(num / by),
        mod = num % by,
        i;
    for (i = 0; i < by; i++) {
        arr[i] = div + (i > by - 1 - mod);
    }
    return arr;
}

/*@
Ox.limit <f> Limits a number by a given mininum and maximum
    <code>Ox.limit(num, min, max)</code> is a shorthand for
    <code>Math.min(Math.max(num, min), max)</code>
    (num) -> <n> <code>num</code>
    (num, max) -> <n> <code>Math.max(num, max)</code>
    (num, min, max) -> <n> <code>Math.min(Math.max(num, min), max)</code>
    num <n> number
    min <n> minimum
    max <n> maximum
    > Ox.limit(1, 2, 3)
    2
    > Ox.limit(4, 2, 3)
    3
    > Ox.limit(2, 1)
    1
@*/
Ox.limit = function(num, min, max) {
    // fixme: rewrite this
    var len = arguments.length;
    max = arguments[len - 1];
    min = len == 3 ? min : 0;
    return Math.min(Math.max(num, min), max);
};

/*@
Ox.log <f> Returns the logarithm of a given number to a given base
    Strangely missing from <code>Math</code>.
    > Ox.log(100, 10)
    2
    > Ox.log(Math.E)
    1
@*/
Ox.log = function(num, base) {
    return Math.log(num) / Math.log(base || Math.E);
};

/*@
Ox.mod <f> Modulo function
    Unlike <code>-1 % 10</code>, which returns <code>-1</code>,
    <code>Ox.mod(-1, 10)</code> returns <code>9</code>.
    > Ox.mod(11, 10)
    1
    > Ox.mod(-11, 10)
    9
@*/
Ox.mod = function(num, by) {
    var mod = num % by;
    return mod >= 0 ? mod : mod + by;
};

/*@
Ox.rad <f> Takes degrees, returns radians
    Strangely missing from <code>Math</code>.
    > Ox.rad(360)
    2 * Math.PI
@*/
Ox.rad = function(deg) {
    return deg * Math.PI / 180;
};

/*@
Ox.random <f> Returns a random integer
    > [0, 1, 2, 3].indexOf(Ox.random(3)) > -1
    true
    > [1, 2].indexOf(Ox.random(1, 2)) > -1
    true
@*/
Ox.random = function() {
    // FIXME: weird, reimplement with Ox.loop / Ox.range
    var len = arguments.length,
        min = len == 1 ? 0 : arguments[0],
        max = arguments[len - 1];
    return min + parseInt(Math.random() * (max - min + 1));
};

/*@
Ox.round <f> Rounds a number with a given number of decimals
    > Ox.round(2 / 3, 6)
    0.666667
    > Ox.round(1 / 2, 3)
    0.5
    > Ox.round(1 / 2)
    1
@*/
Ox.round = function(num, dec) {
    var pow = Math.pow(10, dec || 0);
    return Math.round(num * pow) / pow;
};

/*@
Ox.sinh <f> Hyperbolic sine
    Strangely missing from <code>Math</code>.
@*/
Ox.sinh = function(x) {
    // fixme: no test
    return (Math.exp(x) - Math.exp(-x)) / 2;
};

//@ Constants ------------------------------------------------------------------

//@ Ox.MAX_LATITUDE <n> Maximum latitude of a Mercator projection
Ox.MAX_LATITUDE = Ox.deg(Math.atan(Ox.sinh(Math.PI)));
//@ Ox.MIN_LATITUDE <n> Minimum latitude of a Mercator projection
Ox.MIN_LATITUDE = -Ox.MAX_LATITUDE;

//@ Object ---------------------------------------------------------------------

/*@
Ox.extend <function> Extends an object with one or more other objects
    > Ox.extend({a: 1, b: 1, c: 1}, {b: 2, c: 2}, {c: 3})
    {a: 1, b: 2, c: 3}
@*/
Ox.extend = function() {
    var obj = arguments[0];
    Ox.forEach(Array.prototype.slice.call(arguments, 1), function(arg, i) {
        Ox.forEach(arg, function(val, key) {
            obj[key] = val;
        });
    });
    return obj;
};

/*@
Ox.serialize <f> Parses an object into query parameters
    > Ox.serialize({a: 1, b: 2, c: 3})
    'a=1&b=2&c=3'
@*/
Ox.serialize = function(obj) {
    var arr = [];
    Ox.forEach(obj, function(val, key) {
        arr.push(key + '=' + val);
    });
    return arr.join('&');
};

/*@
Ox.unserialize <f> Parses query parameters into an object
    > Ox.unserialize('a=1&b=2&c=3')
    {a: 1, b: 2, c: 3}
@*/
Ox.unserialize = function(str) {
    var obj = {};
    Ox.forEach(str.split('&'), function(val) {
        var arr = val.split('='),
            num = +arr[1];
        obj[arr[0]] = Ox.isNumber(num) ? num : arr[1];
    });
    return obj;
};

/*
================================================================================
RegExp functions
================================================================================
*/

Ox.regexp = {
    'accents': '¨´`ˆ˜',
    'letters': 'a-z¨´`ˆ˜äåáàâãæçëéèèñïíìîöóòôõøœßúùûÿ'
};

//@ Requests -------------------------------------------------------------------

/*@
Ox.get <f> Get a remote file
    # fixme: remote? same-origin-policy? jsonp?
    (url, callback) -> <u> undefined
    url <s> Remote URL
    callback <f> Callback function
        data <s> The contents of the remote resource
@*/
Ox.get = function(url, callback) {
    var req = new XMLHttpRequest();
    req.open('GET', url, true);
    req.onreadystatechange = function() {
        if (req.readyState == 4) {
            if (req.status == 200) {
                callback(req.responseText);
            } else {
                throw new Error('URL ' + url + ', status ' + req.status);
            }
        }
    };
    req.send();                
};

/*@
Ox.getJSON <f> Get and parse a remote JSON file
    # fixme: remote? same-origin-policy? jsonp?
    (url, callback) -> <u> undefined
    url <s> Remote URL
    callback <f> Callback function
        data <s> The contents of the remote resource
@*/
Ox.getJSON = function(url, callback) {
    Ox.get(url, function(data) {
        callback(JSON.parse(data));
    });
}

/*@
Ox.loadFile <f> Loads a file (image, script or stylesheet)
    (file="script.js", callback)      -> <u> undefined
    (file="stylesheet.css", callback) -> <u> undefined
    (file="image.png", callback)      -> <e> DOM element
    file     <s> Local path or remote URL
    callback <f> Callback function
@*/

Ox.loadFile = (function() {
    // fixme: this doesn't handle errors yet
    // fixme: rename to getFile?
    var cache = {};
    return function (file, callback) {
        var element,
            request,
            type = file.split('.').pop();
            isImage = type != 'css' && type != 'js';
        if (!cache[file]) {
            if (isImage) {
                element = new Image();
                element.onload = addFileToCache;
                element.src = file;
            } else {
                if (!findFileInHead()) {
                    element = document.createElement(
                        type == 'css' ? 'link' : 'script'
                    );
                    element[type == 'css' ? 'href' : 'src'] = file + '?' + Ox.random(1000000);
                    element.type = type == 'css' ?
                        'text/css' : 'text/javascript';
                    if (type == 'css') {
                        element.rel = 'stylesheet';
                        waitForCSS();
                    } else {
                        element.onload = addFileToCache;
                    }
                    document.head.appendChild(element);
                } else {
                    addFileToCache();
                }
            }
        } else {
            callback();
        }
        function addFileToCache() {
            if (isImage) {
                // for an image, save the element itself,
                // so that it remains in the browser cache
                cache['file'] = element;
                callback(element);
            } else {
                cache['file'] = true;
                callback();
            }
        }
        function findFileInHead() {
            return Array.prototype.slice.apply(
                document.getElementsByTagName(type == 'css' ? 'link' : 'script')
            ).map(function(element) {
                return element[type == 'css' ? 'href' : 'src'] == file;
            }).reduce(function(prev, curr) {
                return prev || curr; 
            }, false);
        }
        function waitForCSS() {
            var error = false;
            try {
                element.sheet.cssRule;
            } catch(e) {
                error = true;
                setTimeout(function() {
                    waitForCSS();
                }, 25);
            }
            !error && addFileToCache();
        }
    };
}());

//@ String ---------------------------------------------------------------------

Ox.basename = function(str) {
    /*
    fixme: deprecate
    >>> Ox.basename("foo/bar/foo.bar")
    "foo.bar"
    >>> Ox.basename("foo.bar")
    "foo.bar"
    */
    return str.replace(/^.*[\/\\]/g, '');
};

/*@
Ox.char <f> Alias for String.fromCharCode
@*/
// fixme: add some mapping? like Ox.char(9, 13) or Ox.char([9, 13])?
Ox.char = String.fromCharCode;

/*@
Ox.clean <f> Remove leading, trailing and double whitespace from a string
    > Ox.clean("foo  bar")
    "foo bar"
    > Ox.clean(" foo  bar ")
    "foo bar"
    > Ox.clean(" foo \n bar ")
    "foo\nbar"
@*/
Ox.clean = function(str) {
    return Ox.map(str.split('\n'), function(str) {
        return Ox.trim(str.replace(/\s+/g, ' '));
    }).join('\n');
};

/*@
Ox.endsWith <f> Checks if a string ends with a given substring
    If the substring is a string literal (and not a variable),
    <code>/sub$/.test(str)</code> or <code>!!/sub$/(str)</code>
    is shorter than <code>Ox.ends(str, sub)</code>.
    > Ox.endsWith('foobar', 'bar')
    true
@*/
Ox.endsWith = function(str, sub) {
    // fixme: rename to ends
    return str.substr(str.length - sub.length) == sub;
};

/*@
Ox.highlight <f> Highlight matches in a string
    > Ox.highlight('foobar', 'foo', 'match')
    '<span class="match">foo</span>bar'
@*/
// fixme: with regexp, special chars would have to be escaped
Ox.highlight = function(txt, str, classname) {
    return str && str.length ? txt.replace(
        new RegExp('(' + str + ')', 'ig'),
        '<span class="' + classname + '">$1</span>'
    ) : txt;
};

/*@
Ox.isValidEmail <f> Tests if a string is a valid e-mail address
    (str) -> <b> True if the string is a valid e-mail address
    str <s> Any string
    > Ox.isValidEmail("foo@bar.com")
    true
    > Ox.isValidEmail("foo.bar@foobar.co.uk")
    true
    > Ox.isValidEmail("foo@bar")
    false
    > Ox.isValidEmail("foo@bar..com")
    false
@*/
Ox.isValidEmail = function(str) {
    return !!/^[0-9A-Z\.\+\-_]+@(?:[0-9A-Z\-]+\.)+[A-Z]{2,6}$/i(str);
}

/*@
Ox.pad <f> Pad a string to a given length
    > Ox.pad(1, 2)
    "01"
    > Ox.pad("abc", 6, ".", "right")
    "abc..."
    > Ox.pad("foobar", 3, ".", "right")
    "foo"
    > Ox.pad("abc", 6, "123456", "right")
    "abc123"
    > Ox.pad("abc", 6, "123456", "left")
    "456abc"
@*/
Ox.pad = function(str, len, pad, pos) {
    // fixme: slighly obscure signature
    // fixme: weird for negative numbers
    /*
    */
    str = str.toString().substr(0, len);
    pad = Ox.repeat(pad || '0', len - str.length);
    pos = pos || 'left';
    str = pos == 'left' ? pad + str : str + pad;
    str = pos == 'left' ?
        str.substr(str.length - len, str.length) :
        str.substr(0, len);
    return str;
};

/*@
Ox.parsePath <f> Returns the components of a path
    (str) -> <o> Path
        extension <s> File extension
        filename <s> Filename
        pathname <s> Pathname
    > Ox.parsePath('/foo/bar/foo.bar')
    {extension: 'bar', filename: 'foo.bar', pathname: '/foo/bar/'}
    > Ox.parsePath('foo/')
    {extension: '', filename: '', pathname: 'foo/'}
    > Ox.parsePath('foo')
    {extension: '', filename: 'foo', pathname: ''}
    > Ox.parsePath('.foo')
    {extension: '', filename: '.foo', pathname: ''}
@*/
Ox.parsePath = function(str) {
    var matches = /^(.+\/)?(.+?(\..+)?)?$/(str);
    return {
        pathname: matches[1] || '',
        filename: matches[2] || '',
        extension: matches[3] ? matches[3].substr(1) : ''
    };
}

/*@
Ox.parseSRT <f> Parses an srt subtitle file
    (str) -> <o> Parsed subtitles
        in <n> In point (sec)
        out <n> Out point (sec)
        text <s> Text
    str <s> Contents of an srt subtitle file
    > Ox.parseSRT('1\n01:02:00,000 --> 01:02:03,400\nHello World')
    [{'in': 3720, out: 3723.4, text: 'Hello World'}]
@*/
Ox.parseSRT = function(str, fps) {
    return str.replace(/\r\n/g, '\n').replace(/\n+$/, '').split('\n\n')
        .map(function(block) {
            var lines = block.split('\n'), points;
            lines.shift();
            points = lines.shift().split(' --> ').map(function(point) {
                return point.replace(',', ':').split(':')
                    .reduce(function(prev, curr, i) {
                        return prev + parseInt(curr, 10) *
                            [3600, 60, 1, 0.001][i];
                    }, 0);
            });
            if (fps) {
                points = points.map(function(point) {
                    return Math.round(point * fps) / fps;
                });
            }
            return {
                'in': points[0],
                out: points[1],
                text: lines.join('\n')
            };
        });
};

/*@
Ox.repeat <f> Repeat a value multiple times
    Works for arrays, numbers and strings
    > Ox.repeat(1, 3)
    "111"
    > Ox.repeat("foo", 3)
    "foofoofoo"
    > Ox.repeat([1, 2], 3)
    [1, 2, 1, 2, 1, 2]
@*/
Ox.repeat = function(val, num) {
    var ret;
    if (Ox.isArray(val)) {
        ret = [];
        num >= 1 && Ox.loop(num, function() {
            ret = Ox.merge(ret, val);
        });
    } else {
        ret = num >= 1 ? new Array(num + 1).join(val.toString()) : '';
    }
    return ret;
};

Ox.reverse = function(str) {
    /*
    Ox.reverse("foo")
    oof
    */
    return str.toString().split('').reverse().join('');
};

/*@
Ox.startsWith <f> Checks if a string starts with a given substring
    If the substring is a string literal (and not a variable),
    <code>/^sub/.test(str)</code> or <code>!!/^sub/(str)</code>
    is shorter than <code>Ox.starts(str, sub)</code>.
    > Ox.startsWith('foobar', 'foo')
    true
@*/
Ox.startsWith = function(str, sub) {
    // fixme: rename to starts
    return str.substr(0, sub.length) == sub;
};

/*@
Ox.stripTags <f> Strips HTML tags from a string
    > Ox.stripTags('f<span>o</span>o')
    'foo'
@*/
Ox.stripTags = function(str) {
    return str.replace(/<.*?>/g, '');
};

/*@
Ox.substr <f> A better <code>substr</code>
    > Ox.substr('foobar', 1)
    "oobar"
    > Ox.substr('foobar', -1)
    "r"
    > Ox.substr('foobar', 1, 5)
    "ooba"
    > Ox.substr('foobar', 1, -1)
    "ooba"
    > Ox.substr('foobar', -5, 5)
    "ooba"
    > Ox.substr('foobar', -5, -1)
    "ooba"
@*/
Ox.substr = function(str, start, stop) {
    /***
    // fixme: needed?
    Ox.substr behaves like str[start:stop] in Python
    (or like str.substring() with negative values for stop)
    ***/
    stop = Ox.isUndefined(stop) ? str.length : stop;
    return str.substring(
        start < 0 ? str.length + start : start,
        stop < 0 ? str.length + stop : stop
    );
};

/*@
Ox.toCamelCase <f> Takes a string with '-', '/' or '_', returns a camelCase string
    > Ox.toCamelCase('foo-bar-baz')
    'fooBarBaz'
    > Ox.toCamelCase('foo/bar/baz')
    'fooBarBaz'
    > Ox.toCamelCase('foo_bar_baz')
    'fooBarBaz'
@*/

Ox.toCamelCase = function(str) {
    return str.replace(/[\-\/_][a-z]/g, function(str) {
        return str[1].toUpperCase();
    });
};

/*@
Ox.toDashes <f> Takes a camelCase string, returns a string with dashes
    > Ox.toDashes('fooBarBaz')
    'foo-bar-baz'
@*/
Ox.toDashes = function(str) {
    return str.replace(/[A-Z]/g, function(str) {
        return '-' + str.toLowerCase();
    });
};

/*@
Ox.toSlashes <f> Takes a camelCase string, returns a string with slashes
    > Ox.toSlashes('fooBarBaz')
    'foo/bar/baz'
@*/
Ox.toSlashes = function(str) {
    /*
    */
    return str.replace(/[A-Z]/g, function(str) {
        return '/' + str.toLowerCase();
    });
};

/*@
Ox.toTitleCase <f> Returns a string with capitalized words
    > Ox.toTitleCase('foo')
    'Foo'
    > Ox.toTitleCase('Apple releases iPhone, IBM stock plummets')
    'Apple Releases iPhone, IBM Stock Plummets'
@*/
Ox.toTitleCase = function(str) {
    return Ox.map(str.split(' '), function(v) {
        var sub = v.substr(1),
            low = sub.toLowerCase();
        if (sub == low) {
            v = v.substr(0, 1).toUpperCase() + low;
        }
        return v;
    }).join(' ');
};

/*@
Ox.toUnderscores <f> Takes a camelCase string, returns string with underscores
    > Ox.toUnderscores('fooBarBaz')
    'foo_bar_baz'
@*/
Ox.toUnderscores = function(str) {
    return str.replace(/[A-Z]/g, function(str) {
        return '_' + str.toLowerCase();
    });
};

Ox.trim = function(str) { // is in jQuery, and in JavaScript itself
    /*
    Ox.trim(" foo ")
    "foo"
    */
    return str.replace(/^\s+|\s+$/g, "");
};

/*@
Ox.truncate <f> Truncate a string to a given length
    (string, length) <s> Truncated string
    (string, length, position) -> <s> Truncated string
    (string, length, placeholder) -> <s> Truncated string
    (string, length, position, placeholder) -> <s> Truncated string
    > Ox.truncate('anticonstitutionellement', 16)
    'anticonstitut...'
    > Ox.truncate('anticonstitutionellement', 16, -1)
    '...utionellement'
    > Ox.truncate('anticonstitutionellement', 16, '>')
    'anticonstitutio>'
    > Ox.truncate("anticonstitutionellement", 16, "...", "center")
    'anticon...lement'
@*/
Ox.truncate = function(str, len, pad, pos) {
    /*
    */
    var pad = pad || {},
        pos = pos || "right",
        strlen = str.length,
        padlen = pad.length,
        left, right;
    if (strlen > len) {
        if (pos == "left") {
            str = pad + str.substr(padlen + strlen - len);
        } else if (pos == "center") {
            left = Math.ceil((len - padlen) / 2);
            right = Math.floor((len - padlen) / 2);
            str = str.substr(0, left) + pad + str.substr(-right);
        } else if (pos == "right") {
            str = str.substr(0, len - padlen) + pad;
        }
    }
    return str;
};

/*@
Ox.words <f> Splits a string into words, removing punctuation
    (string) -> <[s]> Array of words
    string <s> Any string
    > Ox.words('Let\'s "walk" a tree-like key/value store--okay?')
    ["let's", "walk", "a", "tree-like", "key", "value", "store", "okay"]
@*/
Ox.words = function(str) {
    var arr = str.toLowerCase().split(/\b/),
        chr = "-'",
        len = arr.length,
        startsWithWord = !!/\w/(arr[0]);
    arr.forEach(function(v, i) {
        // find single occurrences of "-" or "-"
        // that are not at the beginning or end of the string
        // and join the surrounding words with them
        if (
            i > 0 && i < len - 1 &&
            v.length == 1 && chr.indexOf(v) > -1
        ) {
            arr[i + 1] = arr[i - 1] + arr[i] + arr[i + 1];
            arr[i - 1] = arr[i] = '';
        }
    });
    // remove elements that have been emptied above
    arr = arr.filter(function(v) {
        return v.length;
    });
    // return words, not spaces or punctuation
    return arr.filter(function(v, i) {
        return i % 2 == !startsWithWord;
    });
}

/*@
Ox.wordwrap <f> Wrap a string at word boundaries
    > Ox.wordwrap("Anticonstitutionellement, Paris s'eveille", 25, '<br/>')
    "Anticonstitutionellement, <br/>Paris s'eveille"
    > Ox.wordwrap("Anticonstitutionellement, Paris s'eveille", 16, '<br/>')
    "Anticonstitution<br/>ellement, Paris <br/>s'eveille"
    > Ox.wordwrap('These are short words', 16, '<br/>', true)
    'These are <br/>short words'
@*/
Ox.wordwrap = function(str, len, sep, bal, spa) {
    // fixme: bad API, sep/bal/spa should be in options object
    var str = str === null ? '' : str.toString(),
        len = len || 80,
        sep = sep || '<br/>',
        bal = bal || false,
        spa = Ox.isUndefined(spa) ? true : spa,
        words = str.split(' '),
        lines;
    if (bal) {
        // balance lines: test if same number of lines
        // can be achieved with a shorter line length
        lines = Ox.wordwrap(str, len, sep, false).split(sep);
        if (lines.length > 1) {
            // test shorter line, unless
            // that means cutting a word
            var max = Ox.max(Ox.map(words, function(word) {
                return word.length;
            }));
            while (len > max) {
                len--;
                if (Ox.wordwrap(str, len, sep, false).split(sep).length > lines.length) {
                    len++;
                    break;
                }
            }
        }
    }
    lines = [''];
    Ox.forEach(words, function(word) {
        if ((lines[lines.length - 1] + word + ' ').length <= len + 1) {
            // word fits in current line
            lines[lines.length - 1] += word + ' ';
        } else {
            if (word.length <= len) {
                // word fits in next line
                lines.push(word + ' ');
            } else {
                // word is longer than line
                var chr = len - lines[lines.length - 1].length;
                lines[lines.length - 1] += word.substr(0, chr);
                for (var pos = chr; pos < word.length; pos += len) {
                    lines.push(word.substr(pos, len));
                }
                lines[lines.length - 1] += ' ';
            }
        }
    });
    if (!spa) {
        lines = Ox.map(lines, function(line) {
            return Ox.trim(line);
        });
    }
    return Ox.trim(lines.join(sep));    
};

//@ Type -----------------------------------------------------------------------

/*@
Ox.isArguments <f> Tests if a value is an arguments "array"
    (value) -> <b> True if the value is an arguments "array"
    value <*> Any value
    > Ox.isArguments((function() { return arguments; }()))
    true
@*/
Ox.isArguments = function(val) {
    return !!(val && val.toString() == '[object Arguments]');
}

/*@
Ox.isArray <f> Tests if a value is an array
    (value) -> <b> True if the value is a date
    value <*> Any value
    > Ox.isArray([])
    true
    > Ox.isArray((function() { return arguments; }()))
    false
    > Ox.isArray({0: 0, length: 1})
    false
@*/
Ox.isArray = function(val) {
    return val instanceof Array;
}

/*@
Ox.isBoolean <f> Tests if a value is boolean
    (value) -> <b> True if the value is boolean
    value <*> Any value
    > Ox.isBoolean(false)
    true
@*/
Ox.isBoolean = function(val) {
    return typeof val == 'boolean';
};

/*@
Ox.isDate <f> Tests if a value is a date
    (value) -> <b> True if the value is a date
    value <*> Any value
    > Ox.isDate(new Date())
    true
@*/
Ox.isDate = function(val) {
    return val instanceof Date;
};

/*@
Ox.isElement <f> Tests if a value is a DOM element
    (value) -> <b> True if the value is a DOM element
    value <*> Any value
    > Ox.isElement(document.createElement())
    true
@*/
Ox.isElement = function(val) {
    return !!(val && val.nodeType == 1);
};

/*@
Ox.isEqual <function> Returns true if two values are equal
    > Ox.isEqual((function() { return arguments; }()), (function() { return arguments; }()))
    true
    > Ox.isEqual([1, 2, 3], [1, 2, 3])
    true
    > Ox.isEqual([1, 2, 3], [3, 2, 1])
    false
    > Ox.isEqual(false, false)
    true
    > Ox.isEqual(new Date(0), new Date(0))
    true
    > Ox.isEqual(new Date(0), new Date(1))
    false
    > Ox.isEqual(document.createElement('a'), document.createElement('a'))
    true
    > Ox.isEqual(document.createElement('a'), document.createElement('b'))
    false
    > Ox.isEqual(function(a) { return a; }, function(a) { return a; })
    true
    > Ox.isEqual(function(a) { return a; }, function(b) { return b; })
    false
    > Ox.isEqual(Infinity, Infinity)
    true
    > Ox.isEqual(-Infinity, Infinity)
    false
    > Ox.isEqual(NaN, NaN)
    false
    > Ox.isEqual(0, 0)
    true
    > Ox.isEqual({a: 1, b: 2, c: 3}, {c: 3, b: 2, a: 1})
    true
    > Ox.isEqual({a: 1, b: [2, 3], c: {d: '4'}}, {a: 1, b: [2, 3], c: {d: '4'}})
    true
    > Ox.isEqual(/ /, / /)
    true
    > Ox.isEqual(/ /g, / /i)
    false
    > Ox.isEqual('', '')
    true
    > Ox.isEqual(void 0, void 0)
    true
@*/
Ox.isEqual = function(a, b) {
    var isEqual = false, type = Ox.typeOf(a);
    if (a === b) {
        isEqual = true;
    } else if (type == Ox.typeOf(b)) {
        if (a == b) {
            isEqual = true;
        } else if (type == 'date') {
            isEqual = a.getTime() == b.getTime();
        } else if (['element', 'function'].indexOf(type) > -1) {
            isEqual = a.toString() == b.toString();
        } else if (type == 'regexp') {
            isEqual = a.global == b.global &&
                a.ignore == b.ignore &&
                a.multiline == b.multiline &&
                a.source == b.source;
        } else if (
            ['arguments', 'array', 'object'].indexOf(type) > -1 &&
            Ox.len(a) == Ox.len(b)
        ) {
            isEqual = true;
            Ox.forEach(a, function(v, k) {
                isEqual = Ox.isEqual(v, b[k]);
                return isEqual;
            });
        }
    }
    return isEqual;
};

/*@
Ox.isFunction <f> Tests if a value is a function
    (value) -> <b> True if the value is a function
    value <*> Any value
    > Ox.isFunction(function() {})
    true
    > Ox.isFunction(/ /)
    false
@*/
Ox.isFunction = function(val) { // is in jQuery
    return typeof val == 'function' && !Ox.isRegExp(val);
};

/*@
Ox.isInfinity <f> Tests if a value is infinite
    (value) -> <b> True if the value is infinite
    value <*> Any value
    > Ox.isInfinity(Infinity)
    true
    > Ox.isInfinity(-Infinity)
    true
    > Ox.isInfinity(NaN)
    false
@*/
Ox.isInfinity = function(val) {
    return typeof val == 'number' && !isFinite(val) && !Ox.isNaN(val);
};

/*@
Ox.isNaN <f> Tests if a value is "Not a Number"
    (value) -> <b> True if the value is "Not a Number"
    value <*> Any value
    > Ox.isNaN(NaN)
    true
@*/

Ox.isNaN = function(val) {
    return val !== val;
}

/*@
Ox.isNull <f> Tests if a value is <code>null</code>
    (value) -> <b> True if the value is <code>null</null>
    value <*> Any value
    > Ox.isNull(null)
    true
@*/
Ox.isNull = function(val) {
    return val === null;
};

/*@
Ox.isNumber <f> Tests if a value is a number
    (value) -> <b> True if the value is a number
    value <*> Any value
    > Ox.isNumber(0)
    true
    > Ox.isNumber(Infinity)
    false
    > Ox.isNumber(-Infinity)
    false
    > Ox.isNumber(NaN)
    false
@*/

Ox.isNumber = function(val) {
    return typeof val == 'number' && isFinite(val);
};

/*@
Ox.isObject <f> Tests if a value is a an object
    (value) -> <b> True if the value is an object
    value <*> Any value
    > Ox.isObject({})
    true
    > Ox.isObject([])
    false
    > Ox.isObject(new Date())
    false
    > Ox.isObject(null)
    false
@*/

Ox.isObject = function(val) {
    return typeof val == 'object' && !Ox.isArguments(val) &&
        !Ox.isArray(val) && !Ox.isDate(val) && !Ox.isNull(val);
};

/*@
Ox.isRegExp <f> Tests if a value is a regular expression
    (value) -> <b> True if the value is a regular expression
    value <*> Any value
    > Ox.isRegExp(/ /)
    true
@*/

Ox.isRegExp = function(val) {
    return val instanceof RegExp;
};

/*@
Ox.isString <f> Tests if a value is a string
    (value) -> <b> True if the value is a string
    value <*> Any value
    > Ox.isString('')
    true
@*/

Ox.isString = function(val) {
    return typeof val == 'string';
};

/*@
Ox.isUndefined <f> Tests if a value is undefined
    (value) -> <b> True if the value is undefined
    value <*> Any value
    > Ox.isUndefined()
    true
@*/

Ox.isUndefined = function(val) {
    // fixme: val === void 0 is also nice
    return typeof val == 'undefined';
};

/*@
Ox.typeOf <f> Returns the type of a value
    (value) -> <s> type
    value <*> Any value
    # Examples
    > (function() { return Ox.typeOf(arguments); }())
    "arguments"
    > Ox.typeOf([])
    "array"
    > Ox.typeOf(false)
    "boolean"
    > Ox.typeOf(new Date())
    "date"
    > Ox.typeOf(document.createElement())
    "element"
    > Ox.typeOf(function() {})
    "function"
    > Ox.typeOf(Infinity)
    "infinity"
    > Ox.typeOf(NaN)
    "nan"
    > Ox.typeOf(null)
    "null"
    > Ox.typeOf(0)
    "number"
    > Ox.typeOf({})
    "object"
    > Ox.typeOf(/ /)
    "regexp"
    > Ox.typeOf('')
    "string"
    > Ox.typeOf()
    "undefined"
@*/

Ox.typeOf = function(val) {
    var ret;
    Ox.forEach(Ox.TYPES, function(type) {
        if (Ox['is' + type](val)) {
            ret = type.toLowerCase();
            return false;
        }
    });
    return ret;
};
