(function() {
    var root = this;
    var previousO = root.o;
    var o = {};

    // The method in which we export o, that works whether in the browser or
    // Node.js, including noConflict, was graciously copied from underscore.js.
    if (typeof exports !== 'undefined') {
        if (typeof module !== 'undefined' && module.exports) {
            exports = module.exports = o;
        }
        exports.o = o;
    } else {
        root.o = o;
    }

    o.noConflict = function () {
        root.o = previousO;
        return o;
    };

    o.reader = function (key, def) {
        def = def || {};
        var writer = def.writer || o.writer( key, def );
        var predicate = def.predicate || o.predicate( key );

        return function () {
            if (!predicate.call( this )) {
                if (def.required) {
                    throw new Error('...');
                }
                else if (def.default !== undefined) {
                    var value = def.default;
                    if (typeof value === 'function') { 
                        value = value.call( this );
                    }

                    writer.call( this, value );
                }
            }

            return this[key];
        };
    };

    o.writer = function (key, def) {
        def = def || {};
        var isa = def.isa
        if (def.option) isa = isa || 'boolean';

        return function (value) {
            if (def.option && value === undefined) { value = true }
            if (def.filter) { value = def.filter.call( this, value ) }

            if (isa) {
                if (typeof isa === 'string') {
                    if (typeof value !== isa) throw new Error('...');
                }
                else if (!isa.call(this, value)) {
                    throw new Error('...');
                }
            }

            if (def.extends) {
                if (!(value instanceof def.extends)) {
                    throw new Error('...');
                }
            }

            this[key] = value;
            if (def.chain || def.option) { return this }
            return value;
        };
    };

    o.accessor = function (key, def) {
        def = def || {};
        var writer = def.writer || o.writer( key, def );
        var reader = def.reader || o.reader( key, def );

        return function (value) {
            if (value !== undefined) {
                writer.call( this, value );
            }
            return reader.call( this );
        };
    };

    o.predicate = function (key) {
        return function () {
            return o.has( this, key );
        };
    };

    o.clearer = function (key) {
        return function () {
            delete this[key];
        };
    };

    o.before = function (original, func) {
        return function () {
            func.call( this );
            return original.apply( this, arguments );
        };
    };

    o.after = function (original, func) {
        return function () {
            var ret = original.apply( this, arguments );
            func.call( this );
            return ret;
        };
    };

    o.around = function (original, func) {
        return function () {
            var self = this;
            var args = Array.prototype.slice.call(arguments);
            var wrapper = function () {
                original.apply( self, arguments );
            };
            args.unshift( wrapper );
            func.apply( self, args );
        };
    };

    o.proxy = function (key, method) {
        return function () {
            return this[key][method].apply( this[key], arguments );
        };
    };

    o.extend = function (parent, constructor) {
        var child = o.around(
            parent,
            constructor
        );

        var proto = o.merge(
            {},
            parent.prototype,
            constructor.prototype
        );

        child.prototype = proto;

        return child;
    };

    o.merge = function () {
        var fromObjs = Array.prototype.slice.call(arguments);
        var toObj = fromObjs.shift();

        while (fromObjs.length) {
            var obj = fromObjs.shift();
            for (var key in obj) {
                if (o.has(obj, key)) toObj[key] = obj[key];
            }
        }

        return toObj;
    };

    o.clone = function (obj) {
        var newObj = {};
        newObj = o.setPrototype( newObj, obj.constructor.prototype );
        newObj.constructor = obj.constructor;
        o.merge( newObj, obj );
        return newObj;
    };

    o.setPrototype = function (obj, proto) {
        var Constructor = function (obj) {
            o.merge( this, obj );
        };
        Constructor.prototype = proto;

        var newObj = new Constructor( obj );
        newObj.constructor = obj.constructor;

        return newObj;
    };

    o.has = function (obj, key) {
        return Object.prototype.hasOwnProperty.call( obj, key );
    };
}).call(this);

@@ -599,36 +599,36 @@
  %7C%7C %7B%7D;%0A        
-var 
+def.
 writer = def.wri
@@ -664,20 +664,20 @@
         
-var 
+def.
 predicat
@@ -764,16 +764,20 @@
    if (!
+def.
 predicat
@@ -1134,32 +1134,36 @@
                 
+def.
 writer.call( thi
@@ -2221,20 +2221,20 @@
         
-var 
+def.
 writer =
@@ -2278,20 +2278,20 @@
         
-var 
+def.
 reader =

Modify the origin definitions for efficiency.