     # the supplied class and up to the top. The class has to be a valid
     # CoffeeScript class that posses all the necessary internal members.
     Object.defineProperty Object::, "hierarchy",
-        enumerable: no, value: ->
-            [chaining, subject] = [new Array, @]
-            isClass = _.isObject subject.__super__
-            noClass = "The subject is not a class"
-            throw new Error noClass unless isClass
-            while subject? and subject isnt null
-                subject = subject.__super__
-                constructor = subject?.constructor
-                validates = _.isFunction constructor
-                continue unless validates
-                chaining.push constructor
-                subject = constructor
-            return chaining or []
+        enumerable: no, value: (subject) ->
+            assert _.isArray a = accumulate = new Array
+            subject = this unless _.isObject try subject
+            classed = _.isObject subject.__super__ or null
+            assert classed, "supplied object is not a class"
+            scanner = (fn) -> fn a while subject?; return a
+            return scanner _.identity (accumulate) -> try
+                subject = subject.__super__ or undefined
+                constructor = subject.constructor or null
+                return no unless _.isFunction constructor
+                accumulate.push try subject = constructor
 
     # A fancy method for dynamically changing the inheritance chain of
     # the existing classes. This method rebases the current class to

    # a valid __super__ descriptor, among some other prototypal things.
    Object.defineProperty Object::, "rebased",
        enumerable: no, value: (baseclass, force) ->
            isClass = _.isObject baseclass?.__super__
            noClass = "The #{baseclass} is not a class"
            throw new Error noClass unless isClass
            baseclass.rebasement? this, force
            p = (k) => force is yes or not this[k]?
            this[k] = v for k, v of baseclass when p k
            original = this.prototype or {}; r = this
            `function ctor() {this.constructor = r}`
            ctor.prototype = baseclass.prototype
            this.__super__ = baseclass.prototype
            this.prototype = new ctor() or original
            _.extend this.prototype, original; @

            isClass = _.isObject this.prototype
            noClass = "The subject is not a class"
            throw new Error noClass unless isClass
            return yes if this is archetype or no
            return yes if @watermark is archetype
            return undefined unless loose is yes
            return yes if @name is archetype.name
