ende 0.4.25 → 0.5.0

data/lib/assets/javascripts/aura/extensions/stamps/stampit.js

@@ -1,24 +1,5 @@
-!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.stampit=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
-var forIn = _dereq_('mout/object/forIn');
-
-function copyProp(val, key){
-    this[key] = val;
-}
-
-module.exports = function mixInChain(target, objects){
-    var i = 0,
-        n = arguments.length,
-        obj;
-    while(++i < n){
-        obj = arguments[i];
-        if (obj != null) {
-            forIn(obj, copyProp, target);
-        }
-    }
-    return target;
-};
-
-},{"mout/object/forIn":14}],2:[function(_dereq_,module,exports){
+(function(e){if("function"==typeof bootstrap)bootstrap("stampit",e);else if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else if("undefined"!=typeof ses){if(!ses.ok())return;ses.makeStampit=e}else"undefined"!=typeof window?window.stampit=e():global.stampit=e()})(function(){var define,ses,bootstrap,module,exports;
+return (function(e,t,n){function i(n,s){if(!t[n]){if(!e[n]){var o=typeof require=="function"&&require;if(!s&&o)return o(n,!0);if(r)return r(n,!0);throw new Error("Cannot find module '"+n+"'")}var u=t[n]={exports:{}};e[n][0].call(u.exports,function(t){var r=e[n][1][t];return i(r?r:t)},u,u.exports)}return t[n].exports}var r=typeof require=="function"&&require;for(var s=0;s<n.length;s++)i(n[s]);return i})({1:[function(require,module,exports){
 
 
     /**
@@ -43,311 +24,306 @@ module.exports = function mixInChain(target, objects){
 
 
 
-},{}],3:[function(_dereq_,module,exports){
-var forEach = _dereq_('./forEach');
-var makeIterator = _dereq_('../function/makeIterator_');
+},{}],2:[function(require,module,exports){
 
-    /**
-     * Array map
-     */
-    function map(arr, callback, thisObj) {
-        callback = makeIterator(callback, thisObj);
-        var results = [];
-        if (arr == null){
-            return results;
-        }
-
-        var i = -1, len = arr.length;
-        while (++i < len) {
-            results[i] = callback(arr[i], i, arr);
-        }
 
-        return results;
+    function slice(arr, offset){
+        return Array.prototype.slice.call(arr, offset || 0);
     }
 
-     module.exports = map;
-
-
-},{"../function/makeIterator_":4,"./forEach":2}],4:[function(_dereq_,module,exports){
-var prop = _dereq_('./prop');
-var deepMatches = _dereq_('../object/deepMatches');
-
-    /**
-     * Converts argument into a valid iterator.
-     * Used internally on most array/object/collection methods that receives a
-     * callback/iterator providing a shortcut syntax.
-     */
-    function makeIterator(src, thisObj){
-        switch(typeof src) {
-            case 'object':
-                // typeof null == "object"
-                return (src != null)? function(val, key, target){
-                    return deepMatches(val, src);
-                } : src;
-            case 'string':
-            case 'number':
-                return prop(src);
-            case 'function':
-                if (typeof thisObj === 'undefined') {
-                    return src;
-                } else {
-                    return function(val, i, arr){
-                        return src.call(thisObj, val, i, arr);
-                    };
-                }
-            default:
-                return src;
-        }
-    }
-
-    module.exports = makeIterator;
-
-
-
-},{"../object/deepMatches":13,"./prop":5}],5:[function(_dereq_,module,exports){
-
-
     /**
-     * Returns a function that gets a property of the passed object
+     * Return a function that will execute in the given context, optionally adding any additional supplied parameters to the beginning of the arguments collection.
+     * @param {Function} fn  Function.
+     * @param {object} context   Execution context.
+     * @param {rest} args    Arguments (0...n arguments).
+     * @return {Function} Wrapped Function.
      */
-    function prop(name){
-        return function(obj){
-            return obj[name];
+    function bind(fn, context, args){
+        var argsArr = slice(arguments, 2); //curried args
+        return function(){
+            return fn.apply(context, argsArr.concat(slice(arguments)));
         };
     }
 
-    module.exports = prop;
+    module.exports = bind;
 
 
 
-},{}],6:[function(_dereq_,module,exports){
-var kindOf = _dereq_('./kindOf');
-var isPlainObject = _dereq_('./isPlainObject');
-var mixIn = _dereq_('../object/mixIn');
+},{}],3:[function(require,module,exports){
+var shimIndexOf = function shimIndexOf() {
 
-    /**
-     * Clone native types.
-     */
-    function clone(val){
-        switch (kindOf(val)) {
-            case 'Object':
-                return cloneObject(val);
-            case 'Array':
-                return cloneArray(val);
-            case 'RegExp':
-                return cloneRegExp(val);
-            case 'Date':
-                return cloneDate(val);
-            default:
-                return val;
+    if (!Array.prototype.indexOf) {
+        Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
+            "use strict";
+            if (this == null) {
+                throw new TypeError();
+            }
+            var t = Object(this);
+            var len = t.length >>> 0;
+            if (len === 0) {
+                return -1;
+            }
+            var n = 0;
+            if (arguments.length > 1) {
+                n = Number(arguments[1]);
+                if (n != n) { // shortcut for verifying if it's NaN
+                    n = 0;
+                } else if (n != 0 && n != Infinity && n != -Infinity) {
+                    n = (n > 0 || -1) * Math.floor(Math.abs(n));
+                }
+            }
+            if (n >= len) {
+                return -1;
+            }
+            var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
+            for (; k < len; k++) {
+                if (k in t && t[k] === searchElement) {
+                    return k;
+                }
+            }
+            return -1;
         }
     }
 
-    function cloneObject(source) {
-        if (isPlainObject(source)) {
-            return mixIn({}, source);
-        } else {
-            return source;
-        }
-    }
+}
 
-    function cloneRegExp(r) {
-        var flags = '';
-        flags += r.multiline ? 'm' : '';
-        flags += r.global ? 'g' : '';
-        flags += r.ignorecase ? 'i' : '';
-        return new RegExp(r.source, flags);
-    }
+module.exports = shimIndexOf;
 
-    function cloneDate(date) {
-        return new Date(+date);
-    }
+},{}],4:[function(require,module,exports){
+/**
+ * Stampit
+ **
+ * Create objects from reusable, composable behaviors.
+ **
+ * Copyright (c) 2013 Eric Elliott
+ * http://opensource.org/licenses/MIT
+ **/
 
-    function cloneArray(arr) {
-        return arr.slice();
-    }
+'use strict';
+var forEach = require('mout/array/forEach');
+var bind = require('mout/function/bind');
+var mixIn = require('mout/object/mixIn');
+var stringify = require('json-stringify-safe');
+var indexOf = require('./indexof'); // shim indexOf for stringify
 
-    module.exports = clone;
+var create = function (o) {
+  if (arguments.length > 1) {
+    throw new Error('Object.create implementation only accepts the first parameter.');
+  }
+  function F() {}
+  F.prototype = o;
+  return new F();
+};
 
+/**
+ * Return a factory function that will produce new objects using the
+ * prototypes that are passed in or composed.
+ *
+ * @param  {Object} [methods] A map of method names and bodies for delegation.
+ * @param  {Object} [state]   A map of property names and values to clone for each new object.
+ * @param  {Function} [enclose] A closure (function) used to create private data and privileged methods.
+ * @return {Function} factory A factory to produce objects using the given prototypes.
+ * @return {Function} factory.create Just like calling the factory function.
+ * @return {Object} factory.fixed An object map containing the fixed prototypes.
+ * @return {Function} factory.methods Add methods to the methods prototype. Chainable.
+ * @return {Function} factory.state Add properties to the state prototype. Chainable.
+ * @return {Function} factory.enclose Add or replace the closure prototype. Not chainable.
+ */
+var stampit = function stampit(methods, state, enclose) {
+  var fixed = {
+      methods: methods || {},
+      state: state ?
+          JSON.parse(stringify(state)) :
+          {},
+      enclose: enclose
+    },
 
+    factory = function factory(properties, enclose) {
+      var instance = mixIn(create(fixed.methods || {}),
+        fixed.state, properties),
+        alt;
 
-},{"../object/mixIn":18,"./isPlainObject":11,"./kindOf":12}],7:[function(_dereq_,module,exports){
-var clone = _dereq_('./clone');
-var forOwn = _dereq_('../object/forOwn');
-var kindOf = _dereq_('./kindOf');
-var isPlainObject = _dereq_('./isPlainObject');
+      if (typeof fixed.enclose === 'function') {
+        alt = fixed.enclose.call(instance);
+      }
 
-    /**
-     * Recursively clone native types.
-     */
-    function deepClone(val, instanceClone) {
-        switch ( kindOf(val) ) {
-            case 'Object':
-                return cloneObject(val, instanceClone);
-            case 'Array':
-                return cloneArray(val, instanceClone);
-            default:
-                return clone(val);
-        }
-    }
+      if (typeof enclose === 'function') {
+        alt = enclose.call(alt || instance);
+      }
 
-    function cloneObject(source, instanceClone) {
-        if (isPlainObject(source)) {
-            var out = {};
-            forOwn(source, function(val, key) {
-                this[key] = deepClone(val, instanceClone);
-            }, out);
-            return out;
-        } else if (instanceClone) {
-            return instanceClone(source);
-        } else {
-            return source;
-        }
-    }
+      return alt || instance;
+    };
 
-    function cloneArray(arr, instanceClone) {
-        var out = [],
-            i = -1,
-            n = arr.length,
-            val;
-        while (++i < n) {
-            out[i] = deepClone(arr[i], instanceClone);
-        }
-        return out;
+  return mixIn(factory, {
+    create: factory,
+    fixed: fixed,
+    methods: function () {
+      var obj = fixed.methods || {},
+        args = [obj].concat([].slice.call(arguments));
+      fixed.methods = mixIn.apply(this, args);
+      return this;
+    },
+    state: function (state) {
+      var obj = fixed.state || {},
+        args = [obj].concat([].slice.call(arguments));
+      fixed.state = mixIn.apply(this, args);
+      return this;
+    },
+    enclose: function (enclose) {
+      fixed.enclose = enclose;
+      return this;
     }
+  });
+};
 
-    module.exports = deepClone;
-
+/**
+ * Take two or more factories produced from stampit() and
+ * combine them to produce a new factory. Combining overrides
+ * properties with last-in priority.
+ *
+ * @param {...Function} factory A factory produced by stampit().
+ * @return {Function} A new stampit factory composed from arguments.
+ */
+var compose = function compose() {
+  var args = [].slice.call(arguments),
+    initFunctions = [],
+    obj = stampit(),
+    props = ['methods', 'state'];
 
+  forEach(args, function (source) {
+    if (source) {
+      forEach(props, function (prop) {
+        if (source.fixed[prop]) {
+          obj.fixed[prop] = mixIn(obj.fixed[prop],
+            source.fixed[prop]);
+        }
+      });
 
+      if (typeof source.fixed.enclose === 'function') {
+        initFunctions.push(source.fixed.enclose);
+      }
+    }
+  });
 
-},{"../object/forOwn":15,"./clone":6,"./isPlainObject":11,"./kindOf":12}],8:[function(_dereq_,module,exports){
-var isKind = _dereq_('./isKind');
-    /**
-     */
-    var isArray = Array.isArray || function (val) {
-        return isKind(val, 'Array');
-    };
-    module.exports = isArray;
+  return stampit(obj.fixed.methods, obj.fixed.state, function () {
+    forEach(initFunctions, bind(function (fn) {
+      fn.call(this);
+    }, this));
+  });
+};
 
+indexOf();
 
-},{"./isKind":9}],9:[function(_dereq_,module,exports){
-var kindOf = _dereq_('./kindOf');
-    /**
-     * Check if value is from a specific "kind".
-     */
-    function isKind(val, kind){
-        return kindOf(val) === kind;
-    }
-    module.exports = isKind;
+module.exports = mixIn(stampit, {
+  compose: compose,
+  /**
+   * Alias for mixIn
+   */
+  extend: mixIn,
+  /**
+   * Take a destination object followed by one or more source objects,
+   * and copy the source object properties to the destination object,
+   * with last in priority overrides.
+   * @param {Object} destination An object to copy properties to.
+   * @param {...Object} source An object to copy properties from.
+   * @returns {Object}
+   */
+  mixIn: mixIn
+});
 
+},{"mout/array/forEach":1,"mout/function/bind":2,"mout/object/mixIn":5,"./indexof":3,"json-stringify-safe":6}],6:[function(require,module,exports){
+module.exports = stringify;
 
-},{"./kindOf":12}],10:[function(_dereq_,module,exports){
-var isKind = _dereq_('./isKind');
-    /**
-     */
-    function isObject(val) {
-        return isKind(val, 'Object');
+function getSerialize (fn, decycle) {
+  var seen = [];
+  decycle = decycle || function(key, value) {
+    return '[Circular]';
+  };
+  return function(key, value) {
+    var ret = value;
+    if (typeof value === 'object' && value) {
+      if (seen.indexOf(value) !== -1)
+        ret = decycle(key, value);
+      else
+        seen.push(value);
     }
-    module.exports = isObject;
+    if (fn) ret = fn(key, ret);
+    return ret;
+  }
+}
 
+function stringify(obj, fn, spaces, decycle) {
+  return JSON.stringify(obj, getSerialize(fn, decycle), spaces);
+}
 
-},{"./isKind":9}],11:[function(_dereq_,module,exports){
+stringify.getSerialize = getSerialize;
 
+},{}],5:[function(require,module,exports){
+var forOwn = require('./forOwn');
 
     /**
-     * Checks if the value is created by the `Object` constructor.
-     */
-    function isPlainObject(value) {
-        return (!!value
-            && typeof value === 'object'
-            && value.constructor === Object);
+    * Combine properties from all the objects into first one.
+    * - This method affects target object in place, if you want to create a new Object pass an empty object as first param.
+    * @param {object} target    Target Object
+    * @param {...object} objects    Objects to be combined (0...n objects).
+    * @return {object} Target Object.
+    */
+    function mixIn(target, objects){
+        var i = 0,
+            n = arguments.length,
+            obj;
+        while(++i < n){
+            obj = arguments[i];
+            if (obj != null) {
+                forOwn(obj, copyProp, target);
+            }
+        }
+        return target;
     }
 
-    module.exports = isPlainObject;
-
-
+    function copyProp(val, key){
+        this[key] = val;
+    }
 
-},{}],12:[function(_dereq_,module,exports){
+    module.exports = mixIn;
 
 
-    var _rKind = /^\[object (.*)\]$/,
-        _toString = Object.prototype.toString,
-        UNDEF;
+},{"./forOwn":7}],7:[function(require,module,exports){
+var hasOwn = require('./hasOwn');
+var forIn = require('./forIn');
 
     /**
-     * Gets the "kind" of value. (e.g. "String", "Number", etc)
+     * Similar to Array/forEach but works over object properties and fixes Don't
+     * Enum bug on IE.
+     * based on: http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
      */
-    function kindOf(val) {
-        if (val === null) {
-            return 'Null';
-        } else if (val === UNDEF) {
-            return 'Undefined';
-        } else {
-            return _rKind.exec( _toString.call(val) )[1];
-        }
-    }
-    module.exports = kindOf;
-
-
-},{}],13:[function(_dereq_,module,exports){
-var forOwn = _dereq_('./forOwn');
-var isArray = _dereq_('../lang/isArray');
-
-    function containsMatch(array, pattern) {
-        var i = -1, length = array.length;
-        while (++i < length) {
-            if (deepMatches(array[i], pattern)) {
-                return true;
+    function forOwn(obj, fn, thisObj){
+        forIn(obj, function(val, key){
+            if (hasOwn(obj, key)) {
+                return fn.call(thisObj, obj[key], key, obj);
             }
-        }
-
-        return false;
+        });
     }
 
-    function matchArray(target, pattern) {
-        var i = -1, patternLength = pattern.length;
-        while (++i < patternLength) {
-            if (!containsMatch(target, pattern[i])) {
-                return false;
-            }
-        }
+    module.exports = forOwn;
 
-        return true;
-    }
 
-    function matchObject(target, pattern) {
-        var result = true;
-        forOwn(pattern, function(val, key) {
-            if (!deepMatches(target[key], val)) {
-                // Return false to break out of forOwn early
-                return (result = false);
-            }
-        });
 
-        return result;
-    }
+},{"./hasOwn":8,"./forIn":9}],8:[function(require,module,exports){
+
 
     /**
-     * Recursively check if the objects match.
+     * Safer Object.hasOwnProperty
      */
-    function deepMatches(target, pattern){
-        if (target && typeof target === 'object') {
-            if (isArray(target) && isArray(pattern)) {
-                return matchArray(target, pattern);
-            } else {
-                return matchObject(target, pattern);
-            }
-        } else {
-            return target === pattern;
-        }
-    }
+     function hasOwn(obj, prop){
+         return Object.prototype.hasOwnProperty.call(obj, prop);
+     }
 
-    module.exports = deepMatches;
+     module.exports = hasOwn;
 
 
 
-},{"../lang/isArray":8,"./forOwn":15}],14:[function(_dereq_,module,exports){
+},{}],9:[function(require,module,exports){
 
 
     var _hasDontEnumBug,
@@ -411,308 +387,6 @@ var isArray = _dereq_('../lang/isArray');
 
 
 
-},{}],15:[function(_dereq_,module,exports){
-var hasOwn = _dereq_('./hasOwn');
-var forIn = _dereq_('./forIn');
-
-    /**
-     * Similar to Array/forEach but works over object properties and fixes Don't
-     * Enum bug on IE.
-     * based on: http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
-     */
-    function forOwn(obj, fn, thisObj){
-        forIn(obj, function(val, key){
-            if (hasOwn(obj, key)) {
-                return fn.call(thisObj, obj[key], key, obj);
-            }
-        });
-    }
-
-    module.exports = forOwn;
-
-
-
-},{"./forIn":14,"./hasOwn":16}],16:[function(_dereq_,module,exports){
-
-
-    /**
-     * Safer Object.hasOwnProperty
-     */
-     function hasOwn(obj, prop){
-         return Object.prototype.hasOwnProperty.call(obj, prop);
-     }
-
-     module.exports = hasOwn;
-
-
-
-},{}],17:[function(_dereq_,module,exports){
-var hasOwn = _dereq_('./hasOwn');
-var deepClone = _dereq_('../lang/deepClone');
-var isObject = _dereq_('../lang/isObject');
-
-    /**
-     * Deep merge objects.
-     */
-    function merge() {
-        var i = 1,
-            key, val, obj, target;
-
-        // make sure we don't modify source element and it's properties
-        // objects are passed by reference
-        target = deepClone( arguments[0] );
-
-        while (obj = arguments[i++]) {
-            for (key in obj) {
-                if ( ! hasOwn(obj, key) ) {
-                    continue;
-                }
-
-                val = obj[key];
-
-                if ( isObject(val) && isObject(target[key]) ){
-                    // inception, deep merge objects
-                    target[key] = merge(target[key], val);
-                } else {
-                    // make sure arrays, regexp, date, objects are cloned
-                    target[key] = deepClone(val);
-                }
-
-            }
-        }
-
-        return target;
-    }
-
-    module.exports = merge;
-
-
-
-},{"../lang/deepClone":7,"../lang/isObject":10,"./hasOwn":16}],18:[function(_dereq_,module,exports){
-var forOwn = _dereq_('./forOwn');
-
-    /**
-    * Combine properties from all the objects into first one.
-    * - This method affects target object in place, if you want to create a new Object pass an empty object as first param.
-    * @param {object} target    Target Object
-    * @param {...object} objects    Objects to be combined (0...n objects).
-    * @return {object} Target Object.
-    */
-    function mixIn(target, objects){
-        var i = 0,
-            n = arguments.length,
-            obj;
-        while(++i < n){
-            obj = arguments[i];
-            if (obj != null) {
-                forOwn(obj, copyProp, target);
-            }
-        }
-        return target;
-    }
-
-    function copyProp(val, key){
-        this[key] = val;
-    }
-
-    module.exports = mixIn;
-
-
-},{"./forOwn":15}],19:[function(_dereq_,module,exports){
-/**
- * Stampit
- **
- * Create objects from reusable, composable behaviors.
- **
- * Copyright (c) 2013 Eric Elliott
- * http://opensource.org/licenses/MIT
- **/
-'use strict';
-var forEach = _dereq_('mout/array/forEach');
-var mixIn = _dereq_('mout/object/mixIn');
-var merge = _dereq_('mout/object/merge');
-var map = _dereq_('mout/array/map');
-var forOwn = _dereq_('mout/object/forOwn');
-var mixInChain = _dereq_('./mixinchain.js');
-var slice = [].slice;
-
-var create = function (o) {
-  if (arguments.length > 1) {
-    throw new Error('Object.create implementation only accepts the first parameter.');
-  }
-  function F() {}
-  F.prototype = o;
-  return new F();
-};
-
-if(!Array.isArray) {
-  Array.isArray = function (vArg) {
-    return Object.prototype.toString.call(vArg) === "[object Array]";
-  };
-}
-
-var extractFunctions = function extractFunctions(arg) {
-  var arr = [],
-    args = [].slice.call(arguments);
-
-  if (typeof arg === 'function') {
-    arr = map(args, function (fn) {
-      if (typeof fn === 'function') {
-        return fn;
-      }
-    });
-  } else if (typeof arg === 'object') {
-    forEach(args, function (obj) {
-      forOwn(obj, function (fn) {
-        arr.push(fn);
-      });
-    });
-  } else if ( Array.isArray(arg) ) {
-    forEach(arg, function (fn) {
-      arr.push(fn);
-    });
-  }
-  return arr;
-};
-
-/**
- * Return a factory function that will produce new objects using the
- * prototypes that are passed in or composed.
- *
- * @param  {Object} [methods] A map of method names and bodies for delegation.
- * @param  {Object} [state]   A map of property names and values to clone for each new object.
- * @param  {Function} [enclose] A closure (function) used to create private data and privileged methods.
- * @return {Function} factory A factory to produce objects using the given prototypes.
- * @return {Function} factory.create Just like calling the factory function.
- * @return {Object} factory.fixed An object map containing the fixed prototypes.
- * @return {Function} factory.methods Add methods to the methods prototype. Chainable.
- * @return {Function} factory.state Add properties to the state prototype. Chainable.
- * @return {Function} factory.enclose Add or replace the closure prototype. Not chainable.
- */
-var stampit = function stampit(methods, state, enclose) {
-  var fixed = {
-      methods: methods || {},
-      state: state,
-      enclose: extractFunctions(enclose)
-    },
-
-    factory = function factory(properties) {
-      var state = merge({}, fixed.state),
-        instance = mixIn(create(fixed.methods || {}),
-          state, properties),
-        closures = fixed.enclose,
-        args = slice.call(arguments, 1);
-
-      forEach(closures, function (fn) {
-        if (typeof fn === 'function') {
-          instance = fn.apply(instance, args) || instance;
-        }
-      });
-
-      return instance;
-    };
-
-  return mixIn(factory, {
-    create: factory,
-    fixed: fixed,
-    /**
-     * Take n objects and add them to the methods prototype.
-     * @return {Object} stamp  The factory in question (`this`).
-     */
-    methods: function stampMethods() {
-      var obj = fixed.methods || {},
-        args = [obj].concat([].slice.call(arguments));
-      fixed.methods = mixInChain.apply(this, args);
-      return this;
-    },
-    /**
-     * Take n objects and add them to the state prototype.
-     * @return {Object} stamp  The factory in question (`this`).
-     */
-    state: function stampState() {
-      var obj = fixed.state || {},
-        args = [obj].concat([].slice.call(arguments));
-      fixed.state = mixIn.apply(this, args);
-      return this;
-    },
-    /**
-     * Take n functions, an array of functions, or n objects and add
-     * the functions to the enclose prototype.
-     * @return {Object} stamp  The factory in question (`this`).
-     */
-    enclose: function stampEnclose() {
-      fixed.enclose = fixed.enclose
-        .concat( extractFunctions.apply(null, arguments) );
-      return this;
-    }
-  });
-};
-
-/**
- * Take two or more factories produced from stampit() and
- * combine them to produce a new factory. Combining overrides
- * properties with last-in priority.
- *
- * @param {...Function} factory A factory produced by stampit().
- * @return {Function} A new stampit factory composed from arguments.
- */
-var compose = function compose() {
-  var args = [].slice.call(arguments),
-    obj = stampit();
-
-  forEach(args, function (source) {
-    if (source) {
-      if (source.fixed.methods) {
-        obj.fixed.methods = mixInChain({}, obj.fixed.methods,
-          source.fixed.methods);
-      }
-
-      if (source.fixed.state) {
-        obj.fixed.state = mixIn({}, obj.fixed.state,
-          source.fixed.state);
-      }
-
-      if (source.fixed.enclose) {
-        obj.fixed.enclose = obj.fixed.enclose
-          .concat(source.fixed.enclose);
-      }
-    }
-  });
-
-  return stampit(obj.fixed.methods, obj.fixed.state,
-    obj.fixed.enclose);
-};
-
-/**
- * Take an old-fashioned JS constructor and return a stampit stamp
- * that you can freely compose with other stamps.
- * @param  {Function} Constructor 
- * @return {Function}             A composable stampit factory
- *                                (aka stamp).
- */
-var convertConstructor = function convertConstructor(Constructor) {
-  return stampit().methods(Constructor.prototype).enclose(Constructor);
-};
-
-module.exports = mixIn(stampit, {
-  compose: compose,
-  /**
-   * Alias for mixIn
-   */
-  extend: mixIn,
-  /**
-   * Take a destination object followed by one or more source objects,
-   * and copy the source object properties to the destination object,
-   * with last in priority overrides.
-   * @param {Object} destination An object to copy properties to.
-   * @param {...Object} source An object to copy properties from.
-   * @returns {Object}
-   */
-  mixIn: mixIn,
-
-  convertConstructor: convertConstructor
+},{}]},{},[4])(4)
 });
-
-},{"./mixinchain.js":1,"mout/array/forEach":2,"mout/array/map":3,"mout/object/forOwn":15,"mout/object/merge":17,"mout/object/mixIn":18}]},{},[19])
-(19)
-});
+;