/*
* # Semantic UI - 2.2.2
* https://github.com/Semantic-Org/Semantic-UI
* http://www.semantic-ui.com/
*
* Copyright 2014 Contributors
* Released under the MIT license
* http://opensource.org/licenses/MIT
*
*/
/*!
 * # Semantic UI 2.2.2 - Site
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    $.site = $.fn.site = function (parameters) {
        var
          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          settings = ($.isPlainObject(parameters))
            ? $.extend(true, {}, $.site.settings, parameters)
            : $.extend({}, $.site.settings),

          namespace = settings.namespace,
          error = settings.error,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          $document = $(document),
          $module = $document,
          element = this,
          instance = $module.data(moduleNamespace),

          module,
          returnedValue
        ;
        module = {

            initialize: function () {
                module.instantiate();
            },

            instantiate: function () {
                module.verbose('Storing instance of site', module);
                instance = module;
                $module
                  .data(moduleNamespace, module)
                ;
            },

            normalize: function () {
                module.fix.console();
                module.fix.requestAnimationFrame();
            },

            fix: {
                console: function () {
                    module.debug('Normalizing window.console');
                    if (console === undefined || console.log === undefined) {
                        module.verbose('Console not available, normalizing events');
                        module.disable.console();
                    }
                    if (typeof console.group == 'undefined' || typeof console.groupEnd == 'undefined' || typeof console.groupCollapsed == 'undefined') {
                        module.verbose('Console group not available, normalizing events');
                        window.console.group = function () { };
                        window.console.groupEnd = function () { };
                        window.console.groupCollapsed = function () { };
                    }
                    if (typeof console.markTimeline == 'undefined') {
                        module.verbose('Mark timeline not available, normalizing events');
                        window.console.markTimeline = function () { };
                    }
                },
                consoleClear: function () {
                    module.debug('Disabling programmatic console clearing');
                    window.console.clear = function () { };
                },
                requestAnimationFrame: function () {
                    module.debug('Normalizing requestAnimationFrame');
                    if (window.requestAnimationFrame === undefined) {
                        module.debug('RequestAnimationFrame not available, normalizing event');
                        window.requestAnimationFrame = window.requestAnimationFrame
                          || window.mozRequestAnimationFrame
                          || window.webkitRequestAnimationFrame
                          || window.msRequestAnimationFrame
                          || function (callback) { setTimeout(callback, 0); }
                        ;
                    }
                }
            },

            moduleExists: function (name) {
                return ($.fn[name] !== undefined && $.fn[name].settings !== undefined);
            },

            enabled: {
                modules: function (modules) {
                    var
                      enabledModules = []
                    ;
                    modules = modules || settings.modules;
                    $.each(modules, function (index, name) {
                        if (module.moduleExists(name)) {
                            enabledModules.push(name);
                        }
                    });
                    return enabledModules;
                }
            },

            disabled: {
                modules: function (modules) {
                    var
                      disabledModules = []
                    ;
                    modules = modules || settings.modules;
                    $.each(modules, function (index, name) {
                        if (!module.moduleExists(name)) {
                            disabledModules.push(name);
                        }
                    });
                    return disabledModules;
                }
            },

            change: {
                setting: function (setting, value, modules, modifyExisting) {
                    modules = (typeof modules === 'string')
                      ? (modules === 'all')
                        ? settings.modules
                        : [modules]
                      : modules || settings.modules
                    ;
                    modifyExisting = (modifyExisting !== undefined)
                      ? modifyExisting
                      : true
                    ;
                    $.each(modules, function (index, name) {
                        var
                          namespace = (module.moduleExists(name))
                            ? $.fn[name].settings.namespace || false
                            : true,
                          $existingModules
                        ;
                        if (module.moduleExists(name)) {
                            module.verbose('Changing default setting', setting, value, name);
                            $.fn[name].settings[setting] = value;
                            if (modifyExisting && namespace) {
                                $existingModules = $(':data(module-' + namespace + ')');
                                if ($existingModules.length > 0) {
                                    module.verbose('Modifying existing settings', $existingModules);
                                    $existingModules[name]('setting', setting, value);
                                }
                            }
                        }
                    });
                },
                settings: function (newSettings, modules, modifyExisting) {
                    modules = (typeof modules === 'string')
                      ? [modules]
                      : modules || settings.modules
                    ;
                    modifyExisting = (modifyExisting !== undefined)
                      ? modifyExisting
                      : true
                    ;
                    $.each(modules, function (index, name) {
                        var
                          $existingModules
                        ;
                        if (module.moduleExists(name)) {
                            module.verbose('Changing default setting', newSettings, name);
                            $.extend(true, $.fn[name].settings, newSettings);
                            if (modifyExisting && namespace) {
                                $existingModules = $(':data(module-' + namespace + ')');
                                if ($existingModules.length > 0) {
                                    module.verbose('Modifying existing settings', $existingModules);
                                    $existingModules[name]('setting', newSettings);
                                }
                            }
                        }
                    });
                }
            },

            enable: {
                console: function () {
                    module.console(true);
                },
                debug: function (modules, modifyExisting) {
                    modules = modules || settings.modules;
                    module.debug('Enabling debug for modules', modules);
                    module.change.setting('debug', true, modules, modifyExisting);
                },
                verbose: function (modules, modifyExisting) {
                    modules = modules || settings.modules;
                    module.debug('Enabling verbose debug for modules', modules);
                    module.change.setting('verbose', true, modules, modifyExisting);
                }
            },
            disable: {
                console: function () {
                    module.console(false);
                },
                debug: function (modules, modifyExisting) {
                    modules = modules || settings.modules;
                    module.debug('Disabling debug for modules', modules);
                    module.change.setting('debug', false, modules, modifyExisting);
                },
                verbose: function (modules, modifyExisting) {
                    modules = modules || settings.modules;
                    module.debug('Disabling verbose debug for modules', modules);
                    module.change.setting('verbose', false, modules, modifyExisting);
                }
            },

            console: function (enable) {
                if (enable) {
                    if (instance.cache.console === undefined) {
                        module.error(error.console);
                        return;
                    }
                    module.debug('Restoring console function');
                    window.console = instance.cache.console;
                }
                else {
                    module.debug('Disabling console function');
                    instance.cache.console = window.console;
                    window.console = {
                        clear: function () { },
                        error: function () { },
                        group: function () { },
                        groupCollapsed: function () { },
                        groupEnd: function () { },
                        info: function () { },
                        log: function () { },
                        markTimeline: function () { },
                        warn: function () { }
                    };
                }
            },

            destroy: function () {
                module.verbose('Destroying previous site for', $module);
                $module
                  .removeData(moduleNamespace)
                ;
            },

            cache: {},

            setting: function (name, value) {
                if ($.isPlainObject(name)) {
                    $.extend(true, settings, name);
                }
                else if (value !== undefined) {
                    settings[name] = value;
                }
                else {
                    return settings[name];
                }
            },
            internal: function (name, value) {
                if ($.isPlainObject(name)) {
                    $.extend(true, module, name);
                }
                else if (value !== undefined) {
                    module[name] = value;
                }
                else {
                    return module[name];
                }
            },
            debug: function () {
                if (settings.debug) {
                    if (settings.performance) {
                        module.performance.log(arguments);
                    }
                    else {
                        module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                        module.debug.apply(console, arguments);
                    }
                }
            },
            verbose: function () {
                if (settings.verbose && settings.debug) {
                    if (settings.performance) {
                        module.performance.log(arguments);
                    }
                    else {
                        module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                        module.verbose.apply(console, arguments);
                    }
                }
            },
            error: function () {
                module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                module.error.apply(console, arguments);
            },
            performance: {
                log: function (message) {
                    var
                      currentTime,
                      executionTime,
                      previousTime
                    ;
                    if (settings.performance) {
                        currentTime = new Date().getTime();
                        previousTime = time || currentTime;
                        executionTime = currentTime - previousTime;
                        time = currentTime;
                        performance.push({
                            'Element': element,
                            'Name': message[0],
                            'Arguments': [].slice.call(message, 1) || '',
                            'Execution Time': executionTime
                        });
                    }
                    clearTimeout(module.performance.timer);
                    module.performance.timer = setTimeout(module.performance.display, 500);
                },
                display: function () {
                    var
                      title = settings.name + ':',
                      totalTime = 0
                    ;
                    time = false;
                    clearTimeout(module.performance.timer);
                    $.each(performance, function (index, data) {
                        totalTime += data['Execution Time'];
                    });
                    title += ' ' + totalTime + 'ms';
                    if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                        console.groupCollapsed(title);
                        if (console.table) {
                            console.table(performance);
                        }
                        else {
                            $.each(performance, function (index, data) {
                                console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                            });
                        }
                        console.groupEnd();
                    }
                    performance = [];
                }
            },
            invoke: function (query, passedArguments, context) {
                var
                  object = instance,
                  maxDepth,
                  found,
                  response
                ;
                passedArguments = passedArguments || queryArguments;
                context = element || context;
                if (typeof query == 'string' && object !== undefined) {
                    query = query.split(/[\. ]/);
                    maxDepth = query.length - 1;
                    $.each(query, function (depth, value) {
                        var camelCaseValue = (depth != maxDepth)
                          ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                          : query
                        ;
                        if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                            object = object[camelCaseValue];
                        }
                        else if (object[camelCaseValue] !== undefined) {
                            found = object[camelCaseValue];
                            return false;
                        }
                        else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                            object = object[value];
                        }
                        else if (object[value] !== undefined) {
                            found = object[value];
                            return false;
                        }
                        else {
                            module.error(error.method, query);
                            return false;
                        }
                    });
                }
                if ($.isFunction(found)) {
                    response = found.apply(context, passedArguments);
                }
                else if (found !== undefined) {
                    response = found;
                }
                if ($.isArray(returnedValue)) {
                    returnedValue.push(response);
                }
                else if (returnedValue !== undefined) {
                    returnedValue = [returnedValue, response];
                }
                else if (response !== undefined) {
                    returnedValue = response;
                }
                return found;
            }
        };

        if (methodInvoked) {
            if (instance === undefined) {
                module.initialize();
            }
            module.invoke(query);
        }
        else {
            if (instance !== undefined) {
                module.destroy();
            }
            module.initialize();
        }
        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.site.settings = {

        name: 'Site',
        namespace: 'site',

        error: {
            console: 'Console cannot be restored, most likely it was overwritten outside of module',
            method: 'The method you called is not defined.'
        },

        debug: false,
        verbose: false,
        performance: true,

        modules: [
          'accordion',
          'api',
          'checkbox',
          'dimmer',
          'dropdown',
          'embed',
          'form',
          'modal',
          'nag',
          'popup',
          'rating',
          'shape',
          'sidebar',
          'state',
          'sticky',
          'tab',
          'transition',
          'visit',
          'visibility'
        ],

        siteNamespace: 'site',
        namespaceStub: {
            cache: {},
            config: {},
            sections: {},
            section: {},
            utilities: {}
        }

    };

    // allows for selection of elements with data attributes
    $.extend($.expr[":"], {
        data: ($.expr.createPseudo)
          ? $.expr.createPseudo(function (dataName) {
              return function (elem) {
                  return !!$.data(elem, dataName);
              };
          })
          : function (elem, i, match) {
              // support: jQuery < 1.8
              return !!$.data(elem, match[3]);
          }
    });


})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Form Validation
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.form = function (parameters) {
        var
          $allModules = $(this),
          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          legacyParameters = arguments[1],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),
          returnedValue
        ;
        $allModules
          .each(function () {
              var
                $module = $(this),
                element = this,

                formErrors = [],
                keyHeldDown = false,

                // set at run-time
                $field,
                $group,
                $message,
                $prompt,
                $submit,
                $clear,
                $reset,

                settings,
                validation,

                metadata,
                selector,
                className,
                error,

                namespace,
                moduleNamespace,
                eventNamespace,

                instance,
                module
              ;

              module = {

                  initialize: function () {

                      // settings grabbed at run time
                      module.get.settings();
                      if (methodInvoked) {
                          if (instance === undefined) {
                              module.instantiate();
                          }
                          module.invoke(query);
                      }
                      else {
                          if (instance !== undefined) {
                              instance.invoke('destroy');
                          }
                          module.verbose('Initializing form validation', $module, settings);
                          module.bindEvents();
                          module.set.defaults();
                          module.instantiate();
                      }
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous module', instance);
                      module.removeEvents();
                      $module
                        .removeData(moduleNamespace)
                      ;
                  },

                  refresh: function () {
                      module.verbose('Refreshing selector cache');
                      $field = $module.find(selector.field);
                      $group = $module.find(selector.group);
                      $message = $module.find(selector.message);
                      $prompt = $module.find(selector.prompt);

                      $submit = $module.find(selector.submit);
                      $clear = $module.find(selector.clear);
                      $reset = $module.find(selector.reset);
                  },

                  submit: function () {
                      module.verbose('Submitting form', $module);
                      $module
                        .submit()
                      ;
                  },

                  attachEvents: function (selector, action) {
                      action = action || 'submit';
                      $(selector)
                        .on('click' + eventNamespace, function (event) {
                            module[action]();
                            event.preventDefault();
                        })
                      ;
                  },

                  bindEvents: function () {
                      module.verbose('Attaching form events');
                      $module
                        .on('submit' + eventNamespace, module.validate.form)
                        .on('blur' + eventNamespace, selector.field, module.event.field.blur)
                        .on('click' + eventNamespace, selector.submit, module.submit)
                        .on('click' + eventNamespace, selector.reset, module.reset)
                        .on('click' + eventNamespace, selector.clear, module.clear)
                      ;
                      if (settings.keyboardShortcuts) {
                          $module
                            .on('keydown' + eventNamespace, selector.field, module.event.field.keydown)
                          ;
                      }
                      $field
                        .each(function () {
                            var
                              $input = $(this),
                              type = $input.prop('type'),
                              inputEvent = module.get.changeEvent(type, $input)
                            ;
                            $(this)
                              .on(inputEvent + eventNamespace, module.event.field.change)
                            ;
                        })
                      ;
                  },

                  clear: function () {
                      $field
                        .each(function () {
                            var
                              $field = $(this),
                              $element = $field.parent(),
                              $fieldGroup = $field.closest($group),
                              $prompt = $fieldGroup.find(selector.prompt),
                              defaultValue = $field.data(metadata.defaultValue) || '',
                              isCheckbox = $element.is(selector.uiCheckbox),
                              isDropdown = $element.is(selector.uiDropdown),
                              isErrored = $fieldGroup.hasClass(className.error)
                            ;
                            if (isErrored) {
                                module.verbose('Resetting error on field', $fieldGroup);
                                $fieldGroup.removeClass(className.error);
                                $prompt.remove();
                            }
                            if (isDropdown) {
                                module.verbose('Resetting dropdown value', $element, defaultValue);
                                $element.dropdown('clear');
                            }
                            else if (isCheckbox) {
                                $field.prop('checked', false);
                            }
                            else {
                                module.verbose('Resetting field value', $field, defaultValue);
                                $field.val('');
                            }
                        })
                      ;
                  },

                  reset: function () {
                      $field
                        .each(function () {
                            var
                              $field = $(this),
                              $element = $field.parent(),
                              $fieldGroup = $field.closest($group),
                              $prompt = $fieldGroup.find(selector.prompt),
                              defaultValue = $field.data(metadata.defaultValue),
                              isCheckbox = $element.is(selector.uiCheckbox),
                              isDropdown = $element.is(selector.uiDropdown),
                              isErrored = $fieldGroup.hasClass(className.error)
                            ;
                            if (defaultValue === undefined) {
                                return;
                            }
                            if (isErrored) {
                                module.verbose('Resetting error on field', $fieldGroup);
                                $fieldGroup.removeClass(className.error);
                                $prompt.remove();
                            }
                            if (isDropdown) {
                                module.verbose('Resetting dropdown value', $element, defaultValue);
                                $element.dropdown('restore defaults');
                            }
                            else if (isCheckbox) {
                                module.verbose('Resetting checkbox value', $element, defaultValue);
                                $field.prop('checked', defaultValue);
                            }
                            else {
                                module.verbose('Resetting field value', $field, defaultValue);
                                $field.val(defaultValue);
                            }
                        })
                      ;
                  },

                  is: {
                      bracketedRule: function (rule) {
                          return (rule.type && rule.type.match(settings.regExp.bracket));
                      },
                      empty: function ($field) {
                          if (!$field || $field.length === 0) {
                              return true;
                          }
                          else if ($field.is('input[type="checkbox"]')) {
                              return !$field.is(':checked');
                          }
                          else {
                              return module.is.blank($field);
                          }
                      },
                      blank: function ($field) {
                          return $.trim($field.val()) === '';
                      },
                      valid: function () {
                          var
                            allValid = true
                          ;
                          module.verbose('Checking if form is valid');
                          $.each(validation, function (fieldName, field) {
                              if (!(module.validate.field(field, fieldName))) {
                                  allValid = false;
                              }
                          });
                          return allValid;
                      }
                  },

                  removeEvents: function () {
                      $module
                        .off(eventNamespace)
                      ;
                      $field
                        .off(eventNamespace)
                      ;
                      $submit
                        .off(eventNamespace)
                      ;
                      $field
                        .off(eventNamespace)
                      ;
                  },

                  event: {
                      field: {
                          keydown: function (event) {
                              var
                                $field = $(this),
                                key = event.which,
                                isInput = $field.is(selector.input),
                                isCheckbox = $field.is(selector.checkbox),
                                isInDropdown = ($field.closest(selector.uiDropdown).length > 0),
                                keyCode = {
                                    enter: 13,
                                    escape: 27
                                }
                              ;
                              if (key == keyCode.escape) {
                                  module.verbose('Escape key pressed blurring field');
                                  $field
                                    .blur()
                                  ;
                              }
                              if (!event.ctrlKey && key == keyCode.enter && isInput && !isInDropdown && !isCheckbox) {
                                  if (!keyHeldDown) {
                                      $field
                                        .one('keyup' + eventNamespace, module.event.field.keyup)
                                      ;
                                      module.submit();
                                      module.debug('Enter pressed on input submitting form');
                                  }
                                  keyHeldDown = true;
                              }
                          },
                          keyup: function () {
                              keyHeldDown = false;
                          },
                          blur: function (event) {
                              var
                                $field = $(this),
                                $fieldGroup = $field.closest($group),
                                validationRules = module.get.validation($field)
                              ;
                              if ($fieldGroup.hasClass(className.error)) {
                                  module.debug('Revalidating field', $field, validationRules);
                                  if (validationRules) {
                                      module.validate.field(validationRules);
                                  }
                              }
                              else if (settings.on == 'blur' || settings.on == 'change') {
                                  if (validationRules) {
                                      module.validate.field(validationRules);
                                  }
                              }
                          },
                          change: function (event) {
                              var
                                $field = $(this),
                                $fieldGroup = $field.closest($group),
                                validationRules = module.get.validation($field)
                              ;
                              if (settings.on == 'change' || ($fieldGroup.hasClass(className.error) && settings.revalidate)) {
                                  clearTimeout(module.timer);
                                  module.timer = setTimeout(function () {
                                      module.debug('Revalidating field', $field, module.get.validation($field));
                                      module.validate.field(validationRules);
                                  }, settings.delay);
                              }
                          }
                      }

                  },

                  get: {
                      ancillaryValue: function (rule) {
                          if (!rule.type || !module.is.bracketedRule(rule)) {
                              return false;
                          }
                          return rule.type.match(settings.regExp.bracket)[1] + '';
                      },
                      ruleName: function (rule) {
                          if (module.is.bracketedRule(rule)) {
                              return rule.type.replace(rule.type.match(settings.regExp.bracket)[0], '');
                          }
                          return rule.type;
                      },
                      changeEvent: function (type, $input) {
                          if (type == 'checkbox' || type == 'radio' || type == 'hidden' || $input.is('select')) {
                              return 'change';
                          }
                          else {
                              return module.get.inputEvent();
                          }
                      },
                      inputEvent: function () {
                          return (document.createElement('input').oninput !== undefined)
                            ? 'input'
                            : (document.createElement('input').onpropertychange !== undefined)
                              ? 'propertychange'
                              : 'keyup'
                          ;
                      },
                      prompt: function (rule, field) {
                          var
                            ruleName = module.get.ruleName(rule),
                            ancillary = module.get.ancillaryValue(rule),
                            prompt = rule.prompt || settings.prompt[ruleName] || settings.text.unspecifiedRule,
                            requiresValue = (prompt.search('{value}') !== -1),
                            requiresName = (prompt.search('{name}') !== -1),
                            $label,
                            $field,
                            name
                          ;
                          if (requiresName || requiresValue) {
                              $field = module.get.field(field.identifier);
                          }
                          if (requiresValue) {
                              prompt = prompt.replace('{value}', $field.val());
                          }
                          if (requiresName) {
                              $label = $field.closest(selector.group).find('label').eq(0);
                              name = ($label.length == 1)
                                ? $label.text()
                                : $field.prop('placeholder') || settings.text.unspecifiedField
                              ;
                              prompt = prompt.replace('{name}', name);
                          }
                          prompt = prompt.replace('{identifier}', field.identifier);
                          prompt = prompt.replace('{ruleValue}', ancillary);
                          if (!rule.prompt) {
                              module.verbose('Using default validation prompt for type', prompt, ruleName);
                          }
                          return prompt;
                      },
                      settings: function () {
                          if ($.isPlainObject(parameters)) {
                              var
                                keys = Object.keys(parameters),
                                isLegacySettings = (keys.length > 0)
                                  ? (parameters[keys[0]].identifier !== undefined && parameters[keys[0]].rules !== undefined)
                                  : false,
                                ruleKeys
                              ;
                              if (isLegacySettings) {
                                  // 1.x (ducktyped)
                                  settings = $.extend(true, {}, $.fn.form.settings, legacyParameters);
                                  validation = $.extend({}, $.fn.form.settings.defaults, parameters);
                                  module.error(settings.error.oldSyntax, element);
                                  module.verbose('Extending settings from legacy parameters', validation, settings);
                              }
                              else {
                                  // 2.x
                                  if (parameters.fields) {
                                      ruleKeys = Object.keys(parameters.fields);
                                      if (typeof parameters.fields[ruleKeys[0]] == 'string' || $.isArray(parameters.fields[ruleKeys[0]])) {
                                          $.each(parameters.fields, function (name, rules) {
                                              if (typeof rules == 'string') {
                                                  rules = [rules];
                                              }
                                              parameters.fields[name] = {
                                                  rules: []
                                              };
                                              $.each(rules, function (index, rule) {
                                                  parameters.fields[name].rules.push({ type: rule });
                                              });
                                          });
                                      }
                                  }

                                  settings = $.extend(true, {}, $.fn.form.settings, parameters);
                                  validation = $.extend({}, $.fn.form.settings.defaults, settings.fields);
                                  module.verbose('Extending settings', validation, settings);
                              }
                          }
                          else {
                              settings = $.fn.form.settings;
                              validation = $.fn.form.settings.defaults;
                              module.verbose('Using default form validation', validation, settings);
                          }

                          // shorthand
                          namespace = settings.namespace;
                          metadata = settings.metadata;
                          selector = settings.selector;
                          className = settings.className;
                          error = settings.error;
                          moduleNamespace = 'module-' + namespace;
                          eventNamespace = '.' + namespace;

                          // grab instance
                          instance = $module.data(moduleNamespace);

                          // refresh selector cache
                          module.refresh();
                      },
                      field: function (identifier) {
                          module.verbose('Finding field with identifier', identifier);
                          if ($field.filter('#' + identifier).length > 0) {
                              return $field.filter('#' + identifier);
                          }
                          else if ($field.filter('[name="' + identifier + '"]').length > 0) {
                              return $field.filter('[name="' + identifier + '"]');
                          }
                          else if ($field.filter('[name="' + identifier + '[]"]').length > 0) {
                              return $field.filter('[name="' + identifier + '[]"]');
                          }
                          else if ($field.filter('[data-' + metadata.validate + '="' + identifier + '"]').length > 0) {
                              return $field.filter('[data-' + metadata.validate + '="' + identifier + '"]');
                          }
                          return $('<input/>');
                      },
                      fields: function (fields) {
                          var
                            $fields = $()
                          ;
                          $.each(fields, function (index, name) {
                              $fields = $fields.add(module.get.field(name));
                          });
                          return $fields;
                      },
                      validation: function ($field) {
                          var
                            fieldValidation,
                            identifier
                          ;
                          if (!validation) {
                              return false;
                          }
                          $.each(validation, function (fieldName, field) {
                              identifier = field.identifier || fieldName;
                              if (module.get.field(identifier)[0] == $field[0]) {
                                  field.identifier = identifier;
                                  fieldValidation = field;
                              }
                          });
                          return fieldValidation || false;
                      },
                      value: function (field) {
                          var
                            fields = [],
                            results
                          ;
                          fields.push(field);
                          results = module.get.values.call(element, fields);
                          return results[field];
                      },
                      values: function (fields) {
                          var
                            $fields = $.isArray(fields)
                              ? module.get.fields(fields)
                              : $field,
                            values = {}
                          ;
                          $fields.each(function (index, field) {
                              var
                                $field = $(field),
                                type = $field.prop('type'),
                                name = $field.prop('name'),
                                value = $field.val(),
                                isCheckbox = $field.is(selector.checkbox),
                                isRadio = $field.is(selector.radio),
                                isMultiple = (name.indexOf('[]') !== -1),
                                isChecked = (isCheckbox)
                                  ? $field.is(':checked')
                                  : false
                              ;
                              if (name) {
                                  if (isMultiple) {
                                      name = name.replace('[]', '');
                                      if (!values[name]) {
                                          values[name] = [];
                                      }
                                      if (isCheckbox) {
                                          if (isChecked) {
                                              values[name].push(value || true);
                                          }
                                          else {
                                              values[name].push(false);
                                          }
                                      }
                                      else {
                                          values[name].push(value);
                                      }
                                  }
                                  else {
                                      if (isRadio) {
                                          if (isChecked) {
                                              values[name] = value;
                                          }
                                      }
                                      else if (isCheckbox) {
                                          if (isChecked) {
                                              values[name] = value || true;
                                          }
                                          else {
                                              values[name] = false;
                                          }
                                      }
                                      else {
                                          values[name] = value;
                                      }
                                  }
                              }
                          });
                          return values;
                      }
                  },

                  has: {

                      field: function (identifier) {
                          module.verbose('Checking for existence of a field with identifier', identifier);
                          if (typeof identifier !== 'string') {
                              module.error(error.identifier, identifier);
                          }
                          if ($field.filter('#' + identifier).length > 0) {
                              return true;
                          }
                          else if ($field.filter('[name="' + identifier + '"]').length > 0) {
                              return true;
                          }
                          else if ($field.filter('[data-' + metadata.validate + '="' + identifier + '"]').length > 0) {
                              return true;
                          }
                          return false;
                      }

                  },

                  add: {
                      prompt: function (identifier, errors) {
                          var
                            $field = module.get.field(identifier),
                            $fieldGroup = $field.closest($group),
                            $prompt = $fieldGroup.children(selector.prompt),
                            promptExists = ($prompt.length !== 0)
                          ;
                          errors = (typeof errors == 'string')
                            ? [errors]
                            : errors
                          ;
                          module.verbose('Adding field error state', identifier);
                          $fieldGroup
                            .addClass(className.error)
                          ;
                          if (settings.inline) {
                              if (!promptExists) {
                                  $prompt = settings.templates.prompt(errors);
                                  $prompt
                                    .appendTo($fieldGroup)
                                  ;
                              }
                              $prompt
                                .html(errors[0])
                              ;
                              if (!promptExists) {
                                  if (settings.transition && $.fn.transition !== undefined && $module.transition('is supported')) {
                                      module.verbose('Displaying error with css transition', settings.transition);
                                      $prompt.transition(settings.transition + ' in', settings.duration);
                                  }
                                  else {
                                      module.verbose('Displaying error with fallback javascript animation');
                                      $prompt
                                        .fadeIn(settings.duration)
                                      ;
                                  }
                              }
                              else {
                                  module.verbose('Inline errors are disabled, no inline error added', identifier);
                              }
                          }
                      },
                      errors: function (errors) {
                          module.debug('Adding form error messages', errors);
                          module.set.error();
                          $message
                            .html(settings.templates.error(errors))
                          ;
                      }
                  },

                  remove: {
                      prompt: function (identifier) {
                          var
                            $field = module.get.field(identifier),
                            $fieldGroup = $field.closest($group),
                            $prompt = $fieldGroup.children(selector.prompt)
                          ;
                          $fieldGroup
                            .removeClass(className.error)
                          ;
                          if (settings.inline && $prompt.is(':visible')) {
                              module.verbose('Removing prompt for field', identifier);
                              if (settings.transition && $.fn.transition !== undefined && $module.transition('is supported')) {
                                  $prompt.transition(settings.transition + ' out', settings.duration, function () {
                                      $prompt.remove();
                                  });
                              }
                              else {
                                  $prompt
                                    .fadeOut(settings.duration, function () {
                                        $prompt.remove();
                                    })
                                  ;
                              }
                          }
                      }
                  },

                  set: {
                      success: function () {
                          $module
                            .removeClass(className.error)
                            .addClass(className.success)
                          ;
                      },
                      defaults: function () {
                          $field
                            .each(function () {
                                var
                                  $field = $(this),
                                  isCheckbox = ($field.filter(selector.checkbox).length > 0),
                                  value = (isCheckbox)
                                    ? $field.is(':checked')
                                    : $field.val()
                                ;
                                $field.data(metadata.defaultValue, value);
                            })
                          ;
                      },
                      error: function () {
                          $module
                            .removeClass(className.success)
                            .addClass(className.error)
                          ;
                      },
                      value: function (field, value) {
                          var
                            fields = {}
                          ;
                          fields[field] = value;
                          return module.set.values.call(element, fields);
                      },
                      values: function (fields) {
                          if ($.isEmptyObject(fields)) {
                              return;
                          }
                          $.each(fields, function (key, value) {
                              var
                                $field = module.get.field(key),
                                $element = $field.parent(),
                                isMultiple = $.isArray(value),
                                isCheckbox = $element.is(selector.uiCheckbox),
                                isDropdown = $element.is(selector.uiDropdown),
                                isRadio = ($field.is(selector.radio) && isCheckbox),
                                fieldExists = ($field.length > 0),
                                $multipleField
                              ;
                              if (fieldExists) {
                                  if (isMultiple && isCheckbox) {
                                      module.verbose('Selecting multiple', value, $field);
                                      $element.checkbox('uncheck');
                                      $.each(value, function (index, value) {
                                          $multipleField = $field.filter('[value="' + value + '"]');
                                          $element = $multipleField.parent();
                                          if ($multipleField.length > 0) {
                                              $element.checkbox('check');
                                          }
                                      });
                                  }
                                  else if (isRadio) {
                                      module.verbose('Selecting radio value', value, $field);
                                      $field.filter('[value="' + value + '"]')
                                        .parent(selector.uiCheckbox)
                                          .checkbox('check')
                                      ;
                                  }
                                  else if (isCheckbox) {
                                      module.verbose('Setting checkbox value', value, $element);
                                      if (value === true) {
                                          $element.checkbox('check');
                                      }
                                      else {
                                          $element.checkbox('uncheck');
                                      }
                                  }
                                  else if (isDropdown) {
                                      module.verbose('Setting dropdown value', value, $element);
                                      $element.dropdown('set selected', value);
                                  }
                                  else {
                                      module.verbose('Setting field value', value, $field);
                                      $field.val(value);
                                  }
                              }
                          });
                      }
                  },

                  validate: {

                      form: function (event, ignoreCallbacks) {
                          var
                            values = module.get.values(),
                            apiRequest
                          ;

                          // input keydown event will fire submit repeatedly by browser default
                          if (keyHeldDown) {
                              return false;
                          }

                          // reset errors
                          formErrors = [];
                          if (module.is.valid()) {
                              module.debug('Form has no validation errors, submitting');
                              module.set.success();
                              if (ignoreCallbacks !== true) {
                                  return settings.onSuccess.call(element, event, values);
                              }
                          }
                          else {
                              module.debug('Form has errors');
                              module.set.error();
                              if (!settings.inline) {
                                  module.add.errors(formErrors);
                              }
                              // prevent ajax submit
                              if ($module.data('moduleApi') !== undefined) {
                                  event.stopImmediatePropagation();
                              }
                              if (ignoreCallbacks !== true) {
                                  return settings.onFailure.call(element, formErrors, values);
                              }
                          }
                      },

                      // takes a validation object and returns whether field passes validation
                      field: function (field, fieldName) {
                          var
                            identifier = field.identifier || fieldName,
                            $field = module.get.field(identifier),
                            $dependsField = (field.depends)
                              ? module.get.field(field.depends)
                              : false,
                            fieldValid = true,
                            fieldErrors = []
                          ;
                          if (!field.identifier) {
                              module.debug('Using field name as identifier', identifier);
                              field.identifier = identifier;
                          }
                          if ($field.prop('disabled')) {
                              module.debug('Field is disabled. Skipping', identifier);
                              fieldValid = true;
                          }
                          else if (field.optional && module.is.blank($field)) {
                              module.debug('Field is optional and blank. Skipping', identifier);
                              fieldValid = true;
                          }
                          else if (field.depends && module.is.empty($dependsField)) {
                              module.debug('Field depends on another value that is not present or empty. Skipping', $dependsField);
                              fieldValid = true;
                          }
                          else if (field.rules !== undefined) {
                              $.each(field.rules, function (index, rule) {
                                  if (module.has.field(identifier) && !(module.validate.rule(field, rule))) {
                                      module.debug('Field is invalid', identifier, rule.type);
                                      fieldErrors.push(module.get.prompt(rule, field));
                                      fieldValid = false;
                                  }
                              });
                          }
                          if (fieldValid) {
                              module.remove.prompt(identifier, fieldErrors);
                              settings.onValid.call($field);
                          }
                          else {
                              formErrors = formErrors.concat(fieldErrors);
                              module.add.prompt(identifier, fieldErrors);
                              settings.onInvalid.call($field, fieldErrors);
                              return false;
                          }
                          return true;
                      },

                      // takes validation rule and returns whether field passes rule
                      rule: function (field, rule) {
                          var
                            $field = module.get.field(field.identifier),
                            type = rule.type,
                            value = $field.val(),
                            isValid = true,
                            ancillary = module.get.ancillaryValue(rule),
                            ruleName = module.get.ruleName(rule),
                            ruleFunction = settings.rules[ruleName]
                          ;
                          if (!$.isFunction(ruleFunction)) {
                              module.error(error.noRule, ruleName);
                              return;
                          }
                          // cast to string avoiding encoding special values
                          value = (value === undefined || value === '' || value === null)
                            ? ''
                            : $.trim(value + '')
                          ;
                          return ruleFunction.call($field, value, ancillary);
                      }
                  },

                  setting: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          settings[name] = value;
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ($allModules.length > 1) {
                              title += ' ' + '(' + $allModules.length + ')';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };
              module.initialize();
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.form.settings = {

        name: 'Form',
        namespace: 'form',

        debug: false,
        verbose: false,
        performance: true,

        fields: false,

        keyboardShortcuts: true,
        on: 'submit',
        inline: false,

        delay: 200,
        revalidate: true,

        transition: 'scale',
        duration: 200,

        onValid: function () { },
        onInvalid: function () { },
        onSuccess: function () { return true; },
        onFailure: function () { return false; },

        metadata: {
            defaultValue: 'default',
            validate: 'validate'
        },

        regExp: {
            bracket: /\[(.*)\]/i,
            decimal: /^\d*(\.)\d+/,
            email: /^[a-z0-9!#$%&'*+\/=?^_`{|}~.-]+@[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/i,
            escape: /[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,
            flags: /^\/(.*)\/(.*)?/,
            integer: /^\-?\d+$/,
            number: /^\-?\d*(\.\d+)?$/,
            url: /(https?:\/\/(?:www\.|(?!www))[^\s\.]+\.[^\s]{2,}|www\.[^\s]+\.[^\s]{2,})/i
        },

        text: {
            unspecifiedRule: 'Please enter a valid value',
            unspecifiedField: 'This field'
        },

        prompt: {
            empty: '{name} must have a value',
            checked: '{name} must be checked',
            email: '{name} must be a valid e-mail',
            url: '{name} must be a valid url',
            regExp: '{name} is not formatted correctly',
            integer: '{name} must be an integer',
            decimal: '{name} must be a decimal number',
            number: '{name} must be set to a number',
            is: '{name} must be "{ruleValue}"',
            isExactly: '{name} must be exactly "{ruleValue}"',
            not: '{name} cannot be set to "{ruleValue}"',
            notExactly: '{name} cannot be set to exactly "{ruleValue}"',
            contain: '{name} cannot contain "{ruleValue}"',
            containExactly: '{name} cannot contain exactly "{ruleValue}"',
            doesntContain: '{name} must contain  "{ruleValue}"',
            doesntContainExactly: '{name} must contain exactly "{ruleValue}"',
            minLength: '{name} must be at least {ruleValue} characters',
            length: '{name} must be at least {ruleValue} characters',
            exactLength: '{name} must be exactly {ruleValue} characters',
            maxLength: '{name} cannot be longer than {ruleValue} characters',
            match: '{name} must match {ruleValue} field',
            different: '{name} must have a different value than {ruleValue} field',
            creditCard: '{name} must be a valid credit card number',
            minCount: '{name} must have at least {ruleValue} choices',
            exactCount: '{name} must have exactly {ruleValue} choices',
            maxCount: '{name} must have {ruleValue} or less choices'
        },

        selector: {
            checkbox: 'input[type="checkbox"], input[type="radio"]',
            clear: '.clear',
            field: 'input, textarea, select',
            group: '.field',
            input: 'input',
            message: '.error.message',
            prompt: '.prompt.label',
            radio: 'input[type="radio"]',
            reset: '.reset:not([type="reset"])',
            submit: '.submit:not([type="submit"])',
            uiCheckbox: '.ui.checkbox',
            uiDropdown: '.ui.dropdown'
        },

        className: {
            error: 'error',
            label: 'ui prompt label',
            pressed: 'down',
            success: 'success'
        },

        error: {
            identifier: 'You must specify a string identifier for each field',
            method: 'The method you called is not defined.',
            noRule: 'There is no rule matching the one you specified',
            oldSyntax: 'Starting in 2.0 forms now only take a single settings object. Validation settings converted to new syntax automatically.'
        },

        templates: {

            // template that produces error message
            error: function (errors) {
                var
                  html = '<ul class="list">'
                ;
                $.each(errors, function (index, value) {
                    html += '<li>' + value + '</li>';
                });
                html += '</ul>';
                return $(html);
            },

            // template that produces label
            prompt: function (errors) {
                return $('<div/>')
                  .addClass('ui basic red pointing prompt label')
                  .html(errors[0])
                ;
            }
        },

        rules: {

            // is not empty or blank string
            empty: function (value) {
                return !(value === undefined || '' === value || $.isArray(value) && value.length === 0);
            },

            // checkbox checked
            checked: function () {
                return ($(this).filter(':checked').length > 0);
            },

            // is most likely an email
            email: function (value) {
                return $.fn.form.settings.regExp.email.test(value);
            },

            // value is most likely url
            url: function (value) {
                return $.fn.form.settings.regExp.url.test(value);
            },

            // matches specified regExp
            regExp: function (value, regExp) {
                var
                  regExpParts = regExp.match($.fn.form.settings.regExp.flags),
                  flags
                ;
                // regular expression specified as /baz/gi (flags)
                if (regExpParts) {
                    regExp = (regExpParts.length >= 2)
                      ? regExpParts[1]
                      : regExp
                    ;
                    flags = (regExpParts.length >= 3)
                      ? regExpParts[2]
                      : ''
                    ;
                }
                return value.match(new RegExp(regExp, flags));
            },

            // is valid integer or matches range
            integer: function (value, range) {
                var
                  intRegExp = $.fn.form.settings.regExp.integer,
                  min,
                  max,
                  parts
                ;
                if (!range || ['', '..'].indexOf(range) !== -1) {
                    // do nothing
                }
                else if (range.indexOf('..') == -1) {
                    if (intRegExp.test(range)) {
                        min = max = range - 0;
                    }
                }
                else {
                    parts = range.split('..', 2);
                    if (intRegExp.test(parts[0])) {
                        min = parts[0] - 0;
                    }
                    if (intRegExp.test(parts[1])) {
                        max = parts[1] - 0;
                    }
                }
                return (
                  intRegExp.test(value) &&
                  (min === undefined || value >= min) &&
                  (max === undefined || value <= max)
                );
            },

            // is valid number (with decimal)
            decimal: function (value) {
                return $.fn.form.settings.regExp.decimal.test(value);
            },

            // is valid number
            number: function (value) {
                return $.fn.form.settings.regExp.number.test(value);
            },

            // is value (case insensitive)
            is: function (value, text) {
                text = (typeof text == 'string')
                  ? text.toLowerCase()
                  : text
                ;
                value = (typeof value == 'string')
                  ? value.toLowerCase()
                  : value
                ;
                return (value == text);
            },

            // is value
            isExactly: function (value, text) {
                return (value == text);
            },

            // value is not another value (case insensitive)
            not: function (value, notValue) {
                value = (typeof value == 'string')
                  ? value.toLowerCase()
                  : value
                ;
                notValue = (typeof notValue == 'string')
                  ? notValue.toLowerCase()
                  : notValue
                ;
                return (value != notValue);
            },

            // value is not another value (case sensitive)
            notExactly: function (value, notValue) {
                return (value != notValue);
            },

            // value contains text (insensitive)
            contains: function (value, text) {
                // escape regex characters
                text = text.replace($.fn.form.settings.regExp.escape, "\\$&");
                return (value.search(new RegExp(text, 'i')) !== -1);
            },

            // value contains text (case sensitive)
            containsExactly: function (value, text) {
                // escape regex characters
                text = text.replace($.fn.form.settings.regExp.escape, "\\$&");
                return (value.search(new RegExp(text)) !== -1);
            },

            // value contains text (insensitive)
            doesntContain: function (value, text) {
                // escape regex characters
                text = text.replace($.fn.form.settings.regExp.escape, "\\$&");
                return (value.search(new RegExp(text, 'i')) === -1);
            },

            // value contains text (case sensitive)
            doesntContainExactly: function (value, text) {
                // escape regex characters
                text = text.replace($.fn.form.settings.regExp.escape, "\\$&");
                return (value.search(new RegExp(text)) === -1);
            },

            // is at least string length
            minLength: function (value, requiredLength) {
                return (value !== undefined)
                  ? (value.length >= requiredLength)
                  : false
                ;
            },

            // see rls notes for 2.0.6 (this is a duplicate of minLength)
            length: function (value, requiredLength) {
                return (value !== undefined)
                  ? (value.length >= requiredLength)
                  : false
                ;
            },

            // is exactly length
            exactLength: function (value, requiredLength) {
                return (value !== undefined)
                  ? (value.length == requiredLength)
                  : false
                ;
            },

            // is less than length
            maxLength: function (value, maxLength) {
                return (value !== undefined)
                  ? (value.length <= maxLength)
                  : false
                ;
            },

            // matches another field
            match: function (value, identifier) {
                var
                  $form = $(this),
                  matchingValue
                ;
                if ($('[data-validate="' + identifier + '"]').length > 0) {
                    matchingValue = $('[data-validate="' + identifier + '"]').val();
                }
                else if ($('#' + identifier).length > 0) {
                    matchingValue = $('#' + identifier).val();
                }
                else if ($('[name="' + identifier + '"]').length > 0) {
                    matchingValue = $('[name="' + identifier + '"]').val();
                }
                else if ($('[name="' + identifier + '[]"]').length > 0) {
                    matchingValue = $('[name="' + identifier + '[]"]');
                }
                return (matchingValue !== undefined)
                  ? (value.toString() == matchingValue.toString())
                  : false
                ;
            },

            // different than another field
            different: function (value, identifier) {
                // use either id or name of field
                var
                  $form = $(this),
                  matchingValue
                ;
                if ($('[data-validate="' + identifier + '"]').length > 0) {
                    matchingValue = $('[data-validate="' + identifier + '"]').val();
                }
                else if ($('#' + identifier).length > 0) {
                    matchingValue = $('#' + identifier).val();
                }
                else if ($('[name="' + identifier + '"]').length > 0) {
                    matchingValue = $('[name="' + identifier + '"]').val();
                }
                else if ($('[name="' + identifier + '[]"]').length > 0) {
                    matchingValue = $('[name="' + identifier + '[]"]');
                }
                return (matchingValue !== undefined)
                  ? (value.toString() !== matchingValue.toString())
                  : false
                ;
            },

            creditCard: function (cardNumber, cardTypes) {
                var
                  cards = {
                      visa: {
                          pattern: /^4/,
                          length: [16]
                      },
                      amex: {
                          pattern: /^3[47]/,
                          length: [15]
                      },
                      mastercard: {
                          pattern: /^5[1-5]/,
                          length: [16]
                      },
                      discover: {
                          pattern: /^(6011|622(12[6-9]|1[3-9][0-9]|[2-8][0-9]{2}|9[0-1][0-9]|92[0-5]|64[4-9])|65)/,
                          length: [16]
                      },
                      unionPay: {
                          pattern: /^(62|88)/,
                          length: [16, 17, 18, 19]
                      },
                      jcb: {
                          pattern: /^35(2[89]|[3-8][0-9])/,
                          length: [16]
                      },
                      maestro: {
                          pattern: /^(5018|5020|5038|6304|6759|676[1-3])/,
                          length: [12, 13, 14, 15, 16, 17, 18, 19]
                      },
                      dinersClub: {
                          pattern: /^(30[0-5]|^36)/,
                          length: [14]
                      },
                      laser: {
                          pattern: /^(6304|670[69]|6771)/,
                          length: [16, 17, 18, 19]
                      },
                      visaElectron: {
                          pattern: /^(4026|417500|4508|4844|491(3|7))/,
                          length: [16]
                      }
                  },
                  valid = {},
                  validCard = false,
                  requiredTypes = (typeof cardTypes == 'string')
                    ? cardTypes.split(',')
                    : false,
                  unionPay,
                  validation
                ;

                if (typeof cardNumber !== 'string' || cardNumber.length === 0) {
                    return;
                }

                // verify card types
                if (requiredTypes) {
                    $.each(requiredTypes, function (index, type) {
                        // verify each card type
                        validation = cards[type];
                        if (validation) {
                            valid = {
                                length: ($.inArray(cardNumber.length, validation.length) !== -1),
                                pattern: (cardNumber.search(validation.pattern) !== -1)
                            };
                            if (valid.length && valid.pattern) {
                                validCard = true;
                            }
                        }
                    });

                    if (!validCard) {
                        return false;
                    }
                }

                // skip luhn for UnionPay
                unionPay = {
                    number: ($.inArray(cardNumber.length, cards.unionPay.length) !== -1),
                    pattern: (cardNumber.search(cards.unionPay.pattern) !== -1)
                };
                if (unionPay.number && unionPay.pattern) {
                    return true;
                }

                // verify luhn, adapted from  <https://gist.github.com/2134376>
                var
                  length = cardNumber.length,
                  multiple = 0,
                  producedValue = [
                    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
                    [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]
                  ],
                  sum = 0
                ;
                while (length--) {
                    sum += producedValue[multiple][parseInt(cardNumber.charAt(length), 10)];
                    multiple ^= 1;
                }
                return (sum % 10 === 0 && sum > 0);
            },

            minCount: function (value, minCount) {
                if (minCount == 0) {
                    return true;
                }
                if (minCount == 1) {
                    return (value !== '');
                }
                return (value.split(',').length >= minCount);
            },

            exactCount: function (value, exactCount) {
                if (exactCount == 0) {
                    return (value === '');
                }
                if (exactCount == 1) {
                    return (value !== '' && value.search(',') === -1);
                }
                return (value.split(',').length == exactCount);
            },

            maxCount: function (value, maxCount) {
                if (maxCount == 0) {
                    return false;
                }
                if (maxCount == 1) {
                    return (value.search(',') === -1);
                }
                return (value.split(',').length <= maxCount);
            }
        }

    };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Accordion
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.accordion = function (parameters) {
        var
          $allModules = $(this),

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          requestAnimationFrame = window.requestAnimationFrame
            || window.mozRequestAnimationFrame
            || window.webkitRequestAnimationFrame
            || window.msRequestAnimationFrame
            || function (callback) { setTimeout(callback, 0); },

          returnedValue
        ;
        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.accordion.settings, parameters)
                  : $.extend({}, $.fn.accordion.settings),

                className = settings.className,
                namespace = settings.namespace,
                selector = settings.selector,
                error = settings.error,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,
                moduleSelector = $allModules.selector || '',

                $module = $(this),
                $title = $module.find(selector.title),
                $content = $module.find(selector.content),

                element = this,
                instance = $module.data(moduleNamespace),
                observer,
                module
              ;

              module = {

                  initialize: function () {
                      module.debug('Initializing', $module);
                      module.bind.events();
                      if (settings.observeChanges) {
                          module.observeChanges();
                      }
                      module.instantiate();
                  },

                  instantiate: function () {
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },

                  destroy: function () {
                      module.debug('Destroying previous instance', $module);
                      $module
                        .off(eventNamespace)
                        .removeData(moduleNamespace)
                      ;
                  },

                  refresh: function () {
                      $title = $module.find(selector.title);
                      $content = $module.find(selector.content);
                  },

                  observeChanges: function () {
                      if ('MutationObserver' in window) {
                          observer = new MutationObserver(function (mutations) {
                              module.debug('DOM tree modified, updating selector cache');
                              module.refresh();
                          });
                          observer.observe(element, {
                              childList: true,
                              subtree: true
                          });
                          module.debug('Setting up mutation observer', observer);
                      }
                  },

                  bind: {
                      events: function () {
                          module.debug('Binding delegated events');
                          $module
                            .on(settings.on + eventNamespace, selector.trigger, module.event.click)
                          ;
                      }
                  },

                  event: {
                      click: function () {
                          module.toggle.call(this);
                      }
                  },

                  toggle: function (query) {
                      var
                        $activeTitle = (query !== undefined)
                          ? (typeof query === 'number')
                            ? $title.eq(query)
                            : $(query).closest(selector.title)
                          : $(this).closest(selector.title),
                        $activeContent = $activeTitle.next($content),
                        isAnimating = $activeContent.hasClass(className.animating),
                        isActive = $activeContent.hasClass(className.active),
                        isOpen = (isActive && !isAnimating),
                        isOpening = (!isActive && isAnimating)
                      ;
                      module.debug('Toggling visibility of content', $activeTitle);
                      if (isOpen || isOpening) {
                          if (settings.collapsible) {
                              module.close.call($activeTitle);
                          }
                          else {
                              module.debug('Cannot close accordion content collapsing is disabled');
                          }
                      }
                      else {
                          module.open.call($activeTitle);
                      }
                  },

                  open: function (query) {
                      var
                        $activeTitle = (query !== undefined)
                          ? (typeof query === 'number')
                            ? $title.eq(query)
                            : $(query).closest(selector.title)
                          : $(this).closest(selector.title),
                        $activeContent = $activeTitle.next($content),
                        isAnimating = $activeContent.hasClass(className.animating),
                        isActive = $activeContent.hasClass(className.active),
                        isOpen = (isActive || isAnimating)
                      ;
                      if (isOpen) {
                          module.debug('Accordion already open, skipping', $activeContent);
                          return;
                      }
                      module.debug('Opening accordion content', $activeTitle);
                      settings.onOpening.call($activeContent);
                      if (settings.exclusive) {
                          module.closeOthers.call($activeTitle);
                      }
                      $activeTitle
                        .addClass(className.active)
                      ;
                      $activeContent
                        .stop(true, true)
                        .addClass(className.animating)
                      ;
                      if (settings.animateChildren) {
                          if ($.fn.transition !== undefined && $module.transition('is supported')) {
                              $activeContent
                                .children()
                                  .transition({
                                      animation: 'fade in',
                                      queue: false,
                                      useFailSafe: true,
                                      debug: settings.debug,
                                      verbose: settings.verbose,
                                      duration: settings.duration
                                  })
                              ;
                          }
                          else {
                              $activeContent
                                .children()
                                  .stop(true, true)
                                  .animate({
                                      opacity: 1
                                  }, settings.duration, module.resetOpacity)
                              ;
                          }
                      }
                      $activeContent
                        .slideDown(settings.duration, settings.easing, function () {
                            $activeContent
                              .removeClass(className.animating)
                              .addClass(className.active)
                            ;
                            module.reset.display.call(this);
                            settings.onOpen.call(this);
                            settings.onChange.call(this);
                        })
                      ;
                  },

                  close: function (query) {
                      var
                        $activeTitle = (query !== undefined)
                          ? (typeof query === 'number')
                            ? $title.eq(query)
                            : $(query).closest(selector.title)
                          : $(this).closest(selector.title),
                        $activeContent = $activeTitle.next($content),
                        isAnimating = $activeContent.hasClass(className.animating),
                        isActive = $activeContent.hasClass(className.active),
                        isOpening = (!isActive && isAnimating),
                        isClosing = (isActive && isAnimating)
                      ;
                      if ((isActive || isOpening) && !isClosing) {
                          module.debug('Closing accordion content', $activeContent);
                          settings.onClosing.call($activeContent);
                          $activeTitle
                            .removeClass(className.active)
                          ;
                          $activeContent
                            .stop(true, true)
                            .addClass(className.animating)
                          ;
                          if (settings.animateChildren) {
                              if ($.fn.transition !== undefined && $module.transition('is supported')) {
                                  $activeContent
                                    .children()
                                      .transition({
                                          animation: 'fade out',
                                          queue: false,
                                          useFailSafe: true,
                                          debug: settings.debug,
                                          verbose: settings.verbose,
                                          duration: settings.duration
                                      })
                                  ;
                              }
                              else {
                                  $activeContent
                                    .children()
                                      .stop(true, true)
                                      .animate({
                                          opacity: 0
                                      }, settings.duration, module.resetOpacity)
                                  ;
                              }
                          }
                          $activeContent
                            .slideUp(settings.duration, settings.easing, function () {
                                $activeContent
                                  .removeClass(className.animating)
                                  .removeClass(className.active)
                                ;
                                module.reset.display.call(this);
                                settings.onClose.call(this);
                                settings.onChange.call(this);
                            })
                          ;
                      }
                  },

                  closeOthers: function (index) {
                      var
                        $activeTitle = (index !== undefined)
                          ? $title.eq(index)
                          : $(this).closest(selector.title),
                        $parentTitles = $activeTitle.parents(selector.content).prev(selector.title),
                        $activeAccordion = $activeTitle.closest(selector.accordion),
                        activeSelector = selector.title + '.' + className.active + ':visible',
                        activeContent = selector.content + '.' + className.active + ':visible',
                        $openTitles,
                        $nestedTitles,
                        $openContents
                      ;
                      if (settings.closeNested) {
                          $openTitles = $activeAccordion.find(activeSelector).not($parentTitles);
                          $openContents = $openTitles.next($content);
                      }
                      else {
                          $openTitles = $activeAccordion.find(activeSelector).not($parentTitles);
                          $nestedTitles = $activeAccordion.find(activeContent).find(activeSelector).not($parentTitles);
                          $openTitles = $openTitles.not($nestedTitles);
                          $openContents = $openTitles.next($content);
                      }
                      if (($openTitles.length > 0)) {
                          module.debug('Exclusive enabled, closing other content', $openTitles);
                          $openTitles
                            .removeClass(className.active)
                          ;
                          $openContents
                            .removeClass(className.animating)
                            .stop(true, true)
                          ;
                          if (settings.animateChildren) {
                              if ($.fn.transition !== undefined && $module.transition('is supported')) {
                                  $openContents
                                    .children()
                                      .transition({
                                          animation: 'fade out',
                                          useFailSafe: true,
                                          debug: settings.debug,
                                          verbose: settings.verbose,
                                          duration: settings.duration
                                      })
                                  ;
                              }
                              else {
                                  $openContents
                                    .children()
                                      .stop(true, true)
                                      .animate({
                                          opacity: 0
                                      }, settings.duration, module.resetOpacity)
                                  ;
                              }
                          }
                          $openContents
                            .slideUp(settings.duration, settings.easing, function () {
                                $(this).removeClass(className.active);
                                module.reset.display.call(this);
                            })
                          ;
                      }
                  },

                  reset: {

                      display: function () {
                          module.verbose('Removing inline display from element', this);
                          $(this).css('display', '');
                          if ($(this).attr('style') === '') {
                              $(this)
                                .attr('style', '')
                                .removeAttr('style')
                              ;
                          }
                      },

                      opacity: function () {
                          module.verbose('Removing inline opacity from element', this);
                          $(this).css('opacity', '');
                          if ($(this).attr('style') === '') {
                              $(this)
                                .attr('style', '')
                                .removeAttr('style')
                              ;
                          }
                      },

                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      module.debug('Changing internal', name, value);
                      if (value !== undefined) {
                          if ($.isPlainObject(name)) {
                              $.extend(true, module, name);
                          }
                          else {
                              module[name] = value;
                          }
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };
              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;
        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.accordion.settings = {

        name: 'Accordion',
        namespace: 'accordion',

        silent: false,
        debug: false,
        verbose: false,
        performance: true,

        on: 'click', // event on title that opens accordion

        observeChanges: true,  // whether accordion should automatically refresh on DOM insertion

        exclusive: true,  // whether a single accordion content panel should be open at once
        collapsible: true,  // whether accordion content can be closed
        closeNested: false, // whether nested content should be closed when a panel is closed
        animateChildren: true,  // whether children opacity should be animated

        duration: 350, // duration of animation
        easing: 'easeOutQuad', // easing equation for animation


        onOpening: function () { }, // callback before open animation
        onOpen: function () { }, // callback after open animation
        onClosing: function () { }, // callback before closing animation
        onClose: function () { }, // callback after closing animation
        onChange: function () { }, // callback after closing or opening animation

        error: {
            method: 'The method you called is not defined'
        },

        className: {
            active: 'active',
            animating: 'animating'
        },

        selector: {
            accordion: '.accordion',
            title: '.title',
            trigger: '.title',
            content: '.content'
        }

    };

    // Adds easing
    $.extend($.easing, {
        easeOutQuad: function (x, t, b, c, d) {
            return -c * (t /= d) * (t - 2) + b;
        }
    });

})(jQuery, window, document);


/*!
 * # Semantic UI 2.2.2 - Checkbox
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.checkbox = function (parameters) {
        var
          $allModules = $(this),
          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),
          returnedValue
        ;

        $allModules
          .each(function () {
              var
                settings = $.extend(true, {}, $.fn.checkbox.settings, parameters),

                className = settings.className,
                namespace = settings.namespace,
                selector = settings.selector,
                error = settings.error,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                $module = $(this),
                $label = $(this).children(selector.label),
                $input = $(this).children(selector.input),
                input = $input[0],

                initialLoad = false,
                shortcutPressed = false,
                instance = $module.data(moduleNamespace),

                observer,
                element = this,
                module
              ;

              module = {

                  initialize: function () {
                      module.verbose('Initializing checkbox', settings);

                      module.create.label();
                      module.bind.events();

                      module.set.tabbable();
                      module.hide.input();

                      module.observeChanges();
                      module.instantiate();
                      module.setup();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying module');
                      module.unbind.events();
                      module.show.input();
                      $module.removeData(moduleNamespace);
                  },

                  fix: {
                      reference: function () {
                          if ($module.is(selector.input)) {
                              module.debug('Behavior called on <input> adjusting invoked element');
                              $module = $module.closest(selector.checkbox);
                              module.refresh();
                          }
                      }
                  },

                  setup: function () {
                      module.set.initialLoad();
                      if (module.is.indeterminate()) {
                          module.debug('Initial value is indeterminate');
                          module.indeterminate();
                      }
                      else if (module.is.checked()) {
                          module.debug('Initial value is checked');
                          module.check();
                      }
                      else {
                          module.debug('Initial value is unchecked');
                          module.uncheck();
                      }
                      module.remove.initialLoad();
                  },

                  refresh: function () {
                      $label = $module.children(selector.label);
                      $input = $module.children(selector.input);
                      input = $input[0];
                  },

                  hide: {
                      input: function () {
                          module.verbose('Modifying <input> z-index to be unselectable');
                          $input.addClass(className.hidden);
                      }
                  },
                  show: {
                      input: function () {
                          module.verbose('Modifying <input> z-index to be selectable');
                          $input.removeClass(className.hidden);
                      }
                  },

                  observeChanges: function () {
                      if ('MutationObserver' in window) {
                          observer = new MutationObserver(function (mutations) {
                              module.debug('DOM tree modified, updating selector cache');
                              module.refresh();
                          });
                          observer.observe(element, {
                              childList: true,
                              subtree: true
                          });
                          module.debug('Setting up mutation observer', observer);
                      }
                  },

                  attachEvents: function (selector, event) {
                      var
                        $element = $(selector)
                      ;
                      event = $.isFunction(module[event])
                        ? module[event]
                        : module.toggle
                      ;
                      if ($element.length > 0) {
                          module.debug('Attaching checkbox events to element', selector, event);
                          $element
                            .on('click' + eventNamespace, event)
                          ;
                      }
                      else {
                          module.error(error.notFound);
                      }
                  },

                  event: {
                      click: function (event) {
                          var
                            $target = $(event.target)
                          ;
                          if ($target.is(selector.input)) {
                              module.verbose('Using default check action on initialized checkbox');
                              return;
                          }
                          if ($target.is(selector.link)) {
                              module.debug('Clicking link inside checkbox, skipping toggle');
                              return;
                          }
                          module.toggle();
                          $input.focus();
                          event.preventDefault();
                      },
                      keydown: function (event) {
                          var
                            key = event.which,
                            keyCode = {
                                enter: 13,
                                space: 32,
                                escape: 27
                            }
                          ;
                          if (key == keyCode.escape) {
                              module.verbose('Escape key pressed blurring field');
                              $input.blur();
                              shortcutPressed = true;
                          }
                          else if (!event.ctrlKey && (key == keyCode.space || key == keyCode.enter)) {
                              module.verbose('Enter/space key pressed, toggling checkbox');
                              module.toggle();
                              shortcutPressed = true;
                          }
                          else {
                              shortcutPressed = false;
                          }
                      },
                      keyup: function (event) {
                          if (shortcutPressed) {
                              event.preventDefault();
                          }
                      }
                  },

                  check: function () {
                      if (!module.should.allowCheck()) {
                          return;
                      }
                      module.debug('Checking checkbox', $input);
                      module.set.checked();
                      if (!module.should.ignoreCallbacks()) {
                          settings.onChecked.call(input);
                          settings.onChange.call(input);
                      }
                  },

                  uncheck: function () {
                      if (!module.should.allowUncheck()) {
                          return;
                      }
                      module.debug('Unchecking checkbox');
                      module.set.unchecked();
                      if (!module.should.ignoreCallbacks()) {
                          settings.onUnchecked.call(input);
                          settings.onChange.call(input);
                      }
                  },

                  indeterminate: function () {
                      if (module.should.allowIndeterminate()) {
                          module.debug('Checkbox is already indeterminate');
                          return;
                      }
                      module.debug('Making checkbox indeterminate');
                      module.set.indeterminate();
                      if (!module.should.ignoreCallbacks()) {
                          settings.onIndeterminate.call(input);
                          settings.onChange.call(input);
                      }
                  },

                  determinate: function () {
                      if (module.should.allowDeterminate()) {
                          module.debug('Checkbox is already determinate');
                          return;
                      }
                      module.debug('Making checkbox determinate');
                      module.set.determinate();
                      if (!module.should.ignoreCallbacks()) {
                          settings.onDeterminate.call(input);
                          settings.onChange.call(input);
                      }
                  },

                  enable: function () {
                      if (module.is.enabled()) {
                          module.debug('Checkbox is already enabled');
                          return;
                      }
                      module.debug('Enabling checkbox');
                      module.set.enabled();
                      settings.onEnable.call(input);
                      // preserve legacy callbacks
                      settings.onEnabled.call(input);
                  },

                  disable: function () {
                      if (module.is.disabled()) {
                          module.debug('Checkbox is already disabled');
                          return;
                      }
                      module.debug('Disabling checkbox');
                      module.set.disabled();
                      settings.onDisable.call(input);
                      // preserve legacy callbacks
                      settings.onDisabled.call(input);
                  },

                  get: {
                      radios: function () {
                          var
                            name = module.get.name()
                          ;
                          return $('input[name="' + name + '"]').closest(selector.checkbox);
                      },
                      otherRadios: function () {
                          return module.get.radios().not($module);
                      },
                      name: function () {
                          return $input.attr('name');
                      }
                  },

                  is: {
                      initialLoad: function () {
                          return initialLoad;
                      },
                      radio: function () {
                          return ($input.hasClass(className.radio) || $input.attr('type') == 'radio');
                      },
                      indeterminate: function () {
                          return $input.prop('indeterminate') !== undefined && $input.prop('indeterminate');
                      },
                      checked: function () {
                          return $input.prop('checked') !== undefined && $input.prop('checked');
                      },
                      disabled: function () {
                          return $input.prop('disabled') !== undefined && $input.prop('disabled');
                      },
                      enabled: function () {
                          return !module.is.disabled();
                      },
                      determinate: function () {
                          return !module.is.indeterminate();
                      },
                      unchecked: function () {
                          return !module.is.checked();
                      }
                  },

                  should: {
                      allowCheck: function () {
                          if (module.is.determinate() && module.is.checked() && !module.should.forceCallbacks()) {
                              module.debug('Should not allow check, checkbox is already checked');
                              return false;
                          }
                          if (settings.beforeChecked.apply(input) === false) {
                              module.debug('Should not allow check, beforeChecked cancelled');
                              return false;
                          }
                          return true;
                      },
                      allowUncheck: function () {
                          if (module.is.determinate() && module.is.unchecked() && !module.should.forceCallbacks()) {
                              module.debug('Should not allow uncheck, checkbox is already unchecked');
                              return false;
                          }
                          if (settings.beforeUnchecked.apply(input) === false) {
                              module.debug('Should not allow uncheck, beforeUnchecked cancelled');
                              return false;
                          }
                          return true;
                      },
                      allowIndeterminate: function () {
                          if (module.is.indeterminate() && !module.should.forceCallbacks()) {
                              module.debug('Should not allow indeterminate, checkbox is already indeterminate');
                              return false;
                          }
                          if (settings.beforeIndeterminate.apply(input) === false) {
                              module.debug('Should not allow indeterminate, beforeIndeterminate cancelled');
                              return false;
                          }
                          return true;
                      },
                      allowDeterminate: function () {
                          if (module.is.determinate() && !module.should.forceCallbacks()) {
                              module.debug('Should not allow determinate, checkbox is already determinate');
                              return false;
                          }
                          if (settings.beforeDeterminate.apply(input) === false) {
                              module.debug('Should not allow determinate, beforeDeterminate cancelled');
                              return false;
                          }
                          return true;
                      },
                      forceCallbacks: function () {
                          return (module.is.initialLoad() && settings.fireOnInit);
                      },
                      ignoreCallbacks: function () {
                          return (initialLoad && !settings.fireOnInit);
                      }
                  },

                  can: {
                      change: function () {
                          return !($module.hasClass(className.disabled) || $module.hasClass(className.readOnly) || $input.prop('disabled') || $input.prop('readonly'));
                      },
                      uncheck: function () {
                          return (typeof settings.uncheckable === 'boolean')
                            ? settings.uncheckable
                            : !module.is.radio()
                          ;
                      }
                  },

                  set: {
                      initialLoad: function () {
                          initialLoad = true;
                      },
                      checked: function () {
                          module.verbose('Setting class to checked');
                          $module
                            .removeClass(className.indeterminate)
                            .addClass(className.checked)
                          ;
                          if (module.is.radio()) {
                              module.uncheckOthers();
                          }
                          if (!module.is.indeterminate() && module.is.checked()) {
                              module.debug('Input is already checked, skipping input property change');
                              return;
                          }
                          module.verbose('Setting state to checked', input);
                          $input
                            .prop('indeterminate', false)
                            .prop('checked', true)
                          ;
                          module.trigger.change();
                      },
                      unchecked: function () {
                          module.verbose('Removing checked class');
                          $module
                            .removeClass(className.indeterminate)
                            .removeClass(className.checked)
                          ;
                          if (!module.is.indeterminate() && module.is.unchecked()) {
                              module.debug('Input is already unchecked');
                              return;
                          }
                          module.debug('Setting state to unchecked');
                          $input
                            .prop('indeterminate', false)
                            .prop('checked', false)
                          ;
                          module.trigger.change();
                      },
                      indeterminate: function () {
                          module.verbose('Setting class to indeterminate');
                          $module
                            .addClass(className.indeterminate)
                          ;
                          if (module.is.indeterminate()) {
                              module.debug('Input is already indeterminate, skipping input property change');
                              return;
                          }
                          module.debug('Setting state to indeterminate');
                          $input
                            .prop('indeterminate', true)
                          ;
                          module.trigger.change();
                      },
                      determinate: function () {
                          module.verbose('Removing indeterminate class');
                          $module
                            .removeClass(className.indeterminate)
                          ;
                          if (module.is.determinate()) {
                              module.debug('Input is already determinate, skipping input property change');
                              return;
                          }
                          module.debug('Setting state to determinate');
                          $input
                            .prop('indeterminate', false)
                          ;
                      },
                      disabled: function () {
                          module.verbose('Setting class to disabled');
                          $module
                            .addClass(className.disabled)
                          ;
                          if (module.is.disabled()) {
                              module.debug('Input is already disabled, skipping input property change');
                              return;
                          }
                          module.debug('Setting state to disabled');
                          $input
                            .prop('disabled', 'disabled')
                          ;
                          module.trigger.change();
                      },
                      enabled: function () {
                          module.verbose('Removing disabled class');
                          $module.removeClass(className.disabled);
                          if (module.is.enabled()) {
                              module.debug('Input is already enabled, skipping input property change');
                              return;
                          }
                          module.debug('Setting state to enabled');
                          $input
                            .prop('disabled', false)
                          ;
                          module.trigger.change();
                      },
                      tabbable: function () {
                          module.verbose('Adding tabindex to checkbox');
                          if ($input.attr('tabindex') === undefined) {
                              $input.attr('tabindex', 0);
                          }
                      }
                  },

                  remove: {
                      initialLoad: function () {
                          initialLoad = false;
                      }
                  },

                  trigger: {
                      change: function () {
                          var
                            events = document.createEvent('HTMLEvents'),
                            inputElement = $input[0]
                          ;
                          if (inputElement) {
                              module.verbose('Triggering native change event');
                              events.initEvent('change', true, false);
                              inputElement.dispatchEvent(events);
                          }
                      }
                  },


                  create: {
                      label: function () {
                          if ($input.prevAll(selector.label).length > 0) {
                              $input.prev(selector.label).detach().insertAfter($input);
                              module.debug('Moving existing label', $label);
                          }
                          else if (!module.has.label()) {
                              $label = $('<label>').insertAfter($input);
                              module.debug('Creating label', $label);
                          }
                      }
                  },

                  has: {
                      label: function () {
                          return ($label.length > 0);
                      }
                  },

                  bind: {
                      events: function () {
                          module.verbose('Attaching checkbox events');
                          $module
                            .on('click' + eventNamespace, module.event.click)
                            .on('keydown' + eventNamespace, selector.input, module.event.keydown)
                            .on('keyup' + eventNamespace, selector.input, module.event.keyup)
                          ;
                      }
                  },

                  unbind: {
                      events: function () {
                          module.debug('Removing events');
                          $module
                            .off(eventNamespace)
                          ;
                      }
                  },

                  uncheckOthers: function () {
                      var
                        $radios = module.get.otherRadios()
                      ;
                      module.debug('Unchecking other radios', $radios);
                      $radios.removeClass(className.checked);
                  },

                  toggle: function () {
                      if (!module.can.change()) {
                          if (!module.is.radio()) {
                              module.debug('Checkbox is read-only or disabled, ignoring toggle');
                          }
                          return;
                      }
                      if (module.is.indeterminate() || module.is.unchecked()) {
                          module.debug('Currently unchecked');
                          module.check();
                      }
                      else if (module.is.checked() && module.can.uncheck()) {
                          module.debug('Currently checked');
                          module.uncheck();
                      }
                  },
                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.checkbox.settings = {

        name: 'Checkbox',
        namespace: 'checkbox',

        silent: false,
        debug: false,
        verbose: true,
        performance: true,

        // delegated event context
        uncheckable: 'auto',
        fireOnInit: false,

        onChange: function () { },

        beforeChecked: function () { },
        beforeUnchecked: function () { },
        beforeDeterminate: function () { },
        beforeIndeterminate: function () { },

        onChecked: function () { },
        onUnchecked: function () { },

        onDeterminate: function () { },
        onIndeterminate: function () { },

        onEnable: function () { },
        onDisable: function () { },

        // preserve misspelled callbacks (will be removed in 3.0)
        onEnabled: function () { },
        onDisabled: function () { },

        className: {
            checked: 'checked',
            indeterminate: 'indeterminate',
            disabled: 'disabled',
            hidden: 'hidden',
            radio: 'radio',
            readOnly: 'read-only'
        },

        error: {
            method: 'The method you called is not defined'
        },

        selector: {
            checkbox: '.ui.checkbox',
            label: 'label, .box',
            input: 'input[type="checkbox"], input[type="radio"]',
            link: 'a[href]'
        }

    };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Dimmer
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.dimmer = function (parameters) {
        var
          $allModules = $(this),

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          returnedValue
        ;

        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.dimmer.settings, parameters)
                  : $.extend({}, $.fn.dimmer.settings),

                selector = settings.selector,
                namespace = settings.namespace,
                className = settings.className,
                error = settings.error,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,
                moduleSelector = $allModules.selector || '',

                clickEvent = ('ontouchstart' in document.documentElement)
                  ? 'touchstart'
                  : 'click',

                $module = $(this),
                $dimmer,
                $dimmable,

                element = this,
                instance = $module.data(moduleNamespace),
                module
              ;

              module = {

                  preinitialize: function () {
                      if (module.is.dimmer()) {

                          $dimmable = $module.parent();
                          $dimmer = $module;
                      }
                      else {
                          $dimmable = $module;
                          if (module.has.dimmer()) {
                              if (settings.dimmerName) {
                                  $dimmer = $dimmable.find(selector.dimmer).filter('.' + settings.dimmerName);
                              }
                              else {
                                  $dimmer = $dimmable.find(selector.dimmer);
                              }
                          }
                          else {
                              $dimmer = module.create();
                          }
                          module.set.variation();
                      }
                  },

                  initialize: function () {
                      module.debug('Initializing dimmer', settings);

                      module.bind.events();
                      module.set.dimmable();
                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, instance)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous module', $dimmer);
                      module.unbind.events();
                      module.remove.variation();
                      $dimmable
                        .off(eventNamespace)
                      ;
                  },

                  bind: {
                      events: function () {
                          if (settings.on == 'hover') {
                              $dimmable
                                .on('mouseenter' + eventNamespace, module.show)
                                .on('mouseleave' + eventNamespace, module.hide)
                              ;
                          }
                          else if (settings.on == 'click') {
                              $dimmable
                                .on(clickEvent + eventNamespace, module.toggle)
                              ;
                          }
                          if (module.is.page()) {
                              module.debug('Setting as a page dimmer', $dimmable);
                              module.set.pageDimmer();
                          }

                          if (module.is.closable()) {
                              module.verbose('Adding dimmer close event', $dimmer);
                              $dimmable
                                .on(clickEvent + eventNamespace, selector.dimmer, module.event.click)
                              ;
                          }
                      }
                  },

                  unbind: {
                      events: function () {
                          $module
                            .removeData(moduleNamespace)
                          ;
                          $dimmable
                            .off(eventNamespace)
                          ;
                      }
                  },

                  event: {
                      click: function (event) {
                          module.verbose('Determining if event occured on dimmer', event);
                          if ($dimmer.find(event.target).length === 0 || $(event.target).is(selector.content)) {
                              module.hide();
                              event.stopImmediatePropagation();
                          }
                      }
                  },

                  addContent: function (element) {
                      var
                        $content = $(element)
                      ;
                      module.debug('Add content to dimmer', $content);
                      if ($content.parent()[0] !== $dimmer[0]) {
                          $content.detach().appendTo($dimmer);
                      }
                  },

                  create: function () {
                      var
                        $element = $(settings.template.dimmer())
                      ;
                      if (settings.dimmerName) {
                          module.debug('Creating named dimmer', settings.dimmerName);
                          $element.addClass(settings.dimmerName);
                      }
                      $element
                        .appendTo($dimmable)
                      ;
                      return $element;
                  },

                  show: function (callback) {
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      module.debug('Showing dimmer', $dimmer, settings);
                      if ((!module.is.dimmed() || module.is.animating()) && module.is.enabled()) {
                          module.animate.show(callback);
                          settings.onShow.call(element);
                          settings.onChange.call(element);
                      }
                      else {
                          module.debug('Dimmer is already shown or disabled');
                      }
                  },

                  hide: function (callback) {
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      if (module.is.dimmed() || module.is.animating()) {
                          module.debug('Hiding dimmer', $dimmer);
                          module.animate.hide(callback);
                          settings.onHide.call(element);
                          settings.onChange.call(element);
                      }
                      else {
                          module.debug('Dimmer is not visible');
                      }
                  },

                  toggle: function () {
                      module.verbose('Toggling dimmer visibility', $dimmer);
                      if (!module.is.dimmed()) {
                          module.show();
                      }
                      else {
                          module.hide();
                      }
                  },

                  animate: {
                      show: function (callback) {
                          callback = $.isFunction(callback)
                            ? callback
                            : function () { }
                          ;
                          if (settings.useCSS && $.fn.transition !== undefined && $dimmer.transition('is supported')) {
                              if (settings.opacity !== 'auto') {
                                  module.set.opacity();
                              }
                              $dimmer
                                .transition({
                                    animation: settings.transition + ' in',
                                    queue: false,
                                    duration: module.get.duration(),
                                    useFailSafe: true,
                                    onStart: function () {
                                        module.set.dimmed();
                                    },
                                    onComplete: function () {
                                        module.set.active();
                                        callback();
                                    }
                                })
                              ;
                          }
                          else {
                              module.verbose('Showing dimmer animation with javascript');
                              module.set.dimmed();
                              if (settings.opacity == 'auto') {
                                  settings.opacity = 0.8;
                              }
                              $dimmer
                                .stop()
                                .css({
                                    opacity: 0,
                                    width: '100%',
                                    height: '100%'
                                })
                                .fadeTo(module.get.duration(), settings.opacity, function () {
                                    $dimmer.removeAttr('style');
                                    module.set.active();
                                    callback();
                                })
                              ;
                          }
                      },
                      hide: function (callback) {
                          callback = $.isFunction(callback)
                            ? callback
                            : function () { }
                          ;
                          if (settings.useCSS && $.fn.transition !== undefined && $dimmer.transition('is supported')) {
                              module.verbose('Hiding dimmer with css');
                              $dimmer
                                .transition({
                                    animation: settings.transition + ' out',
                                    queue: false,
                                    duration: module.get.duration(),
                                    useFailSafe: true,
                                    onStart: function () {
                                        module.remove.dimmed();
                                    },
                                    onComplete: function () {
                                        module.remove.active();
                                        callback();
                                    }
                                })
                              ;
                          }
                          else {
                              module.verbose('Hiding dimmer with javascript');
                              module.remove.dimmed();
                              $dimmer
                                .stop()
                                .fadeOut(module.get.duration(), function () {
                                    module.remove.active();
                                    $dimmer.removeAttr('style');
                                    callback();
                                })
                              ;
                          }
                      }
                  },

                  get: {
                      dimmer: function () {
                          return $dimmer;
                      },
                      duration: function () {
                          if (typeof settings.duration == 'object') {
                              if (module.is.active()) {
                                  return settings.duration.hide;
                              }
                              else {
                                  return settings.duration.show;
                              }
                          }
                          return settings.duration;
                      }
                  },

                  has: {
                      dimmer: function () {
                          if (settings.dimmerName) {
                              return ($module.find(selector.dimmer).filter('.' + settings.dimmerName).length > 0);
                          }
                          else {
                              return ($module.find(selector.dimmer).length > 0);
                          }
                      }
                  },

                  is: {
                      active: function () {
                          return $dimmer.hasClass(className.active);
                      },
                      animating: function () {
                          return ($dimmer.is(':animated') || $dimmer.hasClass(className.animating));
                      },
                      closable: function () {
                          if (settings.closable == 'auto') {
                              if (settings.on == 'hover') {
                                  return false;
                              }
                              return true;
                          }
                          return settings.closable;
                      },
                      dimmer: function () {
                          return $module.hasClass(className.dimmer);
                      },
                      dimmable: function () {
                          return $module.hasClass(className.dimmable);
                      },
                      dimmed: function () {
                          return $dimmable.hasClass(className.dimmed);
                      },
                      disabled: function () {
                          return $dimmable.hasClass(className.disabled);
                      },
                      enabled: function () {
                          return !module.is.disabled();
                      },
                      page: function () {
                          return $dimmable.is('body');
                      },
                      pageDimmer: function () {
                          return $dimmer.hasClass(className.pageDimmer);
                      }
                  },

                  can: {
                      show: function () {
                          return !$dimmer.hasClass(className.disabled);
                      }
                  },

                  set: {
                      opacity: function (opacity) {
                          var
                            color = $dimmer.css('background-color'),
                            colorArray = color.split(','),
                            isRGB = (colorArray && colorArray.length == 3),
                            isRGBA = (colorArray && colorArray.length == 4)
                          ;
                          opacity = settings.opacity === 0 ? 0 : settings.opacity || opacity;
                          if (isRGB || isRGBA) {
                              colorArray[3] = opacity + ')';
                              color = colorArray.join(',');
                          }
                          else {
                              color = 'rgba(0, 0, 0, ' + opacity + ')';
                          }
                          module.debug('Setting opacity to', opacity);
                          $dimmer.css('background-color', color);
                      },
                      active: function () {
                          $dimmer.addClass(className.active);
                      },
                      dimmable: function () {
                          $dimmable.addClass(className.dimmable);
                      },
                      dimmed: function () {
                          $dimmable.addClass(className.dimmed);
                      },
                      pageDimmer: function () {
                          $dimmer.addClass(className.pageDimmer);
                      },
                      disabled: function () {
                          $dimmer.addClass(className.disabled);
                      },
                      variation: function (variation) {
                          variation = variation || settings.variation;
                          if (variation) {
                              $dimmer.addClass(variation);
                          }
                      }
                  },

                  remove: {
                      active: function () {
                          $dimmer
                            .removeClass(className.active)
                          ;
                      },
                      dimmed: function () {
                          $dimmable.removeClass(className.dimmed);
                      },
                      disabled: function () {
                          $dimmer.removeClass(className.disabled);
                      },
                      variation: function (variation) {
                          variation = variation || settings.variation;
                          if (variation) {
                              $dimmer.removeClass(variation);
                          }
                      }
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ($allModules.length > 1) {
                              title += ' ' + '(' + $allModules.length + ')';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              module.preinitialize();

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.dimmer.settings = {

        name: 'Dimmer',
        namespace: 'dimmer',

        silent: false,
        debug: false,
        verbose: false,
        performance: true,

        // name to distinguish between multiple dimmers in context
        dimmerName: false,

        // whether to add a variation type
        variation: false,

        // whether to bind close events
        closable: 'auto',

        // whether to use css animations
        useCSS: true,

        // css animation to use
        transition: 'fade',

        // event to bind to
        on: false,

        // overriding opacity value
        opacity: 'auto',

        // transition durations
        duration: {
            show: 500,
            hide: 500
        },

        onChange: function () { },
        onShow: function () { },
        onHide: function () { },

        error: {
            method: 'The method you called is not defined.'
        },

        className: {
            active: 'active',
            animating: 'animating',
            dimmable: 'dimmable',
            dimmed: 'dimmed',
            dimmer: 'dimmer',
            disabled: 'disabled',
            hide: 'hide',
            pageDimmer: 'page',
            show: 'show'
        },

        selector: {
            dimmer: '> .ui.dimmer',
            content: '.ui.dimmer > .content, .ui.dimmer > .content > .center'
        },

        template: {
            dimmer: function () {
                return $('<div />').attr('class', 'ui dimmer');
            }
        }

    };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Dropdown
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.dropdown = function (parameters) {
        var
          $allModules = $(this),
          $document = $(document),

          moduleSelector = $allModules.selector || '',

          hasTouch = ('ontouchstart' in document.documentElement),
          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),
          returnedValue
        ;

        $allModules
          .each(function (elementIndex) {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.dropdown.settings, parameters)
                  : $.extend({}, $.fn.dropdown.settings),

                className = settings.className,
                message = settings.message,
                fields = settings.fields,
                keys = settings.keys,
                metadata = settings.metadata,
                namespace = settings.namespace,
                regExp = settings.regExp,
                selector = settings.selector,
                error = settings.error,
                templates = settings.templates,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                $module = $(this),
                $context = $(settings.context),
                $text = $module.find(selector.text),
                $search = $module.find(selector.search),
                $sizer = $module.find(selector.sizer),
                $input = $module.find(selector.input),
                $icon = $module.find(selector.icon),

                $combo = ($module.prev().find(selector.text).length > 0)
                  ? $module.prev().find(selector.text)
                  : $module.prev(),

                $menu = $module.children(selector.menu),
                $item = $menu.find(selector.item),

                activated = false,
                itemActivated = false,
                internalChange = false,
                element = this,
                instance = $module.data(moduleNamespace),

                initialLoad,
                pageLostFocus,
                willRefocus,
                elementNamespace,
                id,
                selectObserver,
                menuObserver,
                module
              ;

              module = {

                  initialize: function () {
                      module.debug('Initializing dropdown', settings);

                      if (module.is.alreadySetup()) {
                          module.setup.reference();
                      }
                      else {
                          module.setup.layout();
                          module.refreshData();

                          module.save.defaults();
                          module.restore.selected();

                          module.create.id();
                          module.bind.events();

                          module.observeChanges();
                          module.instantiate();
                      }

                  },

                  instantiate: function () {
                      module.verbose('Storing instance of dropdown', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous dropdown', $module);
                      module.remove.tabbable();
                      $module
                        .off(eventNamespace)
                        .removeData(moduleNamespace)
                      ;
                      $menu
                        .off(eventNamespace)
                      ;
                      $document
                        .off(elementNamespace)
                      ;
                      module.disconnect.menuObserver();
                      module.disconnect.selectObserver();
                  },

                  observeChanges: function () {
                      if ('MutationObserver' in window) {
                          selectObserver = new MutationObserver(module.event.select.mutation);
                          menuObserver = new MutationObserver(module.event.menu.mutation);
                          module.debug('Setting up mutation observer', selectObserver, menuObserver);
                          module.observe.select();
                          module.observe.menu();
                      }
                  },

                  disconnect: {
                      menuObserver: function () {
                          if (menuObserver) {
                              menuObserver.disconnect();
                          }
                      },
                      selectObserver: function () {
                          if (menuObserver) {
                              menuObserver.disconnect();
                          }
                      }
                  },
                  observe: {
                      select: function () {
                          if (module.has.input()) {
                              selectObserver.observe($input[0], {
                                  childList: true,
                                  subtree: true
                              });
                          }
                      },
                      menu: function () {
                          if (module.has.menu()) {
                              menuObserver.observe($menu[0], {
                                  childList: true,
                                  subtree: true
                              });
                          }
                      }
                  },

                  create: {
                      id: function () {
                          id = (Math.random().toString(16) + '000000000').substr(2, 8);
                          elementNamespace = '.' + id;
                          module.verbose('Creating unique id for element', id);
                      },
                      userChoice: function (values) {
                          var
                            $userChoices,
                            $userChoice,
                            isUserValue,
                            html
                          ;
                          values = values || module.get.userValues();
                          if (!values) {
                              return false;
                          }
                          values = $.isArray(values)
                            ? values
                            : [values]
                          ;
                          $.each(values, function (index, value) {
                              if (module.get.item(value) === false) {
                                  html = settings.templates.addition(module.add.variables(message.addResult, value));
                                  $userChoice = $('<div />')
                                    .html(html)
                                    .attr('data-' + metadata.value, value)
                                    .attr('data-' + metadata.text, value)
                                    .addClass(className.addition)
                                    .addClass(className.item)
                                  ;
                                  if (settings.hideAdditions) {
                                      $userChoice.addClass(className.hidden);
                                  }
                                  $userChoices = ($userChoices === undefined)
                                    ? $userChoice
                                    : $userChoices.add($userChoice)
                                  ;
                                  module.verbose('Creating user choices for value', value, $userChoice);
                              }
                          });
                          return $userChoices;
                      },
                      userLabels: function (value) {
                          var
                            userValues = module.get.userValues()
                          ;
                          if (userValues) {
                              module.debug('Adding user labels', userValues);
                              $.each(userValues, function (index, value) {
                                  module.verbose('Adding custom user value');
                                  module.add.label(value, value);
                              });
                          }
                      },
                      menu: function () {
                          $menu = $('<div />')
                            .addClass(className.menu)
                            .appendTo($module)
                          ;
                      },
                      sizer: function () {
                          $sizer = $('<span />')
                            .addClass(className.sizer)
                            .insertAfter($search)
                          ;
                      }
                  },

                  search: function (query) {
                      query = (query !== undefined)
                        ? query
                        : module.get.query()
                      ;
                      module.verbose('Searching for query', query);
                      if (module.has.minCharacters(query)) {
                          module.filter(query);
                      }
                      else {
                          module.hide();
                      }
                  },

                  select: {
                      firstUnfiltered: function () {
                          module.verbose('Selecting first non-filtered element');
                          module.remove.selectedItem();
                          $item
                            .not(selector.unselectable)
                            .not(selector.addition + selector.hidden)
                              .eq(0)
                              .addClass(className.selected)
                          ;
                      },
                      nextAvailable: function ($selected) {
                          $selected = $selected.eq(0);
                          var
                            $nextAvailable = $selected.nextAll(selector.item).not(selector.unselectable).eq(0),
                            $prevAvailable = $selected.prevAll(selector.item).not(selector.unselectable).eq(0),
                            hasNext = ($nextAvailable.length > 0)
                          ;
                          if (hasNext) {
                              module.verbose('Moving selection to', $nextAvailable);
                              $nextAvailable.addClass(className.selected);
                          }
                          else {
                              module.verbose('Moving selection to', $prevAvailable);
                              $prevAvailable.addClass(className.selected);
                          }
                      }
                  },

                  setup: {
                      api: function () {
                          var
                            apiSettings = {
                                debug: settings.debug,
                                urlData: {
                                    value: module.get.value(),
                                    query: module.get.query()
                                },
                                on: false
                            }
                          ;
                          module.verbose('First request, initializing API');
                          $module
                            .api(apiSettings)
                          ;
                      },
                      layout: function () {
                          if ($module.is('select')) {
                              module.setup.select();
                              module.setup.returnedObject();
                          }
                          if (!module.has.menu()) {
                              module.create.menu();
                          }
                          if (module.is.search() && !module.has.search()) {
                              module.verbose('Adding search input');
                              $search = $('<input />')
                                .addClass(className.search)
                                .prop('autocomplete', 'off')
                                .insertBefore($text)
                              ;
                          }
                          if (module.is.multiple() && module.is.searchSelection() && !module.has.sizer()) {
                              module.create.sizer();
                          }
                          if (settings.allowTab) {
                              module.set.tabbable();
                          }
                      },
                      select: function () {
                          var
                            selectValues = module.get.selectValues()
                          ;
                          module.debug('Dropdown initialized on a select', selectValues);
                          if ($module.is('select')) {
                              $input = $module;
                          }
                          // see if select is placed correctly already
                          if ($input.parent(selector.dropdown).length > 0) {
                              module.debug('UI dropdown already exists. Creating dropdown menu only');
                              $module = $input.closest(selector.dropdown);
                              if (!module.has.menu()) {
                                  module.create.menu();
                              }
                              $menu = $module.children(selector.menu);
                              module.setup.menu(selectValues);
                          }
                          else {
                              module.debug('Creating entire dropdown from select');
                              $module = $('<div />')
                                .attr('class', $input.attr('class'))
                                .addClass(className.selection)
                                .addClass(className.dropdown)
                                .html(templates.dropdown(selectValues))
                                .insertBefore($input)
                              ;
                              if ($input.hasClass(className.multiple) && $input.prop('multiple') === false) {
                                  module.error(error.missingMultiple);
                                  $input.prop('multiple', true);
                              }
                              if ($input.is('[multiple]')) {
                                  module.set.multiple();
                              }
                              if ($input.prop('disabled')) {
                                  module.debug('Disabling dropdown');
                                  $module.addClass(className.disabled);
                              }
                              $input
                                .removeAttr('class')
                                .detach()
                                .prependTo($module)
                              ;
                          }
                          module.refresh();
                      },
                      menu: function (values) {
                          $menu.html(templates.menu(values, fields));
                          $item = $menu.find(selector.item);
                      },
                      reference: function () {
                          module.debug('Dropdown behavior was called on select, replacing with closest dropdown');
                          // replace module reference
                          $module = $module.parent(selector.dropdown);
                          module.refresh();
                          module.setup.returnedObject();
                          // invoke method in context of current instance
                          if (methodInvoked) {
                              instance = module;
                              module.invoke(query);
                          }
                      },
                      returnedObject: function () {
                          var
                            $firstModules = $allModules.slice(0, elementIndex),
                            $lastModules = $allModules.slice(elementIndex + 1)
                          ;
                          // adjust all modules to use correct reference
                          $allModules = $firstModules.add($module).add($lastModules);
                      }
                  },

                  refresh: function () {
                      module.refreshSelectors();
                      module.refreshData();
                  },

                  refreshItems: function () {
                      $item = $menu.find(selector.item);
                  },

                  refreshSelectors: function () {
                      module.verbose('Refreshing selector cache');
                      $text = $module.find(selector.text);
                      $search = $module.find(selector.search);
                      $input = $module.find(selector.input);
                      $icon = $module.find(selector.icon);
                      $combo = ($module.prev().find(selector.text).length > 0)
                        ? $module.prev().find(selector.text)
                        : $module.prev()
                      ;
                      $menu = $module.children(selector.menu);
                      $item = $menu.find(selector.item);
                  },

                  refreshData: function () {
                      module.verbose('Refreshing cached metadata');
                      $item
                        .removeData(metadata.text)
                        .removeData(metadata.value)
                      ;
                  },

                  clearData: function () {
                      module.verbose('Clearing metadata');
                      $item
                        .removeData(metadata.text)
                        .removeData(metadata.value)
                      ;
                      $module
                        .removeData(metadata.defaultText)
                        .removeData(metadata.defaultValue)
                        .removeData(metadata.placeholderText)
                      ;
                  },

                  toggle: function () {
                      module.verbose('Toggling menu visibility');
                      if (!module.is.active()) {
                          module.show();
                      }
                      else {
                          module.hide();
                      }
                  },

                  show: function (callback) {
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      if (module.can.show() && !module.is.active()) {
                          module.debug('Showing dropdown');
                          if (module.has.message() && !(module.has.maxSelections() || module.has.allResultsFiltered())) {
                              module.remove.message();
                          }
                          if (module.is.allFiltered()) {
                              return true;
                          }
                          if (settings.onShow.call(element) !== false) {
                              module.animate.show(function () {
                                  if (module.can.click()) {
                                      module.bind.intent();
                                  }
                                  if (module.has.menuSearch()) {
                                      module.focusSearch();
                                  }
                                  module.set.visible();
                                  callback.call(element);
                              });
                          }
                      }
                  },

                  hide: function (callback) {
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      if (module.is.active()) {
                          module.debug('Hiding dropdown');
                          if (settings.onHide.call(element) !== false) {
                              module.animate.hide(function () {
                                  module.remove.visible();
                                  callback.call(element);
                              });
                          }
                      }
                  },

                  hideOthers: function () {
                      module.verbose('Finding other dropdowns to hide');
                      $allModules
                        .not($module)
                          .has(selector.menu + '.' + className.visible)
                            .dropdown('hide')
                      ;
                  },

                  hideMenu: function () {
                      module.verbose('Hiding menu  instantaneously');
                      module.remove.active();
                      module.remove.visible();
                      $menu.transition('hide');
                  },

                  hideSubMenus: function () {
                      var
                        $subMenus = $menu.children(selector.item).find(selector.menu)
                      ;
                      module.verbose('Hiding sub menus', $subMenus);
                      $subMenus.transition('hide');
                  },

                  bind: {
                      events: function () {
                          if (hasTouch) {
                              module.bind.touchEvents();
                          }
                          module.bind.keyboardEvents();
                          module.bind.inputEvents();
                          module.bind.mouseEvents();
                      },
                      touchEvents: function () {
                          module.debug('Touch device detected binding additional touch events');
                          if (module.is.searchSelection()) {
                              // do nothing special yet
                          }
                          else if (module.is.single()) {
                              $module
                                .on('touchstart' + eventNamespace, module.event.test.toggle)
                              ;
                          }
                          $menu
                            .on('touchstart' + eventNamespace, selector.item, module.event.item.mouseenter)
                          ;
                      },
                      keyboardEvents: function () {
                          module.verbose('Binding keyboard events');
                          $module
                            .on('keydown' + eventNamespace, module.event.keydown)
                          ;
                          if (module.has.search()) {
                              $module
                                .on(module.get.inputEvent() + eventNamespace, selector.search, module.event.input)
                              ;
                          }
                          if (module.is.multiple()) {
                              $document
                                .on('keydown' + elementNamespace, module.event.document.keydown)
                              ;
                          }
                      },
                      inputEvents: function () {
                          module.verbose('Binding input change events');
                          $module
                            .on('change' + eventNamespace, selector.input, module.event.change)
                          ;
                      },
                      mouseEvents: function () {
                          module.verbose('Binding mouse events');
                          if (module.is.multiple()) {
                              $module
                                .on('click' + eventNamespace, selector.label, module.event.label.click)
                                .on('click' + eventNamespace, selector.remove, module.event.remove.click)
                              ;
                          }
                          if (module.is.searchSelection()) {
                              $module
                                .on('mousedown' + eventNamespace, module.event.mousedown)
                                .on('mouseup' + eventNamespace, module.event.mouseup)
                                .on('mousedown' + eventNamespace, selector.menu, module.event.menu.mousedown)
                                .on('mouseup' + eventNamespace, selector.menu, module.event.menu.mouseup)
                                .on('click' + eventNamespace, selector.icon, module.event.icon.click)
                                .on('focus' + eventNamespace, selector.search, module.event.search.focus)
                                .on('click' + eventNamespace, selector.search, module.event.search.focus)
                                .on('blur' + eventNamespace, selector.search, module.event.search.blur)
                                .on('click' + eventNamespace, selector.text, module.event.text.focus)
                              ;
                              if (module.is.multiple()) {
                                  $module
                                    .on('click' + eventNamespace, module.event.click)
                                  ;
                              }
                          }
                          else {
                              if (settings.on == 'click') {
                                  $module
                                    .on('click' + eventNamespace, selector.icon, module.event.icon.click)
                                    .on('click' + eventNamespace, module.event.test.toggle)
                                  ;
                              }
                              else if (settings.on == 'hover') {
                                  $module
                                    .on('mouseenter' + eventNamespace, module.delay.show)
                                    .on('mouseleave' + eventNamespace, module.delay.hide)
                                  ;
                              }
                              else {
                                  $module
                                    .on(settings.on + eventNamespace, module.toggle)
                                  ;
                              }
                              $module
                                .on('mousedown' + eventNamespace, module.event.mousedown)
                                .on('mouseup' + eventNamespace, module.event.mouseup)
                                .on('focus' + eventNamespace, module.event.focus)
                                .on('blur' + eventNamespace, module.event.blur)
                              ;
                          }
                          $menu
                            .on('mouseenter' + eventNamespace, selector.item, module.event.item.mouseenter)
                            .on('mouseleave' + eventNamespace, selector.item, module.event.item.mouseleave)
                            .on('click' + eventNamespace, selector.item, module.event.item.click)
                          ;
                      },
                      intent: function () {
                          module.verbose('Binding hide intent event to document');
                          if (hasTouch) {
                              $document
                                .on('touchstart' + elementNamespace, module.event.test.touch)
                                .on('touchmove' + elementNamespace, module.event.test.touch)
                              ;
                          }
                          $document
                            .on('click' + elementNamespace, module.event.test.hide)
                          ;
                      }
                  },

                  unbind: {
                      intent: function () {
                          module.verbose('Removing hide intent event from document');
                          if (hasTouch) {
                              $document
                                .off('touchstart' + elementNamespace)
                                .off('touchmove' + elementNamespace)
                              ;
                          }
                          $document
                            .off('click' + elementNamespace)
                          ;
                      }
                  },

                  filter: function (query) {
                      var
                        searchTerm = (query !== undefined)
                          ? query
                          : module.get.query(),
                        afterFiltered = function () {
                            if (module.is.multiple()) {
                                module.filterActive();
                            }
                            module.select.firstUnfiltered();
                            if (module.has.allResultsFiltered()) {
                                if (settings.onNoResults.call(element, searchTerm)) {
                                    if (settings.allowAdditions) {
                                        if (settings.hideAdditions) {
                                            module.verbose('User addition with no menu, setting empty style');
                                            module.set.empty();
                                            module.hideMenu();
                                        }
                                    }
                                    else {
                                        module.verbose('All items filtered, showing message', searchTerm);
                                        module.add.message(message.noResults);
                                    }
                                }
                                else {
                                    module.verbose('All items filtered, hiding dropdown', searchTerm);
                                    module.hideMenu();
                                }
                            }
                            else {
                                module.remove.empty();
                                module.remove.message();
                            }
                            if (settings.allowAdditions) {
                                module.add.userSuggestion(query);
                            }
                            if (module.is.searchSelection() && module.can.show() && module.is.focusedOnSearch()) {
                                module.show();
                            }
                        }
                      ;
                      if (settings.useLabels && module.has.maxSelections()) {
                          return;
                      }
                      if (settings.apiSettings) {
                          if (module.can.useAPI()) {
                              module.queryRemote(searchTerm, function () {
                                  afterFiltered();
                              });
                          }
                          else {
                              module.error(error.noAPI);
                          }
                      }
                      else {
                          module.filterItems(searchTerm);
                          afterFiltered();
                      }
                  },

                  queryRemote: function (query, callback) {
                      var
                        apiSettings = {
                            errorDuration: false,
                            cache: 'local',
                            throttle: settings.throttle,
                            urlData: {
                                query: query
                            },
                            onError: function () {
                                module.add.message(message.serverError);
                                callback();
                            },
                            onFailure: function () {
                                module.add.message(message.serverError);
                                callback();
                            },
                            onSuccess: function (response) {
                                module.remove.message();
                                module.setup.menu({
                                    values: response[fields.remoteValues]
                                });
                                callback();
                            }
                        }
                      ;
                      if (!$module.api('get request')) {
                          module.setup.api();
                      }
                      apiSettings = $.extend(true, {}, apiSettings, settings.apiSettings);
                      $module
                        .api('setting', apiSettings)
                        .api('query')
                      ;
                  },

                  filterItems: function (query) {
                      var
                        searchTerm = (query !== undefined)
                          ? query
                          : module.get.query(),
                        results = null,
                        escapedTerm = module.escape.regExp(searchTerm),
                        beginsWithRegExp = new RegExp('^' + escapedTerm, 'igm')
                      ;
                      // avoid loop if we're matching nothing
                      if (module.has.query()) {
                          results = [];

                          module.verbose('Searching for matching values', searchTerm);
                          $item
                            .each(function () {
                                var
                                  $choice = $(this),
                                  text,
                                  value
                                ;
                                if (settings.match == 'both' || settings.match == 'text') {
                                    text = String(module.get.choiceText($choice, false));
                                    if (text.search(beginsWithRegExp) !== -1) {
                                        results.push(this);
                                        return true;
                                    }
                                    else if (settings.fullTextSearch === 'exact' && module.exactSearch(searchTerm, text)) {
                                        results.push(this);
                                        return true;
                                    }
                                    else if (settings.fullTextSearch === true && module.fuzzySearch(searchTerm, text)) {
                                        results.push(this);
                                        return true;
                                    }
                                }
                                if (settings.match == 'both' || settings.match == 'value') {
                                    value = String(module.get.choiceValue($choice, text));

                                    if (value.search(beginsWithRegExp) !== -1) {
                                        results.push(this);
                                        return true;
                                    }
                                    else if (settings.fullTextSearch && module.fuzzySearch(searchTerm, value)) {
                                        results.push(this);
                                        return true;
                                    }
                                }
                            })
                          ;
                      }
                      module.debug('Showing only matched items', searchTerm);
                      module.remove.filteredItem();
                      if (results) {
                          $item
                            .not(results)
                            .addClass(className.filtered)
                          ;
                      }
                  },

                  fuzzySearch: function (query, term) {
                      var
                        termLength = term.length,
                        queryLength = query.length
                      ;
                      query = query.toLowerCase();
                      term = term.toLowerCase();
                      if (queryLength > termLength) {
                          return false;
                      }
                      if (queryLength === termLength) {
                          return (query === term);
                      }
                      search: for (var characterIndex = 0, nextCharacterIndex = 0; characterIndex < queryLength; characterIndex++) {
                          var
                            queryCharacter = query.charCodeAt(characterIndex)
                          ;
                          while (nextCharacterIndex < termLength) {
                              if (term.charCodeAt(nextCharacterIndex++) === queryCharacter) {
                                  continue search;
                              }
                          }
                          return false;
                      }
                      return true;
                  },
                  exactSearch: function (query, term) {
                      query = query.toLowerCase();
                      term = term.toLowerCase();
                      if (term.indexOf(query) > -1) {
                          return true;
                      }
                      return false;
                  },
                  filterActive: function () {
                      if (settings.useLabels) {
                          $item.filter('.' + className.active)
                            .addClass(className.filtered)
                          ;
                      }
                  },

                  focusSearch: function (skipHandler) {
                      if (module.has.search() && !module.is.focusedOnSearch()) {
                          if (skipHandler) {
                              $module.off('focus' + eventNamespace, selector.search);
                              $search.focus();
                              $module.on('focus' + eventNamespace, selector.search, module.event.search.focus);
                          }
                          else {
                              $search.focus();
                          }
                      }
                  },

                  forceSelection: function () {
                      var
                        $currentlySelected = $item.not(className.filtered).filter('.' + className.selected).eq(0),
                        $activeItem = $item.not(className.filtered).filter('.' + className.active).eq(0),
                        $selectedItem = ($currentlySelected.length > 0)
                          ? $currentlySelected
                          : $activeItem,
                        hasSelected = ($selectedItem.length > 0)
                      ;
                      if (hasSelected) {
                          module.debug('Forcing partial selection to selected item', $selectedItem);
                          module.event.item.click.call($selectedItem, {}, true);
                          return;
                      }
                      else {
                          if (settings.allowAdditions) {
                              module.set.selected(module.get.query());
                              module.remove.searchTerm();
                          }
                          else {
                              module.remove.searchTerm();
                          }
                      }
                  },

                  event: {
                      change: function () {
                          if (!internalChange) {
                              module.debug('Input changed, updating selection');
                              module.set.selected();
                          }
                      },
                      focus: function () {
                          if (settings.showOnFocus && !activated && module.is.hidden() && !pageLostFocus) {
                              module.show();
                          }
                      },
                      blur: function (event) {
                          pageLostFocus = (document.activeElement === this);
                          if (!activated && !pageLostFocus) {
                              module.remove.activeLabel();
                              module.hide();
                          }
                      },
                      mousedown: function () {
                          if (module.is.searchSelection()) {
                              // prevent menu hiding on immediate re-focus
                              willRefocus = true;
                          }
                          else {
                              // prevents focus callback from occurring on mousedown
                              activated = true;
                          }
                      },
                      mouseup: function () {
                          if (module.is.searchSelection()) {
                              // prevent menu hiding on immediate re-focus
                              willRefocus = false;
                          }
                          else {
                              activated = false;
                          }
                      },
                      click: function (event) {
                          var
                            $target = $(event.target)
                          ;
                          // focus search
                          if ($target.is($module)) {
                              if (!module.is.focusedOnSearch()) {
                                  module.focusSearch();
                              }
                              else {
                                  module.show();
                              }
                          }
                      },
                      search: {
                          focus: function () {
                              activated = true;
                              if (module.is.multiple()) {
                                  module.remove.activeLabel();
                              }
                              if (settings.showOnFocus) {
                                  module.search();
                              }
                          },
                          blur: function (event) {
                              pageLostFocus = (document.activeElement === this);
                              if (!willRefocus) {
                                  if (!itemActivated && !pageLostFocus) {
                                      if (settings.forceSelection && module.has.query()) {
                                          module.forceSelection();
                                      }
                                      module.hide();
                                  }
                              }
                              willRefocus = false;
                          }
                      },
                      icon: {
                          click: function (event) {
                              module.toggle();
                              event.stopPropagation();
                          }
                      },
                      text: {
                          focus: function (event) {
                              activated = true;
                              module.focusSearch();
                          }
                      },
                      input: function (event) {
                          if (module.is.multiple() || module.is.searchSelection()) {
                              module.set.filtered();
                          }
                          clearTimeout(module.timer);
                          module.timer = setTimeout(module.search, settings.delay.search);
                      },
                      label: {
                          click: function (event) {
                              var
                                $label = $(this),
                                $labels = $module.find(selector.label),
                                $activeLabels = $labels.filter('.' + className.active),
                                $nextActive = $label.nextAll('.' + className.active),
                                $prevActive = $label.prevAll('.' + className.active),
                                $range = ($nextActive.length > 0)
                                  ? $label.nextUntil($nextActive).add($activeLabels).add($label)
                                  : $label.prevUntil($prevActive).add($activeLabels).add($label)
                              ;
                              if (event.shiftKey) {
                                  $activeLabels.removeClass(className.active);
                                  $range.addClass(className.active);
                              }
                              else if (event.ctrlKey) {
                                  $label.toggleClass(className.active);
                              }
                              else {
                                  $activeLabels.removeClass(className.active);
                                  $label.addClass(className.active);
                              }
                              settings.onLabelSelect.apply(this, $labels.filter('.' + className.active));
                          }
                      },
                      remove: {
                          click: function () {
                              var
                                $label = $(this).parent()
                              ;
                              if ($label.hasClass(className.active)) {
                                  // remove all selected labels
                                  module.remove.activeLabels();
                              }
                              else {
                                  // remove this label only
                                  module.remove.activeLabels($label);
                              }
                          }
                      },
                      test: {
                          toggle: function (event) {
                              var
                                toggleBehavior = (module.is.multiple())
                                  ? module.show
                                  : module.toggle
                              ;
                              if (module.is.bubbledLabelClick(event)) {
                                  return;
                              }
                              if (module.determine.eventOnElement(event, toggleBehavior)) {
                                  event.preventDefault();
                              }
                          },
                          touch: function (event) {
                              module.determine.eventOnElement(event, function () {
                                  if (event.type == 'touchstart') {
                                      module.timer = setTimeout(function () {
                                          module.hide();
                                      }, settings.delay.touch);
                                  }
                                  else if (event.type == 'touchmove') {
                                      clearTimeout(module.timer);
                                  }
                              });
                              event.stopPropagation();
                          },
                          hide: function (event) {
                              module.determine.eventInModule(event, module.hide);
                          }
                      },
                      select: {
                          mutation: function (mutations) {
                              module.debug('<select> modified, recreating menu');
                              module.setup.select();
                          }
                      },
                      menu: {
                          mutation: function (mutations) {
                              var
                                mutation = mutations[0],
                                $addedNode = mutation.addedNodes
                                  ? $(mutation.addedNodes[0])
                                  : $(false),
                                $removedNode = mutation.removedNodes
                                  ? $(mutation.removedNodes[0])
                                  : $(false),
                                $changedNodes = $addedNode.add($removedNode),
                                isUserAddition = $changedNodes.is(selector.addition) || $changedNodes.closest(selector.addition).length > 0,
                                isMessage = $changedNodes.is(selector.message) || $changedNodes.closest(selector.message).length > 0
                              ;
                              if (isUserAddition || isMessage) {
                                  module.debug('Updating item selector cache');
                                  module.refreshItems();
                              }
                              else {
                                  module.debug('Menu modified, updating selector cache');
                                  module.refresh();
                              }
                          },
                          mousedown: function () {
                              itemActivated = true;
                          },
                          mouseup: function () {
                              itemActivated = false;
                          }
                      },
                      item: {
                          mouseenter: function (event) {
                              var
                                $target = $(event.target),
                                $item = $(this),
                                $subMenu = $item.children(selector.menu),
                                $otherMenus = $item.siblings(selector.item).children(selector.menu),
                                hasSubMenu = ($subMenu.length > 0),
                                isBubbledEvent = ($subMenu.find($target).length > 0)
                              ;
                              if (!isBubbledEvent && hasSubMenu) {
                                  clearTimeout(module.itemTimer);
                                  module.itemTimer = setTimeout(function () {
                                      module.verbose('Showing sub-menu', $subMenu);
                                      $.each($otherMenus, function () {
                                          module.animate.hide(false, $(this));
                                      });
                                      module.animate.show(false, $subMenu);
                                  }, settings.delay.show);
                                  event.preventDefault();
                              }
                          },
                          mouseleave: function (event) {
                              var
                                $subMenu = $(this).children(selector.menu)
                              ;
                              if ($subMenu.length > 0) {
                                  clearTimeout(module.itemTimer);
                                  module.itemTimer = setTimeout(function () {
                                      module.verbose('Hiding sub-menu', $subMenu);
                                      module.animate.hide(false, $subMenu);
                                  }, settings.delay.hide);
                              }
                          },
                          click: function (event, skipRefocus) {
                              var
                                $choice = $(this),
                                $target = (event)
                                  ? $(event.target)
                                  : $(''),
                                $subMenu = $choice.find(selector.menu),
                                text = module.get.choiceText($choice),
                                value = module.get.choiceValue($choice, text),
                                hasSubMenu = ($subMenu.length > 0),
                                isBubbledEvent = ($subMenu.find($target).length > 0)
                              ;
                              if (!isBubbledEvent && (!hasSubMenu || settings.allowCategorySelection)) {
                                  if (module.is.searchSelection()) {
                                      if (settings.allowAdditions) {
                                          module.remove.userAddition();
                                      }
                                      module.remove.searchTerm();
                                      if (!module.is.focusedOnSearch() && !(skipRefocus == true)) {
                                          module.focusSearch(true);
                                      }
                                  }
                                  if (!settings.useLabels) {
                                      module.remove.filteredItem();
                                      module.set.scrollPosition($choice);
                                  }
                                  module.determine.selectAction.call(this, text, value);
                              }
                          }
                      },

                      document: {
                          // label selection should occur even when element has no focus
                          keydown: function (event) {
                              var
                                pressedKey = event.which,
                                isShortcutKey = module.is.inObject(pressedKey, keys)
                              ;
                              if (isShortcutKey) {
                                  var
                                    $label = $module.find(selector.label),
                                    $activeLabel = $label.filter('.' + className.active),
                                    activeValue = $activeLabel.data(metadata.value),
                                    labelIndex = $label.index($activeLabel),
                                    labelCount = $label.length,
                                    hasActiveLabel = ($activeLabel.length > 0),
                                    hasMultipleActive = ($activeLabel.length > 1),
                                    isFirstLabel = (labelIndex === 0),
                                    isLastLabel = (labelIndex + 1 == labelCount),
                                    isSearch = module.is.searchSelection(),
                                    isFocusedOnSearch = module.is.focusedOnSearch(),
                                    isFocused = module.is.focused(),
                                    caretAtStart = (isFocusedOnSearch && module.get.caretPosition() === 0),
                                    $nextLabel
                                  ;
                                  if (isSearch && !hasActiveLabel && !isFocusedOnSearch) {
                                      return;
                                  }

                                  if (pressedKey == keys.leftArrow) {
                                      // activate previous label
                                      if ((isFocused || caretAtStart) && !hasActiveLabel) {
                                          module.verbose('Selecting previous label');
                                          $label.last().addClass(className.active);
                                      }
                                      else if (hasActiveLabel) {
                                          if (!event.shiftKey) {
                                              module.verbose('Selecting previous label');
                                              $label.removeClass(className.active);
                                          }
                                          else {
                                              module.verbose('Adding previous label to selection');
                                          }
                                          if (isFirstLabel && !hasMultipleActive) {
                                              $activeLabel.addClass(className.active);
                                          }
                                          else {
                                              $activeLabel.prev(selector.siblingLabel)
                                                .addClass(className.active)
                                                .end()
                                              ;
                                          }
                                          event.preventDefault();
                                      }
                                  }
                                  else if (pressedKey == keys.rightArrow) {
                                      // activate first label
                                      if (isFocused && !hasActiveLabel) {
                                          $label.first().addClass(className.active);
                                      }
                                      // activate next label
                                      if (hasActiveLabel) {
                                          if (!event.shiftKey) {
                                              module.verbose('Selecting next label');
                                              $label.removeClass(className.active);
                                          }
                                          else {
                                              module.verbose('Adding next label to selection');
                                          }
                                          if (isLastLabel) {
                                              if (isSearch) {
                                                  if (!isFocusedOnSearch) {
                                                      module.focusSearch();
                                                  }
                                                  else {
                                                      $label.removeClass(className.active);
                                                  }
                                              }
                                              else if (hasMultipleActive) {
                                                  $activeLabel.next(selector.siblingLabel).addClass(className.active);
                                              }
                                              else {
                                                  $activeLabel.addClass(className.active);
                                              }
                                          }
                                          else {
                                              $activeLabel.next(selector.siblingLabel).addClass(className.active);
                                          }
                                          event.preventDefault();
                                      }
                                  }
                                  else if (pressedKey == keys.deleteKey || pressedKey == keys.backspace) {
                                      if (hasActiveLabel) {
                                          module.verbose('Removing active labels');
                                          if (isLastLabel) {
                                              if (isSearch && !isFocusedOnSearch) {
                                                  module.focusSearch();
                                              }
                                          }
                                          $activeLabel.last().next(selector.siblingLabel).addClass(className.active);
                                          module.remove.activeLabels($activeLabel);
                                          event.preventDefault();
                                      }
                                      else if (caretAtStart && !hasActiveLabel && pressedKey == keys.backspace) {
                                          module.verbose('Removing last label on input backspace');
                                          $activeLabel = $label.last().addClass(className.active);
                                          module.remove.activeLabels($activeLabel);
                                      }
                                  }
                                  else {
                                      $activeLabel.removeClass(className.active);
                                  }
                              }
                          }
                      },

                      keydown: function (event) {
                          var
                            pressedKey = event.which,
                            isShortcutKey = module.is.inObject(pressedKey, keys)
                          ;
                          if (isShortcutKey) {
                              var
                                $currentlySelected = $item.not(selector.unselectable).filter('.' + className.selected).eq(0),
                                $activeItem = $menu.children('.' + className.active).eq(0),
                                $selectedItem = ($currentlySelected.length > 0)
                                  ? $currentlySelected
                                  : $activeItem,
                                $visibleItems = ($selectedItem.length > 0)
                                  ? $selectedItem.siblings(':not(.' + className.filtered + ')').addBack()
                                  : $menu.children(':not(.' + className.filtered + ')'),
                                $subMenu = $selectedItem.children(selector.menu),
                                $parentMenu = $selectedItem.closest(selector.menu),
                                inVisibleMenu = ($parentMenu.hasClass(className.visible) || $parentMenu.hasClass(className.animating) || $parentMenu.parent(selector.menu).length > 0),
                                hasSubMenu = ($subMenu.length > 0),
                                hasSelectedItem = ($selectedItem.length > 0),
                                selectedIsSelectable = ($selectedItem.not(selector.unselectable).length > 0),
                                delimiterPressed = (pressedKey == keys.delimiter && settings.allowAdditions && module.is.multiple()),
                                isAdditionWithoutMenu = (settings.allowAdditions && settings.hideAdditions && (pressedKey == keys.enter || delimiterPressed) && selectedIsSelectable),
                                $nextItem,
                                isSubMenuItem,
                                newIndex
                              ;
                              // allow selection with menu closed
                              if (isAdditionWithoutMenu) {
                                  module.verbose('Selecting item from keyboard shortcut', $selectedItem);
                                  module.event.item.click.call($selectedItem, event);
                                  if (module.is.searchSelection()) {
                                      module.remove.searchTerm();
                                  }
                              }

                              // visible menu keyboard shortcuts
                              if (module.is.visible()) {

                                  // enter (select or open sub-menu)
                                  if (pressedKey == keys.enter || delimiterPressed) {
                                      if (pressedKey == keys.enter && hasSelectedItem && hasSubMenu && !settings.allowCategorySelection) {
                                          module.verbose('Pressed enter on unselectable category, opening sub menu');
                                          pressedKey = keys.rightArrow;
                                      }
                                      else if (selectedIsSelectable) {
                                          module.verbose('Selecting item from keyboard shortcut', $selectedItem);
                                          module.event.item.click.call($selectedItem, event);
                                          if (module.is.searchSelection()) {
                                              module.remove.searchTerm();
                                          }
                                      }
                                      event.preventDefault();
                                  }

                                  // sub-menu actions
                                  if (hasSelectedItem) {

                                      if (pressedKey == keys.leftArrow) {

                                          isSubMenuItem = ($parentMenu[0] !== $menu[0]);

                                          if (isSubMenuItem) {
                                              module.verbose('Left key pressed, closing sub-menu');
                                              module.animate.hide(false, $parentMenu);
                                              $selectedItem
                                                .removeClass(className.selected)
                                              ;
                                              $parentMenu
                                                .closest(selector.item)
                                                  .addClass(className.selected)
                                              ;
                                              event.preventDefault();
                                          }
                                      }

                                      // right arrow (show sub-menu)
                                      if (pressedKey == keys.rightArrow) {
                                          if (hasSubMenu) {
                                              module.verbose('Right key pressed, opening sub-menu');
                                              module.animate.show(false, $subMenu);
                                              $selectedItem
                                                .removeClass(className.selected)
                                              ;
                                              $subMenu
                                                .find(selector.item).eq(0)
                                                  .addClass(className.selected)
                                              ;
                                              event.preventDefault();
                                          }
                                      }
                                  }

                                  // up arrow (traverse menu up)
                                  if (pressedKey == keys.upArrow) {
                                      $nextItem = (hasSelectedItem && inVisibleMenu)
                                        ? $selectedItem.prevAll(selector.item + ':not(' + selector.unselectable + ')').eq(0)
                                        : $item.eq(0)
                                      ;
                                      if ($visibleItems.index($nextItem) < 0) {
                                          module.verbose('Up key pressed but reached top of current menu');
                                          event.preventDefault();
                                          return;
                                      }
                                      else {
                                          module.verbose('Up key pressed, changing active item');
                                          $selectedItem
                                            .removeClass(className.selected)
                                          ;
                                          $nextItem
                                            .addClass(className.selected)
                                          ;
                                          module.set.scrollPosition($nextItem);
                                          if (settings.selectOnKeydown && module.is.single()) {
                                              module.set.selectedItem($nextItem);
                                          }
                                      }
                                      event.preventDefault();
                                  }

                                  // down arrow (traverse menu down)
                                  if (pressedKey == keys.downArrow) {
                                      $nextItem = (hasSelectedItem && inVisibleMenu)
                                        ? $nextItem = $selectedItem.nextAll(selector.item + ':not(' + selector.unselectable + ')').eq(0)
                                        : $item.eq(0)
                                      ;
                                      if ($nextItem.length === 0) {
                                          module.verbose('Down key pressed but reached bottom of current menu');
                                          event.preventDefault();
                                          return;
                                      }
                                      else {
                                          module.verbose('Down key pressed, changing active item');
                                          $item
                                            .removeClass(className.selected)
                                          ;
                                          $nextItem
                                            .addClass(className.selected)
                                          ;
                                          module.set.scrollPosition($nextItem);
                                          if (settings.selectOnKeydown && module.is.single()) {
                                              module.set.activeItem($nextItem);
                                              module.set.selected(module.get.choiceValue($nextItem), $nextItem);
                                          }
                                      }
                                      event.preventDefault();
                                  }

                                  // page down (show next page)
                                  if (pressedKey == keys.pageUp) {
                                      module.scrollPage('up');
                                      event.preventDefault();
                                  }
                                  if (pressedKey == keys.pageDown) {
                                      module.scrollPage('down');
                                      event.preventDefault();
                                  }

                                  // escape (close menu)
                                  if (pressedKey == keys.escape) {
                                      module.verbose('Escape key pressed, closing dropdown');
                                      module.hide();
                                  }

                              }
                              else {
                                  // delimiter key
                                  if (delimiterPressed) {
                                      event.preventDefault();
                                  }
                                  // down arrow (open menu)
                                  if (pressedKey == keys.downArrow && !module.is.visible()) {
                                      module.verbose('Down key pressed, showing dropdown');
                                      module.select.firstUnfiltered();
                                      module.show();
                                      event.preventDefault();
                                  }
                              }
                          }
                          else {
                              if (!module.has.search()) {
                                  module.set.selectedLetter(String.fromCharCode(pressedKey));
                              }
                          }
                      }
                  },

                  trigger: {
                      change: function () {
                          var
                            events = document.createEvent('HTMLEvents'),
                            inputElement = $input[0]
                          ;
                          if (inputElement) {
                              module.verbose('Triggering native change event');
                              events.initEvent('change', true, false);
                              inputElement.dispatchEvent(events);
                          }
                      }
                  },

                  determine: {
                      selectAction: function (text, value) {
                          module.verbose('Determining action', settings.action);
                          if ($.isFunction(module.action[settings.action])) {
                              module.verbose('Triggering preset action', settings.action, text, value);
                              module.action[settings.action].call(element, text, value, this);
                          }
                          else if ($.isFunction(settings.action)) {
                              module.verbose('Triggering user action', settings.action, text, value);
                              settings.action.call(element, text, value, this);
                          }
                          else {
                              module.error(error.action, settings.action);
                          }
                      },
                      eventInModule: function (event, callback) {
                          var
                            $target = $(event.target),
                            inDocument = ($target.closest(document.documentElement).length > 0),
                            inModule = ($target.closest($module).length > 0)
                          ;
                          callback = $.isFunction(callback)
                            ? callback
                            : function () { }
                          ;
                          if (inDocument && !inModule) {
                              module.verbose('Triggering event', callback);
                              callback();
                              return true;
                          }
                          else {
                              module.verbose('Event occurred in dropdown, canceling callback');
                              return false;
                          }
                      },
                      eventOnElement: function (event, callback) {
                          var
                            $target = $(event.target),
                            $label = $target.closest(selector.siblingLabel),
                            inVisibleDOM = document.body.contains(event.target),
                            notOnLabel = ($module.find($label).length === 0),
                            notInMenu = ($target.closest($menu).length === 0)
                          ;
                          callback = $.isFunction(callback)
                            ? callback
                            : function () { }
                          ;
                          if (inVisibleDOM && notOnLabel && notInMenu) {
                              module.verbose('Triggering event', callback);
                              callback();
                              return true;
                          }
                          else {
                              module.verbose('Event occurred in dropdown menu, canceling callback');
                              return false;
                          }
                      }
                  },

                  action: {

                      nothing: function () { },

                      activate: function (text, value, element) {
                          value = (value !== undefined)
                            ? value
                            : text
                          ;
                          if (module.can.activate($(element))) {
                              module.set.selected(value, $(element));
                              if (module.is.multiple() && !module.is.allFiltered()) {
                                  return;
                              }
                              else {
                                  module.hideAndClear();
                              }
                          }
                      },

                      select: function (text, value, element) {
                          // mimics action.activate but does not select text
                          module.action.activate.call(element);
                      },

                      combo: function (text, value, element) {
                          value = (value !== undefined)
                            ? value
                            : text
                          ;
                          module.set.selected(value, $(element));
                          module.hideAndClear();
                      },

                      hide: function (text, value, element) {
                          module.set.value(value, text);
                          module.hideAndClear();
                      }

                  },

                  get: {
                      id: function () {
                          return id;
                      },
                      defaultText: function () {
                          return $module.data(metadata.defaultText);
                      },
                      defaultValue: function () {
                          return $module.data(metadata.defaultValue);
                      },
                      placeholderText: function () {
                          return $module.data(metadata.placeholderText) || '';
                      },
                      text: function () {
                          return $text.text();
                      },
                      query: function () {
                          return $.trim($search.val());
                      },
                      searchWidth: function (value) {
                          value = (value !== undefined)
                            ? value
                            : $search.val()
                          ;
                          $sizer.text(value);
                          // prevent rounding issues
                          return Math.ceil($sizer.width() + 1);
                      },
                      selectionCount: function () {
                          var
                            values = module.get.values(),
                            count
                          ;
                          count = (module.is.multiple())
                            ? $.isArray(values)
                              ? values.length
                              : 0
                            : (module.get.value() !== '')
                              ? 1
                              : 0
                          ;
                          return count;
                      },
                      transition: function ($subMenu) {
                          return (settings.transition == 'auto')
                            ? module.is.upward($subMenu)
                              ? 'slide up'
                              : 'slide down'
                            : settings.transition
                          ;
                      },
                      userValues: function () {
                          var
                            values = module.get.values()
                          ;
                          if (!values) {
                              return false;
                          }
                          values = $.isArray(values)
                            ? values
                            : [values]
                          ;
                          return $.grep(values, function (value) {
                              return (module.get.item(value) === false);
                          });
                      },
                      uniqueArray: function (array) {
                          return $.grep(array, function (value, index) {
                              return $.inArray(value, array) === index;
                          });
                      },
                      caretPosition: function () {
                          var
                            input = $search.get(0),
                            range,
                            rangeLength
                          ;
                          if ('selectionStart' in input) {
                              return input.selectionStart;
                          }
                          else if (document.selection) {
                              input.focus();
                              range = document.selection.createRange();
                              rangeLength = range.text.length;
                              range.moveStart('character', -input.value.length);
                              return range.text.length - rangeLength;
                          }
                      },
                      value: function () {
                          var
                            value = ($input.length > 0)
                              ? $input.val()
                              : $module.data(metadata.value),
                            isEmptyMultiselect = ($.isArray(value) && value.length === 1 && value[0] === '')
                          ;
                          // prevents placeholder element from being selected when multiple
                          return (value === undefined || isEmptyMultiselect)
                            ? ''
                            : value
                          ;
                      },
                      values: function () {
                          var
                            value = module.get.value()
                          ;
                          if (value === '') {
                              return '';
                          }
                          return (!module.has.selectInput() && module.is.multiple())
                            ? (typeof value == 'string') // delimited string
                              ? value.split(settings.delimiter)
                              : ''
                            : value
                          ;
                      },
                      remoteValues: function () {
                          var
                            values = module.get.values(),
                            remoteValues = false
                          ;
                          if (values) {
                              if (typeof values == 'string') {
                                  values = [values];
                              }
                              $.each(values, function (index, value) {
                                  var
                                    name = module.read.remoteData(value)
                                  ;
                                  module.verbose('Restoring value from session data', name, value);
                                  if (name) {
                                      if (!remoteValues) {
                                          remoteValues = {};
                                      }
                                      remoteValues[value] = name;
                                  }
                              });
                          }
                          return remoteValues;
                      },
                      choiceText: function ($choice, preserveHTML) {
                          preserveHTML = (preserveHTML !== undefined)
                            ? preserveHTML
                            : settings.preserveHTML
                          ;
                          if ($choice) {
                              if ($choice.find(selector.menu).length > 0) {
                                  module.verbose('Retrieving text of element with sub-menu');
                                  $choice = $choice.clone();
                                  $choice.find(selector.menu).remove();
                                  $choice.find(selector.menuIcon).remove();
                              }
                              return ($choice.data(metadata.text) !== undefined)
                                ? $choice.data(metadata.text)
                                : (preserveHTML)
                                  ? $.trim($choice.html())
                                  : $.trim($choice.text())
                              ;
                          }
                      },
                      choiceValue: function ($choice, choiceText) {
                          choiceText = choiceText || module.get.choiceText($choice);
                          if (!$choice) {
                              return false;
                          }
                          return ($choice.data(metadata.value) !== undefined)
                            ? String($choice.data(metadata.value))
                            : (typeof choiceText === 'string')
                              ? $.trim(choiceText.toLowerCase())
                              : String(choiceText)
                          ;
                      },
                      inputEvent: function () {
                          var
                            input = $search[0]
                          ;
                          if (input) {
                              return (input.oninput !== undefined)
                                ? 'input'
                                : (input.onpropertychange !== undefined)
                                  ? 'propertychange'
                                  : 'keyup'
                              ;
                          }
                          return false;
                      },
                      selectValues: function () {
                          var
                            select = {}
                          ;
                          select.values = [];
                          $module
                            .find('option')
                              .each(function () {
                                  var
                                    $option = $(this),
                                    name = $option.html(),
                                    disabled = $option.attr('disabled'),
                                    value = ($option.attr('value') !== undefined)
                                      ? $option.attr('value')
                                      : name
                                  ;
                                  if (settings.placeholder === 'auto' && value === '') {
                                      select.placeholder = name;
                                  }
                                  else {
                                      select.values.push({
                                          name: name,
                                          value: value,
                                          disabled: disabled
                                      });
                                  }
                              })
                          ;
                          if (settings.placeholder && settings.placeholder !== 'auto') {
                              module.debug('Setting placeholder value to', settings.placeholder);
                              select.placeholder = settings.placeholder;
                          }
                          if (settings.sortSelect) {
                              select.values.sort(function (a, b) {
                                  return (a.name > b.name)
                                    ? 1
                                    : -1
                                  ;
                              });
                              module.debug('Retrieved and sorted values from select', select);
                          }
                          else {
                              module.debug('Retrieved values from select', select);
                          }
                          return select;
                      },
                      activeItem: function () {
                          return $item.filter('.' + className.active);
                      },
                      selectedItem: function () {
                          var
                            $selectedItem = $item.not(selector.unselectable).filter('.' + className.selected)
                          ;
                          return ($selectedItem.length > 0)
                            ? $selectedItem
                            : $item.eq(0)
                          ;
                      },
                      itemWithAdditions: function (value) {
                          var
                            $items = module.get.item(value),
                            $userItems = module.create.userChoice(value),
                            hasUserItems = ($userItems && $userItems.length > 0)
                          ;
                          if (hasUserItems) {
                              $items = ($items.length > 0)
                                ? $items.add($userItems)
                                : $userItems
                              ;
                          }
                          return $items;
                      },
                      item: function (value, strict) {
                          var
                            $selectedItem = false,
                            shouldSearch,
                            isMultiple
                          ;
                          value = (value !== undefined)
                            ? value
                            : (module.get.values() !== undefined)
                              ? module.get.values()
                              : module.get.text()
                          ;
                          shouldSearch = (isMultiple)
                            ? (value.length > 0)
                            : (value !== undefined && value !== null)
                          ;
                          isMultiple = (module.is.multiple() && $.isArray(value));
                          strict = (value === '' || value === 0)
                            ? true
                            : strict || false
                          ;
                          if (shouldSearch) {
                              $item
                                .each(function () {
                                    var
                                      $choice = $(this),
                                      optionText = module.get.choiceText($choice),
                                      optionValue = module.get.choiceValue($choice, optionText)
                                    ;
                                    // safe early exit
                                    if (optionValue === null || optionValue === undefined) {
                                        return;
                                    }
                                    if (isMultiple) {
                                        if ($.inArray(String(optionValue), value) !== -1 || $.inArray(optionText, value) !== -1) {
                                            $selectedItem = ($selectedItem)
                                              ? $selectedItem.add($choice)
                                              : $choice
                                            ;
                                        }
                                    }
                                    else if (strict) {
                                        module.verbose('Ambiguous dropdown value using strict type check', $choice, value);
                                        if (optionValue === value || optionText === value) {
                                            $selectedItem = $choice;
                                            return true;
                                        }
                                    }
                                    else {
                                        if (String(optionValue) == String(value) || optionText == value) {
                                            module.verbose('Found select item by value', optionValue, value);
                                            $selectedItem = $choice;
                                            return true;
                                        }
                                    }
                                })
                              ;
                          }
                          return $selectedItem;
                      }
                  },

                  check: {
                      maxSelections: function (selectionCount) {
                          if (settings.maxSelections) {
                              selectionCount = (selectionCount !== undefined)
                                ? selectionCount
                                : module.get.selectionCount()
                              ;
                              if (selectionCount >= settings.maxSelections) {
                                  module.debug('Maximum selection count reached');
                                  if (settings.useLabels) {
                                      $item.addClass(className.filtered);
                                      module.add.message(message.maxSelections);
                                  }
                                  return true;
                              }
                              else {
                                  module.verbose('No longer at maximum selection count');
                                  module.remove.message();
                                  module.remove.filteredItem();
                                  if (module.is.searchSelection()) {
                                      module.filterItems();
                                  }
                                  return false;
                              }
                          }
                          return true;
                      }
                  },

                  restore: {
                      defaults: function () {
                          module.clear();
                          module.restore.defaultText();
                          module.restore.defaultValue();
                      },
                      defaultText: function () {
                          var
                            defaultText = module.get.defaultText(),
                            placeholderText = module.get.placeholderText
                          ;
                          if (defaultText === placeholderText) {
                              module.debug('Restoring default placeholder text', defaultText);
                              module.set.placeholderText(defaultText);
                          }
                          else {
                              module.debug('Restoring default text', defaultText);
                              module.set.text(defaultText);
                          }
                      },
                      placeholderText: function () {
                          module.set.placeholderText();
                      },
                      defaultValue: function () {
                          var
                            defaultValue = module.get.defaultValue()
                          ;
                          if (defaultValue !== undefined) {
                              module.debug('Restoring default value', defaultValue);
                              if (defaultValue !== '') {
                                  module.set.value(defaultValue);
                                  module.set.selected();
                              }
                              else {
                                  module.remove.activeItem();
                                  module.remove.selectedItem();
                              }
                          }
                      },
                      labels: function () {
                          if (settings.allowAdditions) {
                              if (!settings.useLabels) {
                                  module.error(error.labels);
                                  settings.useLabels = true;
                              }
                              module.debug('Restoring selected values');
                              module.create.userLabels();
                          }
                          module.check.maxSelections();
                      },
                      selected: function () {
                          module.restore.values();
                          if (module.is.multiple()) {
                              module.debug('Restoring previously selected values and labels');
                              module.restore.labels();
                          }
                          else {
                              module.debug('Restoring previously selected values');
                          }
                      },
                      values: function () {
                          // prevents callbacks from occurring on initial load
                          module.set.initialLoad();
                          if (settings.apiSettings && settings.saveRemoteData && module.get.remoteValues()) {
                              module.restore.remoteValues();
                          }
                          else {
                              module.set.selected();
                          }
                          module.remove.initialLoad();
                      },
                      remoteValues: function () {
                          var
                            values = module.get.remoteValues()
                          ;
                          module.debug('Recreating selected from session data', values);
                          if (values) {
                              if (module.is.single()) {
                                  $.each(values, function (value, name) {
                                      module.set.text(name);
                                  });
                              }
                              else {
                                  $.each(values, function (value, name) {
                                      module.add.label(value, name);
                                  });
                              }
                          }
                      }
                  },

                  read: {
                      remoteData: function (value) {
                          var
                            name
                          ;
                          if (window.Storage === undefined) {
                              module.error(error.noStorage);
                              return;
                          }
                          name = sessionStorage.getItem(value);
                          return (name !== undefined)
                            ? name
                            : false
                          ;
                      }
                  },

                  save: {
                      defaults: function () {
                          module.save.defaultText();
                          module.save.placeholderText();
                          module.save.defaultValue();
                      },
                      defaultValue: function () {
                          var
                            value = module.get.value()
                          ;
                          module.verbose('Saving default value as', value);
                          $module.data(metadata.defaultValue, value);
                      },
                      defaultText: function () {
                          var
                            text = module.get.text()
                          ;
                          module.verbose('Saving default text as', text);
                          $module.data(metadata.defaultText, text);
                      },
                      placeholderText: function () {
                          var
                            text
                          ;
                          if (settings.placeholder !== false && $text.hasClass(className.placeholder)) {
                              text = module.get.text();
                              module.verbose('Saving placeholder text as', text);
                              $module.data(metadata.placeholderText, text);
                          }
                      },
                      remoteData: function (name, value) {
                          if (window.Storage === undefined) {
                              module.error(error.noStorage);
                              return;
                          }
                          module.verbose('Saving remote data to session storage', value, name);
                          sessionStorage.setItem(value, name);
                      }
                  },

                  clear: function () {
                      if (module.is.multiple()) {
                          module.remove.labels();
                      }
                      else {
                          module.remove.activeItem();
                          module.remove.selectedItem();
                      }
                      module.set.placeholderText();
                      module.clearValue();
                  },

                  clearValue: function () {
                      module.set.value('');
                  },

                  scrollPage: function (direction, $selectedItem) {
                      var
                        $currentItem = $selectedItem || module.get.selectedItem(),
                        $menu = $currentItem.closest(selector.menu),
                        menuHeight = $menu.outerHeight(),
                        currentScroll = $menu.scrollTop(),
                        itemHeight = $item.eq(0).outerHeight(),
                        itemsPerPage = Math.floor(menuHeight / itemHeight),
                        maxScroll = $menu.prop('scrollHeight'),
                        newScroll = (direction == 'up')
                          ? currentScroll - (itemHeight * itemsPerPage)
                          : currentScroll + (itemHeight * itemsPerPage),
                        $selectableItem = $item.not(selector.unselectable),
                        isWithinRange,
                        $nextSelectedItem,
                        elementIndex
                      ;
                      elementIndex = (direction == 'up')
                        ? $selectableItem.index($currentItem) - itemsPerPage
                        : $selectableItem.index($currentItem) + itemsPerPage
                      ;
                      isWithinRange = (direction == 'up')
                        ? (elementIndex >= 0)
                        : (elementIndex < $selectableItem.length)
                      ;
                      $nextSelectedItem = (isWithinRange)
                        ? $selectableItem.eq(elementIndex)
                        : (direction == 'up')
                          ? $selectableItem.first()
                          : $selectableItem.last()
                      ;
                      if ($nextSelectedItem.length > 0) {
                          module.debug('Scrolling page', direction, $nextSelectedItem);
                          $currentItem
                            .removeClass(className.selected)
                          ;
                          $nextSelectedItem
                            .addClass(className.selected)
                          ;
                          if (settings.selectOnKeydown && module.is.single()) {
                              module.set.selectedItem($nextSelectedItem);
                          }
                          $menu
                            .scrollTop(newScroll)
                          ;
                      }
                  },

                  set: {
                      filtered: function () {
                          var
                            isMultiple = module.is.multiple(),
                            isSearch = module.is.searchSelection(),
                            isSearchMultiple = (isMultiple && isSearch),
                            searchValue = (isSearch)
                              ? module.get.query()
                              : '',
                            hasSearchValue = (typeof searchValue === 'string' && searchValue.length > 0),
                            searchWidth = module.get.searchWidth(),
                            valueIsSet = searchValue !== ''
                          ;
                          if (isMultiple && hasSearchValue) {
                              module.verbose('Adjusting input width', searchWidth, settings.glyphWidth);
                              $search.css('width', searchWidth);
                          }
                          if (hasSearchValue || (isSearchMultiple && valueIsSet)) {
                              module.verbose('Hiding placeholder text');
                              $text.addClass(className.filtered);
                          }
                          else if (!isMultiple || (isSearchMultiple && !valueIsSet)) {
                              module.verbose('Showing placeholder text');
                              $text.removeClass(className.filtered);
                          }
                      },
                      empty: function () {
                          $module.addClass(className.empty);
                      },
                      loading: function () {
                          $module.addClass(className.loading);
                      },
                      placeholderText: function (text) {
                          text = text || module.get.placeholderText();
                          module.debug('Setting placeholder text', text);
                          module.set.text(text);
                          $text.addClass(className.placeholder);
                      },
                      tabbable: function () {
                          if (module.has.search()) {
                              module.debug('Added tabindex to searchable dropdown');
                              $search
                                .val('')
                                .attr('tabindex', 0)
                              ;
                              $menu
                                .attr('tabindex', -1)
                              ;
                          }
                          else {
                              module.debug('Added tabindex to dropdown');
                              if ($module.attr('tabindex') === undefined) {
                                  $module
                                    .attr('tabindex', 0)
                                  ;
                                  $menu
                                    .attr('tabindex', -1)
                                  ;
                              }
                          }
                      },
                      initialLoad: function () {
                          module.verbose('Setting initial load');
                          initialLoad = true;
                      },
                      activeItem: function ($item) {
                          if (settings.allowAdditions && $item.filter(selector.addition).length > 0) {
                              $item.addClass(className.filtered);
                          }
                          else {
                              $item.addClass(className.active);
                          }
                      },
                      scrollPosition: function ($item, forceScroll) {
                          var
                            edgeTolerance = 5,
                            $menu,
                            hasActive,
                            offset,
                            itemHeight,
                            itemOffset,
                            menuOffset,
                            menuScroll,
                            menuHeight,
                            abovePage,
                            belowPage
                          ;

                          $item = $item || module.get.selectedItem();
                          $menu = $item.closest(selector.menu);
                          hasActive = ($item && $item.length > 0);
                          forceScroll = (forceScroll !== undefined)
                            ? forceScroll
                            : false
                          ;
                          if ($item && $menu.length > 0 && hasActive) {
                              itemOffset = $item.position().top;

                              $menu.addClass(className.loading);
                              menuScroll = $menu.scrollTop();
                              menuOffset = $menu.offset().top;
                              itemOffset = $item.offset().top;
                              offset = menuScroll - menuOffset + itemOffset;
                              if (!forceScroll) {
                                  menuHeight = $menu.height();
                                  belowPage = menuScroll + menuHeight < (offset + edgeTolerance);
                                  abovePage = ((offset - edgeTolerance) < menuScroll);
                              }
                              module.debug('Scrolling to active item', offset);
                              if (forceScroll || abovePage || belowPage) {
                                  $menu.scrollTop(offset);
                              }
                              $menu.removeClass(className.loading);
                          }
                      },
                      text: function (text) {
                          if (settings.action !== 'select') {
                              if (settings.action == 'combo') {
                                  module.debug('Changing combo button text', text, $combo);
                                  if (settings.preserveHTML) {
                                      $combo.html(text);
                                  }
                                  else {
                                      $combo.text(text);
                                  }
                              }
                              else {
                                  if (text !== module.get.placeholderText()) {
                                      $text.removeClass(className.placeholder);
                                  }
                                  module.debug('Changing text', text, $text);
                                  $text
                                    .removeClass(className.filtered)
                                  ;
                                  if (settings.preserveHTML) {
                                      $text.html(text);
                                  }
                                  else {
                                      $text.text(text);
                                  }
                              }
                          }
                      },
                      selectedItem: function ($item) {
                          module.debug('Setting user selection to item', $item);
                          module.remove.activeItem();
                          module.set.activeItem($item);
                          module.set.selected(module.get.choiceValue($item), $item);
                      },
                      selectedLetter: function (letter) {
                          var
                            $selectedItem = $item.filter('.' + className.selected),
                            alreadySelectedLetter = $selectedItem.length > 0 && module.has.firstLetter($selectedItem, letter),
                            $nextValue = false,
                            $nextItem
                          ;
                          // check next of same letter
                          if (alreadySelectedLetter) {
                              $nextItem = $selectedItem.nextAll($item).eq(0);
                              if (module.has.firstLetter($nextItem, letter)) {
                                  $nextValue = $nextItem;
                              }
                          }
                          // check all values
                          if (!$nextValue) {
                              $item
                                .each(function () {
                                    if (module.has.firstLetter($(this), letter)) {
                                        $nextValue = $(this);
                                        return false;
                                    }
                                })
                              ;
                          }
                          // set next value
                          if ($nextValue) {
                              module.verbose('Scrolling to next value with letter', letter);
                              module.set.scrollPosition($nextValue);
                              $selectedItem.removeClass(className.selected);
                              $nextValue.addClass(className.selected);
                              if (settings.selectOnKeydown && module.is.single()) {
                                  module.set.selectedItem($nextValue);
                              }
                          }
                      },
                      direction: function ($menu) {
                          if (settings.direction == 'auto') {
                              if (module.is.onScreen($menu)) {
                                  module.remove.upward($menu);
                              }
                              else {
                                  module.set.upward($menu);
                              }
                          }
                          else if (settings.direction == 'upward') {
                              module.set.upward($menu);
                          }
                      },
                      upward: function ($menu) {
                          var $element = $menu || $module;
                          $element.addClass(className.upward);
                      },
                      value: function (value, text, $selected) {
                          var
                            escapedValue = module.escape.value(value),
                            hasInput = ($input.length > 0),
                            isAddition = !module.has.value(value),
                            currentValue = module.get.values(),
                            stringValue = (value !== undefined)
                              ? String(value)
                              : value,
                            newValue
                          ;
                          if (hasInput) {
                              if (!settings.allowReselection && stringValue == currentValue) {
                                  module.verbose('Skipping value update already same value', value, currentValue);
                                  if (!module.is.initialLoad()) {
                                      return;
                                  }
                              }

                              if (module.is.single() && module.has.selectInput() && module.can.extendSelect()) {
                                  module.debug('Adding user option', value);
                                  module.add.optionValue(value);
                              }
                              module.debug('Updating input value', escapedValue, currentValue);
                              internalChange = true;
                              $input
                                .val(escapedValue)
                              ;
                              if (settings.fireOnInit === false && module.is.initialLoad()) {
                                  module.debug('Input native change event ignored on initial load');
                              }
                              else {
                                  module.trigger.change();
                              }
                              internalChange = false;
                          }
                          else {
                              module.verbose('Storing value in metadata', escapedValue, $input);
                              if (escapedValue !== currentValue) {
                                  $module.data(metadata.value, stringValue);
                              }
                          }
                          if (settings.fireOnInit === false && module.is.initialLoad()) {
                              module.verbose('No callback on initial load', settings.onChange);
                          }
                          else {
                              settings.onChange.call(element, value, text, $selected);
                          }
                      },
                      active: function () {
                          $module
                            .addClass(className.active)
                          ;
                      },
                      multiple: function () {
                          $module.addClass(className.multiple);
                      },
                      visible: function () {
                          $module.addClass(className.visible);
                      },
                      exactly: function (value, $selectedItem) {
                          module.debug('Setting selected to exact values');
                          module.clear();
                          module.set.selected(value, $selectedItem);
                      },
                      selected: function (value, $selectedItem) {
                          var
                            isMultiple = module.is.multiple(),
                            $userSelectedItem
                          ;
                          $selectedItem = (settings.allowAdditions)
                            ? $selectedItem || module.get.itemWithAdditions(value)
                            : $selectedItem || module.get.item(value)
                          ;
                          if (!$selectedItem) {
                              return;
                          }
                          module.debug('Setting selected menu item to', $selectedItem);
                          if (module.is.multiple()) {
                              module.remove.searchWidth();
                          }
                          if (module.is.single()) {
                              module.remove.activeItem();
                              module.remove.selectedItem();
                          }
                          else if (settings.useLabels) {
                              module.remove.selectedItem();
                          }
                          // select each item
                          $selectedItem
                            .each(function () {
                                var
                                  $selected = $(this),
                                  selectedText = module.get.choiceText($selected),
                                  selectedValue = module.get.choiceValue($selected, selectedText),

                                  isFiltered = $selected.hasClass(className.filtered),
                                  isActive = $selected.hasClass(className.active),
                                  isUserValue = $selected.hasClass(className.addition),
                                  shouldAnimate = (isMultiple && $selectedItem.length == 1)
                                ;
                                if (isMultiple) {
                                    if (!isActive || isUserValue) {
                                        if (settings.apiSettings && settings.saveRemoteData) {
                                            module.save.remoteData(selectedText, selectedValue);
                                        }
                                        if (settings.useLabels) {
                                            module.add.value(selectedValue, selectedText, $selected);
                                            module.add.label(selectedValue, selectedText, shouldAnimate);
                                            module.set.activeItem($selected);
                                            module.filterActive();
                                            module.select.nextAvailable($selectedItem);
                                        }
                                        else {
                                            module.add.value(selectedValue, selectedText, $selected);
                                            module.set.text(module.add.variables(message.count));
                                            module.set.activeItem($selected);
                                        }
                                    }
                                    else if (!isFiltered) {
                                        module.debug('Selected active value, removing label');
                                        module.remove.selected(selectedValue);
                                    }
                                }
                                else {
                                    if (settings.apiSettings && settings.saveRemoteData) {
                                        module.save.remoteData(selectedText, selectedValue);
                                    }
                                    module.set.text(selectedText);
                                    module.set.value(selectedValue, selectedText, $selected);
                                    $selected
                                      .addClass(className.active)
                                      .addClass(className.selected)
                                    ;
                                }
                            })
                          ;
                      }
                  },

                  add: {
                      label: function (value, text, shouldAnimate) {
                          var
                            $next = module.is.searchSelection()
                              ? $search
                              : $text,
                            escapedValue = module.escape.value(value),
                            $label
                          ;
                          $label = $('<a />')
                            .addClass(className.label)
                            .attr('data-value', escapedValue)
                            .html(templates.label(escapedValue, text))
                          ;
                          $label = settings.onLabelCreate.call($label, escapedValue, text);

                          if (module.has.label(value)) {
                              module.debug('Label already exists, skipping', escapedValue);
                              return;
                          }
                          if (settings.label.variation) {
                              $label.addClass(settings.label.variation);
                          }
                          if (shouldAnimate === true) {
                              module.debug('Animating in label', $label);
                              $label
                                .addClass(className.hidden)
                                .insertBefore($next)
                                .transition(settings.label.transition, settings.label.duration)
                              ;
                          }
                          else {
                              module.debug('Adding selection label', $label);
                              $label
                                .insertBefore($next)
                              ;
                          }
                      },
                      message: function (message) {
                          var
                            $message = $menu.children(selector.message),
                            html = settings.templates.message(module.add.variables(message))
                          ;
                          if ($message.length > 0) {
                              $message
                                .html(html)
                              ;
                          }
                          else {
                              $message = $('<div/>')
                                .html(html)
                                .addClass(className.message)
                                .appendTo($menu)
                              ;
                          }
                      },
                      optionValue: function (value) {
                          var
                            escapedValue = module.escape.value(value),
                            $option = $input.find('option[value="' + escapedValue + '"]'),
                            hasOption = ($option.length > 0)
                          ;
                          if (hasOption) {
                              return;
                          }
                          // temporarily disconnect observer
                          module.disconnect.selectObserver();
                          if (module.is.single()) {
                              module.verbose('Removing previous user addition');
                              $input.find('option.' + className.addition).remove();
                          }
                          $('<option/>')
                            .prop('value', escapedValue)
                            .addClass(className.addition)
                            .html(value)
                            .appendTo($input)
                          ;
                          module.verbose('Adding user addition as an <option>', value);
                          module.observe.select();
                      },
                      userSuggestion: function (value) {
                          var
                            $addition = $menu.children(selector.addition),
                            $existingItem = module.get.item(value),
                            alreadyHasValue = $existingItem && $existingItem.not(selector.addition).length,
                            hasUserSuggestion = $addition.length > 0,
                            html
                          ;
                          if (settings.useLabels && module.has.maxSelections()) {
                              return;
                          }
                          if (value === '' || alreadyHasValue) {
                              $addition.remove();
                              return;
                          }
                          if (hasUserSuggestion) {
                              $addition
                                .data(metadata.value, value)
                                .data(metadata.text, value)
                                .attr('data-' + metadata.value, value)
                                .attr('data-' + metadata.text, value)
                                .removeClass(className.filtered)
                              ;
                              if (!settings.hideAdditions) {
                                  html = settings.templates.addition(module.add.variables(message.addResult, value));
                                  $addition
                                    .html(html)
                                  ;
                              }
                              module.verbose('Replacing user suggestion with new value', $addition);
                          }
                          else {
                              $addition = module.create.userChoice(value);
                              $addition
                                .prependTo($menu)
                              ;
                              module.verbose('Adding item choice to menu corresponding with user choice addition', $addition);
                          }
                          if (!settings.hideAdditions || module.is.allFiltered()) {
                              $addition
                                .addClass(className.selected)
                                .siblings()
                                .removeClass(className.selected)
                              ;
                          }
                          module.refreshItems();
                      },
                      variables: function (message, term) {
                          var
                            hasCount = (message.search('{count}') !== -1),
                            hasMaxCount = (message.search('{maxCount}') !== -1),
                            hasTerm = (message.search('{term}') !== -1),
                            values,
                            count,
                            query
                          ;
                          module.verbose('Adding templated variables to message', message);
                          if (hasCount) {
                              count = module.get.selectionCount();
                              message = message.replace('{count}', count);
                          }
                          if (hasMaxCount) {
                              count = module.get.selectionCount();
                              message = message.replace('{maxCount}', settings.maxSelections);
                          }
                          if (hasTerm) {
                              query = term || module.get.query();
                              message = message.replace('{term}', query);
                          }
                          return message;
                      },
                      value: function (addedValue, addedText, $selectedItem) {
                          var
                            currentValue = module.get.values(),
                            newValue
                          ;
                          if (addedValue === '') {
                              module.debug('Cannot select blank values from multiselect');
                              return;
                          }
                          // extend current array
                          if ($.isArray(currentValue)) {
                              newValue = currentValue.concat([addedValue]);
                              newValue = module.get.uniqueArray(newValue);
                          }
                          else {
                              newValue = [addedValue];
                          }
                          // add values
                          if (module.has.selectInput()) {
                              if (module.can.extendSelect()) {
                                  module.debug('Adding value to select', addedValue, newValue, $input);
                                  module.add.optionValue(addedValue);
                              }
                          }
                          else {
                              newValue = newValue.join(settings.delimiter);
                              module.debug('Setting hidden input to delimited value', newValue, $input);
                          }

                          if (settings.fireOnInit === false && module.is.initialLoad()) {
                              module.verbose('Skipping onadd callback on initial load', settings.onAdd);
                          }
                          else {
                              settings.onAdd.call(element, addedValue, addedText, $selectedItem);
                          }
                          module.set.value(newValue, addedValue, addedText, $selectedItem);
                          module.check.maxSelections();
                      }
                  },

                  remove: {
                      active: function () {
                          $module.removeClass(className.active);
                      },
                      activeLabel: function () {
                          $module.find(selector.label).removeClass(className.active);
                      },
                      empty: function () {
                          $module.removeClass(className.empty);
                      },
                      loading: function () {
                          $module.removeClass(className.loading);
                      },
                      initialLoad: function () {
                          initialLoad = false;
                      },
                      upward: function ($menu) {
                          var $element = $menu || $module;
                          $element.removeClass(className.upward);
                      },
                      visible: function () {
                          $module.removeClass(className.visible);
                      },
                      activeItem: function () {
                          $item.removeClass(className.active);
                      },
                      filteredItem: function () {
                          if (settings.useLabels && module.has.maxSelections()) {
                              return;
                          }
                          if (settings.useLabels && module.is.multiple()) {
                              $item.not('.' + className.active).removeClass(className.filtered);
                          }
                          else {
                              $item.removeClass(className.filtered);
                          }
                          module.remove.empty();
                      },
                      optionValue: function (value) {
                          var
                            escapedValue = module.escape.value(value),
                            $option = $input.find('option[value="' + escapedValue + '"]'),
                            hasOption = ($option.length > 0)
                          ;
                          if (!hasOption || !$option.hasClass(className.addition)) {
                              return;
                          }
                          // temporarily disconnect observer
                          if (selectObserver) {
                              selectObserver.disconnect();
                              module.verbose('Temporarily disconnecting mutation observer');
                          }
                          $option.remove();
                          module.verbose('Removing user addition as an <option>', escapedValue);
                          if (selectObserver) {
                              selectObserver.observe($input[0], {
                                  childList: true,
                                  subtree: true
                              });
                          }
                      },
                      message: function () {
                          $menu.children(selector.message).remove();
                      },
                      searchWidth: function () {
                          $search.css('width', '');
                      },
                      searchTerm: function () {
                          module.verbose('Cleared search term');
                          $search.val('');
                          module.set.filtered();
                      },
                      userAddition: function () {
                          $item.filter(selector.addition).remove();
                      },
                      selected: function (value, $selectedItem) {
                          $selectedItem = (settings.allowAdditions)
                            ? $selectedItem || module.get.itemWithAdditions(value)
                            : $selectedItem || module.get.item(value)
                          ;

                          if (!$selectedItem) {
                              return false;
                          }

                          $selectedItem
                            .each(function () {
                                var
                                  $selected = $(this),
                                  selectedText = module.get.choiceText($selected),
                                  selectedValue = module.get.choiceValue($selected, selectedText)
                                ;
                                if (module.is.multiple()) {
                                    if (settings.useLabels) {
                                        module.remove.value(selectedValue, selectedText, $selected);
                                        module.remove.label(selectedValue);
                                    }
                                    else {
                                        module.remove.value(selectedValue, selectedText, $selected);
                                        if (module.get.selectionCount() === 0) {
                                            module.set.placeholderText();
                                        }
                                        else {
                                            module.set.text(module.add.variables(message.count));
                                        }
                                    }
                                }
                                else {
                                    module.remove.value(selectedValue, selectedText, $selected);
                                }
                                $selected
                                  .removeClass(className.filtered)
                                  .removeClass(className.active)
                                ;
                                if (settings.useLabels) {
                                    $selected.removeClass(className.selected);
                                }
                            })
                          ;
                      },
                      selectedItem: function () {
                          $item.removeClass(className.selected);
                      },
                      value: function (removedValue, removedText, $removedItem) {
                          var
                            values = module.get.values(),
                            newValue
                          ;
                          if (module.has.selectInput()) {
                              module.verbose('Input is <select> removing selected option', removedValue);
                              newValue = module.remove.arrayValue(removedValue, values);
                              module.remove.optionValue(removedValue);
                          }
                          else {
                              module.verbose('Removing from delimited values', removedValue);
                              newValue = module.remove.arrayValue(removedValue, values);
                              newValue = newValue.join(settings.delimiter);
                          }
                          if (settings.fireOnInit === false && module.is.initialLoad()) {
                              module.verbose('No callback on initial load', settings.onRemove);
                          }
                          else {
                              settings.onRemove.call(element, removedValue, removedText, $removedItem);
                          }
                          module.set.value(newValue, removedText, $removedItem);
                          module.check.maxSelections();
                      },
                      arrayValue: function (removedValue, values) {
                          if (!$.isArray(values)) {
                              values = [values];
                          }
                          values = $.grep(values, function (value) {
                              return (removedValue != value);
                          });
                          module.verbose('Removed value from delimited string', removedValue, values);
                          return values;
                      },
                      label: function (value, shouldAnimate) {
                          var
                            $labels = $module.find(selector.label),
                            $removedLabel = $labels.filter('[data-value="' + value + '"]')
                          ;
                          module.verbose('Removing label', $removedLabel);
                          $removedLabel.remove();
                      },
                      activeLabels: function ($activeLabels) {
                          $activeLabels = $activeLabels || $module.find(selector.label).filter('.' + className.active);
                          module.verbose('Removing active label selections', $activeLabels);
                          module.remove.labels($activeLabels);
                      },
                      labels: function ($labels) {
                          $labels = $labels || $module.find(selector.label);
                          module.verbose('Removing labels', $labels);
                          $labels
                            .each(function () {
                                var
                                  $label = $(this),
                                  value = $label.data(metadata.value),
                                  stringValue = (value !== undefined)
                                    ? String(value)
                                    : value,
                                  isUserValue = module.is.userValue(stringValue)
                                ;
                                if (settings.onLabelRemove.call($label, value) === false) {
                                    module.debug('Label remove callback cancelled removal');
                                    return;
                                }
                                module.remove.message();
                                if (isUserValue) {
                                    module.remove.value(stringValue);
                                    module.remove.label(stringValue);
                                }
                                else {
                                    // selected will also remove label
                                    module.remove.selected(stringValue);
                                }
                            })
                          ;
                      },
                      tabbable: function () {
                          if (module.has.search()) {
                              module.debug('Searchable dropdown initialized');
                              $search
                                .removeAttr('tabindex')
                              ;
                              $menu
                                .removeAttr('tabindex')
                              ;
                          }
                          else {
                              module.debug('Simple selection dropdown initialized');
                              $module
                                .removeAttr('tabindex')
                              ;
                              $menu
                                .removeAttr('tabindex')
                              ;
                          }
                      }
                  },

                  has: {
                      menuSearch: function () {
                          return (module.has.search() && $search.closest($menu).length > 0);
                      },
                      search: function () {
                          return ($search.length > 0);
                      },
                      sizer: function () {
                          return ($sizer.length > 0);
                      },
                      selectInput: function () {
                          return ($input.is('select'));
                      },
                      minCharacters: function (searchTerm) {
                          if (settings.minCharacters) {
                              searchTerm = (searchTerm !== undefined)
                                ? String(searchTerm)
                                : String(module.get.query())
                              ;
                              return (searchTerm.length >= settings.minCharacters);
                          }
                          return true;
                      },
                      firstLetter: function ($item, letter) {
                          var
                            text,
                            firstLetter
                          ;
                          if (!$item || $item.length === 0 || typeof letter !== 'string') {
                              return false;
                          }
                          text = module.get.choiceText($item, false);
                          letter = letter.toLowerCase();
                          firstLetter = String(text).charAt(0).toLowerCase();
                          return (letter == firstLetter);
                      },
                      input: function () {
                          return ($input.length > 0);
                      },
                      items: function () {
                          return ($item.length > 0);
                      },
                      menu: function () {
                          return ($menu.length > 0);
                      },
                      message: function () {
                          return ($menu.children(selector.message).length !== 0);
                      },
                      label: function (value) {
                          var
                            escapedValue = module.escape.value(value),
                            $labels = $module.find(selector.label)
                          ;
                          return ($labels.filter('[data-value="' + escapedValue + '"]').length > 0);
                      },
                      maxSelections: function () {
                          return (settings.maxSelections && module.get.selectionCount() >= settings.maxSelections);
                      },
                      allResultsFiltered: function () {
                          var
                            $normalResults = $item.not(selector.addition)
                          ;
                          return ($normalResults.filter(selector.unselectable).length === $normalResults.length);
                      },
                      userSuggestion: function () {
                          return ($menu.children(selector.addition).length > 0);
                      },
                      query: function () {
                          return (module.get.query() !== '');
                      },
                      value: function (value) {
                          var
                            values = module.get.values(),
                            hasValue = $.isArray(values)
                             ? values && ($.inArray(value, values) !== -1)
                             : (values == value)
                          ;
                          return (hasValue)
                            ? true
                            : false
                          ;
                      }
                  },

                  is: {
                      active: function () {
                          return $module.hasClass(className.active);
                      },
                      bubbledLabelClick: function (event) {
                          return $(event.target).is('select, input') && $module.closest('label').length > 0;
                      },
                      alreadySetup: function () {
                          return ($module.is('select') && $module.parent(selector.dropdown).length > 0 && $module.prev().length === 0);
                      },
                      animating: function ($subMenu) {
                          return ($subMenu)
                            ? $subMenu.transition && $subMenu.transition('is animating')
                            : $menu.transition && $menu.transition('is animating')
                          ;
                      },
                      disabled: function () {
                          return $module.hasClass(className.disabled);
                      },
                      focused: function () {
                          return (document.activeElement === $module[0]);
                      },
                      focusedOnSearch: function () {
                          return (document.activeElement === $search[0]);
                      },
                      allFiltered: function () {
                          return ((module.is.multiple() || module.has.search()) && !(settings.hideAdditions == false && module.has.userSuggestion()) && !module.has.message() && module.has.allResultsFiltered());
                      },
                      hidden: function ($subMenu) {
                          return !module.is.visible($subMenu);
                      },
                      initialLoad: function () {
                          return initialLoad;
                      },
                      onScreen: function ($subMenu) {
                          var
                            $currentMenu = $subMenu || $menu,
                            canOpenDownward = true,
                            onScreen = {},
                            calculations
                          ;
                          $currentMenu.addClass(className.loading);
                          calculations = {
                              context: {
                                  scrollTop: $context.scrollTop(),
                                  height: $context.outerHeight()
                              },
                              menu: {
                                  offset: $currentMenu.offset(),
                                  height: $currentMenu.outerHeight()
                              }
                          };
                          onScreen = {
                              above: (calculations.context.scrollTop) <= calculations.menu.offset.top - calculations.menu.height,
                              below: (calculations.context.scrollTop + calculations.context.height) >= calculations.menu.offset.top + calculations.menu.height
                          };
                          if (onScreen.below) {
                              module.verbose('Dropdown can fit in context downward', onScreen);
                              canOpenDownward = true;
                          }
                          else if (!onScreen.below && !onScreen.above) {
                              module.verbose('Dropdown cannot fit in either direction, favoring downward', onScreen);
                              canOpenDownward = true;
                          }
                          else {
                              module.verbose('Dropdown cannot fit below, opening upward', onScreen);
                              canOpenDownward = false;
                          }
                          $currentMenu.removeClass(className.loading);
                          return canOpenDownward;
                      },
                      inObject: function (needle, object) {
                          var
                            found = false
                          ;
                          $.each(object, function (index, property) {
                              if (property == needle) {
                                  found = true;
                                  return true;
                              }
                          });
                          return found;
                      },
                      multiple: function () {
                          return $module.hasClass(className.multiple);
                      },
                      single: function () {
                          return !module.is.multiple();
                      },
                      selectMutation: function (mutations) {
                          var
                            selectChanged = false
                          ;
                          $.each(mutations, function (index, mutation) {
                              if (mutation.target && $(mutation.target).is('select')) {
                                  selectChanged = true;
                                  return true;
                              }
                          });
                          return selectChanged;
                      },
                      search: function () {
                          return $module.hasClass(className.search);
                      },
                      searchSelection: function () {
                          return (module.has.search() && $search.parent(selector.dropdown).length === 1);
                      },
                      selection: function () {
                          return $module.hasClass(className.selection);
                      },
                      userValue: function (value) {
                          return ($.inArray(value, module.get.userValues()) !== -1);
                      },
                      upward: function ($menu) {
                          var $element = $menu || $module;
                          return $element.hasClass(className.upward);
                      },
                      visible: function ($subMenu) {
                          return ($subMenu)
                            ? $subMenu.hasClass(className.visible)
                            : $menu.hasClass(className.visible)
                          ;
                      }
                  },

                  can: {
                      activate: function ($item) {
                          if (settings.useLabels) {
                              return true;
                          }
                          if (!module.has.maxSelections()) {
                              return true;
                          }
                          if (module.has.maxSelections() && $item.hasClass(className.active)) {
                              return true;
                          }
                          return false;
                      },
                      click: function () {
                          return (hasTouch || settings.on == 'click');
                      },
                      extendSelect: function () {
                          return settings.allowAdditions || settings.apiSettings;
                      },
                      show: function () {
                          return !module.is.disabled() && (module.has.items() || module.has.message());
                      },
                      useAPI: function () {
                          return $.fn.api !== undefined;
                      }
                  },

                  animate: {
                      show: function (callback, $subMenu) {
                          var
                            $currentMenu = $subMenu || $menu,
                            start = ($subMenu)
                              ? function () { }
                              : function () {
                                  module.hideSubMenus();
                                  module.hideOthers();
                                  module.set.active();
                              },
                            transition
                          ;
                          callback = $.isFunction(callback)
                            ? callback
                            : function () { }
                          ;
                          module.verbose('Doing menu show animation', $currentMenu);
                          module.set.direction($subMenu);
                          transition = module.get.transition($subMenu);
                          if (module.is.selection()) {
                              module.set.scrollPosition(module.get.selectedItem(), true);
                          }
                          if (module.is.hidden($currentMenu) || module.is.animating($currentMenu)) {
                              if (transition == 'none') {
                                  start();
                                  $currentMenu.transition('show');
                                  callback.call(element);
                              }
                              else if ($.fn.transition !== undefined && $module.transition('is supported')) {
                                  $currentMenu
                                    .transition({
                                        animation: transition + ' in',
                                        debug: settings.debug,
                                        verbose: settings.verbose,
                                        duration: settings.duration,
                                        queue: true,
                                        onStart: start,
                                        onComplete: function () {
                                            callback.call(element);
                                        }
                                    })
                                  ;
                              }
                              else {
                                  module.error(error.noTransition, transition);
                              }
                          }
                      },
                      hide: function (callback, $subMenu) {
                          var
                            $currentMenu = $subMenu || $menu,
                            duration = ($subMenu)
                              ? (settings.duration * 0.9)
                              : settings.duration,
                            start = ($subMenu)
                              ? function () { }
                              : function () {
                                  if (module.can.click()) {
                                      module.unbind.intent();
                                  }
                                  module.remove.active();
                              },
                            transition = module.get.transition($subMenu)
                          ;
                          callback = $.isFunction(callback)
                            ? callback
                            : function () { }
                          ;
                          if (module.is.visible($currentMenu) || module.is.animating($currentMenu)) {
                              module.verbose('Doing menu hide animation', $currentMenu);

                              if (transition == 'none') {
                                  start();
                                  $currentMenu.transition('hide');
                                  callback.call(element);
                              }
                              else if ($.fn.transition !== undefined && $module.transition('is supported')) {
                                  $currentMenu
                                    .transition({
                                        animation: transition + ' out',
                                        duration: settings.duration,
                                        debug: settings.debug,
                                        verbose: settings.verbose,
                                        queue: true,
                                        onStart: start,
                                        onComplete: function () {
                                            if (settings.direction == 'auto') {
                                                module.remove.upward($subMenu);
                                            }
                                            callback.call(element);
                                        }
                                    })
                                  ;
                              }
                              else {
                                  module.error(error.transition);
                              }
                          }
                      }
                  },

                  hideAndClear: function () {
                      module.remove.searchTerm();
                      if (module.has.maxSelections()) {
                          return;
                      }
                      if (module.has.search()) {
                          module.hide(function () {
                              module.remove.filteredItem();
                          });
                      }
                      else {
                          module.hide();
                      }
                  },

                  delay: {
                      show: function () {
                          module.verbose('Delaying show event to ensure user intent');
                          clearTimeout(module.timer);
                          module.timer = setTimeout(module.show, settings.delay.show);
                      },
                      hide: function () {
                          module.verbose('Delaying hide event to ensure user intent');
                          clearTimeout(module.timer);
                          module.timer = setTimeout(module.hide, settings.delay.hide);
                      }
                  },

                  escape: {
                      value: function (value) {
                          var
                            multipleValues = $.isArray(value),
                            stringValue = (typeof value === 'string'),
                            isUnparsable = (!stringValue && !multipleValues),
                            hasQuotes = (stringValue && value.search(regExp.quote) !== -1),
                            values = []
                          ;
                          if (!module.has.selectInput() || isUnparsable || !hasQuotes) {
                              return value;
                          }
                          module.debug('Encoding quote values for use in select', value);
                          if (multipleValues) {
                              $.each(value, function (index, value) {
                                  values.push(value.replace(regExp.quote, '&quot;'));
                              });
                              return values;
                          }
                          return value.replace(regExp.quote, '&quot;');
                      },
                      regExp: function (text) {
                          text = String(text);
                          return text.replace(regExp.escape, '\\$&');
                      }
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;
        return (returnedValue !== undefined)
          ? returnedValue
          : $allModules
        ;
    };

    $.fn.dropdown.settings = {

        silent: false,
        debug: false,
        verbose: false,
        performance: true,

        on: 'click',    // what event should show menu action on item selection
        action: 'activate', // action on item selection (nothing, activate, select, combo, hide, function(){})


        apiSettings: false,
        selectOnKeydown: true,       // Whether selection should occur automatically when keyboard shortcuts used
        minCharacters: 0,          // Minimum characters required to trigger API call
        saveRemoteData: true,       // Whether remote name/value pairs should be stored in sessionStorage to allow remote data to be restored on page refresh
        throttle: 200,        // How long to wait after last user input to search remotely

        context: window,     // Context to use when determining if on screen
        direction: 'auto',     // Whether dropdown should always open in one direction
        keepOnScreen: true,       // Whether dropdown should check whether it is on screen before showing

        match: 'both',     // what to match against with search selection (both, text, or label)
        fullTextSearch: false,      // search anywhere in value (set to 'exact' to require exact matches)

        placeholder: 'auto',     // whether to convert blank <select> values to placeholder text
        preserveHTML: true,       // preserve html when selecting value
        sortSelect: false,      // sort selection on init

        forceSelection: true,       // force a choice on blur with search selection

        allowAdditions: false,      // whether multiple select should allow user added values
        hideAdditions: true,      // whether or not to hide special message prompting a user they can enter a value

        maxSelections: false,      // When set to a number limits the number of selections to this count
        useLabels: true,       // whether multiple select should filter currently active selections from choices
        delimiter: ',',        // when multiselect uses normal <input> the values will be delimited with this character

        showOnFocus: true,       // show menu on focus
        allowReselection: false,      // whether current value should trigger callbacks when reselected
        allowTab: true,       // add tabindex to element
        allowCategorySelection: false,      // allow elements with sub-menus to be selected

        fireOnInit: false,      // Whether callbacks should fire when initializing dropdown values

        transition: 'auto',     // auto transition will slide down or up based on direction
        duration: 200,        // duration of transition

        glyphWidth: 1.037,      // widest glyph width in em (W is 1.037 em) used to calculate multiselect input width

        // label settings on multi-select
        label: {
            transition: 'scale',
            duration: 200,
            variation: false
        },

        // delay before event
        delay: {
            hide: 300,
            show: 200,
            search: 20,
            touch: 50
        },

        /* Callbacks */
        onChange: function (value, text, $selected) { },
        onAdd: function (value, text, $selected) { },
        onRemove: function (value, text, $selected) { },

        onLabelSelect: function ($selectedLabels) { },
        onLabelCreate: function (value, text) { return $(this); },
        onLabelRemove: function (value) { return true; },
        onNoResults: function (searchTerm) { return true; },
        onShow: function () { },
        onHide: function () { },

        /* Component */
        name: 'Dropdown',
        namespace: 'dropdown',

        message: {
            addResult: 'Add <b>{term}</b>',
            count: '{count} selected',
            maxSelections: 'Max {maxCount} selections',
            noResults: 'No results found.',
            serverError: 'There was an error contacting the server'
        },

        error: {
            action: 'You called a dropdown action that was not defined',
            alreadySetup: 'Once a select has been initialized behaviors must be called on the created ui dropdown',
            labels: 'Allowing user additions currently requires the use of labels.',
            missingMultiple: '<select> requires multiple property to be set to correctly preserve multiple values',
            method: 'The method you called is not defined.',
            noAPI: 'The API module is required to load resources remotely',
            noStorage: 'Saving remote data requires session storage',
            noTransition: 'This module requires ui transitions <https://github.com/Semantic-Org/UI-Transition>'
        },

        regExp: {
            escape: /[-[\]{}()*+?.,\\^$|#\s]/g,
            quote: /"/g
        },

        metadata: {
            defaultText: 'defaultText',
            defaultValue: 'defaultValue',
            placeholderText: 'placeholder',
            text: 'text',
            value: 'value'
        },

        // property names for remote query
        fields: {
            remoteValues: 'results',  // grouping for api results
            values: 'values',   // grouping for all dropdown values
            disabled: 'disabled', // whether value should be disabled
            name: 'name',     // displayed dropdown text
            value: 'value',    // actual dropdown value
            text: 'text'      // displayed text when selected
        },

        keys: {
            backspace: 8,
            delimiter: 188, // comma
            deleteKey: 46,
            enter: 13,
            escape: 27,
            pageUp: 33,
            pageDown: 34,
            leftArrow: 37,
            upArrow: 38,
            rightArrow: 39,
            downArrow: 40
        },

        selector: {
            addition: '.addition',
            dropdown: '.ui.dropdown',
            hidden: '.hidden',
            icon: '> .dropdown.icon',
            input: '> input[type="hidden"], > select',
            item: '.item',
            label: '> .label',
            remove: '> .label > .delete.icon',
            siblingLabel: '.label',
            menu: '.menu',
            message: '.message',
            menuIcon: '.dropdown.icon',
            search: 'input.search, .menu > .search > input, .menu input.search',
            sizer: '> input.sizer',
            text: '> .text:not(.icon)',
            unselectable: '.disabled, .filtered'
        },

        className: {
            active: 'active',
            addition: 'addition',
            animating: 'animating',
            disabled: 'disabled',
            empty: 'empty',
            dropdown: 'ui dropdown',
            filtered: 'filtered',
            hidden: 'hidden transition',
            item: 'item',
            label: 'ui label',
            loading: 'loading',
            menu: 'menu',
            message: 'message',
            multiple: 'multiple',
            placeholder: 'default',
            sizer: 'sizer',
            search: 'search',
            selected: 'selected',
            selection: 'selection',
            upward: 'upward',
            visible: 'visible'
        }

    };

    /* Templates */
    $.fn.dropdown.settings.templates = {

        // generates dropdown from select values
        dropdown: function (select) {
            var
              placeholder = select.placeholder || false,
              values = select.values || {},
              html = ''
            ;
            html += '<i class="dropdown icon"></i>';
            if (select.placeholder) {
                html += '<div class="default text">' + placeholder + '</div>';
            }
            else {
                html += '<div class="text"></div>';
            }
            html += '<div class="menu">';
            $.each(select.values, function (index, option) {
                html += (option.disabled)
                  ? '<div class="disabled item" data-value="' + option.value + '">' + option.name + '</div>'
                  : '<div class="item" data-value="' + option.value + '">' + option.name + '</div>'
                ;
            });
            html += '</div>';
            return html;
        },

        // generates just menu from select
        menu: function (response, fields) {
            var
              values = response[fields.values] || {},
              html = ''
            ;
            $.each(values, function (index, option) {
                var
                  maybeText = (option[fields.text])
                    ? 'data-text="' + option[fields.text] + '"'
                    : '',
                  maybeDisabled = (option[fields.disabled])
                    ? 'disabled '
                    : ''
                ;
                html += '<div class="' + maybeDisabled + 'item" data-value="' + option[fields.value] + '"' + maybeText + '>';
                html += '<div class="content">';
                html += '<h4>' + option[fields.name] + '</h4>';
                if (fields['description'])
                    html += '<div class="meta">' + option[fields.description] + '</div>';
                html += '</div></div>';

            });
            return html;
        },

        // generates label for multiselect
        label: function (value, text) {
            return text + '<i class="delete icon"></i>';
        },


        // generates messages like "No results"
        message: function (message) {
            return message;
        },

        // generates user addition to selection menu
        addition: function (choice) {
            return choice;
        }

    };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Embed
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.embed = function (parameters) {

        var
          $allModules = $(this),

          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          returnedValue
        ;

        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.embed.settings, parameters)
                  : $.extend({}, $.fn.embed.settings),

                selector = settings.selector,
                className = settings.className,
                sources = settings.sources,
                error = settings.error,
                metadata = settings.metadata,
                namespace = settings.namespace,
                templates = settings.templates,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                $window = $(window),
                $module = $(this),
                $placeholder = $module.find(selector.placeholder),
                $icon = $module.find(selector.icon),
                $embed = $module.find(selector.embed),

                element = this,
                instance = $module.data(moduleNamespace),
                module
              ;

              module = {

                  initialize: function () {
                      module.debug('Initializing embed');
                      module.determine.autoplay();
                      module.create();
                      module.bind.events();
                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous instance of embed');
                      module.reset();
                      $module
                        .removeData(moduleNamespace)
                        .off(eventNamespace)
                      ;
                  },

                  refresh: function () {
                      module.verbose('Refreshing selector cache');
                      $placeholder = $module.find(selector.placeholder);
                      $icon = $module.find(selector.icon);
                      $embed = $module.find(selector.embed);
                  },

                  bind: {
                      events: function () {
                          if (module.has.placeholder()) {
                              module.debug('Adding placeholder events');
                              $module
                                .on('click' + eventNamespace, selector.placeholder, module.createAndShow)
                                .on('click' + eventNamespace, selector.icon, module.createAndShow)
                              ;
                          }
                      }
                  },

                  create: function () {
                      var
                        placeholder = module.get.placeholder()
                      ;
                      if (placeholder) {
                          module.createPlaceholder();
                      }
                      else {
                          module.createAndShow();
                      }
                  },

                  createPlaceholder: function (placeholder) {
                      var
                        icon = module.get.icon(),
                        url = module.get.url(),
                        embed = module.generate.embed(url)
                      ;
                      placeholder = placeholder || module.get.placeholder();
                      $module.html(templates.placeholder(placeholder, icon));
                      module.debug('Creating placeholder for embed', placeholder, icon);
                  },

                  createEmbed: function (url) {
                      module.refresh();
                      url = url || module.get.url();
                      $embed = $('<div/>')
                        .addClass(className.embed)
                        .html(module.generate.embed(url))
                        .appendTo($module)
                      ;
                      settings.onCreate.call(element, url);
                      module.debug('Creating embed object', $embed);
                  },

                  changeEmbed: function (url) {
                      $embed
                        .html(module.generate.embed(url))
                      ;
                  },

                  createAndShow: function () {
                      module.createEmbed();
                      module.show();
                  },

                  // sets new embed
                  change: function (source, id, url) {
                      module.debug('Changing video to ', source, id, url);
                      $module
                        .data(metadata.source, source)
                        .data(metadata.id, id)
                      ;
                      if (url) {
                          $module.data(metadata.url, url);
                      }
                      else {
                          $module.removeData(metadata.url);
                      }
                      if (module.has.embed()) {
                          module.changeEmbed();
                      }
                      else {
                          module.create();
                      }
                  },

                  // clears embed
                  reset: function () {
                      module.debug('Clearing embed and showing placeholder');
                      module.remove.active();
                      module.remove.embed();
                      module.showPlaceholder();
                      settings.onReset.call(element);
                  },

                  // shows current embed
                  show: function () {
                      module.debug('Showing embed');
                      module.set.active();
                      settings.onDisplay.call(element);
                  },

                  hide: function () {
                      module.debug('Hiding embed');
                      module.showPlaceholder();
                  },

                  showPlaceholder: function () {
                      module.debug('Showing placeholder image');
                      module.remove.active();
                      settings.onPlaceholderDisplay.call(element);
                  },

                  get: {
                      id: function () {
                          return settings.id || $module.data(metadata.id);
                      },
                      placeholder: function () {
                          return settings.placeholder || $module.data(metadata.placeholder);
                      },
                      icon: function () {
                          return (settings.icon)
                            ? settings.icon
                            : ($module.data(metadata.icon) !== undefined)
                              ? $module.data(metadata.icon)
                              : module.determine.icon()
                          ;
                      },
                      source: function (url) {
                          return (settings.source)
                            ? settings.source
                            : ($module.data(metadata.source) !== undefined)
                              ? $module.data(metadata.source)
                              : module.determine.source()
                          ;
                      },
                      type: function () {
                          var source = module.get.source();
                          return (sources[source] !== undefined)
                            ? sources[source].type
                            : false
                          ;
                      },
                      url: function () {
                          return (settings.url)
                            ? settings.url
                            : ($module.data(metadata.url) !== undefined)
                              ? $module.data(metadata.url)
                              : module.determine.url()
                          ;
                      }
                  },

                  determine: {
                      autoplay: function () {
                          if (module.should.autoplay()) {
                              settings.autoplay = true;
                          }
                      },
                      source: function (url) {
                          var
                            matchedSource = false
                          ;
                          url = url || module.get.url();
                          if (url) {
                              $.each(sources, function (name, source) {
                                  if (url.search(source.domain) !== -1) {
                                      matchedSource = name;
                                      return false;
                                  }
                              });
                          }
                          return matchedSource;
                      },
                      icon: function () {
                          var
                            source = module.get.source()
                          ;
                          return (sources[source] !== undefined)
                            ? sources[source].icon
                            : false
                          ;
                      },
                      url: function () {
                          var
                            id = settings.id || $module.data(metadata.id),
                            source = settings.source || $module.data(metadata.source),
                            url
                          ;
                          url = (sources[source] !== undefined)
                            ? sources[source].url.replace('{id}', id)
                            : false
                          ;
                          if (url) {
                              $module.data(metadata.url, url);
                          }
                          return url;
                      }
                  },


                  set: {
                      active: function () {
                          $module.addClass(className.active);
                      }
                  },

                  remove: {
                      active: function () {
                          $module.removeClass(className.active);
                      },
                      embed: function () {
                          $embed.empty();
                      }
                  },

                  encode: {
                      parameters: function (parameters) {
                          var
                            urlString = [],
                            index
                          ;
                          for (index in parameters) {
                              urlString.push(encodeURIComponent(index) + '=' + encodeURIComponent(parameters[index]));
                          }
                          return urlString.join('&amp;');
                      }
                  },

                  generate: {
                      embed: function (url) {
                          module.debug('Generating embed html');
                          var
                            source = module.get.source(),
                            html,
                            parameters
                          ;
                          url = module.get.url(url);
                          if (url) {
                              parameters = module.generate.parameters(source);
                              html = templates.iframe(url, parameters);
                          }
                          else {
                              module.error(error.noURL, $module);
                          }
                          return html;
                      },
                      parameters: function (source, extraParameters) {
                          var
                            parameters = (sources[source] && sources[source].parameters !== undefined)
                              ? sources[source].parameters(settings)
                              : {}
                          ;
                          extraParameters = extraParameters || settings.parameters;
                          if (extraParameters) {
                              parameters = $.extend({}, parameters, extraParameters);
                          }
                          parameters = settings.onEmbed(parameters);
                          return module.encode.parameters(parameters);
                      }
                  },

                  has: {
                      embed: function () {
                          return ($embed.length > 0);
                      },
                      placeholder: function () {
                          return settings.placeholder || $module.data(metadata.placeholder);
                      }
                  },

                  should: {
                      autoplay: function () {
                          return (settings.autoplay === 'auto')
                            ? (settings.placeholder || $module.data(metadata.placeholder) !== undefined)
                            : settings.autoplay
                          ;
                      }
                  },

                  is: {
                      video: function () {
                          return module.get.type() == 'video';
                      }
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ($allModules.length > 1) {
                              title += ' ' + '(' + $allModules.length + ')';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;
        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.embed.settings = {

        name: 'Embed',
        namespace: 'embed',

        silent: false,
        debug: false,
        verbose: false,
        performance: true,

        icon: false,
        source: false,
        url: false,
        id: false,

        // standard video settings
        autoplay: 'auto',
        color: '#444444',
        hd: true,
        brandedUI: false,

        // additional parameters to include with the embed
        parameters: false,

        onDisplay: function () { },
        onPlaceholderDisplay: function () { },
        onReset: function () { },
        onCreate: function (url) { },
        onEmbed: function (parameters) {
            return parameters;
        },

        metadata: {
            id: 'id',
            icon: 'icon',
            placeholder: 'placeholder',
            source: 'source',
            url: 'url'
        },

        error: {
            noURL: 'No URL specified',
            method: 'The method you called is not defined'
        },

        className: {
            active: 'active',
            embed: 'embed'
        },

        selector: {
            embed: '.embed',
            placeholder: '.placeholder',
            icon: '.icon'
        },

        sources: {
            youtube: {
                name: 'youtube',
                type: 'video',
                icon: 'video play',
                domain: 'youtube.com',
                url: '//www.youtube.com/embed/{id}',
                parameters: function (settings) {
                    return {
                        autohide: !settings.brandedUI,
                        autoplay: settings.autoplay,
                        color: settings.color || undefined,
                        hq: settings.hd,
                        jsapi: settings.api,
                        modestbranding: !settings.brandedUI
                    };
                }
            },
            vimeo: {
                name: 'vimeo',
                type: 'video',
                icon: 'video play',
                domain: 'vimeo.com',
                url: '//player.vimeo.com/video/{id}',
                parameters: function (settings) {
                    return {
                        api: settings.api,
                        autoplay: settings.autoplay,
                        byline: settings.brandedUI,
                        color: settings.color || undefined,
                        portrait: settings.brandedUI,
                        title: settings.brandedUI
                    };
                }
            }
        },

        templates: {
            iframe: function (url, parameters) {
                var src = url;
                if (parameters) {
                    src += '?' + parameters;
                }
                return ''
                  + '<iframe src="' + src + '"'
                  + ' width="100%" height="100%"'
                  + ' frameborder="0" scrolling="no" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe>'
                ;
            },
            placeholder: function (image, icon) {
                var
                  html = ''
                ;
                if (icon) {
                    html += '<i class="' + icon + ' icon"></i>';
                }
                if (image) {
                    html += '<img class="placeholder" src="' + image + '">';
                }
                return html;
            }
        },

        // NOT YET IMPLEMENTED
        api: false,
        onPause: function () { },
        onPlay: function () { },
        onStop: function () { }

    };



})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Modal
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.modal = function (parameters) {
        var
          $allModules = $(this),
          $window = $(window),
          $document = $(document),
          $body = $('body'),

          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          requestAnimationFrame = window.requestAnimationFrame
            || window.mozRequestAnimationFrame
            || window.webkitRequestAnimationFrame
            || window.msRequestAnimationFrame
            || function (callback) { setTimeout(callback, 0); },

          returnedValue
        ;

        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.modal.settings, parameters)
                  : $.extend({}, $.fn.modal.settings),

                selector = settings.selector,
                className = settings.className,
                namespace = settings.namespace,
                error = settings.error,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                $module = $(this),
                $context = $(settings.context),
                $close = $module.find(selector.close),

                $allModals,
                $otherModals,
                $focusedElement,
                $dimmable,
                $dimmer,

                element = this,
                instance = $module.data(moduleNamespace),

                elementEventNamespace,
                id,
                observer,
                module
              ;
              module = {

                  initialize: function () {
                      module.verbose('Initializing dimmer', $context);

                      module.create.id();
                      module.create.dimmer();
                      module.refreshModals();

                      module.bind.events();
                      if (settings.observeChanges) {
                          module.observeChanges();
                      }
                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of modal');
                      instance = module;
                      $module
                        .data(moduleNamespace, instance)
                      ;
                  },

                  create: {
                      dimmer: function () {
                          var
                            defaultSettings = {
                                debug: settings.debug,
                                dimmerName: 'modals',
                                duration: {
                                    show: settings.duration,
                                    hide: settings.duration
                                }
                            },
                            dimmerSettings = $.extend(true, defaultSettings, settings.dimmerSettings)
                          ;
                          if (settings.inverted) {
                              dimmerSettings.variation = (dimmerSettings.variation !== undefined)
                                ? dimmerSettings.variation + ' inverted'
                                : 'inverted'
                              ;
                          }
                          if ($.fn.dimmer === undefined) {
                              module.error(error.dimmer);
                              return;
                          }
                          module.debug('Creating dimmer with settings', dimmerSettings);
                          $dimmable = $context.dimmer(dimmerSettings);
                          if (settings.detachable) {
                              module.verbose('Modal is detachable, moving content into dimmer');
                              $dimmable.dimmer('add content', $module);
                          }
                          else {
                              module.set.undetached();
                          }
                          if (settings.blurring) {
                              $dimmable.addClass(className.blurring);
                          }
                          $dimmer = $dimmable.dimmer('get dimmer');
                      },
                      id: function () {
                          id = (Math.random().toString(16) + '000000000').substr(2, 8);
                          elementEventNamespace = '.' + id;
                          module.verbose('Creating unique id for element', id);
                      }
                  },

                  destroy: function () {
                      module.verbose('Destroying previous modal');
                      $module
                        .removeData(moduleNamespace)
                        .off(eventNamespace)
                      ;
                      $window.off(elementEventNamespace);
                      $dimmer.off(elementEventNamespace);
                      $close.off(eventNamespace);
                      $context.dimmer('destroy');
                  },

                  observeChanges: function () {
                      if ('MutationObserver' in window) {
                          observer = new MutationObserver(function (mutations) {
                              module.debug('DOM tree modified, refreshing');
                              module.refresh();
                          });
                          observer.observe(element, {
                              childList: true,
                              subtree: true
                          });
                          module.debug('Setting up mutation observer', observer);
                      }
                  },

                  refresh: function () {
                      module.remove.scrolling();
                      module.cacheSizes();
                      module.set.screenHeight();
                      module.set.type();
                      module.set.position();
                  },

                  refreshModals: function () {
                      $otherModals = $module.siblings(selector.modal);
                      $allModals = $otherModals.add($module);
                  },

                  attachEvents: function (selector, event) {
                      var
                        $toggle = $(selector)
                      ;
                      event = $.isFunction(module[event])
                        ? module[event]
                        : module.toggle
                      ;
                      if ($toggle.length > 0) {
                          module.debug('Attaching modal events to element', selector, event);
                          $toggle
                            .off(eventNamespace)
                            .on('click' + eventNamespace, event)
                          ;
                      }
                      else {
                          module.error(error.notFound, selector);
                      }
                  },

                  bind: {
                      events: function () {
                          module.verbose('Attaching events');
                          $module
                            .on('click' + eventNamespace, selector.close, module.event.close)
                            .on('click' + eventNamespace, selector.approve, module.event.approve)
                            .on('click' + eventNamespace, selector.deny, module.event.deny)
                          ;
                          $window
                            .on('resize' + elementEventNamespace, module.event.resize)
                          ;
                      }
                  },

                  get: {
                      id: function () {
                          return (Math.random().toString(16) + '000000000').substr(2, 8);
                      }
                  },

                  event: {
                      approve: function () {
                          if (settings.onApprove.call(element, $(this)) === false) {
                              module.verbose('Approve callback returned false cancelling hide');
                              return;
                          }
                          module.hide();
                      },
                      deny: function () {
                          if (settings.onDeny.call(element, $(this)) === false) {
                              module.verbose('Deny callback returned false cancelling hide');
                              return;
                          }
                          module.hide();
                      },
                      close: function () {
                          module.hide();
                      },
                      click: function (event) {
                          var
                            $target = $(event.target),
                            isInModal = ($target.closest(selector.modal).length > 0),
                            isInDOM = $.contains(document.documentElement, event.target)
                          ;
                          if (!isInModal && isInDOM) {
                              module.debug('Dimmer clicked, hiding all modals');
                              if (module.is.active()) {
                                  module.remove.clickaway();
                                  if (settings.allowMultiple) {
                                      module.hide();
                                  }
                                  else {
                                      module.hideAll();
                                  }
                              }
                          }
                      },
                      debounce: function (method, delay) {
                          clearTimeout(module.timer);
                          module.timer = setTimeout(method, delay);
                      },
                      keyboard: function (event) {
                          var
                            keyCode = event.which,
                            escapeKey = 27
                          ;
                          if (keyCode == escapeKey) {
                              if (settings.closable) {
                                  module.debug('Escape key pressed hiding modal');
                                  module.hide();
                              }
                              else {
                                  module.debug('Escape key pressed, but closable is set to false');
                              }
                              event.preventDefault();
                          }
                      },
                      resize: function () {
                          if ($dimmable.dimmer('is active')) {
                              requestAnimationFrame(module.refresh);
                          }
                      }
                  },

                  toggle: function () {
                      if (module.is.active() || module.is.animating()) {
                          module.hide();
                      }
                      else {
                          module.show();
                      }
                  },

                  show: function (callback) {
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      module.refreshModals();
                      module.showModal(callback);
                  },

                  hide: function (callback) {
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      module.refreshModals();
                      module.hideModal(callback);
                  },

                  showModal: function (callback) {
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      if (module.is.animating() || !module.is.active()) {

                          module.showDimmer();
                          module.cacheSizes();
                          module.set.position();
                          module.set.screenHeight();
                          module.set.type();
                          module.set.clickaway();

                          if (!settings.allowMultiple && module.others.active()) {
                              module.hideOthers(module.showModal);
                          }
                          else {
                              settings.onShow.call(element);
                              if (settings.transition && $.fn.transition !== undefined && $module.transition('is supported')) {
                                  module.debug('Showing modal with css animations');
                                  $module
                                    .transition({
                                        debug: settings.debug,
                                        animation: settings.transition + ' in',
                                        queue: settings.queue,
                                        duration: settings.duration,
                                        useFailSafe: true,
                                        onComplete: function () {
                                            settings.onVisible.apply(element);
                                            module.add.keyboardShortcuts();
                                            module.save.focus();
                                            module.set.active();
                                            if (settings.autofocus) {
                                                module.set.autofocus();
                                            }
                                            callback();
                                        }
                                    })
                                  ;
                              }
                              else {
                                  module.error(error.noTransition);
                              }
                          }
                      }
                      else {
                          module.debug('Modal is already visible');
                      }
                  },

                  hideModal: function (callback, keepDimmed) {
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      module.debug('Hiding modal');
                      if (settings.onHide.call(element, $(this)) === false) {
                          module.verbose('Hide callback returned false cancelling hide');
                          return;
                      }

                      if (module.is.animating() || module.is.active()) {
                          if (settings.transition && $.fn.transition !== undefined && $module.transition('is supported')) {
                              module.remove.active();
                              $module
                                .transition({
                                    debug: settings.debug,
                                    animation: settings.transition + ' out',
                                    queue: settings.queue,
                                    duration: settings.duration,
                                    useFailSafe: true,
                                    onStart: function () {
                                        if (!module.others.active() && !keepDimmed) {
                                            module.hideDimmer();
                                        }
                                        module.remove.keyboardShortcuts();
                                    },
                                    onComplete: function () {
                                        settings.onHidden.call(element);
                                        module.restore.focus();
                                        callback();
                                    }
                                })
                              ;
                          }
                          else {
                              module.error(error.noTransition);
                          }
                      }
                  },

                  showDimmer: function () {
                      if ($dimmable.dimmer('is animating') || !$dimmable.dimmer('is active')) {
                          module.debug('Showing dimmer');
                          $dimmable.dimmer('show');
                      }
                      else {
                          module.debug('Dimmer already visible');
                      }
                  },

                  hideDimmer: function () {
                      if ($dimmable.dimmer('is animating') || ($dimmable.dimmer('is active'))) {
                          $dimmable.dimmer('hide', function () {
                              module.remove.clickaway();
                              module.remove.screenHeight();
                          });
                      }
                      else {
                          module.debug('Dimmer is not visible cannot hide');
                          return;
                      }
                  },

                  hideAll: function (callback) {
                      var
                        $visibleModals = $allModals.filter('.' + className.active + ', .' + className.animating)
                      ;
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      if ($visibleModals.length > 0) {
                          module.debug('Hiding all visible modals');
                          module.hideDimmer();
                          $visibleModals
                            .modal('hide modal', callback)
                          ;
                      }
                  },

                  hideOthers: function (callback) {
                      var
                        $visibleModals = $otherModals.filter('.' + className.active + ', .' + className.animating)
                      ;
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      if ($visibleModals.length > 0) {
                          module.debug('Hiding other modals', $otherModals);
                          $visibleModals
                            .modal('hide modal', callback, true)
                          ;
                      }
                  },

                  others: {
                      active: function () {
                          return ($otherModals.filter('.' + className.active).length > 0);
                      },
                      animating: function () {
                          return ($otherModals.filter('.' + className.animating).length > 0);
                      }
                  },


                  add: {
                      keyboardShortcuts: function () {
                          module.verbose('Adding keyboard shortcuts');
                          $document
                            .on('keyup' + eventNamespace, module.event.keyboard)
                          ;
                      }
                  },

                  save: {
                      focus: function () {
                          $focusedElement = $(document.activeElement).blur();
                      }
                  },

                  restore: {
                      focus: function () {
                          if ($focusedElement && $focusedElement.length > 0) {
                              $focusedElement.focus();
                          }
                      }
                  },

                  remove: {
                      active: function () {
                          $module.removeClass(className.active);
                      },
                      clickaway: function () {
                          if (settings.closable) {
                              $dimmer
                                .off('click' + elementEventNamespace)
                              ;
                          }
                      },
                      bodyStyle: function () {
                          if ($body.attr('style') === '') {
                              module.verbose('Removing style attribute');
                              $body.removeAttr('style');
                          }
                      },
                      screenHeight: function () {
                          module.debug('Removing page height');
                          $body
                            .css('height', '')
                          ;
                      },
                      keyboardShortcuts: function () {
                          module.verbose('Removing keyboard shortcuts');
                          $document
                            .off('keyup' + eventNamespace)
                          ;
                      },
                      scrolling: function () {
                          $dimmable.removeClass(className.scrolling);
                          $module.removeClass(className.scrolling);
                      }
                  },

                  cacheSizes: function () {
                      var
                        modalHeight = $module.outerHeight()
                      ;
                      if (module.cache === undefined || modalHeight !== 0) {
                          module.cache = {
                              pageHeight: $(document).outerHeight(),
                              height: modalHeight + settings.offset,
                              contextHeight: (settings.context == 'body')
                                ? $(window).height()
                                : $dimmable.height()
                          };
                      }
                      module.debug('Caching modal and container sizes', module.cache);
                  },

                  can: {
                      fit: function () {
                          return ((module.cache.height + (settings.padding * 2)) < module.cache.contextHeight);
                      }
                  },

                  is: {
                      active: function () {
                          return $module.hasClass(className.active);
                      },
                      animating: function () {
                          return $module.transition('is supported')
                            ? $module.transition('is animating')
                            : $module.is(':visible')
                          ;
                      },
                      scrolling: function () {
                          return $dimmable.hasClass(className.scrolling);
                      },
                      modernBrowser: function () {
                          // appName for IE11 reports 'Netscape' can no longer use
                          return !(window.ActiveXObject || "ActiveXObject" in window);
                      }
                  },

                  set: {
                      autofocus: function () {
                          var
                            $inputs = $module.find(':input').filter(':visible'),
                            $autofocus = $inputs.filter('[autofocus]'),
                            $input = ($autofocus.length > 0)
                              ? $autofocus.first()
                              : $inputs.first()
                          ;
                          if ($input.length > 0) {
                              $input.focus();
                          }
                      },
                      clickaway: function () {
                          if (settings.closable) {
                              $dimmer
                                .on('click' + elementEventNamespace, module.event.click)
                              ;
                          }
                      },
                      screenHeight: function () {
                          if (module.can.fit()) {
                              $body.css('height', '');
                          }
                          else {
                              module.debug('Modal is taller than page content, resizing page height');
                              $body
                                .css('height', module.cache.height + (settings.padding * 2))
                              ;
                          }
                      },
                      active: function () {
                          $module.addClass(className.active);
                      },
                      scrolling: function () {
                          $dimmable.addClass(className.scrolling);
                          $module.addClass(className.scrolling);
                      },
                      type: function () {
                          if (module.can.fit()) {
                              module.verbose('Modal fits on screen');
                              if (!module.others.active() && !module.others.animating()) {
                                  module.remove.scrolling();
                              }
                          }
                          else {
                              module.verbose('Modal cannot fit on screen setting to scrolling');
                              module.set.scrolling();
                          }
                      },
                      position: function () {
                          module.verbose('Centering modal on page', module.cache);
                          if (module.can.fit()) {
                              $module
                                .css({
                                    top: '',
                                    marginTop: -(module.cache.height / 2)
                                })
                              ;
                          }
                          else {
                              $module
                                .css({
                                    marginTop: '',
                                    top: $document.scrollTop()
                                })
                              ;
                          }
                      },
                      undetached: function () {
                          $dimmable.addClass(className.undetached);
                      }
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.modal.settings = {

        name: 'Modal',
        namespace: 'modal',

        silent: false,
        debug: false,
        verbose: false,
        performance: true,

        observeChanges: false,

        allowMultiple: false,
        detachable: true,
        closable: true,
        autofocus: true,

        inverted: false,
        blurring: false,

        dimmerSettings: {
            closable: false,
            useCSS: true
        },


        context: 'body',

        queue: false,
        duration: 500,
        offset: 0,
        transition: 'scale',

        // padding with edge of page
        padding: 50,

        // called before show animation
        onShow: function () { },

        // called after show animation
        onVisible: function () { },

        // called before hide animation
        onHide: function () { return true; },

        // called after hide animation
        onHidden: function () { },

        // called after approve selector match
        onApprove: function () { return true; },

        // called after deny selector match
        onDeny: function () { return true; },

        selector: {
            close: '> .close',
            approve: '.actions .positive, .actions .approve, .actions .ok',
            deny: '.actions .negative, .actions .deny, .actions .cancel',
            modal: '.ui.modal'
        },
        error: {
            dimmer: 'UI Dimmer, a required component is not included in this page',
            method: 'The method you called is not defined.',
            notFound: 'The element you specified could not be found'
        },
        className: {
            active: 'active',
            animating: 'animating',
            blurring: 'blurring',
            scrolling: 'scrolling',
            undetached: 'undetached'
        }
    };


})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Nag
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.nag = function (parameters) {
        var
          $allModules = $(this),
          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),
          returnedValue
        ;
        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.nag.settings, parameters)
                  : $.extend({}, $.fn.nag.settings),

                className = settings.className,
                selector = settings.selector,
                error = settings.error,
                namespace = settings.namespace,

                eventNamespace = '.' + namespace,
                moduleNamespace = namespace + '-module',

                $module = $(this),

                $close = $module.find(selector.close),
                $context = (settings.context)
                  ? $(settings.context)
                  : $('body'),

                element = this,
                instance = $module.data(moduleNamespace),

                moduleOffset,
                moduleHeight,

                contextWidth,
                contextHeight,
                contextOffset,

                yOffset,
                yPosition,

                timer,
                module,

                requestAnimationFrame = window.requestAnimationFrame
                  || window.mozRequestAnimationFrame
                  || window.webkitRequestAnimationFrame
                  || window.msRequestAnimationFrame
                  || function (callback) { setTimeout(callback, 0); }
              ;
              module = {

                  initialize: function () {
                      module.verbose('Initializing element');

                      $module
                        .on('click' + eventNamespace, selector.close, module.dismiss)
                        .data(moduleNamespace, module)
                      ;

                      if (settings.detachable && $module.parent()[0] !== $context[0]) {
                          $module
                            .detach()
                            .prependTo($context)
                          ;
                      }

                      if (settings.displayTime > 0) {
                          setTimeout(module.hide, settings.displayTime);
                      }
                      module.show();
                  },

                  destroy: function () {
                      module.verbose('Destroying instance');
                      $module
                        .removeData(moduleNamespace)
                        .off(eventNamespace)
                      ;
                  },

                  show: function () {
                      if (module.should.show() && !$module.is(':visible')) {
                          module.debug('Showing nag', settings.animation.show);
                          if (settings.animation.show == 'fade') {
                              $module
                                .fadeIn(settings.duration, settings.easing)
                              ;
                          }
                          else {
                              $module
                                .slideDown(settings.duration, settings.easing)
                              ;
                          }
                      }
                  },

                  hide: function () {
                      module.debug('Showing nag', settings.animation.hide);
                      if (settings.animation.show == 'fade') {
                          $module
                            .fadeIn(settings.duration, settings.easing)
                          ;
                      }
                      else {
                          $module
                            .slideUp(settings.duration, settings.easing)
                          ;
                      }
                  },

                  onHide: function () {
                      module.debug('Removing nag', settings.animation.hide);
                      $module.remove();
                      if (settings.onHide) {
                          settings.onHide();
                      }
                  },

                  dismiss: function (event) {
                      if (settings.storageMethod) {
                          module.storage.set(settings.key, settings.value);
                      }
                      module.hide();
                      event.stopImmediatePropagation();
                      event.preventDefault();
                  },

                  should: {
                      show: function () {
                          if (settings.persist) {
                              module.debug('Persistent nag is set, can show nag');
                              return true;
                          }
                          if (module.storage.get(settings.key) != settings.value.toString()) {
                              module.debug('Stored value is not set, can show nag', module.storage.get(settings.key));
                              return true;
                          }
                          module.debug('Stored value is set, cannot show nag', module.storage.get(settings.key));
                          return false;
                      }
                  },

                  get: {
                      storageOptions: function () {
                          var
                            options = {}
                          ;
                          if (settings.expires) {
                              options.expires = settings.expires;
                          }
                          if (settings.domain) {
                              options.domain = settings.domain;
                          }
                          if (settings.path) {
                              options.path = settings.path;
                          }
                          return options;
                      }
                  },

                  clear: function () {
                      module.storage.remove(settings.key);
                  },

                  storage: {
                      set: function (key, value) {
                          var
                            options = module.get.storageOptions()
                          ;
                          if (settings.storageMethod == 'localstorage' && window.localStorage !== undefined) {
                              window.localStorage.setItem(key, value);
                              module.debug('Value stored using local storage', key, value);
                          }
                          else if (settings.storageMethod == 'sessionstorage' && window.sessionStorage !== undefined) {
                              window.sessionStorage.setItem(key, value);
                              module.debug('Value stored using session storage', key, value);
                          }
                          else if ($.cookie !== undefined) {
                              $.cookie(key, value, options);
                              module.debug('Value stored using cookie', key, value, options);
                          }
                          else {
                              module.error(error.noCookieStorage);
                              return;
                          }
                      },
                      get: function (key, value) {
                          var
                            storedValue
                          ;
                          if (settings.storageMethod == 'localstorage' && window.localStorage !== undefined) {
                              storedValue = window.localStorage.getItem(key);
                          }
                          else if (settings.storageMethod == 'sessionstorage' && window.sessionStorage !== undefined) {
                              storedValue = window.sessionStorage.getItem(key);
                          }
                              // get by cookie
                          else if ($.cookie !== undefined) {
                              storedValue = $.cookie(key);
                          }
                          else {
                              module.error(error.noCookieStorage);
                          }
                          if (storedValue == 'undefined' || storedValue == 'null' || storedValue === undefined || storedValue === null) {
                              storedValue = undefined;
                          }
                          return storedValue;
                      },
                      remove: function (key) {
                          var
                            options = module.get.storageOptions()
                          ;
                          if (settings.storageMethod == 'localstorage' && window.localStorage !== undefined) {
                              window.localStorage.removeItem(key);
                          }
                          else if (settings.storageMethod == 'sessionstorage' && window.sessionStorage !== undefined) {
                              window.sessionStorage.removeItem(key);
                          }
                              // store by cookie
                          else if ($.cookie !== undefined) {
                              $.removeCookie(key, options);
                          }
                          else {
                              module.error(error.noStorage);
                          }
                      }
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.nag.settings = {

        name: 'Nag',

        silent: false,
        debug: false,
        verbose: false,
        performance: true,

        namespace: 'Nag',

        // allows cookie to be overridden
        persist: false,

        // set to zero to require manually dismissal, otherwise hides on its own
        displayTime: 0,

        animation: {
            show: 'slide',
            hide: 'slide'
        },

        context: false,
        detachable: false,

        expires: 30,
        domain: false,
        path: '/',

        // type of storage to use
        storageMethod: 'cookie',

        // value to store in dismissed localstorage/cookie
        key: 'nag',
        value: 'dismiss',

        error: {
            noCookieStorage: '$.cookie is not included. A storage solution is required.',
            noStorage: 'Neither $.cookie or store is defined. A storage solution is required for storing state',
            method: 'The method you called is not defined.'
        },

        className: {
            bottom: 'bottom',
            fixed: 'fixed'
        },

        selector: {
            close: '.close.icon'
        },

        speed: 500,
        easing: 'easeOutQuad',

        onHide: function () { }

    };

    // Adds easing
    $.extend($.easing, {
        easeOutQuad: function (x, t, b, c, d) {
            return -c * (t /= d) * (t - 2) + b;
        }
    });

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Popup
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.popup = function (parameters) {
        var
          $allModules = $(this),
          $document = $(document),
          $window = $(window),
          $body = $('body'),

          moduleSelector = $allModules.selector || '',

          hasTouch = (true),
          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          returnedValue
        ;
        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.popup.settings, parameters)
                  : $.extend({}, $.fn.popup.settings),

                selector = settings.selector,
                className = settings.className,
                error = settings.error,
                metadata = settings.metadata,
                namespace = settings.namespace,

                eventNamespace = '.' + settings.namespace,
                moduleNamespace = 'module-' + namespace,

                $module = $(this),
                $context = $(settings.context),
                $scrollContext = $(settings.scrollContext),
                $boundary = $(settings.boundary),
                $target = (settings.target)
                  ? $(settings.target)
                  : $module,

                $popup,
                $offsetParent,

                searchDepth = 0,
                triedPositions = false,
                openedWithTouch = false,

                element = this,
                instance = $module.data(moduleNamespace),

                documentObserver,
                elementNamespace,
                id,
                module
              ;

              module = {

                  // binds events
                  initialize: function () {
                      module.debug('Initializing', $module);
                      module.createID();
                      module.bind.events();
                      if (!module.exists() && settings.preserve) {
                          module.create();
                      }
                      module.observeChanges();
                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, instance)
                      ;
                  },

                  observeChanges: function () {
                      if ('MutationObserver' in window) {
                          documentObserver = new MutationObserver(module.event.documentChanged);
                          documentObserver.observe(document, {
                              childList: true,
                              subtree: true
                          });
                          module.debug('Setting up mutation observer', documentObserver);
                      }
                  },

                  refresh: function () {
                      if (settings.popup) {
                          $popup = $(settings.popup).eq(0);
                      }
                      else {
                          if (settings.inline) {
                              $popup = $target.nextAll(selector.popup).eq(0);
                              settings.popup = $popup;
                          }
                      }
                      if (settings.popup) {
                          $popup.addClass(className.loading);
                          $offsetParent = module.get.offsetParent();
                          $popup.removeClass(className.loading);
                          if (settings.movePopup && module.has.popup() && module.get.offsetParent($popup)[0] !== $offsetParent[0]) {
                              module.debug('Moving popup to the same offset parent as activating element');
                              $popup
                                .detach()
                                .appendTo($offsetParent)
                              ;
                          }
                      }
                      else {
                          $offsetParent = (settings.inline)
                            ? module.get.offsetParent($target)
                            : module.has.popup()
                              ? module.get.offsetParent($popup)
                              : $body
                          ;
                      }
                      if ($offsetParent.is('html') && $offsetParent[0] !== $body[0]) {
                          module.debug('Setting page as offset parent');
                          $offsetParent = $body;
                      }
                      if (module.get.variation()) {
                          module.set.variation();
                      }
                  },

                  reposition: function () {
                      module.refresh();
                      module.set.position();
                  },

                  destroy: function () {
                      module.debug('Destroying previous module');
                      if (documentObserver) {
                          documentObserver.disconnect();
                      }
                      // remove element only if was created dynamically
                      if ($popup && !settings.preserve) {
                          module.removePopup();
                      }
                      // clear all timeouts
                      clearTimeout(module.hideTimer);
                      clearTimeout(module.showTimer);
                      // remove events
                      module.unbind.close();
                      module.unbind.events();
                      $module
                        .removeData(moduleNamespace)
                      ;
                  },

                  event: {
                      start: function (event) {
                          var
                            delay = ($.isPlainObject(settings.delay))
                              ? settings.delay.show
                              : settings.delay
                          ;
                          clearTimeout(module.hideTimer);
                          if (!openedWithTouch) {
                              module.showTimer = setTimeout(module.show, delay);
                          }
                      },
                      end: function () {
                          var
                            delay = ($.isPlainObject(settings.delay))
                              ? settings.delay.hide
                              : settings.delay
                          ;
                          clearTimeout(module.showTimer);
                          module.hideTimer = setTimeout(module.hide, delay);
                      },
                      touchstart: function (event) {
                          openedWithTouch = true;
                          module.show();
                      },
                      resize: function () {
                          if (module.is.visible()) {
                              module.set.position();
                          }
                      },
                      documentChanged: function (mutations) {
                          [].forEach.call(mutations, function (mutation) {
                              if (mutation.removedNodes) {
                                  [].forEach.call(mutation.removedNodes, function (node) {
                                      if (node == element || $(node).find(element).length > 0) {
                                          module.debug('Element removed from DOM, tearing down events');
                                          module.destroy();
                                      }
                                  });
                              }
                          });
                      },
                      hideGracefully: function (event) {
                          var
                            $target = $(event.target),
                            isInDOM = $.contains(document.documentElement, event.target),
                            inPopup = ($target.closest(selector.popup).length > 0)
                          ;
                          // don't close on clicks inside popup
                          if (event && !inPopup && isInDOM) {
                              module.debug('Click occurred outside popup hiding popup');
                              module.hide();
                          }
                          else {
                              module.debug('Click was inside popup, keeping popup open');
                          }
                      }
                  },

                  // generates popup html from metadata
                  create: function () {
                      var
                        html = module.get.html(),
                        title = module.get.title(),
                        content = module.get.content()
                      ;

                      if (html || content || title) {
                          module.debug('Creating pop-up html');
                          if (!html) {
                              html = settings.templates.popup({
                                  title: title,
                                  content: content
                              });
                          }
                          $popup = $('<div/>')
                            .addClass(className.popup)
                            .data(metadata.activator, $module)
                            .html(html)
                          ;
                          if (settings.inline) {
                              module.verbose('Inserting popup element inline', $popup);
                              $popup
                                .insertAfter($module)
                              ;
                          }
                          else {
                              module.verbose('Appending popup element to body', $popup);
                              $popup
                                .appendTo($context)
                              ;
                          }
                          module.refresh();
                          module.set.variation();

                          if (settings.hoverable) {
                              module.bind.popup();
                          }
                          settings.onCreate.call($popup, element);
                      }
                      else if ($target.next(selector.popup).length !== 0) {
                          module.verbose('Pre-existing popup found');
                          settings.inline = true;
                          settings.popup = $target.next(selector.popup).data(metadata.activator, $module);
                          module.refresh();
                          if (settings.hoverable) {
                              module.bind.popup();
                          }
                      }
                      else if (settings.popup) {
                          $(settings.popup).data(metadata.activator, $module);
                          module.verbose('Used popup specified in settings');
                          module.refresh();
                          if (settings.hoverable) {
                              module.bind.popup();
                          }
                      }
                      else {
                          module.debug('No content specified skipping display', element);
                      }
                  },

                  createID: function () {
                      id = (Math.random().toString(16) + '000000000').substr(2, 8);
                      elementNamespace = '.' + id;
                      module.verbose('Creating unique id for element', id);
                  },

                  // determines popup state
                  toggle: function () {
                      module.debug('Toggling pop-up');
                      if (module.is.hidden()) {
                          module.debug('Popup is hidden, showing pop-up');
                          module.unbind.close();
                          module.show();
                      }
                      else {
                          module.debug('Popup is visible, hiding pop-up');
                          module.hide();
                      }
                  },

                  show: function (callback) {
                      callback = callback || function () { };
                      module.debug('Showing pop-up', settings.transition);
                      if (module.is.hidden() && !(module.is.active() && module.is.dropdown())) {
                          if (!module.exists()) {
                              module.create();
                          }
                          if (settings.onShow.call($popup, element) === false) {
                              module.debug('onShow callback returned false, cancelling popup animation');
                              return;
                          }
                          else if (!settings.preserve && !settings.popup) {
                              module.refresh();
                          }
                          if ($popup && module.set.position()) {
                              module.save.conditions();
                              if (settings.exclusive) {
                                  module.hideAll();
                              }
                              module.animate.show(callback);
                          }
                      }
                  },


                  hide: function (callback) {
                      callback = callback || function () { };
                      if (module.is.visible() || module.is.animating()) {
                          if (settings.onHide.call($popup, element) === false) {
                              module.debug('onHide callback returned false, cancelling popup animation');
                              return;
                          }
                          module.remove.visible();
                          module.unbind.close();
                          module.restore.conditions();
                          module.animate.hide(callback);
                      }
                  },

                  hideAll: function () {
                      $(selector.popup)
                        .filter('.' + className.visible)
                        .each(function () {
                            $(this)
                              .data(metadata.activator)
                                .popup('hide')
                            ;
                        })
                      ;
                  },
                  exists: function () {
                      if (!$popup) {
                          return false;
                      }
                      if (settings.inline || settings.popup) {
                          return (module.has.popup());
                      }
                      else {
                          return ($popup.closest($context).length >= 1)
                            ? true
                            : false
                          ;
                      }
                  },

                  removePopup: function () {
                      if (module.has.popup() && !settings.popup) {
                          module.debug('Removing popup', $popup);
                          $popup.remove();
                          $popup = undefined;
                          settings.onRemove.call($popup, element);
                      }
                  },

                  save: {
                      conditions: function () {
                          module.cache = {
                              title: $module.attr('title')
                          };
                          if (module.cache.title) {
                              $module.removeAttr('title');
                          }
                          module.verbose('Saving original attributes', module.cache.title);
                      }
                  },
                  restore: {
                      conditions: function () {
                          if (module.cache && module.cache.title) {
                              $module.attr('title', module.cache.title);
                              module.verbose('Restoring original attributes', module.cache.title);
                          }
                          return true;
                      }
                  },
                  supports: {
                      svg: function () {
                          return (typeof SVGGraphicsElement === undefined);
                      }
                  },
                  animate: {
                      show: function (callback) {
                          callback = $.isFunction(callback) ? callback : function () { };
                          if (settings.transition && $.fn.transition !== undefined && $module.transition('is supported')) {
                              module.set.visible();
                              $popup
                                .transition({
                                    animation: settings.transition + ' in',
                                    queue: false,
                                    debug: settings.debug,
                                    verbose: settings.verbose,
                                    duration: settings.duration,
                                    onComplete: function () {
                                        module.bind.close();
                                        callback.call($popup, element);
                                        settings.onVisible.call($popup, element);
                                    }
                                })
                              ;
                          }
                          else {
                              module.error(error.noTransition);
                          }
                      },
                      hide: function (callback) {
                          callback = $.isFunction(callback) ? callback : function () { };
                          module.debug('Hiding pop-up');
                          if (settings.onHide.call($popup, element) === false) {
                              module.debug('onHide callback returned false, cancelling popup animation');
                              return;
                          }
                          if (settings.transition && $.fn.transition !== undefined && $module.transition('is supported')) {
                              $popup
                                .transition({
                                    animation: settings.transition + ' out',
                                    queue: false,
                                    duration: settings.duration,
                                    debug: settings.debug,
                                    verbose: settings.verbose,
                                    onComplete: function () {
                                        module.reset();
                                        callback.call($popup, element);
                                        settings.onHidden.call($popup, element);
                                    }
                                })
                              ;
                          }
                          else {
                              module.error(error.noTransition);
                          }
                      }
                  },

                  change: {
                      content: function (html) {
                          $popup.html(html);
                      }
                  },

                  get: {
                      html: function () {
                          $module.removeData(metadata.html);
                          return $module.data(metadata.html) || settings.html;
                      },
                      title: function () {
                          $module.removeData(metadata.title);
                          return $module.data(metadata.title) || settings.title;
                      },
                      content: function () {
                          $module.removeData(metadata.content);
                          return $module.data(metadata.content) || $module.attr('title') || settings.content;
                      },
                      variation: function () {
                          $module.removeData(metadata.variation);
                          return $module.data(metadata.variation) || settings.variation;
                      },
                      popup: function () {
                          return $popup;
                      },
                      popupOffset: function () {
                          return $popup.offset();
                      },
                      calculations: function () {
                          var
                            targetElement = $target[0],
                            isWindow = ($boundary[0] == window),
                            targetPosition = (settings.inline || (settings.popup && settings.movePopup))
                              ? $target.position()
                              : $target.offset(),
                            screenPosition = (isWindow)
                              ? { top: 0, left: 0 }
                              : $boundary.offset(),
                            calculations = {},
                            scroll = (isWindow)
                              ? { top: $window.scrollTop(), left: $window.scrollLeft() }
                              : { top: 0, left: 0 },
                            screen
                          ;
                          calculations = {
                              // element which is launching popup
                              target: {
                                  element: $target[0],
                                  width: $target.outerWidth(),
                                  height: $target.outerHeight(),
                                  top: targetPosition.top,
                                  left: targetPosition.left,
                                  margin: {}
                              },
                              // popup itself
                              popup: {
                                  width: $popup.outerWidth(),
                                  height: $popup.outerHeight()
                              },
                              // offset container (or 3d context)
                              parent: {
                                  width: $offsetParent.outerWidth(),
                                  height: $offsetParent.outerHeight()
                              },
                              // screen boundaries
                              screen: {
                                  top: screenPosition.top,
                                  left: screenPosition.left,
                                  scroll: {
                                      top: scroll.top,
                                      left: scroll.left
                                  },
                                  width: $boundary.width(),
                                  height: $boundary.height()
                              }
                          };

                          // add in container calcs if fluid
                          if (settings.setFluidWidth && module.is.fluid()) {
                              calculations.container = {
                                  width: $popup.parent().outerWidth()
                              };
                              calculations.popup.width = calculations.container.width;
                          }

                          // add in margins if inline
                          calculations.target.margin.top = (settings.inline)
                            ? parseInt(window.getComputedStyle(targetElement).getPropertyValue('margin-top'), 10)
                            : 0
                          ;
                          calculations.target.margin.left = (settings.inline)
                            ? module.is.rtl()
                              ? parseInt(window.getComputedStyle(targetElement).getPropertyValue('margin-right'), 10)
                              : parseInt(window.getComputedStyle(targetElement).getPropertyValue('margin-left'), 10)
                            : 0
                          ;
                          // calculate screen boundaries
                          screen = calculations.screen;
                          calculations.boundary = {
                              top: screen.top + screen.scroll.top,
                              bottom: screen.top + screen.scroll.top + screen.height,
                              left: screen.left + screen.scroll.left,
                              right: screen.left + screen.scroll.left + screen.width
                          };
                          return calculations;
                      },
                      id: function () {
                          return id;
                      },
                      startEvent: function () {
                          if (settings.on == 'hover') {
                              return 'mouseenter';
                          }
                          else if (settings.on == 'focus') {
                              return 'focus';
                          }
                          return false;
                      },
                      scrollEvent: function () {
                          return 'scroll';
                      },
                      endEvent: function () {
                          if (settings.on == 'hover') {
                              return 'mouseleave';
                          }
                          else if (settings.on == 'focus') {
                              return 'blur';
                          }
                          return false;
                      },
                      distanceFromBoundary: function (offset, calculations) {
                          var
                            distanceFromBoundary = {},
                            popup,
                            boundary
                          ;
                          calculations = calculations || module.get.calculations();

                          // shorthand
                          popup = calculations.popup;
                          boundary = calculations.boundary;

                          if (offset) {
                              distanceFromBoundary = {
                                  top: (offset.top - boundary.top),
                                  left: (offset.left - boundary.left),
                                  right: (boundary.right - (offset.left + popup.width)),
                                  bottom: (boundary.bottom - (offset.top + popup.height))
                              };
                              module.verbose('Distance from boundaries determined', offset, distanceFromBoundary);
                          }
                          return distanceFromBoundary;
                      },
                      offsetParent: function ($target) {
                          var
                            element = ($target !== undefined)
                              ? $target[0]
                              : $module[0],
                            parentNode = element.parentNode,
                            $node = $(parentNode)
                          ;
                          if (parentNode) {
                              var
                                is2D = ($node.css('transform') === 'none'),
                                isStatic = ($node.css('position') === 'static'),
                                isHTML = $node.is('html')
                              ;
                              while (parentNode && !isHTML && isStatic && is2D) {
                                  parentNode = parentNode.parentNode;
                                  $node = $(parentNode);
                                  is2D = ($node.css('transform') === 'none');
                                  isStatic = ($node.css('position') === 'static');
                                  isHTML = $node.is('html');
                              }
                          }
                          return ($node && $node.length > 0)
                            ? $node
                            : $()
                          ;
                      },
                      positions: function () {
                          return {
                              'top left': false,
                              'top center': false,
                              'top right': false,
                              'bottom left': false,
                              'bottom center': false,
                              'bottom right': false,
                              'left center': false,
                              'right center': false
                          };
                      },
                      nextPosition: function (position) {
                          var
                            positions = position.split(' '),
                            verticalPosition = positions[0],
                            horizontalPosition = positions[1],
                            opposite = {
                                top: 'bottom',
                                bottom: 'top',
                                left: 'right',
                                right: 'left'
                            },
                            adjacent = {
                                left: 'center',
                                center: 'right',
                                right: 'left'
                            },
                            backup = {
                                'top left': 'top center',
                                'top center': 'top right',
                                'top right': 'right center',
                                'right center': 'bottom right',
                                'bottom right': 'bottom center',
                                'bottom center': 'bottom left',
                                'bottom left': 'left center',
                                'left center': 'top left'
                            },
                            adjacentsAvailable = (verticalPosition == 'top' || verticalPosition == 'bottom'),
                            oppositeTried = false,
                            adjacentTried = false,
                            nextPosition = false
                          ;
                          if (!triedPositions) {
                              module.verbose('All available positions available');
                              triedPositions = module.get.positions();
                          }

                          module.debug('Recording last position tried', position);
                          triedPositions[position] = true;

                          if (settings.prefer === 'opposite') {
                              nextPosition = [opposite[verticalPosition], horizontalPosition];
                              nextPosition = nextPosition.join(' ');
                              oppositeTried = (triedPositions[nextPosition] === true);
                              module.debug('Trying opposite strategy', nextPosition);
                          }
                          if ((settings.prefer === 'adjacent') && adjacentsAvailable) {
                              nextPosition = [verticalPosition, adjacent[horizontalPosition]];
                              nextPosition = nextPosition.join(' ');
                              adjacentTried = (triedPositions[nextPosition] === true);
                              module.debug('Trying adjacent strategy', nextPosition);
                          }
                          if (adjacentTried || oppositeTried) {
                              module.debug('Using backup position', nextPosition);
                              nextPosition = backup[position];
                          }
                          return nextPosition;
                      }
                  },

                  set: {
                      position: function (position, calculations) {

                          // exit conditions
                          if ($target.length === 0 || $popup.length === 0) {
                              module.error(error.notFound);
                              return;
                          }
                          var
                            offset,
                            distanceAway,
                            target,
                            popup,
                            parent,
                            positioning,
                            popupOffset,
                            distanceFromBoundary
                          ;

                          calculations = calculations || module.get.calculations();
                          position = position || $module.data(metadata.position) || settings.position;

                          offset = $module.data(metadata.offset) || settings.offset;
                          distanceAway = settings.distanceAway;

                          // shorthand
                          target = calculations.target;
                          popup = calculations.popup;
                          parent = calculations.parent;

                          if (target.width === 0 && target.height === 0 && !module.is.svg(target.element)) {
                              module.debug('Popup target is hidden, no action taken');
                              return false;
                          }

                          if (settings.inline) {
                              module.debug('Adding margin to calculation', target.margin);
                              if (position == 'left center' || position == 'right center') {
                                  offset += target.margin.top;
                                  distanceAway += -target.margin.left;
                              }
                              else if (position == 'top left' || position == 'top center' || position == 'top right') {
                                  offset += target.margin.left;
                                  distanceAway -= target.margin.top;
                              }
                              else {
                                  offset += target.margin.left;
                                  distanceAway += target.margin.top;
                              }
                          }

                          module.debug('Determining popup position from calculations', position, calculations);

                          if (module.is.rtl()) {
                              position = position.replace(/left|right/g, function (match) {
                                  return (match == 'left')
                                    ? 'right'
                                    : 'left'
                                  ;
                              });
                              module.debug('RTL: Popup position updated', position);
                          }

                          // if last attempt use specified last resort position
                          if (searchDepth == settings.maxSearchDepth && typeof settings.lastResort === 'string') {
                              position = settings.lastResort;
                          }

                          switch (position) {
                              case 'top left':
                                  positioning = {
                                      top: 'auto',
                                      bottom: parent.height - target.top + distanceAway,
                                      left: target.left + offset,
                                      right: 'auto'
                                  };
                                  break;
                              case 'top center':
                                  positioning = {
                                      bottom: parent.height - target.top + distanceAway,
                                      left: target.left + (target.width / 2) - (popup.width / 2) + offset,
                                      top: 'auto',
                                      right: 'auto'
                                  };
                                  break;
                              case 'top right':
                                  positioning = {
                                      bottom: parent.height - target.top + distanceAway,
                                      right: parent.width - target.left - target.width - offset,
                                      top: 'auto',
                                      left: 'auto'
                                  };
                                  break;
                              case 'left center':
                                  positioning = {
                                      top: target.top + (target.height / 2) - (popup.height / 2) + offset,
                                      right: parent.width - target.left + distanceAway,
                                      left: 'auto',
                                      bottom: 'auto'
                                  };
                                  break;
                              case 'right center':
                                  positioning = {
                                      top: target.top + (target.height / 2) - (popup.height / 2) + offset,
                                      left: target.left + target.width + distanceAway,
                                      bottom: 'auto',
                                      right: 'auto'
                                  };
                                  break;
                              case 'bottom left':
                                  positioning = {
                                      top: target.top + target.height + distanceAway,
                                      left: target.left + offset,
                                      bottom: 'auto',
                                      right: 'auto'
                                  };
                                  break;
                              case 'bottom center':
                                  positioning = {
                                      top: target.top + target.height + distanceAway,
                                      left: target.left + (target.width / 2) - (popup.width / 2) + offset,
                                      bottom: 'auto',
                                      right: 'auto'
                                  };
                                  break;
                              case 'bottom right':
                                  positioning = {
                                      top: target.top + target.height + distanceAway,
                                      right: parent.width - target.left - target.width - offset,
                                      left: 'auto',
                                      bottom: 'auto'
                                  };
                                  break;
                          }
                          if (positioning === undefined) {
                              module.error(error.invalidPosition, position);
                          }

                          module.debug('Calculated popup positioning values', positioning);

                          // tentatively place on stage
                          $popup
                            .css(positioning)
                            .removeClass(className.position)
                            .addClass(position)
                            .addClass(className.loading)
                          ;

                          popupOffset = module.get.popupOffset();

                          // see if any boundaries are surpassed with this tentative position
                          distanceFromBoundary = module.get.distanceFromBoundary(popupOffset, calculations);

                          if (module.is.offstage(distanceFromBoundary, position)) {
                              module.debug('Position is outside viewport', position);
                              if (searchDepth < settings.maxSearchDepth) {
                                  searchDepth++;
                                  position = module.get.nextPosition(position);
                                  module.debug('Trying new position', position);
                                  return ($popup)
                                    ? module.set.position(position, calculations)
                                    : false
                                  ;
                              }
                              else {
                                  if (settings.lastResort) {
                                      module.debug('No position found, showing with last position');
                                  }
                                  else {
                                      module.debug('Popup could not find a position to display', $popup);
                                      module.error(error.cannotPlace, element);
                                      module.remove.attempts();
                                      module.remove.loading();
                                      module.reset();
                                      settings.onUnplaceable.call($popup, element);
                                      return false;
                                  }
                              }
                          }
                          module.debug('Position is on stage', position);
                          module.remove.attempts();
                          module.remove.loading();
                          if (settings.setFluidWidth && module.is.fluid()) {
                              module.set.fluidWidth(calculations);
                          }
                          return true;
                      },

                      fluidWidth: function (calculations) {
                          calculations = calculations || module.get.calculations();
                          module.debug('Automatically setting element width to parent width', calculations.parent.width);
                          $popup.css('width', calculations.container.width);
                      },

                      variation: function (variation) {
                          variation = variation || module.get.variation();
                          if (variation && module.has.popup()) {
                              module.verbose('Adding variation to popup', variation);
                              $popup.addClass(variation);
                          }
                      },

                      visible: function () {
                          $module.addClass(className.visible);
                      }
                  },

                  remove: {
                      loading: function () {
                          $popup.removeClass(className.loading);
                      },
                      variation: function (variation) {
                          variation = variation || module.get.variation();
                          if (variation) {
                              module.verbose('Removing variation', variation);
                              $popup.removeClass(variation);
                          }
                      },
                      visible: function () {
                          $module.removeClass(className.visible);
                      },
                      attempts: function () {
                          module.verbose('Resetting all searched positions');
                          searchDepth = 0;
                          triedPositions = false;
                      }
                  },

                  bind: {
                      events: function () {
                          module.debug('Binding popup events to module');
                          if (settings.on == 'click') {
                              $module
                                .on('click' + eventNamespace, module.toggle)
                              ;
                          }
                          if (settings.on == 'hover' && hasTouch) {
                              $module
                                .on('touchstart' + eventNamespace, module.event.touchstart)
                              ;
                          }
                          if (module.get.startEvent()) {
                              $module
                                .on(module.get.startEvent() + eventNamespace, module.event.start)
                                .on(module.get.endEvent() + eventNamespace, module.event.end)
                              ;
                          }
                          if (settings.target) {
                              module.debug('Target set to element', $target);
                          }
                          $window.on('resize' + elementNamespace, module.event.resize);
                      },
                      popup: function () {
                          module.verbose('Allowing hover events on popup to prevent closing');
                          if ($popup && module.has.popup()) {
                              $popup
                                .on('mouseenter' + eventNamespace, module.event.start)
                                .on('mouseleave' + eventNamespace, module.event.end)
                              ;
                          }
                      },
                      close: function () {
                          if (settings.hideOnScroll === true || (settings.hideOnScroll == 'auto' && settings.on != 'click')) {
                              $scrollContext
                                .one(module.get.scrollEvent() + elementNamespace, module.event.hideGracefully)
                              ;
                          }
                          if (settings.on == 'hover' && openedWithTouch) {
                              module.verbose('Binding popup close event to document');
                              $document
                                .on('touchstart' + elementNamespace, function (event) {
                                    module.verbose('Touched away from popup');
                                    module.event.hideGracefully.call(element, event);
                                })
                              ;
                          }
                          if (settings.on == 'click' && settings.closable) {
                              module.verbose('Binding popup close event to document');
                              $document
                                .on('click' + elementNamespace, function (event) {
                                    module.verbose('Clicked away from popup');
                                    module.event.hideGracefully.call(element, event);
                                })
                              ;
                          }
                      }
                  },

                  unbind: {
                      events: function () {
                          $window
                            .off(elementNamespace)
                          ;
                          $module
                            .off(eventNamespace)
                          ;
                      },
                      close: function () {
                          $document
                            .off(elementNamespace)
                          ;
                          $scrollContext
                            .off(elementNamespace)
                          ;
                      },
                  },

                  has: {
                      popup: function () {
                          return ($popup && $popup.length > 0);
                      }
                  },

                  is: {
                      offstage: function (distanceFromBoundary, position) {
                          var
                            offstage = []
                          ;
                          // return boundaries that have been surpassed
                          $.each(distanceFromBoundary, function (direction, distance) {
                              if (distance < -settings.jitter) {
                                  module.debug('Position exceeds allowable distance from edge', direction, distance, position);
                                  offstage.push(direction);
                              }
                          });
                          if (offstage.length > 0) {
                              return true;
                          }
                          else {
                              return false;
                          }
                      },
                      svg: function (element) {
                          return module.supports.svg() && (element instanceof SVGGraphicsElement);
                      },
                      active: function () {
                          return $module.hasClass(className.active);
                      },
                      animating: function () {
                          return ($popup !== undefined && $popup.hasClass(className.animating));
                      },
                      fluid: function () {
                          return ($popup !== undefined && $popup.hasClass(className.fluid));
                      },
                      visible: function () {
                          return ($popup !== undefined && $popup.hasClass(className.visible));
                      },
                      dropdown: function () {
                          return $module.hasClass(className.dropdown);
                      },
                      hidden: function () {
                          return !module.is.visible();
                      },
                      rtl: function () {
                          return $module.css('direction') == 'rtl';
                      }
                  },

                  reset: function () {
                      module.remove.visible();
                      if (settings.preserve) {
                          if ($.fn.transition !== undefined) {
                              $popup
                                .transition('remove transition')
                              ;
                          }
                      }
                      else {
                          module.removePopup();
                      }
                  },

                  setting: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          settings[name] = value;
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.popup.settings = {

        name: 'Popup',

        // module settings
        silent: false,
        debug: false,
        verbose: false,
        performance: true,
        namespace: 'popup',

        // whether it should use dom mutation observers
        observeChanges: true,

        // callback only when element added to dom
        onCreate: function () { },

        // callback before element removed from dom
        onRemove: function () { },

        // callback before show animation
        onShow: function () { },

        // callback after show animation
        onVisible: function () { },

        // callback before hide animation
        onHide: function () { },

        // callback when popup cannot be positioned in visible screen
        onUnplaceable: function () { },

        // callback after hide animation
        onHidden: function () { },

        // when to show popup
        on: 'hover',

        // element to use to determine if popup is out of boundary
        boundary: window,

        // whether to add touchstart events when using hover
        addTouchEvents: true,

        // default position relative to element
        position: 'top left',

        // name of variation to use
        variation: '',

        // whether popup should be moved to context
        movePopup: true,

        // element which popup should be relative to
        target: false,

        // jq selector or element that should be used as popup
        popup: false,

        // popup should remain inline next to activator
        inline: false,

        // popup should be removed from page on hide
        preserve: false,

        // popup should not close when being hovered on
        hoverable: false,

        // explicitly set content
        content: false,

        // explicitly set html
        html: false,

        // explicitly set title
        title: false,

        // whether automatically close on clickaway when on click
        closable: true,

        // automatically hide on scroll
        hideOnScroll: 'auto',

        // hide other popups on show
        exclusive: false,

        // context to attach popups
        context: 'body',

        // context for binding scroll events
        scrollContext: window,

        // position to prefer when calculating new position
        prefer: 'opposite',

        // specify position to appear even if it doesn't fit
        lastResort: false,

        // delay used to prevent accidental refiring of animations due to user error
        delay: {
            show: 50,
            hide: 70
        },

        // whether fluid variation should assign width explicitly
        setFluidWidth: true,

        // transition settings
        duration: 200,
        transition: 'scale',

        // distance away from activating element in px
        distanceAway: 0,

        // number of pixels an element is allowed to be "offstage" for a position to be chosen (allows for rounding)
        jitter: 2,

        // offset on aligning axis from calculated position
        offset: 0,

        // maximum times to look for a position before failing (9 positions total)
        maxSearchDepth: 15,

        error: {
            invalidPosition: 'The position you specified is not a valid position',
            cannotPlace: 'Popup does not fit within the boundaries of the viewport',
            method: 'The method you called is not defined.',
            noTransition: 'This module requires ui transitions <https://github.com/Semantic-Org/UI-Transition>',
            notFound: 'The target or popup you specified does not exist on the page'
        },

        metadata: {
            activator: 'activator',
            content: 'content',
            html: 'html',
            offset: 'offset',
            position: 'position',
            title: 'title',
            variation: 'variation'
        },

        className: {
            active: 'active',
            animating: 'animating',
            dropdown: 'dropdown',
            fluid: 'fluid',
            loading: 'loading',
            popup: 'ui popup',
            position: 'top left center bottom right',
            visible: 'visible'
        },

        selector: {
            popup: '.ui.popup'
        },

        templates: {
            escape: function (string) {
                var
                  badChars = /[&<>"'`]/g,
                  shouldEscape = /[&<>"'`]/,
                  escape = {
                      "&": "&amp;",
                      "<": "&lt;",
                      ">": "&gt;",
                      '"': "&quot;",
                      "'": "&#x27;",
                      "`": "&#x60;"
                  },
                  escapedChar = function (chr) {
                      return escape[chr];
                  }
                ;
                if (shouldEscape.test(string)) {
                    return string.replace(badChars, escapedChar);
                }
                return string;
            },
            popup: function (text) {
                var
                  html = '',
                  escape = $.fn.popup.settings.templates.escape
                ;
                if (typeof text !== undefined) {
                    if (typeof text.title !== undefined && text.title) {
                        text.title = escape(text.title);
                        html += '<div class="header">' + text.title + '</div>';
                    }
                    if (typeof text.content !== undefined && text.content) {
                        text.content = escape(text.content);
                        html += '<div class="content">' + text.content + '</div>';
                    }
                }
                return html;
            }
        }

    };


})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Progress
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    var
      global = (typeof window != 'undefined' && window.Math == Math)
        ? window
        : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
    ;

    $.fn.progress = function (parameters) {
        var
          $allModules = $(this),

          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          returnedValue
        ;

        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.progress.settings, parameters)
                  : $.extend({}, $.fn.progress.settings),

                className = settings.className,
                metadata = settings.metadata,
                namespace = settings.namespace,
                selector = settings.selector,
                error = settings.error,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                $module = $(this),
                $bar = $(this).find(selector.bar),
                $progress = $(this).find(selector.progress),
                $label = $(this).find(selector.label),

                element = this,
                instance = $module.data(moduleNamespace),

                animating = false,
                transitionEnd,
                module
              ;

              module = {

                  initialize: function () {
                      module.debug('Initializing progress bar', settings);

                      module.set.duration();
                      module.set.transitionEvent();

                      module.read.metadata();
                      module.read.settings();

                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of progress', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },
                  destroy: function () {
                      module.verbose('Destroying previous progress for', $module);
                      clearInterval(instance.interval);
                      module.remove.state();
                      $module.removeData(moduleNamespace);
                      instance = undefined;
                  },

                  reset: function () {
                      module.remove.nextValue();
                      module.update.progress(0);
                  },

                  complete: function () {
                      if (module.percent === undefined || module.percent < 100) {
                          module.remove.progressPoll();
                          module.set.percent(100);
                      }
                  },

                  read: {
                      metadata: function () {
                          var
                            data = {
                                percent: $module.data(metadata.percent),
                                total: $module.data(metadata.total),
                                value: $module.data(metadata.value)
                            }
                          ;
                          if (data.percent) {
                              module.debug('Current percent value set from metadata', data.percent);
                              module.set.percent(data.percent);
                          }
                          if (data.total) {
                              module.debug('Total value set from metadata', data.total);
                              module.set.total(data.total);
                          }
                          if (data.value) {
                              module.debug('Current value set from metadata', data.value);
                              module.set.value(data.value);
                              module.set.progress(data.value);
                          }
                      },
                      settings: function () {
                          if (settings.total !== false) {
                              module.debug('Current total set in settings', settings.total);
                              module.set.total(settings.total);
                          }
                          if (settings.value !== false) {
                              module.debug('Current value set in settings', settings.value);
                              module.set.value(settings.value);
                              module.set.progress(module.value);
                          }
                          if (settings.percent !== false) {
                              module.debug('Current percent set in settings', settings.percent);
                              module.set.percent(settings.percent);
                          }
                      }
                  },

                  increment: function (incrementValue) {
                      var
                        maxValue,
                        startValue,
                        newValue
                      ;
                      if (module.has.total()) {
                          startValue = module.get.value();
                          incrementValue = incrementValue || 1;
                          newValue = startValue + incrementValue;
                      }
                      else {
                          startValue = module.get.percent();
                          incrementValue = incrementValue || module.get.randomValue();

                          newValue = startValue + incrementValue;
                          maxValue = 100;
                          module.debug('Incrementing percentage by', startValue, newValue);
                      }
                      newValue = module.get.normalizedValue(newValue);
                      module.set.progress(newValue);
                  },
                  decrement: function (decrementValue) {
                      var
                        total = module.get.total(),
                        startValue,
                        newValue
                      ;
                      if (total) {
                          startValue = module.get.value();
                          decrementValue = decrementValue || 1;
                          newValue = startValue - decrementValue;
                          module.debug('Decrementing value by', decrementValue, startValue);
                      }
                      else {
                          startValue = module.get.percent();
                          decrementValue = decrementValue || module.get.randomValue();
                          newValue = startValue - decrementValue;
                          module.debug('Decrementing percentage by', decrementValue, startValue);
                      }
                      newValue = module.get.normalizedValue(newValue);
                      module.set.progress(newValue);
                  },

                  has: {
                      progressPoll: function () {
                          return module.progressPoll;
                      },
                      total: function () {
                          return (module.get.total() !== false);
                      }
                  },

                  get: {
                      text: function (templateText) {
                          var
                            value = module.value || 0,
                            total = module.total || 0,
                            percent = (animating)
                              ? module.get.displayPercent()
                              : module.percent || 0,
                            left = (module.total > 0)
                              ? (total - value)
                              : (100 - percent)
                          ;
                          templateText = templateText || '';
                          templateText = templateText
                            .replace('{value}', value)
                            .replace('{total}', total)
                            .replace('{left}', left)
                            .replace('{percent}', percent)
                          ;
                          module.verbose('Adding variables to progress bar text', templateText);
                          return templateText;
                      },

                      normalizedValue: function (value) {
                          if (value < 0) {
                              module.debug('Value cannot decrement below 0');
                              return 0;
                          }
                          if (module.has.total()) {
                              if (value > module.total) {
                                  module.debug('Value cannot increment above total', module.total);
                                  return module.total;
                              }
                          }
                          else if (value > 100) {
                              module.debug('Value cannot increment above 100 percent');
                              return 100;
                          }
                          return value;
                      },

                      updateInterval: function () {
                          if (settings.updateInterval == 'auto') {
                              return settings.duration;
                          }
                          return settings.updateInterval;
                      },

                      randomValue: function () {
                          module.debug('Generating random increment percentage');
                          return Math.floor((Math.random() * settings.random.max) + settings.random.min);
                      },

                      numericValue: function (value) {
                          return (typeof value === 'string')
                            ? (value.replace(/[^\d.]/g, '') !== '')
                              ? +(value.replace(/[^\d.]/g, ''))
                              : false
                            : value
                          ;
                      },

                      transitionEnd: function () {
                          var
                            element = document.createElement('element'),
                            transitions = {
                                'transition': 'transitionend',
                                'OTransition': 'oTransitionEnd',
                                'MozTransition': 'transitionend',
                                'WebkitTransition': 'webkitTransitionEnd'
                            },
                            transition
                          ;
                          for (transition in transitions) {
                              if (element.style[transition] !== undefined) {
                                  return transitions[transition];
                              }
                          }
                      },

                      // gets current displayed percentage (if animating values this is the intermediary value)
                      displayPercent: function () {
                          var
                            barWidth = $bar.width(),
                            totalWidth = $module.width(),
                            minDisplay = parseInt($bar.css('min-width'), 10),
                            displayPercent = (barWidth > minDisplay)
                              ? (barWidth / totalWidth * 100)
                              : module.percent
                          ;
                          return (settings.precision > 0)
                            ? Math.round(displayPercent * (10 * settings.precision)) / (10 * settings.precision)
                            : Math.round(displayPercent)
                          ;
                      },

                      percent: function () {
                          return module.percent || 0;
                      },
                      value: function () {
                          return module.nextValue || module.value || 0;
                      },
                      total: function () {
                          return module.total || false;
                      }
                  },

                  create: {
                      progressPoll: function () {
                          module.progressPoll = setTimeout(function () {
                              module.update.toNextValue();
                              module.remove.progressPoll();
                          }, module.get.updateInterval());
                      },
                  },

                  is: {
                      complete: function () {
                          return module.is.success() || module.is.warning() || module.is.error();
                      },
                      success: function () {
                          return $module.hasClass(className.success);
                      },
                      warning: function () {
                          return $module.hasClass(className.warning);
                      },
                      error: function () {
                          return $module.hasClass(className.error);
                      },
                      active: function () {
                          return $module.hasClass(className.active);
                      },
                      visible: function () {
                          return $module.is(':visible');
                      }
                  },

                  remove: {
                      progressPoll: function () {
                          module.verbose('Removing progress poll timer');
                          if (module.progressPoll) {
                              clearTimeout(module.progressPoll);
                              delete module.progressPoll;
                          }
                      },
                      nextValue: function () {
                          module.verbose('Removing progress value stored for next update');
                          delete module.nextValue;
                      },
                      state: function () {
                          module.verbose('Removing stored state');
                          delete module.total;
                          delete module.percent;
                          delete module.value;
                      },
                      active: function () {
                          module.verbose('Removing active state');
                          $module.removeClass(className.active);
                      },
                      success: function () {
                          module.verbose('Removing success state');
                          $module.removeClass(className.success);
                      },
                      warning: function () {
                          module.verbose('Removing warning state');
                          $module.removeClass(className.warning);
                      },
                      error: function () {
                          module.verbose('Removing error state');
                          $module.removeClass(className.error);
                      }
                  },

                  set: {
                      barWidth: function (value) {
                          if (value > 100) {
                              module.error(error.tooHigh, value);
                          }
                          else if (value < 0) {
                              module.error(error.tooLow, value);
                          }
                          else {
                              $bar
                                .css('width', value + '%')
                              ;
                              $module
                                .attr('data-percent', parseInt(value, 10))
                              ;
                          }
                      },
                      duration: function (duration) {
                          duration = duration || settings.duration;
                          duration = (typeof duration == 'number')
                            ? duration + 'ms'
                            : duration
                          ;
                          module.verbose('Setting progress bar transition duration', duration);
                          $bar
                            .css({
                                'transition-duration': duration
                            })
                          ;
                      },
                      percent: function (percent) {
                          percent = (typeof percent == 'string')
                            ? +(percent.replace('%', ''))
                            : percent
                          ;
                          // round display percentage
                          percent = (settings.precision > 0)
                            ? Math.round(percent * (10 * settings.precision)) / (10 * settings.precision)
                            : Math.round(percent)
                          ;
                          module.percent = percent;
                          if (!module.has.total()) {
                              module.value = (settings.precision > 0)
                                ? Math.round((percent / 100) * module.total * (10 * settings.precision)) / (10 * settings.precision)
                                : Math.round((percent / 100) * module.total * 10) / 10
                              ;
                              if (settings.limitValues) {
                                  module.value = (module.value > 100)
                                    ? 100
                                    : (module.value < 0)
                                      ? 0
                                      : module.value
                                  ;
                              }
                          }
                          module.set.barWidth(percent);
                          module.set.labelInterval();
                          module.set.labels();
                          settings.onChange.call(element, percent, module.value, module.total);
                      },
                      labelInterval: function () {
                          var
                            animationCallback = function () {
                                module.verbose('Bar finished animating, removing continuous label updates');
                                clearInterval(module.interval);
                                animating = false;
                                module.set.labels();
                            }
                          ;
                          clearInterval(module.interval);
                          $bar.one(transitionEnd + eventNamespace, animationCallback);
                          animating = true;
                          module.interval = setInterval(function () {
                              var
                                isInDOM = $.contains(document.documentElement, element)
                              ;
                              if (!isInDOM) {
                                  clearInterval(module.interval);
                                  animating = false;
                              }
                              module.set.labels();
                          }, settings.framerate);
                      },
                      labels: function () {
                          module.verbose('Setting both bar progress and outer label text');
                          module.set.barLabel();
                          module.set.state();
                      },
                      label: function (text) {
                          text = text || '';
                          if (text) {
                              text = module.get.text(text);
                              module.verbose('Setting label to text', text);
                              $label.text(text);
                          }
                      },
                      state: function (percent) {
                          percent = (percent !== undefined)
                            ? percent
                            : module.percent
                          ;
                          if (percent === 100) {
                              if (settings.autoSuccess && !(module.is.warning() || module.is.error() || module.is.success())) {
                                  module.set.success();
                                  module.debug('Automatically triggering success at 100%');
                              }
                              else {
                                  module.verbose('Reached 100% removing active state');
                                  module.remove.active();
                                  module.remove.progressPoll();
                              }
                          }
                          else if (percent > 0) {
                              module.verbose('Adjusting active progress bar label', percent);
                              module.set.active();
                          }
                          else {
                              module.remove.active();
                              module.set.label(settings.text.active);
                          }
                      },
                      barLabel: function (text) {
                          if (text !== undefined) {
                              $progress.text(module.get.text(text));
                          }
                          else if (settings.label == 'ratio' && module.total) {
                              module.verbose('Adding ratio to bar label');
                              $progress.text(module.get.text(settings.text.ratio));
                          }
                          else if (settings.label == 'percent') {
                              module.verbose('Adding percentage to bar label');
                              $progress.text(module.get.text(settings.text.percent));
                          }
                      },
                      active: function (text) {
                          text = text || settings.text.active;
                          module.debug('Setting active state');
                          if (settings.showActivity && !module.is.active()) {
                              $module.addClass(className.active);
                          }
                          module.remove.warning();
                          module.remove.error();
                          module.remove.success();
                          text = settings.onLabelUpdate('active', text, module.value, module.total);
                          if (text) {
                              module.set.label(text);
                          }
                          $bar.one(transitionEnd + eventNamespace, function () {
                              settings.onActive.call(element, module.value, module.total);
                          });
                      },
                      success: function (text) {
                          text = text || settings.text.success || settings.text.active;
                          module.debug('Setting success state');
                          $module.addClass(className.success);
                          module.remove.active();
                          module.remove.warning();
                          module.remove.error();
                          module.complete();
                          if (settings.text.success) {
                              text = settings.onLabelUpdate('success', text, module.value, module.total);
                              module.set.label(text);
                          }
                          else {
                              text = settings.onLabelUpdate('active', text, module.value, module.total);
                              module.set.label(text);
                          }
                          $bar.one(transitionEnd + eventNamespace, function () {
                              settings.onSuccess.call(element, module.total);
                          });
                      },
                      warning: function (text) {
                          text = text || settings.text.warning;
                          module.debug('Setting warning state');
                          $module.addClass(className.warning);
                          module.remove.active();
                          module.remove.success();
                          module.remove.error();
                          module.complete();
                          text = settings.onLabelUpdate('warning', text, module.value, module.total);
                          if (text) {
                              module.set.label(text);
                          }
                          $bar.one(transitionEnd + eventNamespace, function () {
                              settings.onWarning.call(element, module.value, module.total);
                          });
                      },
                      error: function (text) {
                          text = text || settings.text.error;
                          module.debug('Setting error state');
                          $module.addClass(className.error);
                          module.remove.active();
                          module.remove.success();
                          module.remove.warning();
                          module.complete();
                          text = settings.onLabelUpdate('error', text, module.value, module.total);
                          if (text) {
                              module.set.label(text);
                          }
                          $bar.one(transitionEnd + eventNamespace, function () {
                              settings.onError.call(element, module.value, module.total);
                          });
                      },
                      transitionEvent: function () {
                          transitionEnd = module.get.transitionEnd();
                      },
                      total: function (totalValue) {
                          module.total = totalValue;
                      },
                      value: function (value) {
                          module.value = value;
                      },
                      progress: function (value) {
                          if (!module.has.progressPoll()) {
                              module.debug('First update in progress update interval, immediately updating', value);
                              module.update.progress(value);
                              module.create.progressPoll();
                          }
                          else {
                              module.debug('Updated within interval, setting next update to use new value', value);
                              module.set.nextValue(value);
                          }
                      },
                      nextValue: function (value) {
                          module.nextValue = value;
                      }
                  },

                  update: {
                      toNextValue: function () {
                          var
                            nextValue = module.nextValue
                          ;
                          if (nextValue) {
                              module.debug('Update interval complete using last updated value', nextValue);
                              module.update.progress(nextValue);
                              module.remove.nextValue();
                          }
                      },
                      progress: function (value) {
                          var
                            percentComplete
                          ;
                          value = module.get.numericValue(value);
                          if (value === false) {
                              module.error(error.nonNumeric, value);
                          }
                          value = module.get.normalizedValue(value);
                          if (module.has.total()) {
                              module.set.value(value);
                              percentComplete = (value / module.total) * 100;
                              module.debug('Calculating percent complete from total', percentComplete);
                              module.set.percent(percentComplete);
                          }
                          else {
                              percentComplete = value;
                              module.debug('Setting value to exact percentage value', percentComplete);
                              module.set.percent(percentComplete);
                          }
                      }
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.progress.settings = {

        name: 'Progress',
        namespace: 'progress',

        silent: false,
        debug: false,
        verbose: false,
        performance: true,

        random: {
            min: 2,
            max: 5
        },

        duration: 300,

        updateInterval: 'auto',

        autoSuccess: true,
        showActivity: true,
        limitValues: true,

        label: 'percent',
        precision: 0,
        framerate: (1000 / 30), /// 30 fps

        percent: false,
        total: false,
        value: false,

        onLabelUpdate: function (state, text, value, total) {
            return text;
        },
        onChange: function (percent, value, total) { },
        onSuccess: function (total) { },
        onActive: function (value, total) { },
        onError: function (value, total) { },
        onWarning: function (value, total) { },

        error: {
            method: 'The method you called is not defined.',
            nonNumeric: 'Progress value is non numeric',
            tooHigh: 'Value specified is above 100%',
            tooLow: 'Value specified is below 0%'
        },

        regExp: {
            variable: /\{\$*[A-z0-9]+\}/g
        },

        metadata: {
            percent: 'percent',
            total: 'total',
            value: 'value'
        },

        selector: {
            bar: '> .bar',
            label: '> .label',
            progress: '.bar > .progress'
        },

        text: {
            active: false,
            error: false,
            success: false,
            warning: false,
            percent: '{percent}%',
            ratio: '{value} of {total}'
        },

        className: {
            active: 'active',
            error: 'error',
            success: 'success',
            warning: 'warning'
        }

    };


})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Rating
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.rating = function (parameters) {
        var
          $allModules = $(this),
          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),
          returnedValue
        ;
        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.rating.settings, parameters)
                  : $.extend({}, $.fn.rating.settings),

                namespace = settings.namespace,
                className = settings.className,
                metadata = settings.metadata,
                selector = settings.selector,
                error = settings.error,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                element = this,
                instance = $(this).data(moduleNamespace),

                $module = $(this),
                $icon = $module.find(selector.icon),

                initialLoad,
                module
              ;

              module = {

                  initialize: function () {
                      module.verbose('Initializing rating module', settings);

                      if ($icon.length === 0) {
                          module.setup.layout();
                      }

                      if (settings.interactive) {
                          module.enable();
                      }
                      else {
                          module.disable();
                      }
                      module.set.initialLoad();
                      module.set.rating(module.get.initialRating());
                      module.remove.initialLoad();
                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Instantiating module', settings);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous instance', instance);
                      module.remove.events();
                      $module
                        .removeData(moduleNamespace)
                      ;
                  },

                  refresh: function () {
                      $icon = $module.find(selector.icon);
                  },

                  setup: {
                      layout: function () {
                          var
                            maxRating = module.get.maxRating(),
                            html = $.fn.rating.settings.templates.icon(maxRating)
                          ;
                          module.debug('Generating icon html dynamically');
                          $module
                            .html(html)
                          ;
                          module.refresh();
                      }
                  },

                  event: {
                      mouseenter: function () {
                          var
                            $activeIcon = $(this)
                          ;
                          $activeIcon
                            .nextAll()
                              .removeClass(className.selected)
                          ;
                          $module
                            .addClass(className.selected)
                          ;
                          $activeIcon
                            .addClass(className.selected)
                              .prevAll()
                              .addClass(className.selected)
                          ;
                      },
                      mouseleave: function () {
                          $module
                            .removeClass(className.selected)
                          ;
                          $icon
                            .removeClass(className.selected)
                          ;
                      },
                      click: function () {
                          var
                            $activeIcon = $(this),
                            currentRating = module.get.rating(),
                            rating = $icon.index($activeIcon) + 1,
                            canClear = (settings.clearable == 'auto')
                             ? ($icon.length === 1)
                             : settings.clearable
                          ;
                          if (canClear && currentRating == rating) {
                              module.clearRating();
                          }
                          else {
                              module.set.rating(rating);
                          }
                      }
                  },

                  clearRating: function () {
                      module.debug('Clearing current rating');
                      module.set.rating(0);
                  },

                  bind: {
                      events: function () {
                          module.verbose('Binding events');
                          $module
                            .on('mouseenter' + eventNamespace, selector.icon, module.event.mouseenter)
                            .on('mouseleave' + eventNamespace, selector.icon, module.event.mouseleave)
                            .on('click' + eventNamespace, selector.icon, module.event.click)
                          ;
                      }
                  },

                  remove: {
                      events: function () {
                          module.verbose('Removing events');
                          $module
                            .off(eventNamespace)
                          ;
                      },
                      initialLoad: function () {
                          initialLoad = false;
                      }
                  },

                  enable: function () {
                      module.debug('Setting rating to interactive mode');
                      module.bind.events();
                      $module
                        .removeClass(className.disabled)
                      ;
                  },

                  disable: function () {
                      module.debug('Setting rating to read-only mode');
                      module.remove.events();
                      $module
                        .addClass(className.disabled)
                      ;
                  },

                  is: {
                      initialLoad: function () {
                          return initialLoad;
                      }
                  },

                  get: {
                      initialRating: function () {
                          if ($module.data(metadata.rating) !== undefined) {
                              $module.removeData(metadata.rating);
                              return $module.data(metadata.rating);
                          }
                          return settings.initialRating;
                      },
                      maxRating: function () {
                          if ($module.data(metadata.maxRating) !== undefined) {
                              $module.removeData(metadata.maxRating);
                              return $module.data(metadata.maxRating);
                          }
                          return settings.maxRating;
                      },
                      rating: function () {
                          var
                            currentRating = $icon.filter('.' + className.active).length
                          ;
                          module.verbose('Current rating retrieved', currentRating);
                          return currentRating;
                      }
                  },

                  set: {
                      rating: function (rating) {
                          var
                            ratingIndex = (rating - 1 >= 0)
                              ? (rating - 1)
                              : 0,
                            $activeIcon = $icon.eq(ratingIndex)
                          ;
                          $module
                            .removeClass(className.selected)
                          ;
                          $icon
                            .removeClass(className.selected)
                            .removeClass(className.active)
                          ;
                          if (rating > 0) {
                              module.verbose('Setting current rating to', rating);
                              $activeIcon
                                .prevAll()
                                .addBack()
                                  .addClass(className.active)
                              ;
                          }
                          if (!module.is.initialLoad()) {
                              settings.onRate.call(element, rating);
                          }
                      },
                      initialLoad: function () {
                          initialLoad = true;
                      }
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ($allModules.length > 1) {
                              title += ' ' + '(' + $allModules.length + ')';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };
              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.rating.settings = {

        name: 'Rating',
        namespace: 'rating',

        slent: false,
        debug: false,
        verbose: false,
        performance: true,

        initialRating: 0,
        interactive: true,
        maxRating: 4,
        clearable: 'auto',

        fireOnInit: false,

        onRate: function (rating) { },

        error: {
            method: 'The method you called is not defined',
            noMaximum: 'No maximum rating specified. Cannot generate HTML automatically'
        },


        metadata: {
            rating: 'rating',
            maxRating: 'maxRating'
        },

        className: {
            active: 'active',
            disabled: 'disabled',
            selected: 'selected',
            loading: 'loading'
        },

        selector: {
            icon: '.icon'
        },

        templates: {
            icon: function (maxRating) {
                var
                  icon = 1,
                  html = ''
                ;
                while (icon <= maxRating) {
                    html += '<i class="icon"></i>';
                    icon++;
                }
                return html;
            }
        }

    };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Search
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.search = function (parameters) {
        var
          $allModules = $(this),
          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),
          returnedValue
        ;
        $(this)
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.search.settings, parameters)
                  : $.extend({}, $.fn.search.settings),

                className = settings.className,
                metadata = settings.metadata,
                regExp = settings.regExp,
                fields = settings.fields,
                selector = settings.selector,
                error = settings.error,
                namespace = settings.namespace,

                eventNamespace = '.' + namespace,
                moduleNamespace = namespace + '-module',

                $module = $(this),
                $prompt = $module.find(selector.prompt),
                $searchButton = $module.find(selector.searchButton),
                $results = $module.find(selector.results),
                $result = $module.find(selector.result),
                $category = $module.find(selector.category),

                element = this,
                instance = $module.data(moduleNamespace),

                disabledBubbled = false,

                module
              ;

              module = {

                  initialize: function () {
                      module.verbose('Initializing module');
                      module.determine.searchFields();
                      module.bind.events();
                      module.set.type();
                      module.create.results();
                      module.instantiate();
                  },
                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },
                  destroy: function () {
                      module.verbose('Destroying instance');
                      $module
                        .off(eventNamespace)
                        .removeData(moduleNamespace)
                      ;
                  },

                  refresh: function () {
                      module.debug('Refreshing selector cache');
                      $prompt = $module.find(selector.prompt);
                      $searchButton = $module.find(selector.searchButton);
                      $category = $module.find(selector.category);
                      $results = $module.find(selector.results);
                      $result = $module.find(selector.result);
                  },

                  refreshResults: function () {
                      $results = $module.find(selector.results);
                      $result = $module.find(selector.result);
                  },

                  bind: {
                      events: function () {
                          module.verbose('Binding events to search');
                          if (settings.automatic) {
                              $module
                                .on(module.get.inputEvent() + eventNamespace, selector.prompt, module.event.input)
                              ;
                              $prompt
                                .attr('autocomplete', 'off')
                              ;
                          }
                          $module
                            // prompt
                            .on('focus' + eventNamespace, selector.prompt, module.event.focus)
                            .on('blur' + eventNamespace, selector.prompt, module.event.blur)
                            .on('keydown' + eventNamespace, selector.prompt, module.handleKeyboard)
                            // search button
                            .on('click' + eventNamespace, selector.searchButton, module.query)
                            // results
                            .on('mousedown' + eventNamespace, selector.results, module.event.result.mousedown)
                            .on('mouseup' + eventNamespace, selector.results, module.event.result.mouseup)
                            .on('click' + eventNamespace, selector.result, module.event.result.click)
                          ;
                      }
                  },

                  determine: {
                      searchFields: function () {
                          // this makes sure $.extend does not add specified search fields to default fields
                          // this is the only setting which should not extend defaults
                          if (parameters && parameters.searchFields !== undefined) {
                              settings.searchFields = parameters.searchFields;
                          }
                      }
                  },

                  event: {
                      input: function () {
                          clearTimeout(module.timer);
                          module.timer = setTimeout(module.query, settings.searchDelay);
                      },
                      focus: function () {
                          module.set.focus();
                          if (module.has.minimumCharacters()) {
                              module.query();
                              if (module.can.show()) {
                                  module.showResults();
                              }
                          }
                      },
                      blur: function (event) {
                          var
                            pageLostFocus = (document.activeElement === this),
                            callback = function () {
                                module.cancel.query();
                                module.remove.focus();
                                module.timer = setTimeout(module.hideResults, settings.hideDelay);
                            }
                          ;
                          if (pageLostFocus) {
                              return;
                          }
                          if (module.resultsClicked) {
                              module.debug('Determining if user action caused search to close');
                              $module
                                .one('click.close' + eventNamespace, selector.results, function (event) {
                                    if (module.is.inMessage(event) || disabledBubbled) {
                                        $prompt.focus();
                                        return;
                                    }
                                    disabledBubbled = false;
                                    if (!module.is.animating() && !module.is.hidden()) {
                                        callback();
                                    }
                                })
                              ;
                          }
                          else {
                              module.debug('Input blurred without user action, closing results');
                              callback();
                          }
                      },
                      result: {
                          mousedown: function () {
                              module.resultsClicked = true;
                          },
                          mouseup: function () {
                              module.resultsClicked = false;
                          },
                          click: function (event) {
                              module.debug('Search result selected');
                              var
                                $result = $(this),
                                $title = $result.find(selector.title).eq(0),
                                $link = $result.is('a[href]')
                                  ? $result
                                  : $result.find('a[href]').eq(0),
                                href = $link.attr('href') || false,
                                target = $link.attr('target') || false,
                                title = $title.html(),
                                // title is used for result lookup
                                value = ($title.length > 0)
                                  ? $title.text()
                                  : false,
                                results = module.get.results(),
                                result = $result.data(metadata.result) || module.get.result(value, results),
                                returnedValue
                              ;
                              if ($.isFunction(settings.onSelect)) {
                                  if (settings.onSelect.call(element, result, results) === false) {
                                      module.debug('Custom onSelect callback cancelled default select action');
                                      disabledBubbled = true;
                                      return;
                                  }
                              }
                              module.hideResults();
                              if (value) {
                                  module.set.value(value);
                              }
                              if (href) {
                                  module.verbose('Opening search link found in result', $link);
                                  if (target == '_blank' || event.ctrlKey) {
                                      window.open(href);
                                  }
                                  else {
                                      window.location.href = (href);
                                  }
                              }
                          }
                      }
                  },
                  handleKeyboard: function (event) {
                      var
                        // force selector refresh
                        $result = $module.find(selector.result),
                        $category = $module.find(selector.category),
                        currentIndex = $result.index($result.filter('.' + className.active)),
                        resultSize = $result.length,

                        keyCode = event.which,
                        keys = {
                            backspace: 8,
                            enter: 13,
                            escape: 27,
                            upArrow: 38,
                            downArrow: 40
                        },
                        newIndex
                      ;
                      // search shortcuts
                      if (keyCode == keys.escape) {
                          module.verbose('Escape key pressed, blurring search field');
                          module.trigger.blur();
                      }
                      if (module.is.visible()) {
                          if (keyCode == keys.enter) {
                              module.verbose('Enter key pressed, selecting active result');
                              if ($result.filter('.' + className.active).length > 0) {
                                  module.event.result.click.call($result.filter('.' + className.active), event);
                                  event.preventDefault();
                                  return false;
                              }
                          }
                          else if (keyCode == keys.upArrow) {
                              module.verbose('Up key pressed, changing active result');
                              newIndex = (currentIndex - 1 < 0)
                                ? currentIndex
                                : currentIndex - 1
                              ;
                              $category
                                .removeClass(className.active)
                              ;
                              $result
                                .removeClass(className.active)
                                .eq(newIndex)
                                  .addClass(className.active)
                                  .closest($category)
                                    .addClass(className.active)
                              ;
                              event.preventDefault();
                          }
                          else if (keyCode == keys.downArrow) {
                              module.verbose('Down key pressed, changing active result');
                              newIndex = (currentIndex + 1 >= resultSize)
                                ? currentIndex
                                : currentIndex + 1
                              ;
                              $category
                                .removeClass(className.active)
                              ;
                              $result
                                .removeClass(className.active)
                                .eq(newIndex)
                                  .addClass(className.active)
                                  .closest($category)
                                    .addClass(className.active)
                              ;
                              event.preventDefault();
                          }
                      }
                      else {
                          // query shortcuts
                          if (keyCode == keys.enter) {
                              module.verbose('Enter key pressed, executing query');
                              module.query();
                              module.set.buttonPressed();
                              $prompt.one('keyup', module.remove.buttonFocus);
                          }
                      }
                  },

                  setup: {
                      api: function (searchTerm) {
                          var
                            apiSettings = {
                                debug: settings.debug,
                                on: false,
                                cache: true,
                                action: 'search',
                                urlData: {
                                    query: searchTerm
                                },
                                onSuccess: function (response) {
                                    module.parse.response.call(element, response, searchTerm);
                                },
                                onAbort: function (response) {
                                },
                                onFailure: function () {
                                    module.displayMessage(error.serverError);
                                },
                                onError: module.error
                            },
                            searchHTML
                          ;
                          $.extend(true, apiSettings, settings.apiSettings);
                          module.verbose('Setting up API request', apiSettings);
                          $module.api(apiSettings);
                      }
                  },

                  can: {
                      useAPI: function () {
                          return $.fn.api !== undefined;
                      },
                      show: function () {
                          return module.is.focused() && !module.is.visible() && !module.is.empty();
                      },
                      transition: function () {
                          return settings.transition && $.fn.transition !== undefined && $module.transition('is supported');
                      }
                  },

                  is: {
                      animating: function () {
                          return $results.hasClass(className.animating);
                      },
                      hidden: function () {
                          return $results.hasClass(className.hidden);
                      },
                      inMessage: function (event) {
                          return (event.target && $(event.target).closest(selector.message).length > 0);
                      },
                      empty: function () {
                          return ($results.html() === '');
                      },
                      visible: function () {
                          return ($results.filter(':visible').length > 0);
                      },
                      focused: function () {
                          return ($prompt.filter(':focus').length > 0);
                      }
                  },

                  trigger: {
                      blur: function () {
                          var
                            events = document.createEvent('HTMLEvents'),
                            promptElement = $prompt[0]
                          ;
                          if (promptElement) {
                              module.verbose('Triggering native blur event');
                              events.initEvent('blur', false, false);
                              promptElement.dispatchEvent(events);
                          }
                      }
                  },

                  get: {
                      inputEvent: function () {
                          var
                            prompt = $prompt[0],
                            inputEvent = (prompt !== undefined && prompt.oninput !== undefined)
                              ? 'input'
                              : (prompt !== undefined && prompt.onpropertychange !== undefined)
                                ? 'propertychange'
                                : 'keyup'
                          ;
                          return inputEvent;
                      },
                      value: function () {
                          return $prompt.val();
                      },
                      results: function () {
                          var
                            results = $module.data(metadata.results)
                          ;
                          return results;
                      },
                      result: function (value, results) {
                          var
                            lookupFields = ['title', 'id'],
                            result = false
                          ;
                          value = (value !== undefined)
                            ? value
                            : module.get.value()
                          ;
                          results = (results !== undefined)
                            ? results
                            : module.get.results()
                          ;
                          if (settings.type === 'category') {
                              module.debug('Finding result that matches', value);
                              $.each(results, function (index, category) {
                                  if ($.isArray(category.results)) {
                                      result = module.search.object(value, category.results, lookupFields)[0];
                                      // don't continue searching if a result is found
                                      if (result) {
                                          return false;
                                      }
                                  }
                              });
                          }
                          else {
                              module.debug('Finding result in results object', value);
                              result = module.search.object(value, results, lookupFields)[0];
                          }
                          return result || false;
                      },
                  },

                  select: {
                      firstResult: function () {
                          module.verbose('Selecting first result');
                          $result.first().addClass(className.active);
                      }
                  },

                  set: {
                      focus: function () {
                          $module.addClass(className.focus);
                      },
                      loading: function () {
                          $module.addClass(className.loading);
                      },
                      value: function (value) {
                          module.verbose('Setting search input value', value);
                          $prompt
                            .val(value)
                          ;
                      },
                      type: function (type) {
                          type = type || settings.type;
                          if (settings.type == 'category') {
                              $module.addClass(settings.type);
                          }
                      },
                      buttonPressed: function () {
                          $searchButton.addClass(className.pressed);
                      }
                  },

                  remove: {
                      loading: function () {
                          $module.removeClass(className.loading);
                      },
                      focus: function () {
                          $module.removeClass(className.focus);
                      },
                      buttonPressed: function () {
                          $searchButton.removeClass(className.pressed);
                      }
                  },

                  query: function () {
                      var
                        searchTerm = module.get.value(),
                        cache = module.read.cache(searchTerm)
                      ;
                      if (module.has.minimumCharacters()) {
                          if (cache) {
                              module.debug('Reading result from cache', searchTerm);
                              module.save.results(cache.results);
                              module.addResults(cache.html);
                              module.inject.id(cache.results);
                          }
                          else {
                              module.debug('Querying for', searchTerm);
                              if ($.isPlainObject(settings.source) || $.isArray(settings.source)) {
                                  module.search.local(searchTerm);
                              }
                              else if (module.can.useAPI()) {
                                  module.search.remote(searchTerm);
                              }
                              else {
                                  module.error(error.source);
                              }
                          }
                          settings.onSearchQuery.call(element, searchTerm);
                      }
                      else {
                          module.hideResults();
                      }
                  },

                  search: {
                      local: function (searchTerm) {
                          var
                            results = module.search.object(searchTerm, settings.content),
                            searchHTML
                          ;
                          module.set.loading();
                          module.save.results(results);
                          module.debug('Returned local search results', results);

                          searchHTML = module.generateResults({
                              results: results
                          });
                          module.remove.loading();
                          module.addResults(searchHTML);
                          module.inject.id(results);
                          module.write.cache(searchTerm, {
                              html: searchHTML,
                              results: results
                          });
                      },
                      remote: function (searchTerm) {
                          if ($module.api('is loading')) {
                              $module.api('abort');
                          }
                          module.setup.api(searchTerm);
                          $module
                            .api('query')
                          ;
                      },
                      object: function (searchTerm, source, searchFields) {
                          var
                            results = [],
                            fuzzyResults = [],
                            searchExp = searchTerm.toString().replace(regExp.escape, '\\$&'),
                            matchRegExp = new RegExp(regExp.beginsWith + searchExp, 'i'),

                            // avoid duplicates when pushing results
                            addResult = function (array, result) {
                                var
                                  notResult = ($.inArray(result, results) == -1),
                                  notFuzzyResult = ($.inArray(result, fuzzyResults) == -1)
                                ;
                                if (notResult && notFuzzyResult) {
                                    array.push(result);
                                }
                            }
                          ;
                          source = source || settings.source;
                          searchFields = (searchFields !== undefined)
                            ? searchFields
                            : settings.searchFields
                          ;

                          // search fields should be array to loop correctly
                          if (!$.isArray(searchFields)) {
                              searchFields = [searchFields];
                          }

                          // exit conditions if no source
                          if (source === undefined || source === false) {
                              module.error(error.source);
                              return [];
                          }

                          // iterate through search fields looking for matches
                          $.each(searchFields, function (index, field) {
                              $.each(source, function (label, content) {
                                  var
                                    fieldExists = (typeof content[field] == 'string')
                                  ;
                                  if (fieldExists) {
                                      if (content[field].search(matchRegExp) !== -1) {
                                          // content starts with value (first in results)
                                          addResult(results, content);
                                      }
                                      else if (settings.searchFullText && module.fuzzySearch(searchTerm, content[field])) {
                                          // content fuzzy matches (last in results)
                                          addResult(fuzzyResults, content);
                                      }
                                  }
                              });
                          });
                          return $.merge(results, fuzzyResults);
                      }
                  },

                  fuzzySearch: function (query, term) {
                      var
                        termLength = term.length,
                        queryLength = query.length
                      ;
                      if (typeof query !== 'string') {
                          return false;
                      }
                      query = query.toLowerCase();
                      term = term.toLowerCase();
                      if (queryLength > termLength) {
                          return false;
                      }
                      if (queryLength === termLength) {
                          return (query === term);
                      }
                      search: for (var characterIndex = 0, nextCharacterIndex = 0; characterIndex < queryLength; characterIndex++) {
                          var
                            queryCharacter = query.charCodeAt(characterIndex)
                          ;
                          while (nextCharacterIndex < termLength) {
                              if (term.charCodeAt(nextCharacterIndex++) === queryCharacter) {
                                  continue search;
                              }
                          }
                          return false;
                      }
                      return true;
                  },

                  parse: {
                      response: function (response, searchTerm) {
                          var
                            searchHTML = module.generateResults(response)
                          ;
                          module.verbose('Parsing server response', response);
                          if (response !== undefined) {
                              if (searchTerm !== undefined && response[fields.results] !== undefined) {
                                  module.addResults(searchHTML);
                                  module.inject.id(response[fields.results]);
                                  module.write.cache(searchTerm, {
                                      html: searchHTML,
                                      results: response[fields.results]
                                  });
                                  module.save.results(response[fields.results]);
                              }
                          }
                      }
                  },

                  cancel: {
                      query: function () {
                          if (module.can.useAPI()) {
                              $module.api('abort');
                          }
                      }
                  },

                  has: {
                      minimumCharacters: function () {
                          var
                            searchTerm = module.get.value(),
                            numCharacters = searchTerm.length
                          ;
                          return (numCharacters >= settings.minCharacters);
                      }
                  },

                  clear: {
                      cache: function (value) {
                          var
                            cache = $module.data(metadata.cache)
                          ;
                          if (!value) {
                              module.debug('Clearing cache', value);
                              $module.removeData(metadata.cache);
                          }
                          else if (value && cache && cache[value]) {
                              module.debug('Removing value from cache', value);
                              delete cache[value];
                              $module.data(metadata.cache, cache);
                          }
                      }
                  },

                  read: {
                      cache: function (name) {
                          var
                            cache = $module.data(metadata.cache)
                          ;
                          if (settings.cache) {
                              module.verbose('Checking cache for generated html for query', name);
                              return (typeof cache == 'object') && (cache[name] !== undefined)
                                ? cache[name]
                                : false
                              ;
                          }
                          return false;
                      }
                  },

                  create: {
                      id: function (resultIndex, categoryIndex) {
                          var
                            resultID = (resultIndex + 1), // not zero indexed
                            categoryID = (categoryIndex + 1),
                            firstCharCode,
                            letterID,
                            id
                          ;
                          if (categoryIndex !== undefined) {
                              // start char code for "A"
                              letterID = String.fromCharCode(97 + categoryIndex);
                              id = letterID + resultID;
                              module.verbose('Creating category result id', id);
                          }
                          else {
                              id = resultID;
                              module.verbose('Creating result id', id);
                          }
                          return id;
                      },
                      results: function () {
                          if ($results.length === 0) {
                              $results = $('<div />')
                                .addClass(className.results)
                                .appendTo($module)
                              ;
                          }
                      }
                  },

                  inject: {
                      result: function (result, resultIndex, categoryIndex) {
                          module.verbose('Injecting result into results');
                          var
                            $selectedResult = (categoryIndex !== undefined)
                              ? $results
                                  .children().eq(categoryIndex)
                                    .children(selector.result).eq(resultIndex)
                              : $results
                                  .children(selector.result).eq(resultIndex)
                          ;
                          module.verbose('Injecting results metadata', $selectedResult);
                          $selectedResult
                            .data(metadata.result, result)
                          ;
                      },
                      id: function (results) {
                          module.debug('Injecting unique ids into results');
                          var
                            // since results may be object, we must use counters
                            categoryIndex = 0,
                            resultIndex = 0
                          ;
                          if (settings.type === 'category') {
                              // iterate through each category result
                              $.each(results, function (index, category) {
                                  resultIndex = 0;
                                  $.each(category.results, function (index, value) {
                                      var
                                        result = category.results[index]
                                      ;
                                      if (result.id === undefined) {
                                          result.id = module.create.id(resultIndex, categoryIndex);
                                      }
                                      module.inject.result(result, resultIndex, categoryIndex);
                                      resultIndex++;
                                  });
                                  categoryIndex++;
                              });
                          }
                          else {
                              // top level
                              $.each(results, function (index, value) {
                                  var
                                    result = results[index]
                                  ;
                                  if (result.id === undefined) {
                                      result.id = module.create.id(resultIndex);
                                  }
                                  module.inject.result(result, resultIndex);
                                  resultIndex++;
                              });
                          }
                          return results;
                      }
                  },

                  save: {
                      results: function (results) {
                          module.verbose('Saving current search results to metadata', results);
                          $module.data(metadata.results, results);
                      }
                  },

                  write: {
                      cache: function (name, value) {
                          var
                            cache = ($module.data(metadata.cache) !== undefined)
                              ? $module.data(metadata.cache)
                              : {}
                          ;
                          if (settings.cache) {
                              module.verbose('Writing generated html to cache', name, value);
                              cache[name] = value;
                              $module
                                .data(metadata.cache, cache)
                              ;
                          }
                      }
                  },

                  addResults: function (html) {
                      if ($.isFunction(settings.onResultsAdd)) {
                          if (settings.onResultsAdd.call($results, html) === false) {
                              module.debug('onResultsAdd callback cancelled default action');
                              return false;
                          }
                      }
                      if (html) {
                          $results
                            .html(html)
                          ;
                          module.refreshResults();
                          if (settings.selectFirstResult) {
                              module.select.firstResult();
                          }
                          module.showResults();
                      }
                      else {
                          module.hideResults();
                      }
                  },

                  showResults: function () {
                      if (!module.is.visible()) {
                          if (module.can.transition()) {
                              module.debug('Showing results with css animations');
                              $results
                                .transition({
                                    animation: settings.transition + ' in',
                                    debug: settings.debug,
                                    verbose: settings.verbose,
                                    duration: settings.duration,
                                    queue: true
                                })
                              ;
                          }
                          else {
                              module.debug('Showing results with javascript');
                              $results
                                .stop()
                                .fadeIn(settings.duration, settings.easing)
                              ;
                          }
                          settings.onResultsOpen.call($results);
                      }
                  },
                  hideResults: function () {
                      if (module.is.visible()) {
                          if (module.can.transition()) {
                              module.debug('Hiding results with css animations');
                              $results
                                .transition({
                                    animation: settings.transition + ' out',
                                    debug: settings.debug,
                                    verbose: settings.verbose,
                                    duration: settings.duration,
                                    queue: true
                                })
                              ;
                          }
                          else {
                              module.debug('Hiding results with javascript');
                              $results
                                .stop()
                                .fadeOut(settings.duration, settings.easing)
                              ;
                          }
                          settings.onResultsClose.call($results);
                      }
                  },

                  generateResults: function (response) {
                      module.debug('Generating html from response', response);
                      var
                        template = settings.templates[settings.type],
                        isProperObject = ($.isPlainObject(response[fields.results]) && !$.isEmptyObject(response[fields.results])),
                        isProperArray = ($.isArray(response[fields.results]) && response[fields.results].length > 0),
                        html = ''
                      ;
                      if (isProperObject || isProperArray) {
                          if (settings.maxResults > 0) {
                              if (isProperObject) {
                                  if (settings.type == 'standard') {
                                      module.error(error.maxResults);
                                  }
                              }
                              else {
                                  response[fields.results] = response[fields.results].slice(0, settings.maxResults);
                              }
                          }
                          if ($.isFunction(template)) {
                              html = template(response, fields);
                          }
                          else {
                              module.error(error.noTemplate, false);
                          }
                      }
                      else if (settings.showNoResults) {
                          html = module.displayMessage(error.noResults, 'empty');
                      }
                      settings.onResults.call(element, response);
                      return html;
                  },

                  displayMessage: function (text, type) {
                      type = type || 'standard';
                      module.debug('Displaying message', text, type);
                      module.addResults(settings.templates.message(text, type));
                      return settings.templates.message(text, type);
                  },

                  setting: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          settings[name] = value;
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ($allModules.length > 1) {
                              title += ' ' + '(' + $allModules.length + ')';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };
              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }

          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.search.settings = {

        name: 'Search',
        namespace: 'search',

        silent: false,
        debug: false,
        verbose: false,
        performance: true,

        // template to use (specified in settings.templates)
        type: 'standard',

        // minimum characters required to search
        minCharacters: 1,

        // whether to select first result after searching automatically
        selectFirstResult: false,

        // API config
        apiSettings: false,

        // object to search
        source: false,

        // fields to search
        searchFields: [
          'title',
          'description'
        ],

        // field to display in standard results template
        displayField: '',

        // whether to include fuzzy results in local search
        searchFullText: true,

        // whether to add events to prompt automatically
        automatic: true,

        // delay before hiding menu after blur
        hideDelay: 0,

        // delay before searching
        searchDelay: 200,

        // maximum results returned from local
        maxResults: 7,

        // whether to store lookups in local cache
        cache: true,

        // whether no results errors should be shown
        showNoResults: true,

        // transition settings
        transition: 'scale',
        duration: 200,
        easing: 'easeOutExpo',

        // callbacks
        onSelect: false,
        onResultsAdd: false,

        onSearchQuery: function (query) { },
        onResults: function (response) { },

        onResultsOpen: function () { },
        onResultsClose: function () { },

        className: {
            animating: 'animating',
            active: 'active',
            empty: 'empty',
            focus: 'focus',
            hidden: 'hidden',
            loading: 'loading',
            results: 'results',
            pressed: 'down'
        },

        error: {
            source: 'Cannot search. No source used, and Semantic API module was not included',
            noResults: 'Your search returned no results',
            logging: 'Error in debug logging, exiting.',
            noEndpoint: 'No search endpoint was specified',
            noTemplate: 'A valid template name was not specified.',
            serverError: 'There was an issue querying the server.',
            maxResults: 'Results must be an array to use maxResults setting',
            method: 'The method you called is not defined.'
        },

        metadata: {
            cache: 'cache',
            results: 'results',
            result: 'result'
        },

        regExp: {
            escape: /[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,
            beginsWith: '(?:\s|^)'
        },

        // maps api response attributes to internal representation
        fields: {
            categories: 'results',     // array of categories (category view)
            categoryName: 'name',        // name of category (category view)
            categoryResults: 'results',     // array of results (category view)
            description: 'description', // result description
            image: 'image',       // result image
            price: 'price',       // result price
            results: 'results',     // array of results (standard)
            title: 'title',       // result title
            url: 'url',         // result url
            action: 'action',      // "view more" object name
            actionText: 'text',        // "view more" text
            actionURL: 'url'          // "view more" url
        },

        selector: {
            prompt: '.prompt',
            searchButton: '.search.button',
            results: '.results',
            message: '.results > .message',
            category: '.category',
            result: '.result',
            title: '.title, .name'
        },

        templates: {
            escape: function (string) {
                var
                  badChars = /[&<>"'`]/g,
                  shouldEscape = /[&<>"'`]/,
                  escape = {
                      "&": "&amp;",
                      "<": "&lt;",
                      ">": "&gt;",
                      '"': "&quot;",
                      "'": "&#x27;",
                      "`": "&#x60;"
                  },
                  escapedChar = function (chr) {
                      return escape[chr];
                  }
                ;
                if (shouldEscape.test(string)) {
                    return string.replace(badChars, escapedChar);
                }
                return string;
            },
            message: function (message, type) {
                var
                  html = ''
                ;
                if (message !== undefined && type !== undefined) {
                    html += ''
                      + '<div class="message ' + type + '">'
                    ;
                    // message type
                    if (type == 'empty') {
                        html += ''
                          + '<div class="header">No Results</div class="header">'
                          + '<div class="description">' + message + '</div class="description">'
                        ;
                    }
                    else {
                        html += ' <div class="description">' + message + '</div>';
                    }
                    html += '</div>';
                }
                return html;
            },
            category: function (response, fields) {
                var
                  html = '',
                  escape = $.fn.search.settings.templates.escape
                ;
                if (response[fields.categoryResults] !== undefined) {

                    // each category
                    $.each(response[fields.categoryResults], function (index, category) {
                        if (category[fields.results] !== undefined && category.results.length > 0) {

                            html += '<div class="category">';

                            if (category[fields.categoryName] !== undefined) {
                                html += '<div class="name">' + category[fields.categoryName] + '</div>';
                            }

                            // each item inside category
                            $.each(category.results, function (index, result) {
                                if (result[fields.url]) {
                                    html += '<a class="result" href="' + result[fields.url] + '">';
                                }
                                else {
                                    html += '<a class="result">';
                                }
                                if (result[fields.image] !== undefined) {
                                    html += ''
                                      + '<div class="image">'
                                      + ' <img src="' + result[fields.image] + '">'
                                      + '</div>'
                                    ;
                                }
                                html += '<div class="content">';
                                if (result[fields.price] !== undefined) {
                                    html += '<div class="price">' + result[fields.price] + '</div>';
                                }
                                if (result[fields.title] !== undefined) {
                                    html += '<div class="title">' + result[fields.title] + '</div>';
                                }
                                if (result[fields.description] !== undefined) {
                                    html += '<div class="description">' + result[fields.description] + '</div>';
                                }
                                html += ''
                                  + '</div>'
                                ;
                                html += '</a>';
                            });
                            html += ''
                              + '</div>'
                            ;
                        }
                    });
                    if (response[fields.action]) {
                        html += ''
                        + '<a href="' + response[fields.action][fields.actionURL] + '" class="action">'
                        + response[fields.action][fields.actionText]
                        + '</a>';
                    }
                    return html;
                }
                return false;
            },
            standard: function (response, fields) {
                var
                  html = ''
                ;
                if (response[fields.results] !== undefined) {

                    // each result
                    $.each(response[fields.results], function (index, result) {
                        if (result[fields.url]) {
                            html += '<a class="result" href="' + result[fields.url] + '">';
                        }
                        else {
                            html += '<a class="result">';
                        }
                        if (result[fields.image] !== undefined) {
                            html += ''
                              + '<div class="image">'
                              + ' <img src="' + result[fields.image] + '">'
                              + '</div>'
                            ;
                        }
                        html += '<div class="content">';
                        if (result[fields.price] !== undefined) {
                            html += '<div class="price">' + result[fields.price] + '</div>';
                        }
                        if (result[fields.title] !== undefined) {
                            html += '<div class="title">' + result[fields.title] + '</div>';
                        }
                        if (result[fields.description] !== undefined) {
                            html += '<div class="description">' + result[fields.description] + '</div>';
                        }
                        html += ''
                          + '</div>'
                        ;
                        html += '</a>';
                    });

                    if (response[fields.action]) {
                        html += ''
                        + '<a href="' + response[fields.action][fields.actionURL] + '" class="action">'
                        + response[fields.action][fields.actionText]
                        + '</a>';
                    }
                    return html;
                }
                return false;
            }
        }
    };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Shape
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.shape = function (parameters) {
        var
          $allModules = $(this),
          $body = $('body'),

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          requestAnimationFrame = window.requestAnimationFrame
            || window.mozRequestAnimationFrame
            || window.webkitRequestAnimationFrame
            || window.msRequestAnimationFrame
            || function (callback) { setTimeout(callback, 0); },

          returnedValue
        ;

        $allModules
          .each(function () {
              var
                moduleSelector = $allModules.selector || '',
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.shape.settings, parameters)
                  : $.extend({}, $.fn.shape.settings),

                // internal aliases
                namespace = settings.namespace,
                selector = settings.selector,
                error = settings.error,
                className = settings.className,

                // define namespaces for modules
                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                // selector cache
                $module = $(this),
                $sides = $module.find(selector.sides),
                $side = $module.find(selector.side),

                // private variables
                nextIndex = false,
                $activeSide,
                $nextSide,

                // standard module
                element = this,
                instance = $module.data(moduleNamespace),
                module
              ;

              module = {

                  initialize: function () {
                      module.verbose('Initializing module for', element);
                      module.set.defaultSide();
                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, instance)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous module for', element);
                      $module
                        .removeData(moduleNamespace)
                        .off(eventNamespace)
                      ;
                  },

                  refresh: function () {
                      module.verbose('Refreshing selector cache for', element);
                      $module = $(element);
                      $sides = $(this).find(selector.shape);
                      $side = $(this).find(selector.side);
                  },

                  repaint: function () {
                      module.verbose('Forcing repaint event');
                      var
                        shape = $sides[0] || document.createElement('div'),
                        fakeAssignment = shape.offsetWidth
                      ;
                  },

                  animate: function (propertyObject, callback) {
                      module.verbose('Animating box with properties', propertyObject);
                      callback = callback || function (event) {
                          module.verbose('Executing animation callback');
                          if (event !== undefined) {
                              event.stopPropagation();
                          }
                          module.reset();
                          module.set.active();
                      };
                      settings.beforeChange.call($nextSide[0]);
                      if (module.get.transitionEvent()) {
                          module.verbose('Starting CSS animation');
                          $module
                            .addClass(className.animating)
                          ;
                          $sides
                            .css(propertyObject)
                            .one(module.get.transitionEvent(), callback)
                          ;
                          module.set.duration(settings.duration);
                          requestAnimationFrame(function () {
                              $module
                                .addClass(className.animating)
                              ;
                              $activeSide
                                .addClass(className.hidden)
                              ;
                          });
                      }
                      else {
                          callback();
                      }
                  },

                  queue: function (method) {
                      module.debug('Queueing animation of', method);
                      $sides
                        .one(module.get.transitionEvent(), function () {
                            module.debug('Executing queued animation');
                            setTimeout(function () {
                                $module.shape(method);
                            }, 0);
                        })
                      ;
                  },

                  reset: function () {
                      module.verbose('Animating states reset');
                      $module
                        .removeClass(className.animating)
                        .attr('style', '')
                        .removeAttr('style')
                      ;
                      // removeAttr style does not consistently work in safari
                      $sides
                        .attr('style', '')
                        .removeAttr('style')
                      ;
                      $side
                        .attr('style', '')
                        .removeAttr('style')
                        .removeClass(className.hidden)
                      ;
                      $nextSide
                        .removeClass(className.animating)
                        .attr('style', '')
                        .removeAttr('style')
                      ;
                  },

                  is: {
                      complete: function () {
                          return ($side.filter('.' + className.active)[0] == $nextSide[0]);
                      },
                      animating: function () {
                          return $module.hasClass(className.animating);
                      }
                  },

                  set: {

                      defaultSide: function () {
                          $activeSide = $module.find('.' + settings.className.active);
                          $nextSide = ($activeSide.next(selector.side).length > 0)
                            ? $activeSide.next(selector.side)
                            : $module.find(selector.side).first()
                          ;
                          nextIndex = false;
                          module.verbose('Active side set to', $activeSide);
                          module.verbose('Next side set to', $nextSide);
                      },

                      duration: function (duration) {
                          duration = duration || settings.duration;
                          duration = (typeof duration == 'number')
                            ? duration + 'ms'
                            : duration
                          ;
                          module.verbose('Setting animation duration', duration);
                          if (settings.duration || settings.duration === 0) {
                              $sides.add($side)
                                .css({
                                    '-webkit-transition-duration': duration,
                                    '-moz-transition-duration': duration,
                                    '-ms-transition-duration': duration,
                                    '-o-transition-duration': duration,
                                    'transition-duration': duration
                                })
                              ;
                          }
                      },

                      currentStageSize: function () {
                          var
                            $activeSide = $module.find('.' + settings.className.active),
                            width = $activeSide.outerWidth(true),
                            height = $activeSide.outerHeight(true)
                          ;
                          $module
                            .css({
                                width: width,
                                height: height
                            })
                          ;
                      },

                      stageSize: function () {
                          var
                            $clone = $module.clone().addClass(className.loading),
                            $activeSide = $clone.find('.' + settings.className.active),
                            $nextSide = (nextIndex)
                              ? $clone.find(selector.side).eq(nextIndex)
                              : ($activeSide.next(selector.side).length > 0)
                                ? $activeSide.next(selector.side)
                                : $clone.find(selector.side).first(),
                            newWidth = (settings.width == 'next')
                              ? $nextSide.outerWidth(true)
                              : (settings.width == 'initial')
                                ? $module.width()
                                : settings.width,
                            newHeight = (settings.height == 'next')
                              ? $nextSide.outerHeight(true)
                              : (settings.height == 'initial')
                                ? $module.height()
                                : settings.height
                          ;
                          $activeSide.removeClass(className.active);
                          $nextSide.addClass(className.active);
                          $clone.insertAfter($module);
                          $clone.remove();
                          if (settings.width != 'auto') {
                              $module.css('width', newWidth + settings.jitter);
                              module.verbose('Specifying width during animation', newWidth);
                          }
                          if (settings.height != 'auto') {
                              $module.css('height', newHeight + settings.jitter);
                              module.verbose('Specifying height during animation', newHeight);
                          }
                      },

                      nextSide: function (selector) {
                          nextIndex = selector;
                          $nextSide = $side.filter(selector);
                          nextIndex = $side.index($nextSide);
                          if ($nextSide.length === 0) {
                              module.set.defaultSide();
                              module.error(error.side);
                          }
                          module.verbose('Next side manually set to', $nextSide);
                      },

                      active: function () {
                          module.verbose('Setting new side to active', $nextSide);
                          $side
                            .removeClass(className.active)
                          ;
                          $nextSide
                            .addClass(className.active)
                          ;
                          settings.onChange.call($nextSide[0]);
                          module.set.defaultSide();
                      }
                  },

                  flip: {

                      up: function () {
                          if (module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                              module.debug('Side already visible', $nextSide);
                              return;
                          }
                          if (!module.is.animating()) {
                              module.debug('Flipping up', $nextSide);
                              var
                                transform = module.get.transform.up()
                              ;
                              module.set.stageSize();
                              module.stage.above();
                              module.animate(transform);
                          }
                          else {
                              module.queue('flip up');
                          }
                      },

                      down: function () {
                          if (module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                              module.debug('Side already visible', $nextSide);
                              return;
                          }
                          if (!module.is.animating()) {
                              module.debug('Flipping down', $nextSide);
                              var
                                transform = module.get.transform.down()
                              ;
                              module.set.stageSize();
                              module.stage.below();
                              module.animate(transform);
                          }
                          else {
                              module.queue('flip down');
                          }
                      },

                      left: function () {
                          if (module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                              module.debug('Side already visible', $nextSide);
                              return;
                          }
                          if (!module.is.animating()) {
                              module.debug('Flipping left', $nextSide);
                              var
                                transform = module.get.transform.left()
                              ;
                              module.set.stageSize();
                              module.stage.left();
                              module.animate(transform);
                          }
                          else {
                              module.queue('flip left');
                          }
                      },

                      right: function () {
                          if (module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                              module.debug('Side already visible', $nextSide);
                              return;
                          }
                          if (!module.is.animating()) {
                              module.debug('Flipping right', $nextSide);
                              var
                                transform = module.get.transform.right()
                              ;
                              module.set.stageSize();
                              module.stage.right();
                              module.animate(transform);
                          }
                          else {
                              module.queue('flip right');
                          }
                      },

                      over: function () {
                          if (module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                              module.debug('Side already visible', $nextSide);
                              return;
                          }
                          if (!module.is.animating()) {
                              module.debug('Flipping over', $nextSide);
                              module.set.stageSize();
                              module.stage.behind();
                              module.animate(module.get.transform.over());
                          }
                          else {
                              module.queue('flip over');
                          }
                      },

                      back: function () {
                          if (module.is.complete() && !module.is.animating() && !settings.allowRepeats) {
                              module.debug('Side already visible', $nextSide);
                              return;
                          }
                          if (!module.is.animating()) {
                              module.debug('Flipping back', $nextSide);
                              module.set.stageSize();
                              module.stage.behind();
                              module.animate(module.get.transform.back());
                          }
                          else {
                              module.queue('flip back');
                          }
                      }

                  },

                  get: {

                      transform: {
                          up: function () {
                              var
                                translate = {
                                    y: -(($activeSide.outerHeight(true) - $nextSide.outerHeight(true)) / 2),
                                    z: -($activeSide.outerHeight(true) / 2)
                                }
                              ;
                              return {
                                  transform: 'translateY(' + translate.y + 'px) translateZ(' + translate.z + 'px) rotateX(-90deg)'
                              };
                          },

                          down: function () {
                              var
                                translate = {
                                    y: -(($activeSide.outerHeight(true) - $nextSide.outerHeight(true)) / 2),
                                    z: -($activeSide.outerHeight(true) / 2)
                                }
                              ;
                              return {
                                  transform: 'translateY(' + translate.y + 'px) translateZ(' + translate.z + 'px) rotateX(90deg)'
                              };
                          },

                          left: function () {
                              var
                                translate = {
                                    x: -(($activeSide.outerWidth(true) - $nextSide.outerWidth(true)) / 2),
                                    z: -($activeSide.outerWidth(true) / 2)
                                }
                              ;
                              return {
                                  transform: 'translateX(' + translate.x + 'px) translateZ(' + translate.z + 'px) rotateY(90deg)'
                              };
                          },

                          right: function () {
                              var
                                translate = {
                                    x: -(($activeSide.outerWidth(true) - $nextSide.outerWidth(true)) / 2),
                                    z: -($activeSide.outerWidth(true) / 2)
                                }
                              ;
                              return {
                                  transform: 'translateX(' + translate.x + 'px) translateZ(' + translate.z + 'px) rotateY(-90deg)'
                              };
                          },

                          over: function () {
                              var
                                translate = {
                                    x: -(($activeSide.outerWidth(true) - $nextSide.outerWidth(true)) / 2)
                                }
                              ;
                              return {
                                  transform: 'translateX(' + translate.x + 'px) rotateY(180deg)'
                              };
                          },

                          back: function () {
                              var
                                translate = {
                                    x: -(($activeSide.outerWidth(true) - $nextSide.outerWidth(true)) / 2)
                                }
                              ;
                              return {
                                  transform: 'translateX(' + translate.x + 'px) rotateY(-180deg)'
                              };
                          }
                      },

                      transitionEvent: function () {
                          var
                            element = document.createElement('element'),
                            transitions = {
                                'transition': 'transitionend',
                                'OTransition': 'oTransitionEnd',
                                'MozTransition': 'transitionend',
                                'WebkitTransition': 'webkitTransitionEnd'
                            },
                            transition
                          ;
                          for (transition in transitions) {
                              if (element.style[transition] !== undefined) {
                                  return transitions[transition];
                              }
                          }
                      },

                      nextSide: function () {
                          return ($activeSide.next(selector.side).length > 0)
                            ? $activeSide.next(selector.side)
                            : $module.find(selector.side).first()
                          ;
                      }

                  },

                  stage: {

                      above: function () {
                          var
                            box = {
                                origin: (($activeSide.outerHeight(true) - $nextSide.outerHeight(true)) / 2),
                                depth: {
                                    active: ($nextSide.outerHeight(true) / 2),
                                    next: ($activeSide.outerHeight(true) / 2)
                                }
                            }
                          ;
                          module.verbose('Setting the initial animation position as above', $nextSide, box);
                          $sides
                            .css({
                                'transform': 'translateZ(-' + box.depth.active + 'px)'
                            })
                          ;
                          $activeSide
                            .css({
                                'transform': 'rotateY(0deg) translateZ(' + box.depth.active + 'px)'
                            })
                          ;
                          $nextSide
                            .addClass(className.animating)
                            .css({
                                'top': box.origin + 'px',
                                'transform': 'rotateX(90deg) translateZ(' + box.depth.next + 'px)'
                            })
                          ;
                      },

                      below: function () {
                          var
                            box = {
                                origin: (($activeSide.outerHeight(true) - $nextSide.outerHeight(true)) / 2),
                                depth: {
                                    active: ($nextSide.outerHeight(true) / 2),
                                    next: ($activeSide.outerHeight(true) / 2)
                                }
                            }
                          ;
                          module.verbose('Setting the initial animation position as below', $nextSide, box);
                          $sides
                            .css({
                                'transform': 'translateZ(-' + box.depth.active + 'px)'
                            })
                          ;
                          $activeSide
                            .css({
                                'transform': 'rotateY(0deg) translateZ(' + box.depth.active + 'px)'
                            })
                          ;
                          $nextSide
                            .addClass(className.animating)
                            .css({
                                'top': box.origin + 'px',
                                'transform': 'rotateX(-90deg) translateZ(' + box.depth.next + 'px)'
                            })
                          ;
                      },

                      left: function () {
                          var
                            height = {
                                active: $activeSide.outerWidth(true),
                                next: $nextSide.outerWidth(true)
                            },
                            box = {
                                origin: ((height.active - height.next) / 2),
                                depth: {
                                    active: (height.next / 2),
                                    next: (height.active / 2)
                                }
                            }
                          ;
                          module.verbose('Setting the initial animation position as left', $nextSide, box);
                          $sides
                            .css({
                                'transform': 'translateZ(-' + box.depth.active + 'px)'
                            })
                          ;
                          $activeSide
                            .css({
                                'transform': 'rotateY(0deg) translateZ(' + box.depth.active + 'px)'
                            })
                          ;
                          $nextSide
                            .addClass(className.animating)
                            .css({
                                'left': box.origin + 'px',
                                'transform': 'rotateY(-90deg) translateZ(' + box.depth.next + 'px)'
                            })
                          ;
                      },

                      right: function () {
                          var
                            height = {
                                active: $activeSide.outerWidth(true),
                                next: $nextSide.outerWidth(true)
                            },
                            box = {
                                origin: ((height.active - height.next) / 2),
                                depth: {
                                    active: (height.next / 2),
                                    next: (height.active / 2)
                                }
                            }
                          ;
                          module.verbose('Setting the initial animation position as left', $nextSide, box);
                          $sides
                            .css({
                                'transform': 'translateZ(-' + box.depth.active + 'px)'
                            })
                          ;
                          $activeSide
                            .css({
                                'transform': 'rotateY(0deg) translateZ(' + box.depth.active + 'px)'
                            })
                          ;
                          $nextSide
                            .addClass(className.animating)
                            .css({
                                'left': box.origin + 'px',
                                'transform': 'rotateY(90deg) translateZ(' + box.depth.next + 'px)'
                            })
                          ;
                      },

                      behind: function () {
                          var
                            height = {
                                active: $activeSide.outerWidth(true),
                                next: $nextSide.outerWidth(true)
                            },
                            box = {
                                origin: ((height.active - height.next) / 2),
                                depth: {
                                    active: (height.next / 2),
                                    next: (height.active / 2)
                                }
                            }
                          ;
                          module.verbose('Setting the initial animation position as behind', $nextSide, box);
                          $activeSide
                            .css({
                                'transform': 'rotateY(0deg)'
                            })
                          ;
                          $nextSide
                            .addClass(className.animating)
                            .css({
                                'left': box.origin + 'px',
                                'transform': 'rotateY(-180deg)'
                            })
                          ;
                      }
                  },
                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ($allModules.length > 1) {
                              title += ' ' + '(' + $allModules.length + ')';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.shape.settings = {

        // module info
        name: 'Shape',

        // hide all debug content
        silent: false,

        // debug content outputted to console
        debug: false,

        // verbose debug output
        verbose: false,

        // fudge factor in pixels when swapping from 2d to 3d (can be useful to correct rounding errors)
        jitter: 0,

        // performance data output
        performance: true,

        // event namespace
        namespace: 'shape',

        // width during animation, can be set to 'auto', initial', 'next' or pixel amount
        width: 'initial',

        // height during animation, can be set to 'auto', 'initial', 'next' or pixel amount
        height: 'initial',

        // callback occurs on side change
        beforeChange: function () { },
        onChange: function () { },

        // allow animation to same side
        allowRepeats: false,

        // animation duration
        duration: false,

        // possible errors
        error: {
            side: 'You tried to switch to a side that does not exist.',
            method: 'The method you called is not defined'
        },

        // classnames used
        className: {
            animating: 'animating',
            hidden: 'hidden',
            loading: 'loading',
            active: 'active'
        },

        // selectors used
        selector: {
            sides: '.sides',
            side: '.side'
        }

    };


})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Sidebar
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.sidebar = function (parameters) {
        var
          $allModules = $(this),
          $window = $(window),
          $document = $(document),
          $html = $('html'),
          $head = $('head'),

          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          requestAnimationFrame = window.requestAnimationFrame
            || window.mozRequestAnimationFrame
            || window.webkitRequestAnimationFrame
            || window.msRequestAnimationFrame
            || function (callback) { setTimeout(callback, 0); },

          returnedValue
        ;

        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.sidebar.settings, parameters)
                  : $.extend({}, $.fn.sidebar.settings),

                selector = settings.selector,
                className = settings.className,
                namespace = settings.namespace,
                regExp = settings.regExp,
                error = settings.error,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                $module = $(this),
                $context = $(settings.context),

                $sidebars = $module.children(selector.sidebar),
                $fixed = $context.children(selector.fixed),
                $pusher = $context.children(selector.pusher),
                $style,

                element = this,
                instance = $module.data(moduleNamespace),

                elementNamespace,
                id,
                currentScroll,
                transitionEvent,

                module
              ;

              module = {

                  initialize: function () {
                      module.debug('Initializing sidebar', parameters);

                      module.create.id();

                      transitionEvent = module.get.transitionEvent();

                      if (module.is.ios()) {
                          module.set.ios();
                      }

                      // avoids locking rendering if initialized in onReady
                      if (settings.delaySetup) {
                          requestAnimationFrame(module.setup.layout);
                      }
                      else {
                          module.setup.layout();
                      }

                      requestAnimationFrame(function () {
                          module.setup.cache();
                      });

                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },

                  create: {
                      id: function () {
                          id = (Math.random().toString(16) + '000000000').substr(2, 8);
                          elementNamespace = '.' + id;
                          module.verbose('Creating unique id for element', id);
                      }
                  },

                  destroy: function () {
                      module.verbose('Destroying previous module for', $module);
                      $module
                        .off(eventNamespace)
                        .removeData(moduleNamespace)
                      ;
                      if (module.is.ios()) {
                          module.remove.ios();
                      }
                      // bound by uuid
                      $context.off(elementNamespace);
                      $window.off(elementNamespace);
                      $document.off(elementNamespace);
                  },

                  event: {
                      clickaway: function (event) {
                          var
                            clickedInPusher = ($pusher.find(event.target).length > 0 || $pusher.is(event.target)),
                            clickedContext = ($context.is(event.target))
                          ;
                          if (clickedInPusher) {
                              module.verbose('User clicked on dimmed page');
                              module.hide();
                          }
                          if (clickedContext) {
                              module.verbose('User clicked on dimmable context (scaled out page)');
                              module.hide();
                          }
                      },
                      touch: function (event) {
                          //event.stopPropagation();
                      },
                      containScroll: function (event) {
                          if (element.scrollTop <= 0) {
                              element.scrollTop = 1;
                          }
                          if ((element.scrollTop + element.offsetHeight) >= element.scrollHeight) {
                              element.scrollTop = element.scrollHeight - element.offsetHeight - 1;
                          }
                      },
                      scroll: function (event) {
                          if ($(event.target).closest(selector.sidebar).length === 0) {
                              event.preventDefault();
                          }
                      }
                  },

                  bind: {
                      clickaway: function () {
                          module.verbose('Adding clickaway events to context', $context);
                          if (settings.closable) {
                              $context
                                .on('click' + elementNamespace, module.event.clickaway)
                                .on('touchend' + elementNamespace, module.event.clickaway)
                              ;
                          }
                      },
                      scrollLock: function () {
                          if (settings.scrollLock) {
                              module.debug('Disabling page scroll');
                              $window
                                .on('DOMMouseScroll' + elementNamespace, module.event.scroll)
                              ;
                          }
                          module.verbose('Adding events to contain sidebar scroll');
                          $document
                            .on('touchmove' + elementNamespace, module.event.touch)
                          ;
                          $module
                            .on('scroll' + eventNamespace, module.event.containScroll)
                          ;
                      }
                  },
                  unbind: {
                      clickaway: function () {
                          module.verbose('Removing clickaway events from context', $context);
                          $context.off(elementNamespace);
                      },
                      scrollLock: function () {
                          module.verbose('Removing scroll lock from page');
                          $document.off(elementNamespace);
                          $window.off(elementNamespace);
                          $module.off('scroll' + eventNamespace);
                      }
                  },

                  add: {
                      inlineCSS: function () {
                          var
                            width = module.cache.width || $module.outerWidth(),
                            height = module.cache.height || $module.outerHeight(),
                            isRTL = module.is.rtl(),
                            direction = module.get.direction(),
                            distance = {
                                left: width,
                                right: -width,
                                top: height,
                                bottom: -height
                            },
                            style
                          ;

                          if (isRTL) {
                              module.verbose('RTL detected, flipping widths');
                              distance.left = -width;
                              distance.right = width;
                          }

                          style = '<style>';

                          if (direction === 'left' || direction === 'right') {
                              module.debug('Adding CSS rules for animation distance', width);
                              style += ''
                                + ' .ui.visible.' + direction + '.sidebar ~ .fixed,'
                                + ' .ui.visible.' + direction + '.sidebar ~ .pusher {'
                                + '   -webkit-transform: translate3d(' + distance[direction] + 'px, 0, 0);'
                                + '           transform: translate3d(' + distance[direction] + 'px, 0, 0);'
                                + ' }'
                              ;
                          }
                          else if (direction === 'top' || direction == 'bottom') {
                              style += ''
                                + ' .ui.visible.' + direction + '.sidebar ~ .fixed,'
                                + ' .ui.visible.' + direction + '.sidebar ~ .pusher {'
                                + '   -webkit-transform: translate3d(0, ' + distance[direction] + 'px, 0);'
                                + '           transform: translate3d(0, ' + distance[direction] + 'px, 0);'
                                + ' }'
                              ;
                          }

                          /* IE is only browser not to create context with transforms */
                          /* https://www.w3.org/Bugs/Public/show_bug.cgi?id=16328 */
                          if (module.is.ie()) {
                              if (direction === 'left' || direction === 'right') {
                                  module.debug('Adding CSS rules for animation distance', width);
                                  style += ''
                                    + ' body.pushable > .ui.visible.' + direction + '.sidebar ~ .pusher:after {'
                                    + '   -webkit-transform: translate3d(' + distance[direction] + 'px, 0, 0);'
                                    + '           transform: translate3d(' + distance[direction] + 'px, 0, 0);'
                                    + ' }'
                                  ;
                              }
                              else if (direction === 'top' || direction == 'bottom') {
                                  style += ''
                                    + ' body.pushable > .ui.visible.' + direction + '.sidebar ~ .pusher:after {'
                                    + '   -webkit-transform: translate3d(0, ' + distance[direction] + 'px, 0);'
                                    + '           transform: translate3d(0, ' + distance[direction] + 'px, 0);'
                                    + ' }'
                                  ;
                              }
                              /* opposite sides visible forces content overlay */
                              style += ''
                                + ' body.pushable > .ui.visible.left.sidebar ~ .ui.visible.right.sidebar ~ .pusher:after,'
                                + ' body.pushable > .ui.visible.right.sidebar ~ .ui.visible.left.sidebar ~ .pusher:after {'
                                + '   -webkit-transform: translate3d(0px, 0, 0);'
                                + '           transform: translate3d(0px, 0, 0);'
                                + ' }'
                              ;
                          }
                          style += '</style>';
                          $style = $(style)
                            .appendTo($head)
                          ;
                          module.debug('Adding sizing css to head', $style);
                      }
                  },

                  refresh: function () {
                      module.verbose('Refreshing selector cache');
                      $context = $(settings.context);
                      $sidebars = $context.children(selector.sidebar);
                      $pusher = $context.children(selector.pusher);
                      $fixed = $context.children(selector.fixed);
                      module.clear.cache();
                  },

                  refreshSidebars: function () {
                      module.verbose('Refreshing other sidebars');
                      $sidebars = $context.children(selector.sidebar);
                  },

                  repaint: function () {
                      module.verbose('Forcing repaint event');
                      element.style.display = 'none';
                      var ignored = element.offsetHeight;
                      element.scrollTop = element.scrollTop;
                      element.style.display = '';
                  },

                  setup: {
                      cache: function () {
                          module.cache = {
                              width: $module.outerWidth(),
                              height: $module.outerHeight(),
                              rtl: ($module.css('direction') == 'rtl')
                          };
                      },
                      layout: function () {
                          if ($context.children(selector.pusher).length === 0) {
                              module.debug('Adding wrapper element for sidebar');
                              module.error(error.pusher);
                              $pusher = $('<div class="pusher" />');
                              $context
                                .children()
                                  .not(selector.omitted)
                                  .not($sidebars)
                                  .wrapAll($pusher)
                              ;
                              module.refresh();
                          }
                          if ($module.nextAll(selector.pusher).length === 0 || $module.nextAll(selector.pusher)[0] !== $pusher[0]) {
                              module.debug('Moved sidebar to correct parent element');
                              module.error(error.movedSidebar, element);
                              $module.detach().prependTo($context);
                              module.refresh();
                          }
                          module.clear.cache();
                          module.set.pushable();
                          module.set.direction();
                      }
                  },

                  attachEvents: function (selector, event) {
                      var
                        $toggle = $(selector)
                      ;
                      event = $.isFunction(module[event])
                        ? module[event]
                        : module.toggle
                      ;
                      if ($toggle.length > 0) {
                          module.debug('Attaching sidebar events to element', selector, event);
                          $toggle
                            .on('click' + eventNamespace, event)
                          ;
                      }
                      else {
                          module.error(error.notFound, selector);
                      }
                  },

                  show: function (callback) {
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      if (module.is.hidden()) {
                          module.refreshSidebars();
                          if (settings.overlay) {
                              module.error(error.overlay);
                              settings.transition = 'overlay';
                          }
                          module.refresh();
                          if (module.othersActive()) {
                              module.debug('Other sidebars currently visible');
                              if (settings.exclusive) {
                                  // if not overlay queue animation after hide
                                  if (settings.transition != 'overlay') {
                                      module.hideOthers(module.show);
                                      return;
                                  }
                                  else {
                                      module.hideOthers();
                                  }
                              }
                              else {
                                  settings.transition = 'overlay';
                              }
                          }
                          module.pushPage(function () {
                              callback.call(element);
                              settings.onShow.call(element);
                          });
                          settings.onChange.call(element);
                          settings.onVisible.call(element);
                      }
                      else {
                          module.debug('Sidebar is already visible');
                      }
                  },

                  hide: function (callback) {
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      if (module.is.visible() || module.is.animating()) {
                          module.debug('Hiding sidebar', callback);
                          module.refreshSidebars();
                          module.pullPage(function () {
                              callback.call(element);
                              settings.onHidden.call(element);
                          });
                          settings.onChange.call(element);
                          settings.onHide.call(element);
                      }
                  },

                  othersAnimating: function () {
                      return ($sidebars.not($module).filter('.' + className.animating).length > 0);
                  },
                  othersVisible: function () {
                      return ($sidebars.not($module).filter('.' + className.visible).length > 0);
                  },
                  othersActive: function () {
                      return (module.othersVisible() || module.othersAnimating());
                  },

                  hideOthers: function (callback) {
                      var
                        $otherSidebars = $sidebars.not($module).filter('.' + className.visible),
                        sidebarCount = $otherSidebars.length,
                        callbackCount = 0
                      ;
                      callback = callback || function () { };
                      $otherSidebars
                        .sidebar('hide', function () {
                            callbackCount++;
                            if (callbackCount == sidebarCount) {
                                callback();
                            }
                        })
                      ;
                  },

                  toggle: function () {
                      module.verbose('Determining toggled direction');
                      if (module.is.hidden()) {
                          module.show();
                      }
                      else {
                          module.hide();
                      }
                  },

                  pushPage: function (callback) {
                      var
                        transition = module.get.transition(),
                        $transition = (transition === 'overlay' || module.othersActive())
                          ? $module
                          : $pusher,
                        animate,
                        dim,
                        transitionEnd
                      ;
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      if (settings.transition == 'scale down') {
                          module.scrollToTop();
                      }
                      module.set.transition(transition);
                      module.repaint();
                      animate = function () {
                          module.bind.clickaway();
                          module.add.inlineCSS();
                          module.set.animating();
                          module.set.visible();
                      };
                      dim = function () {
                          module.set.dimmed();
                      };
                      transitionEnd = function (event) {
                          if (event.target == $transition[0]) {
                              $transition.off(transitionEvent + elementNamespace, transitionEnd);
                              module.remove.animating();
                              module.bind.scrollLock();
                              callback.call(element);
                          }
                      };
                      $transition.off(transitionEvent + elementNamespace);
                      $transition.on(transitionEvent + elementNamespace, transitionEnd);
                      requestAnimationFrame(animate);
                      if (settings.dimPage && !module.othersVisible()) {
                          requestAnimationFrame(dim);
                      }
                  },

                  pullPage: function (callback) {
                      var
                        transition = module.get.transition(),
                        $transition = (transition == 'overlay' || module.othersActive())
                          ? $module
                          : $pusher,
                        animate,
                        transitionEnd
                      ;
                      callback = $.isFunction(callback)
                        ? callback
                        : function () { }
                      ;
                      module.verbose('Removing context push state', module.get.direction());

                      module.unbind.clickaway();
                      module.unbind.scrollLock();

                      animate = function () {
                          module.set.transition(transition);
                          module.set.animating();
                          module.remove.visible();
                          if (settings.dimPage && !module.othersVisible()) {
                              $pusher.removeClass(className.dimmed);
                          }
                      };
                      transitionEnd = function (event) {
                          if (event.target == $transition[0]) {
                              $transition.off(transitionEvent + elementNamespace, transitionEnd);
                              module.remove.animating();
                              module.remove.transition();
                              module.remove.inlineCSS();
                              if (transition == 'scale down' || (settings.returnScroll && module.is.mobile())) {
                                  module.scrollBack();
                              }
                              callback.call(element);
                          }
                      };
                      $transition.off(transitionEvent + elementNamespace);
                      $transition.on(transitionEvent + elementNamespace, transitionEnd);
                      requestAnimationFrame(animate);
                  },

                  scrollToTop: function () {
                      module.verbose('Scrolling to top of page to avoid animation issues');
                      currentScroll = $(window).scrollTop();
                      $module.scrollTop(0);
                      window.scrollTo(0, 0);
                  },

                  scrollBack: function () {
                      module.verbose('Scrolling back to original page position');
                      window.scrollTo(0, currentScroll);
                  },

                  clear: {
                      cache: function () {
                          module.verbose('Clearing cached dimensions');
                          module.cache = {};
                      }
                  },

                  set: {

                      // ios only (scroll on html not document). This prevent auto-resize canvas/scroll in ios
                      ios: function () {
                          $html.addClass(className.ios);
                      },

                      // container
                      pushed: function () {
                          $context.addClass(className.pushed);
                      },
                      pushable: function () {
                          $context.addClass(className.pushable);
                      },

                      // pusher
                      dimmed: function () {
                          $pusher.addClass(className.dimmed);
                      },

                      // sidebar
                      active: function () {
                          $module.addClass(className.active);
                      },
                      animating: function () {
                          $module.addClass(className.animating);
                      },
                      transition: function (transition) {
                          transition = transition || module.get.transition();
                          $module.addClass(transition);
                      },
                      direction: function (direction) {
                          direction = direction || module.get.direction();
                          $module.addClass(className[direction]);
                      },
                      visible: function () {
                          $module.addClass(className.visible);
                      },
                      overlay: function () {
                          $module.addClass(className.overlay);
                      }
                  },
                  remove: {

                      inlineCSS: function () {
                          module.debug('Removing inline css styles', $style);
                          if ($style && $style.length > 0) {
                              $style.remove();
                          }
                      },

                      // ios scroll on html not document
                      ios: function () {
                          $html.removeClass(className.ios);
                      },

                      // context
                      pushed: function () {
                          $context.removeClass(className.pushed);
                      },
                      pushable: function () {
                          $context.removeClass(className.pushable);
                      },

                      // sidebar
                      active: function () {
                          $module.removeClass(className.active);
                      },
                      animating: function () {
                          $module.removeClass(className.animating);
                      },
                      transition: function (transition) {
                          transition = transition || module.get.transition();
                          $module.removeClass(transition);
                      },
                      direction: function (direction) {
                          direction = direction || module.get.direction();
                          $module.removeClass(className[direction]);
                      },
                      visible: function () {
                          $module.removeClass(className.visible);
                      },
                      overlay: function () {
                          $module.removeClass(className.overlay);
                      }
                  },

                  get: {
                      direction: function () {
                          if ($module.hasClass(className.top)) {
                              return className.top;
                          }
                          else if ($module.hasClass(className.right)) {
                              return className.right;
                          }
                          else if ($module.hasClass(className.bottom)) {
                              return className.bottom;
                          }
                          return className.left;
                      },
                      transition: function () {
                          var
                            direction = module.get.direction(),
                            transition
                          ;
                          transition = (module.is.mobile())
                            ? (settings.mobileTransition == 'auto')
                              ? settings.defaultTransition.mobile[direction]
                              : settings.mobileTransition
                            : (settings.transition == 'auto')
                              ? settings.defaultTransition.computer[direction]
                              : settings.transition
                          ;
                          module.verbose('Determined transition', transition);
                          return transition;
                      },
                      transitionEvent: function () {
                          var
                            element = document.createElement('element'),
                            transitions = {
                                'transition': 'transitionend',
                                'OTransition': 'oTransitionEnd',
                                'MozTransition': 'transitionend',
                                'WebkitTransition': 'webkitTransitionEnd'
                            },
                            transition
                          ;
                          for (transition in transitions) {
                              if (element.style[transition] !== undefined) {
                                  return transitions[transition];
                              }
                          }
                      }
                  },

                  is: {

                      ie: function () {
                          var
                            isIE11 = (!(window.ActiveXObject) && 'ActiveXObject' in window),
                            isIE = ('ActiveXObject' in window)
                          ;
                          return (isIE11 || isIE);
                      },

                      ios: function () {
                          var
                            userAgent = navigator.userAgent,
                            isIOS = userAgent.match(regExp.ios),
                            isMobileChrome = userAgent.match(regExp.mobileChrome)
                          ;
                          if (isIOS && !isMobileChrome) {
                              module.verbose('Browser was found to be iOS', userAgent);
                              return true;
                          }
                          else {
                              return false;
                          }
                      },
                      mobile: function () {
                          var
                            userAgent = navigator.userAgent,
                            isMobile = userAgent.match(regExp.mobile)
                          ;
                          if (isMobile) {
                              module.verbose('Browser was found to be mobile', userAgent);
                              return true;
                          }
                          else {
                              module.verbose('Browser is not mobile, using regular transition', userAgent);
                              return false;
                          }
                      },
                      hidden: function () {
                          return !module.is.visible();
                      },
                      visible: function () {
                          return $module.hasClass(className.visible);
                      },
                      // alias
                      open: function () {
                          return module.is.visible();
                      },
                      closed: function () {
                          return module.is.hidden();
                      },
                      vertical: function () {
                          return $module.hasClass(className.top);
                      },
                      animating: function () {
                          return $context.hasClass(className.animating);
                      },
                      rtl: function () {
                          if (module.cache.rtl === undefined) {
                              module.cache.rtl = ($module.css('direction') == 'rtl');
                          }
                          return module.cache.rtl;
                      }
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              }
              ;

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      module.invoke('destroy');
                  }
                  module.initialize();
              }
          });

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.sidebar.settings = {

        name: 'Sidebar',
        namespace: 'sidebar',

        silent: false,
        debug: false,
        verbose: false,
        performance: true,

        transition: 'auto',
        mobileTransition: 'auto',

        defaultTransition: {
            computer: {
                left: 'uncover',
                right: 'uncover',
                top: 'overlay',
                bottom: 'overlay'
            },
            mobile: {
                left: 'uncover',
                right: 'uncover',
                top: 'overlay',
                bottom: 'overlay'
            }
        },

        context: 'body',
        exclusive: false,
        closable: true,
        dimPage: true,
        scrollLock: false,
        returnScroll: false,
        delaySetup: false,

        duration: 500,

        onChange: function () { },
        onShow: function () { },
        onHide: function () { },

        onHidden: function () { },
        onVisible: function () { },

        className: {
            active: 'active',
            animating: 'animating',
            dimmed: 'dimmed',
            ios: 'ios',
            pushable: 'pushable',
            pushed: 'pushed',
            right: 'right',
            top: 'top',
            left: 'left',
            bottom: 'bottom',
            visible: 'visible'
        },

        selector: {
            fixed: '.fixed',
            omitted: 'script, link, style, .ui.modal, .ui.dimmer, .ui.nag, .ui.fixed',
            pusher: '.pusher',
            sidebar: '.ui.sidebar'
        },

        regExp: {
            ios: /(iPad|iPhone|iPod)/g,
            mobileChrome: /(CriOS)/g,
            mobile: /Mobile|iP(hone|od|ad)|Android|BlackBerry|IEMobile|Kindle|NetFront|Silk-Accelerated|(hpw|web)OS|Fennec|Minimo|Opera M(obi|ini)|Blazer|Dolfin|Dolphin|Skyfire|Zune/g
        },

        error: {
            method: 'The method you called is not defined.',
            pusher: 'Had to add pusher element. For optimal performance make sure body content is inside a pusher element',
            movedSidebar: 'Had to move sidebar. For optimal performance make sure sidebar and pusher are direct children of your body tag',
            overlay: 'The overlay setting is no longer supported, use animation: overlay',
            notFound: 'There were no elements that matched the specified selector'
        }

    };


})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Sticky
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.sticky = function (parameters) {
        var
          $allModules = $(this),
          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),
          returnedValue
        ;

        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.sticky.settings, parameters)
                  : $.extend({}, $.fn.sticky.settings),

                className = settings.className,
                namespace = settings.namespace,
                error = settings.error,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                $module = $(this),
                $window = $(window),
                $scroll = $(settings.scrollContext),
                $container,
                $context,

                selector = $module.selector || '',
                instance = $module.data(moduleNamespace),

                requestAnimationFrame = window.requestAnimationFrame
                  || window.mozRequestAnimationFrame
                  || window.webkitRequestAnimationFrame
                  || window.msRequestAnimationFrame
                  || function (callback) { setTimeout(callback, 0); },

                element = this,

                documentObserver,
                observer,
                module
              ;

              module = {

                  initialize: function () {

                      module.determineContainer();
                      module.determineContext();
                      module.verbose('Initializing sticky', settings, $container);

                      module.save.positions();
                      module.checkErrors();
                      module.bind.events();

                      if (settings.observeChanges) {
                          module.observeChanges();
                      }
                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous instance');
                      module.reset();
                      if (documentObserver) {
                          documentObserver.disconnect();
                      }
                      if (observer) {
                          observer.disconnect();
                      }
                      $window
                        .off('load' + eventNamespace, module.event.load)
                        .off('resize' + eventNamespace, module.event.resize)
                      ;
                      $scroll
                        .off('scrollchange' + eventNamespace, module.event.scrollchange)
                      ;
                      $module.removeData(moduleNamespace);
                  },

                  observeChanges: function () {
                      if ('MutationObserver' in window) {
                          documentObserver = new MutationObserver(module.event.documentChanged);
                          observer = new MutationObserver(module.event.changed);
                          documentObserver.observe(document, {
                              childList: true,
                              subtree: true
                          });
                          observer.observe(element, {
                              childList: true,
                              subtree: true
                          });
                          observer.observe($context[0], {
                              childList: true,
                              subtree: true
                          });
                          module.debug('Setting up mutation observer', observer);
                      }
                  },

                  determineContainer: function () {
                      $container = $module.offsetParent();
                  },

                  determineContext: function () {
                      if (settings.context) {
                          $context = $(settings.context);
                      }
                      else {
                          $context = $container;
                      }
                      if ($context.length === 0) {
                          module.error(error.invalidContext, settings.context, $module);
                          return;
                      }
                  },

                  checkErrors: function () {
                      if (module.is.hidden()) {
                          module.error(error.visible, $module);
                      }
                      if (module.cache.element.height > module.cache.context.height) {
                          module.reset();
                          module.error(error.elementSize, $module);
                          return;
                      }
                  },

                  bind: {
                      events: function () {
                          $window
                            .on('load' + eventNamespace, module.event.load)
                            .on('resize' + eventNamespace, module.event.resize)
                          ;
                          // pub/sub pattern
                          $scroll
                            .off('scroll' + eventNamespace)
                            .on('scroll' + eventNamespace, module.event.scroll)
                            .on('scrollchange' + eventNamespace, module.event.scrollchange)
                          ;
                      }
                  },

                  event: {
                      changed: function (mutations) {
                          clearTimeout(module.timer);
                          module.timer = setTimeout(function () {
                              module.verbose('DOM tree modified, updating sticky menu', mutations);
                              module.refresh();
                          }, 100);
                      },
                      documentChanged: function (mutations) {
                          [].forEach.call(mutations, function (mutation) {
                              if (mutation.removedNodes) {
                                  [].forEach.call(mutation.removedNodes, function (node) {
                                      if (node == element || $(node).find(element).length > 0) {
                                          module.debug('Element removed from DOM, tearing down events');
                                          module.destroy();
                                      }
                                  });
                              }
                          });
                      },
                      load: function () {
                          module.verbose('Page contents finished loading');
                          requestAnimationFrame(module.refresh);
                      },
                      resize: function () {
                          module.verbose('Window resized');
                          requestAnimationFrame(module.refresh);
                      },
                      scroll: function () {
                          requestAnimationFrame(function () {
                              $scroll.triggerHandler('scrollchange' + eventNamespace, $scroll.scrollTop());
                          });
                      },
                      scrollchange: function (event, scrollPosition) {
                          module.stick(scrollPosition);
                          settings.onScroll.call(element);
                      }
                  },

                  refresh: function (hardRefresh) {
                      module.reset();
                      if (!settings.context) {
                          module.determineContext();
                      }
                      if (hardRefresh) {
                          module.determineContainer();
                      }
                      module.save.positions();
                      module.stick();
                      settings.onReposition.call(element);
                  },

                  supports: {
                      sticky: function () {
                          var
                            $element = $('<div/>'),
                            element = $element[0]
                          ;
                          $element.addClass(className.supported);
                          return ($element.css('position').match('sticky'));
                      }
                  },

                  save: {
                      lastScroll: function (scroll) {
                          module.lastScroll = scroll;
                      },
                      elementScroll: function (scroll) {
                          module.elementScroll = scroll;
                      },
                      positions: function () {
                          var
                            scrollContext = {
                                height: $scroll.height()
                            },
                            element = {
                                margin: {
                                    top: parseInt($module.css('margin-top'), 10),
                                    bottom: parseInt($module.css('margin-bottom'), 10),
                                },
                                offset: $module.offset(),
                                width: $module.outerWidth(),
                                height: $module.outerHeight()
                            },
                            context = {
                                offset: $context.offset(),
                                height: $context.outerHeight()
                            },
                            container = {
                                height: $container.outerHeight()
                            }
                          ;
                          if (!module.is.standardScroll()) {
                              module.debug('Non-standard scroll. Removing scroll offset from element offset');

                              scrollContext.top = $scroll.scrollTop();
                              scrollContext.left = $scroll.scrollLeft();

                              element.offset.top += scrollContext.top;
                              context.offset.top += scrollContext.top;
                              element.offset.left += scrollContext.left;
                              context.offset.left += scrollContext.left;
                          }
                          module.cache = {
                              fits: (element.height < scrollContext.height),
                              scrollContext: {
                                  height: scrollContext.height
                              },
                              element: {
                                  margin: element.margin,
                                  top: element.offset.top - element.margin.top,
                                  left: element.offset.left,
                                  width: element.width,
                                  height: element.height,
                                  bottom: element.offset.top + element.height
                              },
                              context: {
                                  top: context.offset.top,
                                  height: context.height,
                                  bottom: context.offset.top + context.height
                              }
                          };
                          module.set.containerSize();
                          module.set.size();
                          module.stick();
                          module.debug('Caching element positions', module.cache);
                      }
                  },

                  get: {
                      direction: function (scroll) {
                          var
                            direction = 'down'
                          ;
                          scroll = scroll || $scroll.scrollTop();
                          if (module.lastScroll !== undefined) {
                              if (module.lastScroll < scroll) {
                                  direction = 'down';
                              }
                              else if (module.lastScroll > scroll) {
                                  direction = 'up';
                              }
                          }
                          return direction;
                      },
                      scrollChange: function (scroll) {
                          scroll = scroll || $scroll.scrollTop();
                          return (module.lastScroll)
                            ? (scroll - module.lastScroll)
                            : 0
                          ;
                      },
                      currentElementScroll: function () {
                          if (module.elementScroll) {
                              return module.elementScroll;
                          }
                          return (module.is.top())
                            ? Math.abs(parseInt($module.css('top'), 10)) || 0
                            : Math.abs(parseInt($module.css('bottom'), 10)) || 0
                          ;
                      },

                      elementScroll: function (scroll) {
                          scroll = scroll || $scroll.scrollTop();
                          var
                            element = module.cache.element,
                            scrollContext = module.cache.scrollContext,
                            delta = module.get.scrollChange(scroll),
                            maxScroll = (element.height - scrollContext.height + settings.offset),
                            elementScroll = module.get.currentElementScroll(),
                            possibleScroll = (elementScroll + delta)
                          ;
                          if (module.cache.fits || possibleScroll < 0) {
                              elementScroll = 0;
                          }
                          else if (possibleScroll > maxScroll) {
                              elementScroll = maxScroll;
                          }
                          else {
                              elementScroll = possibleScroll;
                          }
                          return elementScroll;
                      }
                  },

                  remove: {
                      lastScroll: function () {
                          delete module.lastScroll;
                      },
                      elementScroll: function (scroll) {
                          delete module.elementScroll;
                      },
                      offset: function () {
                          $module.css('margin-top', '');
                      }
                  },

                  set: {
                      offset: function () {
                          module.verbose('Setting offset on element', settings.offset);
                          $module
                            .css('margin-top', settings.offset)
                          ;
                      },
                      containerSize: function () {
                          var
                            tagName = $container.get(0).tagName
                          ;
                          if (tagName === 'HTML' || tagName == 'body') {
                              // this can trigger for too many reasons
                              //module.error(error.container, tagName, $module);
                              module.determineContainer();
                          }
                          else {
                              if (Math.abs($container.outerHeight() - module.cache.context.height) > settings.jitter) {
                                  module.debug('Context has padding, specifying exact height for container', module.cache.context.height);
                                  $container.css({
                                      height: module.cache.context.height
                                  });
                              }
                          }
                      },
                      minimumSize: function () {
                          var
                            element = module.cache.element
                          ;
                          $container
                            .css('min-height', element.height)
                          ;
                      },
                      scroll: function (scroll) {
                          module.debug('Setting scroll on element', scroll);
                          if (module.elementScroll == scroll) {
                              return;
                          }
                          if (module.is.top()) {
                              $module
                                .css('bottom', '')
                                .css('top', -scroll)
                              ;
                          }
                          if (module.is.bottom()) {
                              $module
                                .css('top', '')
                                .css('bottom', scroll)
                              ;
                          }
                      },
                      size: function () {
                          if (module.cache.element.height !== 0 && module.cache.element.width !== 0) {
                              element.style.setProperty('width', module.cache.element.width + 'px', 'important');
                              element.style.setProperty('height', module.cache.element.height + 'px', 'important');
                          }
                      }
                  },

                  is: {
                      standardScroll: function () {
                          return ($scroll[0] == window);
                      },
                      top: function () {
                          return $module.hasClass(className.top);
                      },
                      bottom: function () {
                          return $module.hasClass(className.bottom);
                      },
                      initialPosition: function () {
                          return (!module.is.fixed() && !module.is.bound());
                      },
                      hidden: function () {
                          return (!$module.is(':visible'));
                      },
                      bound: function () {
                          return $module.hasClass(className.bound);
                      },
                      fixed: function () {
                          return $module.hasClass(className.fixed);
                      }
                  },

                  stick: function (scroll) {
                      var
                        cachedPosition = scroll || $scroll.scrollTop(),
                        cache = module.cache,
                        fits = cache.fits,
                        element = cache.element,
                        scrollContext = cache.scrollContext,
                        context = cache.context,
                        offset = (module.is.bottom() && settings.pushing)
                          ? settings.bottomOffset
                          : settings.offset,
                        scroll = {
                            top: cachedPosition + offset,
                            bottom: cachedPosition + offset + scrollContext.height
                        },
                        direction = module.get.direction(scroll.top),
                        elementScroll = (fits)
                          ? 0
                          : module.get.elementScroll(scroll.top),

                        // shorthand
                        doesntFit = !fits,
                        elementVisible = (element.height !== 0)
                      ;

                      if (elementVisible) {

                          if (module.is.initialPosition()) {
                              if (scroll.top >= context.bottom) {
                                  module.debug('Initial element position is bottom of container');
                                  module.bindBottom();
                              }
                              else if (scroll.top > element.top) {
                                  if ((element.height + scroll.top - elementScroll) >= context.bottom) {
                                      module.debug('Initial element position is bottom of container');
                                      module.bindBottom();
                                  }
                                  else {
                                      module.debug('Initial element position is fixed');
                                      module.fixTop();
                                  }
                              }

                          }
                          else if (module.is.fixed()) {

                              // currently fixed top
                              if (module.is.top()) {
                                  if (scroll.top <= element.top) {
                                      module.debug('Fixed element reached top of container');
                                      module.setInitialPosition();
                                  }
                                  else if ((element.height + scroll.top - elementScroll) >= context.bottom) {
                                      module.debug('Fixed element reached bottom of container');
                                      module.bindBottom();
                                  }
                                      // scroll element if larger than screen
                                  else if (doesntFit) {
                                      module.set.scroll(elementScroll);
                                      module.save.lastScroll(scroll.top);
                                      module.save.elementScroll(elementScroll);
                                  }
                              }

                                  // currently fixed bottom
                              else if (module.is.bottom()) {

                                  // top edge
                                  if ((scroll.bottom - element.height) <= element.top) {
                                      module.debug('Bottom fixed rail has reached top of container');
                                      module.setInitialPosition();
                                  }
                                      // bottom edge
                                  else if (scroll.bottom >= context.bottom) {
                                      module.debug('Bottom fixed rail has reached bottom of container');
                                      module.bindBottom();
                                  }
                                      // scroll element if larger than screen
                                  else if (doesntFit) {
                                      module.set.scroll(elementScroll);
                                      module.save.lastScroll(scroll.top);
                                      module.save.elementScroll(elementScroll);
                                  }

                              }
                          }
                          else if (module.is.bottom()) {
                              if (scroll.top <= element.top) {
                                  module.debug('Jumped from bottom fixed to top fixed, most likely used home/end button');
                                  module.setInitialPosition();
                              }
                              else {
                                  if (settings.pushing) {
                                      if (module.is.bound() && scroll.bottom <= context.bottom) {
                                          module.debug('Fixing bottom attached element to bottom of browser.');
                                          module.fixBottom();
                                      }
                                  }
                                  else {
                                      if (module.is.bound() && (scroll.top <= context.bottom - element.height)) {
                                          module.debug('Fixing bottom attached element to top of browser.');
                                          module.fixTop();
                                      }
                                  }
                              }
                          }
                      }
                  },

                  bindTop: function () {
                      module.debug('Binding element to top of parent container');
                      module.remove.offset();
                      $module
                        .css({
                            left: '',
                            top: '',
                            marginBottom: ''
                        })
                        .removeClass(className.fixed)
                        .removeClass(className.bottom)
                        .addClass(className.bound)
                        .addClass(className.top)
                      ;
                      settings.onTop.call(element);
                      settings.onUnstick.call(element);
                  },
                  bindBottom: function () {
                      module.debug('Binding element to bottom of parent container');
                      module.remove.offset();
                      $module
                        .css({
                            left: '',
                            top: ''
                        })
                        .removeClass(className.fixed)
                        .removeClass(className.top)
                        .addClass(className.bound)
                        .addClass(className.bottom)
                      ;
                      settings.onBottom.call(element);
                      settings.onUnstick.call(element);
                  },

                  setInitialPosition: function () {
                      module.debug('Returning to initial position');
                      module.unfix();
                      module.unbind();
                  },


                  fixTop: function () {
                      module.debug('Fixing element to top of page');
                      module.set.minimumSize();
                      module.set.offset();
                      $module
                        .css({
                            left: module.cache.element.left,
                            bottom: '',
                            marginBottom: ''
                        })
                        .removeClass(className.bound)
                        .removeClass(className.bottom)
                        .addClass(className.fixed)
                        .addClass(className.top)
                      ;
                      settings.onStick.call(element);
                  },

                  fixBottom: function () {
                      module.debug('Sticking element to bottom of page');
                      module.set.minimumSize();
                      module.set.offset();
                      $module
                        .css({
                            left: module.cache.element.left,
                            bottom: '',
                            marginBottom: ''
                        })
                        .removeClass(className.bound)
                        .removeClass(className.top)
                        .addClass(className.fixed)
                        .addClass(className.bottom)
                      ;
                      settings.onStick.call(element);
                  },

                  unbind: function () {
                      if (module.is.bound()) {
                          module.debug('Removing container bound position on element');
                          module.remove.offset();
                          $module
                            .removeClass(className.bound)
                            .removeClass(className.top)
                            .removeClass(className.bottom)
                          ;
                      }
                  },

                  unfix: function () {
                      if (module.is.fixed()) {
                          module.debug('Removing fixed position on element');
                          module.remove.offset();
                          $module
                            .removeClass(className.fixed)
                            .removeClass(className.top)
                            .removeClass(className.bottom)
                          ;
                          settings.onUnstick.call(element);
                      }
                  },

                  reset: function () {
                      module.debug('Resetting elements position');
                      module.unbind();
                      module.unfix();
                      module.resetCSS();
                      module.remove.offset();
                      module.remove.lastScroll();
                  },

                  resetCSS: function () {
                      $module
                        .css({
                            width: '',
                            height: ''
                        })
                      ;
                      $container
                        .css({
                            height: ''
                        })
                      ;
                  },

                  setting: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          settings[name] = value;
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 0);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.sticky.settings = {

        name: 'Sticky',
        namespace: 'sticky',

        silent: false,
        debug: false,
        verbose: true,
        performance: true,

        // whether to stick in the opposite direction on scroll up
        pushing: false,

        context: false,

        // Context to watch scroll events
        scrollContext: window,

        // Offset to adjust scroll
        offset: 0,

        // Offset to adjust scroll when attached to bottom of screen
        bottomOffset: 0,

        jitter: 5, // will only set container height if difference between context and container is larger than this number

        // Whether to automatically observe changes with Mutation Observers
        observeChanges: false,

        // Called when position is recalculated
        onReposition: function () { },

        // Called on each scroll
        onScroll: function () { },

        // Called when element is stuck to viewport
        onStick: function () { },

        // Called when element is unstuck from viewport
        onUnstick: function () { },

        // Called when element reaches top of context
        onTop: function () { },

        // Called when element reaches bottom of context
        onBottom: function () { },

        error: {
            container: 'Sticky element must be inside a relative container',
            visible: 'Element is hidden, you must call refresh after element becomes visible. Use silent setting to surpress this warning in production.',
            method: 'The method you called is not defined.',
            invalidContext: 'Context specified does not exist',
            elementSize: 'Sticky element is larger than its container, cannot create sticky.'
        },

        className: {
            bound: 'bound',
            fixed: 'fixed',
            supported: 'native',
            top: 'top',
            bottom: 'bottom'
        }

    };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Tab
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.tab = function (parameters) {

        var
          // use window context if none specified
          $allModules = $.isFunction(this)
              ? $(window)
              : $(this),

          moduleSelector = $allModules.selector || '',
          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          initializedHistory = false,
          returnedValue
        ;

        $allModules
          .each(function () {
              var

                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.tab.settings, parameters)
                  : $.extend({}, $.fn.tab.settings),

                className = settings.className,
                metadata = settings.metadata,
                selector = settings.selector,
                error = settings.error,

                eventNamespace = '.' + settings.namespace,
                moduleNamespace = 'module-' + settings.namespace,

                $module = $(this),
                $context,
                $tabs,

                cache = {},
                firstLoad = true,
                recursionDepth = 0,
                element = this,
                instance = $module.data(moduleNamespace),

                activeTabPath,
                parameterArray,
                module,

                historyEvent

              ;

              module = {

                  initialize: function () {
                      module.debug('Initializing tab menu item', $module);
                      module.fix.callbacks();
                      module.determineTabs();

                      module.debug('Determining tabs', settings.context, $tabs);
                      // set up automatic routing
                      if (settings.auto) {
                          module.set.auto();
                      }
                      module.bind.events();

                      if (settings.history && !initializedHistory) {
                          module.initializeHistory();
                          initializedHistory = true;
                      }

                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },

                  destroy: function () {
                      module.debug('Destroying tabs', $module);
                      $module
                        .removeData(moduleNamespace)
                        .off(eventNamespace)
                      ;
                  },

                  bind: {
                      events: function () {
                          // if using $.tab don't add events
                          if (!$.isWindow(element)) {
                              module.debug('Attaching tab activation events to element', $module);
                              $module
                                .on('click' + eventNamespace, module.event.click)
                              ;
                          }
                      }
                  },

                  determineTabs: function () {
                      var
                        $reference
                      ;

                      // determine tab context
                      if (settings.context === 'parent') {
                          if ($module.closest(selector.ui).length > 0) {
                              $reference = $module.closest(selector.ui);
                              module.verbose('Using closest UI element as parent', $reference);
                          }
                          else {
                              $reference = $module;
                          }
                          $context = $reference.parent();
                          module.verbose('Determined parent element for creating context', $context);
                      }
                      else if (settings.context) {
                          $context = $(settings.context);
                          module.verbose('Using selector for tab context', settings.context, $context);
                      }
                      else {
                          $context = $('body');
                      }
                      // find tabs
                      if (settings.childrenOnly) {
                          $tabs = $context.children(selector.tabs);
                          module.debug('Searching tab context children for tabs', $context, $tabs);
                      }
                      else {
                          $tabs = $context.find(selector.tabs);
                          module.debug('Searching tab context for tabs', $context, $tabs);
                      }
                  },

                  fix: {
                      callbacks: function () {
                          if ($.isPlainObject(parameters) && (parameters.onTabLoad || parameters.onTabInit)) {
                              if (parameters.onTabLoad) {
                                  parameters.onLoad = parameters.onTabLoad;
                                  delete parameters.onTabLoad;
                                  module.error(error.legacyLoad, parameters.onLoad);
                              }
                              if (parameters.onTabInit) {
                                  parameters.onFirstLoad = parameters.onTabInit;
                                  delete parameters.onTabInit;
                                  module.error(error.legacyInit, parameters.onFirstLoad);
                              }
                              settings = $.extend(true, {}, $.fn.tab.settings, parameters);
                          }
                      }
                  },

                  initializeHistory: function () {
                      module.debug('Initializing page state');
                      if ($.address === undefined) {
                          module.error(error.state);
                          return false;
                      }
                      else {
                          if (settings.historyType == 'state') {
                              module.debug('Using HTML5 to manage state');
                              if (settings.path !== false) {
                                  $.address
                                    .history(true)
                                    .state(settings.path)
                                  ;
                              }
                              else {
                                  module.error(error.path);
                                  return false;
                              }
                          }
                          $.address
                            .bind('change', module.event.history.change)
                          ;
                      }
                  },

                  event: {
                      click: function (event) {
                          var
                            tabPath = $(this).data(metadata.tab)
                          ;
                          if (tabPath !== undefined) {
                              if (settings.history) {
                                  module.verbose('Updating page state', event);
                                  $.address.value(tabPath);
                              }
                              else {
                                  module.verbose('Changing tab', event);
                                  module.changeTab(tabPath);
                              }
                              event.preventDefault();
                          }
                          else {
                              module.debug('No tab specified');
                          }
                      },
                      history: {
                          change: function (event) {
                              var
                                tabPath = event.pathNames.join('/') || module.get.initialPath(),
                                pageTitle = settings.templates.determineTitle(tabPath) || false
                              ;
                              module.performance.display();
                              module.debug('History change event', tabPath, event);
                              historyEvent = event;
                              if (tabPath !== undefined) {
                                  module.changeTab(tabPath);
                              }
                              if (pageTitle) {
                                  $.address.title(pageTitle);
                              }
                          }
                      }
                  },

                  refresh: function () {
                      if (activeTabPath) {
                          module.debug('Refreshing tab', activeTabPath);
                          module.changeTab(activeTabPath);
                      }
                  },

                  cache: {

                      read: function (cacheKey) {
                          return (cacheKey !== undefined)
                            ? cache[cacheKey]
                            : false
                          ;
                      },
                      add: function (cacheKey, content) {
                          cacheKey = cacheKey || activeTabPath;
                          module.debug('Adding cached content for', cacheKey);
                          cache[cacheKey] = content;
                      },
                      remove: function (cacheKey) {
                          cacheKey = cacheKey || activeTabPath;
                          module.debug('Removing cached content for', cacheKey);
                          delete cache[cacheKey];
                      }
                  },

                  set: {
                      auto: function () {
                          var
                            url = (typeof settings.path == 'string')
                              ? settings.path.replace(/\/$/, '') + '/{$tab}'
                              : '/{$tab}'
                          ;
                          module.verbose('Setting up automatic tab retrieval from server', url);
                          if ($.isPlainObject(settings.apiSettings)) {
                              settings.apiSettings.url = url;
                          }
                          else {
                              settings.apiSettings = {
                                  url: url
                              };
                          }
                      },
                      loading: function (tabPath) {
                          var
                            $tab = module.get.tabElement(tabPath),
                            isLoading = $tab.hasClass(className.loading)
                          ;
                          if (!isLoading) {
                              module.verbose('Setting loading state for', $tab);
                              $tab
                                .addClass(className.loading)
                                .siblings($tabs)
                                  .removeClass(className.active + ' ' + className.loading)
                              ;
                              if ($tab.length > 0) {
                                  settings.onRequest.call($tab[0], tabPath);
                              }
                          }
                      },
                      state: function (state) {
                          $.address.value(state);
                      }
                  },

                  changeTab: function (tabPath) {
                      var
                        pushStateAvailable = (window.history && window.history.pushState),
                        shouldIgnoreLoad = (pushStateAvailable && settings.ignoreFirstLoad && firstLoad),
                        remoteContent = (settings.auto || $.isPlainObject(settings.apiSettings)),
                        // only add default path if not remote content
                        pathArray = (remoteContent && !shouldIgnoreLoad)
                          ? module.utilities.pathToArray(tabPath)
                          : module.get.defaultPathArray(tabPath)
                      ;
                      tabPath = module.utilities.arrayToPath(pathArray);
                      $.each(pathArray, function (index, tab) {
                          var
                            currentPathArray = pathArray.slice(0, index + 1),
                            currentPath = module.utilities.arrayToPath(currentPathArray),

                            isTab = module.is.tab(currentPath),
                            isLastIndex = (index + 1 == pathArray.length),

                            $tab = module.get.tabElement(currentPath),
                            $anchor,
                            nextPathArray,
                            nextPath,
                            isLastTab
                          ;
                          module.verbose('Looking for tab', tab);
                          if (isTab) {
                              module.verbose('Tab was found', tab);
                              // scope up
                              activeTabPath = currentPath;
                              parameterArray = module.utilities.filterArray(pathArray, currentPathArray);

                              if (isLastIndex) {
                                  isLastTab = true;
                              }
                              else {
                                  nextPathArray = pathArray.slice(0, index + 2);
                                  nextPath = module.utilities.arrayToPath(nextPathArray);
                                  isLastTab = (!module.is.tab(nextPath));
                                  if (isLastTab) {
                                      module.verbose('Tab parameters found', nextPathArray);
                                  }
                              }
                              if (isLastTab && remoteContent) {
                                  if (!shouldIgnoreLoad) {
                                      module.activate.navigation(currentPath);
                                      module.fetch.content(currentPath, tabPath);
                                  }
                                  else {
                                      module.debug('Ignoring remote content on first tab load', currentPath);
                                      firstLoad = false;
                                      module.cache.add(tabPath, $tab.html());
                                      module.activate.all(currentPath);
                                      settings.onFirstLoad.call($tab[0], currentPath, parameterArray, historyEvent);
                                      settings.onLoad.call($tab[0], currentPath, parameterArray, historyEvent);
                                  }
                                  return false;
                              }
                              else {
                                  module.debug('Opened local tab', currentPath);
                                  module.activate.all(currentPath);
                                  if (!module.cache.read(currentPath)) {
                                      module.cache.add(currentPath, true);
                                      module.debug('First time tab loaded calling tab init');
                                      settings.onFirstLoad.call($tab[0], currentPath, parameterArray, historyEvent);
                                  }
                                  settings.onLoad.call($tab[0], currentPath, parameterArray, historyEvent);
                              }

                          }
                          else if (tabPath.search('/') == -1 && tabPath !== '') {
                              // look for in page anchor
                              $anchor = $('#' + tabPath + ', a[name="' + tabPath + '"]');
                              currentPath = $anchor.closest('[data-tab]').data(metadata.tab);
                              $tab = module.get.tabElement(currentPath);
                              // if anchor exists use parent tab
                              if ($anchor && $anchor.length > 0 && currentPath) {
                                  module.debug('Anchor link used, opening parent tab', $tab, $anchor);
                                  if (!$tab.hasClass(className.active)) {
                                      setTimeout(function () {
                                          module.scrollTo($anchor);
                                      }, 0);
                                  }
                                  module.activate.all(currentPath);
                                  if (!module.cache.read(currentPath)) {
                                      module.cache.add(currentPath, true);
                                      module.debug('First time tab loaded calling tab init');
                                      settings.onFirstLoad.call($tab[0], currentPath, parameterArray, historyEvent);
                                  }
                                  settings.onLoad.call($tab[0], currentPath, parameterArray, historyEvent);
                                  return false;
                              }
                          }
                          else {
                              module.error(error.missingTab, $module, $context, currentPath);
                              return false;
                          }
                      });
                  },

                  scrollTo: function ($element) {
                      var
                        scrollOffset = ($element && $element.length > 0)
                          ? $element.offset().top
                          : false
                      ;
                      if (scrollOffset !== false) {
                          module.debug('Forcing scroll to an in-page link in a hidden tab', scrollOffset, $element);
                          $(document).scrollTop(scrollOffset);
                      }
                  },

                  update: {
                      content: function (tabPath, html, evaluateScripts) {
                          var
                            $tab = module.get.tabElement(tabPath),
                            tab = $tab[0]
                          ;
                          evaluateScripts = (evaluateScripts !== undefined)
                            ? evaluateScripts
                            : settings.evaluateScripts
                          ;
                          if (evaluateScripts) {
                              module.debug('Updating HTML and evaluating inline scripts', tabPath, html);
                              $tab.html(html);
                          }
                          else {
                              module.debug('Updating HTML', tabPath, html);
                              tab.innerHTML = html;
                          }
                      }
                  },

                  fetch: {

                      content: function (tabPath, fullTabPath) {
                          var
                            $tab = module.get.tabElement(tabPath),
                            apiSettings = {
                                dataType: 'html',
                                encodeParameters: false,
                                on: 'now',
                                cache: settings.alwaysRefresh,
                                headers: {
                                    'X-Remote': true
                                },
                                onSuccess: function (response) {
                                    if (settings.cacheType == 'response') {
                                        module.cache.add(fullTabPath, response);
                                    }
                                    module.update.content(tabPath, response);
                                    if (tabPath == activeTabPath) {
                                        module.debug('Content loaded', tabPath);
                                        module.activate.tab(tabPath);
                                    }
                                    else {
                                        module.debug('Content loaded in background', tabPath);
                                    }
                                    settings.onFirstLoad.call($tab[0], tabPath, parameterArray, historyEvent);
                                    settings.onLoad.call($tab[0], tabPath, parameterArray, historyEvent);
                                    if (settings.cacheType != 'response') {
                                        module.cache.add(fullTabPath, $tab.html());
                                    }
                                },
                                urlData: {
                                    tab: fullTabPath
                                }
                            },
                            request = $tab.api('get request') || false,
                            existingRequest = (request && request.state() === 'pending'),
                            requestSettings,
                            cachedContent
                          ;

                          fullTabPath = fullTabPath || tabPath;
                          cachedContent = module.cache.read(fullTabPath);


                          if (settings.cache && cachedContent) {
                              module.activate.tab(tabPath);
                              module.debug('Adding cached content', fullTabPath);
                              if (settings.evaluateScripts == 'once') {
                                  module.update.content(tabPath, cachedContent, false);
                              }
                              else {
                                  module.update.content(tabPath, cachedContent);
                              }
                              settings.onLoad.call($tab[0], tabPath, parameterArray, historyEvent);
                          }
                          else if (existingRequest) {
                              module.set.loading(tabPath);
                              module.debug('Content is already loading', fullTabPath);
                          }
                          else if ($.api !== undefined) {
                              requestSettings = $.extend(true, {}, settings.apiSettings, apiSettings);
                              module.debug('Retrieving remote content', fullTabPath, requestSettings);
                              module.set.loading(tabPath);
                              $tab.api(requestSettings);
                          }
                          else {
                              module.error(error.api);
                          }
                      }
                  },

                  activate: {
                      all: function (tabPath) {
                          module.activate.tab(tabPath);
                          module.activate.navigation(tabPath);
                      },
                      tab: function (tabPath) {
                          var
                            $tab = module.get.tabElement(tabPath),
                            $deactiveTabs = (settings.deactivate == 'siblings')
                              ? $tab.siblings($tabs)
                              : $tabs.not($tab),
                            isActive = $tab.hasClass(className.active)
                          ;
                          module.verbose('Showing tab content for', $tab);
                          if (!isActive) {
                              $tab
                                .addClass(className.active)
                              ;
                              $deactiveTabs
                                .removeClass(className.active + ' ' + className.loading)
                              ;
                              if ($tab.length > 0) {
                                  settings.onVisible.call($tab[0], tabPath);
                              }
                          }
                      },
                      navigation: function (tabPath) {
                          var
                            $navigation = module.get.navElement(tabPath),
                            $deactiveNavigation = (settings.deactivate == 'siblings')
                              ? $navigation.siblings($allModules)
                              : $allModules.not($navigation),
                            isActive = $navigation.hasClass(className.active)
                          ;
                          module.verbose('Activating tab navigation for', $navigation, tabPath);
                          if (!isActive) {
                              $navigation
                                .addClass(className.active)
                              ;
                              $deactiveNavigation
                                .removeClass(className.active + ' ' + className.loading)
                              ;
                          }
                      }
                  },

                  deactivate: {
                      all: function () {
                          module.deactivate.navigation();
                          module.deactivate.tabs();
                      },
                      navigation: function () {
                          $allModules
                            .removeClass(className.active)
                          ;
                      },
                      tabs: function () {
                          $tabs
                            .removeClass(className.active + ' ' + className.loading)
                          ;
                      }
                  },

                  is: {
                      tab: function (tabName) {
                          return (tabName !== undefined)
                            ? (module.get.tabElement(tabName).length > 0)
                            : false
                          ;
                      }
                  },

                  get: {
                      initialPath: function () {
                          return $allModules.eq(0).data(metadata.tab) || $tabs.eq(0).data(metadata.tab);
                      },
                      path: function () {
                          return $.address.value();
                      },
                      // adds default tabs to tab path
                      defaultPathArray: function (tabPath) {
                          return module.utilities.pathToArray(module.get.defaultPath(tabPath));
                      },
                      defaultPath: function (tabPath) {
                          var
                            $defaultNav = $allModules.filter('[data-' + metadata.tab + '^="' + tabPath + '/"]').eq(0),
                            defaultTab = $defaultNav.data(metadata.tab) || false
                          ;
                          if (defaultTab) {
                              module.debug('Found default tab', defaultTab);
                              if (recursionDepth < settings.maxDepth) {
                                  recursionDepth++;
                                  return module.get.defaultPath(defaultTab);
                              }
                              module.error(error.recursion);
                          }
                          else {
                              module.debug('No default tabs found for', tabPath, $tabs);
                          }
                          recursionDepth = 0;
                          return tabPath;
                      },
                      navElement: function (tabPath) {
                          tabPath = tabPath || activeTabPath;
                          return $allModules.filter('[data-' + metadata.tab + '="' + tabPath + '"]');
                      },
                      tabElement: function (tabPath) {
                          var
                            $fullPathTab,
                            $simplePathTab,
                            tabPathArray,
                            lastTab
                          ;
                          tabPath = tabPath || activeTabPath;
                          tabPathArray = module.utilities.pathToArray(tabPath);
                          lastTab = module.utilities.last(tabPathArray);
                          $fullPathTab = $tabs.filter('[data-' + metadata.tab + '="' + tabPath + '"]');
                          $simplePathTab = $tabs.filter('[data-' + metadata.tab + '="' + lastTab + '"]');
                          return ($fullPathTab.length > 0)
                            ? $fullPathTab
                            : $simplePathTab
                          ;
                      },
                      tab: function () {
                          return activeTabPath;
                      }
                  },

                  utilities: {
                      filterArray: function (keepArray, removeArray) {
                          return $.grep(keepArray, function (keepValue) {
                              return ($.inArray(keepValue, removeArray) == -1);
                          });
                      },
                      last: function (array) {
                          return $.isArray(array)
                            ? array[array.length - 1]
                            : false
                          ;
                      },
                      pathToArray: function (pathName) {
                          if (pathName === undefined) {
                              pathName = activeTabPath;
                          }
                          return typeof pathName == 'string'
                            ? pathName.split('/')
                            : [pathName]
                          ;
                      },
                      arrayToPath: function (pathArray) {
                          return $.isArray(pathArray)
                            ? pathArray.join('/')
                            : false
                          ;
                      }
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };
              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;
        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;

    };

    // shortcut for tabbed content with no defined navigation
    $.tab = function () {
        $(window).tab.apply(this, arguments);
    };

    $.fn.tab.settings = {

        name: 'Tab',
        namespace: 'tab',

        silent: false,
        debug: false,
        verbose: false,
        performance: true,

        auto: false,      // uses pjax style endpoints fetching content from same url with remote-content headers
        history: false,      // use browser history
        historyType: 'hash',     // #/ or html5 state
        path: false,      // base path of url

        context: false,      // specify a context that tabs must appear inside
        childrenOnly: false,      // use only tabs that are children of context
        maxDepth: 25,         // max depth a tab can be nested

        deactivate: 'siblings', // whether tabs should deactivate sibling menu elements or all elements initialized together

        alwaysRefresh: false,      // load tab content new every tab click
        cache: true,       // cache the content requests to pull locally
        cacheType: 'response', // Whether to cache exact response, or to html cache contents after scripts execute
        ignoreFirstLoad: false,      // don't load remote content on first load

        apiSettings: false,      // settings for api call
        evaluateScripts: 'once',     // whether inline scripts should be parsed (true/false/once). Once will not re-evaluate on cached content

        onFirstLoad: function (tabPath, parameterArray, historyEvent) { }, // called first time loaded
        onLoad: function (tabPath, parameterArray, historyEvent) { }, // called on every load
        onVisible: function (tabPath, parameterArray, historyEvent) { }, // called every time tab visible
        onRequest: function (tabPath, parameterArray, historyEvent) { }, // called ever time a tab beings loading remote content

        templates: {
            determineTitle: function (tabArray) { } // returns page title for path
        },

        error: {
            api: 'You attempted to load content without API module',
            method: 'The method you called is not defined',
            missingTab: 'Activated tab cannot be found. Tabs are case-sensitive.',
            noContent: 'The tab you specified is missing a content url.',
            path: 'History enabled, but no path was specified',
            recursion: 'Max recursive depth reached',
            legacyInit: 'onTabInit has been renamed to onFirstLoad in 2.0, please adjust your code.',
            legacyLoad: 'onTabLoad has been renamed to onLoad in 2.0. Please adjust your code',
            state: 'History requires Asual\'s Address library <https://github.com/asual/jquery-address>'
        },

        metadata: {
            tab: 'tab',
            loaded: 'loaded',
            promise: 'promise'
        },

        className: {
            loading: 'loading',
            active: 'active'
        },

        selector: {
            tabs: '.ui.tab',
            ui: '.ui'
        }

    };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Transition
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.transition = function () {
        var
          $allModules = $(this),
          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          moduleArguments = arguments,
          query = moduleArguments[0],
          queryArguments = [].slice.call(arguments, 1),
          methodInvoked = (typeof query === 'string'),

          requestAnimationFrame = window.requestAnimationFrame
            || window.mozRequestAnimationFrame
            || window.webkitRequestAnimationFrame
            || window.msRequestAnimationFrame
            || function (callback) { setTimeout(callback, 0); },

          returnedValue
        ;
        $allModules
          .each(function (index) {
              var
                $module = $(this),
                element = this,

                // set at run time
                settings,
                instance,

                error,
                className,
                metadata,
                animationEnd,
                animationName,

                namespace,
                moduleNamespace,
                eventNamespace,
                module
              ;

              module = {

                  initialize: function () {

                      // get full settings
                      settings = module.get.settings.apply(element, moduleArguments);

                      // shorthand
                      className = settings.className;
                      error = settings.error;
                      metadata = settings.metadata;

                      // define namespace
                      eventNamespace = '.' + settings.namespace;
                      moduleNamespace = 'module-' + settings.namespace;
                      instance = $module.data(moduleNamespace) || module;

                      // get vendor specific events
                      animationEnd = module.get.animationEndEvent();

                      if (methodInvoked) {
                          methodInvoked = module.invoke(query);
                      }

                      // method not invoked, lets run an animation
                      if (methodInvoked === false) {
                          module.verbose('Converted arguments into settings object', settings);
                          if (settings.interval) {
                              module.delay(settings.animate);
                          }
                          else {
                              module.animate();
                          }
                          module.instantiate();
                      }
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, instance)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous module for', element);
                      $module
                        .removeData(moduleNamespace)
                      ;
                  },

                  refresh: function () {
                      module.verbose('Refreshing display type on next animation');
                      delete module.displayType;
                  },

                  forceRepaint: function () {
                      module.verbose('Forcing element repaint');
                      var
                        $parentElement = $module.parent(),
                        $nextElement = $module.next()
                      ;
                      if ($nextElement.length === 0) {
                          $module.detach().appendTo($parentElement);
                      }
                      else {
                          $module.detach().insertBefore($nextElement);
                      }
                  },

                  repaint: function () {
                      module.verbose('Repainting element');
                      var
                        fakeAssignment = element.offsetWidth
                      ;
                  },

                  delay: function (interval) {
                      var
                        direction = module.get.animationDirection(),
                        shouldReverse,
                        delay
                      ;
                      if (!direction) {
                          direction = module.can.transition()
                            ? module.get.direction()
                            : 'static'
                          ;
                      }
                      interval = (interval !== undefined)
                        ? interval
                        : settings.interval
                      ;
                      shouldReverse = (settings.reverse == 'auto' && direction == className.outward);
                      delay = (shouldReverse || settings.reverse == true)
                        ? ($allModules.length - index) * settings.interval
                        : index * settings.interval
                      ;
                      module.debug('Delaying animation by', delay);
                      setTimeout(module.animate, delay);
                  },

                  animate: function (overrideSettings) {
                      settings = overrideSettings || settings;
                      if (!module.is.supported()) {
                          module.error(error.support);
                          return false;
                      }
                      module.debug('Preparing animation', settings.animation);
                      if (module.is.animating()) {
                          if (settings.queue) {
                              if (!settings.allowRepeats && module.has.direction() && module.is.occurring() && module.queuing !== true) {
                                  module.debug('Animation is currently occurring, preventing queueing same animation', settings.animation);
                              }
                              else {
                                  module.queue(settings.animation);
                              }
                              return false;
                          }
                          else if (!settings.allowRepeats && module.is.occurring()) {
                              module.debug('Animation is already occurring, will not execute repeated animation', settings.animation);
                              return false;
                          }
                          else {
                              module.debug('New animation started, completing previous early', settings.animation);
                              instance.complete();
                          }
                      }
                      if (module.can.animate()) {
                          module.set.animating(settings.animation);
                      }
                      else {
                          module.error(error.noAnimation, settings.animation, element);
                      }
                  },

                  reset: function () {
                      module.debug('Resetting animation to beginning conditions');
                      module.remove.animationCallbacks();
                      module.restore.conditions();
                      module.remove.animating();
                  },

                  queue: function (animation) {
                      module.debug('Queueing animation of', animation);
                      module.queuing = true;
                      $module
                        .one(animationEnd + '.queue' + eventNamespace, function () {
                            module.queuing = false;
                            module.repaint();
                            module.animate.apply(this, settings);
                        })
                      ;
                  },

                  complete: function (event) {
                      module.debug('Animation complete', settings.animation);
                      module.remove.completeCallback();
                      module.remove.failSafe();
                      if (!module.is.looping()) {
                          if (module.is.outward()) {
                              module.verbose('Animation is outward, hiding element');
                              module.restore.conditions();
                              module.hide();
                          }
                          else if (module.is.inward()) {
                              module.verbose('Animation is outward, showing element');
                              module.restore.conditions();
                              module.show();
                          }
                          else {
                              module.verbose('Static animation completed');
                              module.restore.conditions();
                              settings.onComplete.call(element);
                          }
                      }
                  },

                  force: {
                      visible: function () {
                          var
                            style = $module.attr('style'),
                            userStyle = module.get.userStyle(),
                            displayType = module.get.displayType(),
                            overrideStyle = userStyle + 'display: ' + displayType + ' !important;',
                            currentDisplay = $module.css('display'),
                            emptyStyle = (style === undefined || style === '')
                          ;
                          if (currentDisplay !== displayType) {
                              module.verbose('Overriding default display to show element', displayType);
                              $module
                                .attr('style', overrideStyle)
                              ;
                          }
                          else if (emptyStyle) {
                              $module.removeAttr('style');
                          }
                      },
                      hidden: function () {
                          var
                            style = $module.attr('style'),
                            currentDisplay = $module.css('display'),
                            emptyStyle = (style === undefined || style === '')
                          ;
                          if (currentDisplay !== 'none' && !module.is.hidden()) {
                              module.verbose('Overriding default display to hide element');
                              $module
                                .css('display', 'none')
                              ;
                          }
                          else if (emptyStyle) {
                              $module
                                .removeAttr('style')
                              ;
                          }
                      }
                  },

                  has: {
                      direction: function (animation) {
                          var
                            hasDirection = false
                          ;
                          animation = animation || settings.animation;
                          if (typeof animation === 'string') {
                              animation = animation.split(' ');
                              $.each(animation, function (index, word) {
                                  if (word === className.inward || word === className.outward) {
                                      hasDirection = true;
                                  }
                              });
                          }
                          return hasDirection;
                      },
                      inlineDisplay: function () {
                          var
                            style = $module.attr('style') || ''
                          ;
                          return $.isArray(style.match(/display.*?;/, ''));
                      }
                  },

                  set: {
                      animating: function (animation) {
                          var
                            animationClass,
                            direction
                          ;
                          // remove previous callbacks
                          module.remove.completeCallback();

                          // determine exact animation
                          animation = animation || settings.animation;
                          animationClass = module.get.animationClass(animation);

                          // save animation class in cache to restore class names
                          module.save.animation(animationClass);

                          // override display if necessary so animation appears visibly
                          module.force.visible();

                          module.remove.hidden();
                          module.remove.direction();

                          module.start.animation(animationClass);

                      },
                      duration: function (animationName, duration) {
                          duration = duration || settings.duration;
                          duration = (typeof duration == 'number')
                            ? duration + 'ms'
                            : duration
                          ;
                          if (duration || duration === 0) {
                              module.verbose('Setting animation duration', duration);
                              $module
                                .css({
                                    'animation-duration': duration
                                })
                              ;
                          }
                      },
                      direction: function (direction) {
                          direction = direction || module.get.direction();
                          if (direction == className.inward) {
                              module.set.inward();
                          }
                          else {
                              module.set.outward();
                          }
                      },
                      looping: function () {
                          module.debug('Transition set to loop');
                          $module
                            .addClass(className.looping)
                          ;
                      },
                      hidden: function () {
                          $module
                            .addClass(className.transition)
                            .addClass(className.hidden)
                          ;
                      },
                      inward: function () {
                          module.debug('Setting direction to inward');
                          $module
                            .removeClass(className.outward)
                            .addClass(className.inward)
                          ;
                      },
                      outward: function () {
                          module.debug('Setting direction to outward');
                          $module
                            .removeClass(className.inward)
                            .addClass(className.outward)
                          ;
                      },
                      visible: function () {
                          $module
                            .addClass(className.transition)
                            .addClass(className.visible)
                          ;
                      }
                  },

                  start: {
                      animation: function (animationClass) {
                          animationClass = animationClass || module.get.animationClass();
                          module.debug('Starting tween', animationClass);
                          $module
                            .addClass(animationClass)
                            .one(animationEnd + '.complete' + eventNamespace, module.complete)
                          ;
                          if (settings.useFailSafe) {
                              module.add.failSafe();
                          }
                          module.set.duration(settings.duration);
                          settings.onStart.call(element);
                      }
                  },

                  save: {
                      animation: function (animation) {
                          if (!module.cache) {
                              module.cache = {};
                          }
                          module.cache.animation = animation;
                      },
                      displayType: function (displayType) {
                          if (displayType !== 'none') {
                              $module.data(metadata.displayType, displayType);
                          }
                      },
                      transitionExists: function (animation, exists) {
                          $.fn.transition.exists[animation] = exists;
                          module.verbose('Saving existence of transition', animation, exists);
                      }
                  },

                  restore: {
                      conditions: function () {
                          var
                            animation = module.get.currentAnimation()
                          ;
                          if (animation) {
                              $module
                                .removeClass(animation)
                              ;
                              module.verbose('Removing animation class', module.cache);
                          }
                          module.remove.duration();
                      }
                  },

                  add: {
                      failSafe: function () {
                          var
                            duration = module.get.duration()
                          ;
                          module.timer = setTimeout(function () {
                              $module.triggerHandler(animationEnd);
                          }, duration + settings.failSafeDelay);
                          module.verbose('Adding fail safe timer', module.timer);
                      }
                  },

                  remove: {
                      animating: function () {
                          $module.removeClass(className.animating);
                      },
                      animationCallbacks: function () {
                          module.remove.queueCallback();
                          module.remove.completeCallback();
                      },
                      queueCallback: function () {
                          $module.off('.queue' + eventNamespace);
                      },
                      completeCallback: function () {
                          $module.off('.complete' + eventNamespace);
                      },
                      display: function () {
                          $module.css('display', '');
                      },
                      direction: function () {
                          $module
                            .removeClass(className.inward)
                            .removeClass(className.outward)
                          ;
                      },
                      duration: function () {
                          $module
                            .css('animation-duration', '')
                          ;
                      },
                      failSafe: function () {
                          module.verbose('Removing fail safe timer', module.timer);
                          if (module.timer) {
                              clearTimeout(module.timer);
                          }
                      },
                      hidden: function () {
                          $module.removeClass(className.hidden);
                      },
                      visible: function () {
                          $module.removeClass(className.visible);
                      },
                      looping: function () {
                          module.debug('Transitions are no longer looping');
                          if (module.is.looping()) {
                              module.reset();
                              $module
                                .removeClass(className.looping)
                              ;
                          }
                      },
                      transition: function () {
                          $module
                            .removeClass(className.visible)
                            .removeClass(className.hidden)
                          ;
                      }
                  },
                  get: {
                      settings: function (animation, duration, onComplete) {
                          // single settings object
                          if (typeof animation == 'object') {
                              return $.extend(true, {}, $.fn.transition.settings, animation);
                          }
                              // all arguments provided
                          else if (typeof onComplete == 'function') {
                              return $.extend({}, $.fn.transition.settings, {
                                  animation: animation,
                                  onComplete: onComplete,
                                  duration: duration
                              });
                          }
                              // only duration provided
                          else if (typeof duration == 'string' || typeof duration == 'number') {
                              return $.extend({}, $.fn.transition.settings, {
                                  animation: animation,
                                  duration: duration
                              });
                          }
                              // duration is actually settings object
                          else if (typeof duration == 'object') {
                              return $.extend({}, $.fn.transition.settings, duration, {
                                  animation: animation
                              });
                          }
                              // duration is actually callback
                          else if (typeof duration == 'function') {
                              return $.extend({}, $.fn.transition.settings, {
                                  animation: animation,
                                  onComplete: duration
                              });
                          }
                              // only animation provided
                          else {
                              return $.extend({}, $.fn.transition.settings, {
                                  animation: animation
                              });
                          }
                          return $.fn.transition.settings;
                      },
                      animationClass: function (animation) {
                          var
                            animationClass = animation || settings.animation,
                            directionClass = (module.can.transition() && !module.has.direction())
                              ? module.get.direction() + ' '
                              : ''
                          ;
                          return className.animating + ' '
                            + className.transition + ' '
                            + directionClass
                            + animationClass
                          ;
                      },
                      currentAnimation: function () {
                          return (module.cache && module.cache.animation !== undefined)
                            ? module.cache.animation
                            : false
                          ;
                      },
                      currentDirection: function () {
                          return module.is.inward()
                            ? className.inward
                            : className.outward
                          ;
                      },
                      direction: function () {
                          return module.is.hidden() || !module.is.visible()
                            ? className.inward
                            : className.outward
                          ;
                      },
                      animationDirection: function (animation) {
                          var
                            direction
                          ;
                          animation = animation || settings.animation;
                          if (typeof animation === 'string') {
                              animation = animation.split(' ');
                              // search animation name for out/in class
                              $.each(animation, function (index, word) {
                                  if (word === className.inward) {
                                      direction = className.inward;
                                  }
                                  else if (word === className.outward) {
                                      direction = className.outward;
                                  }
                              });
                          }
                          // return found direction
                          if (direction) {
                              return direction;
                          }
                          return false;
                      },
                      duration: function (duration) {
                          duration = duration || settings.duration;
                          if (duration === false) {
                              duration = $module.css('animation-duration') || 0;
                          }
                          return (typeof duration === 'string')
                            ? (duration.indexOf('ms') > -1)
                              ? parseFloat(duration)
                              : parseFloat(duration) * 1000
                            : duration
                          ;
                      },
                      displayType: function () {
                          if (settings.displayType) {
                              return settings.displayType;
                          }
                          if ($module.data(metadata.displayType) === undefined) {
                              // create fake element to determine display state
                              module.can.transition(true);
                          }
                          return $module.data(metadata.displayType);
                      },
                      userStyle: function (style) {
                          style = style || $module.attr('style') || '';
                          return style.replace(/display.*?;/, '');
                      },
                      transitionExists: function (animation) {
                          return $.fn.transition.exists[animation];
                      },
                      animationStartEvent: function () {
                          var
                            element = document.createElement('div'),
                            animations = {
                                'animation': 'animationstart',
                                'OAnimation': 'oAnimationStart',
                                'MozAnimation': 'mozAnimationStart',
                                'WebkitAnimation': 'webkitAnimationStart'
                            },
                            animation
                          ;
                          for (animation in animations) {
                              if (element.style[animation] !== undefined) {
                                  return animations[animation];
                              }
                          }
                          return false;
                      },
                      animationEndEvent: function () {
                          var
                            element = document.createElement('div'),
                            animations = {
                                'animation': 'animationend',
                                'OAnimation': 'oAnimationEnd',
                                'MozAnimation': 'mozAnimationEnd',
                                'WebkitAnimation': 'webkitAnimationEnd'
                            },
                            animation
                          ;
                          for (animation in animations) {
                              if (element.style[animation] !== undefined) {
                                  return animations[animation];
                              }
                          }
                          return false;
                      }

                  },

                  can: {
                      transition: function (forced) {
                          var
                            animation = settings.animation,
                            transitionExists = module.get.transitionExists(animation),
                            elementClass,
                            tagName,
                            $clone,
                            currentAnimation,
                            inAnimation,
                            directionExists,
                            displayType
                          ;
                          if (transitionExists === undefined || forced) {
                              module.verbose('Determining whether animation exists');
                              elementClass = $module.attr('class');
                              tagName = $module.prop('tagName');

                              $clone = $('<' + tagName + ' />').addClass(elementClass).insertAfter($module);
                              currentAnimation = $clone
                                .addClass(animation)
                                .removeClass(className.inward)
                                .removeClass(className.outward)
                                .addClass(className.animating)
                                .addClass(className.transition)
                                .css('animationName')
                              ;
                              inAnimation = $clone
                                .addClass(className.inward)
                                .css('animationName')
                              ;
                              displayType = $clone
                                .attr('class', elementClass)
                                .removeAttr('style')
                                .removeClass(className.hidden)
                                .removeClass(className.visible)
                                .show()
                                .css('display')
                              ;
                              module.verbose('Determining final display state', displayType);
                              module.save.displayType(displayType);

                              $clone.remove();
                              if (currentAnimation != inAnimation) {
                                  module.debug('Direction exists for animation', animation);
                                  directionExists = true;
                              }
                              else if (currentAnimation == 'none' || !currentAnimation) {
                                  module.debug('No animation defined in css', animation);
                                  return;
                              }
                              else {
                                  module.debug('Static animation found', animation, displayType);
                                  directionExists = false;
                              }
                              module.save.transitionExists(animation, directionExists);
                          }
                          return (transitionExists !== undefined)
                            ? transitionExists
                            : directionExists
                          ;
                      },
                      animate: function () {
                          // can transition does not return a value if animation does not exist
                          return (module.can.transition() !== undefined);
                      }
                  },

                  is: {
                      animating: function () {
                          return $module.hasClass(className.animating);
                      },
                      inward: function () {
                          return $module.hasClass(className.inward);
                      },
                      outward: function () {
                          return $module.hasClass(className.outward);
                      },
                      looping: function () {
                          return $module.hasClass(className.looping);
                      },
                      occurring: function (animation) {
                          animation = animation || settings.animation;
                          animation = '.' + animation.replace(' ', '.');
                          return ($module.filter(animation).length > 0);
                      },
                      visible: function () {
                          return $module.is(':visible');
                      },
                      hidden: function () {
                          return $module.css('visibility') === 'hidden';
                      },
                      supported: function () {
                          return (animationEnd !== false);
                      }
                  },

                  hide: function () {
                      module.verbose('Hiding element');
                      if (module.is.animating()) {
                          module.reset();
                      }
                      element.blur(); // IE will trigger focus change if element is not blurred before hiding
                      module.remove.display();
                      module.remove.visible();
                      module.set.hidden();
                      module.force.hidden();
                      settings.onHide.call(element);
                      settings.onComplete.call(element);
                      // module.repaint();
                  },

                  show: function (display) {
                      module.verbose('Showing element', display);
                      module.remove.hidden();
                      module.set.visible();
                      module.force.visible();
                      settings.onShow.call(element);
                      settings.onComplete.call(element);
                      // module.repaint();
                  },

                  toggle: function () {
                      if (module.is.visible()) {
                          module.hide();
                      }
                      else {
                          module.show();
                      }
                  },

                  stop: function () {
                      module.debug('Stopping current animation');
                      $module.triggerHandler(animationEnd);
                  },

                  stopAll: function () {
                      module.debug('Stopping all animation');
                      module.remove.queueCallback();
                      $module.triggerHandler(animationEnd);
                  },

                  clear: {
                      queue: function () {
                          module.debug('Clearing animation queue');
                          module.remove.queueCallback();
                      }
                  },

                  enable: function () {
                      module.verbose('Starting animation');
                      $module.removeClass(className.disabled);
                  },

                  disable: function () {
                      module.debug('Stopping animation');
                      $module.addClass(className.disabled);
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ($allModules.length > 1) {
                              title += ' ' + '(' + $allModules.length + ')';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  // modified for transition to return invoke success
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }

                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return (found !== undefined)
                        ? found
                        : false
                      ;
                  }
              };
              module.initialize();
          })
        ;
        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    // Records if CSS transition is available
    $.fn.transition.exists = {};

    $.fn.transition.settings = {

        // module info
        name: 'Transition',

        // hide all output from this component regardless of other settings
        silent: false,

        // debug content outputted to console
        debug: false,

        // verbose debug output
        verbose: false,

        // performance data output
        performance: true,

        // event namespace
        namespace: 'transition',

        // delay between animations in group
        interval: 0,

        // whether group animations should be reversed
        reverse: 'auto',

        // animation callback event
        onStart: function () { },
        onComplete: function () { },
        onShow: function () { },
        onHide: function () { },

        // whether timeout should be used to ensure callback fires in cases animationend does not
        useFailSafe: true,

        // delay in ms for fail safe
        failSafeDelay: 100,

        // whether EXACT animation can occur twice in a row
        allowRepeats: false,

        // Override final display type on visible
        displayType: false,

        // animation duration
        animation: 'fade',
        duration: false,

        // new animations will occur after previous ones
        queue: true,

        metadata: {
            displayType: 'display'
        },

        className: {
            animating: 'animating',
            disabled: 'disabled',
            hidden: 'hidden',
            inward: 'in',
            loading: 'loading',
            looping: 'looping',
            outward: 'out',
            transition: 'transition',
            visible: 'visible'
        },

        // possible errors
        error: {
            noAnimation: 'Element is no longer attached to DOM. Unable to animate.  Use silent setting to surpress this warning in production.',
            repeated: 'That animation is already occurring, cancelling repeated animation',
            method: 'The method you called is not defined',
            support: 'This browser does not support CSS animations'
        }

    };


})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - API
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    var
      window = (typeof window != 'undefined' && window.Math == Math)
        ? window
        : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
    ;

    $.api = $.fn.api = function (parameters) {

        var
          // use window context if none specified
          $allModules = $.isFunction(this)
              ? $(window)
              : $(this),
          moduleSelector = $allModules.selector || '',
          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          returnedValue
        ;

        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.api.settings, parameters)
                  : $.extend({}, $.fn.api.settings),

                // internal aliases
                namespace = settings.namespace,
                metadata = settings.metadata,
                selector = settings.selector,
                error = settings.error,
                className = settings.className,

                // define namespaces for modules
                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                // element that creates request
                $module = $(this),
                $form = $module.closest(selector.form),

                // context used for state
                $context = (settings.stateContext)
                  ? $(settings.stateContext)
                  : $module,

                // request details
                ajaxSettings,
                requestSettings,
                url,
                data,
                requestStartTime,

                // standard module
                element = this,
                context = $context[0],
                instance = $module.data(moduleNamespace),
                module
              ;

              module = {

                  initialize: function () {
                      if (!methodInvoked) {
                          module.bind.events();
                      }
                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, instance)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous module for', element);
                      $module
                        .removeData(moduleNamespace)
                        .off(eventNamespace)
                      ;
                  },

                  bind: {
                      events: function () {
                          var
                            triggerEvent = module.get.event()
                          ;
                          if (triggerEvent) {
                              module.verbose('Attaching API events to element', triggerEvent);
                              $module
                                .on(triggerEvent + eventNamespace, module.event.trigger)
                              ;
                          }
                          else if (settings.on == 'now') {
                              module.debug('Querying API endpoint immediately');
                              module.query();
                          }
                      }
                  },

                  decode: {
                      json: function (response) {
                          if (response !== undefined && typeof response == 'string') {
                              try {
                                  response = JSON.parse(response);
                              }
                              catch (e) {
                                  // isnt json string
                              }
                          }
                          return response;
                      }
                  },

                  read: {
                      cachedResponse: function (url) {
                          var
                            response
                          ;
                          if (window.Storage === undefined) {
                              module.error(error.noStorage);
                              return;
                          }
                          response = sessionStorage.getItem(url);
                          module.debug('Using cached response', url, response);
                          response = module.decode.json(response);
                          return response;
                      }
                  },
                  write: {
                      cachedResponse: function (url, response) {
                          if (response && response === '') {
                              module.debug('Response empty, not caching', response);
                              return;
                          }
                          if (window.Storage === undefined) {
                              module.error(error.noStorage);
                              return;
                          }
                          if ($.isPlainObject(response)) {
                              response = JSON.stringify(response);
                          }
                          sessionStorage.setItem(url, response);
                          module.verbose('Storing cached response for url', url, response);
                      }
                  },

                  query: function () {

                      if (module.is.disabled()) {
                          module.debug('Element is disabled API request aborted');
                          return;
                      }

                      if (module.is.loading()) {
                          if (settings.interruptRequests) {
                              module.debug('Interrupting previous request');
                              module.abort();
                          }
                          else {
                              module.debug('Cancelling request, previous request is still pending');
                              return;
                          }
                      }

                      // pass element metadata to url (value, text)
                      if (settings.defaultData) {
                          $.extend(true, settings.urlData, module.get.defaultData());
                      }

                      // Add form content
                      if (settings.serializeForm) {
                          settings.data = module.add.formData(settings.data);
                      }

                      // call beforesend and get any settings changes
                      requestSettings = module.get.settings();

                      // check if before send cancelled request
                      if (requestSettings === false) {
                          module.cancelled = true;
                          module.error(error.beforeSend);
                          return;
                      }
                      else {
                          module.cancelled = false;
                      }

                      // get url
                      url = module.get.templatedURL();

                      if (!url && !module.is.mocked()) {
                          module.error(error.missingURL);
                          return;
                      }

                      // replace variables
                      url = module.add.urlData(url);
                      // missing url parameters
                      if (!url && !module.is.mocked()) {
                          return;
                      }

                      requestSettings.url = settings.base + url;

                      // look for jQuery ajax parameters in settings
                      ajaxSettings = $.extend(true, {}, settings, {
                          type: settings.method || settings.type,
                          data: data,
                          url: settings.base + url,
                          beforeSend: settings.beforeXHR,
                          success: function () { },
                          failure: function () { },
                          complete: function () { }
                      });

                      module.debug('Querying URL', ajaxSettings.url);
                      module.verbose('Using AJAX settings', ajaxSettings);
                      if (settings.cache === 'local' && module.read.cachedResponse(url)) {
                          module.debug('Response returned from local cache');
                          module.request = module.create.request();
                          module.request.resolveWith(context, [module.read.cachedResponse(url)]);
                          return;
                      }

                      if (!settings.throttle) {
                          module.debug('Sending request', data, ajaxSettings.method);
                          module.send.request();
                      }
                      else {
                          if (!settings.throttleFirstRequest && !module.timer) {
                              module.debug('Sending request', data, ajaxSettings.method);
                              module.send.request();
                              module.timer = setTimeout(function () { }, settings.throttle);
                          }
                          else {
                              module.debug('Throttling request', settings.throttle);
                              clearTimeout(module.timer);
                              module.timer = setTimeout(function () {
                                  if (module.timer) {
                                      delete module.timer;
                                  }
                                  module.debug('Sending throttled request', data, ajaxSettings.method);
                                  module.send.request();
                              }, settings.throttle);
                          }
                      }

                  },

                  should: {
                      removeError: function () {
                          return (settings.hideError === true || (settings.hideError === 'auto' && !module.is.form()));
                      }
                  },

                  is: {
                      disabled: function () {
                          return ($module.filter(selector.disabled).length > 0);
                      },
                      expectingJSON: function () {
                          return settings.dataType === 'json' || settings.dataType === 'jsonp';
                      },
                      form: function () {
                          return $module.is('form') || $context.is('form');
                      },
                      mocked: function () {
                          return (settings.mockResponse || settings.mockResponseAsync || settings.response || settings.responseAsync);
                      },
                      input: function () {
                          return $module.is('input');
                      },
                      loading: function () {
                          return (module.request)
                            ? (module.request.state() == 'pending')
                            : false
                          ;
                      },
                      abortedRequest: function (xhr) {
                          if (xhr && xhr.readyState !== undefined && xhr.readyState === 0) {
                              module.verbose('XHR request determined to be aborted');
                              return true;
                          }
                          else {
                              module.verbose('XHR request was not aborted');
                              return false;
                          }
                      },
                      validResponse: function (response) {
                          if ((!module.is.expectingJSON()) || !$.isFunction(settings.successTest)) {
                              module.verbose('Response is not JSON, skipping validation', settings.successTest, response);
                              return true;
                          }
                          module.debug('Checking JSON returned success', settings.successTest, response);
                          if (settings.successTest(response)) {
                              module.debug('Response passed success test', response);
                              return true;
                          }
                          else {
                              module.debug('Response failed success test', response);
                              return false;
                          }
                      }
                  },

                  was: {
                      cancelled: function () {
                          return (module.cancelled || false);
                      },
                      succesful: function () {
                          return (module.request && module.request.state() == 'resolved');
                      },
                      failure: function () {
                          return (module.request && module.request.state() == 'rejected');
                      },
                      complete: function () {
                          return (module.request && (module.request.state() == 'resolved' || module.request.state() == 'rejected'));
                      }
                  },

                  add: {
                      urlData: function (url, urlData) {
                          var
                            requiredVariables,
                            optionalVariables
                          ;
                          if (url) {
                              requiredVariables = url.match(settings.regExp.required);
                              optionalVariables = url.match(settings.regExp.optional);
                              urlData = urlData || settings.urlData;
                              if (requiredVariables) {
                                  module.debug('Looking for required URL variables', requiredVariables);
                                  $.each(requiredVariables, function (index, templatedString) {
                                      var
                                        // allow legacy {$var} style
                                        variable = (templatedString.indexOf('$') !== -1)
                                          ? templatedString.substr(2, templatedString.length - 3)
                                          : templatedString.substr(1, templatedString.length - 2),
                                        value = ($.isPlainObject(urlData) && urlData[variable] !== undefined)
                                          ? urlData[variable]
                                          : ($module.data(variable) !== undefined)
                                            ? $module.data(variable)
                                            : ($context.data(variable) !== undefined)
                                              ? $context.data(variable)
                                              : urlData[variable]
                                      ;
                                      // remove value
                                      if (value === undefined) {
                                          module.error(error.requiredParameter, variable, url);
                                          url = false;
                                          return false;
                                      }
                                      else {
                                          module.verbose('Found required variable', variable, value);
                                          value = (settings.encodeParameters)
                                            ? module.get.urlEncodedValue(value)
                                            : value
                                          ;
                                          url = url.replace(templatedString, value);
                                      }
                                  });
                              }
                              if (optionalVariables) {
                                  module.debug('Looking for optional URL variables', requiredVariables);
                                  $.each(optionalVariables, function (index, templatedString) {
                                      var
                                        // allow legacy {/$var} style
                                        variable = (templatedString.indexOf('$') !== -1)
                                          ? templatedString.substr(3, templatedString.length - 4)
                                          : templatedString.substr(2, templatedString.length - 3),
                                        value = ($.isPlainObject(urlData) && urlData[variable] !== undefined)
                                          ? urlData[variable]
                                          : ($module.data(variable) !== undefined)
                                            ? $module.data(variable)
                                            : ($context.data(variable) !== undefined)
                                              ? $context.data(variable)
                                              : urlData[variable]
                                      ;
                                      // optional replacement
                                      if (value !== undefined) {
                                          module.verbose('Optional variable Found', variable, value);
                                          url = url.replace(templatedString, value);
                                      }
                                      else {
                                          module.verbose('Optional variable not found', variable);
                                          // remove preceding slash if set
                                          if (url.indexOf('/' + templatedString) !== -1) {
                                              url = url.replace('/' + templatedString, '');
                                          }
                                          else {
                                              url = url.replace(templatedString, '');
                                          }
                                      }
                                  });
                              }
                          }
                          return url;
                      },
                      formData: function (data) {
                          var
                            canSerialize = ($.fn.serializeObject !== undefined),
                            formData = (canSerialize)
                              ? $form.serializeObject()
                              : $form.serialize(),
                            hasOtherData
                          ;
                          data = data || settings.data;
                          hasOtherData = $.isPlainObject(data);

                          if (hasOtherData) {
                              if (canSerialize) {
                                  module.debug('Extending existing data with form data', data, formData);
                                  data = $.extend(true, {}, data, formData);
                              }
                              else {
                                  module.error(error.missingSerialize);
                                  module.debug('Cant extend data. Replacing data with form data', data, formData);
                                  data = formData;
                              }
                          }
                          else {
                              module.debug('Adding form data', formData);
                              data = formData;
                          }
                          return data;
                      }
                  },

                  send: {
                      request: function () {
                          module.set.loading();
                          module.request = module.create.request();
                          if (module.is.mocked()) {
                              module.mockedXHR = module.create.mockedXHR();
                          }
                          else {
                              module.xhr = module.create.xhr();
                          }
                          settings.onRequest.call(context, module.request, module.xhr);
                      }
                  },

                  event: {
                      trigger: function (event) {
                          module.query();
                          if (event.type == 'submit' || event.type == 'click') {
                              event.preventDefault();
                          }
                      },
                      xhr: {
                          always: function () {
                              // nothing special
                          },
                          done: function (response, textStatus, xhr) {
                              var
                                context = this,
                                elapsedTime = (new Date().getTime() - requestStartTime),
                                timeLeft = (settings.loadingDuration - elapsedTime),
                                translatedResponse = ($.isFunction(settings.onResponse))
                                  ? module.is.expectingJSON()
                                    ? settings.onResponse.call(context, $.extend(true, {}, response))
                                    : settings.onResponse.call(context, response)
                                  : false
                              ;
                              timeLeft = (timeLeft > 0)
                                ? timeLeft
                                : 0
                              ;
                              if (translatedResponse) {
                                  module.debug('Modified API response in onResponse callback', settings.onResponse, translatedResponse, response);
                                  response = translatedResponse;
                              }
                              if (timeLeft > 0) {
                                  module.debug('Response completed early delaying state change by', timeLeft);
                              }
                              setTimeout(function () {
                                  if (module.is.validResponse(response)) {
                                      module.request.resolveWith(context, [response, xhr]);
                                  }
                                  else {
                                      module.request.rejectWith(context, [xhr, 'invalid']);
                                  }
                              }, timeLeft);
                          },
                          fail: function (xhr, status, httpMessage) {
                              var
                                context = this,
                                elapsedTime = (new Date().getTime() - requestStartTime),
                                timeLeft = (settings.loadingDuration - elapsedTime)
                              ;
                              timeLeft = (timeLeft > 0)
                                ? timeLeft
                                : 0
                              ;
                              if (timeLeft > 0) {
                                  module.debug('Response completed early delaying state change by', timeLeft);
                              }
                              setTimeout(function () {
                                  if (module.is.abortedRequest(xhr)) {
                                      module.request.rejectWith(context, [xhr, 'aborted', httpMessage]);
                                  }
                                  else {
                                      module.request.rejectWith(context, [xhr, 'error', status, httpMessage]);
                                  }
                              }, timeLeft);
                          }
                      },
                      request: {
                          done: function (response, xhr) {
                              module.debug('Successful API Response', response);
                              if (settings.cache === 'local' && url) {
                                  module.write.cachedResponse(url, response);
                                  module.debug('Saving server response locally', module.cache);
                              }
                              settings.onSuccess.call(context, response, $module, xhr);
                          },
                          complete: function (firstParameter, secondParameter) {
                              var
                                xhr,
                                response
                              ;
                              // have to guess callback parameters based on request success
                              if (module.was.succesful()) {
                                  response = firstParameter;
                                  xhr = secondParameter;
                              }
                              else {
                                  xhr = firstParameter;
                                  response = module.get.responseFromXHR(xhr);
                              }
                              module.remove.loading();
                              settings.onComplete.call(context, response, $module, xhr);
                          },
                          fail: function (xhr, status, httpMessage) {
                              var
                                // pull response from xhr if available
                                response = module.get.responseFromXHR(xhr),
                                errorMessage = module.get.errorFromRequest(response, status, httpMessage)
                              ;
                              if (status == 'aborted') {
                                  module.debug('XHR Aborted (Most likely caused by page navigation or CORS Policy)', status, httpMessage);
                                  settings.onAbort.call(context, status, $module, xhr);
                                  return true;
                              }
                              else if (status == 'invalid') {
                                  module.debug('JSON did not pass success test. A server-side error has most likely occurred', response);
                              }
                              else if (status == 'error') {
                                  if (xhr !== undefined) {
                                      module.debug('XHR produced a server error', status, httpMessage);
                                      // make sure we have an error to display to console
                                      if (xhr.status != 200 && httpMessage !== undefined && httpMessage !== '') {
                                          module.error(error.statusMessage + httpMessage, ajaxSettings.url);
                                      }
                                      settings.onError.call(context, errorMessage, $module, xhr);
                                  }
                              }

                              if (settings.errorDuration && status !== 'aborted') {
                                  module.debug('Adding error state');
                                  module.set.error();
                                  if (module.should.removeError()) {
                                      setTimeout(module.remove.error, settings.errorDuration);
                                  }
                              }
                              module.debug('API Request failed', errorMessage, xhr);
                              settings.onFailure.call(context, response, $module, xhr);
                          }
                      }
                  },

                  create: {

                      request: function () {
                          // api request promise
                          return $.Deferred()
                            .always(module.event.request.complete)
                            .done(module.event.request.done)
                            .fail(module.event.request.fail)
                          ;
                      },

                      mockedXHR: function () {
                          var
                            // xhr does not simulate these properties of xhr but must return them
                            textStatus = false,
                            status = false,
                            httpMessage = false,
                            responder = settings.mockResponse || settings.response,
                            asyncResponder = settings.mockResponseAsync || settings.responseAsync,
                            asyncCallback,
                            response,
                            mockedXHR
                          ;

                          mockedXHR = $.Deferred()
                            .always(module.event.xhr.complete)
                            .done(module.event.xhr.done)
                            .fail(module.event.xhr.fail)
                          ;

                          if (responder) {
                              if ($.isFunction(responder)) {
                                  module.debug('Using specified synchronous callback', responder);
                                  response = responder.call(context, requestSettings);
                              }
                              else {
                                  module.debug('Using settings specified response', responder);
                                  response = responder;
                              }
                              // simulating response
                              mockedXHR.resolveWith(context, [response, textStatus, { responseText: response }]);
                          }
                          else if ($.isFunction(asyncResponder)) {
                              asyncCallback = function (response) {
                                  module.debug('Async callback returned response', response);

                                  if (response) {
                                      mockedXHR.resolveWith(context, [response, textStatus, { responseText: response }]);
                                  }
                                  else {
                                      mockedXHR.rejectWith(context, [{ responseText: response }, status, httpMessage]);
                                  }
                              };
                              module.debug('Using specified async response callback', asyncResponder);
                              asyncResponder.call(context, requestSettings, asyncCallback);
                          }
                          return mockedXHR;
                      },

                      xhr: function () {
                          var
                            xhr
                          ;
                          // ajax request promise
                          xhr = $.ajax(ajaxSettings)
                            .always(module.event.xhr.always)
                            .done(module.event.xhr.done)
                            .fail(module.event.xhr.fail)
                          ;
                          module.verbose('Created server request', xhr, ajaxSettings);
                          return xhr;
                      }
                  },

                  set: {
                      error: function () {
                          module.verbose('Adding error state to element', $context);
                          $context.addClass(className.error);
                      },
                      loading: function () {
                          module.verbose('Adding loading state to element', $context);
                          $context.addClass(className.loading);
                          requestStartTime = new Date().getTime();
                      }
                  },

                  remove: {
                      error: function () {
                          module.verbose('Removing error state from element', $context);
                          $context.removeClass(className.error);
                      },
                      loading: function () {
                          module.verbose('Removing loading state from element', $context);
                          $context.removeClass(className.loading);
                      }
                  },

                  get: {
                      responseFromXHR: function (xhr) {
                          return $.isPlainObject(xhr)
                            ? (module.is.expectingJSON())
                              ? module.decode.json(xhr.responseText)
                              : xhr.responseText
                            : false
                          ;
                      },
                      errorFromRequest: function (response, status, httpMessage) {
                          return ($.isPlainObject(response) && response.error !== undefined)
                            ? response.error // use json error message
                            : (settings.error[status] !== undefined) // use server error message
                              ? settings.error[status]
                              : httpMessage
                          ;
                      },
                      request: function () {
                          return module.request || false;
                      },
                      xhr: function () {
                          return module.xhr || false;
                      },
                      settings: function () {
                          var
                            runSettings
                          ;
                          runSettings = settings.beforeSend.call(context, settings);
                          if (runSettings) {
                              if (runSettings.success !== undefined) {
                                  module.debug('Legacy success callback detected', runSettings);
                                  module.error(error.legacyParameters, runSettings.success);
                                  runSettings.onSuccess = runSettings.success;
                              }
                              if (runSettings.failure !== undefined) {
                                  module.debug('Legacy failure callback detected', runSettings);
                                  module.error(error.legacyParameters, runSettings.failure);
                                  runSettings.onFailure = runSettings.failure;
                              }
                              if (runSettings.complete !== undefined) {
                                  module.debug('Legacy complete callback detected', runSettings);
                                  module.error(error.legacyParameters, runSettings.complete);
                                  runSettings.onComplete = runSettings.complete;
                              }
                          }
                          if (runSettings === undefined) {
                              module.error(error.noReturnedValue);
                          }
                          if (runSettings === false) {
                              return runSettings;
                          }
                          return (runSettings !== undefined)
                            ? $.extend(true, {}, runSettings)
                            : $.extend(true, {}, settings)
                          ;
                      },
                      urlEncodedValue: function (value) {
                          var
                            decodedValue = window.decodeURIComponent(value),
                            encodedValue = window.encodeURIComponent(value),
                            alreadyEncoded = (decodedValue !== value)
                          ;
                          if (alreadyEncoded) {
                              module.debug('URL value is already encoded, avoiding double encoding', value);
                              return value;
                          }
                          module.verbose('Encoding value using encodeURIComponent', value, encodedValue);
                          return encodedValue;
                      },
                      defaultData: function () {
                          var
                            data = {}
                          ;
                          if (!$.isWindow(element)) {
                              if (module.is.input()) {
                                  data.value = $module.val();
                              }
                              else if (module.is.form()) {

                              }
                              else {
                                  data.text = $module.text();
                              }
                          }
                          return data;
                      },
                      event: function () {
                          if ($.isWindow(element) || settings.on == 'now') {
                              module.debug('API called without element, no events attached');
                              return false;
                          }
                          else if (settings.on == 'auto') {
                              if ($module.is('input')) {
                                  return (element.oninput !== undefined)
                                    ? 'input'
                                    : (element.onpropertychange !== undefined)
                                      ? 'propertychange'
                                      : 'keyup'
                                  ;
                              }
                              else if ($module.is('form')) {
                                  return 'submit';
                              }
                              else {
                                  return 'click';
                              }
                          }
                          else {
                              return settings.on;
                          }
                      },
                      templatedURL: function (action) {
                          action = action || $module.data(metadata.action) || settings.action || false;
                          url = $module.data(metadata.url) || settings.url || false;
                          if (url) {
                              module.debug('Using specified url', url);
                              return url;
                          }
                          if (action) {
                              module.debug('Looking up url for action', action, settings.api);
                              if (settings.api[action] === undefined && !module.is.mocked()) {
                                  module.error(error.missingAction, settings.action, settings.api);
                                  return;
                              }
                              url = settings.api[action];
                          }
                          else if (module.is.form()) {
                              url = $module.attr('action') || $context.attr('action') || false;
                              module.debug('No url or action specified, defaulting to form action', url);
                          }
                          return url;
                      }
                  },

                  abort: function () {
                      var
                        xhr = module.get.xhr()
                      ;
                      if (xhr && xhr.state() !== 'resolved') {
                          module.debug('Cancelling API request');
                          xhr.abort();
                      }
                  },

                  // reset state
                  reset: function () {
                      module.remove.error();
                      module.remove.loading();
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  //'Element'        : element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.api.settings = {

        name: 'API',
        namespace: 'api',

        debug: false,
        verbose: false,
        performance: true,

        // object containing all templates endpoints
        api: {},

        // whether to cache responses
        cache: true,

        // whether new requests should abort previous requests
        interruptRequests: true,

        // event binding
        on: 'auto',

        // context for applying state classes
        stateContext: false,

        // duration for loading state
        loadingDuration: 0,

        // whether to hide errors after a period of time
        hideError: 'auto',

        // duration for error state
        errorDuration: 2000,

        // whether parameters should be encoded with encodeURIComponent
        encodeParameters: true,

        // API action to use
        action: false,

        // templated URL to use
        url: false,

        // base URL to apply to all endpoints
        base: '',

        // data that will
        urlData: {},

        // whether to add default data to url data
        defaultData: true,

        // whether to serialize closest form
        serializeForm: false,

        // how long to wait before request should occur
        throttle: 0,

        // whether to throttle first request or only repeated
        throttleFirstRequest: true,

        // standard ajax settings
        method: 'get',
        data: {},
        dataType: 'json',

        // mock response
        mockResponse: false,
        mockResponseAsync: false,

        // aliases for mock
        response: false,
        responseAsync: false,

        // callbacks before request
        beforeSend: function (settings) { return settings; },
        beforeXHR: function (xhr) { },
        onRequest: function (promise, xhr) { },

        // after request
        onResponse: false, // function(response) { },

        // response was successful, if JSON passed validation
        onSuccess: function (response, $module) { },

        // request finished without aborting
        onComplete: function (response, $module) { },

        // failed JSON success test
        onFailure: function (response, $module) { },

        // server error
        onError: function (errorMessage, $module) { },

        // request aborted
        onAbort: function (errorMessage, $module) { },

        successTest: false,

        // errors
        error: {
            beforeSend: 'The before send function has aborted the request',
            error: 'There was an error with your request',
            exitConditions: 'API Request Aborted. Exit conditions met',
            JSONParse: 'JSON could not be parsed during error handling',
            legacyParameters: 'You are using legacy API success callback names',
            method: 'The method you called is not defined',
            missingAction: 'API action used but no url was defined',
            missingSerialize: 'jquery-serialize-object is required to add form data to an existing data object',
            missingURL: 'No URL specified for api event',
            noReturnedValue: 'The beforeSend callback must return a settings object, beforeSend ignored.',
            noStorage: 'Caching responses locally requires session storage',
            parseError: 'There was an error parsing your request',
            requiredParameter: 'Missing a required URL parameter: ',
            statusMessage: 'Server gave an error: ',
            timeout: 'Your request timed out'
        },

        regExp: {
            required: /\{\$*[A-z0-9]+\}/g,
            optional: /\{\/\$*[A-z0-9]+\}/g,
        },

        className: {
            loading: 'loading',
            error: 'error'
        },

        selector: {
            disabled: '.disabled',
            form: 'form'
        },

        metadata: {
            action: 'action',
            url: 'url'
        }
    };



})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - State
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.state = function (parameters) {
        var
          $allModules = $(this),

          moduleSelector = $allModules.selector || '',

          hasTouch = ('ontouchstart' in document.documentElement),
          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),

          returnedValue
        ;
        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.state.settings, parameters)
                  : $.extend({}, $.fn.state.settings),

                error = settings.error,
                metadata = settings.metadata,
                className = settings.className,
                namespace = settings.namespace,
                states = settings.states,
                text = settings.text,

                eventNamespace = '.' + namespace,
                moduleNamespace = namespace + '-module',

                $module = $(this),

                element = this,
                instance = $module.data(moduleNamespace),

                module
              ;
              module = {

                  initialize: function () {
                      module.verbose('Initializing module');

                      // allow module to guess desired state based on element
                      if (settings.automatic) {
                          module.add.defaults();
                      }

                      // bind events with delegated events
                      if (settings.context && moduleSelector !== '') {
                          $(settings.context)
                            .on(moduleSelector, 'mouseenter' + eventNamespace, module.change.text)
                            .on(moduleSelector, 'mouseleave' + eventNamespace, module.reset.text)
                            .on(moduleSelector, 'click' + eventNamespace, module.toggle.state)
                          ;
                      }
                      else {
                          $module
                            .on('mouseenter' + eventNamespace, module.change.text)
                            .on('mouseleave' + eventNamespace, module.reset.text)
                            .on('click' + eventNamespace, module.toggle.state)
                          ;
                      }
                      module.instantiate();
                  },

                  instantiate: function () {
                      module.verbose('Storing instance of module', module);
                      instance = module;
                      $module
                        .data(moduleNamespace, module)
                      ;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous module', instance);
                      $module
                        .off(eventNamespace)
                        .removeData(moduleNamespace)
                      ;
                  },

                  refresh: function () {
                      module.verbose('Refreshing selector cache');
                      $module = $(element);
                  },

                  add: {
                      defaults: function () {
                          var
                            userStates = parameters && $.isPlainObject(parameters.states)
                              ? parameters.states
                              : {}
                          ;
                          $.each(settings.defaults, function (type, typeStates) {
                              if (module.is[type] !== undefined && module.is[type]()) {
                                  module.verbose('Adding default states', type, element);
                                  $.extend(settings.states, typeStates, userStates);
                              }
                          });
                      }
                  },

                  is: {

                      active: function () {
                          return $module.hasClass(className.active);
                      },
                      loading: function () {
                          return $module.hasClass(className.loading);
                      },
                      inactive: function () {
                          return !($module.hasClass(className.active));
                      },
                      state: function (state) {
                          if (className[state] === undefined) {
                              return false;
                          }
                          return $module.hasClass(className[state]);
                      },

                      enabled: function () {
                          return !($module.is(settings.filter.active));
                      },
                      disabled: function () {
                          return ($module.is(settings.filter.active));
                      },
                      textEnabled: function () {
                          return !($module.is(settings.filter.text));
                      },

                      // definitions for automatic type detection
                      button: function () {
                          return $module.is('.button:not(a, .submit)');
                      },
                      input: function () {
                          return $module.is('input');
                      },
                      progress: function () {
                          return $module.is('.ui.progress');
                      }
                  },

                  allow: function (state) {
                      module.debug('Now allowing state', state);
                      states[state] = true;
                  },
                  disallow: function (state) {
                      module.debug('No longer allowing', state);
                      states[state] = false;
                  },

                  allows: function (state) {
                      return states[state] || false;
                  },

                  enable: function () {
                      $module.removeClass(className.disabled);
                  },

                  disable: function () {
                      $module.addClass(className.disabled);
                  },

                  setState: function (state) {
                      if (module.allows(state)) {
                          $module.addClass(className[state]);
                      }
                  },

                  removeState: function (state) {
                      if (module.allows(state)) {
                          $module.removeClass(className[state]);
                      }
                  },

                  toggle: {
                      state: function () {
                          var
                            apiRequest,
                            requestCancelled
                          ;
                          if (module.allows('active') && module.is.enabled()) {
                              module.refresh();
                              if ($.fn.api !== undefined) {
                                  apiRequest = $module.api('get request');
                                  requestCancelled = $module.api('was cancelled');
                                  if (requestCancelled) {
                                      module.debug('API Request cancelled by beforesend');
                                      settings.activateTest = function () { return false; };
                                      settings.deactivateTest = function () { return false; };
                                  }
                                  else if (apiRequest) {
                                      module.listenTo(apiRequest);
                                      return;
                                  }
                              }
                              module.change.state();
                          }
                      }
                  },

                  listenTo: function (apiRequest) {
                      module.debug('API request detected, waiting for state signal', apiRequest);
                      if (apiRequest) {
                          if (text.loading) {
                              module.update.text(text.loading);
                          }
                          $.when(apiRequest)
                            .then(function () {
                                if (apiRequest.state() == 'resolved') {
                                    module.debug('API request succeeded');
                                    settings.activateTest = function () { return true; };
                                    settings.deactivateTest = function () { return true; };
                                }
                                else {
                                    module.debug('API request failed');
                                    settings.activateTest = function () { return false; };
                                    settings.deactivateTest = function () { return false; };
                                }
                                module.change.state();
                            })
                          ;
                      }
                  },

                  // checks whether active/inactive state can be given
                  change: {

                      state: function () {
                          module.debug('Determining state change direction');
                          // inactive to active change
                          if (module.is.inactive()) {
                              module.activate();
                          }
                          else {
                              module.deactivate();
                          }
                          if (settings.sync) {
                              module.sync();
                          }
                          settings.onChange.call(element);
                      },

                      text: function () {
                          if (module.is.textEnabled()) {
                              if (module.is.disabled()) {
                                  module.verbose('Changing text to disabled text', text.hover);
                                  module.update.text(text.disabled);
                              }
                              else if (module.is.active()) {
                                  if (text.hover) {
                                      module.verbose('Changing text to hover text', text.hover);
                                      module.update.text(text.hover);
                                  }
                                  else if (text.deactivate) {
                                      module.verbose('Changing text to deactivating text', text.deactivate);
                                      module.update.text(text.deactivate);
                                  }
                              }
                              else {
                                  if (text.hover) {
                                      module.verbose('Changing text to hover text', text.hover);
                                      module.update.text(text.hover);
                                  }
                                  else if (text.activate) {
                                      module.verbose('Changing text to activating text', text.activate);
                                      module.update.text(text.activate);
                                  }
                              }
                          }
                      }

                  },

                  activate: function () {
                      if (settings.activateTest.call(element)) {
                          module.debug('Setting state to active');
                          $module
                            .addClass(className.active)
                          ;
                          module.update.text(text.active);
                          settings.onActivate.call(element);
                      }
                  },

                  deactivate: function () {
                      if (settings.deactivateTest.call(element)) {
                          module.debug('Setting state to inactive');
                          $module
                            .removeClass(className.active)
                          ;
                          module.update.text(text.inactive);
                          settings.onDeactivate.call(element);
                      }
                  },

                  sync: function () {
                      module.verbose('Syncing other buttons to current state');
                      if (module.is.active()) {
                          $allModules
                            .not($module)
                              .state('activate');
                      }
                      else {
                          $allModules
                            .not($module)
                              .state('deactivate')
                          ;
                      }
                  },

                  get: {
                      text: function () {
                          return (settings.selector.text)
                            ? $module.find(settings.selector.text).text()
                            : $module.html()
                          ;
                      },
                      textFor: function (state) {
                          return text[state] || false;
                      }
                  },

                  flash: {
                      text: function (text, duration, callback) {
                          var
                            previousText = module.get.text()
                          ;
                          module.debug('Flashing text message', text, duration);
                          text = text || settings.text.flash;
                          duration = duration || settings.flashDuration;
                          callback = callback || function () { };
                          module.update.text(text);
                          setTimeout(function () {
                              module.update.text(previousText);
                              callback.call(element);
                          }, duration);
                      }
                  },

                  reset: {
                      // on mouseout sets text to previous value
                      text: function () {
                          var
                            activeText = text.active || $module.data(metadata.storedText),
                            inactiveText = text.inactive || $module.data(metadata.storedText)
                          ;
                          if (module.is.textEnabled()) {
                              if (module.is.active() && activeText) {
                                  module.verbose('Resetting active text', activeText);
                                  module.update.text(activeText);
                              }
                              else if (inactiveText) {
                                  module.verbose('Resetting inactive text', activeText);
                                  module.update.text(inactiveText);
                              }
                          }
                      }
                  },

                  update: {
                      text: function (text) {
                          var
                            currentText = module.get.text()
                          ;
                          if (text && text !== currentText) {
                              module.debug('Updating text', text);
                              if (settings.selector.text) {
                                  $module
                                    .data(metadata.storedText, text)
                                    .find(settings.selector.text)
                                      .text(text)
                                  ;
                              }
                              else {
                                  $module
                                    .data(metadata.storedText, text)
                                    .html(text)
                                  ;
                              }
                          }
                          else {
                              module.debug('Text is already set, ignoring update', text);
                          }
                      }
                  },

                  setting: function (name, value) {
                      module.debug('Changing setting', name, value);
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          if ($.isPlainObject(settings[name])) {
                              $.extend(true, settings[name], value);
                          }
                          else {
                              settings[name] = value;
                          }
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.state.settings = {

        // module info
        name: 'State',

        // debug output
        debug: false,

        // verbose debug output
        verbose: false,

        // namespace for events
        namespace: 'state',

        // debug data includes performance
        performance: true,

        // callback occurs on state change
        onActivate: function () { },
        onDeactivate: function () { },
        onChange: function () { },

        // state test functions
        activateTest: function () { return true; },
        deactivateTest: function () { return true; },

        // whether to automatically map default states
        automatic: true,

        // activate / deactivate changes all elements instantiated at same time
        sync: false,

        // default flash text duration, used for temporarily changing text of an element
        flashDuration: 1000,

        // selector filter
        filter: {
            text: '.loading, .disabled',
            active: '.disabled'
        },

        context: false,

        // error
        error: {
            beforeSend: 'The before send function has cancelled state change',
            method: 'The method you called is not defined.'
        },

        // metadata
        metadata: {
            promise: 'promise',
            storedText: 'stored-text'
        },

        // change class on state
        className: {
            active: 'active',
            disabled: 'disabled',
            error: 'error',
            loading: 'loading',
            success: 'success',
            warning: 'warning'
        },

        selector: {
            // selector for text node
            text: false
        },

        defaults: {
            input: {
                disabled: true,
                loading: true,
                active: true
            },
            button: {
                disabled: true,
                loading: true,
                active: true,
            },
            progress: {
                active: true,
                success: true,
                warning: true,
                error: true
            }
        },

        states: {
            active: true,
            disabled: true,
            error: true,
            loading: true,
            success: true,
            warning: true
        },

        text: {
            disabled: false,
            flash: false,
            hover: false,
            active: false,
            inactive: false,
            activate: false,
            deactivate: false
        }

    };



})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.2 - Visibility
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

; (function ($, window, document, undefined) {

    "use strict";

    window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
        ? self
        : Function('return this')()
    ;

    $.fn.visibility = function (parameters) {
        var
          $allModules = $(this),
          moduleSelector = $allModules.selector || '',

          time = new Date().getTime(),
          performance = [],

          query = arguments[0],
          methodInvoked = (typeof query == 'string'),
          queryArguments = [].slice.call(arguments, 1),
          returnedValue,

          moduleCount = $allModules.length,
          loadedCount = 0
        ;

        $allModules
          .each(function () {
              var
                settings = ($.isPlainObject(parameters))
                  ? $.extend(true, {}, $.fn.visibility.settings, parameters)
                  : $.extend({}, $.fn.visibility.settings),

                className = settings.className,
                namespace = settings.namespace,
                error = settings.error,
                metadata = settings.metadata,

                eventNamespace = '.' + namespace,
                moduleNamespace = 'module-' + namespace,

                $window = $(window),

                $module = $(this),
                $context = $(settings.context),

                $placeholder,

                selector = $module.selector || '',
                instance = $module.data(moduleNamespace),

                requestAnimationFrame = window.requestAnimationFrame
                  || window.mozRequestAnimationFrame
                  || window.webkitRequestAnimationFrame
                  || window.msRequestAnimationFrame
                  || function (callback) { setTimeout(callback, 0); },

                element = this,
                disabled = false,

                contextObserver,
                observer,
                module
              ;

              module = {

                  initialize: function () {
                      module.debug('Initializing', settings);

                      module.setup.cache();

                      if (module.should.trackChanges()) {

                          if (settings.type == 'image') {
                              module.setup.image();
                          }
                          if (settings.type == 'fixed') {
                              module.setup.fixed();
                          }

                          if (settings.observeChanges) {
                              module.observeChanges();
                          }
                          module.bind.events();
                      }

                      module.save.position();
                      if (!module.is.visible()) {
                          module.error(error.visible, $module);
                      }

                      if (settings.initialCheck) {
                          module.checkVisibility();
                      }
                      module.instantiate();
                  },

                  instantiate: function () {
                      module.debug('Storing instance', module);
                      $module
                        .data(moduleNamespace, module)
                      ;
                      instance = module;
                  },

                  destroy: function () {
                      module.verbose('Destroying previous module');
                      if (observer) {
                          observer.disconnect();
                      }
                      if (contextObserver) {
                          contextObserver.disconnect();
                      }
                      $window
                        .off('load' + eventNamespace, module.event.load)
                        .off('resize' + eventNamespace, module.event.resize)
                      ;
                      $context
                        .off('scroll' + eventNamespace, module.event.scroll)
                        .off('scrollchange' + eventNamespace, module.event.scrollchange)
                      ;
                      if (settings.type == 'fixed') {
                          module.resetFixed();
                          module.remove.placeholder();
                      }
                      $module
                        .off(eventNamespace)
                        .removeData(moduleNamespace)
                      ;
                  },

                  observeChanges: function () {
                      if ('MutationObserver' in window) {
                          contextObserver = new MutationObserver(module.event.contextChanged);
                          observer = new MutationObserver(module.event.changed);
                          contextObserver.observe(document, {
                              childList: true,
                              subtree: true
                          });
                          observer.observe(element, {
                              childList: true,
                              subtree: true
                          });
                          module.debug('Setting up mutation observer', observer);
                      }
                  },

                  bind: {
                      events: function () {
                          module.verbose('Binding visibility events to scroll and resize');
                          if (settings.refreshOnLoad) {
                              $window
                                .on('load' + eventNamespace, module.event.load)
                              ;
                          }
                          $window
                            .on('resize' + eventNamespace, module.event.resize)
                          ;
                          // pub/sub pattern
                          $context
                            .off('scroll' + eventNamespace)
                            .on('scroll' + eventNamespace, module.event.scroll)
                            .on('scrollchange' + eventNamespace, module.event.scrollchange)
                          ;
                      }
                  },

                  event: {
                      changed: function (mutations) {
                          module.verbose('DOM tree modified, updating visibility calculations');
                          module.timer = setTimeout(function () {
                              module.verbose('DOM tree modified, updating sticky menu');
                              module.refresh();
                          }, 100);
                      },
                      contextChanged: function (mutations) {
                          [].forEach.call(mutations, function (mutation) {
                              if (mutation.removedNodes) {
                                  [].forEach.call(mutation.removedNodes, function (node) {
                                      if (node == element || $(node).find(element).length > 0) {
                                          module.debug('Element removed from DOM, tearing down events');
                                          module.destroy();
                                      }
                                  });
                              }
                          });
                      },
                      resize: function () {
                          module.debug('Window resized');
                          if (settings.refreshOnResize) {
                              requestAnimationFrame(module.refresh);
                          }
                      },
                      load: function () {
                          module.debug('Page finished loading');
                          requestAnimationFrame(module.refresh);
                      },
                      // publishes scrollchange event on one scroll
                      scroll: function () {
                          if (settings.throttle) {
                              clearTimeout(module.timer);
                              module.timer = setTimeout(function () {
                                  $context.triggerHandler('scrollchange' + eventNamespace, [$context.scrollTop()]);
                              }, settings.throttle);
                          }
                          else {
                              requestAnimationFrame(function () {
                                  $context.triggerHandler('scrollchange' + eventNamespace, [$context.scrollTop()]);
                              });
                          }
                      },
                      // subscribes to scrollchange
                      scrollchange: function (event, scrollPosition) {
                          module.checkVisibility(scrollPosition);
                      },
                  },

                  precache: function (images, callback) {
                      if (!(images instanceof Array)) {
                          images = [images];
                      }
                      var
                        imagesLength = images.length,
                        loadedCounter = 0,
                        cache = [],
                        cacheImage = document.createElement('img'),
                        handleLoad = function () {
                            loadedCounter++;
                            if (loadedCounter >= images.length) {
                                if ($.isFunction(callback)) {
                                    callback();
                                }
                            }
                        }
                      ;
                      while (imagesLength--) {
                          cacheImage = document.createElement('img');
                          cacheImage.onload = handleLoad;
                          cacheImage.onerror = handleLoad;
                          cacheImage.src = images[imagesLength];
                          cache.push(cacheImage);
                      }
                  },

                  enableCallbacks: function () {
                      module.debug('Allowing callbacks to occur');
                      disabled = false;
                  },

                  disableCallbacks: function () {
                      module.debug('Disabling all callbacks temporarily');
                      disabled = true;
                  },

                  should: {
                      trackChanges: function () {
                          if (methodInvoked) {
                              module.debug('One time query, no need to bind events');
                              return false;
                          }
                          module.debug('Callbacks being attached');
                          return true;
                      }
                  },

                  setup: {
                      cache: function () {
                          module.cache = {
                              occurred: {},
                              screen: {},
                              element: {},
                          };
                      },
                      image: function () {
                          var
                            src = $module.data(metadata.src)
                          ;
                          if (src) {
                              module.verbose('Lazy loading image', src);
                              settings.once = true;
                              settings.observeChanges = false;

                              // show when top visible
                              settings.onOnScreen = function () {
                                  module.debug('Image on screen', element);
                                  module.precache(src, function () {
                                      module.set.image(src, function () {
                                          loadedCount++;
                                          if (loadedCount == moduleCount) {
                                              settings.onAllLoaded.call(this);
                                          }
                                          settings.onLoad.call(this);
                                      });
                                  });
                              };
                          }
                      },
                      fixed: function () {
                          module.debug('Setting up fixed');
                          settings.once = false;
                          settings.observeChanges = false;
                          settings.initialCheck = true;
                          settings.refreshOnLoad = true;
                          if (!parameters.transition) {
                              settings.transition = false;
                          }
                          module.create.placeholder();
                          module.debug('Added placeholder', $placeholder);
                          settings.onTopPassed = function () {
                              module.debug('Element passed, adding fixed position', $module);
                              module.show.placeholder();
                              module.set.fixed();
                              if (settings.transition) {
                                  if ($.fn.transition !== undefined) {
                                      $module.transition(settings.transition, settings.duration);
                                  }
                              }
                          };
                          settings.onTopPassedReverse = function () {
                              module.debug('Element returned to position, removing fixed', $module);
                              module.hide.placeholder();
                              module.remove.fixed();
                          };
                      }
                  },

                  create: {
                      placeholder: function () {
                          module.verbose('Creating fixed position placeholder');
                          $placeholder = $module
                            .clone(false)
                            .css('display', 'none')
                            .addClass(className.placeholder)
                            .insertAfter($module)
                          ;
                      }
                  },

                  show: {
                      placeholder: function () {
                          module.verbose('Showing placeholder');
                          $placeholder
                            .css('display', 'block')
                            .css('visibility', 'hidden')
                          ;
                      }
                  },
                  hide: {
                      placeholder: function () {
                          module.verbose('Hiding placeholder');
                          $placeholder
                            .css('display', 'none')
                            .css('visibility', '')
                          ;
                      }
                  },

                  set: {
                      fixed: function () {
                          module.verbose('Setting element to fixed position');
                          $module
                            .addClass(className.fixed)
                            .css({
                                position: 'fixed',
                                top: settings.offset + 'px',
                                left: 'auto',
                                zIndex: settings.zIndex
                            })
                          ;
                          settings.onFixed.call(element);
                      },
                      image: function (src, callback) {
                          $module
                            .attr('src', src)
                          ;
                          if (settings.transition) {
                              if ($.fn.transition !== undefined) {
                                  $module.transition(settings.transition, settings.duration, callback);
                              }
                              else {
                                  $module.fadeIn(settings.duration, callback);
                              }
                          }
                          else {
                              $module.show();
                          }
                      }
                  },

                  is: {
                      onScreen: function () {
                          var
                            calculations = module.get.elementCalculations()
                          ;
                          return calculations.onScreen;
                      },
                      offScreen: function () {
                          var
                            calculations = module.get.elementCalculations()
                          ;
                          return calculations.offScreen;
                      },
                      visible: function () {
                          if (module.cache && module.cache.element) {
                              return !(module.cache.element.width === 0 && module.cache.element.offset.top === 0);
                          }
                          return false;
                      }
                  },

                  refresh: function () {
                      module.debug('Refreshing constants (width/height)');
                      if (settings.type == 'fixed') {
                          module.resetFixed();
                      }
                      module.reset();
                      module.save.position();
                      if (settings.checkOnRefresh) {
                          module.checkVisibility();
                      }
                      settings.onRefresh.call(element);
                  },

                  resetFixed: function () {
                      module.remove.fixed();
                      module.remove.occurred();
                  },

                  reset: function () {
                      module.verbose('Resetting all cached values');
                      if ($.isPlainObject(module.cache)) {
                          module.cache.screen = {};
                          module.cache.element = {};
                      }
                  },

                  checkVisibility: function (scroll) {
                      module.verbose('Checking visibility of element', module.cache.element);

                      if (!disabled && module.is.visible()) {

                          // save scroll position
                          module.save.scroll(scroll);

                          // update calculations derived from scroll
                          module.save.calculations();

                          // percentage
                          module.passed();

                          // reverse (must be first)
                          module.passingReverse();
                          module.topVisibleReverse();
                          module.bottomVisibleReverse();
                          module.topPassedReverse();
                          module.bottomPassedReverse();

                          // one time
                          module.onScreen();
                          module.offScreen();
                          module.passing();
                          module.topVisible();
                          module.bottomVisible();
                          module.topPassed();
                          module.bottomPassed();

                          // on update callback
                          if (settings.onUpdate) {
                              settings.onUpdate.call(element, module.get.elementCalculations());
                          }
                      }
                  },

                  passed: function (amount, newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        amountInPixels
                      ;
                      // assign callback
                      if (amount && newCallback) {
                          settings.onPassed[amount] = newCallback;
                      }
                      else if (amount !== undefined) {
                          return (module.get.pixelsPassed(amount) > calculations.pixelsPassed);
                      }
                      else if (calculations.passing) {
                          $.each(settings.onPassed, function (amount, callback) {
                              if (calculations.bottomVisible || calculations.pixelsPassed > module.get.pixelsPassed(amount)) {
                                  module.execute(callback, amount);
                              }
                              else if (!settings.once) {
                                  module.remove.occurred(callback);
                              }
                          });
                      }
                  },

                  onScreen: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onOnScreen,
                        callbackName = 'onScreen'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for onScreen', newCallback);
                          settings.onOnScreen = newCallback;
                      }
                      if (calculations.onScreen) {
                          module.execute(callback, callbackName);
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback !== undefined) {
                          return calculations.onOnScreen;
                      }
                  },

                  offScreen: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onOffScreen,
                        callbackName = 'offScreen'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for offScreen', newCallback);
                          settings.onOffScreen = newCallback;
                      }
                      if (calculations.offScreen) {
                          module.execute(callback, callbackName);
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback !== undefined) {
                          return calculations.onOffScreen;
                      }
                  },

                  passing: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onPassing,
                        callbackName = 'passing'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for passing', newCallback);
                          settings.onPassing = newCallback;
                      }
                      if (calculations.passing) {
                          module.execute(callback, callbackName);
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback !== undefined) {
                          return calculations.passing;
                      }
                  },


                  topVisible: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onTopVisible,
                        callbackName = 'topVisible'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for top visible', newCallback);
                          settings.onTopVisible = newCallback;
                      }
                      if (calculations.topVisible) {
                          module.execute(callback, callbackName);
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback === undefined) {
                          return calculations.topVisible;
                      }
                  },

                  bottomVisible: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onBottomVisible,
                        callbackName = 'bottomVisible'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for bottom visible', newCallback);
                          settings.onBottomVisible = newCallback;
                      }
                      if (calculations.bottomVisible) {
                          module.execute(callback, callbackName);
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback === undefined) {
                          return calculations.bottomVisible;
                      }
                  },

                  topPassed: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onTopPassed,
                        callbackName = 'topPassed'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for top passed', newCallback);
                          settings.onTopPassed = newCallback;
                      }
                      if (calculations.topPassed) {
                          module.execute(callback, callbackName);
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback === undefined) {
                          return calculations.topPassed;
                      }
                  },

                  bottomPassed: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onBottomPassed,
                        callbackName = 'bottomPassed'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for bottom passed', newCallback);
                          settings.onBottomPassed = newCallback;
                      }
                      if (calculations.bottomPassed) {
                          module.execute(callback, callbackName);
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback === undefined) {
                          return calculations.bottomPassed;
                      }
                  },

                  passingReverse: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onPassingReverse,
                        callbackName = 'passingReverse'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for passing reverse', newCallback);
                          settings.onPassingReverse = newCallback;
                      }
                      if (!calculations.passing) {
                          if (module.get.occurred('passing')) {
                              module.execute(callback, callbackName);
                          }
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback !== undefined) {
                          return !calculations.passing;
                      }
                  },


                  topVisibleReverse: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onTopVisibleReverse,
                        callbackName = 'topVisibleReverse'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for top visible reverse', newCallback);
                          settings.onTopVisibleReverse = newCallback;
                      }
                      if (!calculations.topVisible) {
                          if (module.get.occurred('topVisible')) {
                              module.execute(callback, callbackName);
                          }
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback === undefined) {
                          return !calculations.topVisible;
                      }
                  },

                  bottomVisibleReverse: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onBottomVisibleReverse,
                        callbackName = 'bottomVisibleReverse'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for bottom visible reverse', newCallback);
                          settings.onBottomVisibleReverse = newCallback;
                      }
                      if (!calculations.bottomVisible) {
                          if (module.get.occurred('bottomVisible')) {
                              module.execute(callback, callbackName);
                          }
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback === undefined) {
                          return !calculations.bottomVisible;
                      }
                  },

                  topPassedReverse: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onTopPassedReverse,
                        callbackName = 'topPassedReverse'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for top passed reverse', newCallback);
                          settings.onTopPassedReverse = newCallback;
                      }
                      if (!calculations.topPassed) {
                          if (module.get.occurred('topPassed')) {
                              module.execute(callback, callbackName);
                          }
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback === undefined) {
                          return !calculations.onTopPassed;
                      }
                  },

                  bottomPassedReverse: function (newCallback) {
                      var
                        calculations = module.get.elementCalculations(),
                        callback = newCallback || settings.onBottomPassedReverse,
                        callbackName = 'bottomPassedReverse'
                      ;
                      if (newCallback) {
                          module.debug('Adding callback for bottom passed reverse', newCallback);
                          settings.onBottomPassedReverse = newCallback;
                      }
                      if (!calculations.bottomPassed) {
                          if (module.get.occurred('bottomPassed')) {
                              module.execute(callback, callbackName);
                          }
                      }
                      else if (!settings.once) {
                          module.remove.occurred(callbackName);
                      }
                      if (newCallback === undefined) {
                          return !calculations.bottomPassed;
                      }
                  },

                  execute: function (callback, callbackName) {
                      var
                        calculations = module.get.elementCalculations(),
                        screen = module.get.screenCalculations()
                      ;
                      callback = callback || false;
                      if (callback) {
                          if (settings.continuous) {
                              module.debug('Callback being called continuously', callbackName, calculations);
                              callback.call(element, calculations, screen);
                          }
                          else if (!module.get.occurred(callbackName)) {
                              module.debug('Conditions met', callbackName, calculations);
                              callback.call(element, calculations, screen);
                          }
                      }
                      module.save.occurred(callbackName);
                  },

                  remove: {
                      fixed: function () {
                          module.debug('Removing fixed position');
                          $module
                            .removeClass(className.fixed)
                            .css({
                                position: '',
                                top: '',
                                left: '',
                                zIndex: ''
                            })
                          ;
                          settings.onUnfixed.call(element);
                      },
                      placeholder: function () {
                          module.debug('Removing placeholder content');
                          if ($placeholder) {
                              $placeholder.remove();
                          }
                      },
                      occurred: function (callback) {
                          if (callback) {
                              var
                                occurred = module.cache.occurred
                              ;
                              if (occurred[callback] !== undefined && occurred[callback] === true) {
                                  module.debug('Callback can now be called again', callback);
                                  module.cache.occurred[callback] = false;
                              }
                          }
                          else {
                              module.cache.occurred = {};
                          }
                      }
                  },

                  save: {
                      calculations: function () {
                          module.verbose('Saving all calculations necessary to determine positioning');
                          module.save.direction();
                          module.save.screenCalculations();
                          module.save.elementCalculations();
                      },
                      occurred: function (callback) {
                          if (callback) {
                              if (module.cache.occurred[callback] === undefined || (module.cache.occurred[callback] !== true)) {
                                  module.verbose('Saving callback occurred', callback);
                                  module.cache.occurred[callback] = true;
                              }
                          }
                      },
                      scroll: function (scrollPosition) {
                          scrollPosition = scrollPosition + settings.offset || $context.scrollTop() + settings.offset;
                          module.cache.scroll = scrollPosition;
                      },
                      direction: function () {
                          var
                            scroll = module.get.scroll(),
                            lastScroll = module.get.lastScroll(),
                            direction
                          ;
                          if (scroll > lastScroll && lastScroll) {
                              direction = 'down';
                          }
                          else if (scroll < lastScroll && lastScroll) {
                              direction = 'up';
                          }
                          else {
                              direction = 'static';
                          }
                          module.cache.direction = direction;
                          return module.cache.direction;
                      },
                      elementPosition: function () {
                          var
                            element = module.cache.element,
                            screen = module.get.screenSize()
                          ;
                          module.verbose('Saving element position');
                          // (quicker than $.extend)
                          element.fits = (element.height < screen.height);
                          element.offset = $module.offset();
                          element.width = $module.outerWidth();
                          element.height = $module.outerHeight();
                          // store
                          module.cache.element = element;
                          return element;
                      },
                      elementCalculations: function () {
                          var
                            screen = module.get.screenCalculations(),
                            element = module.get.elementPosition()
                          ;
                          // offset
                          if (settings.includeMargin) {
                              element.margin = {};
                              element.margin.top = parseInt($module.css('margin-top'), 10);
                              element.margin.bottom = parseInt($module.css('margin-bottom'), 10);
                              element.top = element.offset.top - element.margin.top;
                              element.bottom = element.offset.top + element.height + element.margin.bottom;
                          }
                          else {
                              element.top = element.offset.top;
                              element.bottom = element.offset.top + element.height;
                          }

                          // visibility
                          element.topVisible = (screen.bottom >= element.top);
                          element.topPassed = (screen.top >= element.top);
                          element.bottomVisible = (screen.bottom >= element.bottom);
                          element.bottomPassed = (screen.top >= element.bottom);
                          element.pixelsPassed = 0;
                          element.percentagePassed = 0;

                          // meta calculations
                          element.onScreen = (element.topVisible && !element.bottomPassed);
                          element.passing = (element.topPassed && !element.bottomPassed);
                          element.offScreen = (!element.onScreen);

                          // passing calculations
                          if (element.passing) {
                              element.pixelsPassed = (screen.top - element.top);
                              element.percentagePassed = (screen.top - element.top) / element.height;
                          }
                          module.cache.element = element;
                          module.verbose('Updated element calculations', element);
                          return element;
                      },
                      screenCalculations: function () {
                          var
                            scroll = module.get.scroll()
                          ;
                          module.save.direction();
                          module.cache.screen.top = scroll;
                          module.cache.screen.bottom = scroll + module.cache.screen.height;
                          return module.cache.screen;
                      },
                      screenSize: function () {
                          module.verbose('Saving window position');
                          module.cache.screen = {
                              height: $context.height()
                          };
                      },
                      position: function () {
                          module.save.screenSize();
                          module.save.elementPosition();
                      }
                  },

                  get: {
                      pixelsPassed: function (amount) {
                          var
                            element = module.get.elementCalculations()
                          ;
                          if (amount.search('%') > -1) {
                              return (element.height * (parseInt(amount, 10) / 100));
                          }
                          return parseInt(amount, 10);
                      },
                      occurred: function (callback) {
                          return (module.cache.occurred !== undefined)
                            ? module.cache.occurred[callback] || false
                            : false
                          ;
                      },
                      direction: function () {
                          if (module.cache.direction === undefined) {
                              module.save.direction();
                          }
                          return module.cache.direction;
                      },
                      elementPosition: function () {
                          if (module.cache.element === undefined) {
                              module.save.elementPosition();
                          }
                          return module.cache.element;
                      },
                      elementCalculations: function () {
                          if (module.cache.element === undefined) {
                              module.save.elementCalculations();
                          }
                          return module.cache.element;
                      },
                      screenCalculations: function () {
                          if (module.cache.screen === undefined) {
                              module.save.screenCalculations();
                          }
                          return module.cache.screen;
                      },
                      screenSize: function () {
                          if (module.cache.screen === undefined) {
                              module.save.screenSize();
                          }
                          return module.cache.screen;
                      },
                      scroll: function () {
                          if (module.cache.scroll === undefined) {
                              module.save.scroll();
                          }
                          return module.cache.scroll;
                      },
                      lastScroll: function () {
                          if (module.cache.screen === undefined) {
                              module.debug('First scroll event, no last scroll could be found');
                              return false;
                          }
                          return module.cache.screen.top;
                      }
                  },

                  setting: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, settings, name);
                      }
                      else if (value !== undefined) {
                          settings[name] = value;
                      }
                      else {
                          return settings[name];
                      }
                  },
                  internal: function (name, value) {
                      if ($.isPlainObject(name)) {
                          $.extend(true, module, name);
                      }
                      else if (value !== undefined) {
                          module[name] = value;
                      }
                      else {
                          return module[name];
                      }
                  },
                  debug: function () {
                      if (!settings.silent && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.debug.apply(console, arguments);
                          }
                      }
                  },
                  verbose: function () {
                      if (!settings.silent && settings.verbose && settings.debug) {
                          if (settings.performance) {
                              module.performance.log(arguments);
                          }
                          else {
                              module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
                              module.verbose.apply(console, arguments);
                          }
                      }
                  },
                  error: function () {
                      if (!settings.silent) {
                          module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
                          module.error.apply(console, arguments);
                      }
                  },
                  performance: {
                      log: function (message) {
                          var
                            currentTime,
                            executionTime,
                            previousTime
                          ;
                          if (settings.performance) {
                              currentTime = new Date().getTime();
                              previousTime = time || currentTime;
                              executionTime = currentTime - previousTime;
                              time = currentTime;
                              performance.push({
                                  'Name': message[0],
                                  'Arguments': [].slice.call(message, 1) || '',
                                  'Element': element,
                                  'Execution Time': executionTime
                              });
                          }
                          clearTimeout(module.performance.timer);
                          module.performance.timer = setTimeout(module.performance.display, 500);
                      },
                      display: function () {
                          var
                            title = settings.name + ':',
                            totalTime = 0
                          ;
                          time = false;
                          clearTimeout(module.performance.timer);
                          $.each(performance, function (index, data) {
                              totalTime += data['Execution Time'];
                          });
                          title += ' ' + totalTime + 'ms';
                          if (moduleSelector) {
                              title += ' \'' + moduleSelector + '\'';
                          }
                          if ((console.group !== undefined || console.table !== undefined) && performance.length > 0) {
                              console.groupCollapsed(title);
                              if (console.table) {
                                  console.table(performance);
                              }
                              else {
                                  $.each(performance, function (index, data) {
                                      console.log(data['Name'] + ': ' + data['Execution Time'] + 'ms');
                                  });
                              }
                              console.groupEnd();
                          }
                          performance = [];
                      }
                  },
                  invoke: function (query, passedArguments, context) {
                      var
                        object = instance,
                        maxDepth,
                        found,
                        response
                      ;
                      passedArguments = passedArguments || queryArguments;
                      context = element || context;
                      if (typeof query == 'string' && object !== undefined) {
                          query = query.split(/[\. ]/);
                          maxDepth = query.length - 1;
                          $.each(query, function (depth, value) {
                              var camelCaseValue = (depth != maxDepth)
                                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
                                : query
                              ;
                              if ($.isPlainObject(object[camelCaseValue]) && (depth != maxDepth)) {
                                  object = object[camelCaseValue];
                              }
                              else if (object[camelCaseValue] !== undefined) {
                                  found = object[camelCaseValue];
                                  return false;
                              }
                              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                                  object = object[value];
                              }
                              else if (object[value] !== undefined) {
                                  found = object[value];
                                  return false;
                              }
                              else {
                                  module.error(error.method, query);
                                  return false;
                              }
                          });
                      }
                      if ($.isFunction(found)) {
                          response = found.apply(context, passedArguments);
                      }
                      else if (found !== undefined) {
                          response = found;
                      }
                      if ($.isArray(returnedValue)) {
                          returnedValue.push(response);
                      }
                      else if (returnedValue !== undefined) {
                          returnedValue = [returnedValue, response];
                      }
                      else if (response !== undefined) {
                          returnedValue = response;
                      }
                      return found;
                  }
              };

              if (methodInvoked) {
                  if (instance === undefined) {
                      module.initialize();
                  }
                  instance.save.scroll();
                  instance.save.calculations();
                  module.invoke(query);
              }
              else {
                  if (instance !== undefined) {
                      instance.invoke('destroy');
                  }
                  module.initialize();
              }
          })
        ;

        return (returnedValue !== undefined)
          ? returnedValue
          : this
        ;
    };

    $.fn.visibility.settings = {

        name: 'Visibility',
        namespace: 'visibility',

        debug: false,
        verbose: false,
        performance: true,

        // whether to use mutation observers to follow changes
        observeChanges: true,

        // check position immediately on init
        initialCheck: true,

        // whether to refresh calculations after all page images load
        refreshOnLoad: true,

        // whether to refresh calculations after page resize event
        refreshOnResize: true,

        // should call callbacks on refresh event (resize, etc)
        checkOnRefresh: true,

        // callback should only occur one time
        once: true,

        // callback should fire continuously whe evaluates to true
        continuous: false,

        // offset to use with scroll top
        offset: 0,

        // whether to include margin in elements position
        includeMargin: false,

        // scroll context for visibility checks
        context: window,

        // visibility check delay in ms (defaults to animationFrame)
        throttle: false,

        // special visibility type (image, fixed)
        type: false,

        // z-index to use with visibility 'fixed'
        zIndex: '10',

        // image only animation settings
        transition: 'fade in',
        duration: 1000,

        // array of callbacks for percentage
        onPassed: {},

        // standard callbacks
        onOnScreen: false,
        onOffScreen: false,
        onPassing: false,
        onTopVisible: false,
        onBottomVisible: false,
        onTopPassed: false,
        onBottomPassed: false,

        // reverse callbacks
        onPassingReverse: false,
        onTopVisibleReverse: false,
        onBottomVisibleReverse: false,
        onTopPassedReverse: false,
        onBottomPassedReverse: false,

        // special callbacks for image
        onLoad: function () { },
        onAllLoaded: function () { },

        // special callbacks for fixed position
        onFixed: function () { },
        onUnfixed: function () { },

        // utility callbacks
        onUpdate: false, // disabled by default for performance
        onRefresh: function () { },

        metadata: {
            src: 'src'
        },

        className: {
            fixed: 'fixed',
            placeholder: 'placeholder'
        },

        error: {
            method: 'The method you called is not defined.',
            visible: 'Element is hidden, you must call refresh after element becomes visible'
        }

    };

})(jQuery, window, document);
