Internal method for calculating the maxOptions allowed for setting it in template
@return {Number}
175028
function () {
            var maxCount = 0, suggestion = this.controller.selectedSuggestions;
            if (suggestion.length < this.controller.maxOptions) {
                return this.controller.maxOptions;
            } else {
                for (var i = 0, len = suggestion.length; i < len; i++) {
                    if (ariaUtilsType.isObject(suggestion[i])) {
                        maxCount++;
                    }
                }
                return maxCount;
            }
        }
742096
function (num, min, max) {
        if (typeof num !== 'number' || num < min) {
            return min;
        }
        if (num === Infinity) {
            return _.isNil(max) ? min : max;
        }

        return num;
    }
901504
function parseOptions(options) {
        options = _.defaults(options || {}, defaults);

        if (options.limit !== 'all') {
            options.limit = parseInt(options.limit, 10) || defaults.limit;
        }

        options.page = parseInt(options.page, 10) || defaults.page;

        return options;
    }
1230134
function Range(){
  if (!(this instanceof Range)) {
    return new Range();
  }

  // maximize int.
  var max = Math.pow(2, 32) - 1;
  // default options.
  this.options = {
    min: -max,
    max: max,
    res: {
      range  : /^[\s\d\-~,]+$/,
      blank  : /\s+/g,
      number : /^\-?\d+$/,
      min2num: /^~\-?\d+$/,
      num2max: /^\-?\d+~$/,
      num2num: /^\-?\d+~\-?\d+$/
    }
  };

  Object.freeze(this.options);
}
673114
function() {
      this.oCoords || this.setCoords();
      var xCoords = [this.oCoords.tl.x, this.oCoords.tr.x, this.oCoords.br.x, this.oCoords.bl.x];
      var minX = fabric.util.array.min(xCoords);
      var maxX = fabric.util.array.max(xCoords);
      return Math.abs(minX - maxX);
    }
380941
function () {
  OptionsProcessor.apply(this, arguments)

  this._single = false
  this._cached = false
  this._resolved = true

  this._query = undefined
  this._fields = undefined
  this._options = {
    limit: 500
  }
}
1098038
private int maxOperadType( CssFormatter formatter ) {
        int dataType = operands.get( 0 ).getDataType( formatter );
        for( int i = 1; i < operands.size(); i++ ) {
            dataType = Math.max( dataType, operands.get( i ).getDataType( formatter ) );
        }
        return dataType;
    }
372966
function getMaxY() {
    if (self.options.maxY) {
      return self.options.maxY;
    }

    var max = -Infinity;

    for(let i = 0; i < data.length; i++) {
      if (data[i].y.length) {
        var current = _.max(data[i].y, parseFloat);
        if (current > max) {
          max = current;
        }
      }
    }

    return max + (max - self.options.minY) * 0.2;
  }
755683
function getTruncatedOptions(options, maxResults) {
  if (!maxResults || maxResults >= options.length) {
    return options;
  }

  return options.slice(0, maxResults);
}
140463
function maxWrapperPosition() {
        var a = (wrapperSize - containerSize);
        if (params.freeMode) {
            a = wrapperSize - containerSize;
        }
        // if (params.loop) a -= containerSize;
        if (params.slidesPerView > _this.slides.length && !params.centeredSlides) {
            a = 0;
        }
        if (a < 0) a = 0;
        return a;
    }
641860
function(options) {
      inputEx.SliderField.superclass.setOptions.call(this, options);
      
      this.options.className = options.className ? options.className : 'inputEx-SliderField';
   	   
      this.options.minValue = lang.isUndefined(options.minValue) ? 0 : options.minValue;
      this.options.maxValue = lang.isUndefined(options.maxValue) ? 100 : options.maxValue;
      
      this.options.displayValue = lang.isUndefined(options.displayValue) ? true : options.displayValue;
   }
427815
function() {
      var val = Math.floor(this.options.minValue+(this.options.maxValue-this.options.minValue)*this.slider.getValue()/100);
      return val;
   }
103476
function maxOrMin( args, method ) {
            var m, n,
                i = 0;

            if ( isArray( args[0] ) ) args = args[0];
            m = new BigNumber( args[0] );

            for ( ; ++i < args.length; ) {
                n = new BigNumber( args[i] );

                // If any number is NaN, return NaN.
                if ( !n.s ) {
                    m = n;
                    break;
                } else if ( method.call( m, n ) ) {
                    m = n;
                }
            }

            return m;
        }
312557
function () {
            var docEl = document.documentElement;
            return Math.max( docEl.scrollHeight, document.body.scrollHeight, docEl.clientHeight );
        }
963507
private function getMaxWidth()
    {
        $max = 0;

        foreach ($this->getOptions() as $option) {
            $nameLength = \strlen($option->getName()) + 2;
            if ($option->getShortcut()) {
                $nameLength += \strlen($option->getShortcut()) + 3;
            }

            $max = \max($max, $nameLength);
        }

        foreach ($this->getArguments() as $argument) {
            $max = \max($max, \strlen($argument->getName()));
        }

        return ++$max;
    }
304391
function _createOptions(config) {
  return {
    filename:config.filename,
    displayErrors:true,
    timeout: config.timeout || 20*1000
  };
}
1140798
function(){
			var rows = this.model.get('options').rows*1 || null;
			if(rows) return Math.max(3, rows/2);

			var cellHeight = 70;
			var height = this.$el.parent().height() - this.$el.children(':first').height();

			// Less the maximum required by the tags (Scheduled, Playing, Ended...)
			height -= 180;

			rows = Math.round(height / cellHeight - 0.5);
			console.log(height);
			return Math.max(3, rows);
		}