text: /**
   * skylark-jquery - The skylark plugin library for fully compatible API with jquery.
   * @author Hudaokeji Co.,Ltd
   * @version v0.9.6
   * @link www.skylarkjs.org
   * @license MIT
   */
  (function(factory,globals) {
    var define = globals.define,
        require = globals.require,
        isAmd = (typeof define === 'function' && define.amd),
        isCmd = (!isAmd && typeof exports !== 'undefined');
  
    if (!isAmd && !define) {
      var map = {};
      function absolute(relative, base) {
          if (relative[0]!==".") {
            return relative;
          }
          var stack = base.split("/"),
              parts = relative.split("/");
          stack.pop(); 
          for (var i=0; i<parts.length; i++) {
              if (parts[i] == ".")
                  continue;
              if (parts[i] == "..")
                  stack.pop();
              else
                  stack.push(parts[i]);
          }
          return stack.join("/");
      }
      define = globals.define = function(id, deps, factory) {
          if (typeof factory == 'function') {
              map[id] = {
                  factory: factory,
                  deps: deps.map(function(dep){
                    return absolute(dep,id);
                  }),
                  resolved: false,
                  exports: null
              };
              require(id);
          } else {
              map[id] = {
                  factory : null,
                  resolved : true,
                  exports : factory
              };
          }
      };
      require = globals.require = function(id) {
          if (!map.hasOwnProperty(id)) {
              throw new Error('Module ' + id + ' has not been defined');
          }
          var module = map[id];
          if (!module.resolved) {
              var args = [];
  
              module.deps.forEach(function(dep){
                  args.push(require(dep));
              })
  
              module.exports = module.factory.apply(globals, args) || null;
              module.resolved = true;
          }
          return module.exports;
      };
    }
    
    if (!define) {
       throw new Error("The module utility (ex: requirejs or skylark-utils) is not loaded!");
    }
  
    factory(define,require);
  
    if (!isAmd) {
      var skylarkjs = require("skylark-langx-ns");
  
      if (isCmd) {
        module.exports = skylarkjs;
      } else {
        globals.skylarkjs  = skylarkjs;
      }
    }
  
  })(function(define,require) {
  
  define('skylark-jquery/core',[
  	"skylark-langx/skylark",
  	"skylark-langx/langx",
  	"skylark-domx-browser",
  	"skylark-domx-noder",
  	"skylark-domx-data",
  	"skylark-domx-eventer",
  	"skylark-domx-finder",
  	"skylark-domx-forms",
  	"skylark-domx-transits",
  	"skylark-domx-fx",
  	"skylark-domx-styler",
  	"skylark-domx-query",
  	"skylark-langx-scripter"
  ],function(skylark,langx,browser,noder,datax,eventer,finder,forms,transites,fx,styler,query,scripter){
  	var filter = Array.prototype.filter,
  		slice = Array.prototype.slice;
  
      (function($){
  	    $.fn.jquery = '2.2.0';
  
  	    $.browser = browser;
  	    
  	    $.camelCase = langx.camelCase;
  
  		$.cleanData = function( elems ) {
  			var elem,
  				i = 0;
  
  			for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
  				datax.cleanData(elem);
  			}
  		};
  
  		$.removeData = function(elm,name) {
  			datax.removeData(elm,name);
  		}
  	
  	    $.each = langx.each;
  
  	    $.extend = langx.extend;
  
  	    $.grep = function(elements, callback) {
  	        return filter.call(elements, callback)
  	    };
  
  	    $.attr = function(elm,name) {
  	    	return datax.attr(elm,name);
  	    };
  
  	    $.isArray = langx.isArray;
  	    $.isEmptyObject = langx.isEmptyObject;
  	    $.isFunction = langx.isFunction;
  	    $.isWindow = langx.isWindow;
  	    $.isPlainObject = langx.isPlainObject;
          $.isNumeric = langx.isNumber;
  
  	    $.inArray = langx.inArray;
  
  	    $.makeArray = langx.makeArray;
  	    $.map = langx.map;  // The behavior is somewhat different from the original jquery.
  
  	    $.noop = function() {
  	    };
  
  	    $.parseJSON = window.JSON.parse;
  
  	    $.proxy = langx.proxy;
  
  	    $.trim = langx.trim;
  	    $.type = langx.type;
  
  	    $.fn.extend = function(props) {
  	        langx.mixin($.fn, props);
  	    };
  
  
      })(query);
  
      (function($){
          $.Event = function Event(src, props) {
              if (langx.isString(src)) {
              	var type = src;
              	return eventer.create(type, props);
  	        }
              return eventer.proxy(src, props);
          };
  
          $.event = {};
  
  	    $.event.special = eventer.special;
  
  	    $.fn.submit = function(callback) {
  	        if (0 in arguments) this.bind('submit', callback)
  	        else if (this.length) {
  	            var event = $.Event('submit')
  	            this.eq(0).trigger(event)
  	            if (!event.isDefaultPrevented()) this.get(0).submit()
  	        }
  	        return this
  	    };
  
  	    // event
  	    $.fn.triggerHandler = $.fn.trigger;
  
  	    $.fn.delegate = function(selector, event, callback) {
  	        return this.on(event, selector, callback)
  	    };
  
  	    $.fn.undelegate = function(selector, event, callback) {
  	        return this.off(event, selector, callback)
  	    };
  
  	    $.fn.live = function(event, callback) {
  	        $(document.body).delegate(this.selector, event, callback)
  	        return this
  	    };
  
  	    $.fn.die = function(event, callback) {
  	        $(document.body).undelegate(this.selector, event, callback)
  	        return this
  	    };
  
  	    $.fn.bind = function(event, selector, data, callback) {
  	        return this.on(event, selector, data, callback)
  	    };
  
  	    $.fn.unbind = function(event, callback) {
  	        return this.off(event, callback)
  	    };
  
  	    $.fn.ready = function(callback) {
  	        eventer.ready(callback);
  	        return this;
  	    };
  
  	    $.fn.stop = function() {
  	        // todo
  	        return this;
  	    };
  
  	    $.fn.moveto = function(x, y) {
  	        return this.transit({
  	            left: x + "px",
  	            top: y + "px"
  	        }, 0.4);
  
  	    };
  
  	    $.ready = eventer.ready;
  
  	    $.on = eventer.on;
  
  	    $.off = eventer.off;
      })(query);
  
      (function($){
  	    // plugin compatibility
  	    $.uuid = 0;
  	    $.support = browser.support;
  	    $.expr = {};
  
  	    $.expr[":"] = $.expr.pseudos = $.expr.filters = finder.pseudos;
  
  	    $.expr.createPseudo = function(fn) {
  	    	return fn;
  	    };
  
  	    $.cssHooks = styler.cssHooks;
  
  	    $.contains = noder.contains;
  
  	    $.css = styler.css;
  
  	    $.data = datax.data;
  
  	    $.fx = fx;
  	    $.fx.step = {
  
          };
          
  	    $.fn.animate =  $.wraps.wrapper_every_act(fx.animate, fx);
  
  
          $.speed = function( speed, easing, fn ) {
              var opt = speed && typeof speed === "object" ? $.extend( {}, speed ) : {
                  complete: fn || !fn && easing ||
                      $.isFunction( speed ) && speed,
                  duration: speed,
                  easing: fn && easing || easing && !$.isFunction( easing ) && easing
              };
  
              // Go to the end state if fx are off
              if ( $.fx.off ) {
                  opt.duration = 0;
  
              } else {
                  if ( typeof opt.duration !== "number" ) {
                      if ( opt.duration in $.fx.speeds ) {
                          opt.duration = $.fx.speeds[ opt.duration ];
  
                      } else {
                          opt.duration = $.fx.speeds._default;
                      }
                  }
              }
  
              // Normalize opt.queue - true/undefined/null -> "fx"
              if ( opt.queue == null || opt.queue === true ) {
                  opt.queue = "fx";
              }
  
              // Queueing
              opt.old = opt.complete;
  
              opt.complete = function() {
                  if ( $.isFunction( opt.old ) ) {
                      opt.old.call( this );
                  }
  
                  if ( opt.queue ) {
                      $.dequeue( this, opt.queue );
                  }
              };
  
              return opt;
          };
  
          $.easing = {};
  
  	    $.offset = {};
  	    $.offset.setOffset = function(elem, options, i) {
  	        var position = $.css(elem, "position");
  
  	        // set position first, in-case top/left are set even on static elem
  	        if (position === "static") {
  	            elem.style.position = "relative";
  	        }
  
  	        var curElem = $(elem),
  	            curOffset = curElem.offset(),
  	            curCSSTop = $.css(elem, "top"),
  	            curCSSLeft = $.css(elem, "left"),
  	            calculatePosition = (position === "absolute" || position === "fixed") && $.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
  	            props = {},
  	            curPosition = {},
  	            curTop, curLeft;
  
  	        // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
  	        if (calculatePosition) {
  	            curPosition = curElem.position();
  	            curTop = curPosition.top;
  	            curLeft = curPosition.left;
  	        } else {
  	            curTop = parseFloat(curCSSTop) || 0;
  	            curLeft = parseFloat(curCSSLeft) || 0;
  	        }
  
  	        if ($.isFunction(options)) {
  	            options = options.call(elem, i, curOffset);
  	        }
  
  	        if (options.top != null) {
  	            props.top = (options.top - curOffset.top) + curTop;
  	        }
  	        if (options.left != null) {
  	            props.left = (options.left - curOffset.left) + curLeft;
  	        }
  
  	        if ("using" in options) {
  	            options.using.call(elem, props);
  	        } else {
  	            curElem.css(props);
  	        }
  	    };
  
          $._data = function(elm,propName) {
              if (elm.hasAttribute) {
                  return datax.data(elm,propName);
              } else {
                  return {};
              }
          };
  
       	var t = $.fn.text;  
  	    $.fn.text = function(v) {
  	        var r = t.apply(this,arguments);
  	        if (r === undefined) {
  	            r = "";
  	        }  
  	        return r;
  	    };       
  
  	    $.fn.pos = $.fn.position;
          	    
      })(query);
  
      query.parseHTML = function(html) {
          return  noder.createFragment(html);
      };
  
      query.uniqueSort = query.unique = langx.uniq;
  
      query.skylark = skylark;
  
      return window.jQuery = window.$ = query;
  });
  
  define('skylark-jquery/ajax',[
      "skylark-langx/langx",
      "skylark-net-http/xhr",
      "./core",
  ], function(langx,Xhr,$) {
      var jsonpID = 0;
  
       // Attach a bunch of functions for handling common AJAX events
      $.each( [
          "ajaxStart",
          "ajaxStop",
          "ajaxComplete",
          "ajaxError",
          "ajaxSuccess",
          "ajaxSend"
      ], function( i, type ) {
          $.fn[ type ] = function( fn ) {
              return this.on( type, fn );
          };
      } );
     
  
      function appendQuery(url, query) {
          if (query == '') return url
          return (url + '&' + query).replace(/[&?]{1,2}/, '?')
      }
      
      $.ajaxJSONP = function(options) {
          var deferred = new langx.Deferred();
          var _callbackName = options.jsonpCallback,
              callbackName = ($.isFunction(_callbackName) ?
                  _callbackName() : _callbackName) || ('jsonp' + (++jsonpID)),
              script = document.createElement('script'),
              originalCallback = window[callbackName],
              responseData,
              abort = function(errorType) {
                  $(script).triggerHandler('error', errorType || 'abort')
              },
              xhr = { abort: abort },
              abortTimeout;
  
          for (var key in options.data) {
              options.url = appendQuery(options.url, key + "=" + options.data[key]);
          }
           
  //        if (deferred) deferred.promise(xhr)
  
          $(script).on('load error', function(e, errorType) {
              clearTimeout(abortTimeout)
              $(script).off().remove()
  
              if (e.type == 'error' || !responseData) {
                  deferred.reject(e);
              } else {
                  deferred.resolve(responseData[0],200,xhr);
              }
  
              window[callbackName] = originalCallback
              if (responseData && $.isFunction(originalCallback))
                  originalCallback(responseData[0])
  
              originalCallback = responseData = undefined
          })
  
          window[callbackName] = function() {
              responseData = arguments
          }
  
          script.src = options.url.replace(/\?(.+)=\?/, '?$1=' + callbackName)
          document.head.appendChild(script)
  
          if (options.timeout > 0) abortTimeout = setTimeout(function() {
              abort('timeout')
          }, options.timeout)
  
          return deferred;
      }
  
      //$.ajaxSettings = Xhr.defaultOptions;
      //$.ajaxSettings.xhr = function() {
      //    return new window.XMLHttpRequest()
      //};
  
      $.ajaxSettings = {
          processData : true
      };
  
  
      $.ajax = function(url,options) {
          if (!url) {
              options = {
                  url :  "./"
              };
          } else if (!options) {
              if (langx.isString(url)) {
                  options = {
                      url :  url
                  };
              } else {
                  options = url;
              }
          } else {
              options.url = url;
          }
  
          options = langx.mixin({},$.ajaxSettings,options);
  
          if ('jsonp' == options.dataType) {
              var hasPlaceholder = /\?.+=\?/.test(options.url);
  
              if (!hasPlaceholder)
                  options.url = appendQuery(options.url,
                      options.jsonp ? (options.jsonp + '=?') : options.jsonp === false ? '' : 'callback=?')
              return $.ajaxJSONP(options);
          }
  
          function ajaxSuccess(data,status,xhr) {
              $(document).trigger("ajaxSucess");
              if (options.success) {
                  options.success.apply(this,arguments);
              }
              if (options.complete) {
                  options.complete.apply(this,arguments);
              }
              return data;
          }
  
          function ajaxError() {
              $(document).trigger("ajaxError");
              if (options.error) {
                  options.error.apply(this,arguments);
              }
          }
  
          var p = Xhr.request(options.url,options);
          p = p.then(ajaxSuccess,ajaxError);
          p.success = p.done;
          p.error = p.fail;
          p.complete = p.always;
          
          return p;
      };
  
      // handle optional data/success arguments
      function parseArguments(url, data, success, dataType) {
          if ($.isFunction(url)) {
              dataType = data, success = url, data = undefined,url = undefined;
          } else if ($.isFunction(data)) {
              dataType = success, success = data, data = undefined;
          } 
          if (!$.isFunction(success)) dataType = success, success = undefined
          return {
              url: url,
              data: data,
              success: success,
              dataType: dataType
          }
      }
  
      $.get = function( /* url, data, success, dataType */ ) {
          return $.ajax(parseArguments.apply(null, arguments))
      }
  
      $.post = function( /* url, data, success, dataType */ ) {
          var options = parseArguments.apply(null, arguments)
          options.type = 'POST'
          return $.ajax(options)
      }
  
      $.getJSON = function( /* url, data, success */ ) {
          var options = parseArguments.apply(null, arguments)
          options.dataType = 'json'
          return $.ajax(options)
      }
  
      var originalLoad = $.fn.load;
  
      $.fn.load = function(url, data, success) {
          if ("string" != typeof url && originalLoad) {
              return originalLoad.apply(this, arguments);
          }
          if (!this.length) return this
          var self = this,
              options = parseArguments(url, data, success),
              parts = options.url && options.url.split(/\s/),
              selector,
              callback = options.success
          if (parts && parts.length > 1) options.url = parts[0], selector = parts[1]
  
          if (options.data && typeof options.data === "object") {
              options.type = "POST";
          }
          options.success = function(response) {
              self.html(selector ?
                  $('<div>').html(response.replace(rscript, "")).find(selector) : response)
              callback && callback.apply(self, arguments)
          }
          $.ajax(options)
          return this
      }
  
      $.param = Xhr.param;
  
  
      // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
      function addToPrefiltersOrTransports(structure) {
  
          // dataTypeExpression is optional and defaults to "*"
          return function(dataTypeExpression, func) {
  
              if (typeof dataTypeExpression !== "string") {
                  func = dataTypeExpression;
                  dataTypeExpression = "*";
              }
  
              var dataType,
                  i = 0,
                  dataTypes = dataTypeExpression.toLowerCase().match(rnotwhite) || [];
  
              if (jQuery.isFunction(func)) {
  
                  // For each dataType in the dataTypeExpression
                  while ((dataType = dataTypes[i++])) {
  
                      // Prepend if requested
                      if (dataType[0] === "+") {
                          dataType = dataType.slice(1) || "*";
                          (structure[dataType] = structure[dataType] || []).unshift(func);
  
                          // Otherwise append
                      } else {
                          (structure[dataType] = structure[dataType] || []).push(func);
                      }
                  }
              }
          };
      }
  
      var
          prefilters = {},
          transports = {},
          rnotwhite = (/\S+/g);
  
      $.ajaxPrefilter = addToPrefiltersOrTransports(prefilters);
      $.ajaxTransport = addToPrefiltersOrTransports(transports);
      $.ajaxSetup = function(target, settings) {
          langx.mixin(Xhr.defaultOptions,target,settings);
      };
  
      $.getScript = function( url, callback ) {
          return $.get( url, undefined, callback, "script" );
      };
  
      return $;
  
  });
  
  define('skylark-jquery/callbacks',[
      "./core"
  ], function($) {
  
      //     This module is borrow from zepto.callback.js
      //     (c) 2010-2014 Thomas Fuchs
      //     Zepto.js may be freely distributed under the MIT license.
  
      // Create a collection of callbacks to be fired in a sequence, with configurable behaviour
      // Option flags:
      //   - once: Callbacks fired at most one time.
      //   - memory: Remember the most recent context and arguments
      //   - stopOnFalse: Cease iterating over callback list
      //   - unique: Permit adding at most one instance of the same callback
      $.Callbacks = function(options) {
          options = $.extend({}, options)
  
          var memory, // Last fire value (for non-forgettable lists)
              fired, // Flag to know if list was already fired
              firing, // Flag to know if list is currently firing
              firingStart, // First callback to fire (used internally by add and fireWith)
              firingLength, // End of the loop when firing
              firingIndex, // Index of currently firing callback (modified by remove if needed)
              list = [], // Actual callback list
              stack = !options.once && [], // Stack of fire calls for repeatable lists
              fire = function(data) {
                  memory = options.memory && data
                  fired = true
                  firingIndex = firingStart || 0
                  firingStart = 0
                  firingLength = list.length
                  firing = true
                  for (; list && firingIndex < firingLength; ++firingIndex) {
                      if (list[firingIndex].apply(data[0], data[1]) === false && options.stopOnFalse) {
                          memory = false
                          break
                      }
                  }
                  firing = false
                  if (list) {
                      if (stack) stack.length && fire(stack.shift())
                      else if (memory) list.length = 0
                      else Callbacks.disable()
                  }
              },
  
              Callbacks = {
                  add: function() {
                      if (list) {
                          var start = list.length,
                              add = function(args) {
                                  $.each(args, function(_, arg) {
                                      if (typeof arg === "function") {
                                          if (!options.unique || !Callbacks.has(arg)) list.push(arg)
                                      } else if (arg && arg.length && typeof arg !== 'string') add(arg)
                                  })
                              }
                          add(arguments)
                          if (firing) firingLength = list.length
                          else if (memory) {
                              firingStart = start
                              fire(memory)
                          }
                      }
                      return this
                  },
                  remove: function() {
                      if (list) {
                          $.each(arguments, function(_, arg) {
                              var index
                              while ((index = $.inArray(arg, list, index)) > -1) {
                                  list.splice(index, 1)
                                  // Handle firing indexes
                                  if (firing) {
                                      if (index <= firingLength) --firingLength
                                      if (index <= firingIndex) --firingIndex
                                  }
                              }
                          })
                      }
                      return this
                  },
                  has: function(fn) {
                      return !!(list && (fn ? $.inArray(fn, list) > -1 : list.length))
                  },
                  empty: function() {
                      firingLength = list.length = 0
                      return this
                  },
                  disable: function() {
                      list = stack = memory = undefined
                      return this
                  },
                  disabled: function() {
                      return !list
                  },
                  lock: function() {
                      stack = undefined;
                      if (!memory) Callbacks.disable()
                      return this
                  },
                  locked: function() {
                      return !stack
                  },
                  fireWith: function(context, args) {
                      if (list && (!fired || stack)) {
                          args = args || []
                          args = [context, args.slice ? args.slice() : args]
                          if (firing) stack.push(args)
                          else fire(args)
                      }
                      return this
                  },
                  fire: function() {
                      return Callbacks.fireWith(this, arguments)
                  },
                  fired: function() {
                      return !!fired
                  }
              }
  
          return Callbacks
      };
  
      return $;
  
  });
  
  define('skylark-jquery/deferred',[
      "./core",
      "skylark-langx/langx"
  ], function($,langx) {
  
      $.Deferred = function() {
          var d = new langx.Deferred(),
              ret = {
                  promise : function() {
                      return d.promise;
                  }
              };
  
          ["resolve","resolveWith","reject","rejectWith","notify","then","done","fail","progress","always","state"].forEach(function(name){
              ret[name] = function() {
                var ret2 =   d[name].apply(d,arguments);
                if (ret2 == d) {
                  ret2 = ret;
                }
                return ret2;
              }
          });
  
          return ret;
      };
      
      $.when = function(){
          var p = langx.Deferred.all(langx.makeArray(arguments)),
              originThen = p.then;
          p.then = function(onResolved,onRejected) {
              var handler = function(results) {
                  //results = results.map(function(result){
                  //    return [result];
                  //});
                  return onResolved && onResolved.apply(null,results);
              };
              return originThen.call(p,handler,onRejected);
          };
          return p;
      };
  
      return $;
  
  });
  
  define('skylark-jquery/queue',[
      "skylark-langx/langx",
      "./core",
      "./callbacks"
  ], function(langx, $) {
  
   // jQuery Data object
    var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
        rmultiDash = /([A-Z])/g,
        expando = "Sky" + ( '1.0' + Math.random() ).replace( /\D/g, ""),
        optionsCache = {},
        core_rnotwhite = /\S+/g,
        core_deletedIds = [],
        core_push = core_deletedIds.push;
  
  // Convert String-formatted options into Object-formatted ones and store in cache
    function createOptions( options ) {
      var object = optionsCache[ options ] = {};
      $.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
        object[ flag ] = true;
      });
      return object;
    }
  
    function isArraylike( obj ) {
      var length = obj.length,
          type = $.type( obj );
  
      if ( $.isWindow( obj ) ) {
        return false;
      }
  
      if ( obj.nodeType === 1 && length ) {
        return true;
      }
  
      return type === "array" || type !== "function" &&
          ( length === 0 ||
              typeof length === "number" && length > 0 && ( length - 1 ) in obj );
    }
  
    
  
    function Data() {
      // Support: Android < 4,
      // Old WebKit does not have Object.preventExtensions/freeze method,
      // return new empty object instead with no [[set]] accessor
      Object.defineProperty( this.cache = {}, 0, {
        get: function() {
          return {};
        }
      });
  
      this.expando = expando + Math.random();
    }
  
    Data.uid = 1;
  
    Data.accepts = function( owner ) {
      // Accepts only:
      //  - Node
      //    - Node.ELEMENT_NODE
      //    - Node.DOCUMENT_NODE
      //  - Object
      //    - Any
      return owner.nodeType ?
          owner.nodeType === 1 || owner.nodeType === 9 : true;
    };
  
    Data.prototype = {
      key: function( owner ) {
        // We can accept data for non-element nodes in modern browsers,
        // but we should not, see #8335.
        // Always return the key for a frozen object.
        if ( !Data.accepts( owner ) ) {
          return 0;
        }
  
        var descriptor = {},
        // Check if the owner object already has a cache key
            unlock = owner[ this.expando ];
  
        // If not, create one
        if ( !unlock ) {
          unlock = Data.uid++;
  
          // Secure it in a non-enumerable, non-writable property
          try {
            descriptor[ this.expando ] = { value: unlock };
            Object.defineProperties( owner, descriptor );
  
            // Support: Android < 4
            // Fallback to a less secure definition
          } catch ( e ) {
            descriptor[ this.expando ] = unlock;
            $.extend( owner, descriptor );
          }
        }
  
        // Ensure the cache object
        if ( !this.cache[ unlock ] ) {
          this.cache[ unlock ] = {};
        }
  
        return unlock;
      },
      set: function( owner, data, value ) {
        var prop,
        // There may be an unlock assigned to this node,
        // if there is no entry for this "owner", create one inline
        // and set the unlock as though an owner entry had always existed
            unlock = this.key( owner ),
            cache = this.cache[ unlock ];
  
        // Handle: [ owner, key, value ] args
        if ( typeof data === "string" ) {
          cache[ data ] = value;
  
          // Handle: [ owner, { properties } ] args
        } else {
          // Fresh assignments by object are shallow copied
          if ( $.isEmptyObject( cache ) ) {
            $.extend( this.cache[ unlock ], data );
            // Otherwise, copy the properties one-by-one to the cache object
          } else {
            for ( prop in data ) {
              cache[ prop ] = data[ prop ];
            }
          }
        }
        return cache;
      },
      get: function( owner, key ) {
        // Either a valid cache is found, or will be created.
        // New caches will be created and the unlock returned,
        // allowing direct access to the newly created
        // empty data object. A valid owner object must be provided.
        var cache = this.cache[ this.key( owner ) ];
  
        return key === undefined ?
            cache : cache[ key ];
      },
      access: function( owner, key, value ) {
        var stored;
        // In cases where either:
        //
        //   1. No key was specified
        //   2. A string key was specified, but no value provided
        //
        // Take the "read" path and allow the get method to determine
        // which value to return, respectively either:
        //
        //   1. The entire cache object
        //   2. The data stored at the key
        //
        if ( key === undefined ||
            ((key && typeof key === "string") && value === undefined) ) {
  
          stored = this.get( owner, key );
  
          return stored !== undefined ?
              stored : this.get( owner, $.camelCase(key) );
        }
  
        // [*]When the key is not a string, or both a key and value
        // are specified, set or extend (existing objects) with either:
        //
        //   1. An object of properties
        //   2. A key and value
        //
        this.set( owner, key, value );
  
        // Since the "set" path can have two possible entry points
        // return the expected data based on which path was taken[*]
        return value !== undefined ? value : key;
      },
      remove: function( owner, key ) {
        var i, name, camel,
            unlock = this.key( owner ),
            cache = this.cache[ unlock ];
  
        if ( key === undefined ) {
          this.cache[ unlock ] = {};
  
        } else {
          // Support array or space separated string of keys
          if ( $.isArray( key ) ) {
            // If "name" is an array of keys...
            // When data is initially created, via ("key", "val") signature,
            // keys will be converted to camelCase.
            // Since there is no way to tell _how_ a key was added, remove
            // both plain key and camelCase key. #12786
            // This will only penalize the array argument path.
            name = key.concat( key.map( $.camelCase ) );
          } else {
            camel = $.camelCase( key );
            // Try the string as a key before any manipulation
            if ( key in cache ) {
              name = [ key, camel ];
            } else {
              // If a key with the spaces exists, use it.
              // Otherwise, create an array by matching non-whitespace
              name = camel;
              name = name in cache ?
                  [ name ] : ( name.match( core_rnotwhite ) || [] );
            }
          }
  
          i = name.length;
          while ( i-- ) {
            delete cache[ name[ i ] ];
          }
        }
      },
      hasData: function( owner ) {
        return !$.isEmptyObject(
            this.cache[ owner[ this.expando ] ] || {}
        );
      },
      discard: function( owner ) {
        if ( owner[ this.expando ] ) {
          delete this.cache[ owner[ this.expando ] ];
        }
      }
    };
  
    var data_priv = new Data();
  
    $.extend($, {
      queue: function( elem, type, data ) {
        var queue;
  
        if ( elem ) {
          type = ( type || "fx" ) + "queue";
          queue = data_priv.get( elem, type );
  
          // Speed up dequeue by getting out quickly if this is just a lookup
          if ( data ) {
            if ( !queue || $.isArray( data ) ) {
              queue = data_priv.access( elem, type, $.makeArray(data) );
            } else {
              queue.push( data );
            }
          }
          return queue || [];
        }
      },
  
      dequeue: function( elem, type ) {
        type = type || "fx";
  
        var queue = $.queue( elem, type ),
            startLength = queue.length,
            fn = queue.shift(),
            hooks = $._queueHooks( elem, type ),
            next = function() {
              $.dequeue( elem, type );
            };
  
        // If the fx queue is dequeued, always remove the progress sentinel
        if ( fn === "inprogress" ) {
          fn = queue.shift();
          startLength--;
        }
  
        if ( fn ) {
  
          // Add a progress sentinel to prevent the fx queue from being
          // automatically dequeued
          if ( type === "fx" ) {
            queue.unshift( "inprogress" );
          }
  
          // clear up the last queue stop function
          delete hooks.stop;
          fn.call( elem, next, hooks );
        }
  
        if ( !startLength && hooks ) {
          hooks.empty.fire();
        }
      },
  
      // not intended for public consumption - generates a queueHooks object, or returns the current one
      _queueHooks: function( elem, type ) {
        var key = type + "queueHooks";
        return data_priv.get( elem, key ) || data_priv.access( elem, key, {
          empty: $.Callbacks("once memory").add(function() {
            data_priv.remove( elem, [ type + "queue", key ] );
          })
        });
      },
  
      // array operations
      makeArray: function( arr, results ) {
        var ret = results || [];
  
        if ( arr != null ) {
          if ( isArraylike( Object(arr) ) ) {
            $.merge( ret,
                typeof arr === "string" ?
                    [ arr ] : arr
            );
          } else {
            core_push.call( ret, arr );
          }
        }
  
        return ret;
      },
      merge: function( first, second ) {
        var l = second.length,
            i = first.length,
            j = 0;
  
        if ( typeof l === "number" ) {
          for ( ; j < l; j++ ) {
            first[ i++ ] = second[ j ];
          }
        } else {
          while ( second[j] !== undefined ) {
            first[ i++ ] = second[ j++ ];
          }
        }
  
        first.length = i;
  
        return first;
      }
    });
  
    $.extend($.fn, {
      queue: function( type, data ) {
        var setter = 2;
  
        if ( typeof type !== "string" ) {
          data = type;
          type = "fx";
          setter--;
        }
  
        if ( arguments.length < setter ) {
          return $.queue( this[0], type );
        }
  
        return data === undefined ?
            this :
            this.each(function() {
              var queue = $.queue( this, type, data );
  
              // ensure a hooks for this queue
              $._queueHooks( this, type );
  
              if ( type === "fx" && queue[0] !== "inprogress" ) {
                $.dequeue( this, type );
              }
            });
      },
      dequeue: function( type ) {
        return this.each(function() {
          $.dequeue( this, type );
        });
      },
      // Based off of the plugin by Clint Helfers, with permission.
      // http://blindsignals.com/index.php/2009/07/jquery-delay/
      delay: function( time, type ) {
        time = $.fx ? $.fx.speeds[ time ] || time : time;
        type = type || "fx";
  
        return this.queue( type, function( next, hooks ) {
          var timeout = setTimeout( next, time );
          hooks.stop = function() {
            clearTimeout( timeout );
          };
        });
      },
      clearQueue: function( type ) {
        return this.queue( type || "fx", [] );
      },
      // Get a promise resolved when queues of a certain type
      // are emptied (fx is the type by default)
      promise: function( type, obj ) {
        var tmp,
            count = 1,
            defer = $.Deferred(),
            elements = this,
            i = this.length,
            resolve = function() {
              if ( !( --count ) ) {
                defer.resolveWith( elements, [ elements ] );
              }
            };
  
        if ( typeof type !== "string" ) {
          obj = type;
          type = undefined;
        }
        type = type || "fx";
  
        while( i-- ) {
          tmp = data_priv.get( elements[ i ], type + "queueHooks" );
          if ( tmp && tmp.empty ) {
            count++;
            tmp.empty.add( resolve );
          }
        }
        resolve();
        return defer.promise( obj );
      }
    });
  
    return $;
  
  });
  
  define('skylark-jquery/jquery-plugin',[
  	"skylark-langx-types",
  	"skylark-langx-objects",
  	"skylark-langx-arrays",
  	"skylark-langx/langx",
  	"skylark-domx-data",
  	"skylark-domx-eventer",
  	"skylark-domx-plugins-base",
  	"skylark-domx-query",
  ],function(types, objects, arrays, langx, datax, eventer, plugins, $){
  
      var pluginUuid = 0;
  
  	var JqPlugin = plugins.Plugin.inherit({
  		klassName : "JqPlugin",
  
          pluginEventPrefix: "",
  
          options: {
              // Callbacks
              create: null
          },
  
          destroy: function() {
              this.overrided();
  
              // We can probably remove the unbind calls in 2.0
              // all event bindings should go through this._on()
              this.element
                  .off( this.eventNamespace );
  
              // Clean up events and states
              this.bindings.off( this.eventNamespace );
          },
  
          _construct : function(element,options) {
              //this.options = langx.mixin( {}, this.options );
  
              element = $( element || this.defaultElement || this )[ 0 ];
              this.element = $( element );
              this.uuid = pluginUuid++;
              this.eventNamespace = "." + this.pluginName + this.uuid;
  
              this.bindings = $();
              this.classesElementLookup = {};
  
  			this.hoverable = $();
  			this.focusable = $();
  
              if ( element !== this ) {
                  datax.data( element, this.pluginName, this );
                  this._on( true, this.element, {
                      remove: function( event ) {
                          if ( event.target === element ) {
                              this.destroy();
                          }
                      }
                  } );
                  this.document = $( element.style ?
  
                      // Element within the document
                      element.ownerDocument :
  
                      // Element is window or document
                      element.document || element );
                  this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow );
              }
  
              plugins.Plugin.prototype._construct.call(this,element,options);
  
  //            this.options = langx.mixin( {},
  //                this.options,
  //                this._getCreateOptions(),
  //                options );
  
              this._create();
  
              this._trigger( "create", null, this._getCreateEventData() );
  
              this._init();
          },
  
  
  	     _initOptions : function(options) {
  	     	options = langx.mixin(this._getCreateOptions(),options);
  
  			this.overrided(options);
  		},
  
          _getCreateOptions: function() {
              return {};
          },
  
          _getCreateEventData: langx.noop,
  
  		_super : function() {
  			if (this.overrided) {
  				return this.overrided.apply(this,arguments);
  			}
  		},
  
  		_superApply : function ( args ) {
  			if (this.overrided) {
  				return this.overrided.apply(this,args);
  			}
  		},
  
          _create: langx.noop,
  
          _init: langx.noop,
  
  		_classes: function( options ) {
  			var full = [];
  			var that = this;
  
  			options = objects.mixin( {
  				element: this.element,
  				classes: this.options.classes || {}
  			}, options );
  
  
  			function bindRemoveEvent() {
  				options.element.each( function( _, element ) {
  					var isTracked = langx.map( that.classesElementLookup, function( elements ) {
  						return elements;
  					} )
  						.some( function(elements ) {
  							return $(elements).is( element );
  						} );
  
  					if ( !isTracked ) {
  						that._on( $( element ), {
  							remove: "_untrackClassesElement"
  						} );
  					}
  				} );
  			}
  
  			function processClassString( classes, checkOption ) {
  				var current, i;
  				for ( i = 0; i < classes.length; i++ ) {
  					current = that.classesElementLookup[ classes[ i ] ] || $();
  					if ( options.add ) {
  						bindRemoveEvent();
  						current = $( langx.uniq( current.get().concat( options.element.get() ) ) );
  					} else {
  						current = $( current.not( options.element ).get() );
  					}
  					that.classesElementLookup[ classes[ i ] ] = current;
  					full.push( classes[ i ] );
  					if ( checkOption && options.classes[ classes[ i ] ] ) {
  						full.push( options.classes[ classes[ i ] ] );
  					}
  				}
  			}
  
  			if ( options.keys ) {
  				processClassString( options.keys.match( /\S+/g ) || [], true );
  			}
  			if ( options.extra ) {
  				processClassString( options.extra.match( /\S+/g ) || [] );
  			}
  
  			return full.join( " " );
  		},
  
  		_untrackClassesElement: function( event ) {
  			var that = this;
  			langx.each( that.classesElementLookup, function( key, value ) {
  				if ( arrays.inArray( event.target, value ) !== -1 ) {
  					that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
  				}
  			} );
  
  			this._off( $( event.target ) );
  		},
  
  		_removeClass: function( element, keys, extra ) {
  			return this._toggleClass( element, keys, extra, false );
  		},
  
  		_addClass: function( element, keys, extra ) {
  			return this._toggleClass( element, keys, extra, true );
  		},
  
  		_toggleClass: function( element, keys, extra, add ) {
  			add = ( typeof add === "boolean" ) ? add : extra;
  			var shift = ( typeof element === "string" || element === null ),
  				options = {
  					extra: shift ? keys : extra,
  					keys: shift ? element : keys,
  					element: shift ? this.element : element,
  					add: add
  				};
  			options.element.toggleClass( this._classes( options ), add );
  			return this;
  		},
  
  		_on: function( suppressDisabledCheck, element, handlers ) {
  			var delegateElement;
  			var instance = this;
  
  			// No suppressDisabledCheck flag, shuffle arguments
  			if ( typeof suppressDisabledCheck !== "boolean" ) {
  				handlers = element;
  				element = suppressDisabledCheck;
  				suppressDisabledCheck = false;
  			}
  
  			// No element argument, shuffle and use this.element
  			if ( !handlers ) {
  				handlers = element;
  				element = this.element;
  				delegateElement = this.widget();
  			} else {
  				element = delegateElement = $( element );
  				this.bindings = this.bindings.add( element );
  			}
  
  			objects.each( handlers, function( event, handler ) {
  				function handlerProxy() {
  
  					// Allow widgets to customize the disabled handling
  					// - disabled as an array instead of boolean
  					// - disabled class as method for disabling individual parts
  					if ( !suppressDisabledCheck &&
  							( instance.options.disabled === true ||
  							$( this ).hasClass( "ui-state-disabled" ) ) ) {
  						return;
  					}
  					return ( typeof handler === "string" ? instance[ handler ] : handler )
  						.apply( instance, arguments );
  				}
  
  				// Copy the guid so direct unbinding works
  				if ( typeof handler !== "string" ) {
  					handlerProxy.guid = handler.guid =
  						handler.guid || handlerProxy.guid || $.guid++;
  				}
  
  				var match = event.match( /^([\w:-]*)\s*(.*)$/ );
  				var eventName = match[ 1 ] + instance.eventNamespace;
  				var selector = match[ 2 ];
  
  				if ( selector ) {
  					delegateElement.on( eventName, selector, handlerProxy );
  				} else {
  					element.on( eventName, handlerProxy );
  				}
  			} );
  		},
  
  		_off: function( element, eventName ) {
  			eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
  				this.eventNamespace;
  			element.off( eventName );
  
  			// Clear the stack to avoid memory leaks (#10056)
  			this.bindings = $( this.bindings.not( element ).get() );
  			this.focusable = $( this.focusable.not( element ).get() );
  			this.hoverable = $( this.hoverable.not( element ).get() );
  		},
  
  		_trigger: function( type, event, data ) {
  			var prop, orig;
  			var callback = this.options[ type ];
  
  			data = data || {};
  			event = eventer.proxy( event );
  			event.type = ( type === this.widgetEventPrefix ?
  				type :
  				this.widgetEventPrefix + type ).toLowerCase();
  
  			// The original event may come from any element
  			// so we need to reset the target on the new event
  			event.target = this.element[ 0 ];
  
  			// Copy original event properties over to the new event
  			orig = event.originalEvent;
  			if ( orig ) {
  				for ( prop in orig ) {
  					if ( !( prop in event ) ) {
  						event[ prop ] = orig[ prop ];
  					}
  				}
  			}
  
  			this.element.trigger( event, data );
  			return !( types.isFunction( callback ) &&
  				callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false ||
  				event.isDefaultPrevented() );
  		},
  		_hoverable: function( element ) {
  			this.hoverable = this.hoverable.add( element );
  			this._on( element, {
  				mouseenter: function( event ) {
  					this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
  				},
  				mouseleave: function( event ) {
  					this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
  				}
  			} );
  		},
  
  		_focusable: function( element ) {
  			this.focusable = this.focusable.add( element );
  			this._on( element, {
  				focusin: function( event ) {
  					this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
  				},
  				focusout: function( event ) {
  					this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
  				}
  			} );
  		},
  
  
  	    enable: function() {
  	      return this._setOptions( { disabled: false } );
  	    },
  
  	    disable: function() {
  	      return this._setOptions( { disabled: true } );
  	    }
  
  
  	});
  
  	return JqPlugin;
  });
  /*!
   * jQuery UI Widget @VERSION
   * http://jqueryui.com
   *
   * Copyright jQuery Foundation and other contributors
   * Released under the MIT license.
   * http://jquery.org/license
   */
  
  //>>label: Widget
  //>>group: Core
  //>>description: Provides a factory for creating stateful widgets with a common API.
  //>>docs: http://api.jqueryui.com/jQuery.widget/
  //>>demos: http://jqueryui.com/widget/
  
  define( 'skylark-jquery/widget',[ 
  	"skylark-langx/langx",
  	"skylark-domx-plugins-base",
  	"./core",
  	"./jquery-plugin"
  ],  function(langx,splugins, $,JqPlugin ) {
  
  	var widgetUuid = 0;
  	var widgetHasOwnProperty = Array.prototype.hasOwnProperty;
  	var widgetSlice = Array.prototype.slice;
  
  	$.cleanData = ( function( orig ) {
  		return function( elems ) {
  			var events, elem, i;
  			for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {
  
  				// Only trigger remove when necessary to save time
  				events = $._data( elem, "events" );
  				if ( events && events.remove ) {
  					$( elem ).triggerHandler( "remove" );
  				}
  			}
  			orig( elems );
  		};
  	} )( $.cleanData );
  	
  	$.widget = function( name, base, prototype ) {
  		var existingConstructor, constructor, basePrototype;
  
  		// ProxiedPrototype allows the provided prototype to remain unmodified
  		// so that it can be used as a mixin for multiple widgets (#8876)
  		var proxiedPrototype = {};
  
  		var namespace = name.split( "." )[ 0 ];
  		name = name.split( "." )[ 1 ];
  		var fullName = namespace + "-" + name;
  
  		if ( !prototype ) {
  			prototype = base;
  			base = $.Widget;
  		}
  
  		if ( $.isArray( prototype ) ) {
  			prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
  		}
  
  		// Create selector for plugin
  		$.expr.pseudos[ fullName.toLowerCase() ] = function( elem ) {
  			return !!$.data( elem, fullName );
  		};
  
  		$[ namespace ] = $[ namespace ] || {};
  
  		existingConstructor = $[ namespace ][ name ];
  
  		var basePrototype = base.prototype,
  			newPrototype = {};
  
  		for (var key in prototype) {
  			var value = prototype[key];
  
  			if ( $.isPlainObject( value ) ) {
  				newPrototype[ key ] = $.isPlainObject( basePrototype[ key ] ) ?
  					$.widget.extend( {}, basePrototype[ key ], value ) :
  
  					// Don't extend strings, arrays, etc. with objects
  					$.widget.extend( {}, value );
  			} else {
  				newPrototype[key] = value;
  			}
  		}
  
  		var _proto = $.widget.extend({
  
  			// TODO: remove support for widgetEventPrefix
  			// always use the name + a colon as the prefix, e.g., draggable:start
  			// don't prefix for widgets that aren't DOM-based
  			widgetEventPrefix: existingConstructor ? ( base.prototype.widgetEventPrefix || name ) : name
  		}, {
  			options : base.prototype.options
  		},newPrototype, {
  			name : fullName,
  			namespace: namespace,
  			widgetName: name,
  			pluginName : "jqueryui." + (namespace ? namespace + "." : "") + name,
  			widgetFullName: fullName
  		} );
  
  		constructor = $[ namespace ][ name ] = base.inherit(_proto);
  		/*
  
  		constructor = $[ namespace ][ name ] = function( options, element ) {
  
  			// Allow instantiation without "new" keyword
  			if ( !this._createWidget ) {
  				return new constructor( options, element );
  			}
  
  			// Allow instantiation without initializing for simple inheritance
  			// must use "new" keyword (the code above always passes args)
  			if ( arguments.length ) {
  				this._createWidget( options, element );
  			}
  		};
  		*/
  		// Extend with the existing constructor to carry over any static properties
  		$.extend( constructor, existingConstructor, {
  			version: prototype.version,
  
  			// Copy the object used to create the prototype in case we need to
  			// redefine the widget later
  			_proto: _proto,
  
  			// Track widgets that inherit from this widget in case this widget is
  			// redefined after a widget inherits from it
  			_childConstructors: []
  		} );
  
  		/*
  		basePrototype = new base();
  
  		// We need to make the options hash a property directly on the new instance
  		// otherwise we'll modify the options hash on the prototype that we're
  		// inheriting from
  		basePrototype.options = $.widget.extend( {}, basePrototype.options );
  		$.each( prototype, function( prop, value ) {
  			if ( !$.isFunction( value ) ) {
  				proxiedPrototype[ prop ] = value;
  				return;
  			}
  			proxiedPrototype[ prop ] = ( function() {
  				function _super() {
  					return base.prototype[ prop ].apply( this, arguments );
  				}
  
  				function _superApply( args ) {
  					return base.prototype[ prop ].apply( this, args );
  				}
  
  				return function() {
  					var __super = this._super;
  					var __superApply = this._superApply;
  					var returnValue;
  
  					this._super = _super;
  					this._superApply = _superApply;
  
  					returnValue = value.apply( this, arguments );
  
  					this._super = __super;
  					this._superApply = __superApply;
  
  					return returnValue;
  				};
  			} )();
  		} );
  		constructor.prototype = $.widget.extend( basePrototype, {
  
  			// TODO: remove support for widgetEventPrefix
  			// always use the name + a colon as the prefix, e.g., draggable:start
  			// don't prefix for widgets that aren't DOM-based
  			widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name
  		}, proxiedPrototype, {
  			constructor: constructor,
  			namespace: namespace,
  			widgetName: name,
  			widgetFullName: fullName
  		} );
  		*/
  		// If this widget is being redefined then we need to find all widgets that
  		// are inheriting from it and redefine all of them so that they inherit from
  		// the new version of this widget. We're essentially trying to replace one
  		// level in the prototype chain.
  		if ( existingConstructor ) {
  			$.each( existingConstructor._childConstructors, function( i, child ) {
  				var childPrototype = child.prototype;
  
  				// Redefine the child widget using the same prototype that was
  				// originally used, but inherit from the new version of the base
  				$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor,
  					child._proto );
  			} );
  
  			// Remove the list of existing child constructors from the old constructor
  			// so the old child constructors can be garbage collected
  			delete existingConstructor._childConstructors;
  		} else {
  			if (base._childConstructors) {
  				base._childConstructors.push( constructor );
  			}
  		}
  
  		//$.widget.bridge( name, constructor );
  
  		splugins.register(constructor,name,fullName);
  
  		return constructor;
  	};
  
  	$.widget.extend = function( target ) {
  		var input = widgetSlice.call( arguments, 1 );
  		var inputIndex = 0;
  		var inputLength = input.length;
  		var key;
  		var value;
  
  		for ( ; inputIndex < inputLength; inputIndex++ ) {
  			for ( key in input[ inputIndex ] ) {
  				value = input[ inputIndex ][ key ];
  				if ( widgetHasOwnProperty.call( input[ inputIndex ], key ) && value !== undefined ) {
  
  					// Clone objects
  					if ( $.isPlainObject( value ) ) {
  						target[ key ] = $.isPlainObject( target[ key ] ) ?
  							$.widget.extend( {}, target[ key ], value ) :
  
  							// Don't extend strings, arrays, etc. with objects
  							$.widget.extend( {}, value );
  
  					// Copy everything else by reference
  					} else {
  						target[ key ] = value;
  					}
  				}
  			}
  		}
  		return target;
  	};
  
  
  	$.Widget = 	 JqPlugin.inherit({
  		widgetName: "widget",
  		widgetEventPrefix: "",
  		defaultElement: "<div>",
  
  		options: {
  			classes: {},
  			disabled: false,
  
  			// Callbacks
  			create: null
  		},
  
  		widget: function() {
  			return this.element;
  		},
  
  		_setOption: function( key, value ) {
  			if ( key === "classes" ) {
  				this._setOptionClasses( value );
  			}
  
  			this.options[ key ] = value;
  
  			if ( key === "disabled" ) {
  				this._setOptionDisabled( value );
  			}
  
  			return this;
  		},
  
  		_setOptionClasses: function( value ) {
  			var classKey, elements, currentElements;
  
  			for ( classKey in value ) {
  				currentElements = this.classesElementLookup[ classKey ];
  				if ( value[ classKey ] === this.options.classes[ classKey ] ||
  						!currentElements ||
  						!currentElements.length ) {
  					continue;
  				}
  
  				// We are doing this to create a new jQuery object because the _removeClass() call
  				// on the next line is going to destroy the reference to the current elements being
  				// tracked. We need to save a copy of this collection so that we can add the new classes
  				// below.
  				elements = $( currentElements.get() );
  				this._removeClass( currentElements, classKey );
  
  				// We don't use _addClass() here, because that uses this.options.classes
  				// for generating the string of classes. We want to use the value passed in from
  				// _setOption(), this is the new value of the classes option which was passed to
  				// _setOption(). We pass this value directly to _classes().
  				elements.addClass( this._classes( {
  					element: elements,
  					keys: classKey,
  					classes: value,
  					add: true
  				} ));
  			}
  		},
  
  		_setOptionDisabled: function( value ) {
  			this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );
  
  			// If the widget is becoming disabled, then nothing is interactive
  			if ( value ) {
  				this._removeClass( this.hoverable, null, "ui-state-hover" );
  				this._removeClass( this.focusable, null, "ui-state-focus" );
  			}
  		},
  
  		enable: function() {
  			return this._setOptions( { disabled: false } );
  		},
  
  		disable: function() {
  			return this._setOptions( { disabled: true } );
  		},
  
  
  		_delay: function( handler, delay ) {
  			function handlerProxy() {
  				return ( typeof handler === "string" ? instance[ handler ] : handler )
  					.apply( instance, arguments );
  			}
  			var instance = this;
  			return setTimeout( handlerProxy, delay || 0 );
  		},
  
  		_hoverable: function( element ) {
  			this.hoverable = this.hoverable.add( element );
  			this._on( element, {
  				mouseenter: function( event ) {
  					this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
  				},
  				mouseleave: function( event ) {
  					this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
  				}
  			} );
  		},
  
  		_focusable: function( element ) {
  			this.focusable = this.focusable.add( element );
  			this._on( element, {
  				focusin: function( event ) {
  					this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
  				},
  				focusout: function( event ) {
  					this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
  				}
  			} );
  		}
  
  	});
  
  	$.Widget._childConstructors = [];
  
  	$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
  		$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
  			if ( typeof options === "string" ) {
  				options = { effect: options };
  			}
  
  			var hasOptions;
  			var effectName = !options ?
  				method :
  				options === true || typeof options === "number" ?
  					defaultEffect :
  					options.effect || defaultEffect;
  
  			options = options || {};
  			if ( typeof options === "number" ) {
  				options = { duration: options };
  			}
  
  			hasOptions = !$.isEmptyObject( options );
  			options.complete = callback;
  
  			if ( options.delay ) {
  				element.delay( options.delay );
  			}
  
  			if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
  				element[ method ]( options );
  			} else if ( effectName !== method && element[ effectName ] ) {
  				element[ effectName ]( options.duration, options.easing, callback );
  			} else {
  				element.queue( function( next ) {
  					$( this )[ method ]();
  					if ( callback ) {
  						callback.call( element[ 0 ] );
  					}
  					next();
  				} );
  			}
  		};
  	} );
  
  	return $.widget;
  
  });
  
  define('skylark-jquery/main',[
      "./core",
      "./ajax",
      "./callbacks",
      "./deferred",
      "./queue",
      "./jquery-plugin",
      "./widget"
  ], function($) {
      return $;
  });
  
  define('skylark-jquery', ['skylark-jquery/main'], function (main) { return main; });
  
  
  },this);
  //# sourceMappingURL=sourcemaps/skylark-jquery.js.map
  