Indexes the tracking.
@return {Promise}
972371
function indexTracking() {
  const { tracking = {} } = getComponentsSettings();

  return index({
    file: 'tracking.js',
    config: {
      type: TYPE_TRACKERS,
      config: tracking,
    },
    ...getIndexLogTranslations(TYPE_TRACKERS),
  });
}
563412
function () {
      var tail = this._tail
        , head = this._head;
      for (var i = tail; i < head; i++) {
        var entry = this._byOrder[i];
        if (entry) {
          this._tail = i;
          return entry;
        }
      }
    }
841945
function fetchViews(match) {
  var activeTrace = match.activeTrace.map(fetchViewsStep);

  return activeTrace.some(Promise.is) ?
    Promise.all(activeTrace).then((activeTrace) => merge(match, {activeTrace})) :
    Promise.resolve(merge(match, {activeTrace}));
}
944335
function() {
    var tracker = this._aSelections;
    if(tracker && tracker.length > 0) {
        for(var i=tracker.length-1; i>-1; i--) {
           if(tracker[i].recordId && tracker[i].columnKey){
                return tracker[i];
            }
        }
    }
}
826764
function(index) {
      var that = this;

      var props = this._propIndex(index);
      if (!props) {
        return Promise.reject(new Error('No auto-indexing key specified'));
      }

      return this._dbApi.find(props).then(function(docs) {
        return that._readDoc(docs[0]);
      });
    }
338491
function () {
            var state = this.state,
                currentPage = state.pages[state.currentPage - 1],
                rowIndex = currentPage.rowIndex,
                prevRow = state.rows[rowIndex - 1];
            return prevRow && prevRow[0] + 1 || state.currentPage;
        }
1077608
def tracks_in_collection(start=nil,count=nil,sort=nil,
                             query=nil,extras=nil)
      api.getTracksInCollection self,start,count,sort,query,extras
    end
279464
function() {
      var newItemViews = [];
      _.each(this.modelsToRender(), function(model, indexOfModel) {
        var itemView = this.getItemViewFromModel(model);
        if (!itemView) {
          newItemViews.push({
            view: this.__createItemView(model, true),
            indexOfModel: indexOfModel
          });
        }
      }, this);
      this.__updateOrderedModelIdList();
      return newItemViews;
    }
273852
function SpotifySearch (title) {
  /**
   * @public {Array} tracks.
   */
  this.tracks = []

  // Query spotify, parse xml response, display in terminal,
  // prompt user for track number, play track.
  this._query(title)
  .then(this._parseJSON.bind(this))
  .then(this._printData.bind(this))
  .then(this._promptUser.bind(this))
  .then(this._playTrack.bind(this))
  .fail(this._onError.bind(this))
}
625806
function () {
    var data = {};
    var trackedControllerEls = this.trackedControllerEls;

    if (this.isRecording) { return; }

    // Camera.
    data.camera = this.cameraEl.components['motion-capture-recorder'].getJSONData();

    // Tracked controls.
    Object.keys(trackedControllerEls).forEach(function getControllerData (id) {
      data[id] = trackedControllerEls[id].components['motion-capture-recorder'].getJSONData();
    });

    return data;
  }
592435
function () {
            var data = this._data;
            if (data.selectedIndex == -1) {
                // no item is selected
                return [];
            } else if (data.selectedIndex != null) {
                return [data.selectedIndex];
            } else {
                var retVal = [];
                // we iterate over the view, so that we return indexes in the order visible to the user:
                var view = data.itemsView;
                view.refresh(); // in case there are changes in the view, refresh it
                var items = view.items;
                for (var idx = 0, length = items.length; idx < length; idx++) {
                    if (items[idx].value.selected) {
                        // retVal.push(idx);
                        retVal.push(items[idx].initIndex);
                    }
                }
                return retVal;
            }
        }
953809
function getNextIndex(state, delta) {
    const { index, items, slideWidth, itemsPerSlide } = state;
    let i = index;
    let item;

    // If going backward from 0, we go to the end.
    if (delta === LEFT && i === 0) {
        i = items.length - 1;
    } else {
        // Find the index of the next item that is not fully in view.
        do {
            item = items[i += delta];
        } while (item && item.fullyVisible);

        if (delta === LEFT && !itemsPerSlide) {
            // If going left without items per slide, go as far left as possible while keeping this item fully in view.
            const targetOffset = item.right - slideWidth;
            do {
                item = items[--i];
            } while (item && item.left >= targetOffset);
            i += 1;
        }
    }

    return normalizeIndex(state, i);
}
1334284
function TrackerInfo(obj) {
    this.attempts = obj.attempts
    this.id = obj.id
    this.states = obj.states
    this.origin = obj.origin,
    this.destiny = obj.destiny
    this.trackerWebsite = exportModule.getLink(this.id)
}
548101
function(index, follow) {
            if (_.isNull(follow)) follow = index;
            var value = "";
            value = index ? "index" : "noindex";
            value =  value + "," + (follow ? "follow" : "nofollow");
            this.meta("robots", value);
            return this;
        }
1049294
async function lookup(words) {
  const index = new Index();
  const hits = await index.lookup(words);
  index.quit();
  words.forEach((word, i) => {
    console.log(`hits for "${word}":`, hits[i].join(', '));
  });
  return hits;
}
690291
function track(property, thisArg){
    if(!(property in trackedProperties)){
      trackedProperties[property] = true;
      values[property] = model[property];
      Object.defineProperty(model, property, {
        get: function () { return values[property]; },
        set: function(newValue) {
          var oldValue = values[property];
          values[property] = newValue;
          getListeners(property).forEach(function(callback){
            callback.call(thisArg, newValue, oldValue);
          });
        }
      });
    }
  }
1106768
function getLaunchIndex(PromiseArray){
    return PromiseArray.map(r => {return (r.isRunning === false && r.isRejected === false && r.isResolved === false)}).indexOf(true)
}