progress on migrating to heex templates and font-icons

assets_old/node_modules/traverse/.npmignore

@@ -0,0 +1 @@
+node_modules

assets_old/node_modules/traverse/.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - 0.6

assets_old/node_modules/traverse/LICENSE

@@ -0,0 +1,24 @@
+Copyright 2010 James Halliday (mail@substack.net)
+
+This project is free software released under the MIT/X11 license:
+http://www.opensource.org/licenses/mit-license.php 
+
+Copyright 2010 James Halliday (mail@substack.net)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

assets_old/node_modules/traverse/examples/json.js

@@ -0,0 +1,16 @@
+var traverse = require('traverse');
+
+var id = 54;
+var callbacks = {};
+var obj = { moo : function () {}, foo : [2,3,4, function () {}] };
+
+var scrubbed = traverse(obj).map(function (x) {
+    if (typeof x === 'function') {
+        callbacks[id] = { id : id, f : x, path : this.path };
+        this.update('[Function]');
+        id++;
+    }
+});
+
+console.dir(scrubbed);
+console.dir(callbacks);

assets_old/node_modules/traverse/examples/leaves.js

@@ -0,0 +1,15 @@
+var traverse = require('traverse');
+
+var obj = {
+    a : [1,2,3],
+    b : 4,
+    c : [5,6],
+    d : { e : [7,8], f : 9 },
+};
+
+var leaves = traverse(obj).reduce(function (acc, x) {
+    if (this.isLeaf) acc.push(x);
+    return acc;
+}, []);
+
+console.dir(leaves);

assets_old/node_modules/traverse/examples/negative.js

@@ -0,0 +1,8 @@
+var traverse = require('traverse');
+var obj = [ 5, 6, -3, [ 7, 8, -2, 1 ], { f : 10, g : -13 } ];
+
+traverse(obj).forEach(function (x) {
+    if (x < 0) this.update(x + 128);
+});
+
+console.dir(obj);

assets_old/node_modules/traverse/examples/scrub.js

@@ -0,0 +1,10 @@
+// scrub out circular references
+var traverse = require('traverse');
+
+var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+obj.c.push(obj);
+
+var scrubbed = traverse(obj).map(function (x) {
+    if (this.circular) this.remove()
+});
+console.dir(scrubbed);

assets_old/node_modules/traverse/examples/stringify.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+var traverse = require('traverse');
+
+var obj = [ 'five', 6, -3, [ 7, 8, -2, 1 ], { f : 10, g : -13 } ];
+
+var s = '';
+traverse(obj).forEach(function to_s (node) {
+    if (Array.isArray(node)) {
+        this.before(function () { s += '[' });
+        this.post(function (child) {
+            if (!child.isLast) s += ',';
+        });
+        this.after(function () { s += ']' });
+    }
+    else if (typeof node == 'object') {
+        this.before(function () { s += '{' });
+        this.pre(function (x, key) {
+            to_s(key);
+            s += ':';
+        });
+        this.post(function (child) {
+            if (!child.isLast) s += ',';
+        });
+        this.after(function () { s += '}' });
+    }
+    else if (typeof node == 'string') {
+        s += '"' + node.toString().replace(/"/g, '\\"') + '"';
+    }
+    else if (typeof node == 'function') {
+        s += 'null';
+    }
+    else {
+        s += node.toString();
+    }
+});
+
+console.log('JSON.stringify: ' + JSON.stringify(obj));
+console.log('this stringify: ' + s);

assets_old/node_modules/traverse/index.js

@@ -0,0 +1,314 @@
+var traverse = module.exports = function (obj) {
+    return new Traverse(obj);
+};
+
+function Traverse (obj) {
+    this.value = obj;
+}
+
+Traverse.prototype.get = function (ps) {
+    var node = this.value;
+    for (var i = 0; i < ps.length; i ++) {
+        var key = ps[i];
+        if (!node || !hasOwnProperty.call(node, key)) {
+            node = undefined;
+            break;
+        }
+        node = node[key];
+    }
+    return node;
+};
+
+Traverse.prototype.has = function (ps) {
+    var node = this.value;
+    for (var i = 0; i < ps.length; i ++) {
+        var key = ps[i];
+        if (!node || !hasOwnProperty.call(node, key)) {
+            return false;
+        }
+        node = node[key];
+    }
+    return true;
+};
+
+Traverse.prototype.set = function (ps, value) {
+    var node = this.value;
+    for (var i = 0; i < ps.length - 1; i ++) {
+        var key = ps[i];
+        if (!hasOwnProperty.call(node, key)) node[key] = {};
+        node = node[key];
+    }
+    node[ps[i]] = value;
+    return value;
+};
+
+Traverse.prototype.map = function (cb) {
+    return walk(this.value, cb, true);
+};
+
+Traverse.prototype.forEach = function (cb) {
+    this.value = walk(this.value, cb, false);
+    return this.value;
+};
+
+Traverse.prototype.reduce = function (cb, init) {
+    var skip = arguments.length === 1;
+    var acc = skip ? this.value : init;
+    this.forEach(function (x) {
+        if (!this.isRoot || !skip) {
+            acc = cb.call(this, acc, x);
+        }
+    });
+    return acc;
+};
+
+Traverse.prototype.paths = function () {
+    var acc = [];
+    this.forEach(function (x) {
+        acc.push(this.path); 
+    });
+    return acc;
+};
+
+Traverse.prototype.nodes = function () {
+    var acc = [];
+    this.forEach(function (x) {
+        acc.push(this.node);
+    });
+    return acc;
+};
+
+Traverse.prototype.clone = function () {
+    var parents = [], nodes = [];
+    
+    return (function clone (src) {
+        for (var i = 0; i < parents.length; i++) {
+            if (parents[i] === src) {
+                return nodes[i];
+            }
+        }
+        
+        if (typeof src === 'object' && src !== null) {
+            var dst = copy(src);
+            
+            parents.push(src);
+            nodes.push(dst);
+            
+            forEach(objectKeys(src), function (key) {
+                dst[key] = clone(src[key]);
+            });
+            
+            parents.pop();
+            nodes.pop();
+            return dst;
+        }
+        else {
+            return src;
+        }
+    })(this.value);
+};
+
+function walk (root, cb, immutable) {
+    var path = [];
+    var parents = [];
+    var alive = true;
+    
+    return (function walker (node_) {
+        var node = immutable ? copy(node_) : node_;
+        var modifiers = {};
+        
+        var keepGoing = true;
+        
+        var state = {
+            node : node,
+            node_ : node_,
+            path : [].concat(path),
+            parent : parents[parents.length - 1],
+            parents : parents,
+            key : path.slice(-1)[0],
+            isRoot : path.length === 0,
+            level : path.length,
+            circular : null,
+            update : function (x, stopHere) {
+                if (!state.isRoot) {
+                    state.parent.node[state.key] = x;
+                }
+                state.node = x;
+                if (stopHere) keepGoing = false;
+            },
+            'delete' : function (stopHere) {
+                delete state.parent.node[state.key];
+                if (stopHere) keepGoing = false;
+            },
+            remove : function (stopHere) {
+                if (isArray(state.parent.node)) {
+                    state.parent.node.splice(state.key, 1);
+                }
+                else {
+                    delete state.parent.node[state.key];
+                }
+                if (stopHere) keepGoing = false;
+            },
+            keys : null,
+            before : function (f) { modifiers.before = f },
+            after : function (f) { modifiers.after = f },
+            pre : function (f) { modifiers.pre = f },
+            post : function (f) { modifiers.post = f },
+            stop : function () { alive = false },
+            block : function () { keepGoing = false }
+        };
+        
+        if (!alive) return state;
+        
+        function updateState() {
+            if (typeof state.node === 'object' && state.node !== null) {
+                if (!state.keys || state.node_ !== state.node) {
+                    state.keys = objectKeys(state.node)
+                }
+                
+                state.isLeaf = state.keys.length == 0;
+                
+                for (var i = 0; i < parents.length; i++) {
+                    if (parents[i].node_ === node_) {
+                        state.circular = parents[i];
+                        break;
+                    }
+                }
+            }
+            else {
+                state.isLeaf = true;
+                state.keys = null;
+            }
+            
+            state.notLeaf = !state.isLeaf;
+            state.notRoot = !state.isRoot;
+        }
+        
+        updateState();
+        
+        // use return values to update if defined
+        var ret = cb.call(state, state.node);
+        if (ret !== undefined && state.update) state.update(ret);
+        
+        if (modifiers.before) modifiers.before.call(state, state.node);
+        
+        if (!keepGoing) return state;
+        
+        if (typeof state.node == 'object'
+        && state.node !== null && !state.circular) {
+            parents.push(state);
+            
+            updateState();
+            
+            forEach(state.keys, function (key, i) {
+                path.push(key);
+                
+                if (modifiers.pre) modifiers.pre.call(state, state.node[key], key);
+                
+                var child = walker(state.node[key]);
+                if (immutable && hasOwnProperty.call(state.node, key)) {
+                    state.node[key] = child.node;
+                }
+                
+                child.isLast = i == state.keys.length - 1;
+                child.isFirst = i == 0;
+                
+                if (modifiers.post) modifiers.post.call(state, child);
+                
+                path.pop();
+            });
+            parents.pop();
+        }
+        
+        if (modifiers.after) modifiers.after.call(state, state.node);
+        
+        return state;
+    })(root).node;
+}
+
+function copy (src) {
+    if (typeof src === 'object' && src !== null) {
+        var dst;
+        
+        if (isArray(src)) {
+            dst = [];
+        }
+        else if (isDate(src)) {
+            dst = new Date(src.getTime ? src.getTime() : src);
+        }
+        else if (isRegExp(src)) {
+            dst = new RegExp(src);
+        }
+        else if (isError(src)) {
+            dst = { message: src.message };
+        }
+        else if (isBoolean(src)) {
+            dst = new Boolean(src);
+        }
+        else if (isNumber(src)) {
+            dst = new Number(src);
+        }
+        else if (isString(src)) {
+            dst = new String(src);
+        }
+        else if (Object.create && Object.getPrototypeOf) {
+            dst = Object.create(Object.getPrototypeOf(src));
+        }
+        else if (src.constructor === Object) {
+            dst = {};
+        }
+        else {
+            var proto =
+                (src.constructor && src.constructor.prototype)
+                || src.__proto__
+                || {}
+            ;
+            var T = function () {};
+            T.prototype = proto;
+            dst = new T;
+        }
+        
+        forEach(objectKeys(src), function (key) {
+            dst[key] = src[key];
+        });
+        return dst;
+    }
+    else return src;
+}
+
+var objectKeys = Object.keys || function keys (obj) {
+    var res = [];
+    for (var key in obj) res.push(key)
+    return res;
+};
+
+function toS (obj) { return Object.prototype.toString.call(obj) }
+function isDate (obj) { return toS(obj) === '[object Date]' }
+function isRegExp (obj) { return toS(obj) === '[object RegExp]' }
+function isError (obj) { return toS(obj) === '[object Error]' }
+function isBoolean (obj) { return toS(obj) === '[object Boolean]' }
+function isNumber (obj) { return toS(obj) === '[object Number]' }
+function isString (obj) { return toS(obj) === '[object String]' }
+
+var isArray = Array.isArray || function isArray (xs) {
+    return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+var forEach = function (xs, fn) {
+    if (xs.forEach) return xs.forEach(fn)
+    else for (var i = 0; i < xs.length; i++) {
+        fn(xs[i], i, xs);
+    }
+};
+
+forEach(objectKeys(Traverse.prototype), function (key) {
+    traverse[key] = function (obj) {
+        var args = [].slice.call(arguments, 1);
+        var t = new Traverse(obj);
+        return t[key].apply(t, args);
+    };
+});
+
+var hasOwnProperty = Object.hasOwnProperty || function (obj, key) {
+    return key in obj;
+};

assets_old/node_modules/traverse/package.json

@@ -0,0 +1,46 @@
+{
+    "name" : "traverse",
+    "version" : "0.6.6",
+    "description" : "traverse and transform objects by visiting every node on a recursive walk",
+    "main" : "index.js",
+    "directories" : {
+        "example" : "example",
+        "test" : "test"
+    },
+    "devDependencies" : {
+        "tape" : "~1.0.4"
+    },
+    "scripts" : {
+        "test" : "tape test/*.js"
+    },
+    "testling" : {
+        "files" : "test/*.js",
+        "browsers" : {
+            "iexplore" : [ "6.0", "7.0", "8.0", "9.0" ],
+            "chrome" : [ "10.0", "20.0" ],
+            "firefox" : [ "10.0", "15.0" ],
+            "safari" : [ "5.1" ],
+            "opera" : [ "12.0" ]
+        }
+    },
+    "repository" : {
+        "type" : "git",
+        "url" : "git://github.com/substack/js-traverse.git"
+    },
+    "homepage" : "https://github.com/substack/js-traverse",
+    "keywords" : [
+        "traverse",
+        "walk",
+        "recursive",
+        "map",
+        "forEach",
+        "deep",
+        "clone"
+    ],
+    "author" : {
+        "name" : "James Halliday",
+        "email" : "mail@substack.net",
+        "url" : "http://substack.net"
+    },
+    "license" : "MIT"
+}

assets_old/node_modules/traverse/readme.markdown

@@ -0,0 +1,209 @@
+# traverse
+
+Traverse and transform objects by visiting every node on a recursive walk.
+
+[![browser support](http://ci.testling.com/substack/js-traverse.png)](http://ci.testling.com/substack/js-traverse)
+
+[![build status](https://secure.travis-ci.org/substack/js-traverse.png)](http://travis-ci.org/substack/js-traverse)
+
+# examples
+
+## transform negative numbers in-place
+
+negative.js
+
+````javascript
+var traverse = require('traverse');
+var obj = [ 5, 6, -3, [ 7, 8, -2, 1 ], { f : 10, g : -13 } ];
+
+traverse(obj).forEach(function (x) {
+    if (x < 0) this.update(x + 128);
+});
+
+console.dir(obj);
+````
+
+Output:
+
+    [ 5, 6, 125, [ 7, 8, 126, 1 ], { f: 10, g: 115 } ]
+
+## collect leaf nodes
+
+leaves.js
+
+````javascript
+var traverse = require('traverse');
+
+var obj = {
+    a : [1,2,3],
+    b : 4,
+    c : [5,6],
+    d : { e : [7,8], f : 9 },
+};
+
+var leaves = traverse(obj).reduce(function (acc, x) {
+    if (this.isLeaf) acc.push(x);
+    return acc;
+}, []);
+
+console.dir(leaves);
+````
+
+Output:
+
+    [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
+
+## scrub circular references
+
+scrub.js:
+
+````javascript
+var traverse = require('traverse');
+
+var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+obj.c.push(obj);
+
+var scrubbed = traverse(obj).map(function (x) {
+    if (this.circular) this.remove()
+});
+console.dir(scrubbed);
+````
+
+output:
+
+    { a: 1, b: 2, c: [ 3, 4 ] }
+
+# methods
+
+Each method that takes an `fn` uses the context documented below in the context
+section.
+
+## .map(fn)
+
+Execute `fn` for each node in the object and return a new object with the
+results of the walk. To update nodes in the result use `this.update(value)`.
+
+## .forEach(fn)
+
+Execute `fn` for each node in the object but unlike `.map()`, when
+`this.update()` is called it updates the object in-place.
+
+## .reduce(fn, acc)
+
+For each node in the object, perform a
+[left-fold](http://en.wikipedia.org/wiki/Fold_(higher-order_function))
+with the return value of `fn(acc, node)`.
+
+If `acc` isn't specified, `acc` is set to the root object for the first step
+and the root element is skipped.
+
+## .paths()
+
+Return an `Array` of every possible non-cyclic path in the object.
+Paths are `Array`s of string keys.
+
+## .nodes()
+
+Return an `Array` of every node in the object.
+
+## .clone()
+
+Create a deep clone of the object.
+
+## .get(path)
+
+Get the element at the array `path`.
+
+## .set(path, value)
+
+Set the element at the array `path` to `value`.
+
+## .has(path)
+
+Return whether the element at the array `path` exists.
+
+# context
+
+Each method that takes a callback has a context (its `this` object) with these
+attributes:
+
+## this.node
+
+The present node on the recursive walk
+
+## this.path
+
+An array of string keys from the root to the present node
+
+## this.parent
+
+The context of the node's parent.
+This is `undefined` for the root node.
+
+## this.key
+
+The name of the key of the present node in its parent.
+This is `undefined` for the root node.
+
+## this.isRoot, this.notRoot
+
+Whether the present node is the root node
+
+## this.isLeaf, this.notLeaf
+
+Whether or not the present node is a leaf node (has no children)
+
+## this.level
+
+Depth of the node within the traversal
+
+## this.circular
+
+If the node equals one of its parents, the `circular` attribute is set to the
+context of that parent and the traversal progresses no deeper.
+
+## this.update(value, stopHere=false)
+
+Set a new value for the present node.
+
+All the elements in `value` will be recursively traversed unless `stopHere` is
+true.
+
+## this.remove(stopHere=false)
+
+Remove the current element from the output. If the node is in an Array it will
+be spliced off. Otherwise it will be deleted from its parent.
+
+## this.delete(stopHere=false)
+
+Delete the current element from its parent in the output. Calls `delete` even on
+Arrays.
+
+## this.before(fn)
+
+Call this function before any of the children are traversed.
+
+You can assign into `this.keys` here to traverse in a custom order.
+
+## this.after(fn)
+
+Call this function after any of the children are traversed.
+
+## this.pre(fn)
+
+Call this function before each of the children are traversed.
+
+## this.post(fn)
+
+Call this function after each of the children are traversed.
+
+
+# install
+
+Using [npm](http://npmjs.org) do:
+
+    $ npm install traverse
+
+# license
+
+MIT

assets_old/node_modules/traverse/test/circular.js

@@ -0,0 +1,117 @@
+var test = require('tape');
+var traverse = require('../');
+var deepEqual = require('./lib/deep_equal');
+var util = require('util');
+
+test('circular', function (t) {
+    t.plan(1);
+    
+    var obj = { x : 3 };
+    obj.y = obj;
+    traverse(obj).forEach(function (x) {
+        if (this.path.join('') == 'y') {
+            t.equal(
+                util.inspect(this.circular.node),
+                util.inspect(obj)
+            );
+        }
+    });
+});
+
+test('deepCirc', function (t) {
+    t.plan(2);
+    var obj = { x : [ 1, 2, 3 ], y : [ 4, 5 ] };
+    obj.y[2] = obj;
+    
+    var times = 0;
+    traverse(obj).forEach(function (x) {
+        if (this.circular) {
+            t.same(this.circular.path, []);
+            t.same(this.path, [ 'y', 2 ]);
+        }
+    });
+});
+
+test('doubleCirc', function (t) {
+    var obj = { x : [ 1, 2, 3 ], y : [ 4, 5 ] };
+    obj.y[2] = obj;
+    obj.x.push(obj.y);
+    
+    var circs = [];
+    traverse(obj).forEach(function (x) {
+        if (this.circular) {
+            circs.push({ circ : this.circular, self : this, node : x });
+        }
+    });
+    
+    t.same(circs[0].self.path, [ 'x', 3, 2 ]);
+    t.same(circs[0].circ.path, []);
+     
+    t.same(circs[1].self.path, [ 'y', 2 ]);
+    t.same(circs[1].circ.path, []);
+    
+    t.same(circs.length, 2);
+    t.end();
+});
+
+test('circDubForEach', function (t) {
+    var obj = { x : [ 1, 2, 3 ], y : [ 4, 5 ] };
+    obj.y[2] = obj;
+    obj.x.push(obj.y);
+    
+    traverse(obj).forEach(function (x) {
+        if (this.circular) this.update('...');
+    });
+    
+    t.same(obj, { x : [ 1, 2, 3, [ 4, 5, '...' ] ], y : [ 4, 5, '...' ] });
+    t.end();
+});
+
+test('circDubMap', function (t) {
+    var obj = { x : [ 1, 2, 3 ], y : [ 4, 5 ] };
+    obj.y[2] = obj;
+    obj.x.push(obj.y);
+    
+    var c = traverse(obj).map(function (x) {
+        if (this.circular) {
+            this.update('...');
+        }
+    });
+    
+    t.same(c, { x : [ 1, 2, 3, [ 4, 5, '...' ] ], y : [ 4, 5, '...' ] });
+    t.end();
+});
+
+test('circClone', function (t) {
+    var obj = { x : [ 1, 2, 3 ], y : [ 4, 5 ] };
+    obj.y[2] = obj;
+    obj.x.push(obj.y);
+    
+    var clone = traverse.clone(obj);
+    t.ok(obj !== clone);
+    
+    t.ok(clone.y[2] === clone);
+    t.ok(clone.y[2] !== obj);
+    t.ok(clone.x[3][2] === clone);
+    t.ok(clone.x[3][2] !== obj);
+    t.same(clone.x.slice(0,3), [1,2,3]);
+    t.same(clone.y.slice(0,2), [4,5]);
+    t.end();
+});
+
+test('circMapScrub', function (t) {
+    var obj = { a : 1, b : 2 };
+    obj.c = obj;
+    
+    var scrubbed = traverse(obj).map(function (node) {
+        if (this.circular) this.remove();
+    });
+    t.same(
+        Object.keys(scrubbed).sort(),
+        [ 'a', 'b' ]
+    );
+    t.ok(deepEqual(scrubbed, { a : 1, b : 2 }));
+    
+    t.equal(obj.c, obj);
+    t.end();
+});

assets_old/node_modules/traverse/test/date.js

@@ -0,0 +1,37 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('dateEach', function (t) {
+    var obj = { x : new Date, y : 10, z : 5 };
+    
+    var counts = {};
+    
+    traverse(obj).forEach(function (node) {
+        var t = (node instanceof Date && 'Date') || typeof node;
+        counts[t] = (counts[t] || 0) + 1;
+    });
+    
+    t.same(counts, {
+        object : 1,
+        Date : 1,
+        number : 2,
+    });
+    t.end();
+});
+
+test('dateMap', function (t) {
+    var obj = { x : new Date, y : 10, z : 5 };
+    
+    var res = traverse(obj).map(function (node) {
+        if (typeof node === 'number') this.update(node + 100);
+    });
+    
+    t.ok(obj.x !== res.x);
+    t.same(res, {
+        x : obj.x,
+        y : 110,
+        z : 105,
+    });
+    t.end();
+});
+

assets_old/node_modules/traverse/test/equal.js

@@ -0,0 +1,240 @@
+var test = require('tape');
+var traverse = require('../');
+var deepEqual = require('./lib/deep_equal');
+
+test('deepDates', function (t) {
+    t.plan(2);
+    
+    t.ok(
+        deepEqual(
+            { d : new Date, x : [ 1, 2, 3 ] },
+            { d : new Date, x : [ 1, 2, 3 ] }
+        ),
+        'dates should be equal'
+    );
+    
+    var d0 = new Date;
+    setTimeout(function () {
+        t.ok(
+            !deepEqual(
+                { d : d0, x : [ 1, 2, 3 ], },
+                { d : new Date, x : [ 1, 2, 3 ] }
+            ),
+            'microseconds should count in date equality'
+        );
+    }, 5);
+});
+
+test('deepCircular', function (t) {
+    var a = [1];
+    a.push(a); // a = [ 1, *a ]
+    
+    var b = [1];
+    b.push(a); // b = [ 1, [ 1, *a ] ]
+    
+    t.ok(
+        !deepEqual(a, b),
+        'circular ref mount points count towards equality'
+    );
+    
+    var c = [1];
+    c.push(c); // c = [ 1, *c ]
+    t.ok(
+        deepEqual(a, c),
+        'circular refs are structurally the same here'
+    );
+    
+    var d = [1];
+    d.push(a); // c = [ 1, [ 1, *d ] ]
+    t.ok(
+        deepEqual(b, d),
+        'non-root circular ref structural comparison'
+    );
+    
+    t.end();
+});
+
+test('deepInstances', function (t) {
+    t.ok(
+        !deepEqual([ new Boolean(false) ], [ false ]),
+        'boolean instances are not real booleans'
+    );
+    
+    t.ok(
+        !deepEqual([ new String('x') ], [ 'x' ]),
+        'string instances are not real strings'
+    );
+    
+    t.ok(
+        !deepEqual([ new Number(4) ], [ 4 ]),
+        'number instances are not real numbers'
+    );
+    
+    t.ok(
+        deepEqual([ new RegExp('x') ], [ /x/ ]),
+        'regexp instances are real regexps'
+    );
+    
+    t.ok(
+        !deepEqual([ new RegExp(/./) ], [ /../ ]),
+        'these regexps aren\'t the same'
+    );
+    
+    t.ok(
+        !deepEqual(
+            [ function (x) { return x * 2 } ],
+            [ function (x) { return x * 2 } ]
+        ),
+        'functions with the same .toString() aren\'t necessarily the same'
+    );
+    
+    var f = function (x) { return x * 2 };
+    t.ok(
+        deepEqual([ f ], [ f ]),
+        'these functions are actually equal'
+    );
+    
+    t.end();
+});
+
+test('deepEqual', function (t) {
+    t.ok(
+        !deepEqual([ 1, 2, 3 ], { 0 : 1, 1 : 2, 2 : 3 }),
+        'arrays are not objects'
+    );
+    t.end();
+});
+
+test('falsy', function (t) {
+    t.ok(
+        !deepEqual([ undefined ], [ null ]),
+        'null is not undefined!'
+    );
+    
+    t.ok(
+        !deepEqual([ null ], [ undefined ]),
+        'undefined is not null!'
+    );
+    
+    t.ok(
+        !deepEqual(
+            { a : 1, b : 2, c : [ 3, undefined, 5 ] },
+            { a : 1, b : 2, c : [ 3, null, 5 ] }
+        ),
+        'undefined is not null, however deeply!'
+    );
+    
+    t.ok(
+        !deepEqual(
+            { a : 1, b : 2, c : [ 3, undefined, 5 ] },
+            { a : 1, b : 2, c : [ 3, null, 5 ] }
+        ),
+        'null is not undefined, however deeply!'
+    );
+    
+    t.ok(
+        !deepEqual(
+            { a : 1, b : 2, c : [ 3, undefined, 5 ] },
+            { a : 1, b : 2, c : [ 3, null, 5 ] }
+        ),
+        'null is not undefined, however deeply!'
+    );
+    
+    t.end();
+});
+
+test('deletedArrayEqual', function (t) {
+    var xs = [ 1, 2, 3, 4 ];
+    delete xs[2];
+    
+    var ys = Object.create(Array.prototype);
+    ys[0] = 1;
+    ys[1] = 2;
+    ys[3] = 4;
+    
+    t.ok(
+        deepEqual(xs, ys),
+        'arrays with deleted elements are only equal to'
+        + ' arrays with similarly deleted elements'
+    );
+    
+    t.ok(
+        !deepEqual(xs, [ 1, 2, undefined, 4 ]),
+        'deleted array elements cannot be undefined'
+    );
+    
+    t.ok(
+        !deepEqual(xs, [ 1, 2, null, 4 ]),
+        'deleted array elements cannot be null'
+    );
+    
+    t.end();
+});
+
+test('deletedObjectEqual', function (t) {
+    var obj = { a : 1, b : 2, c : 3 };
+    delete obj.c;
+    
+    t.ok(
+        deepEqual(obj, { a : 1, b : 2 }),
+        'deleted object elements should not show up'
+    );
+    
+    t.ok(
+        !deepEqual(obj, { a : 1, b : 2, c : undefined }),
+        'deleted object elements are not undefined'
+    );
+    
+    t.ok(
+        !deepEqual(obj, { a : 1, b : 2, c : null }),
+        'deleted object elements are not null'
+    );
+    
+    t.end();
+});
+
+test('emptyKeyEqual', function (t) {
+    t.ok(!deepEqual(
+        { a : 1 }, { a : 1, '' : 55 }
+    ));
+    
+    t.end();
+});
+
+test('deepArguments', function (t) {
+    t.ok(
+        !deepEqual(
+            [ 4, 5, 6 ],
+            (function () { return arguments })(4, 5, 6)
+        ),
+        'arguments are not arrays'
+    );
+    
+    t.ok(
+        deepEqual(
+            (function () { return arguments })(4, 5, 6),
+            (function () { return arguments })(4, 5, 6)
+        ),
+        'arguments should equal'
+    );
+    
+    t.end();
+});
+
+test('deepUn', function (t) {
+    t.ok(!deepEqual({ a : 1, b : 2 }, undefined));
+    t.ok(!deepEqual({ a : 1, b : 2 }, {}));
+    t.ok(!deepEqual(undefined, { a : 1, b : 2 }));
+    t.ok(!deepEqual({}, { a : 1, b : 2 }));
+    t.ok(deepEqual(undefined, undefined));
+    t.ok(deepEqual(null, null));
+    t.ok(!deepEqual(undefined, null));
+    
+    t.end();
+});
+
+test('deepLevels', function (t) {
+    var xs = [ 1, 2, [ 3, 4, [ 5, 6 ] ] ];
+    t.ok(!deepEqual(xs, []));
+    t.end();
+});

assets_old/node_modules/traverse/test/error.js

@@ -0,0 +1,11 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('traverse an Error', function (t) {
+    var obj = new Error("test");
+    var results = traverse(obj).map(function (node) {});
+    t.same(results, { message: 'test' });
+    
+    t.end();
+});
+

assets_old/node_modules/traverse/test/has.js

@@ -0,0 +1,15 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('has', function (t) {
+    var obj = { a : 2, b : [ 4, 5, { c : 6 } ] };
+    
+    t.equal(traverse(obj).has([ 'b', 2, 'c' ]), true)
+    t.equal(traverse(obj).has([ 'b', 2, 'c', 0 ]), false)
+    t.equal(traverse(obj).has([ 'b', 2, 'd' ]), false)
+    t.equal(traverse(obj).has([]), true)
+    t.equal(traverse(obj).has([ 'a' ]), true)
+    t.equal(traverse(obj).has([ 'a', 2 ]), false)
+    
+    t.end();
+});

assets_old/node_modules/traverse/test/instance.js

@@ -0,0 +1,17 @@
+var test = require('tape');
+var traverse = require('../');
+var EventEmitter = require('events').EventEmitter;
+
+test('check instanceof on node elems', function (t) {
+    var counts = { emitter : 0 };
+    
+    traverse([ new EventEmitter, 3, 4, { ev : new EventEmitter }])
+        .forEach(function (node) {
+            if (node instanceof EventEmitter) counts.emitter ++;
+        })
+    ;
+    
+    t.equal(counts.emitter, 2);
+    
+    t.end();
+});

assets_old/node_modules/traverse/test/interface.js

@@ -0,0 +1,43 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('interface map', function (t) {
+    var obj = { a : [ 5,6,7 ], b : { c : [8] } };
+    
+    t.same(
+        traverse.paths(obj)
+            .sort()
+            .map(function (path) { return path.join('/') })
+            .slice(1)
+            .join(' ')
+         ,
+         'a a/0 a/1 a/2 b b/c b/c/0'
+    );
+    
+    t.same(
+        traverse.nodes(obj),
+        [
+            { a: [ 5, 6, 7 ], b: { c: [ 8 ] } },
+            [ 5, 6, 7 ], 5, 6, 7,
+            { c: [ 8 ] }, [ 8 ], 8
+        ]
+    );
+    
+    t.same(
+        traverse.map(obj, function (node) {
+            if (typeof node == 'number') {
+                return node + 1000;
+            }
+            else if (Array.isArray(node)) {
+                return node.join(' ');
+            }
+        }),
+        { a: '5 6 7', b: { c: '8' } }
+    );
+    
+    var nodes = 0;
+    traverse.forEach(obj, function (node) { nodes ++ });
+    t.same(nodes, 8);
+    
+    t.end();
+});

assets_old/node_modules/traverse/test/json.js

@@ -0,0 +1,49 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('json test', function (t) {
+    var id = 54;
+    var callbacks = {};
+    var obj = { moo : function () {}, foo : [2,3,4, function () {}] };
+    
+    var scrubbed = traverse(obj).map(function (x) {
+        if (typeof x === 'function') {
+            callbacks[id] = { id : id, f : x, path : this.path };
+            this.update('[Function]');
+            id++;
+        }
+    });
+    
+    t.equal(
+        scrubbed.moo, '[Function]',
+        'obj.moo replaced with "[Function]"'
+    );
+    
+    t.equal(
+        scrubbed.foo[3], '[Function]',
+        'obj.foo[3] replaced with "[Function]"'
+    );
+    
+    t.same(scrubbed, {
+        moo : '[Function]',
+        foo : [ 2, 3, 4, "[Function]" ]
+    }, 'Full JSON string matches');
+    
+    t.same(
+        typeof obj.moo, 'function',
+        'Original obj.moo still a function'
+    );
+    
+    t.same(
+        typeof obj.foo[3], 'function',
+        'Original obj.foo[3] still a function'
+    );
+    
+    t.same(callbacks, {
+        54: { id: 54, f : obj.moo, path: [ 'moo' ] },
+        55: { id: 55, f : obj.foo[3], path: [ 'foo', '3' ] },
+    }, 'Check the generated callbacks list');
+    
+    t.end();
+});
+

assets_old/node_modules/traverse/test/keys.js

@@ -0,0 +1,31 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('sort test', function (t) {
+    var acc = [];
+    traverse({
+        a: 30,
+        b: 22,
+        id: 9
+    }).forEach(function (node) {
+        if ((! Array.isArray(node)) && typeof node === 'object') {
+            this.before(function(node) {
+                this.keys = Object.keys(node);
+                this.keys.sort(function(a, b) {
+                    a = [a === "id" ? 0 : 1, a];
+                    b = [b === "id" ? 0 : 1, b];
+                    return a < b ? -1 : a > b ? 1 : 0;
+                });
+            });
+        }
+        if (this.isLeaf) acc.push(node);
+    });
+    
+    t.equal(
+        acc.join(' '),
+        '9 30 22',
+        'Traversal in a custom order'
+    );
+    
+    t.end();
+});

assets_old/node_modules/traverse/test/leaves.js

@@ -0,0 +1,22 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('leaves test', function (t) {
+    var acc = [];
+    traverse({
+        a : [1,2,3],
+        b : 4,
+        c : [5,6],
+        d : { e : [7,8], f : 9 }
+    }).forEach(function (x) {
+        if (this.isLeaf) acc.push(x);
+    });
+    
+    t.equal(
+        acc.join(' '),
+        '1 2 3 4 5 6 7 8 9',
+        'Traversal in the right(?) order'
+    );
+    
+    t.end();
+});

assets_old/node_modules/traverse/test/lib/deep_equal.js

@@ -0,0 +1,96 @@
+var traverse = require('../../');
+
+module.exports = function (a, b) {
+    if (arguments.length !== 2) {
+        throw new Error(
+            'deepEqual requires exactly two objects to compare against'
+        );
+    }
+    
+    var equal = true;
+    var node = b;
+    
+    traverse(a).forEach(function (y) {
+        var notEqual = (function () {
+            equal = false;
+            //this.stop();
+            return undefined;
+        }).bind(this);
+        
+        //if (node === undefined || node === null) return notEqual();
+        
+        if (!this.isRoot) {
+        /*
+            if (!Object.hasOwnProperty.call(node, this.key)) {
+                return notEqual();
+            }
+        */
+            if (typeof node !== 'object') return notEqual();
+            node = node[this.key];
+        }
+        
+        var x = node;
+        
+        this.post(function () {
+            node = x;
+        });
+        
+        var toS = function (o) {
+            return Object.prototype.toString.call(o);
+        };
+        
+        if (this.circular) {
+            if (traverse(b).get(this.circular.path) !== x) notEqual();
+        }
+        else if (typeof x !== typeof y) {
+            notEqual();
+        }
+        else if (x === null || y === null || x === undefined || y === undefined) {
+            if (x !== y) notEqual();
+        }
+        else if (x.__proto__ !== y.__proto__) {
+            notEqual();
+        }
+        else if (x === y) {
+            // nop
+        }
+        else if (typeof x === 'function') {
+            if (x instanceof RegExp) {
+                // both regexps on account of the __proto__ check
+                if (x.toString() != y.toString()) notEqual();
+            }
+            else if (x !== y) notEqual();
+        }
+        else if (typeof x === 'object') {
+            if (toS(y) === '[object Arguments]'
+            || toS(x) === '[object Arguments]') {
+                if (toS(x) !== toS(y)) {
+                    notEqual();
+                }
+            }
+            else if (toS(y) === '[object RegExp]'
+            || toS(x) === '[object RegExp]') {
+                if (!x || !y || x.toString() !== y.toString()) notEqual();
+            }
+            else if (x instanceof Date || y instanceof Date) {
+                if (!(x instanceof Date) || !(y instanceof Date)
+                || x.getTime() !== y.getTime()) {
+                    notEqual();
+                }
+            }
+            else {
+                var kx = Object.keys(x);
+                var ky = Object.keys(y);
+                if (kx.length !== ky.length) return notEqual();
+                for (var i = 0; i < kx.length; i++) {
+                    var k = kx[i];
+                    if (!Object.hasOwnProperty.call(y, k)) {
+                        notEqual();
+                    }
+                }
+            }
+        }
+    });
+    
+    return equal;
+};

assets_old/node_modules/traverse/test/mutability.js

@@ -0,0 +1,300 @@
+var test = require('tape');
+var traverse = require('../');
+var deepEqual = require('./lib/deep_equal');
+
+test('mutate', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse(obj).forEach(function (x) {
+        if (typeof x === 'number' && x % 2 === 0) {
+            this.update(x * 10);
+        }
+    });
+    t.same(obj, res);
+    t.same(obj, { a : 1, b : 20, c : [ 3, 40 ] });
+    t.end();
+});
+
+test('mutateT', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse.forEach(obj, function (x) {
+        if (typeof x === 'number' && x % 2 === 0) {
+            this.update(x * 10);
+        }
+    });
+    t.same(obj, res);
+    t.same(obj, { a : 1, b : 20, c : [ 3, 40 ] });
+    t.end();
+});
+
+test('map', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse(obj).map(function (x) {
+        if (typeof x === 'number' && x % 2 === 0) {
+            this.update(x * 10);
+        }
+    });
+    t.same(obj, { a : 1, b : 2, c : [ 3, 4 ] });
+    t.same(res, { a : 1, b : 20, c : [ 3, 40 ] });
+    t.end();
+});
+
+test('mapT', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse.map(obj, function (x) {
+        if (typeof x === 'number' && x % 2 === 0) {
+            this.update(x * 10);
+        }
+    });
+    t.same(obj, { a : 1, b : 2, c : [ 3, 4 ] });
+    t.same(res, { a : 1, b : 20, c : [ 3, 40 ] });
+    t.end();
+});
+
+test('clone', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse(obj).clone();
+    t.same(obj, res);
+    t.ok(obj !== res);
+    obj.a ++;
+    t.same(res.a, 1);
+    obj.c.push(5);
+    t.same(res.c, [ 3, 4 ]);
+    t.end();
+});
+
+test('cloneT', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse.clone(obj);
+    t.same(obj, res);
+    t.ok(obj !== res);
+    obj.a ++;
+    t.same(res.a, 1);
+    obj.c.push(5);
+    t.same(res.c, [ 3, 4 ]);
+    t.end();
+});
+
+test('reduce', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse(obj).reduce(function (acc, x) {
+        if (this.isLeaf) acc.push(x);
+        return acc;
+    }, []);
+    t.same(obj, { a : 1, b : 2, c : [ 3, 4 ] });
+    t.same(res, [ 1, 2, 3, 4 ]);
+    t.end();
+});
+
+test('reduceInit', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse(obj).reduce(function (acc, x) {
+        if (this.isRoot) assert.fail('got root');
+        return acc;
+    });
+    t.same(obj, { a : 1, b : 2, c : [ 3, 4 ] });
+    t.same(res, obj);
+    t.end();
+});
+
+test('remove', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    traverse(obj).forEach(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.remove();
+    });
+    
+    t.same(obj, { a : 1, c : [ 3 ] });
+    t.end();
+});
+
+exports.removeNoStop = function() {
+    var obj = { a : 1, b : 2, c : { d: 3, e: 4 }, f: 5 };
+    
+    var keys = [];
+    traverse(obj).forEach(function (x) {
+        keys.push(this.key)
+        if (this.key == 'c') this.remove();
+    });
+
+    t.same(keys, [undefined, 'a', 'b', 'c', 'd', 'e', 'f'])
+    t.end();
+}
+
+exports.removeStop = function() {
+    var obj = { a : 1, b : 2, c : { d: 3, e: 4 }, f: 5 };
+    
+    var keys = [];
+    traverse(obj).forEach(function (x) {
+        keys.push(this.key)
+        if (this.key == 'c') this.remove(true);
+    });
+
+    t.same(keys, [undefined, 'a', 'b', 'c', 'f'])
+    t.end();
+}
+
+test('removeMap', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse(obj).map(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.remove();
+    });
+    
+    t.same(obj, { a : 1, b : 2, c : [ 3, 4 ] });
+    t.same(res, { a : 1, c : [ 3 ] });
+    t.end();
+});
+
+test('delete', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    traverse(obj).forEach(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.delete();
+    });
+    
+    t.ok(!deepEqual(
+        obj, { a : 1, c : [ 3, undefined ] }
+    ));
+    
+    t.ok(deepEqual(
+        obj, { a : 1, c : [ 3 ] }
+    ));
+    
+    t.ok(!deepEqual(
+        obj, { a : 1, c : [ 3, null ] }
+    ));
+    t.end();
+});
+
+test('deleteNoStop', function (t) {
+    var obj = { a : 1, b : 2, c : { d: 3, e: 4 } };
+    
+    var keys = [];
+    traverse(obj).forEach(function (x) {
+        keys.push(this.key)
+        if (this.key == 'c') this.delete();
+    });
+
+    t.same(keys, [undefined, 'a', 'b', 'c', 'd', 'e'])
+    t.end();
+});
+
+test('deleteStop', function (t) {
+    var obj = { a : 1, b : 2, c : { d: 3, e: 4 } };
+    
+    var keys = [];
+    traverse(obj).forEach(function (x) {
+        keys.push(this.key)
+        if (this.key == 'c') this.delete(true);
+    });
+
+    t.same(keys, [undefined, 'a', 'b', 'c'])
+    t.end();
+});
+
+test('deleteRedux', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4, 5 ] };
+    traverse(obj).forEach(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.delete();
+    });
+    
+    t.ok(!deepEqual(
+        obj, { a : 1, c : [ 3, undefined, 5 ] }
+    ));
+    
+    t.ok(deepEqual(
+        obj, { a : 1, c : [ 3 ,, 5 ] }
+    ));
+    
+    t.ok(!deepEqual(
+        obj, { a : 1, c : [ 3, null, 5 ] }
+    ));
+    
+    t.ok(!deepEqual(
+        obj, { a : 1, c : [ 3, 5 ] }
+    ));
+    
+    t.end();
+});
+
+test('deleteMap', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse(obj).map(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.delete();
+    });
+    
+    t.ok(deepEqual(
+        obj,
+        { a : 1, b : 2, c : [ 3, 4 ] }
+    ));
+    
+    var xs = [ 3, 4 ];
+    delete xs[1];
+    
+    t.ok(deepEqual(
+        res, { a : 1, c : xs }
+    ));
+    
+    t.ok(deepEqual(
+        res, { a : 1, c : [ 3, ] }
+    ));
+    
+    t.ok(deepEqual(
+        res, { a : 1, c : [ 3 ] }
+    ));
+    
+    t.end();
+});
+
+test('deleteMapRedux', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4, 5 ] };
+    var res = traverse(obj).map(function (x) {
+        if (this.isLeaf && x % 2 == 0) this.delete();
+    });
+    
+    t.ok(deepEqual(
+        obj,
+        { a : 1, b : 2, c : [ 3, 4, 5 ] }
+    ));
+    
+    var xs = [ 3, 4, 5 ];
+    delete xs[1];
+    
+    t.ok(deepEqual(
+        res, { a : 1, c : xs }
+    ));
+    
+    t.ok(!deepEqual(
+        res, { a : 1, c : [ 3, 5 ] }
+    ));
+    
+    t.ok(deepEqual(
+        res, { a : 1, c : [ 3 ,, 5 ] }
+    ));
+    
+    t.end();
+});
+
+test('objectToString', function (t) {
+    var obj = { a : 1, b : 2, c : [ 3, 4 ] };
+    var res = traverse(obj).forEach(function (x) {
+        if (typeof x === 'object' && !this.isRoot) {
+            this.update(JSON.stringify(x));
+        }
+    });
+    t.same(obj, res);
+    t.same(obj, { a : 1, b : 2, c : "[3,4]" });
+    t.end();
+});
+
+test('stringToObject', function (t) {
+    var obj = { a : 1, b : 2, c : "[3,4]" };
+    var res = traverse(obj).forEach(function (x) {
+        if (typeof x === 'string') {
+            this.update(JSON.parse(x));
+        }
+        else if (typeof x === 'number' && x % 2 === 0) {
+            this.update(x * 10);
+        }
+    });
+    t.deepEqual(obj, res);
+    t.deepEqual(obj, { a : 1, b : 20, c : [ 3, 40 ] });
+    t.end();
+});

assets_old/node_modules/traverse/test/negative.js

@@ -0,0 +1,21 @@
+var traverse = require('../');
+var test = require('tape');
+
+test('negative update test', function (t) {
+    var obj = [ 5, 6, -3, [ 7, 8, -2, 1 ], { f : 10, g : -13 } ];
+    var fixed = traverse.map(obj, function (x) {
+        if (x < 0) this.update(x + 128);
+    });
+    
+    t.same(fixed,
+        [ 5, 6, 125, [ 7, 8, 126, 1 ], { f: 10, g: 115 } ],
+        'Negative values += 128'
+    );
+    
+    t.same(obj,
+        [ 5, 6, -3, [ 7, 8, -2, 1 ], { f: 10, g: -13 } ],
+        'Original references not modified'
+    );
+    
+    t.end();
+});

assets_old/node_modules/traverse/test/obj.js

@@ -0,0 +1,11 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('traverse an object with nested functions', function (t) {
+    t.plan(1);
+    
+    function Cons (x) {
+        t.equal(x, 10)
+    };
+    traverse(new Cons(10));
+});

assets_old/node_modules/traverse/test/siblings.js

@@ -0,0 +1,37 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('siblings', function (t) {
+    var obj = { a : 1, b : 2, c : [ 4, 5, 6 ] };
+    
+    var res = traverse(obj).reduce(function (acc, x) {
+        var p = '/' + this.path.join('/');
+        if (this.parent) {
+            acc[p] = {
+                siblings : this.parent.keys,
+                key : this.key,
+                index : this.parent.keys.indexOf(this.key)
+            };
+        }
+        else {
+            acc[p] = {
+                siblings : [],
+                key : this.key,
+                index : -1
+            }
+        }
+        return acc;
+    }, {});
+    
+    t.same(res, {
+        '/' : { siblings : [], key : undefined, index : -1 },
+        '/a' : { siblings : [ 'a', 'b', 'c' ], key : 'a', index : 0 },
+        '/b' : { siblings : [ 'a', 'b', 'c' ], key : 'b', index : 1 },
+        '/c' : { siblings : [ 'a', 'b', 'c' ], key : 'c', index : 2 },
+        '/c/0' : { siblings : [ '0', '1', '2' ], key : '0', index : 0 },
+        '/c/1' : { siblings : [ '0', '1', '2' ], key : '1', index : 1 },
+        '/c/2' : { siblings : [ '0', '1', '2' ], key : '2', index : 2 }
+    });
+    
+    t.end();
+});

assets_old/node_modules/traverse/test/stop.js

@@ -0,0 +1,44 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('stop', function (t) {
+    var visits = 0;
+    traverse('abcdefghij'.split('')).forEach(function (node) {
+        if (typeof node === 'string') {
+            visits ++;
+            if (node === 'e') this.stop()
+        }
+    });
+    
+    t.equal(visits, 5);
+    t.end();
+});
+
+test('stopMap', function (t) {
+    var s = traverse('abcdefghij'.split('')).map(function (node) {
+        if (typeof node === 'string') {
+            if (node === 'e') this.stop()
+            return node.toUpperCase();
+        }
+    }).join('');
+    
+    t.equal(s, 'ABCDEfghij');
+    t.end();
+});
+
+test('stopReduce', function (t) {
+    var obj = {
+        a : [ 4, 5 ],
+        b : [ 6, [ 7, 8, 9 ] ]
+    };
+    var xs = traverse(obj).reduce(function (acc, node) {
+        if (this.isLeaf) {
+            if (node === 7) this.stop();
+            else acc.push(node)
+        }
+        return acc;
+    }, []);
+    
+    t.same(xs, [ 4, 5, 6 ]);
+    t.end();
+});

assets_old/node_modules/traverse/test/stringify.js

@@ -0,0 +1,36 @@
+var test = require('tape');
+var traverse = require('../');
+
+test('stringify', function (t) {
+    var obj = [ 5, 6, -3, [ 7, 8, -2, 1 ], { f : 10, g : -13 } ];
+    
+    var s = '';
+    traverse(obj).forEach(function (node) {
+        if (Array.isArray(node)) {
+            this.before(function () { s += '[' });
+            this.post(function (child) {
+                if (!child.isLast) s += ',';
+            });
+            this.after(function () { s += ']' });
+        }
+        else if (typeof node == 'object') {
+            this.before(function () { s += '{' });
+            this.pre(function (x, key) {
+                s += '"' + key + '"' + ':';
+            });
+            this.post(function (child) {
+                if (!child.isLast) s += ',';
+            });
+            this.after(function () { s += '}' });
+        }
+        else if (typeof node == 'function') {
+            s += 'null';
+        }
+        else {
+            s += node.toString();
+        }
+    });
+    
+    t.equal(s, JSON.stringify(obj));
+    t.end();
+});

assets_old/node_modules/traverse/test/subexpr.js

@@ -0,0 +1,36 @@
+var traverse = require('../');
+var test = require('tape');
+
+test('subexpr', function (t) {
+    var obj = [ 'a', 4, 'b', 5, 'c', 6 ];
+    var r = traverse(obj).map(function (x) {
+        if (typeof x === 'number') {
+            this.update([ x - 0.1, x, x + 0.1 ], true);
+        }
+    });
+    
+    t.same(obj, [ 'a', 4, 'b', 5, 'c', 6 ]);
+    t.same(r, [
+        'a', [ 3.9, 4, 4.1 ],
+        'b', [ 4.9, 5, 5.1 ],
+        'c', [ 5.9, 6, 6.1 ],
+    ]);
+    t.end();
+});
+
+test('block', function (t) {
+    var obj = [ [ 1 ], [ 2 ], [ 3 ] ];
+    var r = traverse(obj).map(function (x) {
+        if (Array.isArray(x) && !this.isRoot) {
+            if (x[0] === 5) this.block()
+            else this.update([ [ x[0] + 1 ] ])
+        }
+    });
+    
+    t.same(r, [
+        [ [ [ [ [ 5 ] ] ] ] ],
+        [ [ [ [ 5 ] ] ] ],
+        [ [ [ 5 ] ] ],
+    ]);
+    t.end();
+});

assets_old/node_modules/traverse/test/super_deep.js

@@ -0,0 +1,56 @@
+var test = require('tape');
+var traverse = require('../');
+var deepEqual = require('./lib/deep_equal');
+
+test('super_deep', function (t) {
+    var util = require('util');
+    var a0 = make();
+    var a1 = make();
+    t.ok(deepEqual(a0, a1));
+    
+    a0.c.d.moo = true;
+    t.ok(!deepEqual(a0, a1));
+    
+    a1.c.d.moo = true;
+    t.ok(deepEqual(a0, a1));
+    
+    // TODO: this one
+    //a0.c.a = a1;
+    //t.ok(!deepEqual(a0, a1));
+    t.end();
+});
+
+function make () {
+    var a = { self : 'a' };
+    var b = { self : 'b' };
+    var c = { self : 'c' };
+    var d = { self : 'd' };
+    var e = { self : 'e' };
+    
+    a.a = a;
+    a.b = b;
+    a.c = c;
+    
+    b.a = a;
+    b.b = b;
+    b.c = c;
+    
+    c.a = a;
+    c.b = b;
+    c.c = c;
+    c.d = d;
+    
+    d.a = a;
+    d.b = b;
+    d.c = c;
+    d.d = d;
+    d.e = e;
+    
+    e.a = a;
+    e.b = b;
+    e.c = c;
+    e.d = d;
+    e.e = e;
+    
+    return a;
+}

assets_old/node_modules/traverse/testling/leaves.js

@@ -0,0 +1,22 @@
+var traverse = require('./');
+var test = require('testling');
+
+test('leaves', function (t) {
+    var obj = {
+        a : [1,2,3],
+        b : 4,
+        c : [5,6],
+        d : { e : [7,8], f : 9 }
+    };
+    
+    var acc = [];
+    traverse(obj).forEach(function (x) {
+        if (this.isLeaf) acc.push(x);
+    });
+    
+    t.deepEqual(
+        acc, [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ],
+        'traversal in the proper order'
+    );
+    t.end();
+});