right-rails 0.3.0

data/javascripts/right-src.js

@@ -0,0 +1,4939 @@
+/**
+ * RightJS - the right javascript framework
+ *
+ * The library released under terms of the MIT license
+ * Visit http://rightjs.org for more details
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St.
+ */
+
+/**
+ * The framework description object
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+var RightJS = {
+  version: "1.4.3",
+  modules: ["core", "form", "cookie", "xhr", "fx"]
+};
+
+/**
+ * this object will contain info about the current browser
+ *
+ * Copyright (C) 2008 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+var Browser = (function(agent) {
+  return   {
+    IE:           !!(window.attachEvent && !window.opera),
+    Opera:        !!window.opera,
+    WebKit:       agent.indexOf('AppleWebKit/') > -1,
+    Gecko:        agent.indexOf('Gecko') > -1 && agent.indexOf('KHTML') < 0,
+    MobileSafari: !!agent.match(/Apple.*Mobile.*Safari/),
+    Konqueror:    agent.indexOf('Konqueror') > -1,
+
+    // marker for the browsers which don't give access to the HTMLElement unit
+    OLD:          agent.indexOf('MSIE 6') > -1 || agent.indexOf('MSIE 7') > -1,
+    IE8:          agent.indexOf('MSIE 8') > -1
+  }
+})(navigator.userAgent);
+
+/**
+ * There are some util methods
+ *
+ * Credits:
+ *   Some of the functionality and names are inspired or copied from
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+ 
+/**
+ * extends the first object with the keys and values of the second one
+ *
+ * NOTE: the third optional argument tells if the existing values
+ *       of the first object should _NOT_ get updated by the values of the second object
+ *
+ * @param Object destintation object
+ * @param Object source object
+ * @param Boolean flag if the function should not overwrite intersecting values
+ * @return Objecte extended destination object
+ */
+function $ext(dest, src, dont_overwrite) { 
+  var src = src || {};
+
+  for (var key in src)
+    if (!(dont_overwrite && dest[key] !== undefined))
+      dest[key] = src[key];
+
+  return dest;
+};
+
+/**
+ * tries to execute all the functions passed as arguments
+ *
+ * NOTE: will hide all the exceptions raised by the functions
+ *
+ * @param Function to execute
+ * ......
+ * @return mixed first sucessfully executed function result or undefined by default
+ */
+function $try() {
+  for (var i=0; i < arguments.length; i++) {
+    try {
+      return arguments[i]();
+    } catch(e) {}
+  }
+};
+
+/**
+ * evals the given javascript text in the context of the current window
+ *
+ * @param String javascript
+ * @return void
+ */
+function $eval(text) {
+  if (!isString(text) || text.blank()) return;
+  if (window.execScript) {
+    window.execScript(text);
+  } else {
+    var script = document.createElement('script');
+    script.setAttribute('type', 'text/javascript');
+    script.text = text;
+    document.body.appendChild(script);
+  }
+}
+
+/**
+ * throws an exception to break iterations throw a callback
+ *
+ * @return void
+ * @throws Break
+ */
+function $break() {
+  throw new Break();
+};
+
+/**
+ * generates aliases for the object properties
+ *
+ * @param Object object
+ * @param Object aliases hash
+ * @return Object the extended objects
+ */
+function $alias(object, names) {
+  for (var new_name in names) {
+    object[new_name] = object[names[new_name]];
+  }
+  return object;
+};
+
+/**
+ * checks if the given value or a reference points
+ * to a really defined value
+ *
+ * NOTE: will return true for variables equal to null, false, 0, and so one.
+ *
+ * EXAMPLE:
+ *
+ *   var smth = null;
+ *   defined(smth); <- will return true
+ *
+ *   var obj = {};
+ *   defined(obj['smth']); <- will return false
+ *
+ * @param mixed value
+ * @return boolean check result
+ */
+function defined(value) {
+  return value !== undefined;
+};
+
+/**
+ * checks if the given value is a hash-like object
+ *
+ * @param mixed value
+ * @return boolean check result
+ */
+function isHash(value) {
+  return typeof(value) == 'object' && value !== null && value.constructor === Object;
+};
+
+// Konqueror 3 patch
+if (navigator.userAgent.indexOf('Konqueror/3') != -1) {
+  eval(isHash.toString().replace(';', '&&!(arguments[0] instanceof HTMLElement);'));
+}
+
+
+/**
+ * checks if the given value is a function
+ *
+ * @param mixed value
+ * @return boolean check result
+ */
+function isFunction(value) {
+  return typeof(value) == 'function';
+};
+
+/**
+ * checks if the given value is a string
+ *
+ * @param mixed value
+ * @return boolean check result
+ */
+function isString(value) {
+  return typeof(value) == 'string';
+};
+
+/**
+ * checks if the given value is an array
+ *
+ * @param mixed value to check
+ * @return boolean check result
+ */
+function isArray(value) {
+  return value instanceof Array;
+};
+
+/**
+ * checks if the given value is a number
+ *
+ * @param mixed value to check
+ * @return boolean check result
+ */
+function isNumber(value) {
+  return typeof(value) == 'number';
+};
+
+/**
+ * checks if the given value is an element
+ *
+ * @param mixed value to check
+ * @return boolean check result
+ */
+function isElement(value) {
+  return value && !!value.tagName;
+};
+
+/**
+ * checks if the given value is a DOM-node
+ *
+ * @param mixed value to check
+ * @return boolean check result
+ */
+function isNode(value) {
+  return value && !!value.nodeType;
+};
+
+/**
+ * converts any iterables into an array
+ *
+ * @param Object iterable
+ * @return Array list
+ */
+var $A = (function(slice) {
+  return function (it) {
+    try {
+      var a = slice.call(it);
+    } catch(e) {
+      for (var a=[], i=0, length = it.length; i < length; i++)
+        a[i] = it[i];
+    }
+    return a;
+  };
+})(Array.prototype.slice);
+
+/**
+ * shortcut to instance new elements
+ *
+ * @param String tag name
+ * @param object options
+ * @return Element instance
+ */
+function $E(tag_name, options) {
+  return new Element(tag_name, options);
+};
+
+/**
+ * searches an element by id and/or extends it with the framework extentions
+ *
+ * @param String element id or Element to extend
+ * @return Element or null
+ */
+function $(element) {
+  var element = typeof(element) == 'string' ? document.getElementById(element) : element;
+  return Browser.OLD ? Element.prepare(element) : element;
+};
+
+/**
+ * searches for elements in the document which matches the given css-rule
+ *
+ * @param String css-rule
+ * @return Array matching elements list
+ */
+function $$(css_rule) {
+  return $A(document.querySelectorAll(css_rule));
+};
+
+/**
+ * shortcut, generates an array of words from a given string
+ *
+ * @param String string
+ * @return Array of words
+ */
+function $w(string) {
+  return string.trim().split(/\s+/);
+}
+
+/**
+ * generates an unique id for an object
+ *
+ * @param Object object
+ * @return Integer uniq id
+ */
+var $uid = (function() {
+  var _UID = 1;
+  
+  return function(item) {
+    return item.uid || (item.uid = _UID++);
+  };
+})();
+
+
+/**
+ * The Object class extentions
+ *
+ * Credits:
+ *   Some functionality is inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+$ext(Object, {
+  /**
+   * extracts the list of the attribute names of the given object
+   *
+   * @param Object object
+   * @return Array keys list
+   */
+  keys: function(object) {
+    var keys = [];
+    for (var key in object)
+      keys.push(key);
+    return keys;
+  },
+  
+  /**
+   * extracts the list of the attribute values of the given object
+   *
+   * @param Object object
+   * @return Array values list
+   */
+  values: function(object) {
+    var values = [];
+    for (var key in object)
+      values.push(object[key]);
+    return values;
+  },
+  
+  /**
+   * checks if the object-hash has no keys
+   *
+   * @param Object object
+   * @return check result
+   */
+  empty: function(object) {
+    for (var key in object) break;
+    return !key;
+  },
+  
+  /**
+   * returns a copy of the object which contains
+   * all the same keys/values except the key-names
+   * passed the the method arguments
+   *
+   * @param Object object
+   * @param String key-name to exclude
+   * .....
+   * @return Object filtered copy
+   */
+  without: function() {
+    var filter = $A(arguments), object = filter.shift(), copy = {};
+    
+    for (var key in object)
+      if (!filter.includes(key))
+        copy[key] = object[key];
+    
+    return copy;
+  },
+  
+  /**
+   * returns a copy of the object which contains all the
+   * key/value pairs from the specified key-names list
+   *
+   * NOTE: if some key does not exists in the original object, it will be just skipped
+   *
+   * @param Object object
+   * @param String key name to exclude
+   * .....
+   * @return Object filtered copy
+   */
+  only: function() {
+    var filter = $A(arguments), object = filter.shift(), copy = {};
+    
+    for (var i=0, length = filter.length; i < length; i++) {
+      if (defined(object[filter[i]]))
+        copy[filter[i]] = object[filter[i]];
+    }
+    
+    return copy;
+  },
+    
+  /**
+   * merges the given objects and returns the result
+   *
+   * NOTE this method _DO_NOT_ change the objects, it creates a new object
+   *      which conatins all the given ones. 
+   *      if there is some keys introspections, the last object wins.
+   *      all non-object arguments will be omitted
+   *
+   * @param Object object
+   * @param Object mixing
+   * ......
+   * @return Object merged object
+   */
+  merge: function() {
+    var object = {};
+    for (var i=0, length = arguments.length; i < length; i++) {
+      if (isHash(arguments[i])) {
+        $ext(object, arguments[i]);
+      }
+    }
+    return object;
+  },
+  
+  /**
+   * converts a hash-object into an equivalent url query string
+   *
+   * @param Object object
+   * @return String query
+   */
+  toQueryString: function(object) {
+    var tokens = [];
+    for (var key in object) {
+      tokens.push(key+'='+encodeURIComponent(object[key]))
+    }
+    return tokens.join('&');
+  }
+});
+
+/**
+ * here are the starndard Math object extends
+ *
+ * Credits:
+ *   The idea of random mehtod is taken from
+ *     - Ruby      (http://www.ruby-lang.org) Copyright (C) Yukihiro Matsumoto
+ *
+ * Copyright (C) 2008 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+$ext(Math, {
+  /**
+   * the standard random method replacement, to make it more useful
+   *
+   * USE:
+   *   Math.random();    // original functionality, returns a float between 0 and 1
+   *   Math.random(10);  // returns an integer between 0 and 10
+   *   Math.random(1,4); // returns an integer between 1 and 4
+   *
+   * @param Integer minimum value if there's two arguments and maximum value if there's only one
+   * @param Integer maximum value
+   * @return Float random between 0 and 1 if there's no arguments or an integer in the given range
+   */
+  random: function(min, max) {
+    var rand = this._random();
+    if (arguments.length == 0)
+      return rand;
+    
+    if (arguments.length == 1)
+      var max = min, min = 0;
+    
+    return Math.floor(rand * (max-min+1)+min);
+  },
+  _random: Math.random
+});
+
+/**
+ * The Array class extentions
+ *
+ * Credits:
+ *   Some of the functionality is inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *     - Ruby      (http://www.ruby-lang.org) Copyright (C) Yukihiro Matsumoto
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+$ext(Array.prototype, (function(A_proto) {
+  
+  // JavaScript 1.6 methods recatching up or faking
+  var for_each = A_proto.forEach || function(callback, scope) {
+    for (var i=0, length = this.length; i < length; i++)
+      callback.call(scope, this[i], i, this);
+  };
+  
+  var filter = A_proto.filter || function(callback, scope) {
+    for (var result=[], i=0, length = this.length; i < length; i++) {
+      if (callback.call(scope, this[i], i, this))
+        result.push(this[i]);
+    }
+    return result;
+  };
+  
+  var map = A_proto.map || function(callback, scope) {
+    for (var result=[], i=0, length = this.length; i < length; i++) {
+      result.push(callback.call(scope, this[i], i, this));
+    }
+    return result;
+  };
+  
+  var some = A_proto.some || function(callback, scope) {
+    for (var i=0, length = this.length; i < length; i++) {
+      if (callback.call(scope, this[i], i, this))
+        return true;
+    }
+    return false;
+  };
+  
+  var every = A_proto.every || function(callback, scope) {
+    for (var i=0, length = this.length; i < length; i++) {
+      if (!callback.call(scope, this[i], i, this))
+        return false;
+    }
+    return true;
+  };
+  
+  var first = function(callback, scope) {
+    for (var i=0, length = this.length; i < length; i++) {
+      if (callback.call(scope, this[i], i, this))
+        return this[i];
+    }
+    return undefined;
+  };
+  
+  var last = function(callback, scope) {
+    for (var i=this.length-1; i > -1; i--) {
+      if (callback.call(scope, this[i], i, this))
+        return this[i];
+    }
+    return undefined;
+  };
+  
+  
+  //
+  // RightJS callbacks magick preprocessing
+  //
+  
+  // prepares a correct callback function
+  var guess_callback = function(args, array) {
+    var callback = args[0], args = A_proto.slice.call(args, 1), scope = array;
+    
+    if (isString(callback)) {
+      var attr = callback;
+      if (array.length && isFunction(array[0][attr])) {
+        callback = function(object) { return object[attr].apply(object, args); };
+      } else {
+        callback = function(object) { return object[attr]; };
+      }
+    } else {
+      scope = args[0];
+    }
+    
+    return [callback, scope];
+  };
+  
+  // calls the given method with preprocessing the arguments
+  var call_method = function(func, scope, args) {
+    try {
+      return func.apply(scope, guess_callback(args, scope));
+    } catch(e) { if (!(e instanceof Break)) throw(e); }
+  };
+  
+return {
+  /**
+   * IE fix
+   * returns the index of the value in the array
+   *
+   * @param mixed value
+   * @param Integer optional offset
+   * @return Integer index or -1 if not found
+   */
+  indexOf: A_proto.indexOf || function(value, from) {
+    for (var i=(from<0) ? Math.max(0, this.length+from) : from || 0; i < this.length; i++)
+      if (this[i] === value)
+        return i;
+    return -1;
+  },
+  
+  /**
+   * IE fix
+   * returns the last index of the value in the array
+   *
+   * @param mixed value
+   * @return Integer index or -1 if not found
+   */
+  lastIndexOf: A_proto.lastIndexOf || function(value) {
+    for (var i=this.length-1; i > -1; i--)
+      if (this[i] === value)
+        return i;
+    return -1;
+  },
+  
+  /**
+   * returns the first element of the array
+   *
+   * @return mixed first element of the array
+   */
+  first: function() {
+    return arguments.length ? call_method(first, this, arguments) : this[0];
+  },
+  
+  /**
+   * returns the last element of the array
+   *
+   * @return mixed last element of the array
+   */
+  last: function() {
+    return arguments.length ? call_method(last, this, arguments) : this[this.length-1];
+  },
+  
+  /**
+   * returns a random item of the array
+   *
+   * @return mixed a random item
+   */
+  random: function() {
+    return this.length ? this[Math.random(this.length-1)] : null;
+  },
+  
+  /**
+   * returns the array size
+   *
+   * @return Integer the array size
+   */
+  size: function() {
+    return this.length;
+  },
+  
+  /**
+   * cleans the array
+   * @return Array this
+   */
+  clean: function() {
+    this.length = 0;
+    return this;
+  },
+  
+  /**
+   * checks if the array has no elements in it
+   *
+   * @return boolean check result
+   */
+  empty: function() {
+    return !this.length;
+  },
+  
+  /**
+   * creates a copy of the given array
+   *
+   * @return Array copy of the array
+   */
+  clone: function() {
+    return this.slice(0);
+  },
+  
+  /**
+   * calls the given callback function in the given scope for each element of the array
+   *
+   * @param Function callback
+   * @param Object scope
+   * @return Array this
+   */
+  each: function() {
+    call_method(for_each, this, arguments);
+    return this;
+  },
+  forEach: for_each,
+  
+  /**
+   * creates a list of the array items converted in the given callback function
+   *
+   * @param Function callback
+   * @param Object optional scope
+   * @return Array collected
+   */
+  map: function() {
+    return call_method(map, this, arguments);
+  },
+  
+  /**
+   * creates a list of the array items which are matched in the given callback function
+   *
+   * @param Function callback
+   * @param Object optional scope
+   * @return Array filtered copy
+   */
+  filter: function() {
+    return call_method(filter, this, arguments);
+  },
+  
+  /**
+   * checks if any of the array elements is logically true
+   *
+   * @param Function optional callback for checks
+   * @param Object optional scope for the callback
+   * @return boolean check result
+   */
+  some: function() {
+    return call_method(some, this, arguments.length ? arguments : [function(i) { return !!i; }]);
+  },
+  
+  /**
+   * checks if all the array elements are logically true
+   *
+   * @param Function optional callback for checks
+   * @param Object optional scope for the callback
+   * @return Boolean check result
+   */
+  every: function() {
+    return call_method(every, this, arguments.length ? arguments : [function(i) { return !!i; }]);
+  },
+  
+  /**
+   * applies the given lambda to each element in the array
+   *
+   * NOTE: changes the array by itself
+   *
+   * @param Function callback
+   * @param Object optional scope
+   * @return Array this
+   */
+  walk: function() {
+    this.map.apply(this, arguments).forEach(function(value, i) { this[i] = value; }, this);
+    return this;
+  },
+    
+  /**
+   * similar to the concat function but it adds only the values which are not on the list yet
+   *
+   * @param Array to merge
+   * ....................
+   * @return Array new merged
+   */
+  merge: function() {
+    for (var copy = this.clone(), arg, i=0, length = arguments.length; i < length; i++) {
+      arg = arguments[i];
+      if (isArray(arg)) {
+        for (var j=0; j < arg.length; j++) {
+          if (copy.indexOf(arg[j]) == -1)
+            copy.push(arg[j]);
+        }  
+      } else if (copy.indexOf(arg) == -1) {
+        copy.push(arg);
+      }
+    }
+    return copy;
+  },
+  
+  /**
+   * flats out complex array into a single dimension array
+   *
+   * @return Array flatten copy
+   */
+  flatten: function() {
+    var copy = [];
+    this.forEach(function(value) {
+      if (isArray(value)) {
+        copy = copy.concat(value.flatten());
+      } else {
+        copy.push(value);
+      }
+    });
+    return copy;
+  },
+  
+  /**
+   * returns a copy of the array whithout any null or undefined values
+   *
+   * @return Array filtered version
+   */
+  compact: function() {
+    return this.without(null, undefined);
+  },
+  
+  /**
+   * returns a copy of the array which contains only the unique values
+   *
+   * @return Array filtered copy
+   */
+  uniq: function() {
+    return [].merge(this);
+  },
+  
+  /**
+   * checks if all of the given values
+   * exists in the given array
+   *
+   * @param mixed value
+   * ....
+   * @return boolean check result
+   */
+  includes: function() {
+    for (var i=0, length = arguments.length; i < length; i++)
+      if (this.indexOf(arguments[i]) == -1)
+        return false;
+    return true;
+  },
+  
+  /**
+   * returns a copy of the array without the items passed as the arguments
+   *
+   * @param mixed value
+   * ......
+   * @return Array filtered copy
+   */
+  without: function() {
+    var filter = $A(arguments);
+    return this.filter(function(value) {
+      return !filter.includes(value);
+    });
+  },
+  
+  /**
+   * Shuffles the array items in a random order
+   *
+   * @return Array shuffled version
+   */
+  shuffle: function() {
+    var shuff = this.clone();
+    
+    for (var j, x, i = shuff.length; i;
+       j = Math.random(i-1), x = shuff[--i], shuff[i] = shuff[j], shuff[j] = x);
+    
+    return shuff;
+  },
+  
+  /**
+   * sorts the array by running its items though a lambda or calling their attributes
+   *
+   * @param Function callback or attribute name
+   * @param Object scope or attribute argument
+   * @return Array sorted copy
+   */
+  sortBy: function() {
+    var pair = guess_callback(arguments, this);
+    return this.map(function(item, i) {
+      return {
+        item: item,
+        value: pair[0].call(pair[1], item, i, this)
+      }
+    }).sort(function(a, b) {
+      return a.value > b.value ? 1 : a.value < b.value ? -1 : 0;
+    }).map('item');
+  }
+}})(Array.prototype));
+
+$alias(Array.prototype, {
+  include: 'includes',
+  all: 'every',
+  any: 'some'
+});
+
+/**
+ * The String class extentions
+ *
+ * Credits:
+ *   Some of the functionality inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *   The trim function taken from work of Steven Levithan
+ *     - http://blog.stevenlevithan.com/archives/faster-trim-javascript
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+$ext(String.prototype, {
+  /**
+   * checks if the string is an empty string
+   *
+   * @return boolean check result
+   */
+  empty: function() {
+    return this == '';
+  },
+  
+  /**
+   * checks if the string contains only white-spaces
+   *
+   * @return boolean check result
+   */
+  blank: function() {
+    return /^\s*$/.test(this);
+  },
+  
+  /**
+   * removes trailing whitespaces   
+   *
+   * @return String trimmed version
+   */
+  trim: String.prototype.trim || function() {
+    var str = this.replace(/^\s\s*/, ''), i = str.length;
+    while (/\s/.test(str.charAt(--i)));
+    return str.slice(0, i + 1);
+  },
+  
+  /**
+   * returns a copy of the string with all the tags removed
+   * @return String without tags
+   */
+  stripTags: function() {
+    return this.replace(/<\/?[^>]+>/ig, '');
+  },
+  
+  /**
+   * removes all the scripts declarations out of the string
+   * @param mixed option. If it equals true the scrips will be executed, 
+   *                      if a function the scripts will be passed in it
+   * @return String without scripts
+   */
+  stripScripts: function(option) {
+    var scripts = '';
+    var text = this.replace(/<script[^>]*>([\s\S]*?)<\/script>/img, function(match, source) {
+      scripts += source.trim() + "\n";
+      return '';
+    });
+    
+    if (option === true)
+      $eval(scripts);
+    else if (isFunction(option))
+      option(scripts, text);
+    else if (isNumber(option))
+      $eval.bind(scripts).delay(options);
+    
+    return text;
+  },
+  
+  /**
+   * extracts all the scripts out of the string
+   *
+   * @return String the extracted stcripts
+   */
+  extractScripts: function() {
+    var scripts = '';
+    this.stripScripts(function(s,t) { scripts = s; });
+    return scripts;
+  },
+  
+  /**
+   * evals all the scripts in the string
+   *
+   * @return String self (unchanged version with scripts still in their place)
+   */
+  evalScripts: function() {
+    $eval(this.extractScripts());
+    return this;
+  },
+  
+  /**
+   * converts underscored or dasherized string to a camelized one
+   * @returns String camelized version
+   */
+  camelize: function() {
+    var prefix = this.match(/^(\-|_)+?/g) || ''; // <- keeps start dashes alive
+    return prefix + this.substr(prefix.length, this.length).replace(
+       /(\-|_)+?(\D)/g, function(match) {
+         return match.replace(/\-|_/, '').toUpperCase();
+      });
+  },
+  
+  /**
+   * converts a camelized or dasherized string into an underscored one
+   * @return String underscored version
+   */
+  underscored: function() {
+    return this.replace(/([a-z0-9])([A-Z]+)/g, function(match, first, second) {
+      return first+"_"+(second.length > 1 ? second : second.toLowerCase());
+    }).replace(/\-/g, '_');
+  },
+
+  /**
+   * returns a capitalised version of the string
+   *
+   * @return String captialised version
+   */
+  capitalize: function() {
+    return this.replace(/(^|\s|\-|_)[a-z\u00e0-\u00fe\u0430-\u045f]/g, function(match) {
+      return match.toUpperCase();
+    });
+  },
+  
+  /**
+   * checks if the string contains the given substring
+   *
+   * @param String string
+   * @return boolean check result
+   */
+  includes: function(string) {
+    return this.indexOf(string) != -1;
+  },
+  
+  /**
+   * checks if the string starts with the given substring
+   *
+   * @param String string
+   * @param boolean ignore the letters case
+   * @return boolean check result
+   */
+  startsWith: function(string, ignorecase) {
+    var start_str = this.substr(0, string.length);
+    return ignorecase ? start_str.toLowerCase() == string.toLowerCase() : 
+      start_str == string;
+  },
+  
+  /**
+   * checks if the string ends with the given substring
+   *
+   * @param String substring
+   * @param boolean ignore the letters case
+   * @return boolean check result
+   */
+  endsWith: function(string, ignorecase) {
+    var end_str = this.substring(this.length - string.length);
+    return ignorecase ? end_str.toLowerCase() == string.toLowerCase() :
+      end_str == string;
+  },
+  
+  /**
+   * converts the string to an integer value
+   * @param Integer base
+   * @return Integer or NaN
+   */
+  toInt: function(base) {
+    return parseInt(this, base || 10);
+  },
+  
+  /**
+   * converts the string to a float value
+   * @param boolean flat if the method should not use a flexible matching
+   * @return Float or NaN
+   */
+  toFloat: function(strict) {
+    return parseFloat(strict ? this : this.replace(',', '.').replace(/(\d)-(\d)/g, '$1.$2'));
+  }
+  
+});
+
+$alias(String.prototype, {include: 'includes'});
+
+/**
+ * The Function class extentions
+ *
+ * Credits:
+ *   Some of the functionality inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *
+ * Copyright (C) 2008 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+$ext(Function.prototype, {
+  /**
+   * binds the function to be executed in the given scope
+   *
+   * @param Object scope
+   * @param mixed optional curry (left) argument
+   * ....
+   * @return Function binded function
+   */
+  bind: function() {
+    if (arguments.length < 2 && !defined(arguments[0])) return this;
+    
+    var _method = this, args = $A(arguments), scope = args.shift();
+    return function() {
+      return _method.apply(scope, args.concat($A(arguments)));
+    };
+  },
+  
+  /**
+   * binds the function as an event listener to the given scope object
+   *
+   * @param Object scope
+   * @param mixed optional curry (left) argument
+   * .......
+   * @return Function binded function
+   */
+  bindAsEventListener: function() {
+    var _method = this, args = $A(arguments), scope = args.shift();
+    return function(event) {
+      return _method.apply(scope, [event || window.event].concat(args).concat($A(arguments)));
+    };
+  },
+  
+  /**
+   * allows you to put some curry in your cookery
+   *
+   * @param mixed value to curry
+   * ....
+   * @return Function carried function
+   */
+  curry: function() {
+    return this.bind.apply(this, [this].concat($A(arguments)));
+  },
+  
+  /**
+   * delays the function execution
+   *
+   * @param Integer delay ms
+   * @param mixed value to curry
+   * .....
+   * @return Integer timeout marker
+   */
+  delay: function() {
+    var args  = $A(arguments), timeout = args.shift();
+    var timer = new Number(window.setTimeout(this.bind.apply(this, [this].concat(args)), timeout));
+    
+    timer['cancel'] = function() { window.clearTimeout(this); };
+    
+    return timer;
+  },
+  
+  /**
+   * creates a periodical execution of the function with the given timeout
+   *
+   * @param Integer delay ms
+   * @param mixed value to curry
+   * ...
+   * @return Ineger interval marker
+   */
+  periodical: function() {
+    var args  = $A(arguments), timeout = args.shift();
+    var timer = new Number(window.setInterval(this.bind.apply(this, [this].concat(args)), timeout));
+    
+    timer['stop'] = function() { window.clearInterval(this); };
+    
+    return timer;
+  }
+});
+
+/**
+ * The Number class extentions
+ *
+ * Credits:
+ *   Some methods inspired by
+ *     - Ruby      (http://www.ruby-lang.org) Copyright (C) Yukihiro Matsumoto
+ *
+ * Copyright (C) 2008 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+$ext(Number.prototype, {
+  /**
+   * executes the given callback the given number of times
+   *
+   * @param Function callback
+   * @param Object optional callback execution scope
+   * @return void
+   */
+  times: function(callback, scope) {
+    for (var i=0; i < this; i++)
+      callback.call(scope, i);
+    return this;
+  },
+  
+  upto: function(number, callback, scope) {
+    for (var i=this+0; i <= number; i++)
+      callback.call(scope, i);
+    return this;
+  },
+  
+  downto: function(number, callback, scope) {
+    for (var i=this+0; i >= number; i--)
+      callback.call(scope, i);
+    return this;
+  },
+  
+  abs: function() {
+    return Math.abs(this);
+  },
+  
+  round: function() {
+    return Math.round(this);
+  },
+  
+  ceil: function() {
+    return Math.ceil(this);
+  },
+  
+  floor: function() {
+    return Math.floor(this);
+  }
+});
+
+/**
+ * The Regexp class extentions
+ *
+ * Credits:
+ *   Inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+$ext(RegExp, {
+  /**
+   * Escapes the string for safely use as a regular expression
+   *
+   * @param String raw string
+   * @return String escaped string
+   */
+  escape: function(string) {
+    return String(string).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
+  }
+});
+
+/**
+ * The basic Class unit
+ *
+ * Credits:
+ *   The Class unit is inspired by its implementation in
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *     - Ruby      (http://www.ruby-lang.org) Copyright (C) Yukihiro Matsumoto
+ *
+ * Copyright (C) 2008 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+var Class = function() {
+  var args = $A(arguments), properties = args.pop() || {}, parent = args.pop();
+  
+  // if only the parent class has been specified
+  if (arguments.length == 1 && isFunction(properties)) {
+    parent = properties; properties = {};
+  }
+  
+  // basic class object definition
+  var klass = function() {
+    return this.initialize ? this.initialize.apply(this, arguments) : this;
+  };
+  
+  // attaching main class-level methods
+  $ext(klass, Class.Methods);
+  
+  // handling the parent class assign
+  Class.Util.catchSuper(klass, parent);
+  klass.prototype.constructor = klass; // <- don't put it lower
+  
+  // handling the inlinde extends and includes
+  Class.Util.catchExtends(klass, properties);
+  Class.Util.catchIncludes(klass, properties);
+  
+  klass.include(properties);
+  
+  return klass;
+};
+
+/**
+ * This module contains some utils which hepls handling new classes definition
+ *
+ * Copyright (C) 2008 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Class.Util = {
+  /**
+   * handles the class superclass catching up
+   *
+   * @param Function class
+   * @param Class superclass
+   * @return void
+   */
+  catchSuper: function(klass, parent) {
+    if (parent && defined(parent.prototype)) {  
+      klass.parent = parent;
+      var s_klass = function() {};
+      s_klass.prototype = parent.prototype;
+      klass.prototype = new s_klass;
+    }
+    
+    klass.ancestors = [];
+    while (parent) {
+      klass.ancestors.push(parent);
+      parent = parent.parent;
+    }
+  },
+  
+  /**
+   * handles the inline extendings on class definitions
+   *
+   * @param Function class
+   * @param Object user's properties
+   * @return void
+   */
+  catchExtends: function(klass, properties) {
+    if (properties['extend']) {
+      var exts = properties['extend'];
+      
+      klass.extend.apply(klass, isArray(exts) ? exts : [exts]);
+      delete(properties['extend']);
+    }
+  },
+  
+  /**
+   * handles the inline includes of the class definitions
+   *
+   * @param Function class
+   * @param Object user's properties
+   * @return void
+   */
+  catchIncludes: function(klass, properties) {
+    if (properties['include']) {
+      var includes = properties['include'];
+
+      klass.include.apply(klass, isArray(includes) ? includes : [includes]);
+      delete(properties['include']);
+    }
+  }
+};
+
+/**
+ * This module contains the methods by which the Class instances
+ * will be extended. It provides basic and standard way to work
+ * with the classes.
+ *
+ * Copyright (C) 2008 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Class.Methods = {
+  /**
+   * this method will extend the class-level with the given objects
+   *
+   * NOTE: this method _WILL_OVERWRITE_ the existing itercecting entries
+   *
+   * NOTE: this method _WILL_NOT_OVERWRITE_ the class prototype and
+   *       the class 'name' and 'parent' attributes. If one of those
+   *       exists in one of the received modeuls, the attribute will be
+   *       skipped
+   *
+   * @param Object module to extend
+   * ....
+   * @return Class the klass
+   */
+  extend: function() {
+    var filter = ['prototype', 'name', 'parent', 'extend', 'include'];
+    for (var i=0; i < arguments.length; i++) {
+      if (isHash(arguments[i])) {
+        for (var key in arguments[i]) {
+          if (!filter.includes(key)) {
+            this[key] = arguments[i][key];
+          }
+        }
+      }
+    }
+    
+    return this;
+  },
+  
+  /**
+   * extends the class prototype with the given objects
+   * NOTE: this method _WILL_OVERWRITE_ the existing itercecting entries
+   * NOTE: this method _WILL_NOT_OVERWRITE_ the 'klass' attribute of the klass.prototype
+   *
+   * @param Object module to include
+   * ....
+   * @return Class the klass
+   */
+  include: function() {
+    for (var i=0; i < arguments.length; i++) {
+      if (isHash(arguments[i])) {
+        for (var key in arguments[i]) {
+          if (key != 'klass' && key != 'constructor') {
+            
+            // handling the super methods
+            var ancestor = this.ancestors.first(function(klass) { return isFunction(klass.prototype[key]); });
+            
+            if (ancestor) {
+              (function(name, method, $super) {
+                this.prototype[name] = function() {
+                  this.$super = $super;
+                  
+                  return method.apply(this, arguments);
+                };
+              }).call(this, key, arguments[i][key], ancestor.prototype[key]);
+            } else {
+              this.prototype[key] = arguments[i][key];
+            }
+            
+          }
+        }
+      }
+    }
+    return this;
+  }
+};
+
+/**
+ * This is a simple mix-in module to be included in other classes
+ *
+ * Basically it privdes the <tt>setOptions</tt> method which processes
+ * an instance options assigment and merging with the default options
+ *
+ * Credits:
+ *   The idea of the module is inspired by
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+var Options = {
+  /**
+   * assigns the options by merging them with the default ones
+   *
+   * @param Object options
+   * @return Object current instance
+   */
+  setOptions: function(options) {
+    var names = $w('OPTIONS Options options'),
+      objects = [this, this.constructor].concat(this.constructor.ancestors),
+      OPTIONS = objects.map(function(object) {
+        return names.map(function(name) { return object[name]; });
+      }).flatten().first(function(i) { return !!i; });
+    
+    this.options = Object.merge({}, OPTIONS, options);
+    
+    // hooking up the observer options
+    if (isFunction(this.on)) {
+      var match;
+      for (var key in this.options) {
+        if (match = key.match(/on([A-Z][a-z]+)/)) {
+          this.on(match[1].toLowerCase(), this.options[key]);
+          delete(this.options[key]);
+        }
+      }
+    }
+    
+    return this;
+  }
+};
+
+/**
+ * standard Observer class. 
+ *
+ * Might be used as a usual class or as a builder over another objects
+ *
+ * Credits:
+ *   The naming principle is inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+var Observer = new Class({
+  include: Options,
+  
+  /**
+   * general constructor
+   *
+   * @param Object options
+   */
+  initialize: function(options) {
+    this.setOptions(options);
+    
+    // catching up the event shortucts
+    var ancestor, shorts = this.EVENTS || this.constructor.EVENTS ||
+        ((ancestor = this.constructor.ancestors.first('EVENTS')) ?
+          ancestor.EVENTS : null);
+          
+    Observer.createShortcuts(this, shorts);
+  },
+  
+  /**
+   * starts observing an event
+   *
+   * USAGE:
+   *  observe(String event, Function callback[, arguments, ...]);
+   *  observe(String event, String method_name[, arguments, ...]);
+   *  observe(Object events_hash);
+   *
+   * @return Observer self
+   */
+  observe: function() {
+    var args = $A(arguments), event = args.shift();
+    
+    if (!event.trim) { // <- not a string
+      for (var name in event) {
+        this.observe.apply(this, [name].concat(
+          isArray(event[name]) ? event[name] : [event[name]]
+        ).concat(args));
+      }
+    }
+    
+    if (!this.$listeners) this.$listeners = [];
+    
+    var callback = args.shift();
+    switch (typeof callback) {
+      case "string":
+        callback = this[callback];
+        
+      case "function":
+        var hash = { e: event, f: callback, a: args };
+        this.$listeners.push(hash);
+        
+        if (this.$o && this.$o.add) this.$o.add.call(this, hash);
+        
+        break;
+        
+      default:
+        if (isArray(callback)) {
+          callback.each(function(params) {
+            this.observe.apply(this, [event].concat(
+              isArray(params) ? params : [params]
+            ).concat(args));
+          }, this);
+        }
+    }
+    
+    return this;
+  },
+  
+  /**
+   * checks if the observer observes given event and/or callback
+   *
+   * USAGE:
+   *   observes(String event)
+   *   observes(Function callback)
+   *   observes(String event, Function callback)
+   *
+   * @retun Observer self
+   */
+  observes: function(event, callback) {
+    if (this.$listeners) {
+      if (!isString(event)) { callback = event; event = null; }
+      if (isString(callback)) callback = this[callback];
+      
+      return this.$listeners.some(function(i) {
+        return (event && callback) ? i.e == event && i.f == callback :
+          event ? i.e == event : i.f == callback;
+      });
+    }
+    
+    return false;
+  },
+  
+  /**
+   * stops observing an event or/and function
+   *
+   * USAGE:
+   *   stopObserving(String event)
+   *   stopObserving(Function callback)
+   *   stopObserving(String event, Function callback)
+   *
+   * @return Observer self
+   */
+  stopObserving: function(event, callback) {
+    if (this.$listeners) {
+      if (!isString(event)) { callback = event; event = null; }
+      if (isString(callback)) callback = this[callback];
+      
+      this.$listeners = this.$listeners.filter(function(i) {
+        var result = (event && callback) ? (i.e != event || i.f != callback) :
+          (event ? i.e != event : i.f != callback);
+        
+        if (!result && this.$o && this.$o.remove) this.$o.remove.call(this, i);
+        
+        return result;
+      }, this);
+    }
+    
+    return this;
+  },
+  
+  /**
+   * returns the listeners list for the event
+   *
+   * NOTE: if no event was specified the method will return _all_
+   *       event listeners for _all_ the events
+   *
+   * @param String event name
+   * @return Array of listeners
+   */
+  listeners: function(event) {
+    return (this.$listeners || []).filter(function(i) {
+      return !event || i.e == event;
+    }).map(function(i) { return i.f; }).uniq();
+  },
+  
+  /**
+   * initiates the event handling
+   *
+   * @param String event name
+   * @param mixed optional argument
+   * ........
+   * @return Observer self
+   */
+  fire: function() {
+    var args = $A(arguments), event = args.shift();
+    
+    (this.$listeners || []).each(function(i) {
+      if (i.e == event) {
+        (this.$o && this.$o.fire) ? this.$o.fire.call(this, event, args, i)  :
+          i.f.apply(this, i.a.concat(args));
+      }
+    }, this);
+    
+    return this;
+  },
+  
+  extend: {
+    /**
+     * adds an observer functionality to any object
+     *
+     * @param Object object
+     * @param Array optional events list to build shortcuts
+     * @return Object extended object
+     */
+    create: function(object, events) {
+      $ext(object, Object.without(this.prototype, 'initialize', 'setOptions'), true);
+      return this.createShortcuts(object, events || object['EVENTS']);
+    },
+    
+    /**
+     * builds shortcut methods to wire/fire events on the object
+     *
+     * @param Object object to extend
+     * @param Array list of event names
+     * @return Object extended object
+     */
+    createShortcuts: function(object, names) {
+      (names || []).each(function(name) {
+        var shortcuts = {}, method_name = name.replace(/:/g, '_').camelize();
+        shortcuts[method_name] = function() {
+          return this.fire.apply(this, [name].concat($A(arguments)));
+        };
+        shortcuts['on'+method_name.capitalize()] = function() {
+          return this.on.apply(this, [name].concat($A(arguments)));
+        };
+        $ext(object, shortcuts, true);
+      });
+      
+      return object;
+    }
+  }
+});
+
+$alias(Observer.prototype, { on: 'observe' });
+
+/**
+ * iterators in-callbacks break exception
+ *
+ * Copyright (C) 2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+var Break = new Class(Error, {
+  message: "Manual iterator break"
+});
+
+/**
+ * represents some additional functionality for the Event class
+ *
+ * NOTE: there more additional functionality for the Event class in the rightjs-goods project
+ *
+ * Credits:
+ *   The additional method names are inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+var Event = new Class(Event, {
+  extend: {
+    /**
+     * extends a native object with additional functionality
+     *
+     * @param Event event
+     * @return Event same event but extended
+     */
+    ext: function(event) {
+      if (!event.stop) {
+        $ext(event, this.Methods, true);
+        
+        if (Browser.IE) {
+          // faking the which button
+          if (event.type == 'click' || event.type == 'dblclick') {
+            event.which = 1;
+          } else if (event.type == 'contextmenu') {
+            event.which = 3;
+          } else {
+            event.which = event.button == 2 ? 3 : event.button == 4 ? 2 : 1;
+          }
+          
+          // faking the mouse position
+          var scrolls = window.scrolls();
+
+          event.pageX = event.clientX + scrolls.x;
+          event.pageY = event.clientY + scrolls.y;
+
+
+          // faking the relatedElement
+          event.relatedElement = event.type == 'mouseover' ? event.fromEvent :
+            event.type == 'mouseout' ? event.toEvent : null;
+
+          // faking the target property  
+          event.target = event.srcElement;
+        }
+      }
+      
+      // Safari bug fix
+      if (event.target && event.target.nodeType == 3)
+        event.target = event.target.parentNode;
+      
+      return event;
+    },
+    
+    /**
+     * cleans up the event name
+     *
+     * @param String event name
+     * @return String fixed event name
+     */
+    cleanName: function(name) {
+      name = name.toLowerCase();
+      name = name.startsWith('on') ? name.slice(2) : name;
+      name = name == 'rightclick'  ? 'contextmenu' : name;
+      return name;
+    },
+    
+    /**
+     * returns a real, browser specific event name 
+     *
+     * @param String clean unified name
+     * @return String real name
+     */
+    realName: function(name) {
+      if (Browser.Gecko     && name == 'mousewheel')  name = 'DOMMouseScroll';
+      if (Browser.Konqueror && name == 'contextmenu') name = 'rightclick';
+      return name;
+    },
+    
+    /**
+     * Registers some additional event extendsions
+     *
+     * @param Object methods
+     * @return void
+     */
+    addMethods: function(methods) {
+      $ext(this.Methods, methods);
+      
+      try { // extending the events prototype
+        $ext(Event.parent.prototype, methods, true);
+      } catch(e) {};
+    },
+    
+    // the additional methods registry
+    Methods: {}
+  },
+  
+  /**
+   * just initializes new custom event
+   *
+   * @param String event name
+   * @param Object options
+   * @return Event
+   */
+  initialize: function(name, options) {
+    return new Event.Custom(Event.cleanName(name), options);
+  }
+});
+
+// hooking up the standard extendsions
+Event.addMethods({
+  stopPropagation: function() {
+    this.cancelBubble = true;
+  },
+  
+  preventDefault: function() {
+    this.returnValue = false;
+  },
+  
+  stop: function() {
+    this.stopPropagation();
+    this.preventDefault();
+    return this;
+  },
+  
+  position: function() {
+    return {x: this.pageX, y: this.pageY};
+  }
+});
+
+
+
+
+/**
+ * custom events unit, used as a mediator for the artificial events handling in the generic observer
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Event.Custom = new Class({
+  /**
+   * constructor
+   *
+   * @param String event name
+   * @param Object options
+   */
+  initialize: function(name, options) {
+    this.type = name;
+    $ext(this, options || {});
+  },
+  
+  stop: function() {}
+});
+
+/**
+ * The DOM Element unit handling
+ *
+ * Credits:
+ *   The basic principles of the elements extending are originated from
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+window.Element = new Class(window.Element, {
+  /**
+   * basic constructor
+   *
+   * @param String tag name
+   * @param Object new element options
+   * @return Element object
+   */
+  initialize: function(tag_name, options) {
+    if (Browser.IE && tag_name == 'input' && options && options.checked) {
+      tag_name = '<input checked="true"/>';
+    }
+    
+    var element = $(document.createElement(tag_name)), options = options || {};
+    
+    if (options['html'])    { element.innerHTML = options['html'];  delete(options['html']);    }
+    if (options['class'])   { element.className = options['class']; delete(options['class']);   }
+    if (options['style'])   { element.setStyle(options['style']);   delete(options['style']);   }
+    if (options['observe']) { element.observe(options['observe']);  delete(options['observe']); }
+    
+    return element.set(options);
+  },
+  
+  extend: {
+    Methods: {}, // DO NOT Extend this object manually unless you need it, use Element#addMethods
+    
+    /**
+     * IE browsers manual elements extending
+     *
+     * @param Element
+     * @return Element
+     */
+    prepare: function(element) {
+      if (element && element.tagName && !element.set) {
+        $ext(element, Element.Methods, true);
+        
+        if (self['Form']) {
+          switch(element.tagName) {
+            case 'FORM':
+              Form.ext(element);
+              break;
+
+            case 'INPUT':
+            case 'SELECT':
+            case 'BUTTON':
+            case 'TEXTAREA':
+              Form.Element.ext(element);
+              break;
+          }
+        }
+      }
+      return element;
+    },
+    
+    /**
+     * registeres the methods on the custom element methods list
+     * will add them to prototype and will generate a non extensive static mirror
+     * 
+     * USAGE:
+     *  Element.addMethods({
+     *    foo: function(bar) {}
+     *  });
+     *
+     *  $(element).foo(bar);
+     *  Element.foo(element, bar);
+     *
+     * @param Object new methods list
+     * @param Boolean flag if the method should keep the existing methods alive
+     * @return Element the global Element object
+     */
+    addMethods: function(methods, dont_overwrite) {
+      $ext(this.Methods, methods, dont_overwrite);
+      
+      try { // busting up the basic element prototypes
+        $ext(HTMLElement.prototype, methods, dont_overwrite);
+      } catch(e) {
+        try { // IE8 native element extension
+          $ext(this.parent.prototype, methods, dont_overwrite);
+        } catch(e) {}
+      }
+      
+      return this;
+    }
+  }
+});
+
+/**
+ * The DOM Element unit structures handling module
+ *
+ * NOTE: all the methods will process and return only the Element nodes
+ *       all the textual nodes will be skipped
+ *
+ * NOTE: if a css-rule was specified then the result of the method
+ *       will be filtered/adjusted depends on the rule
+ *
+ *       the css-rule might be a string or a Selector instance
+ *
+ * Credits:
+ *   The naming principle and most of the names are taken from
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *   The insertions system implementation is inspired by
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2008 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Element.addMethods({
+  parent: function(css_rule) {
+    return css_rule ? this.parents(css_rule).first() : $(this.parentNode);
+  },
+  
+  parents: function(css_rule) {
+    return this.rCollect('parentNode', css_rule);
+  },
+  
+  subNodes: function(css_rule) {
+    return this.firstChild ? (this.firstChild.tagName ? [$(this.firstChild)] : []
+      ).concat(this.rCollect.call(this.firstChild, 'nextSibling', css_rule)) : [];
+  },
+  
+  siblings: function(css_rule) {
+    return this.prevSiblings(css_rule).reverse().concat(this.nextSiblings(css_rule));
+  },
+  
+  nextSiblings: function(css_rule) {
+    return this.rCollect('nextSibling', css_rule);
+  },
+  
+  prevSiblings: function(css_rule) {
+    return this.rCollect('previousSibling', css_rule);
+  },
+  
+  next: function(css_rule) {
+    return this.nextSiblings(css_rule).first();
+  },
+  
+  prev: function(css_rule) {
+    return this.prevSiblings(css_rule).first();
+  },
+  
+// those two are moved to the Selector unit definition
+//  first:  Element.Methods.querySelector,
+//  select: Element.Methods.querySelectorAll,
+  
+  match: function(css_rule) {
+    return new Selector(css_rule).match(this);
+  },
+  
+  /**
+   * removes the elemnt out of this parent node
+   *
+   * @return Element self
+   */
+  remove: function() {
+    if (this.parentNode) {
+      this.parentNode.removeChild(this);
+    }
+    return this;
+  },
+  
+  /**
+   * handles the elements insertion functionality
+   *
+   * The content might be one of the following data
+   *
+   *  o) an element instance
+   *  o) a String, which will be converted into content to insert (all the scripts will be parsed out and executed)
+   *  o) a list of Elements 
+   *  o) a hash like {position: content}
+   *
+   * @param mixed data to insert
+   * @param String position to insert  top/bottom/before/after/instead
+   * @return Element self
+   */
+  insert: function(content, position) {
+    if (isHash(content)) {
+      for (var position in content) {
+        this.insert(content[position], position)
+      }
+    } else {
+      var scripts = '';
+      position = isString(position) ? position.toLowerCase() : 'bottom';
+      
+      if (isString(content)) {
+        content = content.stripScripts(function(s, h) { scripts = s; });
+      }
+      
+      Element.insertions[position](this, content.tagName ? content :
+        Element.insertions.createFragment.call(
+          (position == 'bottom' || position == 'top' || !this.parentNode) ?
+            this : this.parentNode, content
+        )
+      );
+      $eval(scripts);
+    }
+    return this;
+  },
+  
+  insertTo: function(element, position) {
+    $(element).insert(this, position);
+    return this;
+  },
+  
+  /**
+   * replaces the current element by the given content
+   *
+   * @param mixed content (a String, an Element or a list of elements)
+   * @return Element self
+   */
+  replace: function(content) {
+    return this.insert(content, 'instead');
+  },
+  
+  /**
+   * updates the content of the element by the given content
+   *
+   * @param mixed content (a String, an Element or a list of elements)
+   * @return Element self
+   */
+  update: function(content) {
+    if (isString(content)) {
+      this.innerHTML = content.stripScripts();
+      content.evalScripts();
+    } else {
+      this.clean().insert(content);
+    }
+    return this;
+  },
+  
+  /**
+   * wraps the element with the given element
+   *
+   * @param Element wrapper
+   * @return Element self
+   */
+  wrap: function(element) {
+    if (this.parentNode) {
+      this.parentNode.replaceChild(element, this);
+      element.appendChild(this);
+    }
+    return this;
+  },
+  
+  /**
+   * removes all the child nodes out of the element
+   *
+   * @return Element self
+   */
+  clean: function() {
+    while (this.firstChild) {
+      this.removeChild(this.firstChild);
+    }
+    
+    return this;
+  },
+  
+  /**
+   * checks if the element has no child nodes
+   *
+   * @return boolean check result
+   */
+  empty: function() {
+    return this.innerHTML.blank();
+  },
+
+  /**
+   * recursively collects nodes by pointer attribute name
+   *
+   * @param String pointer attribute name
+   * @param String optional css-atom rule
+   * @return Array found elements
+   */
+  rCollect: function(attr, css_rule) {
+    var node = this, nodes = [];
+
+    while ((node = node[attr])) {
+      if (node.tagName && (!css_rule || new Selector(css_rule).match(node))) {
+        nodes.push(Browser.OLD ? Element.prepare(node) : node);
+      }
+    }
+    
+    return nodes;
+  }
+});
+
+// list of insertions handling functions
+// NOTE: each of the methods will be called in the contects of the current element
+Element.insertions = {
+  bottom: function(target, content) {
+    target.appendChild(content);
+  },
+  
+  top: function(target, content) {
+    target.firstChild ? target.insertBefore(content, target.firstChild) : target.appendChild(content);
+  },
+  
+  after: function(target, content) {
+    if (target.parentNode) {
+      target.nextSibling ? target.parentNode.insertBefore(content, target.nextSibling) : target.parentNode.appendChild(content);
+    }
+  },
+  
+  before: function(target, content) {
+    if (target.parentNode) {
+      target.parentNode.insertBefore(content, target);
+    }
+  },
+  
+  instead: function(target, content) {
+    if (target.parentNode) {
+      target.parentNode.replaceChild(content, target);
+    }
+  },
+  
+  // converts any data into a html fragment unit
+  createFragment: function(content) {
+    var fragment;
+    
+    if (isString(content)) {
+      var tmp = document.createElement('div'),
+          wrap = Element.insertions.wraps[this.tagName] || ['', '', 0],
+          depth = wrap[2];
+          
+      tmp.innerHTML = wrap[0] + content + wrap[1];
+      
+      while (depth > 0) {
+        tmp = tmp.firstChild;
+        depth--;
+      }
+      
+      fragment = arguments.callee.call(this, tmp.childNodes);
+      
+    } else {
+      fragment = document.createDocumentFragment();
+      
+      if (isNode(content)) {
+        fragment.appendChild(content);
+      } else if (content && content.length) {
+        for (var i=0, length = content.length; i < length; i++) {
+          // in case of NodeList unit, the elements will be removed out of the list during the appends
+          // therefore if that's an array we use the 'i' variable, and if it's a collection of nodes
+          // then we always hit the first element of the stack
+          fragment.appendChild(content[content.length == length ? i : 0]);
+        }
+      }
+    }
+    
+    return fragment;
+  },
+  
+  wraps: {
+    TABLE:  ['<table>',                '</table>',                   1],
+    TBODY:  ['<table><tbody>',         '</tbody></table>',           2],
+    TR:     ['<table><tbody><tr>',     '</tr></tbody></table>',      3],
+    TD:     ['<table><tbody><tr><td>', '</td></tr></tbody></table>', 4],
+    SELECT: ['<select>',               '</select>',                  1]
+  }
+};
+$alias(Element.insertions.wraps, {
+  THEAD: 'TBODY',
+  TFOOT: 'TBODY',
+  TH:    'TD'
+});
+
+/**
+ * this module contains the element unit styles related methods
+ *
+ * Credits:
+ *   Some of the functionality is inspired by 
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *     - Dojo      (www.dojotoolkit.org)      Copyright (C) The Dojo Foundation
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Element.addMethods({
+  /**
+   * assigns styles out of the hash to the element
+   *
+   * NOTE: the style keys might be camelized or dasherized, both cases should work
+   *
+   * @param Object styles list or String style name
+   * @param String style value in case of the first param a string style name
+   * @return Element self
+   */
+  setStyle: function(hash, value) {
+    if (value) { var style = {}; style[hash] = value; hash = style; }
+    else if(isString(hash)) {
+      var style = {};
+      hash.split(';').each(function(option) {
+        var els = option.split(':').map('trim');
+        if (els[0] && els[1]) {
+          style[els[0]] = els[1];
+        }
+      });
+      hash = style;
+    }
+    
+    var c_key;
+    for (var key in hash) {
+      c_key = key.indexOf('-') != -1 ? key.camelize() : key;
+      
+      if (key == 'opacity') {
+        this.setOpacity(hash[key]);
+      } else if (key == 'float') {
+        c_key = Browser.IE ? 'styleFloat' : 'cssFloat';
+      }
+      
+      this.style[c_key] = hash[key];
+    }
+    
+    return this;
+  },
+  
+  /**
+   * handles the opacity setting
+   *
+   * @param Float opacity value between 0 and 1
+   * @return Element self
+   */
+  setOpacity: function(value) {
+    var key = 'opacity';
+    if (Browser.IE) {
+      key = 'filter';
+      value = 'alpha(opacity='+ value * 100 +')';
+    }
+    this.style[key] = value;
+    return this;
+  },
+  
+  /**
+   * returns style of the element
+   *
+   * NOTE: will include the CSS level definitions
+   *
+   * @param String style key
+   * @return String style value or null if not set
+   */
+  getStyle: function(key) {
+    return this._getStyle(this.style, key) || this._getStyle(this.computedStyles(), key);
+  },
+  
+  /**
+   * returns the hash of computed styles for the element
+   *
+   * @return Object/CSSDefinition computed styles
+   */
+  computedStyles: function() {
+    //     old IE,              IE8,                 W3C
+    return this.currentStyle || this.runtimeStyle || this.ownerDocument.defaultView.getComputedStyle(this, null) || {};
+  },
+  
+  // cleans up the style value
+  _getStyle: function(style, key) {
+    var value, key = key.camelize();
+    
+    switch (key) {
+      case 'opacity':
+        value = !Browser.IE ? style[key] :
+          (((style['filter'] || '').match(/opacity=(\d+)/i) || ['', '100'])[1].toInt() / 100)+'';
+        break;
+        
+      case 'float':
+        key   = Browser.IE ? 'styleFloat' : 'cssFloat';
+        
+      default:
+        if (style[key]) {
+          value = style[key];
+        } else {
+          var values = $w('top right bottom left').map(function(name) {
+            var tokens = key.underscored().split('_'); tokens.splice(1, 0, name);
+            return style[tokens.join('_').camelize()];
+          }).uniq();
+
+          if (values.length == 1) {
+            value = values[0];
+          }
+        }
+        
+        // Opera returns named colors with quotes
+        if (value && Browser.Opera && /color/.test(key)) {
+          var match = value.match(/"(.+?)"/);
+          value = match ? match[1] : value;
+        }
+    }
+    
+    return value ? value : null;
+  },
+  
+  /**
+   * checks if the element has the given class name
+   * 
+   * @param String class name
+   * @return boolean check result
+   */
+  hasClass: function(name) {
+    return (' '+this.className+' ').indexOf(' '+name+' ') != -1;
+  },
+  
+  /**
+   * sets the whole class-name string for the element
+   *
+   * @param String class-name
+   * @return Element self
+   */
+  setClass: function(class_name) {
+    this.className = class_name;
+    return this;
+  },
+
+  /**
+   * adds the given class name to the element
+   *
+   * @param String class name
+   * @return Element self
+   */
+  addClass: function(name) {
+    if ((' '+this.className+' ').indexOf(' '+name+' ') == -1) {
+      this.className += (this.className ? ' ' : '') + name;
+    }
+    return this;
+  },
+  
+  /**
+   * removes the given class name
+   *
+   * @param String class name
+   * @return Element self
+   */
+  removeClass: function(name) {
+    this.className = (' '+this.className+' ').replace(' '+name+' ', ' ').trim();
+    return this;
+  },
+  
+  /**
+   * toggles the given class name on the element
+   *
+   * @param String class name
+   * @return Element self
+   */
+   toggleClass: function(name) {
+     return this[this.hasClass(name) ? 'removeClass' : 'addClass'](name);
+   },
+   
+   /**
+    * adds the given class-name to the element
+    * and removes it from all the element siblings
+    *
+    * @param String class name
+    * @return Element self
+    */
+   radioClass: function(name) {
+     this.siblings().each('removeClass', name);
+     return this.addClass(name);
+   }
+});
+
+/**
+ * Common DOM Element unit methods
+ *
+ * Credits:
+ *   Most of the naming system in the module inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *
+ * Copyright (C) 2008 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+Element.addMethods({
+  /**
+   * sets the element attributes
+   *
+   * @param String attr name or Object attributes hash
+   * @param mixed attribute value
+   * @return Element self
+   */
+  set: function(hash, value) {
+    if (value) { var val = {}; val[hash] = value; hash = val; }
+
+    for (var key in hash)
+      this[key] = hash[key];
+      
+    return this;
+  },
+  
+  /**
+   * returns the attribute value for the name
+   *
+   * @param String attr name
+   * @return mixed value
+   */
+  get: function(name) {
+    var value = this.getAttribute(name) || this[name];
+    return value == '' ? null : value;
+  },
+  
+  /**
+   * checks if the element has that attribute
+   *
+   * @param String attr name
+   * @return Boolean check result
+   */
+  has: function(name) {
+    return this.get(name) != null;
+  },
+  
+  /**
+   * erases the given attribute of the element
+   *
+   * @param String attr name
+   * @return Element self
+   */
+  erase: function(name) {
+    this.removeAttribute(name);
+    return this;
+  },
+  
+  /**
+   * checks if the elemnt is hidden
+   *
+   * NOTE: will check css level computed styles too
+   *
+   * @return boolean check result
+   */
+  hidden: function() {
+    return this.getStyle('display') == 'none';
+  },
+  
+  /**
+   * checks if the element is visible
+   *
+   * @return boolean check result
+   */
+  visible: function() {
+    return !this.hidden();
+  },
+  
+  /**
+   * hides the element
+   *
+   * @param String optional effect name
+   * @param Object the optional effect options
+   * @return Element self
+   */
+  hide: function(effect, options) {
+    this._$pd = this.getStyle('display');
+    this.style.display = 'none';
+    return this;
+  },
+  
+  /**
+   * shows the element
+   *
+   * @param String optional effect name
+   * @param Object the optional effect options
+   * @return Element self
+   */
+  show: function(effect, options) {
+    // setting 'block' for the divs and 'inline' for the other elements hidden on the css-level
+    var value = this.tagName == 'DIV' ? 'block' : 'inline';
+    this.style.display = this._$pd == 'none' ? value : this._$pd || value;
+    return this;
+  },
+  
+  /**
+   * toggles the visibility state of the element
+   *
+   * @param String optional effect name
+   * @param Object the optional effect options
+   * @return Element self
+   */
+  toggle: function(effect, options) {
+    return this[this.hidden() ? 'show' : 'hide'](effect, options);
+  },
+  
+  /**
+   * shows the element and hides all the sibligns
+   *
+   * @param String optional effect name
+   * @param Object the optional effect options
+   * @return Element self
+   */
+  radio: function(effect, options) {
+    this.siblings().each('hide', effect, options);
+    return this.show();
+  }
+});
+
+/**
+ * this module contains the Element's part of functionality 
+ * responsible for the dimensions and positions getting/setting
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+Element.addMethods({
+  
+  sizes: function() {
+    return { x: this.offsetWidth, y: this.offsetHeight };
+  },
+  
+  position: function() {
+    var dims = this.dimensions();
+    return { x: dims.left, y: dims.top };
+  },
+  
+  scrolls: function() {
+    return { x: this.scrollLeft, y: this.scrollTop };
+  },
+  
+  /**
+   * returns the element dimensions hash
+   *
+   * @return Object dimensions (top, left, width, height, scrollLeft, scrollTop)
+   */
+  dimensions: function() {
+    var left = 0, top = 0;
+    
+    if (this.getBoundingClientRect) {
+      var rect = this.getBoundingClientRect(), doc = this.ownerDocument.documentElement, scrolls = window.scrolls();
+      
+      left = rect.left + scrolls.x - doc.clientLeft;
+      top  = rect.top  + scrolls.y - doc.clientTop;
+    } else {
+      // Manual version
+      left = this.offsetLeft;
+      top  = this.offsetTop;
+      
+      if (this.getStyle('position') != 'absolute') {
+        var body = this.ownerDocument.body, html = body.parentNode;
+        
+        left += body.offsetLeft + html.offsetLeft;
+        top  += body.offsetTop  + html.offsetTop;
+      }
+    }
+    
+    return {
+      top:        top,
+      left:       left,
+      width:      this.sizes().x,
+      height:     this.sizes().y,
+      scrollLeft: this.scrolls().x,
+      scrollTop:  this.scrolls().y
+    };
+  },
+  
+  /**
+   * sets the width of the element in pixels
+   *
+   * NOTE: will double assign the size of the element, so it match the exact
+   *       size including any possible borders and paddings
+   *
+   * @param Integer width in pixels
+   * @return Element self
+   */
+  setWidth: function(width_px) {
+    this.style.width = width_px + 'px';
+    if (this.offsetWidth) this.style.width = (2 * width_px - this.offsetWidth) + 'px';
+    return this;
+  },
+  
+  /**
+   * sets the width of the element in pixels
+   *
+   * NOTE: will double assign the size of the element, so it match the exact
+   *       size including any possible borders and paddings
+   *
+   * @param Integer height in pixels
+   * @return Element self
+   */
+  setHeight: function(height_px) {
+    this.style.height = height_px + 'px';
+    if (this.offsetHeight) this.style.height = (2 * height_px - this.offsetHeight) + 'px';
+    return this;
+  },
+  
+  /**
+   * sets the size of the element in pixels
+   *
+   * NOTE: will double assign the size of the element, so it match the exact
+   *       size including any possible borders and paddings
+   *
+   * @param Integer width in pixels or {x: 10, y: 20} like object
+   * @param Integer height
+   * @return Element self
+   */
+  resize: function(width, height) {
+    if (isHash(width)) {
+      height = width.y;
+      width  = width.x;
+    }
+    
+    this.setWidth(width);
+    return this.setHeight(height);
+  },
+  
+  /**
+   * sets the element position (against the window corner)
+   *
+   * @param Number left position in pixels or an object like {x: 10, y: 20}
+   * @param Number top position in pixels
+   * @return Element self
+   */
+  moveTo: function(left, top) {
+    if (isHash(left)) {
+      top  = left.y;
+      left = left.x;
+    }
+    
+    return this.setStyle({
+      left: left + 'px',
+      top:  top  + 'px'
+    });
+  },
+  
+  /**
+   * sets the scroll position
+   *
+   * @param Integer left scroll px or an object like {x: 22, y: 33}
+   * @param Integer top scroll px
+   * @return Element self
+   */
+  scrollTo: function(left, top) {
+    if (isHash(left)) {
+      top  = left.y;
+      left = left.x;
+    }
+    
+    this.scrollLeft = left;
+    this.scrollTop  = top;
+    
+    return this;
+  },
+  
+  /**
+   * makes the window be scrolled to the element
+   *
+   * @return Element self
+   */
+  scrollThere: function() {
+    window.scrollTo(this);
+    return this;
+  }
+});
+
+/**
+ * DOM Element events handling methods
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+Element.addMethods((function() {
+  var observer = Observer.create({}, 
+    $w('click rightclick contextmenu mousedown mouseup mouseover mouseout mousemove keypress keydown keyup')
+  );
+  
+  observer.$o = {
+    add: function(hash) {
+      var callback = hash.f, args = hash.a;
+      hash.e = Event.cleanName(hash.e);
+      hash.n = Event.realName(hash.e);
+      
+      hash.w = function() {
+        Event.ext(arguments[0]);
+        return callback.apply(this, $A(arguments).concat(args));
+      };
+      
+      if (this.addEventListener) {
+        this.addEventListener(hash.n, hash.w, false);
+      } else {
+        hash.w = hash.w.bind(this);
+        this.attachEvent('on'+ hash.n, hash.w);
+      }
+    },
+    
+    remove: function(hash) {
+      if (this.removeEventListener) {
+        this.removeEventListener(hash.n, hash.w, false);
+      } else {
+        this.detachEvent('on'+ hash.n, hash.w);
+      }
+    },
+    
+    fire: function(name, args, hash) {
+      var event = new Event(name, args.shift());
+      hash.f.apply(this, [event].concat(hash.a).concat(args));
+    }
+  };
+  
+  // a simple events terminator method to be hooked like
+  // this.onClick('stopEvent');
+  observer.stopEvent = function(e) { e.stop(); };
+  
+  $ext(window,   observer);
+  $ext(document, observer);
+  
+  return observer;
+})());
+
+
+/**
+ * The DOM elements selection handling class
+ *
+ * Credits:
+ *   The naming principles of the unit are inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+
+// checking, monkeying and hooking the native css-selectors interface
+//          IE8               W3C
+[document, (Element.parent || self['HTMLElement'] || {}.constructor).prototype].each(function(object, i) {
+  var old_selector     = object.querySelector;
+  var old_selector_all = object.querySelectorAll;
+  
+  // the native selectors checking/monkeying
+  var selectors = {};
+  if (!old_selector) selectors.querySelector = function(css_rule) {
+    return new Selector(css_rule).first(this);
+  };
+  if (!old_selector_all) selectors.querySelectorAll = function(css_rule) {
+    return new Selector(css_rule).select(this);
+  };
+  
+  // RightJS version of the selectors
+  selectors.first = old_selector ? i ? function(css_rule) {
+    return this.querySelector(this.tagName + ' ' + (css_rule || '*'));
+  } : function(css_rule) {
+    return this.querySelector(css_rule || '*');
+  } : selectors.querySelector;
+  
+  selectors.select = old_selector_all ? i ? function(css_rule) {
+    return $A(this.querySelectorAll(this.tagName + ' ' + (css_rule || '*')));
+  } : function(css_rule) {
+    return $A(this.querySelectorAll(css_rule || '*'));
+  } : selectors.querySelectorAll;
+  
+  return i ? Element.addMethods(selectors) : $ext(object, selectors);
+});
+
+
+var Selector = new Class({
+  extend: {
+    cache: {}
+  },
+    
+  /**
+   * constructor
+   *
+   * @param String css rule definition
+   * @return void
+   */
+  initialize: function(css_rule) {
+    var cached = isString(css_rule) ? Selector.cache[css_rule] : css_rule;
+    if (cached) return cached;
+    Selector.cache[css_rule] = this;
+    
+    this.cssRule = css_rule || '*';
+    
+    var strategy = 'Manual';
+    if (this.cssRule.includes(',')) {
+      strategy = 'Multiple';
+    }
+    
+    this.strategy = new Selector[strategy](this.cssRule);
+  },
+  
+  /**
+   * selects the first matching element which is a sub node of the given element
+   * and matches the selector's css-rule
+   *
+   * @param Element element
+   * @return Element matching element or null if nothing found
+   */
+  first: Browser.OLD ? function(element) {
+    var element = this.strategy.first(element);
+    return  element ? $(element) : null;
+  } : function(element) {
+    return this.strategy.first(element);
+  },
+  
+  /**
+   * select all the subnodes of the element which are matching the rule
+   *
+   * @param Element element
+   * @return Array list of found nodes
+   */
+  select: Browser.OLD ? function(element) {
+    return this.strategy.select(element).map(Element.prepare);
+  } : function(element) {
+    return this.strategy.select(element);
+  },
+  
+  /**
+   * checks if the element matches the rule
+   *
+   * @param Element element
+   * @return Boolean check result
+   */
+  match: function(element) {
+    return this.strategy.match(element);
+  }
+});
+
+
+/**
+ * this class represent a simple css-definition atom unit
+ *
+ * the main purpose is to organize the simpliest case of css-rule match for the manual matcher.
+ *
+ * Credits:
+ *   Some functionality and principles are inspired by css-selectors in
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Selector.Atom = new Class({
+  id: null,
+  tag: '*',
+  classes: [],
+  pseudo: null,
+  pseudoValue: null,
+  attrs: {},
+
+  rel: ' ', // relations with the previous atom
+
+  ID_RE:     /#([\w\-_]+)/,
+  TAG_RE:    /^[\w\*]+/,
+  CLASS_RE:  /\.([\w\-\._]+)/,
+  PSEUDO_RE: /:([\w\-]+)(\((.+?)\))*$/,
+  ATTRS_RE:  /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/,
+
+  /**
+   * constructor
+   *
+   * @param String css-definition
+   * @param String relation with the previous atom
+   * @return void
+   */
+  initialize: function(css_rule, rel) {
+    css_rule = css_rule.trim();
+    this.rel = rel || ' ';
+    this.hasNonTagMatcher = !/^[a-z\*]+$/.test(css_rule);
+    
+    // NOTE! dont change the order of the atom parsing, there might be collisions
+    this.attrs = {};
+    while((m = css_rule.match(this.ATTRS_RE))) {
+      this.attrs[m[1]] = { op: m[2], value: m[5] || m[6] };
+      css_rule = css_rule.replace(m[0], '');
+    }
+    
+    if ((m = css_rule.match(this.PSEUDO_RE))) {
+      this.pseudo = m[1];
+      this.pseudoValue = m[3] == '' ? null : m[3];
+      css_rule = css_rule.replace(m[0], '');
+    } else {
+      this.pseudo = null;
+      this.pseudoValue = null;
+    }
+    
+    this.id  = (css_rule.match(this.ID_RE) || [1, null])[1];
+    this.tag = (css_rule.match(this.TAG_RE) || '*').toString().toUpperCase();
+    this.classes = (css_rule.match(this.CLASS_RE) || [1, ''])[1].split('.').without('');
+    
+    this.buildMatch();
+  },
+
+  /**
+   * cecks if the node matches the atom
+   *
+   * @param Element element
+   * @return Boolean check result
+   */
+  match: null, // this method is dinamically generated depend on the situation
+
+// protected
+
+  // building the match method for the particular case
+  buildMatch: function() {
+    var matchers = [];
+    
+    if (this.id)                   matchers.push('matchId');
+    if (this.tag != '*')           matchers.push('matchTag');
+    if (this.classes.length)       matchers.push('matchClass');
+    if (!Object.empty(this.attrs)) matchers.push('matchAttrs');
+    if (this.pseudo)               matchers.push('matchPseudo');
+    
+    if (matchers.length == 1) {
+      this.match = this[matchers[0]];
+    } else if (matchers.length) {
+      var length = matchers.length;
+      this.match = function(element) {
+        for (var i=0; i < length; i++)
+          if (!this[matchers[i]](element))
+            return false;
+        return true;
+      }
+    } else {
+      this.match = function() { return true; }
+    }
+  },
+
+  matchId: function(element) {
+    return element.id == this.id;
+  },
+
+  matchTag: function(element) {
+    return element.tagName == this.tag;
+  },
+
+  matchClass: function(element) {
+    if (element.className) {
+      var names = element.className.split(' ');
+      if (names.length == 1) {
+        return this.classes.indexOf(names[0]) != -1;
+      } else {
+        for (var i=0, length = this.classes.length; i < length; i++)
+          if (names.indexOf(this.classes[i]) == -1)
+            return false;
+            
+        return true;
+      }
+    }
+    return false;
+  },
+
+  matchAttrs: function(element) {
+    var matches = true;
+    for (var key in this.attrs) {
+      matches &= this.matchAttr(element, key, this.attrs[key]['op'], this.attrs[key]['value']);
+    }
+    return matches;
+  },
+  
+  matchAttr: function(element, name, operator, value) {
+    var attr = element.getAttribute(name) || '';
+    switch(operator) {
+      case '=':  return attr == value;
+      case '*=': return attr.includes(value);
+      case '^=': return attr.startsWith(value);
+      case '$=': return attr.endsWith(value);
+      case '~=': return attr.split(' ').includes(value);
+      case '|=': return attr.split('-').includes(value);
+      default:   return attr != '';
+    }
+    return false;
+  },
+
+  matchPseudo: function(element) {
+    return this.pseudoMatchers[this.pseudo].call(element, this.pseudoValue, this.pseudoMatchers);
+  },
+
+  /**
+   * W3C pseudo matchers
+   *
+   * NOTE: methods of the module will be called in a context of an element
+   */
+  pseudoMatchers: {
+    checked: function() {
+      return this.checked;
+    },
+    
+    disabled: function() {
+      return this.disabled;
+    },
+
+    empty: function() {
+      return !(this.innerText || this.innerHTML || this.textContent || '').length;
+    },
+
+    'first-child': function(tag_name) {
+      var node = this;
+      while ((node = node.previousSibling)) {
+        if (node.tagName && (!tag_name || node.tagName == tag_name)) {
+          return false;
+        }
+      }
+      return true;
+    },
+    
+    'first-of-type': function() {
+      return arguments[1]['first-child'].call(this, this.tagName);
+    },
+
+    'last-child': function(tag_name) {
+      var node = this;
+      while ((node = node.nextSibling)) {
+        if (node.tagName && (!tag_name || node.tagName == tag_name)) {
+          return false;
+        }
+      }
+      return true;
+    },
+    
+    'last-of-type': function() {
+      return arguments[1]['last-child'].call(this, this.tagName);
+    },
+
+    'only-child': function(tag_name, matchers) {
+      return matchers['first-child'].call(this, tag_name) 
+        && matchers['last-child'].call(this, tag_name);
+    },
+    
+    'only-of-type': function() {
+      return arguments[1]['only-child'].call(this, this.tagName, arguments[1]);
+    },
+
+    'nth-child': function(number, matchers, tag_name) {
+      if (!matchers.hasParent(this)) return false;
+      number = number.toLowerCase();
+      
+      if (number == 'n') return true;
+      
+      if (number.includes('n')) {
+        // parsing out the matching expression
+        var a = b = 0;
+        if (m = number.match(/^([+-]?\d*)?n([+-]?\d*)?$/)) {
+          a = m[1] == '-' ? -1 : parseInt(m[1], 10) || 1;
+          b = parseInt(m[2], 10) || 0;
+        }
+        
+        // getting the element index
+        var index = 1, node = this;
+        while ((node = node.previousSibling)) {
+          if (node.tagName && (!tag_name || node.tagName == tag_name)) index++;
+        }
+        
+        return (index - b) % a == 0 && (index - b) / a >= 0;
+        
+      } else {
+        return matchers['index'].call(this, number.toInt() - 1, matchers, tag_name);
+      }
+    },
+    
+    'nth-of-type': function(number) {
+      return arguments[1]['nth-child'].call(this, number, arguments[1], this.tagName);
+    },
+    
+// protected
+    index: function(number, matchers, tag_name) {
+      number = isString(number) ? number.toInt() : number;
+      var node = this, count = 0;
+      while ((node = node.previousSibling)) {
+        if (node.tagName && (!tag_name || node.tagName == tag_name) && ++count > number) return false;
+      }
+      return count == number;
+    },
+    
+    // checking if the element has a parent node
+    // the '-----fake' parent is a temporary context for the element
+    // just of the matching process
+    hasParent: function(element) {
+      return element.parentNode && element.parentNode.id != '-----fake';
+    }
+  }
+});
+
+/**
+ * represents a manual (virtual) selector strategy
+ *
+ * Credits:
+ *   Some principles were inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Selector.Manual = new Class({
+  ATOMS_SPLIT_RE: /(\s*([~>+ ])\s*)(?![^\s\)\]]*(\)|\]))/,
+  
+  /**
+   * constructor
+   *
+   * @param String css-rule
+   */
+  initialize: function(css_rule) {
+    var css_rule = css_rule.trim();
+    this.cssRule = css_rule;
+    
+    this.atoms = [];
+
+    var relation = null, match = null;
+
+    while (match = css_rule.match(this.ATOMS_SPLIT_RE)) {
+      separator_pos = css_rule.indexOf(match[0]);
+      this.atoms.push(new Selector.Atom(css_rule.substring(0, separator_pos), relation));
+
+      relation = match[2]; // <- puts the current relation to the next atom
+
+      // chopping off the first atom of the rule
+      css_rule = css_rule.substr(separator_pos+(match[1].length==1 ? 1 : match[1].length-1)).trim();
+    }
+    this.atoms.push(new Selector.Atom(css_rule, relation));
+  },
+
+  /**
+   * searches for the first matching subnode
+   *
+   * @param Element base node
+   * @return Element matching element or null if nothing found
+   */
+  first: function(node) {
+    return this.select(node).first();
+  },
+
+  /**
+   * selects all the matching subnodes
+   *
+   * @param Element base node
+   * @return Array found nodes
+   */
+  select: function(node) {
+    var founds, atom, index, sub_founds;
+    
+    for (var i=0, i_length = this.atoms.length; i < i_length; i++) {
+      atom = this.atoms[i];
+      if (i == 0) {
+        founds =  this.find[atom.rel](node, atom);
+        
+      } else {
+        if (i > 1) founds = this.uniq(founds);
+        
+        for (var j=0; j < founds.length; j++) {
+          sub_founds = this.find[atom.rel](founds[j], atom);
+          
+          sub_founds.unshift(1); // <- nuke the parent node out of the list
+          sub_founds.unshift(j); // <- position to insert the subresult
+
+          founds.splice.apply(founds, sub_founds);
+          
+          j += sub_founds.length - 3;
+        }
+      }
+    }
+    
+    return this.atoms.length > 1 ? this.uniq(founds) : founds;
+  },
+
+  /**
+   * checks if the node matches the rule
+   *
+   * @param Element node to check
+   * @return boolean check result
+   */
+  match: function(element) {
+    // if there's more than one atom, we match the element in a context
+    if (!this.atoms || this.atoms.length > 1) {
+      if (element.parentNode) {
+          // searching for the top parent node
+          // NOTE: don't use the Element.parents in here to avoid annecessary elements extending
+          var p = element, parent;
+          while ((p = p.parentNode)) parent = p;
+        } else {
+          // putting the element in a temporary context so we could test it
+          var parent = document.createElement('div'), parent_is_fake = true;
+          parent.id = '-----fake'; // <- this id is used in the manual 'match' method,
+                                   // to determine if the element originally had no parent node
+          parent.appendChild(element);
+        }
+
+        var match = this.select(parent).includes(element);
+        if (parent_is_fake) parent.removeChild(element);
+    } else {
+      // if there's just one atom, we simple match against it.
+      var match = this.atoms[0].match(element);
+    }
+    
+    return match;
+  },
+  
+// protected
+  uniq: function(elements) {
+    var uniq = [], uids = [], uid;
+    for (var i=0, length = elements.length; i < length; i++) {
+      uid = $uid(elements[i]);
+      if (!uids[uid]) {
+        uniq.push(elements[i]);
+        uids[uid] = true;
+      }
+    }
+    
+    return uniq;
+  },
+
+  find: {
+    /**
+     * search for any descendant nodes
+     */
+    ' ': function(element, atom) {
+      var founds = $A(element.getElementsByTagName(atom.tag));
+      if (atom.hasNonTagMatcher) {
+        var matching = [];
+        for (var i=0, length = founds.length; i < length; i++) {
+          if (atom.match(founds[i]))
+            matching.push(founds[i]);
+        }
+        return matching;
+      }
+      return founds;
+    },
+
+    /**
+     * search for immidate descendant nodes
+     */
+    '>': function(element, atom) {
+      var node = element.firstChild, matched = [];
+      while (node) {
+        if (atom.match(node)) {
+          matched.push(node);
+        }
+        node = node.nextSibling;
+      }
+      return matched;
+    },
+
+    /**
+     * search for immiate sibling nodes
+     */
+    '+': function(element, atom) {
+      while ((element = element.nextSibling)) {
+        if (element.tagName) {
+          return atom.match(element) ? [element] : [];
+        }
+      }
+      return [];
+    },
+
+    /**
+     * search for late sibling nodes
+     */
+    '~': function(element, atom) {
+      var founds = [];
+      while ((element = element.nextSibling)) {
+        if (atom.match(element))
+          founds.push(element);
+      }
+      return founds;
+    }
+  } 
+
+});
+
+/**
+ * represents a complex, multi ruled select strategy
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Selector.Multiple  = new Class({
+  
+  /**
+   * constructor
+   *
+   * @param String css-rule
+   */
+  initialize: function(css_rule) {
+    this.cssRule = css_rule;
+    this.selectors = css_rule.split(',').map(function(rule) {
+      return rule.blank() ? null : new Selector.Manual(rule);
+    }).compact();
+  },
+
+  /**
+   * searches for the first matching subnode
+   *
+   * @param Element base node
+   * @return Element matching element or null if nothing found
+   */
+  first: function(node) {
+    return this.selectors.map('first', node).first(function(i) { return !!i;});
+  },
+
+  /**
+   * selects all the matching subnodes
+   *
+   * @param Element base node
+   * @return Array found nodes
+   */
+  select: function(node) {
+    return this.selectors.map('select', node, null).flatten().uniq();
+  },
+
+  /**
+   * checks if the node matches the rule
+   *
+   * @param Element node to check
+   * @return boolean check result
+   */
+  match: function(node) {
+    return this.selectors.some('match', node) || !this.selectors.length;
+  }
+});
+
+
+/**
+ * the window object extensions
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+$ext(self, (function(win) {
+  var old_scroll = win.scrollTo;
+  
+return {
+    /**
+     * returns the inner-sizes of the window
+     *
+     * @return Object x: d+, y: d+
+     */
+    sizes: function() {
+      return this.innerWidth ? {x: this.innerWidth, y: this.innerHeight} :
+        {x: document.documentElement.clientWidth, y: document.documentElement.clientHeight};
+    },
+
+    /**
+     * returns the scrolls for the window
+     *
+     * @return Object x: d+, y: d+
+     */
+    scrolls: function() {
+      return (this.pageXOffset || this.pageYOffset) ? {x: this.pageXOffset, y: this.pageYOffset} :
+        (this.document.body.scrollLeft || this.document.body.scrollTop) ? 
+        {x: this.document.body.scrollLeft, y: this.document.body.scrollTop} :
+        {x: this.document.documentElement.scrollLeft, y: this.document.documentElement.scrollTop};
+    },
+
+    /**
+     * overloading the native scrollTo method to support hashes and element references
+     *
+     * @param mixed number left position, a hash position, element or a string element id
+     * @param number top position
+     * @return window self
+     */
+    scrollTo: function(left, top) {
+      if(isElement(left) || (isString(left) && $(left))) {
+        left = $(left).position();
+      }
+
+      if (isHash(left)) {
+        top  = left.y;
+        left = left.x;
+      }
+      
+      old_scroll(left, top);
+
+      return this;
+    }
+};
+
+})(window));
+
+/**
+ * The dom-ready event handling code
+ *
+ * Credits:
+ *   The basic principles of the module are originated from
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+[window, document].each(function(object) {
+  Observer.createShortcuts(object, ['ready']);
+  var ready = object.ready.bind(object);
+  
+  if (Browser.IE) {
+    var tmp = $E('div');
+    (function() {
+      var loaded = false;
+      try {
+        document.body.appendChild(tmp);
+        tmp.remove();
+        loaded = true;
+      } catch(e) { arguments.callee.delay(50);}
+      if (loaded) ready();
+    })();
+  } else if (document['readyState'] !== undefined) {
+    (function() {
+      $w('loaded complete').includes(document.readyState) ? ready() : arguments.callee.delay(50);
+    })();
+  } else {
+    document.addEventListener('DOMContentLoaded', ready, false);
+  }
+  
+});
+
+/**
+ * The form unit class and extensions
+ *
+ * Credits:
+ *   The basic principles of the module are inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *
+ * Copyright (C) 2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+var Form = new Class(Element, {
+  /**
+   * generic forms creation constructor
+   *
+   * @param Object form options
+   */
+  initialize: function(options) {
+    var options = options || {}, remote = options['remote'],
+      form = this.$super('form', Object.without(options, 'remote'));
+    
+    if (remote) form.remotize();
+    
+    return form;
+  },
+  
+  extend: {
+    /**
+     * IE browsers manual elements extending
+     *
+     * @param Element form
+     * @return Form element
+     */
+    ext: function(element) {
+      return $ext(element, this.Methods);
+    },
+    
+    Methods: {},
+    
+    /**
+     * Extends the form functionality
+     *
+     * @param Object methods hash
+     * @return void
+     */
+    addMethods: function(methods, dont_overwrite) {
+      $ext(Form.Methods, methods, dont_overwrite);
+      
+      try { // trying to extend the form element prototype
+        $ext(HTMLFormElement.prototype, methods, dont_overwrite);
+      } catch(e) {}
+    }
+  }
+});
+
+Form.addMethods({
+  /**
+   * returns the form elements as an array of extended units
+   *
+   * @return Array of elements
+   */
+  getElements: function() {
+    return this.select('input,select,textarea,button');
+  },
+  
+  /**
+   * returns the list of all the input elements on the form
+   *
+   * @return Array of elements
+   */
+  inputs: function() {
+    return this.getElements().filter(function(input) {
+      return !['submit', 'button', 'reset', 'image', null].includes(input.type);
+    });
+  },
+  
+  /**
+   * focuses on the first input element on the form
+   *
+   * @return Form this
+   */
+  focus: function() {
+    var first = this.inputs().first(function(input) { return input.type != 'hidden'; });
+    if (first) first.focus();
+    return this.fire('focus');
+  },
+  
+  /**
+   * removes focus out of all the form elements
+   *
+   * @return Form this
+   */
+  blur: function() {
+    this.getElements().each('blur');
+    return this.fire('blur');
+  },
+  
+  /**
+   * disables all the elements on the form
+   *
+   * @return Form this
+   */
+  disable: function() {
+    this.getElements().each('disable');
+    return this.fire('disable');
+  },
+  
+  /**
+   * enables all the elements on the form
+   *
+   * @return Form this
+   */
+  enable: function() {
+    this.getElements().each('enable');
+    return this.fire('enable');
+  },
+  
+  /**
+   * returns the list of the form values
+   *
+   * @return Object values
+   */
+  values: function() {
+    var values = {};
+    
+    this.inputs().each(function(input) {
+      if (!input.disabled && input.name && (!['checkbox', 'radio'].includes(input.type) || input.checked))
+        values[input.name] = input.getValue();
+    });
+    
+    return values;
+  },
+  
+  /**
+   * returns the key/values organized ready to be sent via a get request
+   *
+   * @return String serialized values
+   */
+  serialize: function() {
+    return Object.toQueryString(this.values());
+  }
+});
+
+// creating the shortcuts
+Form.addMethods(Observer.createShortcuts({}, $w('submit reset focus')), true);
+
+
+
+/**
+ * there is the form-elements additional methods container
+ *
+ * Credits:
+ *   The basic ideas are taken from
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *
+ * Copyright (C) 2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+(function() {
+  // trying to get the input element classes list
+  try { var input_classes = [HTMLInputElement, HTMLSelectElement, HTMLTextAreaElement, HTMLButtonElement];
+  } catch(e) { var input_classes = []; }
+  
+  Form.Element = {
+    /**
+     * IE browsers manual elements extending
+     *
+     * @param Element element
+     * @return Element extended element
+     */
+    ext: function(element) {
+      // highjack the native methods to be able to call them froum our wrappers
+      element._blur   = element.blur;
+      element._focus  = element.focus;
+      element._select = element.select;
+
+      return $ext(element, this.Methods);
+    },
+
+    // the methods container
+    Methods: {},
+
+    /**
+     * Extends the Form.Element methods
+     *
+     * @param Object methods list
+     * @return void
+     */
+    addMethods: function(methods, dont_overwrite) {
+      $ext(this.Methods, methods, dont_overwrite);
+
+      // extending the input element prototypes
+      input_classes.each(function(klass) {
+        $ext(klass.prototype, methods, dont_overwrite);
+      });
+    }
+  };
+
+  // creating the blur, focus and select methods aliases
+  input_classes.each(function(klass) {
+    $alias(klass.prototype, {
+      _blur:   'blur',
+      _focus:  'focus',
+      _select: 'select'
+    });
+  });
+})();
+
+Form.Element.addMethods({
+  /**
+   * uniform access to the element values
+   *
+   * @return String element value
+   */
+  getValue: function() {
+    if (this.type == 'select-multiple') {
+      return $A(this.getElementsByTagName('option')).map(function(option) {
+        return option.selected ? option.value : null;
+      }).compact();
+    } else {
+      return this.value;
+    }
+  },
+
+  /**
+   * uniform accesss to set the element value
+   *
+   * @param String value
+   * @return Element this
+   */
+  setValue: function(value) {
+    if (this.type == 'select-multiple') {
+      value = (isArray(value) ? value : [value]).map(String);
+      $A(this.getElementsByTagName('option')).each(function(option) {
+        option.selected = value.includes(option.value);
+      });
+    } else {
+      this.value = value;
+    }
+    return this;
+  },
+
+  /**
+   * makes the element disabled
+   *
+   * @return Element this
+   */
+  disable: function() {
+    this.disabled = true;
+    this.fire('disable');
+    return this;
+  },
+
+  /**
+   * makes the element enabled
+   *
+   * @return Element this
+   */
+  enable: function() {
+    this.disabled = false;
+    this.fire('enable');
+    return this;
+  },
+  
+  /**
+   * focuses on the element
+   *
+   * @return Element this
+   */
+  focus: function() {
+    Browser.OLD ? this._focus() : this._focus.call(this);
+    this.focused = true;
+    this.fire('focus');
+    return this;
+  },
+  
+  /**
+   * focuses on the element and selects its content
+   *
+   * @return Element this
+   */
+  select: function() {
+    this.focus();
+    Browser.OLD ? this._select() : this._select.call(this);
+    return this;
+  },
+  
+  /**
+   * looses the element focus
+   *
+   * @return Element this
+   */
+  blur: function() {
+    Browser.OLD ? this._blur() : this._blur.call(this);
+    this.focused = false;
+    this.fire('blur');
+    return this;
+  }
+});
+
+// creating the common event shortcuts
+Form.Element.addMethods(Observer.createShortcuts({}, $w('disable enable focus blur change')), true);
+
+
+/**
+ * this module handles the work with cookies
+ *
+ * Credits:
+ *   Most things in the unit are take from
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+var Cookie = new Class({
+  include: Options,
+  
+  extend: {
+    // sets the cookie
+    set: function(name, value, options) {
+      return new this(name, options).set(value);
+    },
+    // gets the cookie
+    get: function(name) {
+      return new this(name).get();
+    },
+    // deletes the cookie
+    remove: function(name) {
+      return new this(name).remove();
+    },
+    
+    // checks if the cookies are enabled
+    enabled: function() {
+      document.cookie = "__t=1";
+      return document.cookie.indexOf("__t=1")!=-1;
+    },
+    
+    // some basic options
+    Options: {
+      secure:   false,
+      document: document
+    }
+  },
+  
+  /**
+   * constructor
+   * @param String cookie name
+   * @param Object options
+   * @return void
+   */
+  initialize: function(name, options) {
+    this.name = name;
+    this.setOptions(options);
+  },
+  
+  /**
+   * sets the cookie with the name
+   *
+   * @param mixed value
+   * @return Cookie this
+   */
+  set: function(value) {
+    var value = encodeURIComponent(value);
+    if (this.options.domain) value += '; domain=' + this.options.domain;
+    if (this.options.path) value += '; path=' + this.options.path;
+    if (this.options.duration){
+      var date = new Date();
+      date.setTime(date.getTime() + this.options.duration * 24 * 60 * 60 * 1000);
+      value += '; expires=' + date.toGMTString();
+    }
+    if (this.options.secure) value += '; secure';
+    this.options.document.cookie = this.name + '=' + value;
+    return this;
+  },
+  
+  /**
+   * searches for a cookie with the name
+   *
+   * @return mixed saved value or null if nothing found
+   */
+  get: function() {
+    var value = this.options.document.cookie.match('(?:^|;)\\s*' + RegExp.escape(this.name) + '=([^;]*)');
+    return (value) ? decodeURIComponent(value[1]) : null;
+  },
+  
+  /** 
+   * removes the cookie
+   *
+   * @return Cookie this
+   */
+  remove: function() {
+    this.options.duration = -1;
+    return this.set('');
+  }
+});
+
+/**
+ * XMLHttpRequest wrapper
+ *
+ * Credits:
+ *   Some of the functionality inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *     - jQuery    (http://jquery.com)        Copyright (C) John Resig
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+var Xhr = new Class(Observer, {
+  extend: {
+    // supported events list
+    EVENTS: $w('success failure complete request cancel create'),
+    
+    // default options
+    Options: {
+      headers: {
+        'X-Requested-With': 'XMLHttpRequest',
+        'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
+      },
+      method:       'post',
+      encoding:     'utf-8',
+      async:        true,
+      evalScripts:  false,
+      evalResponse: false,
+      evalJSON:     true,
+      secureJSON:   true,
+      urlEncoded:   true,
+      spinner:      null,
+      spinnerFx:    'fade',
+      params:       null
+    },
+    
+    /**
+     * Shortcut to initiate and send an XHR in a single call
+     *
+     * @param String url
+     * @param Object options
+     * @return Xhr request
+     */
+    load: function(url, options) {
+      return new this(url, Object.merge({method: 'get'}, options)).send();
+    }
+  },
+  
+  /**
+   * basic constructor
+   *
+   * @param String url
+   * @param Object options
+   */
+  initialize: function(url, options) {
+    this.initCallbacks(); // system level callbacks should be initialized before the user callbacks
+    
+    this.url = url;
+    this.$super(options);
+    
+    // copying some options to the instance level attributes
+    for (var key in Xhr.Options)
+      this[key] = this.options[key];
+      
+    this.initSpinner();
+  },
+  
+  /**
+   * sets a header 
+   *
+   * @param String header name
+   * @param String header value
+   * @return Xhr self
+   */
+  setHeader: function(name, value) {
+    this.headers[name] = value;
+    return this;
+  },
+  
+  /**
+   * tries to get a response header
+   *
+   * @return mixed String header value or undefined
+   */
+  getHeader: function(name) {
+    try {
+      return this.xhr.getResponseHeader(name);
+    } catch(e) {}
+  },
+  
+  /**
+   * checks if the request was successful
+   *
+   * @return boolean check result
+   */
+  successful: function() {
+    return (this.status >= 200) && (this.status < 300);
+  },
+  
+  /**
+   * performs the actual request sending
+   *
+   * @param Object options
+   * @return Xhr self
+   */
+  send: function(params) {
+    var add_params = {}, url = this.url;
+    
+    var method = this.method.toUpperCase();
+    if (['PUT', 'DELETE'].includes(method)) {
+      add_params['_method'] = method.toLowerCase();
+      method = 'POST';
+    }
+    
+    var data = this.prepareData(this.params, this.prepareParams(params), add_params);
+    
+    if (this.urlEncoded && method == 'POST' && !this.headers['Content-type']) {
+      this.setHeader('Content-type', 'application/x-www-form-urlencoded; charset='+this.encoding);
+    }
+    
+    if (method == 'GET') {
+      url += (url.includes('?') ? '&' : '?') + data;
+      data = null;
+    }
+    
+    this.xhr = this.createXhr();
+    this.fire('create');
+    
+    this.xhr.open(method, url, this.async);
+    
+    this.xhr.onreadystatechange = this.stateChanged.bind(this);
+    
+    for (var key in this.headers) {
+      this.xhr.setRequestHeader(key, this.headers[key]);
+    }
+    
+    this.xhr.send(data);
+    this.fire('request');
+    
+    if (!this.async) this.stateChanged();
+    
+    return this;
+  },
+  
+  /**
+   * elements automaticall update method, creates an Xhr request 
+   * and updates the element innerHTML value onSuccess.
+   * 
+   * @param Element element
+   * @param Object optional request params
+   * @return Xhr self
+   */
+  update: function(element, params) {
+    return this.onSuccess(function(r) { element.update(r.text); }).send(params);
+  },
+  
+  /**
+   * stops the request processing
+   *
+   * @return Xhr self
+   */
+  cancel: function() {
+    if (!this.xhr || this.xhr.canceled) return this;
+    
+    this.xhr.abort();
+    this.xhr.onreadystatechange = function() {};
+    this.xhr.canceled = true;
+    
+    return this.fire('cancel');
+  },
+  
+// protected
+  // wrapping the original method to send references to the xhr objects
+  fire: function(name) {
+    return this.$super(name, this, this.xhr);
+  },
+  
+  // creates new request instance
+  createXhr: function() {
+    if (this.form && this.form.getElements().map('type').includes('file')) {
+      return new Xhr.IFramed(this.form);
+    } else try {
+      return new XMLHttpRequest();
+    } catch(e) {
+      return new ActiveXObject('MSXML2.XMLHTTP');
+    }
+  },
+  
+  // prepares user sending params
+  prepareParams: function(params) {
+    if (params && params.tagName == 'FORM') {
+      this.form = params;
+      params = params.values();
+    }
+    return params;
+  },
+  
+  // converts all the params into a url params string
+  prepareData: function() {
+    return $A(arguments).map(function(param) {
+      if (!isString(param)) {
+        param = Object.toQueryString(param);
+      }
+      return param.blank() ? null : param;
+    }).compact().join('&');
+  },
+
+  // handles the state change
+  stateChanged: function() {
+    if (this.xhr.readyState != 4 || this.xhr.canceled) return;
+    
+    try { this.status = this.xhr.status;
+    } catch(e) { this.status = 0; }
+    
+    this.text = this.responseText = this.xhr.responseText;
+    this.xml  = this.responseXML  = this.xhr.responseXML;
+    
+    this.fire('complete').fire(this.successful() ? 'success' : 'failure');
+  },
+  
+  // called on success
+  tryScripts: function(response) {
+    if (this.evalResponse || (/(ecma|java)script/).test(this.getHeader('Content-type'))) {
+      $eval(this.text);
+    } else if ((/json/).test(this.getHeader('Content-type')) && this.evalJSON) {
+      this.json = this.responseJSON = this.sanitizedJSON();
+    } else if (this.evalScripts) {
+      this.text.evalScripts();
+    }
+  },
+  
+  // sanitizes the json-response texts
+  sanitizedJSON: function() {
+    // checking the JSON response formatting
+    if (!(/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(this.text.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, ''))) {
+      if (this.secureJSON) {
+        throw "JSON parse error: "+this.text;
+      } else {
+        return null;
+      }
+    }
+    
+    return eval("("+this.text+")");
+  },
+  
+  // initializes the request callbacks
+  initCallbacks: function() {
+    // creating an automatical spinner handling
+    this.on('create', 'showSpinner').on('complete', 'hideSpinner').on('cancel', 'hideSpinner');
+    
+    // response scripts evaluation, should be before the global xhr callbacks
+    this.on('success', 'tryScripts');
+    
+    // wiring the global xhr callbacks
+    Xhr.EVENTS.each(function(name) {
+      this.on(name, function() { Xhr.fire(name, this, this.xhr); });
+    }, this);
+  },
+  
+  // inits the spinner
+  initSpinner: function() {
+    if (this.spinner)
+      this.spinner = $(this.spinner);
+      
+      if (Xhr.Options.spinner && this.spinner === $(Xhr.Options.spinner))
+        this.spinner = null;
+  },
+  
+  showSpinner: function() { if (this.spinner) this.spinner.show(this.spinnerFx, {duration: 100}); },
+  hideSpinner: function() { if (this.spinner) this.spinner.hide(this.spinnerFx, {duration: 100}); }
+});
+
+// creating the class level observer
+Observer.create(Xhr);
+
+// attaching the common spinner handling
+$ext(Xhr, {
+  counter: 0,
+  showSpinner: function() {
+    if (this.Options.spinner) $(this.Options.spinner).show(this.Options.spinnerFx, {duration: 100});
+  },
+  hideSpinner: function() {
+    if (this.Options.spinner) $(this.Options.spinner).hide(this.Options.spinnerFx, {duration: 100});
+  }
+});
+
+Xhr.on('create', function() {
+  this.counter++;
+  this.showSpinner();
+}).on('complete', function() {
+  this.counter--;
+  if (this.counter < 1) this.hideSpinner();
+}).on('cancel', function() {
+  this.counter--;
+  if (this.counter < 1) this.hideSpinner();
+});
+
+
+/**
+ * Here are the Form unit Xhr extensions
+ *
+ * Credits:
+ *   Some of the functionality inspired by
+ *     - Prototype (http://prototypejs.org)   Copyright (C) Sam Stephenson
+ *     - jQuery    (http://jquery.com)        Copyright (C) John Resig
+ *
+ * Copyright (C) 2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Form.addMethods({
+  /**
+   * sends the form via xhr request
+   *
+   * @params Options xhr request options
+   * @return Form this
+   */
+  send: function(options) {
+    options = options || {};
+    options['method'] = options['method'] || this.method || 'post';
+    
+    new Xhr(this.get('action') || document.location.href, options
+      ).onRequest(this.disable.bind(this)
+      ).onComplete(this.enable.bind(this)).send(this);
+    
+    return this;
+  },
+  
+  /**
+   * makes the form be remote by default
+   *
+   * @params Object default options
+   * @return Form this
+   */
+  remotize: function(options) {
+    this.onsubmit = function() {
+      this.send.bind(this, Object.merge({spinner: this.first('.spinner')}, options)).delay(20);
+      return false;
+    };
+      
+    this.remote   = true;
+    return this;
+  },
+  
+  /**
+   * removes the remote call hook
+   *
+   * NOTE: will nuke onsubmit attribute
+   *
+   * @return Form this
+   */
+  unremotize: function() {
+    this.onsubmit = function() {};
+    this.remote   = false;
+    return this;
+  }
+});
+
+/**
+ * this module contains the Element unit XHR related extensions
+ *
+ * Credits:
+ *   - jQuery    (http://jquery.com)        Copyright (C) John Resig
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+Element.addMethods({
+  /**
+   * performs an Xhr request to the given url
+   * and updates the element internals with the responseText
+   *
+   * @param String url address
+   * @param Object xhr options
+   * @return Element this
+   */
+  load: function(url, options) {
+    new Xhr(url, Object.merge({method: 'get'}, options)).update(this);
+    return this;
+  }
+});
+
+/**
+ * This unit presents a fake drop in replacement for the XmlHTTPRequest unit
+ * but works with an iframe targeting in the background
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+Xhr.IFramed = new Class({
+  /**
+   * constructor
+   *
+   * @param Form form which will be submitted via the frame
+   * @return void
+   */
+  initialize: function(form) {
+    this.form = form;
+    
+    var id = 'xhr_frame_'+Math.random().toString().split('.').last();
+    $E('div').insertTo(document.body).update('<iframe name="'+id+'" id="'+id+'" width="0" height="0" frameborder="0" src="about:blank"></iframe>');
+    
+    this.iframe = $(id);
+    this.iframe.on('load', this.onLoad.bind(this));
+  },
+  
+  send: function() {
+    // stubbing the onsubmit method so it allowed us to submit the form
+    var old_onsubmit = this.form.onsubmit,
+        old_target   = this.form.target;
+    
+    this.form.onsubmit = function() {};
+    this.form.target   = this.iframe.id;
+    
+    this.form.submit();
+    
+    this.form.onsubmit = old_onsubmit;
+    this.form.target   = old_target;
+  },
+  
+  onLoad: function() {
+    this.status       = 200;
+    this.readyState   = 4;
+    
+    var doc = window[this.iframe.id].document.documentElement;
+    this.responseText = doc ? doc.innerHTML : null;
+    
+    this.onreadystatechange();
+  },
+  
+  // dummy API methods
+  open:               function() {},
+  abort:              function() {},
+  setRequestHeader:   function() {},
+  onreadystatechange: function() {}
+});
+
+/**
+ * Basic visual effects class
+ *
+ * Credits:
+ *   The basic principles, structures and naming system are inspired by
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+var Fx = new Class(Observer, {
+  extend: {
+    EVENTS: $w('start finish cancel'),
+    
+    // named durations
+    Durations: {
+      'short':  200,
+      'normal': 400,
+      'long':   800
+    },
+    
+    // default options
+    Options: {
+      fps:        Browser.IE ? 40 : 60,
+      duration:   'normal',
+      transition: 'Sin',
+      queue:      true
+    },
+
+    // list of basic transitions
+    Transitions: {
+      Sin: function(i)  {
+        return -(Math.cos(Math.PI * i) - 1) / 2;
+      },
+      
+      Cos: function(i) {
+        return Math.asin((i-0.5) * 2)/Math.PI + 0.5;
+      },
+      
+      Exp: function(i) {
+        return Math.pow(2, 8 * (i - 1));
+      },
+      
+      Log: function(i) {
+        return 1 - Math.pow(2, - 8 * i);
+      },
+      
+      Lin: function(i) {
+        return i;
+      }
+    }
+  },
+  
+  /**
+   * Basic constructor
+   *
+   * @param Object options
+   */
+  initialize: function(element, options) {
+    this.$super(options);
+    this.element = $(element);
+  },
+  
+  /**
+   * starts the transition
+   *
+   * @return Fx this
+   */
+  start: function() {
+    if (this.queue(arguments)) return this;
+    this.prepare.apply(this, arguments);
+    
+    this.transition = Fx.Transitions[this.options.transition] || this.options.transition;
+    var duration    = Fx.Durations[this.options.duration]     || this.options.duration;
+    
+    this.steps  = (duration / 1000 * this.options.fps).ceil();
+    this.number = 1;
+    
+    return this.fire('start', this).startTimer();
+  },
+  
+  /**
+   * finishes the transition
+   *
+   * @return Fx this
+   */
+  finish: function() {
+    return this.stopTimer().fire('finish').next();
+  },
+  
+  /**
+   * interrupts the transition
+   *
+   * @return Fx this
+   */
+  cancel: function() {
+    return this.stopTimer().fire('cancel').next();
+  },
+  
+  /**
+   * pauses the transition
+   *
+   * @return Fx this
+   */
+  pause: function() {
+    return this.stopTimer();
+  },
+  
+  /**
+   * resumes a paused transition
+   *
+   * @return Fx this
+   */
+  resume: function() {
+    return this.startTimer();
+  },
+  
+// protected
+  // dummy method, should be implemented in a subclass
+  prepare: function() {},
+
+  // dummy method, should implement the actual things happenning
+  render: function(value) {},
+  
+  // the periodically called method
+  // NOTE: called outside of the instance scope!
+  step: function($this) {
+    if ($this.steps >= $this.number) {
+      $this.render($this.transition($this.number / $this.steps));
+      
+      $this.number ++;
+    } else {
+      $this.finish();
+    }
+  },
+  
+  // calculates the current value
+  calc: function(start, end, delata) {
+    return start + (end - start) * delta;
+  },
+  
+  startTimer: function() {
+    this.timer = this.step.periodical((1000 / this.options.fps).round(), this);
+    return this;
+  },
+  
+  stopTimer: function() {
+    if (this.timer) {
+      this.timer.stop();
+    }
+    return this;
+  },
+
+  // handles effects queing
+  // should return false if there's no queue and true if there is a queue
+  queue: function(args) {
+    if (!this.element) return false;
+    if (this.$chained) {
+      delete(this['$chained']);
+      return false;
+    }
+
+    var uid = $uid(this.element), chain;
+    if (!Fx.$chains)      Fx.$chains = {};
+    if (!Fx.$chains[uid]) Fx.$chains[uid] = [];
+    chain = Fx.$chains[uid];
+
+    if (this.options.queue)
+      chain.push([args, this]);
+    
+    this.next = function() {
+      var next = chain.shift(); next = chain[0];
+      if (next) {
+        next[1].$chained = true;
+        next[1].start.apply(next[1], next[0]);
+      }
+      return this;
+    };
+
+    return chain[0][1] !== this && this.options.queue;
+  },
+  
+  next: function() {
+    return this;
+  }
+  
+  
+});
+
+/**
+ * Here are the Array class extensions depend on the fx library
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+$ext(Array.prototype, {
+  /**
+   * converts the array into a string rgb(R,G,B) definition
+   *
+   * @return String rgb(DDD, DDD, DDD) value
+   */
+  toRgb: function() {
+    return 'rgb('+this.map(Math.round)+')';
+  }
+});
+
+/**
+ * There are the String unit extensions for the effects library
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-il>
+ */
+String.COLORS = {
+  maroon:  '#800000',
+  red:     '#ff0000',
+  orange:  '#ffA500',
+  yellow:  '#ffff00',
+  olive:   '#808000',
+  purple:  '#800080',
+  fuchsia: '#ff00ff',
+  white:   '#ffffff',
+  lime:    '#00ff00',
+  green:   '#008000',
+  navy:    '#000080',
+  blue:    '#0000ff',
+  aqua:    '#00ffff',
+  teal:    '#008080',
+  black:   '#000000',
+  silver:  '#c0c0c0',
+  gray:    '#808080',
+  brown:   '#a52a2a'
+};
+
+$ext(String.prototype, {
+  /**
+   * converts a #XXX or rgb(X, X, X) sring into standard #XXXXXX color string
+   *
+   * @return String hex color
+   */
+  toHex: function() {
+    var match = this.match(/^#(\w)(\w)(\w)$/);
+    
+    if (match) {
+      match = "#"+ match[1]+match[1]+match[2]+match[2]+match[3]+match[3];
+    } else if (match = this.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/)) {
+      match = "#"+ match.slice(1).map(function(bit) {
+        bit = (bit-0).toString(16);
+        return bit.length == 1 ? '0'+bit : bit;
+      }).join('');
+    } else {
+      match = String.COLORS[this] || this;
+    }
+    
+    return match;
+  },
+  
+  /**
+   * converts a hex string into an rgb array
+   *
+   * @param boolean flag if need an array
+   * @return String rgb(R,G,B) or Array [R,G,B]
+   */
+  toRgb: function(array) {
+    var match = (this.toHex()||'').match(/#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})/i);
+    
+    if (match) {
+      match = match.slice(1).map('toInt', 16);
+      match = array ? match : match.toRgb();
+    }
+    
+    return match;
+  }
+});
+
+/**
+ * This class provides the basic effect for styles manipulation
+ *
+ * Credits:
+ *   The idea is inspired by the Morph effect from
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Fx.Morph = new Class(Fx, {
+
+// protected
+  
+  /**
+   * starts the effect
+   *
+   * @param mixed an Object with an end style or a string with the end class-name(s)
+   * @return Fx this
+   */
+  prepare: function(style) {
+    this.endStyle   = this._findStyle(style);
+    this.startStyle = this._getStyle(this.element, Object.keys(this.endStyle));
+    
+    this._cleanStyles();
+    
+    return this.$super();
+  },
+  
+  render: function(delta) {
+    var value, start, end;
+    
+    for (var key in this.endStyle) {
+      start = this.startStyle[key];
+      end   = this.endStyle[key];
+
+      if (typeof(start) == 'number') {
+        // handling floats like opacity
+        value = start + (end - start) * delta;
+        
+      } else if(start.length == 2) {
+        // handling usual sizes with dimensions
+        value = (start[0] + (end[0] - start[0]) * delta) + end[1];
+
+      } else if(start.length == 3) {
+        // calculating colors
+        value = end.map(function(value, i) {
+          return start[i] + (value - start[i]) * delta;
+        }).toRgb();
+      }
+      
+      if (key == 'opacity') {
+        this.element.setOpacity(value);
+      } else {
+        this.element.style[key] = value;
+      }
+    }
+  },
+  
+// private
+
+  // finds the style definition by a css-selector string
+  _findStyle: function(style) {
+    // a dummy node to calculate the end styles
+    var element = this._dummy().setStyle(style);
+    
+    // grabbing the computed styles
+    var element_styles      = element.computedStyles();
+    var this_element_styles = this.element.computedStyles();
+    
+    // grabbing the element style
+    var end_style = this._getStyle(element, Object.keys(style), element_styles);
+    
+    // assigning the border style if the end style has a border
+    var border_style = element_styles.borderTopStyle, element_border_style = this_element_styles.borderTopStyle;
+    if (border_style != element_border_style) {
+      if (element_border_style  == 'none') {
+        this.element.style.borderWidth =  '0px';
+      }
+      this.element.style.borderStyle = border_style;
+      if (this._transp(this_element_styles.borderTopColor)) {
+        this.element.style.borderColor = this_element_styles.color;
+      }
+    }
+    
+    element.remove();
+    
+    return end_style;
+  },
+  
+  // creates a dummy element to work with
+  _dummy: function() {
+    // a container for the styles extraction element
+    var container = Fx.Morph.$c = (Fx.Morph.$c || $E('div', {style: "visibility:hidden;float:left;height:0;width:0"}));
+    if (this.element.parentNode) this.element.parentNode.insertBefore(container, this.element);
+    
+    return $(this.element.cloneNode(false)).insertTo(container);
+  },
+  
+  // grabs computed styles with the given keys out of the element
+  _getStyle: function(element, keys, styles) {
+    var style = {}, styles = styles || element.computedStyles(), name;
+    if (isString(keys)) { name = keys, keys = [keys]; }
+    
+    for (var i=0; i < keys.length; i++) {
+      var key = keys[i].camelize();
+      
+      // keys preprocessing
+      if (key == 'background') key = 'backgroundColor';
+      else if (key == 'border') {
+        key = 'borderWidth';
+        keys.splice(i+1, 0, 'borderColor'); // inserting the border color as the next unit
+      }
+      
+      // getting the actual style
+      style[key] = element._getStyle(styles, key);
+      
+      // Opera returns named colors as quoted strings
+      if (Browser.Opera && /color/i.test(key)) style[key] = style[key].replace(/'|"/g, '');
+      
+      // getting the real color if it's a transparent
+      if (this._transp(style[key])) style[key] = this._getBGColor(element);
+      
+      // getting the real width and height if they not set or set as 'auto'
+      if (!style[key] || style[key] == 'auto') {
+        style[key] = key == 'width'  ? element.offsetWidth  + 'px' :
+                     key == 'height' ? element.offsetHeight + 'px' : '';
+      }
+    }
+    
+    return name ? style[name] : style;
+  },
+  
+  // looking for the visible background color of the element
+  _getBGColor: function(element) {
+    return [element].concat(element.parents()).map(function(node) {
+      var bg = node.getStyle('backgroundColor');
+      return (bg && !this._transp(bg)) ? bg : null; 
+    }, this).compact().first() || 'rgb(255,255,255)';
+  },
+  
+  // prepares the style values to be processed correctly
+  _cleanStyles: function() {
+    var end = this.endStyle, start = this.startStyle;
+    
+    // filling up missing styles
+    for (var key in end) {
+      if (start[key] === '' && /^[\d\.\-]+[a-z]+$/.test(end[key])) {
+        start[key] = '0px';
+      }
+    }
+    
+    [end, start].each(this._cleanStyle, this);
+    
+    // removing duplications between start and end styles
+    for (var key in end) {
+      if (!defined(start[key]) || (end[key] instanceof Array ? end[key].join() === start[key].join() : end[key] === start[key])) {
+        delete(end[key]);
+        delete(start[key]);
+      }
+    }
+  },
+  
+  // cleans up a style object
+  _cleanStyle: function(style) {
+    var match;
+    for (var key in style) {
+      style[key] = String(style[key]);
+        
+      if (/color/i.test(key)) {
+        // preparing the colors
+        style[key] = style[key].toRgb(true);
+        if (!style[key]) delete(style[key]);
+      } else if (/^[\d\.]+$/.test(style[key])) {
+        // preparing numberic values
+        style[key] = style[key].toFloat();
+      } else if (match = style[key].match(/^([\d\.\-]+)([a-z]+)$/i)) {
+        // preparing values with dimensions
+        style[key] = [match[1].toFloat(), match[2]];
+        
+      } else {
+        delete(style[key]);
+      }
+    }
+  },
+  
+  // checks if the color is transparent
+  _transp: function(color) {
+    return color == 'transparent' || color == 'rgba(0, 0, 0, 0)';
+  }
+});
+
+/**
+ * the elements hightlighting effect
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Fx.Highlight = new Class(Fx.Morph, {
+  extend: {
+    Options: Object.merge(Fx.Options, {
+      color:      '#FF8',
+      transition: 'Exp'
+    })
+  },
+  
+// protected
+  
+  /**
+   * starts the transition
+   *
+   * @param String the hightlight color
+   * @param String optional fallback color
+   * @return self
+   */
+  prepare: function(start, end) {
+    var end_color = end || this.element.getStyle('backgroundColor');
+    
+    if (this._transp(end_color)) {
+      this.onFinish(function() { this.element.style.backgroundColor = 'transparent'; });
+      end_color = this._getBGColor(this.element);
+    }
+    
+    this.element.style.backgroundColor = (start || this.options.color);
+    
+    return this.$super({backgroundColor: end_color});
+  }
+});
+
+/**
+ * this is a superclass for the bidirectional effects
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Fx.Twin = new Class(Fx.Morph, {
+  
+  /**
+   * hides the element if it meant to be switched off
+   *
+   * @return Fx self
+   */
+  finish: function() {
+    if (this.how == 'out')
+      this.element.hide();
+      
+    return this.$super();
+  },
+
+// protected
+  
+  /**
+   * assigns the direction of the effect in or out
+   *
+   * @param String 'in', 'out' or 'toggle', 'toggle' by default
+   */
+  setHow: function(how) {
+    this.how = how || 'toggle';
+    
+    if (this.how == 'toggle')
+      this.how = this.element.visible() ? 'out' : 'in';
+  }
+
+});
+
+/**
+ * the slide effects wrapper
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Fx.Slide = new Class(Fx.Twin, {
+  extend: {
+    Options: Object.merge(Fx.Options, {
+      direction: 'top'
+    })
+  },
+  
+// protected  
+  prepare: function(how) {
+    this.setHow(how);
+
+    this.element.show();
+    this.sizes = this.element.sizes();
+    
+    this.styles = {};
+    $w('overflow height width marginTop marginLeft').each(function(key) {
+      this.styles[key] = this.element.style[key];
+    }, this);
+
+    this.element.style.overflow = 'hidden';
+    this.onFinish('_getBack').onCancel('_getBack');
+
+    return this.$super(this._endStyle(this.options.direction));
+  },
+
+  _getBack: function() {
+    this.element.setStyle(this.styles);
+  },
+
+  // calculates the final style
+  _endStyle: function(direction) {
+    var style = {}, sizes = this.sizes,
+      margin_left = (this.styles.marginLeft || '0').toFloat(),
+      margin_top  = (this.styles.marginTop  || '0').toFloat();
+
+    if (this.how == 'out') {
+      style[['top', 'bottom'].includes(direction) ? 'height' : 'width'] = '0px';
+
+      if (direction == 'right') {
+        style.marginLeft = margin_left + sizes.x+'px';
+      } else if (direction == 'bottom') {
+        style.marginTop = margin_top + sizes.y +'px';
+      }
+
+    } else if (this.how == 'in') {
+      var element_style = this.element.style;
+      
+      if (['top', 'bottom'].includes(direction)) {
+        style.height = sizes.y + 'px';
+        element_style.height = '0px';
+      } else {
+        style.width = sizes.x + 'px';
+        element_style.width = '0px';
+      }
+
+      if (direction == 'right') {
+        style.marginLeft = margin_left + 'px';
+        element_style.marginLeft = margin_left + sizes.x + 'px';
+      } else if (direction == 'bottom') {
+        style.marginTop = margin_top + 'px';
+        element_style.marginTop = margin_top + sizes.y + 'px';
+      }
+    }
+
+    return style;
+  }
+
+});
+
+/**
+ * The opacity effects wrapper
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Fx.Fade = new Class(Fx.Twin, {
+  prepare: function(how) {
+    this.setHow(how);
+    
+    if (this.how == 'in')
+      this.element.setOpacity(0).show();
+    
+    return this.$super({opacity: typeof(how) == 'number' ? how : this.how == 'in' ? 1 : 0});
+  }
+});
+
+/**
+ * This block contains additional Element shortcuts for effects easy handling
+ *
+ * Credits:
+ *   Some ideas are inspired by 
+ *     - MooTools  (http://mootools.net)      Copyright (C) Valerio Proietti
+ *
+ * Copyright (C) 2008-2009 Nikolay V. Nemshilov aka St. <nemshilov#gma-ilc-om>
+ */
+Element.addMethods((function(methods) {
+  var old_hide   = methods.hide,
+      old_show   = methods.show,
+      old_resize = methods.resize;
+
+return {
+
+  /**
+   * hides the element with given visual effect
+   *
+   * @param String fx name
+   * @param Object fx options
+   */
+  hide: function(fx, options) {
+    return fx ? this.fx(fx, ['out', options], old_hide) : old_hide.call(this);
+  },
+  
+  /**
+   * shows the element with the given visual effect
+   *
+   * @param String fx name
+   * @param Object fx options
+   */
+  show: function(fx, options) {
+    return fx ? this.fx(fx, ['in', options], old_show) : old_show.call(this);
+  },
+  
+  /**
+   * resizes the element using the Morph visual effect
+   *
+   * @param Integer width
+   * @param Integer height
+   * @param Object options
+   */
+  resize: function(width, height, options) {
+    if (isHash(width)) {
+      height = width.y;
+      width  = width.x;
+    }
+    if (options) {
+      var style = {};
+      if (isNumber(height)) style.height = height+'px';
+      if (isNumber(width))  style.width  = width +'px';
+      
+      if (!isHash(options)) options = {duration: options};
+      
+      return this.fx('morph', [style, options]);
+    } else {
+      return old_resize.call(this, width, height);
+    }
+  },
+  
+  /**
+   * runs the Fx.Morth effect to the given style
+   *
+   * @param Object style or a String class names
+   * @param Object optional effect options
+   * @return Element self
+   */
+  morph: function(style, options) {
+    return this.fx('morph', [style, options || {}]); // <- don't replace with arguments
+  },
+  
+  /**
+   * highlights the element
+   *
+   * @param String start color
+   * @param String optional end color
+   * @param Object effect options
+   * @return Element self
+   */
+  highlight: function() {
+    return this.fx('highlight', arguments);
+  },
+  
+  /**
+   * runs the Fx.Fade effect on the element
+   *
+   * @param mixed fade direction 'in' 'out' or a float number
+   * @return Element self
+   */
+  fade: function() {
+    return this.fx('fade', arguments);
+  },
+  
+  /**
+   * runs the Fx.Slide effect on the element
+   *
+   * @param String 'in' or 'out'
+   * @param Object effect options
+   * @return Element self
+   */
+  slide: function() {
+    return this.fx('slide', arguments);
+  },
+  
+// protected
+
+  // runs an Fx on the element
+  fx: function(name, args, on_finish) {
+    var args = $A(args).compact(), options = {};
+    if (isHash(args.last())) { options = args.pop(); }
+    
+    var fx = new Fx[name.capitalize()](this, options);
+    if (on_finish) fx.onFinish(on_finish.bind(this));
+    fx.start.apply(fx, args);
+    
+    return this;
+  }
+  
+}})(Element.Methods));
+