// vim: et:ts=4:sw=4:sts=4:ft=js // OxJS (c) 2011 Ox2620, dual-licensed GPL/MIT, see http://oxjs.org for details // 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 The Ox object See Ox.wrap for details. (value) -> wrapped value value <*> Any value @*/ Ox = function(val) { return Ox.wrap(val); }; /*@ Ox.load Loads a module (module, callback) -> undefined (module, options, callback) -> undefined module Module name options Module options callback Callback function success 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 Prints its arguments to the console (arg, ...) -> String The string contains the timestamp, the name of the caller function, and any arguments, separated by spaces arg <*> any value > Ox.print("foo").substr(-3) "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 Returns a unique id () -> Unique id > Ox.uid() != Ox.uid() true @*/ Ox.uid = (function() { var uid = 0; return function() { return uid++; }; }()); /*@ Ox.wrap Wraps a value so that one can directly call any Ox function on it Additionally, chain() allows for chaining, and value() returns the original value. See examples for details. (value) -> wrapped value chain wrap the return value to allow chaining value unwrap the value wrapped by 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) { 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 Returns an array w/o nullundefined > 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 Flattens an array > Ox.flatten([1, [2, [3], 4], 5]) [1, 2, 3, 4, 5] @*/ 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 Merges an array with one or more other arrays > Ox.merge(['foo'], ['foo', 'bar'], ['bar']) ['foo', 'foo', 'bar', 'bar'] @*/ 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.unique 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 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 Returns the average of an array's values, or an object's properties (collection) -> 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 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.count Counts the occurences of values in an array, object or string > 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 (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 Returns true if a condition holds for every element of a collection Unlike [].every(), Ox.every() 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 Filters a collection by a given condition Unlike [].filter(), Ox.filter() 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 Returns array elements that match a string, leading matches first > Ox.find(['foo', 'bar', 'foobar', 'barfoo'], 'foo') [['foo", 'foobar'], ['barfoo']] @*/ Ox.find = function(arr, str) { /* returns an array with two arrays as elements: an array of elements of arr that begin with str, and an array of elements of arr that contain, but do not begin with str */ var arrLowerCase = arr.map(function(v) { return v.toLowerCase(); }), ret = [[], []]; str && arrLowerCase.forEach(function(v, i) { var index = v.indexOf(str.toLowerCase()); index > -1 && ret[index == 0 ? 0 : 1].push(arr[i]); }); return ret; }; /*@ Ox.forEach forEach loop Ox.forEach() loops over arrays, objects and strings. Returning false from the iterator function acts like a break statement (unlike [].forEach(), like $.each()). The arguments of the iterator function are (value, key) (like [].forEach(), unlike $.each()). (collection, callback) The collection collection An array, object or string callback Callback function value <*> Value key Key @*/ /* > 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; }) > Ox.test.string "012abcfoo" */ Ox.forEach = function(obj, fn) { var isObject = Ox.isObject(obj), key; for (key in obj) { key = isObject ? key : parseInt(key); if (/*hasOwnProperty.call(obj, key) && */fn(obj[key], key) === false) { break; } } return obj; }; /*@ Ox.getObjectById Returns an array element with a given id @*/ // fixme: shouldn't this be getElementById() ? Ox.getObjectById = function(arr, id) { /*** >>> Ox.getObjectById([{id: "foo", title: "Foo"}, {id: "bar", title: "Bar"}], "foo").title "Foo" ***/ var ret = null; Ox.forEach(arr, function(v) { if (v.id == id) { ret = v; return false; } }); return ret; }; /*@ Ox.getPositionById Returns the index of an array element with a given id @*/ // fixme: shouldn't this be getIndexById() ? Ox.getPositionById = function(arr, id) { /*** >>> Ox.getPositionById([{id: "foo", title: "Foo"}, {id: "bar", title: "Bar"}], "bar") 1 ***/ 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 Generic getter and setter function See examples for details. # Usage -------------------------------------------------------------------- Ox.getset(options, args=[]) -> all options Ox.getset(options, args=[key]) -> <*> options[key] Ox.getset(options, args=[key, value], callback, context) -> 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) -> context sets multiple options and calls fn(key, value) for every key/value pair that was added or modified # Arguments ---------------------------------------------------------------- options Options object (key/value pairs) args The arguments "array" of the caller function callback Callback function The callback is called for every key/value pair that was added or modified. key Key value <*> Value context The parent object of the caller function (for chaining) # Examples ----------------------------------------------------------------- > 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 Returns true if an array, object or string is empty > Ox.isEmpty([]) true > Ox.isEmpty({}) true > Ox.isEmpty('') true @*/ Ox.isEmpty = function(val) { return Ox.len(val) == 0; }; /*@ Ox.keys Returns the keys of an array, object or string Unlike Object.keys(), Ox.keys() 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 Gets or sets the last element of an array Unlike foobarbaz[foobarbaz.length - 1], Ox.last(foobarbaz) is short. > Ox.test.array = [1, 2, 3] > 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 Returns the length of an array, function, object or string Not to be confused with Ox.length, which is the length property of the Ox function (1 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 For-loop, functional-style Returning false from the iterater function acts like a break statement. Unlike a for loop, Ox.loop doesn't leak its counter variable to the outer scope, but returns it. (stop, callback) -> Next value equivalent to for (var i = 0; i < stop; i++) (start, stop, callback) -> Next value equivalent to for (var i = start; i < stop; i++) or, if start is larger than stop, for (var i = start; i > stop; i--) (start, stop, step) -> Next value equivalent to for (var i = start; i < stop; i += step) start Start value stop Stop value (exclusive) step Step value callback Iterator function i 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 Takes an array-like object and returns a true array Alias for Array.prototype.slice.call (value) -> 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 Takes an array and returns an object Ox.makeObject is a helper for functions with two alternative signatures like ('key', 'val') and ({key: 'val'}). > (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 Transforms the values of an array, object or string Unlike [].map(), Ox.map() works for arrays, objects and strings. Returning null 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 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 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 Python-style range (stop) -> <[n]> range Returns an array of integers from 0 (inclusive) to stop (exclusive). (start, stop) -> <[n]> range Returns an array of integers from start (inclusive) to stop (exclusive). (start, stop, step) -> <[n]> range Returns an array of numbers from start (inclusive) to stop (exclusive), incrementing by step. start Start value stop Stop value step 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.serialize = function(obj) { /* >>> Ox.serialize({a: 1, b: 2, c: 3}) 'a=1&b=2&c=3' */ var arr = []; Ox.forEach(obj, function(val, key) { val !== '' && arr.push(key + '=' + val); }); return arr.join('&'); }; Ox.setPropertyOnce = function(arr, str) { /* >>> Ox.setPropertyOnce([{selected: false}, {selected: false}], 'selected') 0 >>> Ox.setPropertyOnce([{selected: false}, {selected: true}], 'selected') 1 >>> Ox.setPropertyOnce([{selected: true}, {selected: true}], 'selected') 0 */ 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 = function(arr) { /* >>> Ox.shuffle([1, 2, 3]).length 3 */ var shuffle = arr; return shuffle.sort(function() { return Math.random() - 0.5; }); }; Ox.some = function(obj, fn) { /* Ox.some() works for arrays, objects and strings, unlike [].some() >>> 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 */ return Ox.filter(Ox.values(obj), fn).length > 0; }; Ox.sort = function(arr) { /* >>> Ox.sort(['10', '9', 'B', 'a']) ['9', '10', 'a', 'B'] */ 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.sum = function(obj) { /* >>> Ox.sum([-1, 0, 1]) 0 >>> Ox.sum({a: 1, b: 2, c: 3}) 6 */ var sum = 0; Ox.forEach(obj, function(val) { sum += val; }); 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.unserialize = function(str) { /* >>> Ox.unserialize('a=1&b=2&c=3').c '3' */ var arr, obj = {}; Ox.forEach(str.split('&'), function(val) { arr = val.split('='); obj[arr[0]] = arr[1]; }); return obj; }; Ox.values = function(obj) { /* >>> 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,]) [1] */ // fixme: why doesn't this use map? var values = []; Ox.forEach(obj, function(val) { values.push(val); }); return values; }; Ox.walk = function(obj, fn) { /* >>> a = 0; Ox.walk({a: 1, b: {c: 2, d: 3}}, function(v, k) { a += Ox.isNumber(v) ? v : 0}); a 6 */ Ox.forEach(obj, function(val, key) { fn(val, key, obj); Ox.walk(obj[key], fn); }); }; //@ Color ---------------------------------------------------------------------- /*@ Ox.hsl 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 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 Radius of the earth in meters // see http://en.wikipedia.org/wiki/WGS-84 Ox.EARTH_RADIUS = 6378137; //@ Ox.EARTH_CIRCUMFERENCE Circumference of the earth in meters Ox.EARTH_CIRCUMFERENCE = Ox.EARTH_RADIUS * 2 * Math.PI; //@ Ox.HTML_ENTITIES