diff --git a/demos/doc/js/doc.js b/demos/doc/js/doc.js
index b86dac02..84d50511 100644
--- a/demos/doc/js/doc.js
+++ b/demos/doc/js/doc.js
@@ -8,11 +8,14 @@ Ox.load('UI', {
         doc.forEach(function(item) {
             Ox.DocPage({doc: item}).appendTo(Ox.UI.$body);
         });
+        /*
         Ox.get('../../build/Ox.UI/js/Map/Ox.Map.js', function(source) {
             var doc = Ox.doc(source);
             doc.forEach(function(item) {
                 Ox.DocPage({doc: item}).appendTo(Ox.UI.$body);
             });
         });
+        */
+        Ox.print('TEST', Ox.test(source))
     });
 });
\ No newline at end of file
diff --git a/source/Ox.js b/source/Ox.js
index 86996197..a5e182e5 100644
--- a/source/Ox.js
+++ b/source/Ox.js
@@ -143,246 +143,6 @@ Core functions
 ================================================================================
 */
 
-/*@
-Ox.doc <f> Generates documentation for annotated JavaScript
-    (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() {
-    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'
-        }
-    return function(source) {
-        var blocks = [],
-            items = [],
-            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');
-            // create a tree and parse its root node
-            item = parseNode(parseTree(lines));
-            if (/^[A-Z]/.test(item.name)) {
-                item.source = parseTokens(tokens[i]);
-                items.push(item);
-            } else {
-                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)
-                );
-            }
-        });
-        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;
-            Ox.print(node, node.line, 'item', item);
-            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: JSON.parse(lines[1].trim())
-                result: lines[1].trim()
-            };
-        }
-        function parseTokens(tokens, includeLeading) {
-            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 items;
-    };
-}())
-
 Ox.get = function(url, callback) {
     var req = new XMLHttpRequest();
     req.open('GET', url, true);
@@ -427,19 +187,19 @@ Ox.getset <f> Generic getter and setter function
     context  <obj> The parent object of the caller function (for chaining)
     # Examples -----------------------------------------------------------------
     <script>
-        var object = new function() {
+        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>
-    > object.options("key", "val").options("key")
+    > Ox.test.object.options("key", "val").options("key")
     "val"
-    > object.options({foo: "foo", bar: "bar"}).options()
+    > Ox.test.object.options({foo: "foo", bar: "bar"}).options()
     {"key": "val", "foo": "foo", "bar": "bar"}
 @*/
 
@@ -824,13 +584,15 @@ Ox.forEach <f> forEach loop
     callback <f> Callback function
         value <*> Value
         key <n|s> Key
-    > var string = "";
-    > Ox.forEach(["f", "o", "o"], function(v, i) { string += i; })
-    > Ox.forEach({a: "f", b: "o", c: "o"}, function(v, k) { string += k; })
-    > Ox.forEach("foo", function(v) { string += v; })
-    > string
-    "012abcfoo"
 @*/
+/*
+    > 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) {
@@ -1021,11 +783,13 @@ Ox.makeArray <f> Takes an array-like object and returns a true array
     ["foo", "bar"]
     > Ox.makeArray("foo")
     ["f", "o", "o"]
-    > Ox.makeArray({0: "f", 1: "o", 2: "0", length: 3})
+    > Ox.makeArray({0: "f", 1: "o", 2: "o", length: 3})
     ["f", "o", "o"]
 @*/
 
-Ox.makeArray = Array.prototype.slice.call;
+Ox.makeArray = function(obj) {
+    return Array.prototype.slice.call(obj);
+}
 
 Ox.makeObject = function(obj) {
     /*
@@ -1689,7 +1453,6 @@ Ox.canvas <function> Generic canvas object
 @*/
 
 Ox.canvas = function() {
-    // Ox.canvas(img) or Ox.canvas(width, height)
     var c = {}, isImage = arguments.length == 1,
         image = isImage ? arguments[0] : {
             width: arguments[0], height: arguments[1]
@@ -1735,7 +1498,7 @@ Ox.documentReady = (function() {
 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
+    > Ox.element("<div>").addClass("red").addClass("red")[0].className
     "red"
     > Ox.element("<div>").attr({id: "red"}).attr("id")
     "red"
@@ -2950,6 +2713,598 @@ Ox.parseURLs = function(html) {
     );
 };
 
+/*
+================================================================================
+JavaScript functions
+================================================================================
+*/
+
+/*@
+Ox.doc <f> Generates documentation for annotated JavaScript
+    (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() {
+    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'
+        }
+    return function(source) {
+        var blocks = [],
+            items = [],
+            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');
+            // create a tree and parse its root node
+            item = parseNode(parseTree(lines));
+            if (/^[A-Z]/.test(item.name)) {
+                item.source = parseTokens(tokens[i]);
+                items.push(item);
+            } else {
+                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)
+                );
+            }
+        });
+        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;
+            Ox.print(node, node.line, 'item', item);
+            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: JSON.parse(lines[1].trim())
+                result: lines[1].trim()
+            };
+        }
+        function parseTokens(tokens, includeLeading) {
+            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 items;
+    };
+}());
+
+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 = function(source) {
+    var tests = {
+        success: [],
+        failure: []
+    };
+    Ox.doc(source).forEach(function(item) {
+        item.examples && item.examples.forEach(function(example) {
+            Ox.print(example)
+            var actual = eval(example.statement);
+            if (example.result) {
+                tests[
+                    Ox.isEqual(eval('Ox.test.result = ' + example.result), actual) ?
+                    'success' : 'failure'
+                ].push({
+                    test: example.statement,
+                    expected: example.result,
+                    actual: actual
+                });
+            }
+        });
+    });
+    return 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'
+            ],
+            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'
+            ]
+        };
+
+    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.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 functions
@@ -3275,328 +3630,6 @@ Ox.toDashes = function(str) {
     });
 };
 
-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.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'
-            ],
-            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'
-            ]
-        };
-
-    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.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;
-
-    };
-
-}()); 
-
 Ox.toSlashes = function(str) {
     /*
     >>> Ox.toSlashes("fooBarBaz")