each-arg/dist/each-arg.umd.js

Iterates through arguments or any other array-like object starting from specific index.

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = global || self, global.eachArg = factory());
}(this, function () { 'use strict';

  /**
   * isArray
   */

  var isArray = Array.isArray;

  /**
   * toString
   */

  var str = Object.prototype.toString;

  /**
   * Whether or not the given `val`
   * is an array.
   *
   * example:
   *
   *        isArray([]);
   *        // > true
   *        isArray(arguments);
   *        // > false
   *        isArray('');
   *        // > false
   *
   * @param {mixed} val
   * @return {bool}
   */

  var isArray_1 = isArray || function (val) {
    return !! val && '[object Array]' == str.call(val);
  };

  var isWindow = function (obj) {

    if (obj == null) {
      return false;
    }

    var o = Object(obj);

    return o === o.window;
  };

  var isFunction_1 = isFunction;

  var toString = Object.prototype.toString;

  function isFunction (fn) {
    var string = toString.call(fn);
    return string === '[object Function]' ||
      (typeof fn === 'function' && string !== '[object RegExp]') ||
      (typeof window !== 'undefined' &&
       // IE8 and below
       (fn === window.setTimeout ||
        fn === window.alert ||
        fn === window.confirm ||
        fn === window.prompt))
  }

  var isArrayLike = function (obj) {

    if (!obj) {
      return false;
    }

    if (isArray_1(obj)) {
      return true;
    }

    if (isFunction_1(obj) || isWindow(obj)) {
      return false;
    }

    obj = Object(obj);

    var length = 'length' in obj && obj.length;

    if (obj.nodeType === 1 && length) {
      return true;
    }

    return length === 0 ||
      typeof length === 'number' && length > 0 && ( length - 1 ) in obj;
  };

  function toArray(args, start) {
    if (!isArrayLike(args) && args !== "") {
      throw new TypeError(args + " can't be converted to array.");
    }

    if (start == null) {
      start = 0;
    }

    if (typeof start !== "number" || !isFinite(start)) {
      throw new TypeError(start + " is not a valid start point.");
    }

    var len = args.length;

    if (start < 0) {
      start += len;
    }

    var argsObj = Object(args);
    var result = new Array(len - start);

    for (var i = start; i < len; i++) {
      if (i in argsObj) {
        result[i - start] = argsObj[i];
      }
    }

    return result;
  }

  function error(message) {
    return new TypeError(message);
  }

  function wrapCallback(callback, thisArg, arr, args, argsLen) {
    var extraLen = argsLen - 3;
    return extraLen === 0 ? function (i) {
      return callback.call(thisArg, arr[i], i);
    } : extraLen === 1 ? function (i) {
      return callback.call(thisArg, arr[i], i, args[3]);
    } : function (i) {
      return callback.call.apply(callback, [thisArg, arr[i], i].concat(toArray(args, 3)));
    };
  }

  function eachArg(arr, start, callback) {
    var args = arguments;
    var argsLen = args.length;

    if (argsLen < 3) {
      throw error("expected 3 arguments, got " + argsLen);
    }

    if (!isArrayLike(arr) && arr !== "") {
      throw error(arr + " can't be converted to array.");
    }

    if (typeof start !== "number" || !isFinite(start)) {
      throw error(start + " is not a valid start point.");
    }

    if (!isFunction_1(callback)) {
      throw error(callback + " is not a function.");
    }

    var arrObj = Object(arr);
    var len = arrObj.length;

    if (start < 0) {
      start += len;
    }

    var cb = wrapCallback(callback, this, arrObj, args, argsLen);

    for (var i = start; i < len; i++) {
      if (i in arrObj && cb(i)) {
        return;
      }
    }
  }

  return eachArg;

}));
//# sourceMappingURL=each-arg.umd.js.map