順次処理用のメソッドをミックスインする
@method mixin
@param  {Function} target
@param  {String}   listName
777325
function sequantial (target, listName) {

  /**
   * 各行に対して関数を呼び出します
   * @method forEach
   * @param  {Function} callback
   */
  target.forEach = function forEach (callback) {
    var list = [].slice.call(this[listName]);
    var len = list.length;
    for(var i = 0; i < len; i++) {
      callback(list[i], i, list);
    }
  };

  /**
   * すべての行に対して、真であるかを調査する
   * @method every
   * @param  {Function} callback
   * @return {Boolean}
   */
  target.every = function every (callback) {
    var list = [].slice.call(this[listName]);
    var len = list.length;
    for(var i = 0; i < len; i++) {
      if (!callback(list[i], i, list)) {
        return false;
      }
    }
    return true;
  };

  /**
   * いずれかの行に対して、真であるかを調査する
   * @method some
   * @param  {Function} callback
   * @return {Boolean}
   */
  target.some = function some (callback) {
    var list = [].slice.call(this[listName]);
    var len = list.length;
    for(var i = 0; i < len; i++) {
      if (callback(list[i], i, list)) {
        return true;
      }
    }
    return false;
  };

  /**
   * callbackを満たす行を配列で返す
   * @method filter
   * @param  {Function} callback
   * @return {Array}
   */
  target.filter = function filter (callback) {
    var list = [].slice.call(this[listName]);
    var len = list.length;
    var result = [];
    for(var i = 0; i < len; i++) {
      if (callback(list[i], i, list)) {
        result.push(list[i]);
      }
    }
    return result;
  };

  /**
   * 各行から新しい配列を作成します
   * @method map
   * @param  {Function} callback
   */
  target.map = function map (callback) {
    var list = [].slice.call(this[listName]);
    var len = list.length;
    var result = [];
    for(var i = 0; i < len; i++) {
      result.push(callback(list[i], i, list));
    }
    return result;
  };

  /**
   * 各行から値を計算します
   * @method reduce
   * @param  {Function} callback
   * @param  {Mixed}    initial
   * @return {Mixed}    result
   */
  target.reduce = function reduce (callback, initial) {
    var list = [].slice.call(this[listName]);
    var len = list.length;
    var value = initial;
    for(var i = 0; i < len; i++) {
      value = callback(value, list[i], i, list);
    }
    return value;
  };

  /**
   * 各行をインデックスの降順で値を計算します
   * @method reduceRight
   * @param  {Function} callback
   * @param  {Mixed}    initial
   * @return {Mixed}    result
   */
  target.reduceRight = function reduceRight (callback, initial) {
    var list = [].slice.call(this[listName]);
    var len = list.length;
    var value = initial;
    for(var i = len - 1; -1 < i; i--) {
      value = callback(value, list[i], i, list);
    }
    return value;
  };

}
1125829
function addTo(name) {
            var indexName = name,
                match = name.match(/^([^\(]*)\s*\(([^\)]*)\)\s*/),
                params = match && match[2];
            name = match && match[1] || name;

            if (!index[indexName]) {
                if (params) {
                    // there can be no function calls here because of the regex match
                    /*jshint evil: true */
                    params = eval('[' + params + ']');
                }
                var mixin = _mixins[name],
                    checkAgain = false,
                    skip = false;

                if (mixin) {
                    if (typeof mixin === 'function') {
                        if (_initiatedOnce[name]) {
                            if (!initiatedOnce[name]) {
                                initiatedOnce[name] = [];
                                // add the placeholder so the mixin ends up in the right place
                                // we will replace all names with the appropriate mixins at the end
                                // (so we have all of the appropriate arguments)
                                mixin = name;
                            } else {
                                // but we only want to add it a single time
                                skip = true;
                            }
                            if (params) {
                                initiatedOnce[name].push(params);
                            }
                        } else {
                            mixin = mixin.apply(this, params || []);
                            checkAgain = true;
                        }
                    } else if (params) {
                        throw new Error('the mixin "' + name + '" does not support parameters');
                    }
                    get(_dependsOn[name], index, initiatedOnce, rtn);
                    get(_dependsInjected[name], index, initiatedOnce, rtn);

                    index[indexName] = true;
                    if (checkAgain) {
                        get([mixin], index, initiatedOnce, rtn);
                    } else if (!skip) {
                        checkForInlineMixins(mixin, rtn);
                        rtn.push(mixin);
                    }

                } else {
                    throw new Error('invalid mixin "' + name + '"');
                }
            }
        }
48672
function mixin$1(name, mix, g) {
  // Unnamed global
  if (isObject(name)) {
    mixin$1(("__" + (mixins_id++) + "__"), name, true);
    return
  }

  var store = g ? globals : mixins;

  // Getter
  if (!mix) {
    if (isUndefined(store[name]))
      { throw new Error(("Unregistered mixin: " + name)) }

    return store[name]
  }

  // Setter
  store[name] = isFunction(mix) ?
    extend(mix.prototype, store[name] || {}) && mix :
    extend(store[name] || {}, mix);
}
911579
def remove_mixins(target):
        

        mixedins_by_name = Mixin.get_mixedins_by_name(target).copy()

        for _name in mixedins_by_name:  # for all named mixins
            while True:  # remove all mixins named _name
                try:
                    Mixin.remove_mixin(target, _name)
                except Mixin.MixInError:
                    break
709809
function setTarget(target) {
        var targetMethods = {};
        for (var name in methods) {
            targetMethods[name] = wrapMethod(target, methods[name]);
        }
        return targetMethods;
    }
469010
def get_mixedins_by_name(target):
        """"""

        result = getattr(target, Mixin.__MIXEDIN_KEY__, None)

        if result is None:
            result = dict()
            setattr(target, Mixin.__MIXEDIN_KEY__, result)

        return result
126564
function() {
		if(this.init) { this.init.apply(this, arguments) }
		for (var i=0, mixin; mixin = mixins[i]; i++) {
			if (mixin.init) { mixin.init.apply(this) }
		}
	}
1271286
function(namespace, target) {
      
      target = target || {};
      
      var names = namespace.split('.'),
          context = target;
      
      for (var i = 0; i < names.length; i++) {
        var name = names[i];
        context = (name in context) ? context[name] : (context[name] = {});
      }
      
      return target;
    }
1020774
function (pluginName, targetName, targetData) {
        if (arguments.length < 2) {
          throw (new Error('expected at least 2 arguments'));
        }

        if (arguments.length === 2) {
          targetData = targetName;
          targetName = lib.getNameUID(prefix, data.id);
        }

        gtx.configFor(pluginName, targetName, targetData);

        lib.pushUnique(data.plugins, pluginName);
        lib.pushHash(plugins, pluginName, data);

        lib.pushUnique(tasks, pluginName + ':' + targetName);
      }
17065
function bundleArray(target, src, name, notSelf) {
      var srcValues, targetValues;
      if (src[name]) {
        srcValues = src[name] || [];
        targetValues = target[name] || [];
        target[name] = uniq(targetValues.concat(srcValues.filter(function(d) {
          return !notSelf || d !== target.name;
        })));
      }
    }
968930
function merge (target, src) {
        var dst = {};

        if (target && typeof target === 'object') {
            Object.keys(target).forEach(function (key) {
                dst[key] = target[key];
            });
        }
        Object.keys(src).forEach(function (key) {
            if (typeof src[key] !== 'object' || !src[key]) {
                dst[key] = src[key];
            } else {
                if (!target[key]) {
                    dst[key] = src[key];
                } else {
                    dst[key] = merge(target[key], src[key]);
                }
            }
        });

        return dst;
    }
426871
function mixin(array) {
        var support = !!(Object.defineProperty && Object.defineProperties);
        if (!support) throw new Error('without defineProperty, simple-statistics cannot be mixed in');

        // only methods which work on basic arrays in a single step
        // are supported
        var arrayMethods = ['median', 'standard_deviation', 'sum',
            'sample_skewness',
            'mean', 'min', 'max', 'quantile', 'geometric_mean',
            'harmonic_mean', 'root_mean_square'];

        // create a closure with a method name so that a reference
        // like `arrayMethods[i]` doesn't follow the loop increment
        function wrap(method) {
            return function() {
                // cast any arguments into an array, since they're
                // natively objects
                var args = Array.prototype.slice.apply(arguments);
                // make the first argument the array itself
                args.unshift(this);
                // return the result of the ss method
                return ss[method].apply(ss, args);
            };
        }

        // select object to extend
        var extending;
        if (array) {
            // create a shallow copy of the array so that our internal
            // operations do not change it by reference
            extending = array.slice();
        } else {
            extending = Array.prototype;
        }

        // for each array function, define a function that gets
        // the array as the first argument.
        // We use [defineProperty](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/defineProperty)
        // because it allows these properties to be non-enumerable:
        // `for (var in x)` loops will not run into problems with this
        // implementation.
        for (var i = 0; i < arrayMethods.length; i++) {
            Object.defineProperty(extending, arrayMethods[i], {
                value: wrap(arrayMethods[i]),
                configurable: true,
                enumerable: false,
                writable: true
            });
        }

        return extending;
    }
227325
function mix(target, source) {
        var args = _arrSlice.call(arguments),
            i = 1,
            key, self = arguments.callee,
            //如果最后参数是布尔，判定是否覆写同名属性
            ride = $.isBoolean(args[args.length - 1]) ? args.pop() : true;
        if(args.length === 1) {
            target = !this.window ? this : _cleanObj;
            i = 0;
        }

        while((source = args[i++])) {
            //source = [{a:1},{b:3}];
            if($.isArray(source)) {
                for(var n = 0, len = source.length; n < len; n++) {
                    self(target, source[n], ride);
                }

                continue;
            }
            //杂糅只允许对象
            for(key in source) {
                if(ride || !(key in target)) {
                    target[key] = source[key];
                }
            }
        }
        return target;
    }
917489
function (target) {
        var element = this.hashForMethods[target.id]
        if (element) {
            element.paused = false
        }

        var elementUpdate = this.hashForUpdates[target.id]
        //console.log('foo', target.id, elementUpdate)
        if (elementUpdate) {
            elementUpdate.paused = false
        }
    }
329839
function throwIf (target /*, illegal... */) {
    Array.prototype.slice.call(arguments, 1).forEach(function (name) {
      if (options[name]) {
        throw new Error('Cannot set ' + name + ' and ' + target + 'together');
      }
    });
  }
1170630
function(target, source, all) {
        target = target || {};
        for (var key in source) {
            // merge only if hasOwnProperty unless `all´ flag is set
            if (all || source.hasOwnProperty(key)) {
                target[key] = source[key];
            }
        }
        return target;
    }
295671
function multi(list /*, ... */) {
		var mw = core.base();
		mw.targets = (isArray(list) ? list : Array.prototype.slice.call(arguments.length, 0));
		mw.enabled = true;
		mw.writeln = function (line) {
			if (mw.enabled) {
				for (var i = 0, ii = mw.targets.length; i < ii; i++) {
					mw.targets[i].writeln(line);
				}
			}
		};
		mw.toString = function () {
			return '<miniwrite-multi>';
		};
		return mw;
	}