.-.-.-.-.-

karma.conf.js000064400000000746151676724710007150 0ustar00module.exports = function(config) {

config.set({
    basePath: '',
    frameworks: ['jasmine'],
    files: [
      'lib/jquery/jquery.js',
      'lib/angular/angular.js',
      'dist/bootstrap-tagsinput.min.js',
      'dist/bootstrap-tagsinput-angular.min.js',
      'test/helpers.js',
      { pattern: 'test/bootstrap-tagsinput/*.tests.js' }
    ],
    reporters: ['progress'],
    port: 9876,
    logLevel: config.LOG_DEBUG,
    captureTimeout: 60000
  });

};
src/bootstrap-tagsinput.js000064400000053635151676724710011756 0ustar00(function ($) {
  "use strict";

/**
   * Constructor function
   */
  function TagsInput(element, options) {
    this.isInit = true;
    this.itemsArray = [];

this.$element = $(element);
    this.$element.hide();

this.isSelect = (element.tagName === 'SELECT');
    this.multiple = (this.isSelect && element.hasAttribute('multiple'));
    this.objectItems = options && options.itemValue;
    this.placeholderText = element.hasAttribute('placeholder') ? this.$element.attr('placeholder') : '';
    this.inputSize = Math.max(1, this.placeholderText.length);

this.$container = $('<div class="bootstrap-tagsinput"></div>');
    this.$input = $('<input type="text" placeholder="' + this.placeholderText + '"/>').appendTo(this.$container);

this.$element.before(this.$container);

this.build(options);
    this.isInit = false;
  }

TagsInput.prototype = {
    constructor: TagsInput,

/**
     * Adds the given item as a new tag. Pass true to dontPushVal to prevent
     * updating the elements val()
     */
    add: function(item, dontPushVal, options) {
      var self = this;

if (self.options.maxTags && self.itemsArray.length >= self.options.maxTags)
        return;

// Ignore falsey values, except false
      if (item !== false && !item)
        return;

// Trim value
      if (typeof item === "string" && self.options.trimValue) {
        item = $.trim(item);
      }

// Throw an error when trying to add an object while the itemValue option was not set
      if (typeof item === "object" && !self.objectItems)
        throw("Can't add objects when itemValue option is not set");

// Ignore strings only containg whitespace
      if (item.toString().match(/^\s*$/))
        return;

// If SELECT but not multiple, remove current tag
      if (self.isSelect && !self.multiple && self.itemsArray.length > 0)
        self.remove(self.itemsArray[0]);

if (typeof item === "string" && this.$element[0].tagName === 'INPUT') {
        var delimiter = (self.options.delimiterRegex) ? self.options.delimiterRegex : self.options.delimiter;
        var items = item.split(delimiter);
        if (items.length > 1) {
          for (var i = 0; i < items.length; i++) {
            this.add(items[i], true);
          }

if (!dontPushVal)
            self.pushVal();
          return;
        }
      }

var itemValue = self.options.itemValue(item),
          itemText = self.options.itemText(item),
          tagClass = self.options.tagClass(item),
          itemTitle = self.options.itemTitle(item);

// Ignore items allready added
      var existing = $.grep(self.itemsArray, function(item) { return self.options.itemValue(item) === itemValue; } )[0];
      if (existing && !self.options.allowDuplicates) {
        // Invoke onTagExists
        if (self.options.onTagExists) {
          var $existingTag = $(".tag", self.$container).filter(function() { return $(this).data("item") === existing; });
          self.options.onTagExists(item, $existingTag);
        }
        return;
      }

// if length greater than limit
      if (self.items().toString().length + item.length + 1 > self.options.maxInputLength)
        return;

// raise beforeItemAdd arg
      var beforeItemAddEvent = $.Event('beforeItemAdd', { item: item, cancel: false, options: options});
      self.$element.trigger(beforeItemAddEvent);
      if (beforeItemAddEvent.cancel)
        return;

// register item in internal array and map
      self.itemsArray.push(item);

// add a tag element

var $tag = $('<span class="tag ' + htmlEncode(tagClass) + (itemTitle !== null ? ('" title="' + itemTitle) : '') + '">' + htmlEncode(itemText) + '<span data-role="remove"></span></span>');
      $tag.data('item', item);
      self.findInputWrapper().before($tag);
      $tag.after(' ');

// Check to see if the tag exists in its raw or uri-encoded form
      var optionExists = (
        $('option[value="' + encodeURIComponent(itemValue) + '"]', self.$element).length ||
        $('option[value="' + htmlEncode(itemValue) + '"]', self.$element).length
      );

// add <option /> if item represents a value not present in one of the <select />'s options
      if (self.isSelect && !optionExists) {
        var $option = $('<option selected>' + htmlEncode(itemText) + '</option>');
        $option.data('item', item);
        $option.attr('value', itemValue);
        self.$element.append($option);
      }

if (!dontPushVal)
        self.pushVal();

// Add class when reached maxTags
      if (self.options.maxTags === self.itemsArray.length || self.items().toString().length === self.options.maxInputLength)
        self.$container.addClass('bootstrap-tagsinput-max');

// If using typeahead, once the tag has been added, clear the typeahead value so it does not stick around in the input.
      if ($('.typeahead, .twitter-typeahead', self.$container).length) {
        self.$input.typeahead('val', '');
      }

if (this.isInit) {
        self.$element.trigger($.Event('itemAddedOnInit', { item: item, options: options }));
      } else {
        self.$element.trigger($.Event('itemAdded', { item: item, options: options }));
      }
    },

/**
     * Removes the given item. Pass true to dontPushVal to prevent updating the
     * elements val()
     */
    remove: function(item, dontPushVal, options) {
      var self = this;

if (self.objectItems) {
        if (typeof item === "object")
          item = $.grep(self.itemsArray, function(other) { return self.options.itemValue(other) ==  self.options.itemValue(item); } );
        else
          item = $.grep(self.itemsArray, function(other) { return self.options.itemValue(other) ==  item; } );

item = item[item.length-1];
      }

if (item) {
        var beforeItemRemoveEvent = $.Event('beforeItemRemove', { item: item, cancel: false, options: options });
        self.$element.trigger(beforeItemRemoveEvent);
        if (beforeItemRemoveEvent.cancel)
          return;

$('.tag', self.$container).filter(function() { return $(this).data('item') === item; }).remove();
        $('option', self.$element).filter(function() { return $(this).data('item') === item; }).remove();
        if($.inArray(item, self.itemsArray) !== -1)
          self.itemsArray.splice($.inArray(item, self.itemsArray), 1);
      }

if (!dontPushVal)
        self.pushVal();

// Remove class when reached maxTags
      if (self.options.maxTags > self.itemsArray.length)
        self.$container.removeClass('bootstrap-tagsinput-max');

self.$element.trigger($.Event('itemRemoved',  { item: item, options: options }));
    },

/**
     * Removes all items
     */
    removeAll: function() {
      var self = this;

$('.tag', self.$container).remove();
      $('option', self.$element).remove();

while(self.itemsArray.length > 0)
        self.itemsArray.pop();

self.pushVal();
    },

/**
     * Refreshes the tags so they match the text/value of their corresponding
     * item.
     */
    refresh: function() {
      var self = this;
      $('.tag', self.$container).each(function() {
        var $tag = $(this),
            item = $tag.data('item'),
            itemValue = self.options.itemValue(item),
            itemText = self.options.itemText(item),
            tagClass = self.options.tagClass(item);

// Update tag's class and inner text
          $tag.attr('class', null);
          $tag.addClass('tag ' + htmlEncode(tagClass));
          $tag.contents().filter(function() {
            return this.nodeType == 3;
          })[0].nodeValue = htmlEncode(itemText);

if (self.isSelect) {
            var option = $('option', self.$element).filter(function() { return $(this).data('item') === item; });
            option.attr('value', itemValue);
          }
      });
    },

/**
     * Returns the items added as tags
     */
    items: function() {
      return this.itemsArray;
    },

/**
     * Assembly value by retrieving the value of each item, and set it on the
     * element.
     */
    pushVal: function() {
      var self = this,
          val = $.map(self.items(), function(item) {
            return self.options.itemValue(item).toString();
          });

self.$element.val(val, true).trigger('change');
    },

/**
     * Initializes the tags input behaviour on the element
     */
    build: function(options) {
      var self = this;

self.options = $.extend({}, defaultOptions, options);
      // When itemValue is set, freeInput should always be false
      if (self.objectItems)
        self.options.freeInput = false;

makeOptionItemFunction(self.options, 'itemValue');
      makeOptionItemFunction(self.options, 'itemText');
      makeOptionFunction(self.options, 'tagClass');

// Typeahead Bootstrap version 2.3.2
      if (self.options.typeahead) {
        var typeahead = self.options.typeahead || {};

makeOptionFunction(typeahead, 'source');

self.$input.typeahead($.extend({}, typeahead, {
          source: function (query, process) {
            function processItems(items) {
              var texts = [];

for (var i = 0; i < items.length; i++) {
                var text = self.options.itemText(items[i]);
                map[text] = items[i];
                texts.push(text);
              }
              process(texts);
            }

this.map = {};
            var map = this.map,
                data = typeahead.source(query);

if ($.isFunction(data.success)) {
              // support for Angular callbacks
              data.success(processItems);
            } else if ($.isFunction(data.then)) {
              // support for Angular promises
              data.then(processItems);
            } else {
              // support for functions and jquery promises
              $.when(data)
               .then(processItems);
            }
          },
          updater: function (text) {
            self.add(this.map[text]);
            return this.map[text];
          },
          matcher: function (text) {
            return (text.toLowerCase().indexOf(this.query.trim().toLowerCase()) !== -1);
          },
          sorter: function (texts) {
            return texts.sort();
          },
          highlighter: function (text) {
            var regex = new RegExp( '(' + this.query + ')', 'gi' );
            return text.replace( regex, "<strong>$1</strong>" );
          }
        }));
      }

// typeahead.js
      if (self.options.typeaheadjs) {
          var typeaheadConfig = null;
          var typeaheadDatasets = {};

// Determine if main configurations were passed or simply a dataset
          var typeaheadjs = self.options.typeaheadjs;
          if ($.isArray(typeaheadjs)) {
            typeaheadConfig = typeaheadjs[0];
            typeaheadDatasets = typeaheadjs[1];
          } else {
            typeaheadDatasets = typeaheadjs;
          }

self.$input.typeahead(typeaheadConfig, typeaheadDatasets).on('typeahead:selected', $.proxy(function (obj, datum) {
            if (typeaheadDatasets.valueKey)
              self.add(datum[typeaheadDatasets.valueKey]);
            else
              self.add(datum);
            self.$input.typeahead('val', '');
          }, self));
      }

self.$container.on('click', $.proxy(function(event) {
        if (! self.$element.attr('disabled')) {
          self.$input.removeAttr('disabled');
        }
        self.$input.focus();
      }, self));

if (self.options.addOnBlur && self.options.freeInput) {
          self.$input.on('focusout', $.proxy(function(event) {
              // HACK: only process on focusout when no typeahead opened, to
              //       avoid adding the typeahead text as tag
              if ($('.typeahead, .twitter-typeahead', self.$container).length === 0) {
                self.add(self.$input.val());
                self.$input.val('');
              }
          }, self));
        }

self.$container.on('keydown', 'input', $.proxy(function(event) {
        var $input = $(event.target),
            $inputWrapper = self.findInputWrapper();

if (self.$element.attr('disabled')) {
          self.$input.attr('disabled', 'disabled');
          return;
        }

switch (event.which) {
          // BACKSPACE
          case 8:
            if (doGetCaretPosition($input[0]) === 0) {
              var prev = $inputWrapper.prev();
              if (prev.length) {
                self.remove(prev.data('item'));
              }
            }
            break;

// DELETE
          case 46:
            if (doGetCaretPosition($input[0]) === 0) {
              var next = $inputWrapper.next();
              if (next.length) {
                self.remove(next.data('item'));
              }
            }
            break;

// LEFT ARROW
          case 37:
            // Try to move the input before the previous tag
            var $prevTag = $inputWrapper.prev();
            if ($input.val().length === 0 && $prevTag[0]) {
              $prevTag.before($inputWrapper);
              $input.focus();
            }
            break;
          // RIGHT ARROW
          case 39:
            // Try to move the input after the next tag
            var $nextTag = $inputWrapper.next();
            if ($input.val().length === 0 && $nextTag[0]) {
              $nextTag.after($inputWrapper);
              $input.focus();
            }
            break;
         default:
             // ignore
         }

// Reset internal input's size
        var textLength = $input.val().length,
            wordSpace = Math.ceil(textLength / 5),
            size = textLength + wordSpace + 1;
        $input.attr('size', Math.max(this.inputSize, $input.val().length));
      }, self));

self.$container.on('keypress', 'input', $.proxy(function(event) {
         var $input = $(event.target);

if (self.$element.attr('disabled')) {
            self.$input.attr('disabled', 'disabled');
            return;
         }

var text = $input.val(),
         maxLengthReached = self.options.maxChars && text.length >= self.options.maxChars;
         if (self.options.freeInput && (keyCombinationInList(event, self.options.confirmKeys) || maxLengthReached)) {
            // Only attempt to add a tag if there is data in the field
            if (text.length !== 0) {
               self.add(maxLengthReached ? text.substr(0, self.options.maxChars) : text);
               $input.val('');
            }

// If the field is empty, let the event triggered fire as usual
            if (self.options.cancelConfirmKeysOnEmpty === false) {
                event.preventDefault();
            }
         }

// Reset internal input's size
         var textLength = $input.val().length,
            wordSpace = Math.ceil(textLength / 5),
            size = textLength + wordSpace + 1;
         $input.attr('size', Math.max(this.inputSize, $input.val().length));
      }, self));

// Remove icon clicked
      self.$container.on('click', '[data-role=remove]', $.proxy(function(event) {
        if (self.$element.attr('disabled')) {
          return;
        }
        self.remove($(event.target).closest('.tag').data('item'));
      }, self));

// Only add existing value as tags when using strings as tags
      if (self.options.itemValue === defaultOptions.itemValue) {
        if (self.$element[0].tagName === 'INPUT') {
            self.add(self.$element.val());
        } else {
          $('option', self.$element).each(function() {
            self.add($(this).attr('value'), true);
          });
        }
      }
    },

/**
     * Removes all tagsinput behaviour and unregsiter all event handlers
     */
    destroy: function() {
      var self = this;

// Unbind events
      self.$container.off('keypress', 'input');
      self.$container.off('click', '[role=remove]');

self.$container.remove();
      self.$element.removeData('tagsinput');
      self.$element.show();
    },

/**
     * Sets focus on the tagsinput
     */
    focus: function() {
      this.$input.focus();
    },

/**
     * Returns the internal input element
     */
    input: function() {
      return this.$input;
    },

/**
     * Returns the element which is wrapped around the internal input. This
     * is normally the $container, but typeahead.js moves the $input element.
     */
    findInputWrapper: function() {
      var elt = this.$input[0],
          container = this.$container[0];
      while(elt && elt.parentNode !== container)
        elt = elt.parentNode;

return $(elt);
    }
  };

/**
   * Register JQuery plugin
   */
  $.fn.tagsinput = function(arg1, arg2, arg3) {
    var results = [];

this.each(function() {
      var tagsinput = $(this).data('tagsinput');
      // Initialize a new tags input
      if (!tagsinput) {
          tagsinput = new TagsInput(this, arg1);
          $(this).data('tagsinput', tagsinput);
          results.push(tagsinput);

if (this.tagName === 'SELECT') {
              $('option', $(this)).attr('selected', 'selected');
          }

// Init tags from $(this).val()
          $(this).val($(this).val());
      } else if (!arg1 && !arg2) {
          // tagsinput already exists
          // no function, trying to init
          results.push(tagsinput);
      } else if(tagsinput[arg1] !== undefined) {
          // Invoke function on existing tags input
            if(tagsinput[arg1].length === 3 && arg3 !== undefined){
               var retVal = tagsinput[arg1](arg2, null, arg3);
            }else{
               var retVal = tagsinput[arg1](arg2);
            }
          if (retVal !== undefined)
              results.push(retVal);
      }
    });

if ( typeof arg1 == 'string') {
      // Return the results from the invoked function calls
      return results.length > 1 ? results : results[0];
    } else {
      return results;
    }
  };

$.fn.tagsinput.Constructor = TagsInput;

/**
   * Most options support both a string or number as well as a function as
   * option value. This function makes sure that the option with the given
   * key in the given options is wrapped in a function
   */
  function makeOptionItemFunction(options, key) {
    if (typeof options[key] !== 'function') {
      var propertyName = options[key];
      options[key] = function(item) { return item[propertyName]; };
    }
  }
  function makeOptionFunction(options, key) {
    if (typeof options[key] !== 'function') {
      var value = options[key];
      options[key] = function() { return value; };
    }
  }
  /**
   * HtmlEncodes the given value
   */
  var htmlEncodeContainer = $('<div />');
  function htmlEncode(value) {
    if (value) {
      return htmlEncodeContainer.text(value).html();
    } else {
      return '';
    }
  }

/**
   * Returns the position of the caret in the given input field
   * http://flightschool.acylt.com/devnotes/caret-position-woes/
   */
  function doGetCaretPosition(oField) {
    var iCaretPos = 0;
    if (document.selection) {
      oField.focus ();
      var oSel = document.selection.createRange();
      oSel.moveStart ('character', -oField.value.length);
      iCaretPos = oSel.text.length;
    } else if (oField.selectionStart || oField.selectionStart == '0') {
      iCaretPos = oField.selectionStart;
    }
    return (iCaretPos);
  }

/**
    * Returns boolean indicates whether user has pressed an expected key combination.
    * @param object keyPressEvent: JavaScript event object, refer
    *     http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
    * @param object lookupList: expected key combinations, as in:
    *     [13, {which: 188, shiftKey: true}]
    */
  function keyCombinationInList(keyPressEvent, lookupList) {
      var found = false;
      $.each(lookupList, function (index, keyCombination) {
          if (typeof (keyCombination) === 'number' && keyPressEvent.which === keyCombination) {
              found = true;
              return false;
          }

if (keyPressEvent.which === keyCombination.which) {
              var alt = !keyCombination.hasOwnProperty('altKey') || keyPressEvent.altKey === keyCombination.altKey,
                  shift = !keyCombination.hasOwnProperty('shiftKey') || keyPressEvent.shiftKey === keyCombination.shiftKey,
                  ctrl = !keyCombination.hasOwnProperty('ctrlKey') || keyPressEvent.ctrlKey === keyCombination.ctrlKey;
              if (alt && shift && ctrl) {
                  found = true;
                  return false;
              }
          }
      });

return found;
  }

/**
   * Initialize tagsinput behaviour on inputs and selects which have
   * data-role=tagsinput
   */
  $(function() {
    $("input[data-role=tagsinput], select[multiple][data-role=tagsinput]").tagsinput();
  });
})(window.jQuery);
src/bootstrap-tagsinput-angular.js000064400000005676151676724710013407 0ustar00angular.module('bootstrap-tagsinput', [])
.directive('bootstrapTagsinput', [function() {

function getItemProperty(scope, property) {
    if (!property)
      return undefined;

if (angular.isFunction(scope.$parent[property]))
      return scope.$parent[property];

return function(item) {
      return item[property];
    };
  }

return {
    restrict: 'EA',
    scope: {
      model: '=ngModel'
    },
    template: '<select multiple></select>',
    replace: false,
    link: function(scope, element, attrs) {
      $(function() {
        if (!angular.isArray(scope.model))
          scope.model = [];

var select = $('select', element);
        var typeaheadSourceArray = attrs.typeaheadSource ? attrs.typeaheadSource.split('.') : null;
        var typeaheadSource = typeaheadSourceArray ?
            (typeaheadSourceArray.length > 1 ?
                scope.$parent[typeaheadSourceArray[0]][typeaheadSourceArray[1]]
                : scope.$parent[typeaheadSourceArray[0]])
            : null;

select.tagsinput(scope.$parent[attrs.options || ''] || {
          typeahead : {
            source   : angular.isFunction(typeaheadSource) ? typeaheadSource : null
          },
          itemValue: getItemProperty(scope, attrs.itemvalue),
          itemText : getItemProperty(scope, attrs.itemtext),
          confirmKeys : getItemProperty(scope, attrs.confirmkeys) ? JSON.parse(attrs.confirmkeys) : [13],
          tagClass : angular.isFunction(scope.$parent[attrs.tagclass]) ? scope.$parent[attrs.tagclass] : function(item) { return attrs.tagclass; }
        });

for (var i = 0; i < scope.model.length; i++) {
          select.tagsinput('add', scope.model[i]);
        }

select.on('itemAdded', function(event) {
          if (scope.model.indexOf(event.item) === -1)
            scope.model.push(event.item);
        });

select.on('itemRemoved', function(event) {
          var idx = scope.model.indexOf(event.item);
          if (idx !== -1)
            scope.model.splice(idx, 1);
        });

// create a shallow copy of model's current state, needed to determine
        // diff when model changes
        var prev = scope.model.slice();
        scope.$watch("model", function() {
          var added = scope.model.filter(function(i) {return prev.indexOf(i) === -1;}),
              removed = prev.filter(function(i) {return scope.model.indexOf(i) === -1;}),
              i;

prev = scope.model.slice();

// Remove tags no longer in binded model
          for (i = 0; i < removed.length; i++) {
            select.tagsinput('remove', removed[i]);
          }

// Refresh remaining tags
          select.tagsinput('refresh');

// Add new items in model as tags
          for (i = 0; i < added.length; i++) {
            select.tagsinput('add', added[i]);
          }
        }, true);
      });
    }
  };
}]);
src/bootstrap-tagsinput-typeahead.css000064400000002000151676724710014050 0ustar00.twitter-typeahead .tt-query,
.twitter-typeahead .tt-hint {
    margin-bottom: 0;
}

.twitter-typeahead .tt-hint
{
    display: none;
}

.tt-menu {
    position: absolute;
    top: 100%;
    left: 0;
    z-index: 1000;
    display: none;
    float: left;
    min-width: 160px;
    padding: 5px 0;
    margin: 2px 0 0;
    list-style: none;
    font-size: 14px;
    background-color: #ffffff;
    border: 1px solid #cccccc;
    border: 1px solid rgba(0, 0, 0, 0.15);
    border-radius: 4px;
    -webkit-box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175);
    box-shadow: 0 6px 12px rgba(0, 0, 0, 0.175);
    background-clip: padding-box;
    cursor: pointer;
}

.tt-suggestion {
    display: block;
    padding: 3px 20px;
    clear: both;
    font-weight: normal;
    line-height: 1.428571429;
    color: #333333;
    white-space: nowrap;
}

.tt-suggestion:hover,
.tt-suggestion:focus {
    color: #ffffff;
    text-decoration: none;
    outline: 0;
    background-color: #428bca;
}
src/bootstrap-tagsinput.css000064400000002534151676724710012122 0ustar00.bootstrap-tagsinput {
  background-color: #fff;
  border: 1px solid #ccc;
  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
  display: inline-block;
  padding: 4px 6px;
  color: #555;
  vertical-align: middle;
  border-radius: 4px;
  max-width: 100%;
  line-height: 22px;
  cursor: text;
}
.bootstrap-tagsinput input {
  border: none;
  box-shadow: none;
  outline: none;
  background-color: transparent;
  padding: 0 6px;
  margin: 0;
  width: auto;
  max-width: inherit;
}
.bootstrap-tagsinput.form-control input::-moz-placeholder {
  color: #777;
  opacity: 1;
}
.bootstrap-tagsinput.form-control input:-ms-input-placeholder {
  color: #777;
}
.bootstrap-tagsinput.form-control input::-webkit-input-placeholder {
  color: #777;
}
.bootstrap-tagsinput input:focus {
  border: none;
  box-shadow: none;
}
.bootstrap-tagsinput .tag {
  margin-right: 2px;
  color: white;
}
.bootstrap-tagsinput .tag [data-role="remove"] {
  margin-left: 8px;
  cursor: pointer;
}
.bootstrap-tagsinput .tag [data-role="remove"]:after {
  content: "x";
  padding: 0px 2px;
}
.bootstrap-tagsinput .tag [data-role="remove"]:hover {
  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
}
.bootstrap-tagsinput .tag [data-role="remove"]:hover:active {
  box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
}
package.json000064400000004474151676724710007063 0ustar00{
  "_args": [
    [
      "bootstrap-tagsinput@0.7.1",
      "C:\\Users\\Ovi-PC\\Downloads\\themekit-master\\themekit"
    ]
  ],
  "_from": "bootstrap-tagsinput@0.7.1",
  "_id": "bootstrap-tagsinput@0.7.1",
  "_inBundle": false,
  "_integrity": "sha1-/+Owa74qEGlF7ygUVoAFqU8hGTc=",
  "_location": "/bootstrap-tagsinput",
  "_phantomChildren": {},
  "_requested": {
    "type": "version",
    "registry": true,
    "raw": "bootstrap-tagsinput@0.7.1",
    "name": "bootstrap-tagsinput",
    "escapedName": "bootstrap-tagsinput",
    "rawSpec": "0.7.1",
    "saveSpec": null,
    "fetchSpec": "0.7.1"
  },
  "_requiredBy": [
    "/"
  ],
  "_resolved": "https://registry.npmjs.org/bootstrap-tagsinput/-/bootstrap-tagsinput-0.7.1.tgz",
  "_spec": "0.7.1",
  "_where": "C:\\Users\\Ovi-PC\\Downloads\\themekit-master\\themekit",
  "author": {
    "name": "Tim Schlechter"
  },
  "banner": "/*\n * <%= pkg.name %> v<%= pkg.version %> by <%= pkg.author %>\n * <%= pkg.license.url %>\n */\n",
  "bugs": {
    "url": "https://github.com/timschlechter/bootstrap-tagsinput/issues"
  },
  "contributors": [
    {
      "name": "Luckner Jr Jean-Baptiste"
    }
  ],
  "description": "jQuery plugin providing a Twitter Bootstrap user interface for managing tags.",
  "devDependencies": {
    "bower": "~1.3.8",
    "grunt": "~0.4.1",
    "grunt-bower-task": "~0.4.0",
    "grunt-cli": "~0.1.13",
    "grunt-contrib-copy": "~0.5.0",
    "grunt-contrib-uglify": "^0.9.1",
    "grunt-jquerymanifest": "~0.1.4",
    "grunt-karma": "~0.8.3",
    "grunt-zip": "~0.15.0",
    "karma": "~0.12.19",
    "karma-jasmine": "~0.1.5",
    "karma-phantomjs-launcher": "~0.1.3",
    "phantomjs": "~1.9.7-15"
  },
  "download": "http://timschlechter.github.io/bootstrap-tagsinput/build/bootstrap-tagsinput.zip",
  "homepage": "http://timschlechter.github.io/bootstrap-tagsinput/examples/",
  "keywords": [
    "tags",
    "bootstrap",
    "input",
    "select",
    "form"
  ],
  "license": "MIT",
  "main": "dist/bootstrap-tagsinput.js",
  "name": "bootstrap-tagsinput",
  "repository": {
    "type": "git",
    "url": "git://github.com/timschlechter/bootstrap-tagsinput.git"
  },
  "scripts": {
    "test": "karma start --single-run --no-auto-watch"
  },
  "title": "Bootstrap Tags Input",
  "version": "0.7.1"
}
.travis.yml000064400000000334151676724710006675 0ustar00language: node_js
node_js:
  - 0.10

before_script:
  - export DISPLAY=:99.0
  - sh -e /etc/init.d/xvfb start
  - npm install
  - ./node_modules/.bin/grunt install

script:
  - ./node_modules/.bin/grunt test
test/bootstrap-tagsinput-angular.tests.js000064400000005063151676724710014726 0ustar00describe('bootstrap-tagsinput', function() {

// Load the myApp module, which contains the directive
  beforeEach(module('bootstrap-tagsinput'));
  
  describe("with strings as items" , function() {
    describe("compile with 2 tags in model" , function() {
      var $scope,
          $element;
  
      beforeEach(inject(function($compile, $rootScope){
        $scope = $rootScope;
        $scope.tags = ['Amsterdam', 'New York'];
        $element = $compile(angular.element('<bootstrap-tagsinput ng-model="tags" />'))($scope);
        $scope.$digest();
      }));
      
      it('should hide the element', function() {
        expect($element.is(":visible")).toBe(false);
      });

it('should have 2 tags', function() {
        expect($('.tag', $element).length).toBe(2);
      });
    });
  });

describe("with objects as items" , function() {
    describe("compile with 2 tags in model" , function() {
      var $scope,
          $element;
  
      beforeEach(inject(function($compile, $rootScope){
        $scope = $rootScope;
        $scope.tags = [{ value: 1, text: 'Amsterdam'}, { value: 2, text: 'New York'} ];
        $element = $compile(angular.element('<bootstrap-tagsinput ng-model="tags" itemvalue="value" itemtext="text"/>'))($scope);
        $scope.$digest();
      }));
      
      it('should hide the element', function() {
        expect($element.is(":visible")).toBe(false);
      });

it('should have 2 tags', function() {
        expect($('.tag', $element).length).toBe(2);
      });
      describe("changing a tag's text" , function() {
        beforeEach(function() {
          $scope.tags[0].text = 'Paris';
          $scope.$digest();
        });
        it("should update tag's text", function() {
          expect($('.tag', $element).first().text()).toBe('Paris');
        });
      });

describe("adding an item to the model" , function() {
        beforeEach(function() {
          $scope.tags.push({ value: 3, text: 'Beijing'});
          $scope.$digest();
        });
        it("should add a tag", function() {
          expect($('.tag', $element).length).toBe(3);
        });
      });

describe("BACKSPACE", function() {
        beforeEach(function() {
          $element.tagsinput('focus');
        });

it('after last tag, should remove item from model', function() {
          $('input', $element).trigger($.Event('keydown', { which: 8 }));
          $scope.$digest();
          expect($scope.tags.length).toBe(1);
        });
      });
    });
  });
});test/bootstrap-tagsinput/input_with_object_items.tests.js000064400000010560151676724710020216 0ustar00describe("bootstrap-tagsinput", function() {

describe("with objects as items", function() {
    testTagsInput('<input type="text" />', function() {
      it("adding a item should throw an exception", function() {
        var element = this.$element;
        expect(function() { element.tagsinput('add', {}); }).toThrow("Can't add objects when itemValue option is not set");
      });
    });

testTagsInput('<input type="text" />', { itemValue: function(item) { return item.value; } }, function() {
      describe("adding an item", function() {
        var item;
        beforeEach(function() {
          item = { value: 1 };
          this.$element.tagsinput('add', item);
        });
        it("'items' should return the item", function() {
          expect(this.$element.tagsinput('items')[0]).toBe(item);
        });
        it("val() should return the item's value", function() {
          expect(this.$element.val()).toBe("1");
        });
        it("tag's text should be the item's value", function() {
          expect($('.tag', this.$sandbox).text()).toBe("1");
        });
      });
    });

testTagsInput('<input type="text" />', { itemValue: 'value' }, function() {
      describe("adding an item", function() {
        var item;
        beforeEach(function() {
          item = { value: 1 };
          this.$element.tagsinput('add', item);
        });
        it("'items' should return the item", function() {
          expect(this.$element.tagsinput('items')[0]).toBe(item);
        });
        it("'items' should returns exactly 1 item", function() {
          expect(this.$element.tagsinput('items').length).toBe(1);
        });
        it("val() should return the item's value", function() {
          expect(this.$element.val()).toBe("1");
        });
        it("tag's text should be the item's value", function() {
          expect($('.tag', this.$sandbox).text()).toBe("1");
        });
      });
    });

testTagsInput('<input type="text" />', { itemValue: function(item) { return item.value; }, itemText: function(item) { return item.text; } }, function() {
      describe("adding an item", function() {
        var item = { value: 1, text: 'some' };
        beforeEach(function() {
          this.$element.tagsinput('add', item);
        });
        it("'items' should return the item", function() {
          expect(this.$element.tagsinput('items')[0]).toBe(item);
        });
        it("val() should return the item's value", function() {
          expect(this.$element.val()).toBe("1");
        });
        it("tag's text should be the item's text", function() {
          expect($('.tag', this.$sandbox).text()).toBe("some");
        });

describe("change item and invoke 'refesh'", function() {
          beforeEach(function() {
            item.text = 'changed';
            this.$element.tagsinput('refresh');
          });

it("should update tags's text", function() {
            expect($('.tag', this.$sandbox).text()).toBe('changed');
          });
          it("tag should still have remove button", function() {
            expect($('[data-role=remove]', this.$sandbox)[0]).not.toBeUndefined();
          });
        });
      });
    });
	
    testTagsInput('<input type="text" />', { itemValue: function(item) { return item.value; }, itemText: function(item) { return item.text; }, itemTitle: function(item) { return item.title; } }, function() {
	  describe("adding an item with a title", function() {
        var item;
        beforeEach(function() {
          item = { value: 1, text: 'one', title: 'number one' };
          this.$element.tagsinput('add', item);
        });
        it("'items' should return the item", function() {
          expect(this.$element.tagsinput('items')[0]).toBe(item);
        });
        it("'items' should returns exactly 1 item", function() {
          expect(this.$element.tagsinput('items').length).toBe(1);
        });
        it("val() should return the item's value", function() {
          expect(this.$element.val()).toBe("1");
        });
        it("tag's text should be the item's value", function() {
          expect($('.tag', this.$sandbox).text()).toBe("one");
        });
		it("tag's title should be the item's title", function() {
		  expect($('.tag', this.$sandbox).attr('title')).toBe("number one");
		});
	  });
	});
  });
});test/bootstrap-tagsinput/reproduced_bugs.tests.js000064400000014511151676724710016451 0ustar00describe("bootstrap-tagsinput", function() {

describe("Reproduced bugs", function() {

describe("#1: Demo error", function() {

testTagsInput('<input type="text" value="some_tag" />', function() {
        it("clicking remove button should remove item", function() {
          $('[data-role=remove]', this.$sandbox).trigger('click');
          expect(this.$element.tagsinput('items').length).toBe(0);
        });
        it("clicking remove button should remove tag element", function() {
          $('[data-role=remove]', this.$sandbox).trigger('click');
          expect($('.tag', this.$sandbox).length).toBe(0);
        });
      });
    });

describe("#11: Cannot remove an item by programming", function() {
      testTagsInput('<input type="text" />', { itemValue: function(item) { return item.value; } }, function() {
        describe("add two different objects with same value", function() {
          var item1 = { value: 1 },
              item2 = { value: 1 };

beforeEach(function() {
            this.$element.tagsinput('add', item1);
            this.$element.tagsinput('add', item2);
          });
          it("'items' should return the first added item", function() {
            expect(this.$element.tagsinput('items')[0]).toBe(item1);
          });
          it("'items' should return exactly 1 item", function() {
            expect(this.$element.tagsinput('items').length).toBe(1);
          });
          it("should have exactly 1 tag", function() {
            expect($('.tag', this.$sandbox).length).toBe(1);
          });
        });

describe("remove item", function() {
          beforeEach(function() {
            this.$element.tagsinput('add', { value: 1 });
          });
          it("by value, should remove then item", function() {
            this.$element.tagsinput('remove', 1);
            expect(this.$element.tagsinput('items').length).toBe(0);
          });
          it("by value, should remove then tag", function() {
            this.$element.tagsinput('remove', 1);
            expect($('.tag', this.$sandbox).length).toBe(0);
          });
          it("by different instance, should remove then tag", function() {
            this.$element.tagsinput('remove', { value: 1 });
            expect($('.tag', this.$sandbox).length).toBe(0);
          });
          it("should remove items when none of the items have a matching value", function() {
            this.$element.tagsinput('add', { value: 1 });
            this.$element.tagsinput('remove', 2);
            expect(this.$element.tagsinput('items').length).toBe(1);
          });
        });
      });

testTagsInput('<select />', { itemValue: function(item) { return item.value; } }, function() {
        describe("add two objects", function() {
          var item1 = { value: 1 },
              item2 = { value: 2 };

beforeEach(function() {
            this.$element.tagsinput('add', item1);
            this.$element.tagsinput('add', item2);
          });
          it("'items' should return the last added item", function() {
            expect(this.$element.tagsinput('items')[0]).toBe(item2);
          });
          it("'items' should return exactly 1 item", function() {
            expect(this.$element.tagsinput('items').length).toBe(1);
          });
          it("should have exactly 1 tag", function() {
            expect($('.tag', this.$sandbox).length).toBe(1);
          });
          it("val() should return first item's value", function() {
            expect(this.$element.val()).toBe("2");
          });
        });
      });
    });

describe("#34: Error in ReloadPage", function() {
      describe("init tagsinput with objects as items, but with value set on element", function() {
        testTagsInput('<input type="text" value="1" />', { itemValue: function(item) { return item.value; } }, function() {
          it("should have no tags", function() {
            expect(this.$element.tagsinput('items').length).toBe(0);
          });
        });

testTagsInput('<select><option value="1" /></select>', { itemValue: function(item) { return item.value; } }, function() {
          it("should have no tags", function() {
            expect(this.$element.tagsinput('items').length).toBe(0);
          });
        });
      });
    });

describe("#90: Error in reinitialization (arg1 and arg2 are undefined)", function() {
      describe("init tagsinput twice", function() {
        testTagsInput('<input type="text" value="1" />', { itemValue: function(item) { return item.value; } }, function() {
          it("should not fail if an element is reinitialized", function () {
            this.$element.tagsinput();
          });
          it("should return the original instance if already initialized", function () {
            return this.$element.tagsinput() === this;
          });
        });
      });
    });
    
    describe("#142: Initialization of Null Values for Multi Select field", function() {
      testTagsInput('<select multiple data-role="tagsinput"></select>', function() {
        it("Initializing an empty select shouldn't throw an error.", function() {
            $("select[multiple][data-role=tagsinput]").tagsinput();
        });
      });
    });

describe("#128: Custom classes for tags don't work if entered as strings", function() {
      testTagsInput('<input type="text" value="1" />', { tagClass: 'big' }, function() {
        it("should have a tag with class 'big' when using tagClass option as string", function() {
            expect($(".big", this.$tagsinput).length).toBe(1);
        });
      });

testTagsInput('<input type="text" value="1" />', { tagClass: function() { return 'big'; } }, function() {
        it("should have a tag with class 'big' when using tagClass option as function", function() {
            expect($(".big", this.$tagsinput).length).toBe(1);
        });
      });
    });

describe("#107: Fixed bug when removing items", function() {
      testTagsInput('<input type="text" value="yes,no" />', function() {
        it("should not remove items when remove a non-existing item", function() {
            this.$element.tagsinput('remove', 'maybe');
            expect(this.$element.tagsinput('items').length).toBe(2);
        });
      });
    });
  });
});test/bootstrap-tagsinput/input_with_string_items.tests.js000064400000017114151676724710020260 0ustar00describe("bootstrap-tagsinput", function() {

describe("with strings as items", function() {

testTagsInput('<input type="text" />', { trimValue: true }, function(){
      it("trim item values", function() {
        this.$element.tagsinput('add', ' some_tag  ');
        this.$element.tagsinput('add', 'some_tag  ');
        expect(this.$element.val()).toBe('some_tag');
      });
    });

testTagsInput('<input type="text" />', function() {
      it("should hide input", function() {
        expect(this.$element.css('display')).toBe('none');
      });

it("should add tag on when pressing ENTER", function() {
        this.$tagsinput_input.val('some_tag');
        this.$tagsinput_input.trigger($.Event('keypress', { which: 13 }));
        expect(this.$element.tagsinput('items').length).toBe(1);
      });
	  
      it("should add tag on when pressing COMMA ,", function() {
        this.$tagsinput_input.val('some_tag');
        this.$tagsinput_input.trigger($.Event('keypress', { which: 44 }));
        expect(this.$element.tagsinput('items').length).toBe(1);
      });

describe("should not add tag", function() {
        it("when adding same item twice", function() {
          this.$element.tagsinput('add', 'some_tag');
          this.$element.tagsinput('add', 'some_tag');
          expect(this.$element.val()).toBe('some_tag');
        });

it("when adding empty string", function() {
          this.$element.tagsinput('add', '');
          expect(this.$element.tagsinput('items').length).toBe(0);
        });

it("when adding whitespace string", function() {
          this.$element.tagsinput('add', ' ');
          expect(this.$element.tagsinput('items').length).toBe(0);
        });

it("when adding undefined", function() {
          this.$element.tagsinput('add', undefined);
          expect(this.$element.tagsinput('items').length).toBe(0);
        });

it("when adding null", function() {
          this.$element.tagsinput('add', null);
          expect(this.$element.tagsinput('items').length).toBe(0);
        });
      });

describe("should add tag", function() {
        it("when adding boolean false", function() {
          this.$element.tagsinput('add', false);
          expect(this.$element.tagsinput('items').length).toBe(1);
        });

it("when adding boolean true", function() {
          this.$element.tagsinput('add', false);
          expect(this.$element.tagsinput('items').length).toBe(1);
        });
      });

describe("invoke 'add' with a string", function() {
        beforeEach(function() {
          this.$element.tagsinput('add', 'some_tag');
        });

it("val() should return 'some_tag'", function() {
          expect(this.$element.val()).toBe('some_tag');
        });

it("'items' should return 1 item", function() {
          expect(this.$element.tagsinput('items').length).toBe(1);
        });

describe("invoking 'remove'", function() {

beforeEach(function() {
            this.$element.tagsinput('remove', 'some_tag');
          });

it("val() should should return null", function() {
            expect(this.$element.val()).toBe('');
          });
        });
      });

describe("invoke 'add' with a string containing a comma", function() {
        beforeEach(function() {
          this.$element.tagsinput('add', 'before,after');
        });

it("val() should return 'before,after'", function() {
          expect(this.$element.val()).toBe('before,after');
        });

it("'items' should return 2 items", function() {
          expect(this.$element.tagsinput('items').length).toBe(2);
        });
      });

it("'focus' should place focus in input", function() {
        this.$element.tagsinput('focus');
        expect(hasFocus(this.$tagsinput_input)).toBe(true);
      });
    });

testTagsInput('<input type="text" value="some,tags" />', function() {
      it('should have 2 tags', function() {
        expect(this.$element.tagsinput('items').length).toBe(2);
      });

describe("invoke 'removeAll'", function() {
        beforeEach(function() {
          this.$element.tagsinput('removeAll');
        });

it("should remove both tags", function() {
          expect(this.$element.tagsinput('items').length).toBe(0);
        });

it("val() should return ''", function() {
          expect(this.$element.val()).toBe('');
        });
      });

describe("BACKSPACE", function() {
        beforeEach(function() {
          this.$element.tagsinput('focus');
        });

it('after last tag, should remove the last tag', function() {
          this.$tagsinput_input.trigger($.Event('keydown', { which: 8 }));
          expect(this.$element.tagsinput('items')[0]).toBe('some');
        });

it('after first tag, should remove the first tag', function() {
          this.$tagsinput_input.trigger($.Event('keydown', { which: 37 }));
          this.$tagsinput_input.trigger($.Event('keydown', { which: 8 }));
          expect(this.$element.tagsinput('items')[0]).toBe('tags');
        });
      });

describe("DELETE", function() {
        beforeEach(function() {
          this.$element.tagsinput('focus');
          // move cursor before last tag
          this.$tagsinput_input.trigger($.Event('keydown', { which: 37 }));
        });

it('before last tag, should remove the last tag', function() {
          this.$tagsinput_input.trigger($.Event('keydown', { which: 46 }));
          expect(this.$element.tagsinput('items')[0]).toBe('some');
        });

it('before first tag, should remove the first tag', function() {
          this.$tagsinput_input.trigger($.Event('keydown', { which: 37 }));
            this.$tagsinput_input.trigger($.Event('keydown', { which: 46 }));
          expect(this.$element.tagsinput('items')[0]).toBe('tags');
        });
      });
    });

testTagsInput('<input type="text" value="some,tag"/>', { maxTags: 2 }, function() {
      it("should have class 'bootstrap-tagsinput-max'", function() {
        expect(this.$tagsinput.hasClass('bootstrap-tagsinput-max')).toBe(true);
      });
         
      describe("adding another tag", function() {
        it("should not add the tag", function() {
          this.$element.tagsinput('add', 'another');
          expect(this.$element.tagsinput('items').length).toBe(2);
        });
      });

describe("removing a tags", function() {
        it("should not have class 'bootstrap-tagsinput-max'", function() {
          this.$element.tagsinput('remove', 'some');
          expect(this.$tagsinput.hasClass('bootstrap-tagsinput-max')).toBe(false);
        });
      })
    });

testTagsInput('<input type="text" />', { confirmKeys: [9] }, function() {
      it("should add tag on when pressing TAB", function() {
        this.$tagsinput_input.val('some_tag');
        this.$tagsinput_input.trigger($.Event('keypress', { which: 9 }));
        expect(this.$element.tagsinput('items').length).toBe(1);
      });
    });
  });  
});
test/bootstrap-tagsinput/select_with_string_items.tests.js000064400000002747151676724710020406 0ustar00describe("bootstrap-tagsinput", function() {

describe("with strings as items", function() {

testTagsInput("<select multiple />", function() {

describe("when added 1 item", function() {
        beforeEach(function() {
          this.$element.tagsinput('add', 'some_tag');
        });

it("val() should return array containing 1 item", function() {
          expect(this.$element.val()[0]).toBe('some_tag');
        });

describe("invoking 'remove'", function() {
          beforeEach(function() {
            this.$element.tagsinput('remove', 'some_tag');
          });

it("val() should should return null", function() {
            expect(this.$element.val()).toBeNull();
          });

it("there should be no <option /> elements", function() {
            expect($("option", this.$sandbox).length).toBe(0);
          });
        });
      });

describe("when added item containing a comma", function() {
        beforeEach(function() {
          this.$element.tagsinput('add', 'before,after');
        });

it("val() should return array containing 1 item", function() {
          expect(this.$element.val()[0]).toBe('before,after');
        });
      });
    });

testTagsInput('<select multiple><option value="some">some</option></select>', function() {
      it('should have one tag', function() {
        expect(this.$element.tagsinput('items')[0]).toBe('some');
      });
    });
  });
});test/bootstrap-tagsinput/select_with_object_items.tests.js000064400000002655151676724710020344 0ustar00describe("bootstrap-tagsinput", function() {

describe("with objects as items", function() {
    
    testTagsInput('<select multiple />', { itemValue: function(item) { return item.value; }, itemText: function(item) { return item.text; } }, function() {
      describe("adding an item", function() {
        var item;
        beforeEach(function() {
          item = { value: 1, text: 'some' };
          this.$element.tagsinput('add', item);
        });
        it("'items' should return the item", function() {
          expect(this.$element.tagsinput('items')[0]).toBe(item);
        });
        it("val() should return the item's value", function() {
          expect(this.$element.val()[0]).toBe("1");
        });
        it("tag's text should be the item's text", function() {
          expect($('.tag', this.$sandbox).text()).toBe("some");
        });

describe("change item's value and text and invoke 'refesh'", function() {
          beforeEach(function() {
            item.value = 2;
            item.text = 'changed';
            this.$element.tagsinput('refresh');
          });

it("should update tags's text", function() {
            expect($('.tag', this.$sandbox).text()).toBe('changed');
          });
          it("val() should return item's new value", function() {
            expect(this.$element.val()[0]).toBe("2");
          });
        });
      });
    });
  });
});test/bootstrap-tagsinput/events.tests.js000064400000001447151676724710014605 0ustar00describe("bootstrap-tagsinput", function() {

describe("events", function() {
    testTagsInput('<input type="text" />', function() {
      it("beforeItemAdd canceled", function() {
        this.$element.on('beforeItemAdd', function(event) {
          event.cancel = true;
        });
        this.$element.tagsinput('add', 'some');
        expect(this.$element.tagsinput('items').length).toBe(0);
      });
    });

testTagsInput('<input type="text" value="1" />', function() {
      it("beforeItemRemove canceled", function() {
        this.$element.on('beforeItemRemove', function(event) {
          event.cancel = true;
        });
        this.$element.tagsinput('remove', '1');
        expect(this.$element.tagsinput('items').length).toBe(1);
      });
    });
  });
});
test/index.html000064400000003416151676724710007544 0ustar00<!DOCTYPE html>
<html>
  <head>
    <title>Jasmine Test Runner</title>
    <meta name="robots" content="noindex, nofollow" />
    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    
    <link rel="stylesheet" href="lib/jasmine/lib/jasmine-core/jasmine.css"/>
    
    <script type="text/javascript" src="lib/jquery/dist/jquery.min.js"></script>
    <script type="text/javascript" src="lib/angular/angular.min.js"></script>
    <script type="text/javascript" src="lib/bootstrap/dist/js/bootstrap.min.js"></script>
    <script type="text/javascript" src="lib/jasmine/lib/jasmine-core/jasmine.js"></script>
    <script type="text/javascript" src="lib/jasmine/lib/jasmine-core/jasmine-html.js"></script>
    <script type="text/javascript" src="lib/jasmine/lib/jasmine-core/boot.js"></script>

describe(elementHtml + ' (options: ' + JSON.stringify(options, function(name, value) { return (typeof value === "function") ? value.toString() : value; }) + ')', function() {
   beforeEach(function() {
      this.$sandbox = $('<div />').appendTo($('body'));
      this.$element = $(elementHtml).appendTo(this.$sandbox);
      this.$element.tagsinput(options);
      this.$tagsinput = $('.bootstrap-tagsinput', this.$sandbox);
      this.$tagsinput_input = $('input', this.$tagsinput);
    });

afterEach(function() {

this.$element.tagsinput('destroy');
      this.$sandbox.remove();

delete this.$tagsinput_input;
      delete this.$tagsinput;
      delete this.$sandbox;
      delete this.$element;
    });

tests();
  });
}

function hasFocus($elt) {
  return $elt.get(0) === document.activeElement;
}bootstrap-tagsinput.jquery.json000064400000001243151676724710013026 0ustar00{
  "name": "bootstrap-tagsinput",
  "version": "0.7.1",
  "title": "Bootstrap Tags Input",
  "author": {
    "name": "Tim Schlechter"
  },
  "licenses": [
    {
      "type": "MIT",
      "url": "http://opensource.org/licenses/MIT"
    }
  ],
  "dependencies": {
    "jquery": "*"
  },
  "description": "jQuery plugin providing a Twitter Bootstrap user interface for managing tags.",
  "keywords": [
    "tags",
    "bootstrap",
    "input",
    "select",
    "form"
  ],
  "download": "http://timschlechter.github.io/bootstrap-tagsinput/build/bootstrap-tagsinput.zip",
  "homepage": "http://timschlechter.github.io/bootstrap-tagsinput/examples/"
}LICENSE000064400000002115151676724710005570 0ustar00The MIT License (MIT)

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Gruntfile.js000064400000004236151676724710007066 0ustar00module.exports = function(grunt) {

grunt.loadNpmTasks('grunt-contrib-copy');
  grunt.loadNpmTasks('grunt-contrib-uglify');
  grunt.loadNpmTasks('grunt-karma');
  grunt.loadNpmTasks('grunt-zip');
  grunt.loadNpmTasks('grunt-jquerymanifest');
  grunt.loadNpmTasks('grunt-bower-task');

grunt.initConfig({
    pkg: grunt.file.readJSON('package.json'),
    bower: {
      install: {
        options: {
          targetDir: './lib',
          layout: 'byType',
          install: true,
          verbose: true,
          cleanTargetDir: false,
          cleanBowerDir: true,
          bowerOptions: {
            forceLatest: true
          }
        }
      }
    },
    copy: {
      build: {
        files: [
          { expand: true, flatten: true, src: ['src/*.*'], dest: 'dist/', filter: 'isFile' }
        ]
      }
    },
    uglify: {
      options: {
        banner: '<%= pkg.banner %>',
        sourceMap: 'dist/<%= pkg.name %>.min.js.map',
        sourceMappingURL: '<%= pkg.name %>.min.js.map'
      },
      build: {
        files: {
          'dist/<%= pkg.name %>.min.js': 'src/<%= pkg.name %>.js',
          'dist/<%= pkg.name %>-angular.min.js': 'src/<%= pkg.name %>-angular.js'
        }
      }
    },
    karma: {
      unit: {
        configFile: 'karma.conf.js',
        runnerPort: 9999,
        singleRun: true,
        autoWatch: false,
        browsers: ['PhantomJS']
      }
    },
    zip: {
      delpoy: {
        // cwd: 'dist/',
        src:  [
            'dist/bootstrap-tagsinput*.js',
            'dist/bootstrap-tagsinput*.css',
            'dist/bootstrap-tagsinput*.less',
            'dist/bootstrap-tagsinput*.map'
         ],
        dest:  'dist/<%= pkg.name %>.zip'
      }
    },
    jquerymanifest: {
      options: {
        source: grunt.file.readJSON('package.json'),
        overrides: {
          title: '<%= pkg.title %>'
        }
      }
    }
  });

grunt.registerTask('install', ['bower']);
  grunt.registerTask('compile', ['uglify', 'copy']);
  grunt.registerTask('test', ['compile', 'karma']);
  grunt.registerTask('build', ['test', 'jquerymanifest', 'zip']);
};
dist/bootstrap-tagsinput.js000064400000053635151676724710012132 0ustar00(function ($) {
  "use strict";