first commit

assets/js/plugins/pickers/color/i18n/jquery.spectrum-de.js

@@ -0,0 +1,18 @@
+// Spectrum Colorpicker
+// German (de) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["de"] = {
+        cancelText: "Abbrechen",
+        chooseText: "Wählen",
+        clearText: "Farbauswahl zurücksetzen",
+        noColorSelectedText: "Keine Farbe ausgewählt",
+        togglePaletteMoreText: "Mehr",
+        togglePaletteLessText: "Weniger"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-dk.js

@@ -0,0 +1,14 @@
+// Spectrum Colorpicker
+// Danish (dk) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["dk"] = {
+		cancelText: "annuller",
+		chooseText: "Vælg"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-es.js

@@ -0,0 +1,14 @@
+// Spectrum Colorpicker
+// Spanish (es) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["es"] = {
+        cancelText: "Cancelar",
+        chooseText: "Elegir"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-fa.js

@@ -0,0 +1,14 @@
+// Spectrum Colorpicker
+// Persian (fa) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["fa"] = {
+        cancelText: "لغو",
+        chooseText: "انتخاب"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-fi.js

@@ -0,0 +1,14 @@
+// Spectrum Colorpicker
+// Finnish (fi) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["fi"] = {
+        cancelText: "Kumoa",
+        chooseText: "Valitse"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-fr.js

@@ -0,0 +1,18 @@
+// Spectrum Colorpicker
+// French (fr) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["fr"] = {
+        cancelText: "Annuler",
+        chooseText: "Valider",
+        clearText: "Sélection de la couleur claire",
+        noColorSelectedText: "Aucune couleur sélectionnée",
+        togglePaletteMoreText: "plus",
+        togglePaletteLessText: "moins"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-he.js

@@ -0,0 +1,18 @@
+// Spectrum Colorpicker
+// Hebrew (he) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["he"] = {
+        cancelText: "בטל בחירה",
+        chooseText: "בחר צבע",
+        clearText: "אפס בחירה",
+        noColorSelectedText: "לא נבחר צבע",
+        togglePaletteMoreText: "עוד צבעים",
+        togglePaletteLessText: "פחות צבעים"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-it.js

@@ -0,0 +1,16 @@
+// Spectrum Colorpicker
+// Italian (it) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["it"] = {
+		cancelText: "annulla",
+		chooseText: "scegli",
+		clearText: "Annulla selezione colore",
+		noColorSelectedText: "Nessun colore selezionato"
+	};
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-ja.js

@@ -0,0 +1,14 @@
+// Spectrum Colorpicker
+// Japanese (ja) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["ja"] = {
+        cancelText: "中止",
+        chooseText: "選択"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-nl.js

@@ -0,0 +1,17 @@
+// Spectrum Colorpicker
+// Dutch (nl-nl) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["nl-nl"] = {
+        cancelText: "Annuleer",
+        chooseText: "Kies",
+        clearText: "Wis kleur selectie",
+        togglePaletteMoreText: 'Meer',
+        togglePaletteLessText: 'Minder'
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-pt-br.js

@@ -0,0 +1,14 @@
+// Spectrum Colorpicker
+// Brazilian (pt-br) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["pt-br"] = {
+        cancelText: "Cancelar",
+        chooseText: "Escolher"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-ru.js

@@ -0,0 +1,14 @@
+// Spectrum Colorpicker
+// Russian (ru) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["ru"] = {
+		cancelText: "отмена",
+		chooseText: "выбрать"
+	};
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-sv.js

@@ -0,0 +1,14 @@
+// Spectrum Colorpicker
+// Swedish (sv) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["sv"] = {
+        cancelText: "Avbryt",
+        chooseText: "Välj"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-tr.js

@@ -0,0 +1,14 @@
+// Spectrum Colorpicker
+// Turkish (tr) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["tr"] = {
+		cancelText: "iptal",
+		chooseText: "tamam"
+	};
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/color/i18n/jquery.spectrum-zh-cn.js

@@ -0,0 +1,15 @@
+// Spectrum Colorpicker
+// Simplified Chinese (zh-cn) localization
+// https://github.com/bgrins/spectrum
+
+(function ( $ ) {
+
+    var localization = $.spectrum.localization["zh-cn"] = {
+        cancelText: "取消",
+        chooseText: "选择",
+        clearText: "清除"
+    };
+
+    $.extend($.fn.spectrum.defaults, localization);
+
+})( jQuery );

assets/js/plugins/pickers/location/autocomplete_addresspicker.js

@@ -0,0 +1,310 @@
+/*
+ * jQuery UI addresspicker @VERSION
+ *
+ * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * Depends:
+ *   jquery.ui.core.js
+ *   jquery.ui.widget.js
+ *   jquery.ui.autocomplete.js
+ */
+(function( $, undefined ) {
+
+  $.widget( "ui.addresspicker", {
+    options: {
+        appendAddressString: "",
+        draggableMarker: true,
+        regionBias: null,
+        bounds: '',
+        componentsFilter:'',
+        updateCallback: null,
+        reverseGeocode: false,
+        autocomplete: 'default',
+        language: '',
+        mapOptions: {
+            zoom: 5,
+            center: new google.maps.LatLng(46, 2),
+            scrollwheel: false,
+            mapTypeId: google.maps.MapTypeId.ROADMAP
+        },
+        elements: {
+            map: false,
+            lat: false,
+            lng: false,
+            street_number: false,
+            route: false,
+            locality: false,
+            sublocality: false,
+            administrative_area_level_3: false,
+            administrative_area_level_2: false,
+            administrative_area_level_1: false,
+            country: false,
+            postal_code: false,
+            type: false
+
+        },
+        autocomplete: '' // could be autocomplete: "bootstrap" to use bootstrap typeahead autocomplete instead of jQueryUI
+    },
+
+    marker: function() {
+      return this.gmarker;
+    },
+
+    map: function() {
+      return this.gmap;
+    },
+
+    updatePosition: function() {
+      this._updatePosition(this.gmarker.getPosition());
+    },
+
+    reloadPosition: function() {
+      this.gmarker.setVisible(true);
+      this.gmarker.setPosition(new google.maps.LatLng(this.lat.val, this.lng.val));
+      this.gmap.setCenter(this.gmarker.getPosition());
+    },
+
+    resize: function() {
+      google.maps.event.trigger(this.gmap, 'resize')
+    },
+
+    selected: function() {
+      return this.selectedResult;
+    },
+    _mapped: {},
+    _create: function() {
+      var self = this;
+      this.geocoder = {
+        geocode: function(options, callback)
+        {
+          jQuery.ajax({
+            url: "https://maps.googleapis.com/maps/api/geocode/json?" + jQuery.param(options) + '&sensor=false',
+            type: "GET",
+            success: function(data) {
+              callback(data.results, data.status);
+            }
+          });
+        }
+        //new google.maps.Geocoder();
+      };
+
+      if (this.options.autocomplete === 'bootstrap') {
+          this.element.typeahead({
+            source: function(query, process) {
+                self._mapped = {};
+                var response = function(results) {
+                    var labels = [];
+                    for (var i = 0; i < results.length; i++) {
+                        self._mapped[results[i].label] = results[i];
+                        labels.push(results[i].label);
+                    }
+                    process(labels);
+                };
+                var request = {term: query};
+                self._geocode(request, response);
+            },
+            updater: function(item) {
+                var ui = {item: self._mapped[item]}
+                self._focusAddress(null, ui);
+                self._selectAddress(null, ui);
+                return item;
+            }
+          });
+      } else {
+        this.element.autocomplete($.extend({
+            source: $.proxy(this._geocode, this),
+            focus:  $.proxy(this._focusAddress, this),
+            select: $.proxy(this._selectAddress, this)
+        }), this.options.autocomplete);
+      }
+
+      this.lat      = $(this.options.elements.lat);
+      this.lng      = $(this.options.elements.lng);
+      this.street_number = $(this.options.elements.street_number);
+      this.route = $(this.options.elements.route);
+      this.locality = $(this.options.elements.locality);
+      this.sublocality = $(this.options.elements.sublocality);
+      this.administrative_area_level_3 = $(this.options.elements.administrative_area_level_3);
+      this.administrative_area_level_2 = $(this.options.elements.administrative_area_level_2);
+      this.administrative_area_level_1 = $(this.options.elements.administrative_area_level_1);
+      this.country  = $(this.options.elements.country);
+      this.postal_code = $(this.options.elements.postal_code);
+      this.type     = $(this.options.elements.type);
+      if (this.options.elements.map) {
+        this.mapElement = $(this.options.elements.map);
+        this._initMap();
+      }
+    },
+
+    _initMap: function() {
+      if (this.lat && this.lat.val()) {
+        this.options.mapOptions.center = new google.maps.LatLng(this.lat.val(), this.lng.val());
+      }
+
+      this.gmap = new google.maps.Map(this.mapElement[0], this.options.mapOptions);
+      this.gmarker = new google.maps.Marker({
+        position: this.options.mapOptions.center,
+        map:this.gmap,
+        draggable: this.options.draggableMarker});
+      google.maps.event.addListener(this.gmarker, 'dragend', $.proxy(this._markerMoved, this));
+      this.gmarker.setVisible(false);
+    },
+
+    _updatePosition: function(location) {
+      if (this.lat) {
+        this.lat.val(location.lat());
+      }
+      if (this.lng) {
+        this.lng.val(location.lng());
+      }
+    },
+
+    _addressParts: {street_number: null, route: null, locality: null, sublocality: null,
+                    administrative_area_level_3: null, administrative_area_level_2: null,
+                    administrative_area_level_1: null, country: null, postal_code:null, type: null},
+
+    _updateAddressParts: function(geocodeResult){
+
+      parsedResult = this._parseGeocodeResult(geocodeResult);
+
+      for (addressPart in this._addressParts){
+        if (this[addressPart]){
+          if (parsedResult[addressPart] !== false){
+            this[addressPart].val(parsedResult[addressPart]);
+          } else {
+            this[addressPart].val('');
+          }
+        }
+      }
+    },
+
+    _updateAddressPartsViaReverseGeocode: function(location){
+      this.geocoder.geocode({'latlng': location.lat() + "," + location.lng()}, $.proxy(function(results, status){
+        if (status == google.maps.GeocoderStatus.OK){
+
+          this._updateAddressParts(results[0]);
+          this.element.val(results[0].formatted_address);
+          this.selectedResult = results[0];
+
+          if (this.options.updateCallback) {
+            this.options.updateCallback(this.selectedResult, this._parseGeocodeResult(this.selectedResult));
+          }
+        }
+      }, this));
+    },
+
+    _parseGeocodeResult: function(geocodeResult){
+
+      var parsed = this._parseLatAndLng(geocodeResult.geometry.location);
+
+      for (var addressPart in this._addressParts){
+        parsed[addressPart] = this._findInfo(geocodeResult, addressPart);
+      }
+
+      parsed.type = geocodeResult.types[0];
+
+      return parsed;
+    },
+
+    _parseLatAndLng: function(location){
+      var longitude, latitude;
+
+      if(typeof(location.lat) === 'function'){
+        latitude =  location.lat();
+        longitude = location.lng();
+      } else {
+        latitude = location.lat;
+        longitude = location.lng;
+      }
+
+      return { lat: latitude, lng: longitude };
+    },
+
+    _markerMoved: function() {
+      this._updatePosition(this.gmarker.getPosition());
+
+      if (this.options.reverseGeocode){
+        this._updateAddressPartsViaReverseGeocode(this.gmarker.getPosition());
+      }
+    },
+
+    // Autocomplete source method: fill its suggests with google geocoder results
+    _geocode: function(request, response) {
+        var address = request.term, self = this;
+        this.geocoder.geocode({
+          'language': this.options.language,
+          'address': address + this.options.appendAddressString,
+          'region': this.options.regionBias,
+          'bounds': this.options.bounds,
+          'components': this.options.componentsFilter
+        }, function(results, status) {
+            if (status == google.maps.GeocoderStatus.OK && results) {
+                for (var i = 0; i < results.length; i++) {
+                  result = results[i]
+                  g = result.geometry
+                  g.location = new google.maps.LatLng(g.location.lat, g.location.lng);
+                  g.viewport = new google.maps.LatLngBounds(
+                    new google.maps.LatLng(g.viewport.southwest.lat, g.viewport.southwest.lng),
+                    new google.maps.LatLng(g.viewport.northeast.lat, g.viewport.northeast.lng)
+                  )
+                  result.label =  results[i].formatted_address;
+                }
+            }
+            response(results);
+        })
+    },
+
+    _findInfo: function(result, type) {
+      for (var i = 0; i < result.address_components.length; i++) {
+        var component = result.address_components[i];
+        if (component.types.indexOf(type) !=-1) {
+          return component.long_name;
+        }
+      }
+      return false;
+    },
+
+    _focusAddress: function(event, ui) {
+      var address = ui.item;
+      if (!address) {
+        return;
+      }
+      if (this.gmarker) {
+        this.gmarker.setPosition(address.geometry.location);
+        this.gmarker.setVisible(true);
+        this.gmap.fitBounds(address.geometry.viewport);
+      }
+
+      this._updatePosition(address.geometry.location);
+
+      this._updateAddressParts(address);
+
+    },
+
+    _selectAddress: function(event, ui) {
+      this.selectedResult = ui.item;
+      if (this.options.updateCallback) {
+        this.options.updateCallback(this.selectedResult, this._parseGeocodeResult(this.selectedResult));
+      }
+    }
+  });
+
+  $.extend( $.ui.addresspicker, {
+    version: "@VERSION"
+  });
+
+  // make IE think it doesn't suck
+  if(!Array.indexOf){
+    Array.prototype.indexOf = function(obj){
+      for(var i=0; i<this.length; i++){
+        if(this[i]==obj){
+          return i;
+        }
+      }
+      return -1;
+    }
+  }
+
+})( jQuery );

assets/js/plugins/pickers/location/location.js

@@ -0,0 +1,270 @@
+(function ( $ ) {
+
+    /**
+     * Holds google map object and related utility entities.
+     * @constructor
+     */
+    function GMapContext(domElement, options) {
+        var _map = new google.maps.Map(domElement, options);
+        var _marker = new google.maps.Marker({
+            position: new google.maps.LatLng(54.19335, -3.92695),
+            map: _map,
+            title: "Drag Me",
+            draggable: options.draggable
+        });
+        return {
+            map: _map,
+            marker: _marker,
+            circle: null,
+            location: _marker.position,
+            radius: options.radius,
+            locationName: options.locationName,
+            settings: options.settings,
+            domContainer: domElement,
+            geodecoder: new google.maps.Geocoder()
+        }
+    }
+
+    // Utility functions for Google Map Manipulations
+    var GmUtility = {
+        /**
+         * Draw a circle over the the map. Returns circle object.
+         * Also writes new circle object in gmapContext.
+         *
+         * @param center - LatLng of the center of the circle
+         * @param radius - radius in meters
+         * @param gmapContext - context
+         * @param options
+         */
+        drawCircle: function(gmapContext, center, radius, options) {
+            if (gmapContext.circle != null) {
+                gmapContext.circle.setMap(null);
+            }
+            if (radius > 0) {
+                radius *= 1;
+                options = $.extend({
+                    strokeColor: "#0000FF",
+                    strokeOpacity: 0.35,
+                    strokeWeight: 2,
+                    fillColor: "#0000FF",
+                    fillOpacity: 0.20
+                }, options);
+                options.map = gmapContext.map;
+                options.radius = radius;
+                options.center = center;
+                gmapContext.circle = new google.maps.Circle(options);
+                return gmapContext.circle;
+            }
+            return null;
+        },
+        /**
+         *
+         * @param gMapContext
+         * @param location
+         * @param callback
+         */
+        setPosition: function(gMapContext, location, callback) {
+            gMapContext.location = location;
+            gMapContext.marker.setPosition(location);
+            gMapContext.map.panTo(location);
+            this.drawCircle(gMapContext, location, gMapContext.radius, {});
+            if (gMapContext.settings.enableReverseGeocode) {
+                gMapContext.geodecoder.geocode({latLng: gMapContext.location}, function(results, status){
+                    if (status == google.maps.GeocoderStatus.OK && results.length > 0){
+                        gMapContext.locationName = results[0].formatted_address;
+                    }
+                    if (callback) {
+                        callback.call(this, gMapContext);
+                    }
+                });
+            } else {
+                if (callback) {
+                    callback.call(this, gMapContext);
+                }
+            }
+
+        },
+        locationFromLatLng: function(lnlg) {
+            return {latitude: lnlg.lat(), longitude: lnlg.lng()}
+        }
+    }
+
+    function isPluginApplied(domObj) {
+        return getContextForElement(domObj) != undefined;
+    }
+
+    function getContextForElement(domObj) {
+        return $(domObj).data("locationpicker");
+    }
+
+    function updateInputValues(inputBinding, gmapContext){
+        if (!inputBinding) return;
+        var currentLocation = GmUtility.locationFromLatLng(gmapContext.location);
+        if (inputBinding.latitudeInput) {
+            inputBinding.latitudeInput.val(currentLocation.latitude);
+        }
+        if (inputBinding.longitudeInput) {
+            inputBinding.longitudeInput.val(currentLocation.longitude);
+        }
+        if (inputBinding.radiusInput) {
+            inputBinding.radiusInput.val(gmapContext.radius);
+        }
+        if (inputBinding.locationNameInput) {
+            inputBinding.locationNameInput.val(gmapContext.locationName);
+        }
+    } 
+ 
+    function setupInputListenersInput(inputBinding, gmapContext) {
+        if (inputBinding) {
+            if (inputBinding.radiusInput){
+		          inputBinding.radiusInput.on("change", function() {
+		              gmapContext.radius = $(this).val();
+		              GmUtility.setPosition(gmapContext, gmapContext.location, function(context){
+		              	context.settings.onchanged(GmUtility.locationFromLatLng(context.location), context.radius, false);
+		              });
+		          });
+            }
+            if (inputBinding.locationNameInput && gmapContext.settings.enableAutocomplete) {
+                gmapContext.autocomplete = new google.maps.places.Autocomplete(inputBinding.locationNameInput.get(0));
+                google.maps.event.addListener(gmapContext.autocomplete, 'place_changed', function() {
+                    var place = gmapContext.autocomplete.getPlace();
+                    if (!place.geometry) {
+                        gmapContext.settings.onlocationnotfound(place.name);
+                        return;
+                    }
+                    GmUtility.setPosition(gmapContext, place.geometry.location, function(context) {		                    
+                        updateInputValues(inputBinding, context);
+                        context.settings.onchanged(GmUtility.locationFromLatLng(context.location), context.radius, false);
+                    });
+                });
+            }
+            if (inputBinding.latitudeInput) {
+            	inputBinding.latitudeInput.on("change", function() {
+            		GmUtility.setPosition(gmapContext, new google.maps.LatLng($(this).val(), gmapContext.location.lng()), function(context){
+		              	context.settings.onchanged(GmUtility.locationFromLatLng(context.location), context.radius, false);
+		            });
+            	});
+            }
+            if (inputBinding.longitudeInput) {
+            	inputBinding.longitudeInput.on("change", function() {
+            		GmUtility.setPosition(gmapContext, new google.maps.LatLng(gmapContext.location.lat(), $(this).val()), function(context){
+		              	context.settings.onchanged(GmUtility.locationFromLatLng(context.location), context.radius, false);
+		            });
+            	});
+            }
+        }
+    }
+
+    /**
+     * Initialization:
+     *  $("#myMap").locationpicker(options);
+     * @param options
+     * @param params
+     * @returns {*}
+     */
+    $.fn.locationpicker = function( options, params ) {
+        if (typeof options == 'string') { // Command provided
+            var _targetDomElement = this.get(0);
+            // Plug-in is not applied - nothing to do.
+            if (!isPluginApplied(_targetDomElement)) return;
+            var gmapContext = getContextForElement(_targetDomElement);
+            switch (options) {
+                case "location":
+                    if (params == undefined) { // Getter
+                        var location = GmUtility.locationFromLatLng(gmapContext.location);
+                        location.radius = gmapContext.radius;
+                        location.name = gmapContext.locationName;
+                        return location;
+                    } else { // Setter
+                        if (params.radius) {
+                            gmapContext.radius = params.radius;
+                        }
+                        GmUtility.setPosition(gmapContext, new google.maps.LatLng(params.latitude, params.longitude), function(gmapContext) {
+                            updateInputValues(gmapContext.settings.inputBinding, gmapContext);
+                        });
+                    }
+                    break;
+                case "subscribe":
+                    /**
+                     * Provides interface for subscribing for GoogleMap events.
+                     * See Google API documentation for details.
+                     * Parameters:
+                     * - event: string, name of the event
+                     * - callback: function, callback function to be invoked
+                     */
+                    if (options == undefined) { // Getter is not available
+                        return null;
+                    } else {
+                        var event = params.event;
+                        var callback = params.callback;
+                        if (!event || ! callback) {
+                            console.error("LocationPicker: Invalid arguments for method \"subscribe\"")
+                            return null;
+                        }
+                        google.maps.event.addListener(gmapContext.map, event, callback);
+                    }
+
+                    break;
+            }
+            return null;
+        }
+        return this.each(function() {
+            var $target = $(this);
+            // If plug-in hasn't been applied before - initialize, otherwise - skip
+            if (isPluginApplied(this)) return;
+            // Plug-in initialization is required
+            // Defaults
+            var settings = $.extend({}, $.fn.locationpicker.defaults, options );
+            // Initialize
+            var gmapContext = new GMapContext(this, {
+                zoom: settings.zoom,
+                center: new google.maps.LatLng(settings.location.latitude, settings.location.longitude),
+                mapTypeId: google.maps.MapTypeId.ROADMAP,
+                mapTypeControl: false,
+                disableDoubleClickZoom: false,
+                scrollwheel: settings.scrollwheel,
+                streetViewControl: false,
+                radius: settings.radius,
+                locationName: settings.locationName,
+                settings: settings,
+                draggable: settings.draggable
+            });
+            $target.data("locationpicker", gmapContext);
+            // Subscribe GMap events
+            google.maps.event.addListener(gmapContext.marker, "dragend", function(event) {
+                GmUtility.setPosition(gmapContext, gmapContext.marker.position, function(context){
+                    var currentLocation = GmUtility.locationFromLatLng(gmapContext.location);
+                    context.settings.onchanged(currentLocation, context.radius, true);
+                    updateInputValues(gmapContext.settings.inputBinding, gmapContext);
+                });
+            });
+            GmUtility.setPosition(gmapContext, new google.maps.LatLng(settings.location.latitude, settings.location.longitude), function(context){
+                updateInputValues(settings.inputBinding, gmapContext);
+                context.settings.oninitialized($target);
+            });
+            // Set up input bindings if needed
+            setupInputListenersInput(settings.inputBinding, gmapContext);
+        });
+    };
+    $.fn.locationpicker.defaults = {
+        location: {latitude: 40.7324319, longitude: -73.82480799999996},
+        locationName: "",
+        radius: 500,
+        zoom: 15,
+        scrollwheel: true,
+        inputBinding: {
+            latitudeInput: null,
+            longitudeInput: null,
+            radiusInput: null,
+            locationNameInput: null
+        },
+        enableAutocomplete: false,
+        enableReverseGeocode: true,
+        draggable: true,
+        onchanged: function(currentLocation, radius, isMarkerDropped) {},
+        onlocationnotfound: function(locationName) {},
+        oninitialized: function (component) {}
+
+    }
+
+}( jQuery ));

assets/js/plugins/pickers/location/typeahead_addresspicker.js

@@ -0,0 +1,225 @@
+(function() {
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  (function($) {
+    this.AddressPickerResult = (function() {
+      function AddressPickerResult(placeResult, fromReverseGeocoding) {
+        this.placeResult = placeResult;
+        this.fromReverseGeocoding = fromReverseGeocoding != null ? fromReverseGeocoding : false;
+        this.latitude = this.placeResult.geometry.location.lat();
+        this.longitude = this.placeResult.geometry.location.lng();
+      }
+
+      AddressPickerResult.prototype.addressTypes = function() {
+        var component, type, types, _i, _j, _len, _len1, _ref, _ref1;
+        types = [];
+        _ref = this.addressComponents();
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          component = _ref[_i];
+          _ref1 = component.types;
+          for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+            type = _ref1[_j];
+            if (types.indexOf(type) === -1) {
+              types.push(type);
+            }
+          }
+        }
+        return types;
+      };
+
+      AddressPickerResult.prototype.addressComponents = function() {
+        return this.placeResult.address_components || [];
+      };
+
+      AddressPickerResult.prototype.address = function() {
+        return this.placeResult.formatted_address;
+      };
+
+      AddressPickerResult.prototype.nameForType = function(type, shortName) {
+        var component, _i, _len, _ref;
+        if (shortName == null) {
+          shortName = false;
+        }
+        _ref = this.addressComponents();
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          component = _ref[_i];
+          if (component.types.indexOf(type) !== -1) {
+            return (shortName ? component.short_name : component.long_name);
+          }
+        }
+        return null;
+      };
+
+      AddressPickerResult.prototype.lat = function() {
+        return this.latitude;
+      };
+
+      AddressPickerResult.prototype.lng = function() {
+        return this.longitude;
+      };
+
+      AddressPickerResult.prototype.setLatLng = function(latitude, longitude) {
+        this.latitude = latitude;
+        this.longitude = longitude;
+      };
+
+      AddressPickerResult.prototype.isAccurate = function() {
+        return !this.placeResult.geometry.viewport;
+      };
+
+      AddressPickerResult.prototype.isReverseGeocoding = function() {
+        return this.fromReverseGeocoding;
+      };
+
+      return AddressPickerResult;
+
+    })();
+    return this.AddressPicker = (function(_super) {
+      __extends(AddressPicker, _super);
+
+      function AddressPicker(options) {
+        if (options == null) {
+          options = {};
+        }
+        this.markerDragged = __bind(this.markerDragged, this);
+        this.updateBoundsForPlace = __bind(this.updateBoundsForPlace, this);
+        this.updateMap = __bind(this.updateMap, this);
+        this.options = $.extend({
+          local: [],
+          datumTokenizer: function(d) {
+            return Bloodhound.tokenizers.whitespace(d.num);
+          },
+          queryTokenizer: Bloodhound.tokenizers.whitespace,
+          autocompleteService: {
+            types: ["geocode"]
+          },
+          zoomForLocation: 16,
+          reverseGeocoding: false
+        }, options);
+        AddressPicker.__super__.constructor.call(this, this.options);
+        if (this.options.map) {
+          this.initMap();
+        }
+        this.placeService = new google.maps.places.PlacesService(document.createElement('div'));
+      }
+
+      AddressPicker.prototype.bindDefaultTypeaheadEvent = function(typeahead) {
+        typeahead.bind("typeahead:selected", this.updateMap);
+        return typeahead.bind("typeahead:cursorchanged", this.updateMap);
+      };
+
+      AddressPicker.prototype.initMap = function() {
+        var markerOptions, _ref, _ref1;
+        if ((_ref = this.options) != null ? (_ref1 = _ref.map) != null ? _ref1.gmap : void 0 : void 0) {
+          this.map = this.options.map.gmap;
+        } else {
+          this.mapOptions = $.extend({
+            zoom: 3,
+            center: new google.maps.LatLng(0, 0),
+            mapTypeId: google.maps.MapTypeId.ROADMAP,
+            boundsForLocation: this.updateBoundsForPlace
+          }, this.options.map);
+          this.map = new google.maps.Map($(this.mapOptions.id)[0], this.mapOptions);
+        }
+        this.lastResult = null;
+        markerOptions = $.extend({
+          draggable: true,
+          visible: false,
+          position: this.map.getCenter(),
+          map: this.map
+        }, this.options.marker || {});
+        this.marker = new google.maps.Marker(markerOptions);
+        if (markerOptions.draggable) {
+          return google.maps.event.addListener(this.marker, 'dragend', this.markerDragged);
+        }
+      };
+
+      AddressPicker.prototype.get = function(query, cb) {
+        var service;
+        service = new google.maps.places.AutocompleteService();
+        this.options.autocompleteService.input = query;
+        return service.getPlacePredictions(this.options.autocompleteService, (function(_this) {
+          return function(predictions) {
+            $(_this).trigger('addresspicker:predictions', [predictions]);
+            return cb(predictions);
+          };
+        })(this));
+      };
+
+      AddressPicker.prototype.updateMap = function(event, place) {
+        return this.placeService.getDetails(place, (function(_this) {
+          return function(response) {
+            var _ref;
+            _this.lastResult = new AddressPickerResult(response);
+            if (_this.marker) {
+              _this.marker.setPosition(response.geometry.location);
+              _this.marker.setVisible(true);
+            }
+            if (_this.map) {
+              if ((_ref = _this.mapOptions) != null) {
+                _ref.boundsForLocation(response);
+              }
+            }
+            return $(_this).trigger('addresspicker:selected', _this.lastResult);
+          };
+        })(this));
+      };
+
+      AddressPicker.prototype.updateBoundsForPlace = function(response) {
+        if (response.geometry.viewport) {
+          return this.map.fitBounds(response.geometry.viewport);
+        } else {
+          this.map.setCenter(response.geometry.location);
+          return this.map.setZoom(this.options.zoomForLocation);
+        }
+      };
+
+      AddressPicker.prototype.markerDragged = function() {
+        if (this.options.reverseGeocoding) {
+          return this.reverseGeocode(this.marker.getPosition());
+        } else {
+          if (this.lastResult) {
+            this.lastResult.setLatLng(this.marker.getPosition().lat(), this.marker.getPosition().lng());
+          } else {
+            this.lastResult = new AddressPickerResult({
+              geometry: {
+                location: this.marker.getPosition()
+              }
+            });
+          }
+          return $(this).trigger('addresspicker:selected', this.lastResult);
+        }
+      };
+
+      AddressPicker.prototype.reverseGeocode = function(position) {
+        if (this.geocoder == null) {
+          this.geocoder = new google.maps.Geocoder();
+        }
+        return this.geocoder.geocode({
+          location: position
+        }, (function(_this) {
+          return function(results) {
+            if (results && results.length > 0) {
+              _this.lastResult = new AddressPickerResult(results[0], true);
+              return $(_this).trigger('addresspicker:selected', _this.lastResult);
+            }
+          };
+        })(this));
+      };
+
+      AddressPicker.prototype.getGMap = function() {
+        return this.map;
+      };
+
+      AddressPicker.prototype.getGMarker = function() {
+        return this.marker;
+      };
+
+      return AddressPicker;
+
+    })(Bloodhound);
+  })(jQuery);
+
+}).call(this);

assets/js/plugins/pickers/pickadate/legacy.js

@@ -0,0 +1,133 @@
+
+/*jshint
+   asi: true,
+   unused: true,
+   boss: true,
+   loopfunc: true,
+   eqnull: true
+ */
+
+
+/*!
+ * Legacy browser support
+ */
+
+
+// Map array support
+if ( ![].map ) {
+    Array.prototype.map = function ( callback, self ) {
+        var array = this, len = array.length, newArray = new Array( len )
+        for ( var i = 0; i < len; i++ ) {
+            if ( i in array ) {
+                newArray[ i ] = callback.call( self, array[ i ], i, array )
+            }
+        }
+        return newArray
+    }
+}
+
+
+// Filter array support
+if ( ![].filter ) {
+    Array.prototype.filter = function( callback ) {
+        if ( this == null ) throw new TypeError()
+        var t = Object( this ), len = t.length >>> 0
+        if ( typeof callback != 'function' ) throw new TypeError()
+        var newArray = [], thisp = arguments[ 1 ]
+        for ( var i = 0; i < len; i++ ) {
+          if ( i in t ) {
+            var val = t[ i ]
+            if ( callback.call( thisp, val, i, t ) ) newArray.push( val )
+          }
+        }
+        return newArray
+    }
+}
+
+
+// Index of array support
+if ( ![].indexOf ) {
+    Array.prototype.indexOf = function( searchElement ) {
+        if ( this == null ) throw new TypeError()
+        var t = Object( this ), len = t.length >>> 0
+        if ( len === 0 ) return -1
+        var n = 0
+        if ( arguments.length > 1 ) {
+            n = Number( arguments[ 1 ] )
+            if ( n != n ) {
+                n = 0
+            }
+            else if ( n !== 0 && n != Infinity && n != -Infinity ) {
+                n = ( n > 0 || -1 ) * Math.floor( Math.abs( n ) )
+            }
+        }
+        if ( n >= len ) return -1
+        var k = n >= 0 ? n : Math.max( len - Math.abs( n ), 0 )
+        for ( ; k < len; k++ ) {
+            if ( k in t && t[ k ] === searchElement ) return k
+        }
+        return -1
+    }
+}
+
+
+/*!
+ * Cross-Browser Split 1.1.1
+ * Copyright 2007-2012 Steven Levithan <stevenlevithan.com>
+ * Available under the MIT License
+ * http://blog.stevenlevithan.com/archives/cross-browser-split
+ */
+var nativeSplit = String.prototype.split, compliantExecNpcg = /()??/.exec('')[1] === undefined
+String.prototype.split = function(separator, limit) {
+    var str = this
+    if (Object.prototype.toString.call(separator) !== '[object RegExp]') {
+        return nativeSplit.call(str, separator, limit)
+    }
+    var output = [],
+        flags = (separator.ignoreCase ? 'i' : '') +
+                (separator.multiline  ? 'm' : '') +
+                (separator.extended   ? 'x' : '') +
+                (separator.sticky     ? 'y' : ''),
+        lastLastIndex = 0,
+        separator2, match, lastIndex, lastLength
+    separator = new RegExp(separator.source, flags + 'g')
+    str += ''
+    if (!compliantExecNpcg) {
+        separator2 = new RegExp('^' + separator.source + '$(?!\\s)', flags)
+    }
+    limit = limit === undefined ? -1 >>> 0 : limit >>> 0
+    while (match = separator.exec(str)) {
+        lastIndex = match.index + match[0].length
+        if (lastIndex > lastLastIndex) {
+            output.push(str.slice(lastLastIndex, match.index))
+            if (!compliantExecNpcg && match.length > 1) {
+                match[0].replace(separator2, function () {
+                    for (var i = 1; i < arguments.length - 2; i++) {
+                        if (arguments[i] === undefined) {
+                            match[i] = undefined
+                        }
+                    }
+                })
+            }
+            if (match.length > 1 && match.index < str.length) {
+                Array.prototype.push.apply(output, match.slice(1))
+            }
+            lastLength = match[0].length
+            lastLastIndex = lastIndex
+            if (output.length >= limit) {
+                break
+            }
+        }
+        if (separator.lastIndex === match.index) {
+            separator.lastIndex++
+        }
+    }
+    if (lastLastIndex === str.length) {
+        if (lastLength || !separator.test('')) {
+            output.push('')
+        }
+    } else {
+        output.push(str.slice(lastLastIndex))
+    }
+    return output.length > limit ? output.slice(0, limit) : output
+};

assets/js/plugins/pickers/pickadate/translations/FORMATTING.md

@@ -0,0 +1,7 @@
+### The following convention is used for choosing a format for the translation files:
+
+1. Google for “Microsoft Style Guide LANGUAGE COUNTRY”.
+2. Check the standard suggestions for Long Date Formats.
+3. Set this as the `format` option using [pickadate’s formatting rules](http://amsul.ca/pickadate.js/date.htm#formatting-rules).
+
+Make sure `formatSubmit` is always `yyyy/mm/dd` to ensure our servers always get the value formatted the same.

assets/js/plugins/pickers/pickadate/translations/NAMING.md

@@ -0,0 +1,21 @@
+### The following convention is used for naming the translation files:
+
+```
+LANGUAGE_COUNTRY.js
+```
+
+#### Where:
+
+```
+LANGUAGE = The lowercase ISO 639-1 language code.
+```
+
+> See http://en.wikipedia.org/wiki/List_of_ISO_639-1_codes
+
+```
+COUNTRY = The uppercase ISO 3166-1 country code.
+```
+
+> See http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements
+
+When there is no `COUNTRY` in the filename, it is assumed the generic language is used in multiple countries.

assets/js/plugins/pickers/pickadate/translations/ar.js

@@ -0,0 +1,12 @@
+// Arabic
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'يناير', 'فبراير', 'مارس', 'ابريل', 'مايو', 'يونيو', 'يوليو', 'اغسطس', 'سبتمبر', 'اكتوبر', 'نوفمبر', 'ديسمبر' ],
+    monthsShort: [ 'يناير', 'فبراير', 'مارس', 'ابريل', 'مايو', 'يونيو', 'يوليو', 'اغسطس', 'سبتمبر', 'اكتوبر', 'نوفمبر', 'ديسمبر' ],
+    weekdaysFull: [ 'الاحد', 'الاثنين', 'الثلاثاء', 'الاربعاء', 'الخميس', 'الجمعة', 'السبت' ],
+    weekdaysShort: [ 'الاحد', 'الاثنين', 'الثلاثاء', 'الاربعاء', 'الخميس', 'الجمعة', 'السبت' ],
+    today: 'اليوم',
+    clear: 'مسح',
+    format: 'yyyy mmmm dd',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/bg_BG.js

@@ -0,0 +1,13 @@
+// Bulgarian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'януари','февруари','март','април','май','юни','юли','август','септември','октомври','ноември','декември' ],
+    monthsShort: [ 'янр','фев','мар','апр','май','юни','юли','авг','сеп','окт','ное','дек' ],
+    weekdaysFull: [ 'неделя', 'понеделник', 'вторник', 'сряда', 'четвъртък', 'петък', 'събота' ],
+    weekdaysShort: [ 'нд', 'пн', 'вт', 'ср', 'чт', 'пт', 'сб' ],
+    today: 'днес',
+    clear: 'изтривам',
+    firstDay: 1,
+    format: 'd mmmm yyyy г.',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/bs_BA.js

@@ -0,0 +1,13 @@
+// Bosnian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'januar', 'februar', 'mart', 'april', 'maj', 'juni', 'juli', 'august', 'septembar', 'oktobar', 'novembar', 'decembar' ],
+    monthsShort: [ 'jan', 'feb', 'mar', 'apr', 'maj', 'jun', 'jul', 'aug', 'sep', 'okt', 'nov', 'dec' ],
+    weekdaysFull: [ 'nedjelja', 'ponedjeljak', 'utorak', 'srijeda', 'cetvrtak', 'petak', 'subota' ],
+    weekdaysShort: [ 'ne', 'po', 'ut', 'sr', 'če', 'pe', 'su' ],
+    today: 'danas',
+    clear: 'izbrisati',
+    firstDay: 1,
+    format: 'dd. mmmm yyyy.',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/ca_ES.js

@@ -0,0 +1,13 @@
+// Catalan
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'Gener', 'Febrer', 'Març', 'Abril', 'Maig', 'juny', 'Juliol', 'Agost', 'Setembre', 'Octubre', 'Novembre', 'Desembre' ],
+    monthsShort: [ 'Gen', 'Feb', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Oct', 'Nov', 'Des' ],
+    weekdaysFull: [ 'diumenge', 'dilluns', 'dimarts', 'dimecres', 'dijous', 'divendres', 'dissabte' ],
+    weekdaysShort: [ 'diu', 'dil', 'dim', 'dmc', 'dij', 'div', 'dis' ],
+    today: 'avui',
+    clear: 'esborrar',
+    firstDay: 1,
+    format: 'dddd d !de mmmm !de yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/cs_CZ.js

@@ -0,0 +1,13 @@
+// Czech
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'leden', 'únor', 'březen', 'duben', 'květen', 'červen', 'červenec', 'srpen', 'září', 'říjen', 'listopad', 'prosinec' ],
+    monthsShort: [ 'led', 'úno', 'bře', 'dub', 'kvě', 'čer', 'čvc', 'srp', 'zář', 'říj', 'lis', 'pro' ],
+    weekdaysFull: [ 'neděle', 'pondělí', 'úterý', 'středa', 'čtvrtek', 'pátek', 'sobota' ],
+    weekdaysShort: [ 'ne', 'po', 'út', 'st', 'čt', 'pá', 'so' ],
+    today: 'dnes',
+    clear: 'vymazat',
+    firstDay: 1,
+    format: 'd. mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/da_DK.js

@@ -0,0 +1,13 @@
+// Danish
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'januar', 'februar', 'marts', 'april', 'maj', 'juni', 'juli', 'august', 'september', 'oktober', 'november', 'december' ],
+    monthsShort: [ 'jan', 'feb', 'mar', 'apr', 'maj', 'jun', 'jul', 'aug', 'sep', 'okt', 'nov', 'dec' ],
+    weekdaysFull: [ 'søndag', 'mandag', 'tirsdag', 'onsdag', 'torsdag', 'fredag', 'lørdag' ],
+    weekdaysShort: [ 'søn', 'man', 'tir', 'ons', 'tor', 'fre', 'lør' ],
+    today: 'i dag',
+    clear: 'slet',
+    firstDay: 1,
+    format: 'd. mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/de_DE.js

@@ -0,0 +1,13 @@
+// German
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'Januar', 'Februar', 'März', 'April', 'Mai', 'Juni', 'Juli', 'August', 'September', 'Oktober', 'November', 'Dezember' ],
+    monthsShort: [ 'Jan', 'Feb', 'Mär', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dez' ],
+    weekdaysFull: [ 'Sonntag', 'Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag', 'Samstag' ],
+    weekdaysShort: [ 'So', 'Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa' ],
+    today: 'Heute',
+    clear: 'Löschen',
+    firstDay: 1,
+    format: 'dddd, dd. mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/el_GR.js

@@ -0,0 +1,13 @@
+// Greek
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'Ιανουάριος', 'Φεβρουάριος', 'Μάρτιος', 'Απρίλιος', 'Μάιος', 'Ιούνιος', 'Ιούλιος', 'Αύγουστος', 'Σεπτέμβριος', 'Οκτώβριος', 'Νοέμβριος', 'Δεκέμβριος' ],
+    monthsShort: [ 'Ιαν', 'Φεβ', 'Μαρ', 'Απρ', 'Μαι', 'Ιουν', 'Ιουλ', 'Αυγ', 'Σεπ', 'Οκτ', 'Νοε', 'Δεκ' ],
+    weekdaysFull: [ 'Κυριακή', 'Δευτέρα', 'Τρίτη', 'Τετάρτη', 'Πέμπτη', 'Παρασκευή', 'Σάββατο' ],
+    weekdaysShort: [ 'Κυρ', 'Δευ', 'Τρι', 'Τετ', 'Πεμ', 'Παρ', 'Σαβ' ],
+    today: 'σήμερα',
+    clear: 'Διαγραφή',
+    firstDay: 1,
+    format: 'd mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/es_ES.js

@@ -0,0 +1,13 @@
+// Spanish
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre' ],
+    monthsShort: [ 'ene', 'feb', 'mar', 'abr', 'may', 'jun', 'jul', 'ago', 'sep', 'oct', 'nov', 'dic' ],
+    weekdaysFull: [ 'domingo', 'lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado' ],
+    weekdaysShort: [ 'dom', 'lun', 'mar', 'mié', 'jue', 'vie', 'sáb' ],
+    today: 'hoy',
+    clear: 'borrar',
+    firstDay: 1,
+    format: 'dddd d !de mmmm !de yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/et_EE.js

@@ -0,0 +1,13 @@
+// Estonian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'jaanuar', 'veebruar', 'märts', 'aprill', 'mai', 'juuni', 'juuli', 'august', 'september', 'oktoober', 'november', 'detsember' ],
+    monthsShort: [ 'jaan', 'veebr', 'märts', 'apr', 'mai', 'juuni', 'juuli', 'aug', 'sept', 'okt', 'nov', 'dets' ],
+    weekdaysFull: [ 'pühapäev', 'esmaspäev', 'teisipäev', 'kolmapäev', 'neljapäev', 'reede', 'laupäev' ],
+    weekdaysShort: [ 'püh', 'esm', 'tei', 'kol', 'nel', 'ree', 'lau' ],
+    today: 'täna',
+    clear: 'kustutama',
+    firstDay: 1,
+    format: 'd. mmmm yyyy. a',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/eu_ES.js

@@ -0,0 +1,13 @@
+// Basque
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'urtarrila', 'otsaila', 'martxoa', 'apirila', 'maiatza', 'ekaina', 'uztaila', 'abuztua', 'iraila', 'urria', 'azaroa', 'abendua' ],
+    monthsShort: [ 'urt', 'ots', 'mar', 'api', 'mai', 'eka', 'uzt', 'abu', 'ira', 'urr', 'aza', 'abe' ],
+    weekdaysFull: [ 'igandea', 'astelehena', 'asteartea', 'asteazkena', 'osteguna', 'ostirala', 'larunbata' ],
+    weekdaysShort: [ 'ig.', 'al.', 'ar.', 'az.', 'og.', 'or.', 'lr.' ],
+    today: 'gaur',
+    clear: 'garbitu',
+    firstDay: 1,
+    format: 'dddd, yyyy(e)ko mmmmren da',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/fi_FI.js

@@ -0,0 +1,13 @@
+// Finnish
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'tammikuu', 'helmikuu', 'maaliskuu', 'huhtikuu', 'toukokuu', 'kesäkuu', 'heinäkuu', 'elokuu', 'syyskuu', 'lokakuu', 'marraskuu', 'joulukuu' ],
+    monthsShort: [ 'tammi', 'helmi', 'maalis', 'huhti', 'touko', 'kesä', 'heinä', 'elo', 'syys', 'loka', 'marras', 'joulu' ],
+    weekdaysFull: [ 'sunnuntai', 'maanantai', 'tiistai', 'keskiviikko', 'torstai', 'perjantai', 'lauantai' ],
+    weekdaysShort: [ 'su', 'ma', 'ti', 'ke', 'to', 'pe', 'la' ],
+    today: 'tänään',
+    clear: 'tyhjennä',
+    firstDay: 1,
+    format: 'd.m.yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/fr_FR.js

@@ -0,0 +1,17 @@
+// French
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre' ],
+    monthsShort: [ 'Jan', 'Fev', 'Mar', 'Avr', 'Mai', 'Juin', 'Juil', 'Aou', 'Sep', 'Oct', 'Nov', 'Dec' ],
+    weekdaysFull: [ 'Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi' ],
+    weekdaysShort: [ 'Dim', 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam' ],
+    today: 'Aujourd\'hui',
+    clear: 'Effacer',
+    firstDay: 1,
+    format: 'dd mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd',
+    labelMonthNext: 'Mois suivant',
+    labelMonthPrev: 'Mois précédent',
+    labelMonthSelect: 'Sélectionner un mois',
+    labelYearSelect: 'Sélectionner une année'
+});

assets/js/plugins/pickers/pickadate/translations/gl_ES.js

@@ -0,0 +1,13 @@
+// Galician
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'Xaneiro', 'Febreiro', 'Marzo', 'Abril', 'Maio', 'Xuño', 'Xullo', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Decembro' ],
+    monthsShort: [ 'xan', 'feb', 'mar', 'abr', 'mai', 'xun', 'xul', 'ago', 'sep', 'out', 'nov', 'dec' ],
+    weekdaysFull: [ 'domingo', 'luns', 'martes', 'mércores', 'xoves', 'venres', 'sábado' ],
+    weekdaysShort: [ 'dom', 'lun', 'mar', 'mér', 'xov', 'ven', 'sab' ],
+    today: 'hoxe',
+    clear: 'borrar',
+    firstDay: 1,
+    format: 'dddd d !de mmmm !de yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/he_IL.js

@@ -0,0 +1,12 @@
+// Hebrew
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'ינואר', 'פברואר', 'מרץ', 'אפריל', 'מאי', 'יוני', 'יולי', 'אוגוסט', 'ספטמבר', 'אוקטובר', 'נובמבר', 'דצמבר' ],
+    monthsShort: [ 'ינו', 'פבר', 'מרץ', 'אפר', 'מאי', 'יונ', 'יול', 'אוג', 'ספט', 'אוק', 'נוב', 'דצמ' ],
+    weekdaysFull: [ 'יום ראשון', 'יום שני', 'יום שלישי', 'יום רביעי', 'יום חמישי', 'יום ששי', 'יום שבת' ],
+    weekdaysShort: [ 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ש' ],
+    today: 'היום',
+    clear: 'למחוק',
+    format: 'yyyy mmmmב d dddd',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/hr_HR.js

@@ -0,0 +1,13 @@
+// Croatian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'sijećanj', 'veljača', 'ožujak', 'travanj', 'svibanj', 'lipanj', 'srpanj', 'kolovoz', 'rujan', 'listopad', 'studeni', 'prosinac' ],
+    monthsShort: [ 'sij', 'velj', 'ožu', 'tra', 'svi', 'lip', 'srp', 'kol', 'ruj', 'lis', 'stu', 'pro' ],
+    weekdaysFull: [ 'nedjelja', 'ponedjeljak', 'utorak', 'srijeda', 'četvrtak', 'petak', 'subota' ],
+    weekdaysShort: [ 'ned', 'pon', 'uto', 'sri', 'čet', 'pet', 'sub' ],
+    today: 'danas',
+    clear: 'izbrisati',
+    firstDay: 1,
+    format: 'd. mmmm yyyy.',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/hu_HU.js

@@ -0,0 +1,13 @@
+// Hungarian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'január', 'február', 'március', 'április', 'május', 'június', 'július', 'augusztus', 'szeptember', 'október', 'november', 'december' ],
+    monthsShort: [ 'jan', 'febr', 'márc', 'ápr', 'máj', 'jún', 'júl', 'aug', 'szept', 'okt', 'nov', 'dec' ],
+    weekdaysFull: [ 'vasárnap', 'hétfő', 'kedd', 'szerda', 'csütörtök', 'péntek', 'szombat' ],
+    weekdaysShort: [ 'V', 'H', 'K', 'SZe', 'CS', 'P', 'SZo' ],
+    today: 'Ma',
+    clear: 'Törlés',
+    firstDay: 1,
+    format: 'yyyy. mmmm dd.',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/id_ID.js

@@ -0,0 +1,13 @@
+// Indonesian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'Januari', 'Februari', 'Maret', 'April', 'Mei', 'Juni', 'Juli', 'Agustus', 'September', 'Oktober', 'November', 'Desember' ],
+    monthsShort: [ 'Jan', 'Feb', 'Mar', 'Apr', 'Mei', 'Jun', 'Jul', 'Agu', 'Sep', 'Okt', 'Nov', 'Des' ],
+    weekdaysFull: [ 'Minggu', 'Senin', 'Selasa', 'Rabu', 'Kamis', 'Jumat', 'Sabtu' ],
+    weekdaysShort: [ 'Min', 'Sen', 'Sel', 'Rab', 'Kam', 'Jum', 'Sab' ],
+    today: 'hari ini',
+    clear: 'menghapus',
+    firstDay: 1,
+    format: 'd mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/is_IS.js

@@ -0,0 +1,13 @@
+// Icelandic
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'janúar', 'febrúar', 'mars', 'apríl', 'maí', 'júní', 'júlí', 'ágúst', 'september', 'október', 'nóvember', 'desember' ],
+    monthsShort: [ 'jan', 'feb', 'mar', 'apr', 'maí', 'jún', 'júl', 'ágú', 'sep', 'okt', 'nóv', 'des' ],
+    weekdaysFull: [ 'sunnudagur', 'mánudagur', 'þriðjudagur', 'miðvikudagur', 'fimmtudagur', 'föstudagur', 'laugardagur' ],
+    weekdaysShort: [ 'sun', 'mán', 'þri', 'mið', 'fim', 'fös', 'lau' ],
+    today: 'Í dag',
+    clear: 'Hreinsa',
+    firstDay: 1,
+    format: 'dd. mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/it_IT.js

@@ -0,0 +1,13 @@
+// Italian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'gennaio', 'febbraio', 'marzo', 'aprile', 'maggio', 'giugno', 'luglio', 'agosto', 'settembre', 'ottobre', 'novembre', 'dicembre' ],
+    monthsShort: [ 'gen', 'feb', 'mar', 'apr', 'mag', 'giu', 'lug', 'ago', 'set', 'ott', 'nov', 'dic' ],
+    weekdaysFull: [ 'domenica', 'lunedì', 'martedì', 'mercoledì', 'giovedì', 'venerdì', 'sabato' ],
+    weekdaysShort: [ 'dom', 'lun', 'mar', 'mer', 'gio', 'ven', 'sab' ],
+    today: 'oggi',
+    clear: 'cancellare',
+    firstDay: 1,
+    format: 'dddd d mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/ja_JP.js

@@ -0,0 +1,13 @@
+// Japanese
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ '1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月' ],
+    monthsShort: [ '1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月' ],
+    weekdaysFull: [ '日曜日', '月曜日', '火曜日', '水曜日', '木曜日', '金曜日', '土曜日' ],
+    weekdaysShort: [ '日曜日', '月曜日', '火曜日', '水曜日', '木曜日', '金曜日', '土曜日' ],
+    today: '今日',
+    clear: '消去',
+    firstDay: 1,
+    format: 'yyyy mm dd',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/ko_KR.js

@@ -0,0 +1,13 @@
+// Korean
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ '1월', '2월', '3월', '4월', '5월', '6월', '7월', '8월', '9월', '10월', '11월', '12월' ],
+    monthsShort: [ '1월', '2월', '3월', '4월', '5월', '6월', '7월', '8월', '9월', '10월', '11월', '12월' ],
+    weekdaysFull: [ '일요일', '월요일', '화요일', '수요일', '목요일', '금요일', '토요일' ],
+    weekdaysShort: [ '일', '월', '화', '수', '목', '금', '토' ],
+    today: '오늘',
+    clear: '취소',
+    firstDay: 1,
+    format: 'yyyy 년 mm 월 dd 일',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/ne_NP.js

@@ -0,0 +1,13 @@
+// Nepali
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'जनवरी', 'फेब्रुअरी', 'मार्च', 'अप्रिल', 'मे', 'जुन', 'जुलाई', 'अगस्त', 'सेप्टेम्बर', 'अक्टोबर', 'नोवेम्बर', 'डिसेम्बर' ],
+    monthsShort: [ 'जन', 'फेब्रु', 'मार्च', 'अप्रिल', 'मे', 'जुन', 'जुल', 'अग', 'सेप्टे', 'अक्टो', 'नोभे', 'डिसे' ],
+    weekdaysFull: [ 'सोमबार', 'मङ्लबार', 'बुधबार', 'बिहीबार', 'शुक्रबार', 'शनिबार', 'आईतबार' ],
+    weekdaysShort: [ 'सोम', 'मंगल्', 'बुध', 'बिही', 'शुक्र', 'शनि', 'आईत' ],
+    numbers: [ '०', '१', '२', '३', '४', '५', '६', '७', '८', '९' ],
+    today: 'आज',
+    clear: 'मेटाउनुहोस्',
+    format: 'dddd, dd mmmm, yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/nl_NL.js

@@ -0,0 +1,13 @@
+// Dutch
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'januari', 'februari', 'maart', 'april', 'mei', 'juni', 'juli', 'augustus', 'september', 'oktober', 'november', 'december' ],
+    monthsShort: [ 'jan', 'feb', 'maa', 'apr', 'mei', 'jun', 'jul', 'aug', 'sep', 'okt', 'nov', 'dec' ],
+    weekdaysFull: [ 'zondag', 'maandag', 'dinsdag', 'woensdag', 'donderdag', 'vrijdag', 'zaterdag' ],
+    weekdaysShort: [ 'zo', 'ma', 'di', 'wo', 'do', 'vr', 'za' ],
+    today: 'vandaag',
+    clear: 'verwijderen',
+    firstDay: 1,
+    format: 'dddd d mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/no_NO.js

@@ -0,0 +1,13 @@
+// Norwegian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'januar', 'februar', 'mars', 'april', 'mai', 'juni', 'juli', 'august', 'september', 'oktober', 'november', 'desember' ],
+    monthsShort: [ 'jan', 'feb', 'mar', 'apr', 'mai', 'jun', 'jul', 'aug', 'sep', 'okt', 'nov', 'des' ],
+    weekdaysFull: [ 'søndag', 'mandag', 'tirsdag', 'onsdag', 'torsdag', 'fredag', 'lørdag' ],
+    weekdaysShort: [ 'søn','man','tir', 'ons', 'tor', 'fre', 'lør' ],
+    today: 'i dag',
+    clear: 'nullstill',
+    firstDay: 1,
+    format: 'dd. mmm. yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/pl_PL.js

@@ -0,0 +1,13 @@
+// Polish
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'styczeń', 'luty', 'marzec', 'kwiecień', 'maj', 'czerwiec', 'lipiec', 'sierpień', 'wrzesień', 'październik', 'listopad', 'grudzień' ],
+    monthsShort: [ 'sty', 'lut', 'mar', 'kwi', 'maj', 'cze', 'lip', 'sie', 'wrz', 'paź', 'lis', 'gru' ],
+    weekdaysFull: [ 'niedziela', 'poniedziałek', 'wtorek', 'środa', 'czwartek', 'piątek', 'sobota' ],
+    weekdaysShort: [ 'N', 'Pn', 'Wt', 'Śr', 'Cz', 'Pt', 'So' ],
+    today: 'dzisiaj',
+    clear: 'usunąć',
+    firstDay: 1,
+    format: 'd mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/pt_BR.js

@@ -0,0 +1,12 @@
+// Brazilian Portuguese
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'janeiro', 'fevereiro', 'março', 'abril', 'maio', 'junho', 'julho', 'agosto', 'setembro', 'outubro', 'novembro', 'dezembro' ],
+    monthsShort: [ 'jan', 'fev', 'mar', 'abr', 'mai', 'jun', 'jul', 'ago', 'set', 'out', 'nov', 'dez' ],
+    weekdaysFull: [ 'domingo', 'segunda-feira', 'terça-feira', 'quarta-feira', 'quinta-feira', 'sexta-feira', 'sábado' ],
+    weekdaysShort: [ 'dom', 'seg', 'ter', 'qua', 'qui', 'sex', 'sab' ],
+    today: 'hoje',
+    clear: 'excluir',
+    format: 'dddd, d !de mmmm !de yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/pt_PT.js

@@ -0,0 +1,12 @@
+// Portuguese
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'janeiro', 'fevereiro', 'março', 'abril', 'maio', 'junho', 'julho', 'agosto', 'setembro', 'outubro', 'novembro', 'dezembro' ],
+    monthsShort: [ 'jan', 'fev', 'mar', 'abr', 'mai', 'jun', 'jul', 'ago', 'set', 'out', 'nov', 'dez' ],
+    weekdaysFull: [ 'domingo', 'segunda', 'terça', 'quarta', 'quinta', 'sexta', 'sábado' ],
+    weekdaysShort: [ 'dom', 'seg', 'ter', 'qua', 'qui', 'sex', 'sab' ],
+    today: 'hoje',
+    clear: 'excluir',
+    format: 'd !de mmmm !de yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/ro_RO.js

@@ -0,0 +1,13 @@
+// Romanian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'ianuarie', 'februarie', 'martie', 'aprilie', 'mai', 'iunie', 'iulie', 'august', 'septembrie', 'octombrie', 'noiembrie', 'decembrie' ],
+    monthsShort: [ 'ian', 'feb', 'mar', 'apr', 'mai', 'iun', 'iul', 'aug', 'sep', 'oct', 'noi', 'dec' ],
+    weekdaysFull: [ 'duminică', 'luni', 'marţi', 'miercuri', 'joi', 'vineri', 'sâmbătă' ],
+    weekdaysShort: [ 'D', 'L', 'Ma', 'Mi', 'J', 'V', 'S' ],
+    today: 'azi',
+    clear: 'șterge',
+    firstDay: 1,
+    format: 'dd mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/ru_RU.js

@@ -0,0 +1,13 @@
+// Russian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'Января', 'Февраля', 'Марта', 'Апреля', 'Мая', 'Июня', 'Июля', 'Августа', 'Сентября', 'Октября', 'Ноября', 'Декабря' ],
+    monthsShort: [ 'Янв', 'Фев', 'Мар', 'Апр', 'Май', 'Июн', 'Июл', 'Авг', 'Сен', 'Окт', 'Ноя', 'Дек' ],
+    weekdaysFull: [ 'воскресенье', 'понедельник', 'вторник', 'среда', 'четверг', 'пятница', 'суббота' ],
+    weekdaysShort: [ 'вс', 'пн', 'вт', 'ср', 'чт', 'пт', 'сб' ],
+    today: 'сегодня',
+    clear: 'удалить',
+    firstDay: 1,
+    format: 'd mmmm yyyy г.',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/sk_SK.js

@@ -0,0 +1,13 @@
+// Slovak
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'január', 'február', 'marec', 'apríl', 'máj', 'jún', 'júl', 'august', 'september', 'október', 'november', 'december' ],
+    monthsShort: [ 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X', 'XI', 'XII' ],
+    weekdaysFull: [ 'nedeļľa', 'pondelok', 'utorok', 'streda', 'š̌švrtok', 'piatok', 'sobota' ],
+    weekdaysShort: [ 'Ne', 'Po', 'Ut', 'St', 'Št', 'Pi', 'So' ],
+    today: 'dnes',
+    clear: 'vymazať',
+    firstDay: 1,
+    format: 'd. mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/sl_SI.js

@@ -0,0 +1,13 @@
+// Slovenian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'januar', 'februar', 'marec', 'april', 'maj', 'junij', 'julij', 'avgust', 'september', 'oktober', 'november', 'december' ],
+    monthsShort: [ 'jan', 'feb', 'mar', 'apr', 'maj', 'jun', 'jul', 'avg', 'sep', 'okt', 'nov', 'dec' ],
+    weekdaysFull: [ 'nedelja', 'ponedeljek', 'torek', 'sreda', 'četrtek', 'petek', 'sobota' ],
+    weekdaysShort: [ 'ned', 'pon', 'tor', 'sre', 'čet', 'pet', 'sob' ],
+    today: 'danes',
+    clear: 'izbriši',
+    firstDay: 1,
+    format: 'd. mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/sv_SE.js

@@ -0,0 +1,13 @@
+// Swedish
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'januari', 'februari', 'mars', 'april', 'maj', 'juni', 'juli', 'augusti', 'september', 'oktober', 'november', 'december' ],
+    monthsShort: [ 'jan', 'feb', 'mar', 'apr', 'maj', 'jun', 'jul', 'aug', 'sep', 'okt', 'nov', 'dec' ],
+    weekdaysFull: [ 'söndag', 'måndag', 'tisdag', 'onsdag', 'torsdag', 'fredag', 'lördag' ],
+    weekdaysShort: [ 'sön', 'mån', 'tis', 'ons', 'tor', 'fre', 'lör' ],
+    today: 'i dag',
+    clear: 'bort',
+    firstDay: 1,
+    format: 'd/m yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/th_TH.js

@@ -0,0 +1,12 @@
+// Thai
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'มกราคม', 'กุมภาพันธ์', 'มีนาคม', 'เมษายน', 'พฤษภาคม', 'มิถุนายน', 'กรกฎาคม', 'สิงหาคม', 'กันยายน', 'ตุลาคม', 'พฤศจิกายน', 'ธันวาคม' ],
+    monthsShort: [ 'ม.ค.', 'ก.พ.', 'มี.ค.', 'เม.ย.', 'พ.ค.', 'มิ.ย.', 'ก.ค.', 'ส.ค.', 'ก.ย.', 'ต.ค.', 'พ.ย.', 'ธ.ค.' ],
+    weekdaysFull: [ 'อาทติย', 'จันทร', 'องัคาร', 'พุธ', 'พฤหสั บดี', 'ศกุร', 'เสาร' ],
+    weekdaysShort: [ 'อ.', 'จ.', 'อ.', 'พ.', 'พฤ.', 'ศ.', 'ส.' ],
+    today: 'วันนี้',
+    clear: 'ลบ',
+    format: 'd mmmm yyyy',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/tr_TR.js

@@ -0,0 +1,13 @@
+// Turkish
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'Ocak', 'Şubat', 'Mart', 'Nisan', 'Mayıs', 'Haziran', 'Temmuz', 'Ağustos', 'Eylül', 'Ekim', 'Kasım', 'Aralık' ],
+    monthsShort: [ 'Oca', 'Şub', 'Mar', 'Nis', 'May', 'Haz', 'Tem', 'Ağu', 'Eyl', 'Eki', 'Kas', 'Ara' ],
+    weekdaysFull: [ 'Pazar', 'Pazartesi', 'Salı', 'Çarşamba', 'Perşembe', 'Cuma', 'Cumartesi' ],
+    weekdaysShort: [ 'Pzr', 'Pzt', 'Sal', 'Çrş', 'Prş', 'Cum', 'Cmt' ],
+    today: 'bugün',
+    clear: 'sil',
+    firstDay: 1,
+    format: 'dd mmmm yyyy dddd',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/uk_UA.js

@@ -0,0 +1,13 @@
+// Ukrainian
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'січень', 'лютий', 'березень', 'квітень', 'травень', 'червень', 'липень', 'серпень', 'вересень', 'жовтень', 'листопад', 'грудень' ],
+    monthsShort: [ 'січ', 'лют', 'бер', 'кві', 'тра', 'чер', 'лип', 'сер', 'вер', 'жов', 'лис', 'гру' ],
+    weekdaysFull: [ 'неділя', 'понеділок', 'вівторок', 'середа', 'четвер', 'п‘ятниця', 'субота' ],
+    weekdaysShort: [ 'нд', 'пн', 'вт', 'ср', 'чт', 'пт', 'сб' ],
+    today: 'сьогодні',
+    clear: 'викреслити',
+    firstDay: 1,
+    format: 'dd mmmm yyyy p.',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/vi_VN.js

@@ -0,0 +1,11 @@
+// Vietnamese
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ 'Tháng Một', 'Tháng Hai', 'Tháng Ba', 'Tháng Tư', 'Tháng Năm', 'Tháng Sáu', 'Tháng Bảy', 'Tháng Tám', 'Tháng Chín', 'Tháng Mười', 'Tháng Mười Một', 'Tháng Mười Hai' ],
+    monthsShort: [ 'Một', 'Hai', 'Ba', 'Tư', 'Năm', 'Sáu', 'Bảy', 'Tám', 'Chín', 'Mưới', 'Mười Một', 'Mười Hai' ],
+    weekdaysFull: [ 'Chủ Nhật', 'Thứ Hai', 'Thứ Ba', 'Thứ Tư', 'Thứ Năm', 'Thứ Sáu', 'Thứ Bảy' ],
+    weekdaysShort: [ 'C.Nhật', 'T.Hai', 'T.Ba', 'T.Tư', 'T.Năm', 'T.Sáu', 'T.Bảy' ],
+    today: 'Hôm Nay',
+    clear: 'Xoá',
+    firstDay: 1
+});

assets/js/plugins/pickers/pickadate/translations/zh_CN.js

@@ -0,0 +1,13 @@
+// Simplified Chinese
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ '一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月' ],
+    monthsShort: [ '一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '十一', '十二' ],
+    weekdaysFull: [ '星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六' ],
+    weekdaysShort: [ '日', '一', '二', '三', '四', '五', '六' ],
+    today: '今日',
+    clear: '删',
+    firstDay: 1,
+    format: 'yyyy 年 mm 月 dd 日',
+    formatSubmit: 'yyyy/mm/dd'
+});

assets/js/plugins/pickers/pickadate/translations/zh_TW.js

@@ -0,0 +1,13 @@
+// Traditional Chinese
+
+jQuery.extend( jQuery.fn.pickadate.defaults, {
+    monthsFull: [ '一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月' ],
+    monthsShort: [ '一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '十一', '十二' ],
+    weekdaysFull: [ '星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六' ],
+    weekdaysShort: [ '日', '一', '二', '三', '四', '五', '六' ],
+    today: '今天',
+    clear: '清除',
+    firstDay: 1,
+    format: 'yyyy 年 mm 月 dd 日',
+    formatSubmit: 'yyyy/mm/dd'
+});