Apply helper that allows specifying thisArg
@private
438547
function _apply(func, thisArg, promisedArgs) {
		return well.all(promisedArgs || []).then(function(args) {
			return func.apply(thisArg, args);
		});
	}
872185
function extend() {
    let arg = arguments,
        target = arg[0] || {},
        deep = false,
        length = arg.length,
        i = 1,
        value, attr,
        copyIsArray;

    if (isBoolean(target)) {
        deep = target;
        target = arg[1] || {};
        i++;
    }

    for (; i < length; i++) {
        for (attr in arg[i]) {

            value = arg[i][attr];

            if (deep && (isPlainObject(value) || (copyIsArray = isArray(value)))) {

                let src = target[attr];

                if (copyIsArray) {
                    copyIsArray = false;
                    src = isArray(src) ? src : [];
                } else {
                    src = isPlainObject(src) ? src : {};
                }

                target[attr] = extend(deep, src, value);

            } else {
                target[attr] = value;
            }
        }
    }

    return target;
}
265299
function extendThis() {
		var i, ni, objects, object, prop;
		objects = arguments;
		for (i = 0, ni = objects.length; i < ni; i++) {
			object = objects[i];
			for (prop in object) {
				this[prop] = object[prop];
			}
		}

		return this;
	}
110825
function(callback, thisArg) {
      return this.array.forEach(function(v, k) {
        callback.call(thisArg, v, k, this);
      }, this);
    }
1264523
function() {
        var args = Array.prototype.slice.call(arguments, 0),
            org = args.shift();

        return kwargs.apply(org, args);
    }
1169929
function applyNew(args) {
        // create an object with ctor's prototype but without
        // calling ctor on it.
        var ctor = args.callee, t = forceNew(ctor);
        // execute the real constructor on the new object
        ctor.apply(t, args);
        return t;
    }
186076
function (thisArg, index, context, step, data) {
    var steps = this.steps;
    var stepIndex = steps.indexOf(step);

    if (typeof step !== 'string' || !step) {
      throw Error('The `step` parameter must be a non-empty string');
    }

    if (stepIndex === -1) {
      throw Error('The step `' + step + '` not exists');
    }

    this.next(thisArg, {stepIndex: stepIndex, flowIndex: 0}, context, null, data);

    return this;
  }
1279401
function _doOnce(fn) {
    var called = false;
    return function() {
      if (called) return;
      called = true;
      fn.apply(this, arguments);
    };
  }
760185
function (fnName, args) {
            var func;
            var ancestor = this;
            var isFunc = isFunction(fnName);
            while (ancestor.parentView) {
                ancestor = ancestor.parentView;
                if (ancestor) {
                    func = isFunc ? fnName : ancestor[fnName];
                    func.apply(ancestor, args);
                }
            }
            return this;
        }
448073
function(fn) {
		return function() {
			var realArgs = [];
			var fnArgs = arguments;
			each(fnArgs, function(val, i) {
				if (i <= fnArgs.length) {
					while (val && val.isComputed) {
						val = val();
					}
					realArgs.push(val);
				}
			});
			return fn.apply(this, realArgs);
		};
	}
1359987
function (caller_args, caller_result) {
            if (!this.enabled())
                return undefined;
            var args = [];
            if (this.async()) {
                args.push(function (value) {
                    if (typeof caller_result === "function")
                        caller_result(value);
                });
            }
            args = _cs.concat(args, this.args(), caller_args);
            return this.func().apply(this.ctx(), args);
        }
682969
function (context, stepName, thisArg) {
    var steps = this.steps;
    var stepIndex = stepName ? steps.indexOf(stepName) : 0;
    var index = null;

    if (stepIndex === -1) {
      stepIndex = 0;
    }

    index = { stepIndex: stepIndex, flowIndex: 0 };

    this.next(thisArg, index, context || {}, null);

    return this;
  }
124322
function(cbArray, extraArgs) {
        var i, length

        for (i = 0, length = cbArray.length; i < length; i++)
          cbArray[i].apply(this, extraArgs)
      }
362919
function (fn, args) {
      fn = fn.toUpperCase();
      args = args || [];

      if (instance.helper.SUPPORTED_FORMULAS.indexOf(fn) > -1) {
        if (instance.formulas[fn]) {
          return instance.formulas[fn].apply(this, args);
        }
      }

      throw Error('NAME');
    }
324654
function(name, otherArgs) {
			if (name === 'option' && (otherArgs.length === 0 ||
					(otherArgs.length === 1 && typeof otherArgs[0] === 'string'))) {
				return true;
			}
			return $.inArray(name, this._getters) > -1;
		}
218955
function not(pred, thisArg) {
    function notPred() {
        return !(notPred.pred.apply(notPred.thisArg, arguments));
    }
    notPred.pred = pred;
    notPred.thisArg = thisArg;
    return notPred;
}
1365940
function checkArguments () {
    var obj = flag(this, 'object')
      , type = Object.prototype.toString.call(obj);
    this.assert(
        '[object Arguments]' === type
      , 'expected #{this} to be arguments but got ' + type
      , 'expected #{this} to not be arguments'
    );
  }