Callback Function
@param element
@param index
@param array
166626
function tokenizeByLine (element, index, array) {
    parser.line = index + 1
    parser.column = 1

    var paragraphNode = parser.createParentNode('Paragraph')

    // 空行ではない場合
    if (element !== '') {
      // 半角括弧を全角括弧に変換
      var str = new Jaco(element).toWideJapneseSymbol().toString()

      // 改行ノードをParagraphNodeに追加する
      parser.add(parser.createTextNode('Text', str), paragraphNode)
    }

    // 改行ノードをParagraphNodeに追加する
    parser.add(parser.createTextNode('WhiteSpace', '\n'), paragraphNode)

    // ParagraphNodeをRoodNodeに追加
    parser.add(paragraphNode, rootNode)
  }
481129
function(index) {
            var step;

            if (!this.steps[index]) {
                if (this.config.loop && this._loops < this.config.maxLoops) {
                    this._loops++;
                    step = this.steps[this._current = 0];
                } else {
                    return false;
                }
            } else {
                step = this.steps[index];
            }

            if (step.preload && !step.preloaded) {
                this._handlePreload(step.preload, function() {
                    step.preloaded = true;
                    this._setNext(step.nextDelay);

                    if(step.fn) {
                        step.fn.call(this, step);
                    }

                }.bind(this));
            } else {
                this._setNext(step.nextDelay);

                if(step.fn) {
                    step.fn.call(this, step);
                }
            }

            if (step.autoDestroy) {
                var i = this.steps.indexOf(step);
                this._current = i;
                this._recentDestroy = true;
                this.steps.splice(i, 1);
            }
        }
1187031
function(callback){
              [].every.call(this, function(el, idx){
                return callback.call(el, idx, el) !== false
              })
              return this
            }
763232
public static void atIndex( final int[] array, int index, int value ) {
        final int i = calculateIndex( array, index );

        array[ i ] = value;
    }
1128646
function(element, callback) {
        resolveElementHeightChange(element).then(function(newVal, oldVal) {
            var heightEvent = jQuery.Event('timelineMe.itemHeightChanged', {elementHeight: newVal, previousHeight: oldVal});
            element.trigger(heightEvent);
        });
        element.on('timelineMe.itemHeightChanged', function(e) {
            callback({element: element, newVal: e.elementHeight, oldVal: e.previousHeight});
            resolveElementHeightChange($(e.target), {previousHeight: e.elementHeight}).then(function(newVal, oldVal) {
                var heightEvent = jQuery.Event('timelineMe.itemHeightChanged', {elementHeight: newVal, previousHeight: oldVal});
                $(e.target).trigger(heightEvent);
            });
        });
    }
1363296
function (items, array, index) {
        
        // There might be some optimization to be made here.
        // Right now, I'm just going for a simple solution.
        
        if (   !(items instanceof Array)
            || !(array instanceof Array) )
            throw "IllegalArgumentException: items and array must both be Array objects.";
        
        var numRemoved = 0;
        for (var i = 0, len = items.length; i < len; i++) {
            if (Arrays.remove(items[i], array, index) >= 0)
                numRemoved++;
        }
        
        return numRemoved;
    }
1230366
function forEachElement(elements, callback = () => {}) {
  const elementsType = Object.prototype.toString.call(elements);
  const isCollectionTyped = (elementsType === '[object Array]' ||
          (elementsType === '[object NodeList]') ||
          (elementsType === '[object HTMLCollection]') ||
          (typeof jQuery !== 'undefined' && elements instanceof jQuery) || // jquery
          (typeof Elements !== 'undefined' && elements instanceof Elements) // mootools
      );
  let i = 0;
  const j = elements.length;
  if (isCollectionTyped) {
    for (; i < j; i += 1) {
      callback(elements[i]);
    }
  } else {
    callback(elements);
  }
}
1113521
function onchange(array, index, removed, added) {
		edb.Array.$onchange(array, index, removed, added);
	}
467206
function findIndexInArray(array, callback) {
        var _length = array.length;
        for (var i = 0; i < _length; i++) {
            if (callback(array[i])) return i;
        }
        return -1;
    }
850051
public static Object setOrAppend(Object array, int index, Object value) {
		if(index < length(array)) {
			Array.set(array, index, value);
			return array;
		}else {
			return append(array, value);
		}
	}
565473
public static void set(final int[][] array, final long index, int value)
    {
        array[segment(index)][displacement(index)] = value;
    }
735842
function(element, callback, nowait) {
    var self = this;
    if (!nowait) {
      this.waitForPage(function() {
        self.waitForElement(element, callback, true);
      });
    }
    else {
      var loadWait = function() {
        setTimeout(function() {
          self.waitForElement(element, callback, true);
        }, 100);
      };
      if (nowait) {
        getPage(function(page) {
          page.evaluate(function(element) {
            var element = jQuery(element);
            return ((element.length > 0) && element.is(':visible'));
          }, function(found) {
            if (found) {
              self.debug('Element ' + element + ' found');
              callback.call(self);
            }
            else {
              loadWait();
            }
          }, element);
        });
      }
      else {
        loadWait();
      }
    }
  }
589256
private void setArrayNodeID(int index, ArrayList<INode> array, INode node) {
        if (index < array.size()) {
            array.set(index, node);
        } else {
            array.add(index, node);
        }
    }
912537
function forEach(array, itemCallback) {
  for (let i = 0, len = array.length; i < len; i++) {
    if (itemCallback) {
      itemCallback.call(array[i], array[i], i);
    }
  }
}
1245652
function (arr, callback, thisObj) {
  if (arr == null) {
    return;
  }
  var i = -1,
      len = arr.length;
  while (++i < len) {
    // we iterate over sparse items since there is no way to make it
    // work properly on IE 7-8. see #64
    if ( callback.call(thisObj, arr[i], i, arr) === false ) {
      break;
    }
  }
}
196813
function(fn) {
            	var n = this.elements.length;
            	for (var i = 0; i < n; i++) {
            	    fn(this.elements[i], i + 1);
            	}
                }
477860
public void add(int index, int element)
    {
        if (index == size())//special case, just appending
        {
            add(element);
        }
        else
        {
            boundsCheck(index);
            enlargeIfNeeded(1);
            System.arraycopy(array, index, array, index+1, end-index);
            array[index] = element;
            end++;
        }
    }