text: (function() {
  
      /**
       * Config
       */
      var moduleName = 'angularUtils.directives.dirPagination';
      var DEFAULT_ID = '__default';
  
      /**
       * Module
       */
      angular.module(moduleName, [])
          .directive('dirPaginate', ['$timeout', '$compile', '$parse', 'paginationService', dirPaginateDirective])
          .directive('dirPaginateNoCompile', noCompileDirective)
          .directive('dirPaginationControls', ['paginationService', 'paginationTemplate', dirPaginationControlsDirective])
          .filter('itemsPerPage', ['paginationService', itemsPerPageFilter])
          .service('paginationService', paginationService)
          .provider('paginationTemplate', paginationTemplateProvider)
          .run(['$templateCache', dirPaginationControlsTemplateInstaller]);
  
      function dirPaginateDirective($timeout, $compile, $parse, paginationService) {
  
          return {
              terminal: true,
              multiElement: true,
              priority: 100,
              compile: dirPaginationCompileFn
          };
  
          function dirPaginationCompileFn(tElement, tAttrs) {
  
              var expression = tAttrs.dirPaginate;
              var match = expression.match(/^\s*([\s\S]+?)\s+in\s+([\s\S]+?)(?:\s+as\s+([\s\S]+?))?(?:\s+track\s+by\s+([\s\S]+?))?\s*$/);
  
              var filterPattern = /\|\s*itemsPerPage\s*:\s*(.*\(\s*\w*\)|([^\)]*?(?=\s+as\s+))|[^\)]*)/;
              if (match[2].match(filterPattern) === null) {
                  throw 'pagination directive: the \'itemsPerPage\' filter must be set.';
              }
              var itemsPerPageFilterRemoved = match[2].replace(filterPattern, '');
              var collectionGetter = $parse(itemsPerPageFilterRemoved);
  
              addNoCompileAttributes(tElement);
  
              var rawId = tAttrs.paginationId || DEFAULT_ID;
              paginationService.registerInstance(rawId);
  
              return function dirPaginationLinkFn(scope, element, attrs) {
  
                  scope.TickboxArray = {}
  
                  scope.toggleTickbox = function(tickboxId) {
                      if (scope.TickboxArray[tickboxId] == null || scope.TickboxArray[tickboxId] == false) {
                          scope.TickboxArray[tickboxId] = true;
                      } else {
                          scope.TickboxArray[tickboxId] = false;
                      }
                  }
                  var paginationId = $parse(attrs.paginationId)(scope) || attrs.paginationId || DEFAULT_ID;
  
                  paginationService.registerInstance(paginationId);
  
                  var repeatExpression = getRepeatExpression(expression, paginationId);
                  addNgRepeatToElement(element, attrs, repeatExpression);
  
                  removeTemporaryAttributes(element);
                  var compiled = $compile(element);
  
                  var currentPageGetter = makeCurrentPageGetterFn(scope, attrs, paginationId);
                  paginationService.setCurrentPageParser(paginationId, currentPageGetter, scope);
  
  
                  if (typeof attrs.totalItems !== 'undefined') {
                      paginationService.setAsyncModeTrue(paginationId);
                      scope.$watch(function() {
                          return $parse(attrs.totalItems)(scope);
                      }, function(result) {
                          if (0 <= result) {
                              paginationService.setCollectionLength(paginationId, result);
                          }
                      });
                  } else {
                      paginationService.setAsyncModeFalse(paginationId);
                      scope.$watchCollection(function() {
                          return collectionGetter(scope);
                      }, function(collection) {
                          if (collection) {
                              var collectionLength = (collection instanceof Array) ? collection.length : Object.keys(collection).length;
                              paginationService.setCollectionLength(paginationId, collectionLength);
                          }
                      });
                  }
  
                  scope.$on("toggleAllBoxesEvent", function(event, args) {
                      toggleAllBoxes();
                  });
  
                  function toggleAllBoxes() {
  
                      var itemsPerPage = paginationService.getItemsPerPage(paginationId);
                      var currentPage = paginationService.getCurrentPage(paginationId);
                      var collection = collectionGetter(scope);
  
                      function cauculateOffset(itemsPerPage, currentPage) {
                          return (currentPage - 1) * itemsPerPage + 1;
                      };
  
                      function getEntryIdListFromCollection(collection, itemsPerPage, offset) {
  
                          var itemsToSelect = [];
                          angular.forEach(collection, function(item, index) {
                              console.log(offset);
                              if ( index+1 >= offset ) {
                                  itemsToSelect.push(item.id);
                              }
                          });
                          return itemsToSelect;
                      }
  
                      function selectEntries(entriesToSelect) {
                          angular.forEach ( entriesToSelect , function (entry, index) {
  
                              $timeout(function() {
                                    scope.TickboxArray[entry] = true;
                              }, 0);
                          });
                      }
  
                      var collectionOffset = cauculateOffset(itemsPerPage, currentPage);
                      console.log(collectionOffset);
                      var entriesToSelect = getEntryIdListFromCollection(collection, itemsPerPage, collectionOffset);
  
                      selectEntries(entriesToSelect);
  
  
  
                      if (Object.keys(scope.TickboxArray).length > 0) {
                          angular.forEach(scope.TickboxArray, function(value, iterator) {
                              delete scope.TickboxArray[iterator];
                          });
                      }
  
                  }
  
  
                  compiled(scope);
              };
          }
  
          function getRepeatExpression(expression, paginationId) {
              var repeatExpression,
                  idDefinedInFilter = !!expression.match(/(\|\s*itemsPerPage\s*:[^|]*:[^|]*)/);
  
              if (paginationId !== DEFAULT_ID && !idDefinedInFilter) {
                  repeatExpression = expression.replace(/(\|\s*itemsPerPage\s*:\s*[^|\s]*)/, "$1 : '" + paginationId + "'");
              } else {
                  repeatExpression = expression;
              }
  
              return repeatExpression;
          }
  
          function addNgRepeatToElement(element, attrs, repeatExpression) {
              if (element[0].hasAttribute('dir-paginate-start') || element[0].hasAttribute('data-dir-paginate-start')) {
                  // using multiElement mode (dir-paginate-start, dir-paginate-end)
                  attrs.$set('ngRepeatStart', repeatExpression);
                  element.eq(element.length - 1).attr('ng-repeat-end', true);
              } else {
                  attrs.$set('ngRepeat', repeatExpression);
              }
          }
  
          function addNoCompileAttributes(tElement) {
              angular.forEach(tElement, function(el) {
                  if (el.nodeType === 1) {
                      angular.element(el).attr('dir-paginate-no-compile', true);
                  }
              });
          }
  
          function removeTemporaryAttributes(element) {
              angular.forEach(element, function(el) {
                  if (el.nodeType === 1) {
                      angular.element(el).removeAttr('dir-paginate-no-compile');
                  }
              });
              element.eq(0).removeAttr('dir-paginate-start').removeAttr('dir-paginate').removeAttr('data-dir-paginate-start').removeAttr('data-dir-paginate');
              element.eq(element.length - 1).removeAttr('dir-paginate-end').removeAttr('data-dir-paginate-end');
          }
  
          function makeCurrentPageGetterFn(scope, attrs, paginationId) {
              var currentPageGetter;
              if (attrs.currentPage) {
                  currentPageGetter = $parse(attrs.currentPage);
              } else {
                  var defaultCurrentPage = (paginationId + '__currentPage').replace(/\W/g, '_');
                  scope[defaultCurrentPage] = 1;
                  currentPageGetter = $parse(defaultCurrentPage);
              }
              return currentPageGetter;
          }
      }
  
      function noCompileDirective() {
          return {
              priority: 5000,
              terminal: true
          };
      }
  
      function dirPaginationControlsTemplateInstaller($templateCache) {
          $templateCache.put('angularUtils.directives.dirPagination.template', '<ul class="pagination" ng-if="1 < pages.length || !autoHide"><li ng-if="boundaryLinks" ng-class="{ disabled : pagination.current == 1 }"><a href="" ng-click="setCurrent(1)">&laquo;</a></li><li ng-if="directionLinks" ng-class="{ disabled : pagination.current == 1 }"><a href="" ng-click="setCurrent(pagination.current - 1)">&lsaquo;</a></li><li ng-repeat="pageNumber in pages track by tracker(pageNumber, $index)" ng-class="{ active : pagination.current == pageNumber, disabled : pageNumber == \'...\' || ( ! autoHide && pages.length === 1 ) }"><a href="" ng-click="setCurrent(pageNumber)">{{ pageNumber }}</a></li><li ng-if="directionLinks" ng-class="{ disabled : pagination.current == pagination.last }"><a href="" ng-click="setCurrent(pagination.current + 1)">&rsaquo;</a></li><li ng-if="boundaryLinks"  ng-class="{ disabled : pagination.current == pagination.last }"><a href="" ng-click="setCurrent(pagination.last)">&raquo;</a></li></ul>');
      }
  
      function dirPaginationControlsDirective(paginationService, paginationTemplate) {
  
          var numberRegex = /^\d+$/;
  
          var DDO = {
              restrict: 'AE',
              scope: {
                  maxSize: '=?',
                  onPageChange: '&?',
                  paginationId: '=?',
                  autoHide: '=?'
              },
              link: dirPaginationControlsLinkFn
          };
  
          var templateString = paginationTemplate.getString();
          if (templateString !== undefined) {
              DDO.template = templateString;
          } else {
              DDO.templateUrl = function(elem, attrs) {
                  return attrs.templateUrl || paginationTemplate.getPath();
              };
          }
          return DDO;
  
          function dirPaginationControlsLinkFn(scope, element, attrs) {
  
              var rawId = attrs.paginationId || DEFAULT_ID;
              var paginationId = scope.paginationId || attrs.paginationId || DEFAULT_ID;
  
              if (!paginationService.isRegistered(paginationId) && !paginationService.isRegistered(rawId)) {
                  var idMessage = (paginationId !== DEFAULT_ID) ? ' (id: ' + paginationId + ') ' : ' ';
                  if (window.console) {
                      console.warn('Pagination directive: the pagination controls' + idMessage + 'cannot be used without the corresponding pagination directive, which was not found at link time.');
                  }
              }
  
              if (!scope.maxSize) {
                  scope.maxSize = 9;
              }
              scope.autoHide = scope.autoHide === undefined ? true : scope.autoHide;
              scope.directionLinks = angular.isDefined(attrs.directionLinks) ? scope.$parent.$eval(attrs.directionLinks) : true;
              scope.boundaryLinks = angular.isDefined(attrs.boundaryLinks) ? scope.$parent.$eval(attrs.boundaryLinks) : false;
  
              var paginationRange = Math.max(scope.maxSize, 5);
              scope.pages = [];
              scope.pagination = {
                  last: 1,
                  current: 1
              };
              scope.range = {
                  lower: 1,
                  upper: 1,
                  total: 1
              };
  
              scope.$watch('maxSize', function(val) {
                  if (val) {
                      paginationRange = Math.max(scope.maxSize, 5);
                      generatePagination();
                  }
              });
  
              scope.$watch(function() {
                  if (paginationService.isRegistered(paginationId)) {
                      return (paginationService.getCollectionLength(paginationId) + 1) * paginationService.getItemsPerPage(paginationId);
                  }
              }, function(length) {
                  if (0 < length) {
                      generatePagination();
                  }
              });
  
              scope.$watch(function() {
                  if (paginationService.isRegistered(paginationId)) {
                      return (paginationService.getItemsPerPage(paginationId));
                  }
              }, function(current, previous) {
                  if (current != previous && typeof previous !== 'undefined') {
                      goToPage(scope.pagination.current);
                  }
              });
  
              scope.$watch(function() {
                  if (paginationService.isRegistered(paginationId)) {
                      return paginationService.getCurrentPage(paginationId);
                  }
              }, function(currentPage, previousPage) {
                  if (currentPage != previousPage) {
                      goToPage(currentPage);
                  }
              });
  
              scope.setCurrent = function(num) {
                  if (paginationService.isRegistered(paginationId) && isValidPageNumber(num)) {
                      num = parseInt(num, 10);
                      paginationService.setCurrentPage(paginationId, num);
                  }
              };
  
              scope.tracker = function(id, index) {
                  return id + '_' + index;
              };
  
              function goToPage(num) {
                  if (paginationService.isRegistered(paginationId) && isValidPageNumber(num)) {
                      var oldPageNumber = scope.pagination.current;
  
                      scope.pages = generatePagesArray(num, paginationService.getCollectionLength(paginationId), paginationService.getItemsPerPage(paginationId), paginationRange);
                      scope.pagination.current = num;
                      updateRangeValues();
  
                      if (scope.onPageChange) {
                          scope.onPageChange({
                              newPageNumber: num,
                              oldPageNumber: oldPageNumber
                          });
                      }
                  }
              }
  
              function generatePagination() {
                  if (paginationService.isRegistered(paginationId)) {
                      var page = parseInt(paginationService.getCurrentPage(paginationId)) || 1;
                      scope.pages = generatePagesArray(page, paginationService.getCollectionLength(paginationId), paginationService.getItemsPerPage(paginationId), paginationRange);
                      scope.pagination.current = page;
                      scope.pagination.last = scope.pages[scope.pages.length - 1];
                      if (scope.pagination.last < scope.pagination.current) {
                          scope.setCurrent(scope.pagination.last);
                      } else {
                          updateRangeValues();
                      }
                  }
              }
  
              function updateRangeValues() {
                  if (paginationService.isRegistered(paginationId)) {
                      var currentPage = paginationService.getCurrentPage(paginationId),
                          itemsPerPage = paginationService.getItemsPerPage(paginationId),
                          totalItems = paginationService.getCollectionLength(paginationId);
  
                      scope.range.lower = (currentPage - 1) * itemsPerPage + 1;
                      scope.range.upper = Math.min(currentPage * itemsPerPage, totalItems);
                      scope.range.total = totalItems;
                  }
              }
  
              function isValidPageNumber(num) {
                  return (numberRegex.test(num) && (0 < num && num <= scope.pagination.last));
              }
          }
  
          function generatePagesArray(currentPage, collectionLength, rowsPerPage, paginationRange) {
              var pages = [];
              var totalPages = Math.ceil(collectionLength / rowsPerPage);
              var halfWay = Math.ceil(paginationRange / 2);
              var position;
  
              if (currentPage <= halfWay) {
                  position = 'start';
              } else if (totalPages - halfWay < currentPage) {
                  position = 'end';
              } else {
                  position = 'middle';
              }
  
              var ellipsesNeeded = paginationRange < totalPages;
              var i = 1;
              while (i <= totalPages && i <= paginationRange) {
                  var pageNumber = calculatePageNumber(i, currentPage, paginationRange, totalPages);
  
                  var openingEllipsesNeeded = (i === 2 && (position === 'middle' || position === 'end'));
                  var closingEllipsesNeeded = (i === paginationRange - 1 && (position === 'middle' || position === 'start'));
                  if (ellipsesNeeded && (openingEllipsesNeeded || closingEllipsesNeeded)) {
                      pages.push('...');
                  } else {
                      pages.push(pageNumber);
                  }
                  i++;
              }
              return pages;
          }
  
          function calculatePageNumber(i, currentPage, paginationRange, totalPages) {
              var halfWay = Math.ceil(paginationRange / 2);
              if (i === paginationRange) {
                  return totalPages;
              } else if (i === 1) {
                  return i;
              } else if (paginationRange < totalPages) {
                  if (totalPages - halfWay < currentPage) {
                      return totalPages - paginationRange + i;
                  } else if (halfWay < currentPage) {
                      return currentPage - halfWay + i;
                  } else {
                      return i;
                  }
              } else {
                  return i;
              }
          }
      }
  
      function itemsPerPageFilter(paginationService) {
  
          return function(collection, itemsPerPage, paginationId) {
              if (typeof(paginationId) === 'undefined') {
                  paginationId = DEFAULT_ID;
              }
              if (!paginationService.isRegistered(paginationId)) {
                  throw 'pagination directive: the itemsPerPage id argument (id: ' + paginationId + ') does not match a registered pagination-id.';
              }
              var end;
              var start;
              if (angular.isObject(collection)) {
                  itemsPerPage = parseInt(itemsPerPage) || 9999999999;
                  if (paginationService.isAsyncMode(paginationId)) {
                      start = 0;
                  } else {
                      start = (paginationService.getCurrentPage(paginationId) - 1) * itemsPerPage;
                  }
                  end = start + itemsPerPage;
                  paginationService.setItemsPerPage(paginationId, itemsPerPage);
  
                  if (collection instanceof Array) {
                      return collection.slice(start, end);
                  } else {
                      var slicedObject = {};
                      angular.forEach(keys(collection).slice(start, end), function(key) {
                          slicedObject[key] = collection[key];
                      });
                      return slicedObject;
                  }
              } else {
                  return collection;
              }
          };
      }
  
      function keys(obj) {
          if (!Object.keys) {
              var objKeys = [];
              for (var i in obj) {
                  if (obj.hasOwnProperty(i)) {
                      objKeys.push(i);
                  }
              }
              return objKeys;
          } else {
              return Object.keys(obj);
          }
      }
  
      function paginationService() {
  
          var instances = {};
          var lastRegisteredInstance;
  
          this.registerInstance = function(instanceId) {
              if (typeof instances[instanceId] === 'undefined') {
                  instances[instanceId] = {
                      asyncMode: false
                  };
                  lastRegisteredInstance = instanceId;
              }
          };
  
          this.deregisterInstance = function(instanceId) {
              delete instances[instanceId];
          };
  
          this.isRegistered = function(instanceId) {
              return (typeof instances[instanceId] !== 'undefined');
          };
  
          this.getLastInstanceId = function() {
              return lastRegisteredInstance;
          };
  
          this.setCurrentPageParser = function(instanceId, val, scope) {
              instances[instanceId].currentPageParser = val;
              instances[instanceId].context = scope;
          };
          this.setCurrentPage = function(instanceId, val) {
              instances[instanceId].currentPageParser.assign(instances[instanceId].context, val);
          };
          this.getCurrentPage = function(instanceId) {
              var parser = instances[instanceId].currentPageParser;
              return parser ? parser(instances[instanceId].context) : 1;
          };
  
          this.setItemsPerPage = function(instanceId, val) {
              instances[instanceId].itemsPerPage = val;
          };
          this.getItemsPerPage = function(instanceId) {
              return instances[instanceId].itemsPerPage;
          };
  
          this.setCollectionLength = function(instanceId, val) {
              instances[instanceId].collectionLength = val;
          };
          this.getCollectionLength = function(instanceId) {
              return instances[instanceId].collectionLength;
          };
  
          this.setAsyncModeTrue = function(instanceId) {
              instances[instanceId].asyncMode = true;
          };
  
          this.setAsyncModeFalse = function(instanceId) {
              instances[instanceId].asyncMode = false;
          };
  
          this.isAsyncMode = function(instanceId) {
              return instances[instanceId].asyncMode;
          };
      }
  
      function paginationTemplateProvider() {
  
          var templatePath = 'angularUtils.directives.dirPagination.template';
          var templateString;
  
          this.setPath = function(path) {
              templatePath = path;
          };
  
          this.setString = function(str) {
              templateString = str;
          };
  
          this.$get = function() {
              return {
                  getPath: function() {
                      return templatePath;
                  },
                  getString: function() {
                      return templateString;
                  }
              };
          };
      }
  })();