/*! 
   * jQuery Steps v1.1.0 - 09/04/2014
   * Copyright (c) 2014 Rafael Staib (http://www.jquery-steps.com)
   * Licensed under MIT http://www.opensource.org/licenses/MIT
   */
  ;(function ($, undefined)
  {
  $.fn.extend({
      _aria: function (name, value)
      {
          return this.attr("aria-" + name, value);
      },
  
      _removeAria: function (name)
      {
          return this.removeAttr("aria-" + name);
      },
  
      _enableAria: function (enable)
      {
          return (enable == null || enable) ? 
              this.removeClass("disabled")._aria("disabled", "false") : 
              this.addClass("disabled")._aria("disabled", "true");
      },
  
      _showAria: function (show)
      {
          return (show == null || show) ? 
              this.show()._aria("hidden", "false") : 
              this.hide()._aria("hidden", "true");
      },
  
      _selectAria: function (select)
      {
          return (select == null || select) ? 
              this.addClass("current")._aria("selected", "true") : 
              this.removeClass("current")._aria("selected", "false");
      },
  
      _id: function (id)
      {
          return (id) ? this.attr("id", id) : this.attr("id");
      }
  });
  
  if (!String.prototype.format)
  {
      String.prototype.format = function()
      {
          var args = (arguments.length === 1 && $.isArray(arguments[0])) ? arguments[0] : arguments;
          var formattedString = this;
          for (var i = 0; i < args.length; i++)
          {
              var pattern = new RegExp("\\{" + i + "\\}", "gm");
              formattedString = formattedString.replace(pattern, args[i]);
          }
          return formattedString;
      };
  }
  
  /**
   * A global unique id count.
   *
   * @static
   * @private
   * @property _uniqueId
   * @type Integer
   **/
  var _uniqueId = 0;
  
  /**
   * The plugin prefix for cookies.
   *
   * @final
   * @private
   * @property _cookiePrefix
   * @type String
   **/
  var _cookiePrefix = "jQu3ry_5teps_St@te_";
  
  /**
   * Suffix for the unique tab id.
   *
   * @final
   * @private
   * @property _tabSuffix
   * @type String
   * @since 0.9.7
   **/
  var _tabSuffix = "-t-";
  
  /**
   * Suffix for the unique tabpanel id.
   *
   * @final
   * @private
   * @property _tabpanelSuffix
   * @type String
   * @since 0.9.7
   **/
  var _tabpanelSuffix = "-p-";
  
  /**
   * Suffix for the unique title id.
   *
   * @final
   * @private
   * @property _titleSuffix
   * @type String
   * @since 0.9.7
   **/
  var _titleSuffix = "-h-";
  
  /**
   * An error message for an "index out of range" error.
   *
   * @final
   * @private
   * @property _indexOutOfRangeErrorMessage
   * @type String
   **/
  var _indexOutOfRangeErrorMessage = "Index out of range.";
  
  /**
   * An error message for an "missing corresponding element" error.
   *
   * @final
   * @private
   * @property _missingCorrespondingElementErrorMessage
   * @type String
   **/
  var _missingCorrespondingElementErrorMessage = "One or more corresponding step {0} are missing.";
  
  /**
   * Adds a step to the cache.
   *
   * @static
   * @private
   * @method addStepToCache
   * @param wizard {Object} A jQuery wizard object
   * @param step {Object} The step object to add
   **/
  function addStepToCache(wizard, step)
  {
      getSteps(wizard).push(step);
  }
  
  function analyzeData(wizard, options, state)
  {
      var stepTitles = wizard.children(options.headerTag),
          stepContents = wizard.children(options.bodyTag);
  
      // Validate content
      if (stepTitles.length > stepContents.length)
      {
          throwError(_missingCorrespondingElementErrorMessage, "contents");
      }
      else if (stepTitles.length < stepContents.length)
      {
          throwError(_missingCorrespondingElementErrorMessage, "titles");
      }
          
      var startIndex = options.startIndex;
  
      state.stepCount = stepTitles.length;
  
      // Tries to load the saved state (step position)
      if (options.saveState && $.cookie)
      {
          var savedState = $.cookie(_cookiePrefix + getUniqueId(wizard));
          // Sets the saved position to the start index if not undefined or out of range 
          var savedIndex = parseInt(savedState, 0);
          if (!isNaN(savedIndex) && savedIndex < state.stepCount)
          {
              startIndex = savedIndex;
          }
      }
  
      state.currentIndex = startIndex;
  
      stepTitles.each(function (index)
      {
          var item = $(this), // item == header
              content = stepContents.eq(index),
              modeData = content.data("mode"),
              mode = (modeData == null) ? contentMode.html : getValidEnumValue(contentMode,
                  (/^\s*$/.test(modeData) || isNaN(modeData)) ? modeData : parseInt(modeData, 0)),
              contentUrl = (mode === contentMode.html || content.data("url") === undefined) ?
                  "" : content.data("url"),
              contentLoaded = (mode !== contentMode.html && content.data("loaded") === "1"),
              step = $.extend({}, stepModel, {
                  title: item.html(),
                  content: (mode === contentMode.html) ? content.html() : "",
                  contentUrl: contentUrl,
                  contentMode: mode,
                  contentLoaded: contentLoaded
              });
  
          addStepToCache(wizard, step);
      });
  }
  
  /**
   * Triggers the onCanceled event.
   *
   * @static
   * @private
   * @method cancel
   * @param wizard {Object} The jQuery wizard object
   **/
  function cancel(wizard)
  {
      wizard.triggerHandler("canceled");
  }
  
  function decreaseCurrentIndexBy(state, decreaseBy)
  {
      return state.currentIndex - decreaseBy;
  }
  
  /**
   * Removes the control functionality completely and transforms the current state to the initial HTML structure.
   *
   * @static
   * @private
   * @method destroy
   * @param wizard {Object} A jQuery wizard object
   **/
  function destroy(wizard, options)
  {
      var eventNamespace = getEventNamespace(wizard);
  
      // Remove virtual data objects from the wizard
      wizard.unbind(eventNamespace).removeData("uid").removeData("options")
          .removeData("state").removeData("steps").removeData("eventNamespace")
          .find(".actions a").unbind(eventNamespace);
  
      // Remove attributes and CSS classes from the wizard
      wizard.removeClass(options.clearFixCssClass + " vertical");
  
      var contents = wizard.find(".content > *");
  
      // Remove virtual data objects from panels and their titles
      contents.removeData("loaded").removeData("mode").removeData("url");
  
      // Remove attributes, CSS classes and reset inline styles on all panels and their titles
      contents.removeAttr("id").removeAttr("role").removeAttr("tabindex")
          .removeAttr("class").removeAttr("style")._removeAria("labelledby")
          ._removeAria("hidden");
  
      // Empty panels if the mode is set to 'async' or 'iframe'
      wizard.find(".content > [data-mode='async'],.content > [data-mode='iframe']").empty();
  
      var wizardSubstitute = $("<{0} class=\"{1}\"></{0}>".format(wizard.get(0).tagName, wizard.attr("class")));
  
      var wizardId = wizard._id();
      if (wizardId != null && wizardId !== "")
      {
          wizardSubstitute._id(wizardId);
      }
  
      wizardSubstitute.html(wizard.find(".content").html());
      wizard.after(wizardSubstitute);
      wizard.remove();
  
      return wizardSubstitute;
  }
  
  /**
   * Triggers the onFinishing and onFinished event.
   *
   * @static
   * @private
   * @method finishStep
   * @param wizard {Object} The jQuery wizard object
   * @param state {Object} The state container of the current wizard
   **/
  function finishStep(wizard, state)
  {
      var currentStep = wizard.find(".steps li").eq(state.currentIndex);
  
      if (wizard.triggerHandler("finishing", [state.currentIndex]))
      {
          currentStep.addClass("done").removeClass("error");
          wizard.triggerHandler("finished", [state.currentIndex]);
      }
      else
      {
          currentStep.addClass("error");
      }
  }
  
  /**
   * Gets or creates if not exist an unique event namespace for the given wizard instance.
   *
   * @static
   * @private
   * @method getEventNamespace
   * @param wizard {Object} A jQuery wizard object
   * @return {String} Returns the unique event namespace for the given wizard
   */
  function getEventNamespace(wizard)
  {
      var eventNamespace = wizard.data("eventNamespace");
  
      if (eventNamespace == null)
      {
          eventNamespace = "." + getUniqueId(wizard);
          wizard.data("eventNamespace", eventNamespace);
      }
  
      return eventNamespace;
  }
  
  function getStepAnchor(wizard, index)
  {
      var uniqueId = getUniqueId(wizard);
  
      return wizard.find("#" + uniqueId + _tabSuffix + index);
  }
  
  function getStepPanel(wizard, index)
  {
      var uniqueId = getUniqueId(wizard);
  
      return wizard.find("#" + uniqueId + _tabpanelSuffix + index);
  }
  
  function getStepTitle(wizard, index)
  {
      var uniqueId = getUniqueId(wizard);
  
      return wizard.find("#" + uniqueId + _titleSuffix + index);
  }
  
  function getOptions(wizard)
  {
      return wizard.data("options");
  }
  
  function getState(wizard)
  {
      return wizard.data("state");
  }
  
  function getSteps(wizard)
  {
      return wizard.data("steps");
  }
  
  /**
   * Gets a specific step object by index.
   *
   * @static
   * @private
   * @method getStep
   * @param index {Integer} An integer that belongs to the position of a step
   * @return {Object} A specific step object
   **/
  function getStep(wizard, index)
  {
      var steps = getSteps(wizard);
  
      if (index < 0 || index >= steps.length)
      {
          throwError(_indexOutOfRangeErrorMessage);
      }
  
      return steps[index];
  }
  
  /**
   * Gets or creates if not exist an unique id from the given wizard instance.
   *
   * @static
   * @private
   * @method getUniqueId
   * @param wizard {Object} A jQuery wizard object
   * @return {String} Returns the unique id for the given wizard
   */
  function getUniqueId(wizard)
  {
      var uniqueId = wizard.data("uid");
  
      if (uniqueId == null)
      {
          uniqueId = wizard._id();
          if (uniqueId == null)
          {
              uniqueId = "steps-uid-".concat(_uniqueId);
              wizard._id(uniqueId);
          }
  
          _uniqueId++;
          wizard.data("uid", uniqueId);
      }
  
      return uniqueId;
  }
  
  /**
   * Gets a valid enum value by checking a specific enum key or value.
   * 
   * @static
   * @private
   * @method getValidEnumValue
   * @param enumType {Object} Type of enum
   * @param keyOrValue {Object} Key as `String` or value as `Integer` to check for
   */
  function getValidEnumValue(enumType, keyOrValue)
  {
      validateArgument("enumType", enumType);
      validateArgument("keyOrValue", keyOrValue);
  
      // Is key
      if (typeof keyOrValue === "string")
      {
          var value = enumType[keyOrValue];
          if (value === undefined)
          {
              throwError("The enum key '{0}' does not exist.", keyOrValue);
          }
  
          return value;
      }
      // Is value
      else if (typeof keyOrValue === "number")
      {
          for (var key in enumType)
          {
              if (enumType[key] === keyOrValue)
              {
                  return keyOrValue;
              }
          }
  
          throwError("Invalid enum value '{0}'.", keyOrValue);
      }
      // Type is not supported
      else
      {
          throwError("Invalid key or value type.");
      }
  }
  
  /**
   * Routes to the next step.
   *
   * @static
   * @private
   * @method goToNextStep
   * @param wizard {Object} The jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   * @return {Boolean} Indicates whether the action executed
   **/
  function goToNextStep(wizard, options, state)
  {
      return paginationClick(wizard, options, state, increaseCurrentIndexBy(state, 1));
  }
  
  /**
   * Routes to the previous step.
   *
   * @static
   * @private
   * @method goToPreviousStep
   * @param wizard {Object} The jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   * @return {Boolean} Indicates whether the action executed
   **/
  function goToPreviousStep(wizard, options, state)
  {
      return paginationClick(wizard, options, state, decreaseCurrentIndexBy(state, 1));
  }
  
  /**
   * Routes to a specific step by a given index.
   *
   * @static
   * @private
   * @method goToStep
   * @param wizard {Object} The jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   * @param index {Integer} The position (zero-based) to route to
   * @return {Boolean} Indicates whether the action succeeded or failed
   **/
  function goToStep(wizard, options, state, index)
  {
      if (index < 0 || index >= state.stepCount)
      {
          throwError(_indexOutOfRangeErrorMessage);
      }
  
      if (options.forceMoveForward && index < state.currentIndex)
      {
          return;
      }
  
      var oldIndex = state.currentIndex;
      if (wizard.triggerHandler("stepChanging", [state.currentIndex, index]))
      {
          // Save new state
          state.currentIndex = index;
          saveCurrentStateToCookie(wizard, options, state);
  
          // Change visualisation
          refreshStepNavigation(wizard, options, state, oldIndex);
          refreshPagination(wizard, options, state);
          loadAsyncContent(wizard, options, state);
          startTransitionEffect(wizard, options, state, index, oldIndex, function()
          {
              wizard.triggerHandler("stepChanged", [index, oldIndex]);
          });
      }
      else
      {
          wizard.find(".steps li").eq(oldIndex).addClass("error");
      }
  
      return true;
  }
  
  function increaseCurrentIndexBy(state, increaseBy)
  {
      return state.currentIndex + increaseBy;
  }
  
  /**
   * Initializes the component.
   *
   * @static
   * @private
   * @method initialize
   * @param options {Object} The component settings
   **/
  function initialize(options)
  {
      /*jshint -W040 */
      var opts = $.extend(true, {}, defaults, options);
  
      return this.each(function ()
      {
          var wizard = $(this);
          var state = {
              currentIndex: opts.startIndex,
              currentStep: null,
              stepCount: 0,
              transitionElement: null
          };
  
          // Create data container
          wizard.data("options", opts);
          wizard.data("state", state);
          wizard.data("steps", []);
  
          analyzeData(wizard, opts, state);
          render(wizard, opts, state);
          registerEvents(wizard, opts);
  
          // Trigger focus
          if (opts.autoFocus && _uniqueId === 0)
          {
              getStepAnchor(wizard, opts.startIndex).focus();
          }
  
          wizard.triggerHandler("init", [opts.startIndex]);
      });
  }
  
  /**
   * Inserts a new step to a specific position.
   *
   * @static
   * @private
   * @method insertStep
   * @param wizard {Object} The jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   * @param index {Integer} The position (zero-based) to add
   * @param step {Object} The step object to add
   * @example
   *     $("#wizard").steps().insert(0, {
   *         title: "Title",
   *         content: "", // optional
   *         contentMode: "async", // optional
   *         contentUrl: "/Content/Step/1" // optional
   *     });
   * @chainable
   **/
  function insertStep(wizard, options, state, index, step)
  {
      if (index < 0 || index > state.stepCount)
      {
          throwError(_indexOutOfRangeErrorMessage);
      }
  
      // TODO: Validate step object
  
      // Change data
      step = $.extend({}, stepModel, step);
      insertStepToCache(wizard, index, step);
      if (state.currentIndex !== state.stepCount && state.currentIndex >= index)
      {
          state.currentIndex++;
          saveCurrentStateToCookie(wizard, options, state);
      }
      state.stepCount++;
  
      var contentContainer = wizard.find(".content"),
          header = $("<{0}>{1}</{0}>".format(options.headerTag, step.title)),
          body = $("<{0}></{0}>".format(options.bodyTag));
  
      if (step.contentMode == null || step.contentMode === contentMode.html)
      {
          body.html(step.content);
      }
  
      if (index === 0)
      {
          contentContainer.prepend(body).prepend(header);
      }
      else
      {
          getStepPanel(wizard, (index - 1)).after(body).after(header);
      }
  
      renderBody(wizard, state, body, index);
      renderTitle(wizard, options, state, header, index);
      refreshSteps(wizard, options, state, index);
      if (index === state.currentIndex)
      {
          refreshStepNavigation(wizard, options, state);
      }
      refreshPagination(wizard, options, state);
  
      return wizard;
  }
  
  /**
   * Inserts a step object to the cache at a specific position.
   *
   * @static
   * @private
   * @method insertStepToCache
   * @param wizard {Object} A jQuery wizard object
   * @param index {Integer} The position (zero-based) to add
   * @param step {Object} The step object to add
   **/
  function insertStepToCache(wizard, index, step)
  {
      getSteps(wizard).splice(index, 0, step);
  }
  
  /**
   * Handles the keyup DOM event for pagination.
   *
   * @static
   * @private
   * @event keyup
   * @param event {Object} An event object
   */
  function keyUpHandler(event)
  {
      var wizard = $(this),
          options = getOptions(wizard),
          state = getState(wizard);
  
      if (options.suppressPaginationOnFocus && wizard.find(":focus").is(":input"))
      {
          event.preventDefault();
          return false;
      }
  
      var keyCodes = { left: 37, right: 39 };
      if (event.keyCode === keyCodes.left)
      {
          event.preventDefault();
          goToPreviousStep(wizard, options, state);
      }
      else if (event.keyCode === keyCodes.right)
      {
          event.preventDefault();
          goToNextStep(wizard, options, state);
      }
  }
  
  /**
   * Loads and includes async content.
   *
   * @static
   * @private
   * @method loadAsyncContent
   * @param wizard {Object} A jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   */
  function loadAsyncContent(wizard, options, state)
  {
      if (state.stepCount > 0)
      {
          var currentIndex = state.currentIndex,
              currentStep = getStep(wizard, currentIndex);
  
          if (!options.enableContentCache || !currentStep.contentLoaded)
          {
              switch (getValidEnumValue(contentMode, currentStep.contentMode))
              {
                  case contentMode.iframe:
                      wizard.find(".content > .body").eq(state.currentIndex).empty()
                          .html("<iframe src=\"" + currentStep.contentUrl + "\" frameborder=\"0\" scrolling=\"no\" />")
                          .data("loaded", "1");
                      break;
  
                  case contentMode.async:
                      var currentStepContent = getStepPanel(wizard, currentIndex)._aria("busy", "true")
                          .empty().append(renderTemplate(options.loadingTemplate, { text: options.labels.loading }));
  
                      $.ajax({ url: currentStep.contentUrl, cache: false }).done(function (data)
                      {
                          currentStepContent.empty().html(data)._aria("busy", "false").data("loaded", "1");
                          wizard.triggerHandler("contentLoaded", [currentIndex]);
                      });
                      break;
              }
          }
      }
  }
  
  /**
   * Fires the action next or previous click event.
   *
   * @static
   * @private
   * @method paginationClick
   * @param wizard {Object} The jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   * @param index {Integer} The position (zero-based) to route to
   * @return {Boolean} Indicates whether the event fired successfully or not
   **/
  function paginationClick(wizard, options, state, index)
  {
      var oldIndex = state.currentIndex;
  
      if (index >= 0 && index < state.stepCount && !(options.forceMoveForward && index < state.currentIndex))
      {
          var anchor = getStepAnchor(wizard, index),
              parent = anchor.parent(),
              isDisabled = parent.hasClass("disabled");
  
          // Enable the step to make the anchor clickable!
          parent._enableAria();
          anchor.click();
  
          // An error occured
          if (oldIndex === state.currentIndex && isDisabled)
          {
              // Disable the step again if current index has not changed; prevents click action.
              parent._enableAria(false);
              return false;
          }
  
          return true;
      }
  
      return false;
  }
  
  /**
   * Fires when a pagination click happens.
   *
   * @static
   * @private
   * @event click
   * @param event {Object} An event object
   */
  function paginationClickHandler(event)
  {
      event.preventDefault();
  
      var anchor = $(this),
          wizard = anchor.parent().parent().parent().parent(),
          options = getOptions(wizard),
          state = getState(wizard),
          href = anchor.attr("href");
  
      switch (href.substring(href.lastIndexOf("#") + 1))
      {
          case "cancel":
              cancel(wizard);
              break;
  
          case "finish":
              finishStep(wizard, state);
              break;
  
          case "next":
              goToNextStep(wizard, options, state);
              break;
  
          case "previous":
              goToPreviousStep(wizard, options, state);
              break;
      }
  }
  
  /**
   * Refreshs the visualization state for the entire pagination.
   *
   * @static
   * @private
   * @method refreshPagination
   * @param wizard {Object} A jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   */
  function refreshPagination(wizard, options, state)
  {
      if (options.enablePagination)
      {
          var finish = wizard.find(".actions a[href$='#finish']").parent(),
              next = wizard.find(".actions a[href$='#next']").parent();
  
          if (!options.forceMoveForward)
          {
              var previous = wizard.find(".actions a[href$='#previous']").parent();
              previous._enableAria(state.currentIndex > 0);
          }
  
          if (options.enableFinishButton && options.showFinishButtonAlways)
          {
              finish._enableAria(state.stepCount > 0);
              next._enableAria(state.stepCount > 1 && state.stepCount > (state.currentIndex + 1));
          }
          else
          {
              finish._showAria(options.enableFinishButton && state.stepCount === (state.currentIndex + 1));
              next._showAria(state.stepCount === 0 || state.stepCount > (state.currentIndex + 1)).
                  _enableAria(state.stepCount > (state.currentIndex + 1) || !options.enableFinishButton);
          }
      }
  }
  
  /**
   * Refreshs the visualization state for the step navigation (tabs).
   *
   * @static
   * @private
   * @method refreshStepNavigation
   * @param wizard {Object} A jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   * @param [oldIndex] {Integer} The index of the prior step
   */
  function refreshStepNavigation(wizard, options, state, oldIndex)
  {
      var currentOrNewStepAnchor = getStepAnchor(wizard, state.currentIndex),
          currentInfo = $("<span class=\"current-info audible\">" + options.labels.current + " </span>"),
          stepTitles = wizard.find(".content > .title");
  
      if (oldIndex != null)
      {
          var oldStepAnchor = getStepAnchor(wizard, oldIndex);
          oldStepAnchor.parent().addClass("done").removeClass("error")._selectAria(false);
          stepTitles.eq(oldIndex).removeClass("current").next(".body").removeClass("current");
          currentInfo = oldStepAnchor.find(".current-info");
          currentOrNewStepAnchor.focus();
      }
  
      currentOrNewStepAnchor.prepend(currentInfo).parent()._selectAria().removeClass("done")._enableAria();
      stepTitles.eq(state.currentIndex).addClass("current").next(".body").addClass("current");
  }
  
  /**
   * Refreshes step buttons and their related titles beyond a certain position.
   *
   * @static
   * @private
   * @method refreshSteps
   * @param wizard {Object} A jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   * @param index {Integer} The start point for refreshing ids
   */
  function refreshSteps(wizard, options, state, index)
  {
      var uniqueId = getUniqueId(wizard);
  
      for (var i = index; i < state.stepCount; i++)
      {
          var uniqueStepId = uniqueId + _tabSuffix + i,
              uniqueBodyId = uniqueId + _tabpanelSuffix + i,
              uniqueHeaderId = uniqueId + _titleSuffix + i,
              title = wizard.find(".title").eq(i)._id(uniqueHeaderId);
  
          wizard.find(".steps a").eq(i)._id(uniqueStepId)
              ._aria("controls", uniqueBodyId).attr("href", "#" + uniqueHeaderId)
              .html(renderTemplate(options.titleTemplate, { index: i + 1, title: title.html() }));
          wizard.find(".body").eq(i)._id(uniqueBodyId)
              ._aria("labelledby", uniqueHeaderId);
      }
  }
  
  function registerEvents(wizard, options)
  {
      var eventNamespace = getEventNamespace(wizard);
  
      wizard.bind("canceled" + eventNamespace, options.onCanceled);
      wizard.bind("contentLoaded" + eventNamespace, options.onContentLoaded);
      wizard.bind("finishing" + eventNamespace, options.onFinishing);
      wizard.bind("finished" + eventNamespace, options.onFinished);
      wizard.bind("init" + eventNamespace, options.onInit);
      wizard.bind("stepChanging" + eventNamespace, options.onStepChanging);
      wizard.bind("stepChanged" + eventNamespace, options.onStepChanged);
  
      if (options.enableKeyNavigation)
      {
          wizard.bind("keyup" + eventNamespace, keyUpHandler);
      }
  
      wizard.find(".actions a").bind("click" + eventNamespace, paginationClickHandler);
  }
  
  /**
   * Removes a specific step by an given index.
   *
   * @static
   * @private
   * @method removeStep
   * @param wizard {Object} A jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   * @param index {Integer} The position (zero-based) of the step to remove
   * @return Indecates whether the item is removed.
   **/
  function removeStep(wizard, options, state, index)
  {
      // Index out of range and try deleting current item will return false.
      if (index < 0 || index >= state.stepCount || state.currentIndex === index)
      {
          return false;
      }
  
      // Change data
      removeStepFromCache(wizard, index);
      if (state.currentIndex > index)
      {
          state.currentIndex--;
          saveCurrentStateToCookie(wizard, options, state);
      }
      state.stepCount--;
  
      getStepTitle(wizard, index).remove();
      getStepPanel(wizard, index).remove();
      getStepAnchor(wizard, index).parent().remove();
  
      // Set the "first" class to the new first step button 
      if (index === 0)
      {
          wizard.find(".steps li").first().addClass("first");
      }
  
      // Set the "last" class to the new last step button 
      if (index === state.stepCount)
      {
          wizard.find(".steps li").eq(index).addClass("last");
      }
  
      refreshSteps(wizard, options, state, index);
      refreshPagination(wizard, options, state);
  
      return true;
  }
  
  function removeStepFromCache(wizard, index)
  {
      getSteps(wizard).splice(index, 1);
  }
  
  /**
   * Transforms the base html structure to a more sensible html structure.
   *
   * @static
   * @private
   * @method render
   * @param wizard {Object} A jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   **/
  function render(wizard, options, state)
  {
      // Create a content wrapper and copy HTML from the intial wizard structure
      var wrapperTemplate = "<{0} class=\"{1}\">{2}</{0}>",
          orientation = getValidEnumValue(stepsOrientation, options.stepsOrientation),
          verticalCssClass = (orientation === stepsOrientation.vertical) ? " vertical" : "",
          contentWrapper = $(wrapperTemplate.format(options.contentContainerTag, "content " + options.clearFixCssClass, wizard.html())),
          stepsWrapper = $(wrapperTemplate.format(options.stepsContainerTag, "steps " + options.clearFixCssClass, "<ul role=\"tablist\"></ul>")),
          stepTitles = contentWrapper.children(options.headerTag),
          stepContents = contentWrapper.children(options.bodyTag);
  
      // Transform the wizard wrapper and remove the inner HTML
      wizard.attr("role", "application").empty().append(stepsWrapper).append(contentWrapper)
          .addClass(options.cssClass + " " + options.clearFixCssClass + verticalCssClass);
  
      // Add WIA-ARIA support
      stepContents.each(function (index)
      {
          renderBody(wizard, state, $(this), index);
      });
  
      stepTitles.each(function (index)
      {
          renderTitle(wizard, options, state, $(this), index);
      });
  
      refreshStepNavigation(wizard, options, state);
      renderPagination(wizard, options, state);
  }
  
  /**
   * Transforms the body to a proper tabpanel.
   *
   * @static
   * @private
   * @method renderBody
   * @param wizard {Object} A jQuery wizard object
   * @param body {Object} A jQuery body object
   * @param index {Integer} The position of the body
   */
  function renderBody(wizard, state, body, index)
  {
      var uniqueId = getUniqueId(wizard),
          uniqueBodyId = uniqueId + _tabpanelSuffix + index,
          uniqueHeaderId = uniqueId + _titleSuffix + index;
  
      body._id(uniqueBodyId).attr("role", "tabpanel")._aria("labelledby", uniqueHeaderId)
          .addClass("body")._showAria(state.currentIndex === index);
  }
  
  /**
   * Renders a pagination if enabled.
   *
   * @static
   * @private
   * @method renderPagination
   * @param wizard {Object} A jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   */
  function renderPagination(wizard, options, state)
  {
      if (options.enablePagination)
      {
          var pagination = "<{0} class=\"actions {1}\"><ul role=\"menu\" aria-label=\"{2}\">{3}</ul></{0}>",
              buttonTemplate = "<li><a href=\"#{0}\" role=\"menuitem\">{1}</a></li>",
              buttons = "";
  
          if (!options.forceMoveForward)
          {
              buttons += buttonTemplate.format("previous", options.labels.previous);
          }
  
          buttons += buttonTemplate.format("next", options.labels.next);
  
          if (options.enableFinishButton)
          {
              buttons += buttonTemplate.format("finish", options.labels.finish);
          }
  
          if (options.enableCancelButton)
          {
              buttons += buttonTemplate.format("cancel", options.labels.cancel);
          }
  
          wizard.append(pagination.format(options.actionContainerTag, options.clearFixCssClass,
              options.labels.pagination, buttons));
  
          refreshPagination(wizard, options, state);
          loadAsyncContent(wizard, options, state);
      }
  }
  
  /**
   * Renders a template and replaces all placeholder.
   *
   * @static
   * @private
   * @method renderTemplate
   * @param template {String} A template
   * @param substitutes {Object} A list of substitute
   * @return {String} The rendered template
   */
  function renderTemplate(template, substitutes)
  {
      var matches = template.match(/#([a-z]*)#/gi);
  
      for (var i = 0; i < matches.length; i++)
      {
          var match = matches[i], 
              key = match.substring(1, match.length - 1);
  
          if (substitutes[key] === undefined)
          {
              throwError("The key '{0}' does not exist in the substitute collection!", key);
          }
  
          template = template.replace(match, substitutes[key]);
      }
  
      return template;
  }
  
  /**
   * Transforms the title to a step item button.
   *
   * @static
   * @private
   * @method renderTitle
   * @param wizard {Object} A jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   * @param header {Object} A jQuery header object
   * @param index {Integer} The position of the header
   */
  function renderTitle(wizard, options, state, header, index)
  {
      var uniqueId = getUniqueId(wizard),
          uniqueStepId = uniqueId + _tabSuffix + index,
          uniqueBodyId = uniqueId + _tabpanelSuffix + index,
          uniqueHeaderId = uniqueId + _titleSuffix + index,
          stepCollection = wizard.find(".steps > ul"),
          title = renderTemplate(options.titleTemplate, {
              index: index + 1,
              title: header.html()
          }),
          stepItem = $("<li role=\"tab\"><a id=\"" + uniqueStepId + "\" href=\"#" + uniqueHeaderId + 
              "\" aria-controls=\"" + uniqueBodyId + "\">" + title + "</a></li>");
          
      stepItem._enableAria(options.enableAllSteps || state.currentIndex > index);
  
      if (state.currentIndex > index)
      {
          stepItem.addClass("done");
      }
  
      header._id(uniqueHeaderId).attr("tabindex", "-1").addClass("title");
  
      if (index === 0)
      {
          stepCollection.prepend(stepItem);
      }
      else
      {
          stepCollection.find("li").eq(index - 1).after(stepItem);
      }
  
      // Set the "first" class to the new first step button
      if (index === 0)
      {
          stepCollection.find("li").removeClass("first").eq(index).addClass("first");
      }
  
      // Set the "last" class to the new last step button
      if (index === (state.stepCount - 1))
      {
          stepCollection.find("li").removeClass("last").eq(index).addClass("last");
      }
  
      // Register click event
      stepItem.children("a").bind("click" + getEventNamespace(wizard), stepClickHandler);
  }
  
  /**
   * Saves the current state to a cookie.
   *
   * @static
   * @private
   * @method saveCurrentStateToCookie
   * @param wizard {Object} A jQuery wizard object
   * @param options {Object} Settings of the current wizard
   * @param state {Object} The state container of the current wizard
   */
  function saveCurrentStateToCookie(wizard, options, state)
  {
      if (options.saveState && $.cookie)
      {
          $.cookie(_cookiePrefix + getUniqueId(wizard), state.currentIndex);
      }
  }
  
  function startTransitionEffect(wizard, options, state, index, oldIndex, doneCallback)
  {
      var stepContents = wizard.find(".content > .body"),
          effect = getValidEnumValue(transitionEffect, options.transitionEffect),
          effectSpeed = options.transitionEffectSpeed,
          newStep = stepContents.eq(index),
          currentStep = stepContents.eq(oldIndex);
  
      switch (effect)
      {
          case transitionEffect.fade:
          case transitionEffect.slide:
              var hide = (effect === transitionEffect.fade) ? "fadeOut" : "slideUp",
                  show = (effect === transitionEffect.fade) ? "fadeIn" : "slideDown";
  
              state.transitionElement = newStep;
              currentStep[hide](effectSpeed, function ()
              {
                  var wizard = $(this)._showAria(false).parent().parent(),
                      state = getState(wizard);
  
                  if (state.transitionElement)
                  {
                      state.transitionElement[show](effectSpeed, function ()
                      {
                          $(this)._showAria();
                      }).promise().done(doneCallback);
                      state.transitionElement = null;
                  }
              });
              break;
  
          case transitionEffect.slideLeft:
              var outerWidth = currentStep.outerWidth(true),
                  posFadeOut = (index > oldIndex) ? -(outerWidth) : outerWidth,
                  posFadeIn = (index > oldIndex) ? outerWidth : -(outerWidth);
  
              $.when(currentStep.animate({ left: posFadeOut }, effectSpeed, 
                      function () { $(this)._showAria(false); }),
                  newStep.css("left", posFadeIn + "px")._showAria()
                      .animate({ left: 0 }, effectSpeed)).done(doneCallback);
              break;
  
          default:
              $.when(currentStep._showAria(false), newStep._showAria())
                  .done(doneCallback);
              break;
      }
  }
  
  /**
   * Fires when a step click happens.
   *
   * @static
   * @private
   * @event click
   * @param event {Object} An event object
   */
  function stepClickHandler(event)
  {
      event.preventDefault();
  
      var anchor = $(this),
          wizard = anchor.parent().parent().parent().parent(),
          options = getOptions(wizard),
          state = getState(wizard),
          oldIndex = state.currentIndex;
  
      if (anchor.parent().is(":not(.disabled):not(.current)"))
      {
          var href = anchor.attr("href"),
              position = parseInt(href.substring(href.lastIndexOf("-") + 1), 0);
  
          goToStep(wizard, options, state, position);
      }
  
      // If nothing has changed
      if (oldIndex === state.currentIndex)
      {
          getStepAnchor(wizard, oldIndex).focus();
          return false;
      }
  }
  
  function throwError(message)
  {
      if (arguments.length > 1)
      {
          message = message.format(Array.prototype.slice.call(arguments, 1));
      }
  
      throw new Error(message);
  }
  
  /**
   * Checks an argument for null or undefined and throws an error if one check applies.
   *
   * @static
   * @private
   * @method validateArgument
   * @param argumentName {String} The name of the given argument
   * @param argumentValue {Object} The argument itself
   */
  function validateArgument(argumentName, argumentValue)
  {
      if (argumentValue == null)
      {
          throwError("The argument '{0}' is null or undefined.", argumentName);
      }
  }
  
  /**
   * Represents a jQuery wizard plugin.
   *
   * @class steps
   * @constructor
   * @param [method={}] The name of the method as `String` or an JSON object for initialization
   * @param [params=]* {Array} Additional arguments for a method call
   * @chainable
   **/
  $.fn.steps = function (method)
  {
      if ($.fn.steps[method])
      {
          return $.fn.steps[method].apply(this, Array.prototype.slice.call(arguments, 1));
      }
      else if (typeof method === "object" || !method)
      {
          return initialize.apply(this, arguments);
      }
      else
      {
          $.error("Method " + method + " does not exist on jQuery.steps");
      }
  };
  
  /**
   * Adds a new step.
   *
   * @method add
   * @param step {Object} The step object to add
   * @chainable
   **/
  $.fn.steps.add = function (step)
  {
      var state = getState(this);
      return insertStep(this, getOptions(this), state, state.stepCount, step);
  };
  
  /**
   * Removes the control functionality completely and transforms the current state to the initial HTML structure.
   *
   * @method destroy
   * @chainable
   **/
  $.fn.steps.destroy = function ()
  {
      return destroy(this, getOptions(this));
  };
  
  /**
   * Triggers the onFinishing and onFinished event.
   *
   * @method finish
   **/
  $.fn.steps.finish = function ()
  {
      finishStep(this, getState(this));
  };
  
  /**
   * Gets the current step index.
   *
   * @method getCurrentIndex
   * @return {Integer} The actual step index (zero-based)
   * @for steps
   **/
  $.fn.steps.getCurrentIndex = function ()
  {
      return getState(this).currentIndex;
  };
  
  /**
   * Gets the current step object.
   *
   * @method getCurrentStep
   * @return {Object} The actual step object
   **/
  $.fn.steps.getCurrentStep = function ()
  {
      return getStep(this, getState(this).currentIndex);
  };
  
  /**
   * Gets a specific step object by index.
   *
   * @method getStep
   * @param index {Integer} An integer that belongs to the position of a step
   * @return {Object} A specific step object
   **/
  $.fn.steps.getStep = function (index)
  {
      return getStep(this, index);
  };
  
  /**
   * Inserts a new step to a specific position.
   *
   * @method insert
   * @param index {Integer} The position (zero-based) to add
   * @param step {Object} The step object to add
   * @example
   *     $("#wizard").steps().insert(0, {
   *         title: "Title",
   *         content: "", // optional
   *         contentMode: "async", // optional
   *         contentUrl: "/Content/Step/1" // optional
   *     });
   * @chainable
   **/
  $.fn.steps.insert = function (index, step)
  {
      return insertStep(this, getOptions(this), getState(this), index, step);
  };
  
  /**
   * Routes to the next step.
   *
   * @method next
   * @return {Boolean} Indicates whether the action executed
   **/
  $.fn.steps.next = function ()
  {
      return goToNextStep(this, getOptions(this), getState(this));
  };
  
  /**
   * Routes to the previous step.
   *
   * @method previous
   * @return {Boolean} Indicates whether the action executed
   **/
  $.fn.steps.previous = function ()
  {
      return goToPreviousStep(this, getOptions(this), getState(this));
  };
  
  /**
   * Removes a specific step by an given index.
   *
   * @method remove
   * @param index {Integer} The position (zero-based) of the step to remove
   * @return Indecates whether the item is removed.
   **/
  $.fn.steps.remove = function (index)
  {
      return removeStep(this, getOptions(this), getState(this), index);
  };
  
  /**
   * Sets a specific step object by index.
   *
   * @method setStep
   * @param index {Integer} An integer that belongs to the position of a step
   * @param step {Object} The step object to change
   **/
  $.fn.steps.setStep = function (index, step)
  {
      throw new Error("Not yet implemented!");
  };
  
  /**
   * Skips an certain amount of steps.
   *
   * @method skip
   * @param count {Integer} The amount of steps that should be skipped
   * @return {Boolean} Indicates whether the action executed
   **/
  $.fn.steps.skip = function (count)
  {
      throw new Error("Not yet implemented!");
  };
  
  /**
   * An enum represents the different content types of a step and their loading mechanisms.
   *
   * @class contentMode
   * @for steps
   **/
  var contentMode = $.fn.steps.contentMode = {
      /**
       * HTML embedded content
       *
       * @readOnly
       * @property html
       * @type Integer
       * @for contentMode
       **/
      html: 0,
  
      /**
       * IFrame embedded content
       *
       * @readOnly
       * @property iframe
       * @type Integer
       * @for contentMode
       **/
      iframe: 1,
  
      /**
       * Async embedded content
       *
       * @readOnly
       * @property async
       * @type Integer
       * @for contentMode
       **/
      async: 2
  };
  
  /**
   * An enum represents the orientation of the steps navigation.
   *
   * @class stepsOrientation
   * @for steps
   **/
  var stepsOrientation = $.fn.steps.stepsOrientation = {
      /**
       * Horizontal orientation
       *
       * @readOnly
       * @property horizontal
       * @type Integer
       * @for stepsOrientation
       **/
      horizontal: 0,
  
      /**
       * Vertical orientation
       *
       * @readOnly
       * @property vertical
       * @type Integer
       * @for stepsOrientation
       **/
      vertical: 1
  };
  
  /**
   * An enum that represents the various transition animations.
   *
   * @class transitionEffect
   * @for steps
   **/
  var transitionEffect = $.fn.steps.transitionEffect = {
      /**
       * No transition animation
       *
       * @readOnly
       * @property none
       * @type Integer
       * @for transitionEffect
       **/
      none: 0,
  
      /**
       * Fade in transition
       *
       * @readOnly
       * @property fade
       * @type Integer
       * @for transitionEffect
       **/
      fade: 1,
  
      /**
       * Slide up transition
       *
       * @readOnly
       * @property slide
       * @type Integer
       * @for transitionEffect
       **/
      slide: 2,
  
      /**
       * Slide left transition
       *
       * @readOnly
       * @property slideLeft
       * @type Integer
       * @for transitionEffect
       **/
      slideLeft: 3
  };
  
  var stepModel = $.fn.steps.stepModel = {
      title: "",
      content: "",
      contentUrl: "",
      contentMode: contentMode.html,
      contentLoaded: false
  };
  
  /**
   * An object that represents the default settings.
   * There are two possibities to override the sub-properties.
   * Either by doing it generally (global) or on initialization.
   *
   * @static
   * @class defaults
   * @for steps
   * @example
   *   // Global approach
   *   $.steps.defaults.headerTag = "h3";
   * @example
   *   // Initialization approach
   *   $("#wizard").steps({ headerTag: "h3" });
   **/
  var defaults = $.fn.steps.defaults = {
      /**
       * The header tag is used to find the step button text within the declared wizard area.
       *
       * @property headerTag
       * @type String
       * @default "h1"
       * @for defaults
       **/
      headerTag: "h1",
  
      /**
       * The body tag is used to find the step content within the declared wizard area.
       *
       * @property bodyTag
       * @type String
       * @default "div"
       * @for defaults
       **/
      bodyTag: "div",
  
      /**
       * The content container tag which will be used to wrap all step contents.
       *
       * @property contentContainerTag
       * @type String
       * @default "div"
       * @for defaults
       **/
      contentContainerTag: "div",
  
      /**
       * The action container tag which will be used to wrap the pagination navigation.
       *
       * @property actionContainerTag
       * @type String
       * @default "div"
       * @for defaults
       **/
      actionContainerTag: "div",
  
      /**
       * The steps container tag which will be used to wrap the steps navigation.
       *
       * @property stepsContainerTag
       * @type String
       * @default "div"
       * @for defaults
       **/
      stepsContainerTag: "div",
  
      /**
       * The css class which will be added to the outer component wrapper.
       *
       * @property cssClass
       * @type String
       * @default "wizard"
       * @for defaults
       * @example
       *     <div class="wizard">
       *         ...
       *     </div>
       **/
      cssClass: "wizard",
  
      /**
       * The css class which will be used for floating scenarios.
       *
       * @property clearFixCssClass
       * @type String
       * @default "clearfix"
       * @for defaults
       **/
      clearFixCssClass: "clearfix",
  
      /**
       * Determines whether the steps are vertically or horizontally oriented.
       *
       * @property stepsOrientation
       * @type stepsOrientation
       * @default horizontal
       * @for defaults
       * @since 1.0.0
       **/
      stepsOrientation: stepsOrientation.horizontal,
  
      /*
       * Tempplates
       */
  
      /**
       * The title template which will be used to create a step button.
       *
       * @property titleTemplate
       * @type String
       * @default "<span class=\"number\">#index#.</span> #title#"
       * @for defaults
       **/
      titleTemplate: "<span class=\"number\">#index#.</span> #title#",
  
      /**
       * The loading template which will be used to create the loading animation.
       *
       * @property loadingTemplate
       * @type String
       * @default "<span class=\"spinner\"></span> #text#"
       * @for defaults
       **/
      loadingTemplate: "<span class=\"spinner\"></span> #text#",
  
      /*
       * Behaviour
       */
  
      /**
       * Sets the focus to the first wizard instance in order to enable the key navigation from the begining if `true`. 
       *
       * @property autoFocus
       * @type Boolean
       * @default false
       * @for defaults
       * @since 0.9.4
       **/
      autoFocus: false,
  
      /**
       * Enables all steps from the begining if `true` (all steps are clickable).
       *
       * @property enableAllSteps
       * @type Boolean
       * @default false
       * @for defaults
       **/
      enableAllSteps: false,
  
      /**
       * Enables keyboard navigation if `true` (arrow left and arrow right).
       *
       * @property enableKeyNavigation
       * @type Boolean
       * @default true
       * @for defaults
       **/
      enableKeyNavigation: true,
  
      /**
       * Enables pagination if `true`.
       *
       * @property enablePagination
       * @type Boolean
       * @default true
       * @for defaults
       **/
      enablePagination: true,
  
      /**
       * Suppresses pagination if a form field is focused.
       *
       * @property suppressPaginationOnFocus
       * @type Boolean
       * @default true
       * @for defaults
       **/
      suppressPaginationOnFocus: true,
  
      /**
       * Enables cache for async loaded or iframe embedded content.
       *
       * @property enableContentCache
       * @type Boolean
       * @default true
       * @for defaults
       **/
      enableContentCache: true,
  
      /**
       * Shows the cancel button if enabled.
       *
       * @property enableCancelButton
       * @type Boolean
       * @default false
       * @for defaults
       **/
      enableCancelButton: false,
  
      /**
       * Shows the finish button if enabled.
       *
       * @property enableFinishButton
       * @type Boolean
       * @default true
       * @for defaults
       **/
      enableFinishButton: true,
  
      /**
       * Not yet implemented.
       *
       * @property preloadContent
       * @type Boolean
       * @default false
       * @for defaults
       **/
      preloadContent: false,
  
      /**
       * Shows the finish button always (on each step; right beside the next button) if `true`. 
       * Otherwise the next button will be replaced by the finish button if the last step becomes active.
       *
       * @property showFinishButtonAlways
       * @type Boolean
       * @default false
       * @for defaults
       **/
      showFinishButtonAlways: false,
  
      /**
       * Prevents jumping to a previous step.
       *
       * @property forceMoveForward
       * @type Boolean
       * @default false
       * @for defaults
       **/
      forceMoveForward: false,
  
      /**
       * Saves the current state (step position) to a cookie.
       * By coming next time the last active step becomes activated.
       *
       * @property saveState
       * @type Boolean
       * @default false
       * @for defaults
       **/
      saveState: false,
  
      /**
       * The position to start on (zero-based).
       *
       * @property startIndex
       * @type Integer
       * @default 0
       * @for defaults
       **/
      startIndex: 0,
  
      /*
       * Animation Effect Configuration
       */
  
      /**
       * The animation effect which will be used for step transitions.
       *
       * @property transitionEffect
       * @type transitionEffect
       * @default none
       * @for defaults
       **/
      transitionEffect: transitionEffect.none,
  
      /**
       * Animation speed for step transitions (in milliseconds).
       *
       * @property transitionEffectSpeed
       * @type Integer
       * @default 200
       * @for defaults
       **/
      transitionEffectSpeed: 200,
  
      /*
       * Events
       */
  
      /**
       * Fires before the step changes and can be used to prevent step changing by returning `false`. 
       * Very useful for form validation. 
       *
       * @property onStepChanging
       * @type Event
       * @default function (event, currentIndex, newIndex) { return true; }
       * @for defaults
       **/
      onStepChanging: function (event, currentIndex, newIndex) { return true; },
  
      /**
       * Fires after the step has change. 
       *
       * @property onStepChanged
       * @type Event
       * @default function (event, currentIndex, priorIndex) { }
       * @for defaults
       **/
      onStepChanged: function (event, currentIndex, priorIndex) { },
  
      /**
       * Fires after cancelation. 
       *
       * @property onCanceled
       * @type Event
       * @default function (event) { }
       * @for defaults
       **/
      onCanceled: function (event) { },
  
      /**
       * Fires before finishing and can be used to prevent completion by returning `false`. 
       * Very useful for form validation. 
       *
       * @property onFinishing
       * @type Event
       * @default function (event, currentIndex) { return true; }
       * @for defaults
       **/
      onFinishing: function (event, currentIndex) { return true; },
  
      /**
       * Fires after completion. 
       *
       * @property onFinished
       * @type Event
       * @default function (event, currentIndex) { }
       * @for defaults
       **/
      onFinished: function (event, currentIndex) { },
  
      /**
       * Fires after async content is loaded. 
       *
       * @property onContentLoaded
       * @type Event
       * @default function (event, index) { }
       * @for defaults
       **/
      onContentLoaded: function (event, currentIndex) { },
  
      /**
       * Fires when the wizard is initialized. 
       *
       * @property onInit
       * @type Event
       * @default function (event) { }
       * @for defaults
       **/
      onInit: function (event, currentIndex) { },
  
      /**
       * Contains all labels. 
       *
       * @property labels
       * @type Object
       * @for defaults
       **/
      labels: {
          /**
           * Label for the cancel button.
           *
           * @property cancel
           * @type String
           * @default "Cancel"
           * @for defaults
           **/
          cancel: "Cancel",
  
          /**
           * This label is important for accessability reasons.
           * Indicates which step is activated.
           *
           * @property current
           * @type String
           * @default "current step:"
           * @for defaults
           **/
          current: "current step:",
  
          /**
           * This label is important for accessability reasons and describes the kind of navigation.
           *
           * @property pagination
           * @type String
           * @default "Pagination"
           * @for defaults
           * @since 0.9.7
           **/
          pagination: "Pagination",
  
          /**
           * Label for the finish button.
           *
           * @property finish
           * @type String
           * @default "Finish"
           * @for defaults
           **/
          finish: "Finish",
  
          /**
           * Label for the next button.
           *
           * @property next
           * @type String
           * @default "Next"
           * @for defaults
           **/
          next: "Next",
  
          /**
           * Label for the previous button.
           *
           * @property previous
           * @type String
           * @default "Previous"
           * @for defaults
           **/
          previous: "Previous",
  
          /**
           * Label for the loading animation.
           *
           * @property loading
           * @type String
           * @default "Loading ..."
           * @for defaults
           **/
          loading: "Loading ..."
      }
  };
  })(jQuery);