text: /*! Scroller 1.2.2
   * ©2011-2014 SpryMedia Ltd - datatables.net/license
   */
  
  /**
   * @summary     Scroller
   * @description Virtual rendering for DataTables
   * @version     1.2.2
   * @file        dataTables.scroller.js
   * @author      SpryMedia Ltd (www.sprymedia.co.uk)
   * @contact     www.sprymedia.co.uk/contact
   * @copyright   Copyright 2011-2014 SpryMedia Ltd.
   *
   * This source file is free software, available under the following license:
   *   MIT license - http://datatables.net/license/mit
   *
   * This source file is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
   *
   * For details please refer to: http://www.datatables.net
   */
  
  ;(function(window, document, undefined) {
      var factory = function($, DataTable) {
          'use strict'
  
          /**
           * Scroller is a virtual rendering plug-in for DataTables which allows large
           * datasets to be drawn on screen every quickly. What the virtual rendering means
           * is that only the visible portion of the table (and a bit to either side to make
           * the scrolling smooth) is drawn, while the scrolling container gives the
           * visual impression that the whole table is visible. This is done by making use
           * of the pagination abilities of DataTables and moving the table around in the
           * scrolling container DataTables adds to the page. The scrolling container is
           * forced to the height it would be for the full table display using an extra
           * element.
           *
           * Note that rows in the table MUST all be the same height. Information in a cell
           * which expands on to multiple lines will cause some odd behaviour in the scrolling.
           *
           * Scroller is initialised by simply including the letter 'S' in the sDom for the
           * table you want to have this feature enabled on. Note that the 'S' must come
           * AFTER the 't' parameter in `dom`.
           *
           * Key features include:
           *   <ul class="limit_length">
           *     <li>Speed! The aim of Scroller for DataTables is to make rendering large data sets fast</li>
           *     <li>Full compatibility with deferred rendering in DataTables 1.9 for maximum speed</li>
           *     <li>Display millions of rows</li>
           *     <li>Integration with state saving in DataTables (scrolling position is saved)</li>
           *     <li>Easy to use</li>
           *   </ul>
           *
           *  @class
           *  @constructor
           *  @global
           *  @param {object} oDT DataTables settings object
           *  @param {object} [oOpts={}] Configuration object for FixedColumns. Options
           *    are defined by {@link Scroller.defaults}
           *
           *  @requires jQuery 1.7+
           *  @requires DataTables 1.9.0+
           *
           *  @example
           *    $(document).ready(function() {
           *        $('#example').dataTable( {
           *            "sScrollY": "200px",
           *            "sAjaxSource": "media/dataset/large.txt",
           *            "sDom": "frtiS",
           *            "bDeferRender": true
           *        } );
           *    } );
           */
          var Scroller = function(oDTSettings, oOpts) {
              /* Sanity check - you just know it will happen */
              if (!this instanceof Scroller) {
                  alert(
                      "Scroller warning: Scroller must be initialised with the 'new' keyword.",
                  )
                  return
              }
  
              if (typeof oOpts == 'undefined') {
                  oOpts = {}
              }
  
              /**
               * Settings object which contains customisable information for the Scroller instance
               * @namespace
               * @private
               * @extends Scroller.defaults
               */
              this.s = {
                  /**
                   * DataTables settings object
                   *  @type     object
                   *  @default  Passed in as first parameter to constructor
                   */
                  dt: oDTSettings,
  
                  /**
                   * Pixel location of the top of the drawn table in the viewport
                   *  @type     int
                   *  @default  0
                   */
                  tableTop: 0,
  
                  /**
                   * Pixel location of the bottom of the drawn table in the viewport
                   *  @type     int
                   *  @default  0
                   */
                  tableBottom: 0,
  
                  /**
                   * Pixel location of the boundary for when the next data set should be loaded and drawn
                   * when scrolling up the way.
                   *  @type     int
                   *  @default  0
                   *  @private
                   */
                  redrawTop: 0,
  
                  /**
                   * Pixel location of the boundary for when the next data set should be loaded and drawn
                   * when scrolling down the way. Note that this is actually calculated as the offset from
                   * the top.
                   *  @type     int
                   *  @default  0
                   *  @private
                   */
                  redrawBottom: 0,
  
                  /**
                   * Auto row height or not indicator
                   *  @type     bool
                   *  @default  0
                   */
                  autoHeight: true,
  
                  /**
                   * Number of rows calculated as visible in the visible viewport
                   *  @type     int
                   *  @default  0
                   */
                  viewportRows: 0,
  
                  /**
                   * setTimeout reference for state saving, used when state saving is enabled in the DataTable
                   * and when the user scrolls the viewport in order to stop the cookie set taking too much
                   * CPU!
                   *  @type     int
                   *  @default  0
                   */
                  stateTO: null,
  
                  /**
                   * setTimeout reference for the redraw, used when server-side processing is enabled in the
                   * DataTables in order to prevent DoSing the server
                   *  @type     int
                   *  @default  null
                   */
                  drawTO: null,
  
                  heights: {
                      jump: null,
                      page: null,
                      virtual: null,
                      scroll: null,
  
                      /**
                       * Height of rows in the table
                       *  @type     int
                       *  @default  0
                       */
                      row: null,
  
                      /**
                       * Pixel height of the viewport
                       *  @type     int
                       *  @default  0
                       */
                      viewport: null,
                  },
  
                  topRowFloat: 0,
                  scrollDrawDiff: null,
                  loaderVisible: false,
              }
  
              // @todo The defaults should extend a `c` property and the internal settings
              // only held in the `s` property. At the moment they are mixed
              this.s = $.extend(this.s, Scroller.oDefaults, oOpts)
  
              // Workaround for row height being read from height object (see above comment)
              this.s.heights.row = this.s.rowHeight
  
              /**
               * DOM elements used by the class instance
               * @private
               * @namespace
               *
               */
              this.dom = {
                  force: document.createElement('div'),
                  scroller: null,
                  table: null,
                  loader: null,
              }
  
              /* Attach the instance to the DataTables instance so it can be accessed */
              this.s.dt.oScroller = this
  
              /* Let's do it */
              this._fnConstruct()
          }
  
          Scroller.prototype = /** @lends Scroller.prototype */ {
              /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
               * Public methods
               * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
              /**
               * Calculate the pixel position from the top of the scrolling container for
               * a given row
               *  @param {int} iRow Row number to calculate the position of
               *  @returns {int} Pixels
               *  @example
               *    $(document).ready(function() {
               *      $('#example').dataTable( {
               *        "sScrollY": "200px",
               *        "sAjaxSource": "media/dataset/large.txt",
               *        "sDom": "frtiS",
               *        "bDeferRender": true,
               *        "fnInitComplete": function (o) {
               *          // Find where row 25 is
               *          alert( o.oScroller.fnRowToPixels( 25 ) );
               *        }
               *      } );
               *    } );
               */
              fnRowToPixels: function(rowIdx, intParse, virtual) {
                  var pixels
  
                  if (virtual) {
                      pixels = this._domain(
                          'virtualToPhysical',
                          rowIdx * this.s.heights.row,
                      )
                  } else {
                      var diff = rowIdx - this.s.baseRowTop
                      pixels = this.s.baseScrollTop + diff * this.s.heights.row
                  }
  
                  return intParse || intParse === undefined
                      ? parseInt(pixels, 10)
                      : pixels
              },
  
              /**
               * Calculate the row number that will be found at the given pixel position
               * (y-scroll).
               *
               * Please note that when the height of the full table exceeds 1 million
               * pixels, Scroller switches into a non-linear mode for the scrollbar to fit
               * all of the records into a finite area, but this function returns a linear
               * value (relative to the last non-linear positioning).
               *  @param {int} iPixels Offset from top to calculate the row number of
               *  @param {int} [intParse=true] If an integer value should be returned
               *  @param {int} [virtual=false] Perform the calculations in the virtual domain
               *  @returns {int} Row index
               *  @example
               *    $(document).ready(function() {
               *      $('#example').dataTable( {
               *        "sScrollY": "200px",
               *        "sAjaxSource": "media/dataset/large.txt",
               *        "sDom": "frtiS",
               *        "bDeferRender": true,
               *        "fnInitComplete": function (o) {
               *          // Find what row number is at 500px
               *          alert( o.oScroller.fnPixelsToRow( 500 ) );
               *        }
               *      } );
               *    } );
               */
              fnPixelsToRow: function(pixels, intParse, virtual) {
                  var diff = pixels - this.s.baseScrollTop
                  var row = virtual
                      ? this._domain('physicalToVirtual', pixels) /
                        this.s.heights.row
                      : diff / this.s.heights.row + this.s.baseRowTop
  
                  return intParse || intParse === undefined
                      ? parseInt(row, 10)
                      : row
              },
  
              /**
               * Calculate the row number that will be found at the given pixel position (y-scroll)
               *  @param {int} iRow Row index to scroll to
               *  @param {bool} [bAnimate=true] Animate the transition or not
               *  @returns {void}
               *  @example
               *    $(document).ready(function() {
               *      $('#example').dataTable( {
               *        "sScrollY": "200px",
               *        "sAjaxSource": "media/dataset/large.txt",
               *        "sDom": "frtiS",
               *        "bDeferRender": true,
               *        "fnInitComplete": function (o) {
               *          // Immediately scroll to row 1000
               *          o.oScroller.fnScrollToRow( 1000 );
               *        }
               *      } );
               *
               *      // Sometime later on use the following to scroll to row 500...
               *          var oSettings = $('#example').dataTable().fnSettings();
               *      oSettings.oScroller.fnScrollToRow( 500 );
               *    } );
               */
              fnScrollToRow: function(iRow, bAnimate) {
                  var that = this
                  var ani = false
                  var px = this.fnRowToPixels(iRow)
  
                  // We need to know if the table will redraw or not before doing the
                  // scroll. If it will not redraw, then we need to use the currently
                  // displayed table, and scroll with the physical pixels. Otherwise, we
                  // need to calculate the table's new position from the virtual
                  // transform.
                  var preRows =
                      ((this.s.displayBuffer - 1) / 2) * this.s.viewportRows
                  var drawRow = iRow - preRows
                  if (drawRow < 0) {
                      drawRow = 0
                  }
  
                  if (
                      (px > this.s.redrawBottom || px < this.s.redrawTop) &&
                      this.s.dt._iDisplayStart !== drawRow
                  ) {
                      ani = true
                      px = this.fnRowToPixels(iRow, false, true)
                  }
  
                  if (typeof bAnimate == 'undefined' || bAnimate) {
                      this.s.ani = ani
                      $(this.dom.scroller).animate(
                          {
                              scrollTop: px,
                          },
                          function() {
                              // This needs to happen after the animation has completed and
                              // the final scroll event fired
                              setTimeout(function() {
                                  that.s.ani = false
                              }, 25)
                          },
                      )
                  } else {
                      $(this.dom.scroller).scrollTop(px)
                  }
              },
  
              /**
               * Calculate and store information about how many rows are to be displayed
               * in the scrolling viewport, based on current dimensions in the browser's
               * rendering. This can be particularly useful if the table is initially
               * drawn in a hidden element - for example in a tab.
               *  @param {bool} [bRedraw=true] Redraw the table automatically after the recalculation, with
               *    the new dimensions forming the basis for the draw.
               *  @returns {void}
               *  @example
               *    $(document).ready(function() {
               *      // Make the example container hidden to throw off the browser's sizing
               *      document.getElementById('container').style.display = "none";
               *      var oTable = $('#example').dataTable( {
               *        "sScrollY": "200px",
               *        "sAjaxSource": "media/dataset/large.txt",
               *        "sDom": "frtiS",
               *        "bDeferRender": true,
               *        "fnInitComplete": function (o) {
               *          // Immediately scroll to row 1000
               *          o.oScroller.fnScrollToRow( 1000 );
               *        }
               *      } );
               *
               *      setTimeout( function () {
               *        // Make the example container visible and recalculate the scroller sizes
               *        document.getElementById('container').style.display = "block";
               *        oTable.fnSettings().oScroller.fnMeasure();
               *      }, 3000 );
               */
              fnMeasure: function(bRedraw) {
                  if (this.s.autoHeight) {
                      this._fnCalcRowHeight()
                  }
  
                  var heights = this.s.heights
  
                  heights.viewport = $(this.dom.scroller).height()
                  this.s.viewportRows =
                      parseInt(heights.viewport / heights.row, 10) + 1
                  this.s.dt._iDisplayLength =
                      this.s.viewportRows * this.s.displayBuffer
  
                  if (bRedraw === undefined || bRedraw) {
                      this.s.dt.oInstance.fnDraw()
                  }
              },
  
              /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
               * Private methods (they are of course public in JS, but recommended as private)
               * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
              /**
               * Initialisation for Scroller
               *  @returns {void}
               *  @private
               */
              _fnConstruct: function() {
                  var that = this
  
                  /* Sanity check */
                  if (!this.s.dt.oFeatures.bPaginate) {
                      this.s.dt.oApi._fnLog(
                          this.s.dt,
                          0,
                          'Pagination must be enabled for Scroller',
                      )
                      return
                  }
  
                  /* Insert a div element that we can use to force the DT scrolling container to
                   * the height that would be required if the whole table was being displayed
                   */
                  this.dom.force.style.position = 'absolute'
                  this.dom.force.style.top = '0px'
                  this.dom.force.style.left = '0px'
                  this.dom.force.style.width = '1px'
  
                  this.dom.scroller = $(
                      'div.' + this.s.dt.oClasses.sScrollBody,
                      this.s.dt.nTableWrapper,
                  )[0]
                  this.dom.scroller.appendChild(this.dom.force)
                  this.dom.scroller.style.position = 'relative'
  
                  this.dom.table = $('>table', this.dom.scroller)[0]
                  this.dom.table.style.position = 'absolute'
                  this.dom.table.style.top = '0px'
                  this.dom.table.style.left = '0px'
  
                  // Add class to 'announce' that we are a Scroller table
                  $(this.s.dt.nTableWrapper).addClass('DTS')
  
                  // Add a 'loading' indicator
                  if (this.s.loadingIndicator) {
                      this.dom.loader = $(
                          '<div class="DTS_Loading">' +
                              this.s.dt.oLanguage.sLoadingRecords +
                              '</div>',
                      ).css('display', 'none')
  
                      $(this.dom.scroller.parentNode)
                          .css('position', 'relative')
                          .append(this.dom.loader)
                  }
  
                  /* Initial size calculations */
                  if (this.s.heights.row && this.s.heights.row != 'auto') {
                      this.s.autoHeight = false
                  }
                  this.fnMeasure(false)
  
                  /* Scrolling callback to see if a page change is needed - use a throttled
                   * function for the save save callback so we aren't hitting it on every
                   * scroll
                   */
                  this.s.ingnoreScroll = true
                  this.s.stateSaveThrottle = this.s.dt.oApi._fnThrottle(
                      function() {
                          that.s.dt.oApi._fnSaveState(that.s.dt)
                      },
                      500,
                  )
                  $(this.dom.scroller).on('scroll.DTS', function(e) {
                      that._fnScroll.call(that)
                  })
  
                  /* In iOS we catch the touchstart event in case the user tries to scroll
                   * while the display is already scrolling
                   */
                  $(this.dom.scroller).on('touchstart.DTS', function() {
                      that._fnScroll.call(that)
                  })
  
                  /* Update the scroller when the DataTable is redrawn */
                  this.s.dt.aoDrawCallback.push({
                      fn: function() {
                          if (that.s.dt.bInitialised) {
                              that._fnDrawCallback.call(that)
                          }
                      },
                      sName: 'Scroller',
                  })
  
                  /* On resize, update the information element, since the number of rows shown might change */
                  $(window).on('resize.DTS', function() {
                      that.fnMeasure(false)
                      that._fnInfo()
                  })
  
                  /* Add a state saving parameter to the DT state saving so we can restore the exact
                   * position of the scrolling
                   */
                  var initialStateSave = true
                  this.s.dt.oApi._fnCallbackReg(
                      this.s.dt,
                      'aoStateSaveParams',
                      function(oS, oData) {
                          /* Set iScroller to saved scroll position on initialization.
                           */
                          if (initialStateSave && that.s.dt.oLoadedState) {
                              oData.iScroller = that.s.dt.oLoadedState.iScroller
                              oData.iScrollerTopRow =
                                  that.s.dt.oLoadedState.iScrollerTopRow
                              initialStateSave = false
                          } else {
                              oData.iScroller = that.dom.scroller.scrollTop
                              oData.iScrollerTopRow = that.s.topRowFloat
                          }
                      },
                      'Scroller_State',
                  )
  
                  if (this.s.dt.oLoadedState) {
                      this.s.topRowFloat =
                          this.s.dt.oLoadedState.iScrollerTopRow || 0
                  }
  
                  /* Destructor */
                  this.s.dt.aoDestroyCallback.push({
                      sName: 'Scroller',
                      fn: function() {
                          $(window).off('resize.DTS')
                          $(that.dom.scroller).off('touchstart.DTS scroll.DTS')
                          $(that.s.dt.nTableWrapper).removeClass('DTS')
                          $(
                              'div.DTS_Loading',
                              that.dom.scroller.parentNode,
                          ).remove()
  
                          that.dom.table.style.position = ''
                          that.dom.table.style.top = ''
                          that.dom.table.style.left = ''
                      },
                  })
              },
  
              /**
               * Scrolling function - fired whenever the scrolling position is changed.
               * This method needs to use the stored values to see if the table should be
               * redrawn as we are moving towards the end of the information that is
               * currently drawn or not. If needed, then it will redraw the table based on
               * the new position.
               *  @returns {void}
               *  @private
               */
              _fnScroll: function() {
                  var that = this,
                      heights = this.s.heights,
                      iScrollTop = this.dom.scroller.scrollTop,
                      iTopRow
  
                  if (this.s.skip) {
                      return
                  }
  
                  if (this.s.ingnoreScroll) {
                      return
                  }
  
                  /* If the table has been sorted or filtered, then we use the redraw that
                   * DataTables as done, rather than performing our own
                   */
                  if (this.s.dt.bFiltered || this.s.dt.bSorted) {
                      this.s.lastScrollTop = 0
                      return
                  }
  
                  /* Update the table's information display for what is now in the viewport */
                  this._fnInfo()
  
                  /* We don't want to state save on every scroll event - that's heavy
                   * handed, so use a timeout to update the state saving only when the
                   * scrolling has finished
                   */
                  clearTimeout(this.s.stateTO)
                  this.s.stateTO = setTimeout(function() {
                      that.s.dt.oApi._fnSaveState(that.s.dt)
                  }, 250)
  
                  /* Check if the scroll point is outside the trigger boundary which would required
                   * a DataTables redraw
                   */
                  if (
                      iScrollTop < this.s.redrawTop ||
                      iScrollTop > this.s.redrawBottom
                  ) {
                      var preRows = Math.ceil(
                          ((this.s.displayBuffer - 1) / 2) * this.s.viewportRows,
                      )
  
                      if (
                          Math.abs(iScrollTop - this.s.lastScrollTop) >
                              heights.viewport ||
                          this.s.ani
                      ) {
                          iTopRow =
                              parseInt(
                                  this._domain('physicalToVirtual', iScrollTop) /
                                      heights.row,
                                  10,
                              ) - preRows
                          this.s.topRowFloat =
                              this._domain('physicalToVirtual', iScrollTop) /
                              heights.row
                      } else {
                          iTopRow = this.fnPixelsToRow(iScrollTop) - preRows
                          this.s.topRowFloat = this.fnPixelsToRow(
                              iScrollTop,
                              false,
                          )
                      }
  
                      if (iTopRow <= 0) {
                          /* At the start of the table */
                          iTopRow = 0
                      } else if (
                          iTopRow + this.s.dt._iDisplayLength >
                          this.s.dt.fnRecordsDisplay()
                      ) {
                          /* At the end of the table */
                          iTopRow =
                              this.s.dt.fnRecordsDisplay() -
                              this.s.dt._iDisplayLength
                          if (iTopRow < 0) {
                              iTopRow = 0
                          }
                      } else if (iTopRow % 2 !== 0) {
                          // For the row-striping classes (odd/even) we want only to start
                          // on evens otherwise the stripes will change between draws and
                          // look rubbish
                          iTopRow++
                      }
  
                      if (iTopRow != this.s.dt._iDisplayStart) {
                          /* Cache the new table position for quick lookups */
                          this.s.tableTop = $(this.s.dt.nTable).offset().top
                          this.s.tableBottom =
                              $(this.s.dt.nTable).height() + this.s.tableTop
  
                          var draw = function() {
                              if (that.s.scrollDrawReq === null) {
                                  that.s.scrollDrawReq = iScrollTop
                              }
  
                              that.s.dt._iDisplayStart = iTopRow
                              if (that.s.dt.oApi._fnCalculateEnd) {
                                  // Removed in 1.10
                                  that.s.dt.oApi._fnCalculateEnd(that.s.dt)
                              }
                              that.s.dt.oApi._fnDraw(that.s.dt)
                          }
  
                          /* Do the DataTables redraw based on the calculated start point - note that when
                           * using server-side processing we introduce a small delay to not DoS the server...
                           */
                          if (this.s.dt.oFeatures.bServerSide) {
                              clearTimeout(this.s.drawTO)
                              this.s.drawTO = setTimeout(draw, this.s.serverWait)
                          } else {
                              draw()
                          }
  
                          if (this.dom.loader && !this.s.loaderVisible) {
                              this.dom.loader.css('display', 'block')
                              this.s.loaderVisible = true
                          }
                      }
                  }
  
                  this.s.lastScrollTop = iScrollTop
                  this.s.stateSaveThrottle()
              },
  
              /**
               * Convert from one domain to another. The physical domain is the actual
               * pixel count on the screen, while the virtual is if we had browsers which
               * had scrolling containers of infinite height (i.e. the absolute value)
               *
               *  @param {string} dir Domain transform direction, `virtualToPhysical` or
               *    `physicalToVirtual`
               *  @returns {number} Calculated transform
               *  @private
               */
              _domain: function(dir, val) {
                  var heights = this.s.heights
                  var coeff
  
                  // If the virtual and physical height match, then we use a linear
                  // transform between the two, allowing the scrollbar to be linear
                  if (heights.virtual === heights.scroll) {
                      coeff =
                          (heights.virtual - heights.viewport) /
                          (heights.scroll - heights.viewport)
  
                      if (dir === 'virtualToPhysical') {
                          return val / coeff
                      } else if (dir === 'physicalToVirtual') {
                          return val * coeff
                      }
                  }
  
                  // Otherwise, we want a non-linear scrollbar to take account of the
                  // redrawing regions at the start and end of the table, otherwise these
                  // can stutter badly - on large tables 30px (for example) scroll might
                  // be hundreds of rows, so the table would be redrawing every few px at
                  // the start and end. Use a simple quadratic to stop this. It does mean
                  // the scrollbar is non-linear, but with such massive data sets, the
                  // scrollbar is going to be a best guess anyway
                  var xMax = (heights.scroll - heights.viewport) / 2
                  var yMax = (heights.virtual - heights.viewport) / 2
  
                  coeff = yMax / (xMax * xMax)
  
                  if (dir === 'virtualToPhysical') {
                      if (val < yMax) {
                          return Math.pow(val / coeff, 0.5)
                      } else {
                          val = yMax * 2 - val
                          return val < 0
                              ? heights.scroll
                              : xMax * 2 - Math.pow(val / coeff, 0.5)
                      }
                  } else if (dir === 'physicalToVirtual') {
                      if (val < xMax) {
                          return val * val * coeff
                      } else {
                          val = xMax * 2 - val
                          return val < 0
                              ? heights.virtual
                              : yMax * 2 - val * val * coeff
                      }
                  }
              },
  
              /**
               * Draw callback function which is fired when the DataTable is redrawn. The main function of
               * this method is to position the drawn table correctly the scrolling container for the rows
               * that is displays as a result of the scrolling position.
               *  @returns {void}
               *  @private
               */
              _fnDrawCallback: function() {
                  var that = this,
                      heights = this.s.heights,
                      iScrollTop = this.dom.scroller.scrollTop,
                      iActualScrollTop = iScrollTop,
                      iScrollBottom = iScrollTop + heights.viewport,
                      iTableHeight = $(this.s.dt.nTable).height(),
                      displayStart = this.s.dt._iDisplayStart,
                      displayLen = this.s.dt._iDisplayLength,
                      displayEnd = this.s.dt.fnRecordsDisplay()
  
                  // Disable the scroll event listener while we are updating the DOM
                  this.s.skip = true
  
                  // Resize the scroll forcing element
                  this._fnScrollForce()
  
                  // Reposition the scrolling for the updated virtual position if needed
                  if (displayStart === 0) {
                      // Linear calculation at the top of the table
                      iScrollTop = this.s.topRowFloat * heights.row
                  } else if (displayStart + displayLen >= displayEnd) {
                      // Linear calculation that the bottom as well
                      iScrollTop =
                          heights.scroll -
                          (displayEnd - this.s.topRowFloat) * heights.row
                  } else {
                      // Domain scaled in the middle
                      iScrollTop = this._domain(
                          'virtualToPhysical',
                          this.s.topRowFloat * heights.row,
                      )
                  }
  
                  this.dom.scroller.scrollTop = iScrollTop
  
                  // Store positional information so positional calculations can be based
                  // upon the current table draw position
                  this.s.baseScrollTop = iScrollTop
                  this.s.baseRowTop = this.s.topRowFloat
  
                  // Position the table in the virtual scroller
                  var tableTop =
                      iScrollTop -
                      (this.s.topRowFloat - displayStart) * heights.row
                  if (displayStart === 0) {
                      tableTop = 0
                  } else if (displayStart + displayLen >= displayEnd) {
                      tableTop = heights.scroll - iTableHeight
                  }
  
                  this.dom.table.style.top = tableTop + 'px'
  
                  /* Cache some information for the scroller */
                  this.s.tableTop = tableTop
                  this.s.tableBottom = iTableHeight + this.s.tableTop
  
                  // Calculate the boundaries for where a redraw will be triggered by the
                  // scroll event listener
                  var boundaryPx =
                      (iScrollTop - this.s.tableTop) * this.s.boundaryScale
                  this.s.redrawTop = iScrollTop - boundaryPx
                  this.s.redrawBottom = iScrollTop + boundaryPx
  
                  this.s.skip = false
  
                  // Restore the scrolling position that was saved by DataTable's state
                  // saving Note that this is done on the second draw when data is Ajax
                  // sourced, and the first draw when DOM soured
                  if (
                      this.s.dt.oFeatures.bStateSave &&
                      this.s.dt.oLoadedState !== null &&
                      typeof this.s.dt.oLoadedState.iScroller != 'undefined'
                  ) {
                      // A quirk of DataTables is that the draw callback will occur on an
                      // empty set if Ajax sourced, but not if server-side processing.
                      var ajaxSourced =
                          (this.s.dt.sAjaxSource || that.s.dt.ajax) &&
                          !this.s.dt.oFeatures.bServerSide
                              ? true
                              : false
  
                      if (
                          (ajaxSourced && this.s.dt.iDraw == 2) ||
                          (!ajaxSourced && this.s.dt.iDraw == 1)
                      ) {
                          setTimeout(function() {
                              $(that.dom.scroller).scrollTop(
                                  that.s.dt.oLoadedState.iScroller,
                              )
                              that.s.redrawTop =
                                  that.s.dt.oLoadedState.iScroller -
                                  heights.viewport / 2
  
                              // In order to prevent layout thrashing we need another
                              // small delay
                              setTimeout(function() {
                                  that.s.ingnoreScroll = false
                              }, 0)
                          }, 0)
                      }
                  } else {
                      that.s.ingnoreScroll = false
                  }
  
                  // Because of the order of the DT callbacks, the info update will
                  // take precedence over the one we want here. So a 'thread' break is
                  // needed
                  setTimeout(function() {
                      that._fnInfo.call(that)
                  }, 0)
  
                  // Hide the loading indicator
                  if (this.dom.loader && this.s.loaderVisible) {
                      this.dom.loader.css('display', 'none')
                      this.s.loaderVisible = false
                  }
              },
  
              /**
               * Force the scrolling container to have height beyond that of just the
               * table that has been drawn so the user can scroll the whole data set.
               *
               * Note that if the calculated required scrolling height exceeds a maximum
               * value (1 million pixels - hard-coded) the forcing element will be set
               * only to that maximum value and virtual / physical domain transforms will
               * be used to allow Scroller to display tables of any number of records.
               *  @returns {void}
               *  @private
               */
              _fnScrollForce: function() {
                  var heights = this.s.heights
                  var max = 1000000
  
                  heights.virtual = heights.row * this.s.dt.fnRecordsDisplay()
                  heights.scroll = heights.virtual
  
                  if (heights.scroll > max) {
                      heights.scroll = max
                  }
  
                  this.dom.force.style.height = heights.scroll + 'px'
              },
  
              /**
               * Automatic calculation of table row height. This is just a little tricky here as using
               * initialisation DataTables has tale the table out of the document, so we need to create
               * a new table and insert it into the document, calculate the row height and then whip the
               * table out.
               *  @returns {void}
               *  @private
               */
              _fnCalcRowHeight: function() {
                  var dt = this.s.dt
                  var origTable = dt.nTable
                  var nTable = origTable.cloneNode(false)
                  var tbody = $('<tbody/>').appendTo(nTable)
                  var container = $(
                      '<div class="' +
                          dt.oClasses.sWrapper +
                          ' DTS">' +
                          '<div class="' +
                          dt.oClasses.sScrollWrapper +
                          '">' +
                          '<div class="' +
                          dt.oClasses.sScrollBody +
                          '"></div>' +
                          '</div>' +
                          '</div>',
                  )
  
                  // Want 3 rows in the sizing table so :first-child and :last-child
                  // CSS styles don't come into play - take the size of the middle row
                  $('tbody tr:lt(4)', origTable)
                      .clone()
                      .appendTo(tbody)
                  while ($('tr', tbody).length < 3) {
                      tbody.append('<tr><td>&nbsp;</td></tr>')
                  }
  
                  $('div.' + dt.oClasses.sScrollBody, container).append(nTable)
  
                  var appendTo
                  if (dt._bInitComplete) {
                      appendTo = origTable.parentNode
                  } else {
                      if (!this.s.dt.nHolding) {
                          this.s.dt.nHolding = $('<div></div>').insertBefore(
                              this.s.dt.nTable,
                          )
                      }
                      appendTo = this.s.dt.nHolding
                  }
  
                  container.appendTo(appendTo)
                  this.s.heights.row = $('tr', tbody)
                      .eq(1)
                      .outerHeight()
                  container.remove()
              },
  
              /**
               * Update any information elements that are controlled by the DataTable based on the scrolling
               * viewport and what rows are visible in it. This function basically acts in the same way as
               * _fnUpdateInfo in DataTables, and effectively replaces that function.
               *  @returns {void}
               *  @private
               */
              _fnInfo: function() {
                  if (!this.s.dt.oFeatures.bInfo) {
                      return
                  }
  
                  var dt = this.s.dt,
                      language = dt.oLanguage,
                      iScrollTop = this.dom.scroller.scrollTop,
                      iStart = Math.floor(
                          this.fnPixelsToRow(iScrollTop, false, this.s.ani) + 1,
                      ),
                      iMax = dt.fnRecordsTotal(),
                      iTotal = dt.fnRecordsDisplay(),
                      iPossibleEnd = Math.ceil(
                          this.fnPixelsToRow(
                              iScrollTop + this.s.heights.viewport,
                              false,
                              this.s.ani,
                          ),
                      ),
                      iEnd = iTotal < iPossibleEnd ? iTotal : iPossibleEnd,
                      sStart = dt.fnFormatNumber(iStart),
                      sEnd = dt.fnFormatNumber(iEnd),
                      sMax = dt.fnFormatNumber(iMax),
                      sTotal = dt.fnFormatNumber(iTotal),
                      sOut
  
                  if (
                      dt.fnRecordsDisplay() === 0 &&
                      dt.fnRecordsDisplay() == dt.fnRecordsTotal()
                  ) {
                      /* Empty record set */
                      sOut = language.sInfoEmpty + language.sInfoPostFix
                  } else if (dt.fnRecordsDisplay() === 0) {
                      /* Empty record set after filtering */
                      sOut =
                          language.sInfoEmpty +
                          ' ' +
                          language.sInfoFiltered.replace('_MAX_', sMax) +
                          language.sInfoPostFix
                  } else if (dt.fnRecordsDisplay() == dt.fnRecordsTotal()) {
                      /* Normal record set */
                      sOut =
                          language.sInfo
                              .replace('_START_', sStart)
                              .replace('_END_', sEnd)
                              .replace('_MAX_', sMax)
                              .replace('_TOTAL_', sTotal) + language.sInfoPostFix
                  } else {
                      /* Record set after filtering */
                      sOut =
                          language.sInfo
                              .replace('_START_', sStart)
                              .replace('_END_', sEnd)
                              .replace('_MAX_', sMax)
                              .replace('_TOTAL_', sTotal) +
                          ' ' +
                          language.sInfoFiltered.replace(
                              '_MAX_',
                              dt.fnFormatNumber(dt.fnRecordsTotal()),
                          ) +
                          language.sInfoPostFix
                  }
  
                  var callback = language.fnInfoCallback
                  if (callback) {
                      sOut = callback.call(
                          dt.oInstance,
                          dt,
                          iStart,
                          iEnd,
                          iMax,
                          iTotal,
                          sOut,
                      )
                  }
  
                  var n = dt.aanFeatures.i
                  if (typeof n != 'undefined') {
                      for (var i = 0, iLen = n.length; i < iLen; i++) {
                          $(n[i]).html(sOut)
                      }
                  }
              },
          }
  
          /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
           * Statics
           * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
          /**
           * Scroller default settings for initialisation
           *  @namespace
           *  @name Scroller.defaults
           *  @static
           */
          Scroller.defaults = /** @lends Scroller.defaults */ {
              /**
               * Indicate if Scroller show show trace information on the console or not. This can be
               * useful when debugging Scroller or if just curious as to what it is doing, but should
               * be turned off for production.
               *  @type     bool
               *  @default  false
               *  @static
               *  @example
               *    var oTable = $('#example').dataTable( {
               *        "sScrollY": "200px",
               *        "sDom": "frtiS",
               *        "bDeferRender": true,
               *        "oScroller": {
               *          "trace": true
               *        }
               *    } );
               */
              trace: false,
  
              /**
               * Scroller will attempt to automatically calculate the height of rows for it's internal
               * calculations. However the height that is used can be overridden using this parameter.
               *  @type     int|string
               *  @default  auto
               *  @static
               *  @example
               *    var oTable = $('#example').dataTable( {
               *        "sScrollY": "200px",
               *        "sDom": "frtiS",
               *        "bDeferRender": true,
               *        "oScroller": {
               *          "rowHeight": 30
               *        }
               *    } );
               */
              rowHeight: 'auto',
  
              /**
               * When using server-side processing, Scroller will wait a small amount of time to allow
               * the scrolling to finish before requesting more data from the server. This prevents
               * you from DoSing your own server! The wait time can be configured by this parameter.
               *  @type     int
               *  @default  200
               *  @static
               *  @example
               *    var oTable = $('#example').dataTable( {
               *        "sScrollY": "200px",
               *        "sDom": "frtiS",
               *        "bDeferRender": true,
               *        "oScroller": {
               *          "serverWait": 100
               *        }
               *    } );
               */
              serverWait: 200,
  
              /**
               * The display buffer is what Scroller uses to calculate how many rows it should pre-fetch
               * for scrolling. Scroller automatically adjusts DataTables' display length to pre-fetch
               * rows that will be shown in "near scrolling" (i.e. just beyond the current display area).
               * The value is based upon the number of rows that can be displayed in the viewport (i.e.
               * a value of 1), and will apply the display range to records before before and after the
               * current viewport - i.e. a factor of 3 will allow Scroller to pre-fetch 1 viewport's worth
               * of rows before the current viewport, the current viewport's rows and 1 viewport's worth
               * of rows after the current viewport. Adjusting this value can be useful for ensuring
               * smooth scrolling based on your data set.
               *  @type     int
               *  @default  7
               *  @static
               *  @example
               *    var oTable = $('#example').dataTable( {
               *        "sScrollY": "200px",
               *        "sDom": "frtiS",
               *        "bDeferRender": true,
               *        "oScroller": {
               *          "displayBuffer": 10
               *        }
               *    } );
               */
              displayBuffer: 9,
  
              /**
               * Scroller uses the boundary scaling factor to decide when to redraw the table - which it
               * typically does before you reach the end of the currently loaded data set (in order to
               * allow the data to look continuous to a user scrolling through the data). If given as 0
               * then the table will be redrawn whenever the viewport is scrolled, while 1 would not
               * redraw the table until the currently loaded data has all been shown. You will want
               * something in the middle - the default factor of 0.5 is usually suitable.
               *  @type     float
               *  @default  0.5
               *  @static
               *  @example
               *    var oTable = $('#example').dataTable( {
               *        "sScrollY": "200px",
               *        "sDom": "frtiS",
               *        "bDeferRender": true,
               *        "oScroller": {
               *          "boundaryScale": 0.75
               *        }
               *    } );
               */
              boundaryScale: 0.5,
  
              /**
               * Show (or not) the loading element in the background of the table. Note that you should
               * include the dataTables.scroller.css file for this to be displayed correctly.
               *  @type     boolean
               *  @default  false
               *  @static
               *  @example
               *    var oTable = $('#example').dataTable( {
               *        "sScrollY": "200px",
               *        "sDom": "frtiS",
               *        "bDeferRender": true,
               *        "oScroller": {
               *          "loadingIndicator": true
               *        }
               *    } );
               */
              loadingIndicator: false,
          }
  
          Scroller.oDefaults = Scroller.defaults
  
          /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
           * Constants
           * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
          /**
           * Scroller version
           *  @type      String
           *  @default   See code
           *  @name      Scroller.version
           *  @static
           */
          Scroller.version = '1.2.2'
  
          /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
           * Initialisation
           * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
          /*
           * Register a new feature with DataTables
           */
          if (
              typeof $.fn.dataTable == 'function' &&
              typeof $.fn.dataTableExt.fnVersionCheck == 'function' &&
              $.fn.dataTableExt.fnVersionCheck('1.9.0')
          ) {
              $.fn.dataTableExt.aoFeatures.push({
                  fnInit: function(oDTSettings) {
                      var init = oDTSettings.oInit
                      var opts = init.scroller || init.oScroller || {}
                      var oScroller = new Scroller(oDTSettings, opts)
                      return oScroller.dom.wrapper
                  },
                  cFeature: 'S',
                  sFeature: 'Scroller',
              })
          } else {
              alert(
                  'Warning: Scroller requires DataTables 1.9.0 or greater - www.datatables.net/download',
              )
          }
  
          // Attach Scroller to DataTables so it can be accessed as an 'extra'
          $.fn.dataTable.Scroller = Scroller
          $.fn.DataTable.Scroller = Scroller
  
          // DataTables 1.10 API method aliases
          if ($.fn.dataTable.Api) {
              var Api = $.fn.dataTable.Api
  
              Api.register('scroller()', function() {
                  return this
              })
  
              Api.register('scroller().rowToPixels()', function(
                  rowIdx,
                  intParse,
                  virtual,
              ) {
                  var ctx = this.context
  
                  if (ctx.length && ctx[0].oScroller) {
                      return ctx[0].oScroller.fnRowToPixels(
                          rowIdx,
                          intParse,
                          virtual,
                      )
                  }
                  // undefined
              })
  
              Api.register('scroller().pixelsToRow()', function(
                  pixels,
                  intParse,
                  virtual,
              ) {
                  var ctx = this.context
  
                  if (ctx.length && ctx[0].oScroller) {
                      return ctx[0].oScroller.fnPixelsToRow(
                          pixels,
                          intParse,
                          virtual,
                      )
                  }
                  // undefined
              })
  
              Api.register('scroller().scrollToRow()', function(row, ani) {
                  this.iterator('table', function(ctx) {
                      if (ctx.oScroller) {
                          ctx.oScroller.fnScrollToRow(row, ani)
                      }
                  })
  
                  return this
              })
  
              Api.register('scroller().measure()', function(redraw) {
                  this.iterator('table', function(ctx) {
                      if (ctx.oScroller) {
                          ctx.oScroller.fnMeasure(redraw)
                      }
                  })
  
                  return this
              })
          }
  
          return Scroller
      } // /factory
  
      // Define as an AMD module if possible
      if (typeof define === 'function' && define.amd) {
          define(['jquery', 'datatables'], factory)
      } else if (typeof exports === 'object') {
          // Node/CommonJS
          factory(require('jquery'), require('datatables'))
      } else if (jQuery && !jQuery.fn.dataTable.Scroller) {
          // Otherwise simply initialise as normal, stopping multiple evaluation
          factory(jQuery, jQuery.fn.dataTable)
      }
  })(window, document)
  