mirror of
https://github.com/swc-project/swc.git
synced 2025-01-02 18:43:52 +03:00
3750 lines
171 KiB
JavaScript
3750 lines
171 KiB
JavaScript
!function() {
|
|
this.MooTools = {
|
|
version: "1.4.5",
|
|
build: "ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0"
|
|
};
|
|
var typeOf1 = this.typeOf = function(item1) {
|
|
if (null == item1) return "null";
|
|
if (null != item1.$family) return item1.$family();
|
|
if (item1.nodeName) {
|
|
if (1 == item1.nodeType) return "element";
|
|
if (3 == item1.nodeType) return /\S/.test(item1.nodeValue) ? "textnode" : "whitespace";
|
|
} else if ("number" == typeof item1.length) {
|
|
if (item1.callee) return "arguments";
|
|
if ("item" in item1) return "collection";
|
|
}
|
|
return typeof item1;
|
|
}, instanceOf1 = this.instanceOf = function(item1, object1) {
|
|
if (null == item1) return !1;
|
|
for(var constructor1 = item1.$constructor || item1.constructor; constructor1;){
|
|
if (constructor1 === object1) return !0;
|
|
constructor1 = constructor1.parent;
|
|
}
|
|
return !!item1.hasOwnProperty && item1 instanceof object1;
|
|
}, Function1 = this.Function, enumerables1 = !0;
|
|
for(var i1 in {
|
|
toString: 1
|
|
})enumerables1 = null;
|
|
enumerables1 && (enumerables1 = [
|
|
"hasOwnProperty",
|
|
"valueOf",
|
|
"isPrototypeOf",
|
|
"propertyIsEnumerable",
|
|
"toLocaleString",
|
|
"toString",
|
|
"constructor"
|
|
]), Function1.prototype.overloadSetter = function(usePlural1) {
|
|
var self1 = this;
|
|
return function(a1, b1) {
|
|
if (null == a1) return this;
|
|
if (usePlural1 || "string" != typeof a1) {
|
|
for(var k1 in a1)self1.call(this, k1, a1[k1]);
|
|
if (enumerables1) for(var i1 = enumerables1.length; i1--;)k1 = enumerables1[i1], a1.hasOwnProperty(k1) && self1.call(this, k1, a1[k1]);
|
|
} else self1.call(this, a1, b1);
|
|
return this;
|
|
};
|
|
}, Function1.prototype.overloadGetter = function(usePlural1) {
|
|
var self1 = this;
|
|
return function(a1) {
|
|
var args1, result1;
|
|
if ("string" != typeof a1 ? args1 = a1 : arguments.length > 1 ? args1 = arguments : usePlural1 && (args1 = [
|
|
a1
|
|
]), args1) {
|
|
result1 = {};
|
|
for(var i1 = 0; i1 < args1.length; i1++)result1[args1[i1]] = self1.call(this, args1[i1]);
|
|
} else result1 = self1.call(this, a1);
|
|
return result1;
|
|
};
|
|
}, Function1.prototype.extend = (function(key1, value1) {
|
|
this[key1] = value1;
|
|
}).overloadSetter(), Function1.prototype.implement = (function(key1, value1) {
|
|
this.prototype[key1] = value1;
|
|
}).overloadSetter();
|
|
var slice1 = Array.prototype.slice;
|
|
Function1.from = function(item1) {
|
|
return "function" == typeOf1(item1) ? item1 : function() {
|
|
return item1;
|
|
};
|
|
}, Array.from = function(item1) {
|
|
return null == item1 ? [] : Type1.isEnumerable(item1) && "string" != typeof item1 ? "array" == typeOf1(item1) ? item1 : slice1.call(item1) : [
|
|
item1
|
|
];
|
|
}, Number.from = function(item1) {
|
|
var number1 = parseFloat(item1);
|
|
return isFinite(number1) ? number1 : null;
|
|
}, String.from = function(item1) {
|
|
return item1 + "";
|
|
}, Function1.implement({
|
|
hide: function() {
|
|
return this.$hidden = !0, this;
|
|
},
|
|
protect: function() {
|
|
return this.$protected = !0, this;
|
|
}
|
|
});
|
|
var Type1 = this.Type = function(name1, object1) {
|
|
if (name1) {
|
|
var lower1 = name1.toLowerCase(), typeCheck1 = function(item1) {
|
|
return typeOf1(item1) == lower1;
|
|
};
|
|
Type1["is" + name1] = typeCheck1, null != object1 && (object1.prototype.$family = (function() {
|
|
return lower1;
|
|
}).hide(), object1.type = typeCheck1);
|
|
}
|
|
return null == object1 ? null : (object1.extend(this), object1.$constructor = Type1, object1.prototype.$constructor = object1, object1);
|
|
}, toString1 = Object.prototype.toString;
|
|
Type1.isEnumerable = function(item1) {
|
|
return null != item1 && "number" == typeof item1.length && "[object Function]" != toString1.call(item1);
|
|
};
|
|
var hooks1 = {}, hooksOf1 = function(object1) {
|
|
var type1 = typeOf1(object1.prototype);
|
|
return hooks1[type1] || (hooks1[type1] = []);
|
|
}, implement1 = function(name1, method1) {
|
|
if (!method1 || !method1.$hidden) {
|
|
for(var hooks1 = hooksOf1(this), i1 = 0; i1 < hooks1.length; i1++){
|
|
var hook1 = hooks1[i1];
|
|
"type" == typeOf1(hook1) ? implement1.call(hook1, name1, method1) : hook1.call(this, name1, method1);
|
|
}
|
|
var previous1 = this.prototype[name1];
|
|
null != previous1 && previous1.$protected || (this.prototype[name1] = method1), null == this[name1] && "function" == typeOf1(method1) && extend1.call(this, name1, function(item1) {
|
|
return method1.apply(item1, slice1.call(arguments, 1));
|
|
});
|
|
}
|
|
}, extend1 = function(name1, method1) {
|
|
if (!method1 || !method1.$hidden) {
|
|
var previous1 = this[name1];
|
|
null != previous1 && previous1.$protected || (this[name1] = method1);
|
|
}
|
|
};
|
|
Type1.implement({
|
|
implement: implement1.overloadSetter(),
|
|
extend: extend1.overloadSetter(),
|
|
alias: (function(name1, existing1) {
|
|
implement1.call(this, name1, this.prototype[existing1]);
|
|
}).overloadSetter(),
|
|
mirror: function(hook1) {
|
|
return hooksOf1(this).push(hook1), this;
|
|
}
|
|
}), new Type1("Type", Type1);
|
|
var force1 = function(name1, object1, methods1) {
|
|
var isType1 = object1 != Object, prototype1 = object1.prototype;
|
|
isType1 && (object1 = new Type1(name1, object1));
|
|
for(var i1 = 0, l1 = methods1.length; i1 < l1; i1++){
|
|
var key1 = methods1[i1], generic1 = object1[key1], proto1 = prototype1[key1];
|
|
generic1 && generic1.protect(), isType1 && proto1 && object1.implement(key1, proto1.protect());
|
|
}
|
|
if (isType1) {
|
|
var methodsEnumerable1 = prototype1.propertyIsEnumerable(methods1[0]);
|
|
object1.forEachMethod = function(fn1) {
|
|
if (!methodsEnumerable1) for(var i1 = 0, l1 = methods1.length; i1 < l1; i1++)fn1.call(prototype1, prototype1[methods1[i1]], methods1[i1]);
|
|
for(var key1 in prototype1)fn1.call(prototype1, prototype1[key1], key1);
|
|
};
|
|
}
|
|
return force1;
|
|
};
|
|
force1("String", String, [
|
|
"charAt",
|
|
"charCodeAt",
|
|
"concat",
|
|
"indexOf",
|
|
"lastIndexOf",
|
|
"match",
|
|
"quote",
|
|
"replace",
|
|
"search",
|
|
"slice",
|
|
"split",
|
|
"substr",
|
|
"substring",
|
|
"trim",
|
|
"toLowerCase",
|
|
"toUpperCase"
|
|
])("Array", Array, [
|
|
"pop",
|
|
"push",
|
|
"reverse",
|
|
"shift",
|
|
"sort",
|
|
"splice",
|
|
"unshift",
|
|
"concat",
|
|
"join",
|
|
"slice",
|
|
"indexOf",
|
|
"lastIndexOf",
|
|
"filter",
|
|
"forEach",
|
|
"every",
|
|
"map",
|
|
"some",
|
|
"reduce",
|
|
"reduceRight"
|
|
])("Number", Number, [
|
|
"toExponential",
|
|
"toFixed",
|
|
"toLocaleString",
|
|
"toPrecision"
|
|
])("Function", Function1, [
|
|
"apply",
|
|
"call",
|
|
"bind"
|
|
])("RegExp", RegExp, [
|
|
"exec",
|
|
"test"
|
|
])("Object", Object, [
|
|
"create",
|
|
"defineProperty",
|
|
"defineProperties",
|
|
"keys",
|
|
"getPrototypeOf",
|
|
"getOwnPropertyDescriptor",
|
|
"getOwnPropertyNames",
|
|
"preventExtensions",
|
|
"isExtensible",
|
|
"seal",
|
|
"isSealed",
|
|
"freeze",
|
|
"isFrozen"
|
|
])("Date", Date, [
|
|
"now"
|
|
]), Object.extend = extend1.overloadSetter(), Date.extend("now", function() {
|
|
return +new Date();
|
|
}), new Type1("Boolean", Boolean), Number.prototype.$family = (function() {
|
|
return isFinite(this) ? "number" : "null";
|
|
}).hide(), Number.extend("random", function(min1, max1) {
|
|
return Math.floor(Math.random() * (max1 - min1 + 1) + min1);
|
|
});
|
|
var hasOwnProperty1 = Object.prototype.hasOwnProperty;
|
|
Object.extend("forEach", function(object1, fn1, bind1) {
|
|
for(var key1 in object1)hasOwnProperty1.call(object1, key1) && fn1.call(bind1, object1[key1], key1, object1);
|
|
}), Object.each = Object.forEach, Array.implement({
|
|
forEach: function(fn1, bind1) {
|
|
for(var i1 = 0, l1 = this.length; i1 < l1; i1++)i1 in this && fn1.call(bind1, this[i1], i1, this);
|
|
},
|
|
each: function(fn1, bind1) {
|
|
return Array.forEach(this, fn1, bind1), this;
|
|
}
|
|
});
|
|
var cloneOf1 = function(item1) {
|
|
switch(typeOf1(item1)){
|
|
case "array":
|
|
return item1.clone();
|
|
case "object":
|
|
return Object.clone(item1);
|
|
default:
|
|
return item1;
|
|
}
|
|
};
|
|
Array.implement("clone", function() {
|
|
for(var i1 = this.length, clone1 = Array(i1); i1--;)clone1[i1] = cloneOf1(this[i1]);
|
|
return clone1;
|
|
});
|
|
var mergeOne1 = function(source1, key1, current1) {
|
|
switch(typeOf1(current1)){
|
|
case "object":
|
|
"object" == typeOf1(source1[key1]) ? Object.merge(source1[key1], current1) : source1[key1] = Object.clone(current1);
|
|
break;
|
|
case "array":
|
|
source1[key1] = current1.clone();
|
|
break;
|
|
default:
|
|
source1[key1] = current1;
|
|
}
|
|
return source1;
|
|
};
|
|
Object.extend({
|
|
merge: function(source1, k1, v1) {
|
|
if ("string" == typeOf1(k1)) return mergeOne1(source1, k1, v1);
|
|
for(var i1 = 1, l1 = arguments.length; i1 < l1; i1++){
|
|
var object1 = arguments[i1];
|
|
for(var key1 in object1)mergeOne1(source1, key1, object1[key1]);
|
|
}
|
|
return source1;
|
|
},
|
|
clone: function(object1) {
|
|
var clone1 = {};
|
|
for(var key1 in object1)clone1[key1] = cloneOf1(object1[key1]);
|
|
return clone1;
|
|
},
|
|
append: function(original1) {
|
|
for(var i1 = 1, l1 = arguments.length; i1 < l1; i1++){
|
|
var extended1 = arguments[i1] || {};
|
|
for(var key1 in extended1)original1[key1] = extended1[key1];
|
|
}
|
|
return original1;
|
|
}
|
|
}), [
|
|
"Object",
|
|
"WhiteSpace",
|
|
"TextNode",
|
|
"Collection",
|
|
"Arguments"
|
|
].each(function(name1) {
|
|
new Type1(name1);
|
|
});
|
|
var UID1 = Date.now();
|
|
String.extend("uniqueID", function() {
|
|
return (UID1++).toString(36);
|
|
});
|
|
var Hash1 = this.Hash = new Type1("Hash", function(object1) {
|
|
for(var key1 in "hash" == typeOf1(object1) && (object1 = Object.clone(object1.getClean())), object1)this[key1] = object1[key1];
|
|
return this;
|
|
});
|
|
Hash1.implement({
|
|
forEach: function(fn1, bind1) {
|
|
Object.forEach(this, fn1, bind1);
|
|
},
|
|
getClean: function() {
|
|
var clean1 = {};
|
|
for(var key1 in this)this.hasOwnProperty(key1) && (clean1[key1] = this[key1]);
|
|
return clean1;
|
|
},
|
|
getLength: function() {
|
|
var length1 = 0;
|
|
for(var key1 in this)this.hasOwnProperty(key1) && length1++;
|
|
return length1;
|
|
}
|
|
}), Hash1.alias("each", "forEach"), Object.type = Type1.isObject;
|
|
var Native1 = this.Native = function(properties1) {
|
|
return new Type1(properties1.name, properties1.initialize);
|
|
};
|
|
Native1.type = Type1.type, Native1.implement = function(objects1, methods1) {
|
|
for(var i1 = 0; i1 < objects1.length; i1++)objects1[i1].implement(methods1);
|
|
return Native1;
|
|
};
|
|
var arrayType1 = Array.type;
|
|
Array.type = function(item1) {
|
|
return instanceOf1(item1, Array) || arrayType1(item1);
|
|
}, this.$A = function(item1) {
|
|
return Array.from(item1).slice();
|
|
}, this.$arguments = function(i1) {
|
|
return function() {
|
|
return arguments[i1];
|
|
};
|
|
}, this.$chk = function(obj1) {
|
|
return !!(obj1 || 0 === obj1);
|
|
}, this.$clear = function(timer1) {
|
|
return clearTimeout(timer1), clearInterval(timer1), null;
|
|
}, this.$defined = function(obj1) {
|
|
return null != obj1;
|
|
}, this.$each = function(iterable1, fn1, bind1) {
|
|
var type1 = typeOf1(iterable1);
|
|
("arguments" == type1 || "collection" == type1 || "array" == type1 || "elements" == type1 ? Array : Object).each(iterable1, fn1, bind1);
|
|
}, this.$empty = function() {}, this.$extend = function(original1, extended1) {
|
|
return Object.append(original1, extended1);
|
|
}, this.$H = function(object1) {
|
|
return new Hash1(object1);
|
|
}, this.$merge = function() {
|
|
var args1 = Array.slice(arguments);
|
|
return args1.unshift({}), Object.merge.apply(null, args1);
|
|
}, this.$lambda = Function1.from, this.$mixin = Object.merge, this.$random = Number.random, this.$splat = Array.from, this.$time = Date.now, this.$type = function(object1) {
|
|
var type1 = typeOf1(object1);
|
|
return "elements" == type1 ? "array" : "null" != type1 && type1;
|
|
}, this.$unlink = function(object1) {
|
|
switch(typeOf1(object1)){
|
|
case "object":
|
|
return Object.clone(object1);
|
|
case "array":
|
|
return Array.clone(object1);
|
|
case "hash":
|
|
return new Hash1(object1);
|
|
default:
|
|
return object1;
|
|
}
|
|
};
|
|
}(), Array.implement({
|
|
every: function(fn1, bind1) {
|
|
for(var i1 = 0, l1 = this.length >>> 0; i1 < l1; i1++)if (i1 in this && !fn1.call(bind1, this[i1], i1, this)) return !1;
|
|
return !0;
|
|
},
|
|
filter: function(fn1, bind1) {
|
|
for(var value1, results1 = [], i1 = 0, l1 = this.length >>> 0; i1 < l1; i1++)i1 in this && (value1 = this[i1], fn1.call(bind1, value1, i1, this) && results1.push(value1));
|
|
return results1;
|
|
},
|
|
indexOf: function(item1, from1) {
|
|
for(var length1 = this.length >>> 0, i1 = from1 < 0 ? Math.max(0, length1 + from1) : from1 || 0; i1 < length1; i1++)if (this[i1] === item1) return i1;
|
|
return -1;
|
|
},
|
|
map: function(fn1, bind1) {
|
|
for(var length1 = this.length >>> 0, results1 = Array(length1), i1 = 0; i1 < length1; i1++)i1 in this && (results1[i1] = fn1.call(bind1, this[i1], i1, this));
|
|
return results1;
|
|
},
|
|
some: function(fn1, bind1) {
|
|
for(var i1 = 0, l1 = this.length >>> 0; i1 < l1; i1++)if (i1 in this && fn1.call(bind1, this[i1], i1, this)) return !0;
|
|
return !1;
|
|
},
|
|
clean: function() {
|
|
return this.filter(function(item1) {
|
|
return null != item1;
|
|
});
|
|
},
|
|
invoke: function(methodName1) {
|
|
var args1 = Array.slice(arguments, 1);
|
|
return this.map(function(item1) {
|
|
return item1[methodName1].apply(item1, args1);
|
|
});
|
|
},
|
|
associate: function(keys1) {
|
|
for(var obj1 = {}, length1 = Math.min(this.length, keys1.length), i1 = 0; i1 < length1; i1++)obj1[keys1[i1]] = this[i1];
|
|
return obj1;
|
|
},
|
|
link: function(object1) {
|
|
for(var result1 = {}, i1 = 0, l1 = this.length; i1 < l1; i1++)for(var key1 in object1)if (object1[key1](this[i1])) {
|
|
result1[key1] = this[i1], delete object1[key1];
|
|
break;
|
|
}
|
|
return result1;
|
|
},
|
|
contains: function(item1, from1) {
|
|
return -1 != this.indexOf(item1, from1);
|
|
},
|
|
append: function(array1) {
|
|
return this.push.apply(this, array1), this;
|
|
},
|
|
getLast: function() {
|
|
return this.length ? this[this.length - 1] : null;
|
|
},
|
|
getRandom: function() {
|
|
return this.length ? this[Number.random(0, this.length - 1)] : null;
|
|
},
|
|
include: function(item1) {
|
|
return this.contains(item1) || this.push(item1), this;
|
|
},
|
|
combine: function(array1) {
|
|
for(var i1 = 0, l1 = array1.length; i1 < l1; i1++)this.include(array1[i1]);
|
|
return this;
|
|
},
|
|
erase: function(item1) {
|
|
for(var i1 = this.length; i1--;)this[i1] === item1 && this.splice(i1, 1);
|
|
return this;
|
|
},
|
|
empty: function() {
|
|
return this.length = 0, this;
|
|
},
|
|
flatten: function() {
|
|
for(var array1 = [], i1 = 0, l1 = this.length; i1 < l1; i1++){
|
|
var type1 = typeOf(this[i1]);
|
|
"null" != type1 && (array1 = array1.concat("array" == type1 || "collection" == type1 || "arguments" == type1 || instanceOf(this[i1], Array) ? Array.flatten(this[i1]) : this[i1]));
|
|
}
|
|
return array1;
|
|
},
|
|
pick: function() {
|
|
for(var i1 = 0, l1 = this.length; i1 < l1; i1++)if (null != this[i1]) return this[i1];
|
|
return null;
|
|
},
|
|
hexToRgb: function(array1) {
|
|
if (3 != this.length) return null;
|
|
var rgb1 = this.map(function(value1) {
|
|
return 1 == value1.length && (value1 += value1), value1.toInt(16);
|
|
});
|
|
return array1 ? rgb1 : "rgb(" + rgb1 + ")";
|
|
},
|
|
rgbToHex: function(array1) {
|
|
if (this.length < 3) return null;
|
|
if (4 == this.length && 0 == this[3] && !array1) return "transparent";
|
|
for(var hex1 = [], i1 = 0; i1 < 3; i1++){
|
|
var bit1 = (this[i1] - 0).toString(16);
|
|
hex1.push(1 == bit1.length ? "0" + bit1 : bit1);
|
|
}
|
|
return array1 ? hex1 : "#" + hex1.join("");
|
|
}
|
|
}), Array.alias("extend", "append");
|
|
var $pick = function() {
|
|
return Array.from(arguments).pick();
|
|
};
|
|
String.implement({
|
|
test: function(regex1, params1) {
|
|
return ("regexp" == typeOf(regex1) ? regex1 : RegExp("" + regex1, params1)).test(this);
|
|
},
|
|
contains: function(string1, separator1) {
|
|
return separator1 ? (separator1 + this + separator1).indexOf(separator1 + string1 + separator1) > -1 : String(this).indexOf(string1) > -1;
|
|
},
|
|
trim: function() {
|
|
return String(this).replace(/^\s+|\s+$/g, "");
|
|
},
|
|
clean: function() {
|
|
return String(this).replace(/\s+/g, " ").trim();
|
|
},
|
|
camelCase: function() {
|
|
return String(this).replace(/-\D/g, function(match1) {
|
|
return match1.charAt(1).toUpperCase();
|
|
});
|
|
},
|
|
hyphenate: function() {
|
|
return String(this).replace(/[A-Z]/g, function(match1) {
|
|
return "-" + match1.charAt(0).toLowerCase();
|
|
});
|
|
},
|
|
capitalize: function() {
|
|
return String(this).replace(/\b[a-z]/g, function(match1) {
|
|
return match1.toUpperCase();
|
|
});
|
|
},
|
|
escapeRegExp: function() {
|
|
return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g, "\\$1");
|
|
},
|
|
toInt: function(base1) {
|
|
return parseInt(this, base1 || 10);
|
|
},
|
|
toFloat: function() {
|
|
return parseFloat(this);
|
|
},
|
|
hexToRgb: function(array1) {
|
|
var hex1 = String(this).match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
|
|
return hex1 ? hex1.slice(1).hexToRgb(array1) : null;
|
|
},
|
|
rgbToHex: function(array1) {
|
|
var rgb1 = String(this).match(/\d{1,3}/g);
|
|
return rgb1 ? rgb1.rgbToHex(array1) : null;
|
|
},
|
|
substitute: function(object1, regexp1) {
|
|
return String(this).replace(regexp1 || /\\?\{([^{}]+)\}/g, function(match1, name1) {
|
|
return "\\" == match1.charAt(0) ? match1.slice(1) : null != object1[name1] ? object1[name1] : "";
|
|
});
|
|
}
|
|
}), Number.implement({
|
|
limit: function(min1, max1) {
|
|
return Math.min(max1, Math.max(min1, this));
|
|
},
|
|
round: function(precision1) {
|
|
return Math.round(this * (precision1 = Math.pow(10, precision1 || 0).toFixed(precision1 < 0 ? -precision1 : 0))) / precision1;
|
|
},
|
|
times: function(fn1, bind1) {
|
|
for(var i1 = 0; i1 < this; i1++)fn1.call(bind1, i1, this);
|
|
},
|
|
toFloat: function() {
|
|
return parseFloat(this);
|
|
},
|
|
toInt: function(base1) {
|
|
return parseInt(this, base1 || 10);
|
|
}
|
|
}), Number.alias("each", "times"), function(math1) {
|
|
var methods1 = {};
|
|
math1.each(function(name1) {
|
|
Number[name1] || (methods1[name1] = function() {
|
|
return Math[name1].apply(null, [
|
|
this
|
|
].concat(Array.from(arguments)));
|
|
});
|
|
}), Number.implement(methods1);
|
|
}([
|
|
"abs",
|
|
"acos",
|
|
"asin",
|
|
"atan",
|
|
"atan2",
|
|
"ceil",
|
|
"cos",
|
|
"exp",
|
|
"floor",
|
|
"log",
|
|
"max",
|
|
"min",
|
|
"pow",
|
|
"sin",
|
|
"sqrt",
|
|
"tan"
|
|
]), Function.extend({
|
|
attempt: function() {
|
|
for(var i1 = 0, l1 = arguments.length; i1 < l1; i1++)try {
|
|
return arguments[i1]();
|
|
} catch (e1) {}
|
|
return null;
|
|
}
|
|
}), Function.implement({
|
|
attempt: function(args1, bind1) {
|
|
try {
|
|
return this.apply(bind1, Array.from(args1));
|
|
} catch (e1) {}
|
|
return null;
|
|
},
|
|
bind: function(that1) {
|
|
var self1 = this, args1 = arguments.length > 1 ? Array.slice(arguments, 1) : null, F1 = function() {}, bound1 = function() {
|
|
var context1 = that1, length1 = arguments.length;
|
|
this instanceof bound1 && (F1.prototype = self1.prototype, context1 = new F1());
|
|
var result1 = args1 || length1 ? self1.apply(context1, args1 && length1 ? args1.concat(Array.slice(arguments)) : args1 || arguments) : self1.call(context1);
|
|
return context1 == that1 ? result1 : context1;
|
|
};
|
|
return bound1;
|
|
},
|
|
pass: function(args1, bind1) {
|
|
var self1 = this;
|
|
return null != args1 && (args1 = Array.from(args1)), function() {
|
|
return self1.apply(bind1, args1 || arguments);
|
|
};
|
|
},
|
|
delay: function(delay1, bind1, args1) {
|
|
return setTimeout(this.pass(null == args1 ? [] : args1, bind1), delay1);
|
|
},
|
|
periodical: function(periodical1, bind1, args1) {
|
|
return setInterval(this.pass(null == args1 ? [] : args1, bind1), periodical1);
|
|
}
|
|
}), delete Function.prototype.bind, Function.implement({
|
|
create: function(options1) {
|
|
var self1 = this;
|
|
return options1 = options1 || {}, function(event1) {
|
|
var args1 = options1.arguments;
|
|
args1 = null != args1 ? Array.from(args1) : Array.slice(arguments, options1.event ? 1 : 0), options1.event && (args1 = [
|
|
event1 || window.event
|
|
].extend(args1));
|
|
var returns1 = function() {
|
|
return self1.apply(options1.bind || null, args1);
|
|
};
|
|
return options1.delay ? setTimeout(returns1, options1.delay) : options1.periodical ? setInterval(returns1, options1.periodical) : options1.attempt ? Function.attempt(returns1) : returns1();
|
|
};
|
|
},
|
|
bind: function(bind1, args1) {
|
|
var self1 = this;
|
|
return null != args1 && (args1 = Array.from(args1)), function() {
|
|
return self1.apply(bind1, args1 || arguments);
|
|
};
|
|
},
|
|
bindWithEvent: function(bind1, args1) {
|
|
var self1 = this;
|
|
return null != args1 && (args1 = Array.from(args1)), function(event1) {
|
|
return self1.apply(bind1, null == args1 ? arguments : [
|
|
event1
|
|
].concat(args1));
|
|
};
|
|
},
|
|
run: function(args1, bind1) {
|
|
return this.apply(bind1, Array.from(args1));
|
|
}
|
|
}), Object.create == Function.prototype.create && (Object.create = null);
|
|
var $try = Function.attempt;
|
|
!function() {
|
|
var hasOwnProperty1 = Object.prototype.hasOwnProperty;
|
|
Object.extend({
|
|
subset: function(object1, keys1) {
|
|
for(var results1 = {}, i1 = 0, l1 = keys1.length; i1 < l1; i1++){
|
|
var k1 = keys1[i1];
|
|
k1 in object1 && (results1[k1] = object1[k1]);
|
|
}
|
|
return results1;
|
|
},
|
|
map: function(object1, fn1, bind1) {
|
|
var results1 = {};
|
|
for(var key1 in object1)hasOwnProperty1.call(object1, key1) && (results1[key1] = fn1.call(bind1, object1[key1], key1, object1));
|
|
return results1;
|
|
},
|
|
filter: function(object1, fn1, bind1) {
|
|
var results1 = {};
|
|
for(var key1 in object1){
|
|
var value1 = object1[key1];
|
|
hasOwnProperty1.call(object1, key1) && fn1.call(bind1, value1, key1, object1) && (results1[key1] = value1);
|
|
}
|
|
return results1;
|
|
},
|
|
every: function(object1, fn1, bind1) {
|
|
for(var key1 in object1)if (hasOwnProperty1.call(object1, key1) && !fn1.call(bind1, object1[key1], key1)) return !1;
|
|
return !0;
|
|
},
|
|
some: function(object1, fn1, bind1) {
|
|
for(var key1 in object1)if (hasOwnProperty1.call(object1, key1) && fn1.call(bind1, object1[key1], key1)) return !0;
|
|
return !1;
|
|
},
|
|
keys: function(object1) {
|
|
var keys1 = [];
|
|
for(var key1 in object1)hasOwnProperty1.call(object1, key1) && keys1.push(key1);
|
|
return keys1;
|
|
},
|
|
values: function(object1) {
|
|
var values1 = [];
|
|
for(var key1 in object1)hasOwnProperty1.call(object1, key1) && values1.push(object1[key1]);
|
|
return values1;
|
|
},
|
|
getLength: function(object1) {
|
|
return Object.keys(object1).length;
|
|
},
|
|
keyOf: function(object1, value1) {
|
|
for(var key1 in object1)if (hasOwnProperty1.call(object1, key1) && object1[key1] === value1) return key1;
|
|
return null;
|
|
},
|
|
contains: function(object1, value1) {
|
|
return null != Object.keyOf(object1, value1);
|
|
},
|
|
toQueryString: function(object1, base1) {
|
|
var queryString1 = [];
|
|
return Object.each(object1, function(value1, key1) {
|
|
switch(base1 && (key1 = base1 + "[" + key1 + "]"), typeOf(value1)){
|
|
case "object":
|
|
result1 = Object.toQueryString(value1, key1);
|
|
break;
|
|
case "array":
|
|
var result1, qs1 = {};
|
|
value1.each(function(val1, i1) {
|
|
qs1[i1] = val1;
|
|
}), result1 = Object.toQueryString(qs1, key1);
|
|
break;
|
|
default:
|
|
result1 = key1 + "=" + encodeURIComponent(value1);
|
|
}
|
|
null != value1 && queryString1.push(result1);
|
|
}), queryString1.join("&");
|
|
}
|
|
});
|
|
}(), Hash.implement({
|
|
has: Object.prototype.hasOwnProperty,
|
|
keyOf: function(value1) {
|
|
return Object.keyOf(this, value1);
|
|
},
|
|
hasValue: function(value1) {
|
|
return Object.contains(this, value1);
|
|
},
|
|
extend: function(properties1) {
|
|
return Hash.each(properties1 || {}, function(value1, key1) {
|
|
Hash.set(this, key1, value1);
|
|
}, this), this;
|
|
},
|
|
combine: function(properties1) {
|
|
return Hash.each(properties1 || {}, function(value1, key1) {
|
|
Hash.include(this, key1, value1);
|
|
}, this), this;
|
|
},
|
|
erase: function(key1) {
|
|
return this.hasOwnProperty(key1) && delete this[key1], this;
|
|
},
|
|
get: function(key1) {
|
|
return this.hasOwnProperty(key1) ? this[key1] : null;
|
|
},
|
|
set: function(key1, value1) {
|
|
return (!this[key1] || this.hasOwnProperty(key1)) && (this[key1] = value1), this;
|
|
},
|
|
empty: function() {
|
|
return Hash.each(this, function(value1, key1) {
|
|
delete this[key1];
|
|
}, this), this;
|
|
},
|
|
include: function(key1, value1) {
|
|
return null == this[key1] && (this[key1] = value1), this;
|
|
},
|
|
map: function(fn1, bind1) {
|
|
return new Hash(Object.map(this, fn1, bind1));
|
|
},
|
|
filter: function(fn1, bind1) {
|
|
return new Hash(Object.filter(this, fn1, bind1));
|
|
},
|
|
every: function(fn1, bind1) {
|
|
return Object.every(this, fn1, bind1);
|
|
},
|
|
some: function(fn1, bind1) {
|
|
return Object.some(this, fn1, bind1);
|
|
},
|
|
getKeys: function() {
|
|
return Object.keys(this);
|
|
},
|
|
getValues: function() {
|
|
return Object.values(this);
|
|
},
|
|
toQueryString: function(base1) {
|
|
return Object.toQueryString(this, base1);
|
|
}
|
|
}), Hash.extend = Object.append, Hash.alias({
|
|
indexOf: "keyOf",
|
|
contains: "hasValue"
|
|
}), function() {
|
|
var document1 = this.document, window1 = document1.window = this, ua1 = navigator.userAgent.toLowerCase(), platform1 = navigator.platform.toLowerCase(), UA1 = ua1.match(/(opera|ie|firefox|chrome|version)[\s\/:]([\w\d\.]+)?.*?(safari|version[\s\/:]([\w\d\.]+)|$)/) || [
|
|
null,
|
|
"unknown",
|
|
0
|
|
], mode1 = "ie" == UA1[1] && document1.documentMode, Browser1 = this.Browser = {
|
|
extend: Function.prototype.extend,
|
|
name: "version" == UA1[1] ? UA1[3] : UA1[1],
|
|
version: mode1 || parseFloat("opera" == UA1[1] && UA1[4] ? UA1[4] : UA1[2]),
|
|
Platform: {
|
|
name: ua1.match(/ip(?:ad|od|hone)/) ? "ios" : (ua1.match(/(?:webos|android)/) || platform1.match(/mac|win|linux/) || [
|
|
"other"
|
|
])[0]
|
|
},
|
|
Features: {
|
|
xpath: !!document1.evaluate,
|
|
air: !!window1.runtime,
|
|
query: !!document1.querySelector,
|
|
json: !!window1.JSON
|
|
},
|
|
Plugins: {}
|
|
};
|
|
Browser1[Browser1.name] = !0, Browser1[Browser1.name + parseInt(Browser1.version, 10)] = !0, Browser1.Platform[Browser1.Platform.name] = !0, Browser1.Request = function() {
|
|
var XMLHTTP1 = function() {
|
|
return new XMLHttpRequest();
|
|
}, MSXML21 = function() {
|
|
return new ActiveXObject("MSXML2.XMLHTTP");
|
|
}, MSXML1 = function() {
|
|
return new ActiveXObject("Microsoft.XMLHTTP");
|
|
};
|
|
return Function.attempt(function() {
|
|
return XMLHTTP1(), XMLHTTP1;
|
|
}, function() {
|
|
return MSXML21(), MSXML21;
|
|
}, function() {
|
|
return MSXML1(), MSXML1;
|
|
});
|
|
}(), Browser1.Features.xhr = !!Browser1.Request;
|
|
var version1 = (Function.attempt(function() {
|
|
return navigator.plugins["Shockwave Flash"].description;
|
|
}, function() {
|
|
return new ActiveXObject("ShockwaveFlash.ShockwaveFlash").GetVariable("$version");
|
|
}) || "0 r0").match(/\d+/g);
|
|
if (Browser1.Plugins.Flash = {
|
|
version: Number(version1[0] || "0." + version1[1]) || 0,
|
|
build: Number(version1[2]) || 0
|
|
}, Browser1.exec = function(text1) {
|
|
if (!text1) return text1;
|
|
if (window1.execScript) window1.execScript(text1);
|
|
else {
|
|
var script1 = document1.createElement("script");
|
|
script1.setAttribute("type", "text/javascript"), script1.text = text1, document1.head.appendChild(script1), document1.head.removeChild(script1);
|
|
}
|
|
return text1;
|
|
}, String.implement("stripScripts", function(exec1) {
|
|
var scripts1 = "", text1 = this.replace(/<script[^>]*>([\s\S]*?)<\/script>/gi, function(all1, code1) {
|
|
return scripts1 += code1 + "\n", "";
|
|
});
|
|
return !0 === exec1 ? Browser1.exec(scripts1) : "function" == typeOf(exec1) && exec1(scripts1, text1), text1;
|
|
}), Browser1.extend({
|
|
Document: this.Document,
|
|
Window: this.Window,
|
|
Element: this.Element,
|
|
Event: this.Event
|
|
}), this.Window = this.$constructor = new Type("Window", function() {}), this.$family = Function.from("window").hide(), Window.mirror(function(name1, method1) {
|
|
window1[name1] = method1;
|
|
}), this.Document = document1.$constructor = new Type("Document", function() {}), document1.$family = Function.from("document").hide(), Document.mirror(function(name1, method1) {
|
|
document1[name1] = method1;
|
|
}), document1.html = document1.documentElement, document1.head || (document1.head = document1.getElementsByTagName("head")[0]), document1.execCommand) try {
|
|
document1.execCommand("BackgroundImageCache", !1, !0);
|
|
} catch (e1) {}
|
|
if (this.attachEvent && !this.addEventListener) {
|
|
var unloadEvent1 = function() {
|
|
this.detachEvent("onunload", unloadEvent1), document1.head = document1.html = document1.window = null;
|
|
};
|
|
this.attachEvent("onunload", unloadEvent1);
|
|
}
|
|
var arrayFrom1 = Array.from;
|
|
try {
|
|
arrayFrom1(document1.html.childNodes);
|
|
} catch (e1) {
|
|
Array.from = function(item1) {
|
|
if ("string" != typeof item1 && Type.isEnumerable(item1) && "array" != typeOf(item1)) {
|
|
for(var i1 = item1.length, array1 = Array(i1); i1--;)array1[i1] = item1[i1];
|
|
return array1;
|
|
}
|
|
return arrayFrom1(item1);
|
|
};
|
|
var prototype1 = Array.prototype, slice1 = prototype1.slice;
|
|
[
|
|
"pop",
|
|
"push",
|
|
"reverse",
|
|
"shift",
|
|
"sort",
|
|
"splice",
|
|
"unshift",
|
|
"concat",
|
|
"join",
|
|
"slice"
|
|
].each(function(name1) {
|
|
var method1 = prototype1[name1];
|
|
Array[name1] = function(item1) {
|
|
return method1.apply(Array.from(item1), slice1.call(arguments, 1));
|
|
};
|
|
});
|
|
}
|
|
Browser1.Platform.ios && (Browser1.Platform.ipod = !0), Browser1.Engine = {};
|
|
var setEngine1 = function(name1, version1) {
|
|
Browser1.Engine.name = name1, Browser1.Engine[name1 + version1] = !0, Browser1.Engine.version = version1;
|
|
};
|
|
if (Browser1.ie) switch(Browser1.Engine.trident = !0, Browser1.version){
|
|
case 6:
|
|
setEngine1("trident", 4);
|
|
break;
|
|
case 7:
|
|
setEngine1("trident", 5);
|
|
break;
|
|
case 8:
|
|
setEngine1("trident", 6);
|
|
}
|
|
if (Browser1.firefox && (Browser1.Engine.gecko = !0, setEngine1("gecko", Browser1.version >= 3 ? 19 : 18)), Browser1.safari || Browser1.chrome) switch(Browser1.Engine.webkit = !0, Browser1.version){
|
|
case 2:
|
|
setEngine1("webkit", 419);
|
|
break;
|
|
case 3:
|
|
setEngine1("webkit", 420);
|
|
break;
|
|
case 4:
|
|
setEngine1("webkit", 525);
|
|
}
|
|
if (Browser1.opera && (Browser1.Engine.presto = !0, setEngine1("presto", Browser1.version >= 9.6 ? 960 : Browser1.version >= 9.5 ? 950 : 925)), "unknown" == Browser1.name) switch((ua1.match(/(?:webkit|khtml|gecko)/) || [])[0]){
|
|
case "webkit":
|
|
case "khtml":
|
|
Browser1.Engine.webkit = !0;
|
|
break;
|
|
case "gecko":
|
|
Browser1.Engine.gecko = !0;
|
|
}
|
|
this.$exec = Browser1.exec;
|
|
}(), function() {
|
|
var _keys1 = {}, DOMEvent1 = this.DOMEvent = new Type("DOMEvent", function(event1, win1) {
|
|
if (win1 || (win1 = window), (event1 = event1 || win1.event).$extended) return event1;
|
|
this.event = event1, this.$extended = !0, this.shift = event1.shiftKey, this.control = event1.ctrlKey, this.alt = event1.altKey, this.meta = event1.metaKey;
|
|
for(var type1 = this.type = event1.type, target1 = event1.target || event1.srcElement; target1 && 3 == target1.nodeType;)target1 = target1.parentNode;
|
|
if (this.target = document.id(target1), 0 == type1.indexOf("key")) {
|
|
var code1 = this.code = event1.which || event1.keyCode;
|
|
this.key = _keys1[code1] || Object.keyOf(Event.Keys, code1), "keydown" == type1 && (code1 > 111 && code1 < 124 ? this.key = "f" + (code1 - 111) : code1 > 95 && code1 < 106 && (this.key = code1 - 96)), null == this.key && (this.key = String.fromCharCode(code1).toLowerCase());
|
|
} else if ("click" == type1 || "dblclick" == type1 || "contextmenu" == type1 || "DOMMouseScroll" == type1 || 0 == type1.indexOf("mouse")) {
|
|
var doc1 = win1.document;
|
|
if (doc1 = doc1.compatMode && "CSS1Compat" != doc1.compatMode ? doc1.body : doc1.html, this.page = {
|
|
x: null != event1.pageX ? event1.pageX : event1.clientX + doc1.scrollLeft,
|
|
y: null != event1.pageY ? event1.pageY : event1.clientY + doc1.scrollTop
|
|
}, this.client = {
|
|
x: null != event1.pageX ? event1.pageX - win1.pageXOffset : event1.clientX,
|
|
y: null != event1.pageY ? event1.pageY - win1.pageYOffset : event1.clientY
|
|
}, ("DOMMouseScroll" == type1 || "mousewheel" == type1) && (this.wheel = event1.wheelDelta ? event1.wheelDelta / 120 : -(event1.detail || 0) / 3), this.rightClick = 3 == event1.which || 2 == event1.button, "mouseover" == type1 || "mouseout" == type1) {
|
|
for(var related1 = event1.relatedTarget || event1[("mouseover" == type1 ? "from" : "to") + "Element"]; related1 && 3 == related1.nodeType;)related1 = related1.parentNode;
|
|
this.relatedTarget = document.id(related1);
|
|
}
|
|
} else if (0 == type1.indexOf("touch") || 0 == type1.indexOf("gesture")) {
|
|
this.rotation = event1.rotation, this.scale = event1.scale, this.targetTouches = event1.targetTouches, this.changedTouches = event1.changedTouches;
|
|
var touches1 = this.touches = event1.touches;
|
|
if (touches1 && touches1[0]) {
|
|
var touch1 = touches1[0];
|
|
this.page = {
|
|
x: touch1.pageX,
|
|
y: touch1.pageY
|
|
}, this.client = {
|
|
x: touch1.clientX,
|
|
y: touch1.clientY
|
|
};
|
|
}
|
|
}
|
|
this.client || (this.client = {}), this.page || (this.page = {});
|
|
});
|
|
DOMEvent1.implement({
|
|
stop: function() {
|
|
return this.preventDefault().stopPropagation();
|
|
},
|
|
stopPropagation: function() {
|
|
return this.event.stopPropagation ? this.event.stopPropagation() : this.event.cancelBubble = !0, this;
|
|
},
|
|
preventDefault: function() {
|
|
return this.event.preventDefault ? this.event.preventDefault() : this.event.returnValue = !1, this;
|
|
}
|
|
}), DOMEvent1.defineKey = function(code1, key1) {
|
|
return _keys1[code1] = key1, this;
|
|
}, DOMEvent1.defineKeys = DOMEvent1.defineKey.overloadSetter(!0), DOMEvent1.defineKeys({
|
|
38: "up",
|
|
40: "down",
|
|
37: "left",
|
|
39: "right",
|
|
27: "esc",
|
|
32: "space",
|
|
8: "backspace",
|
|
9: "tab",
|
|
46: "delete",
|
|
13: "enter"
|
|
});
|
|
}();
|
|
var Event = DOMEvent;
|
|
Event.Keys = {}, Event.Keys = new Hash(Event.Keys), function() {
|
|
var Class1 = this.Class = new Type("Class", function(params1) {
|
|
instanceOf(params1, Function) && (params1 = {
|
|
initialize: params1
|
|
});
|
|
var newClass1 = (function() {
|
|
if (reset1(this), newClass1.$prototyping) return this;
|
|
this.$caller = null;
|
|
var value1 = this.initialize ? this.initialize.apply(this, arguments) : this;
|
|
return this.$caller = this.caller = null, value1;
|
|
}).extend(this).implement(params1);
|
|
return newClass1.$constructor = Class1, newClass1.prototype.$constructor = newClass1, newClass1.prototype.parent = parent1, newClass1;
|
|
}), parent1 = function() {
|
|
if (!this.$caller) throw Error('The method "parent" cannot be called.');
|
|
var name1 = this.$caller.$name, parent1 = this.$caller.$owner.parent, previous1 = parent1 ? parent1.prototype[name1] : null;
|
|
if (!previous1) throw Error('The method "' + name1 + '" has no parent.');
|
|
return previous1.apply(this, arguments);
|
|
}, reset1 = function(object1) {
|
|
for(var key1 in object1){
|
|
var value1 = object1[key1];
|
|
switch(typeOf(value1)){
|
|
case "object":
|
|
var F1 = function() {};
|
|
F1.prototype = value1, object1[key1] = reset1(new F1());
|
|
break;
|
|
case "array":
|
|
object1[key1] = value1.clone();
|
|
}
|
|
}
|
|
return object1;
|
|
}, wrap1 = function(self1, key1, method1) {
|
|
method1.$origin && (method1 = method1.$origin);
|
|
var wrapper1 = (function() {
|
|
if (method1.$protected && null == this.$caller) throw Error('The method "' + key1 + '" cannot be called.');
|
|
var caller1 = this.caller, current1 = this.$caller;
|
|
this.caller = current1, this.$caller = wrapper1;
|
|
var result1 = method1.apply(this, arguments);
|
|
return this.$caller = current1, this.caller = caller1, result1;
|
|
}).extend({
|
|
$owner: self1,
|
|
$origin: method1,
|
|
$name: key1
|
|
});
|
|
return wrapper1;
|
|
}, implement1 = function(key1, value1, retain1) {
|
|
if (Class1.Mutators.hasOwnProperty(key1) && null == (value1 = Class1.Mutators[key1].call(this, value1))) return this;
|
|
if ("function" == typeOf(value1)) {
|
|
if (value1.$hidden) return this;
|
|
this.prototype[key1] = retain1 ? value1 : wrap1(this, key1, value1);
|
|
} else Object.merge(this.prototype, key1, value1);
|
|
return this;
|
|
}, getInstance1 = function(klass1) {
|
|
klass1.$prototyping = !0;
|
|
var proto1 = new klass1();
|
|
return delete klass1.$prototyping, proto1;
|
|
};
|
|
Class1.implement("implement", implement1.overloadSetter()), Class1.Mutators = {
|
|
Extends: function(parent1) {
|
|
this.parent = parent1, this.prototype = getInstance1(parent1);
|
|
},
|
|
Implements: function(items1) {
|
|
Array.from(items1).each(function(item1) {
|
|
var instance1 = new item1();
|
|
for(var key1 in instance1)implement1.call(this, key1, instance1[key1], !0);
|
|
}, this);
|
|
}
|
|
};
|
|
}(), function() {
|
|
this.Chain = new Class({
|
|
$chain: [],
|
|
chain: function() {
|
|
return this.$chain.append(Array.flatten(arguments)), this;
|
|
},
|
|
callChain: function() {
|
|
return !!this.$chain.length && this.$chain.shift().apply(this, arguments);
|
|
},
|
|
clearChain: function() {
|
|
return this.$chain.empty(), this;
|
|
}
|
|
});
|
|
var removeOn1 = function(string1) {
|
|
return string1.replace(/^on([A-Z])/, function(full1, first1) {
|
|
return first1.toLowerCase();
|
|
});
|
|
};
|
|
this.Events = new Class({
|
|
$events: {},
|
|
addEvent: function(type1, fn1, internal1) {
|
|
return type1 = removeOn1(type1), fn1 == $empty || (this.$events[type1] = (this.$events[type1] || []).include(fn1), internal1 && (fn1.internal = !0)), this;
|
|
},
|
|
addEvents: function(events1) {
|
|
for(var type1 in events1)this.addEvent(type1, events1[type1]);
|
|
return this;
|
|
},
|
|
fireEvent: function(type1, args1, delay1) {
|
|
type1 = removeOn1(type1);
|
|
var events1 = this.$events[type1];
|
|
return events1 && (args1 = Array.from(args1), events1.each(function(fn1) {
|
|
delay1 ? fn1.delay(delay1, this, args1) : fn1.apply(this, args1);
|
|
}, this)), this;
|
|
},
|
|
removeEvent: function(type1, fn1) {
|
|
type1 = removeOn1(type1);
|
|
var events1 = this.$events[type1];
|
|
if (events1 && !fn1.internal) {
|
|
var index1 = events1.indexOf(fn1);
|
|
-1 != index1 && delete events1[index1];
|
|
}
|
|
return this;
|
|
},
|
|
removeEvents: function(events1) {
|
|
var type1;
|
|
if ("object" == typeOf(events1)) {
|
|
for(type1 in events1)this.removeEvent(type1, events1[type1]);
|
|
return this;
|
|
}
|
|
for(type1 in events1 && (events1 = removeOn1(events1)), this.$events)if (!events1 || events1 == type1) for(var fns1 = this.$events[type1], i1 = fns1.length; i1--;)i1 in fns1 && this.removeEvent(type1, fns1[i1]);
|
|
return this;
|
|
}
|
|
}), this.Options = new Class({
|
|
setOptions: function() {
|
|
var options1 = this.options = Object.merge.apply(null, [
|
|
{},
|
|
this.options
|
|
].append(arguments));
|
|
if (this.addEvent) for(var option1 in options1)"function" == typeOf(options1[option1]) && /^on[A-Z]/.test(option1) && (this.addEvent(option1, options1[option1]), delete options1[option1]);
|
|
return this;
|
|
}
|
|
});
|
|
}(), (function() {
|
|
var parsed1, separatorIndex1, combinatorIndex1, reversed1, cache1 = {}, reverseCache1 = {}, reUnescape1 = /\\/g, parse1 = function(expression1, isReversed1) {
|
|
if (null == expression1) return null;
|
|
if (!0 === expression1.Slick) return expression1;
|
|
expression1 = ("" + expression1).replace(/^\s+|\s+$/g, "");
|
|
var currentCache1 = (reversed1 = !!isReversed1) ? reverseCache1 : cache1;
|
|
if (currentCache1[expression1]) return currentCache1[expression1];
|
|
for(parsed1 = {
|
|
Slick: !0,
|
|
expressions: [],
|
|
raw: expression1,
|
|
reverse: function() {
|
|
return parse1(this.raw, !0);
|
|
}
|
|
}, separatorIndex1 = -1; expression1 != (expression1 = expression1.replace(regexp1, parser1)););
|
|
return parsed1.length = parsed1.expressions.length, currentCache1[parsed1.raw] = reversed1 ? reverse1(parsed1) : parsed1;
|
|
}, reverseCombinator1 = function(combinator1) {
|
|
return "!" === combinator1 ? " " : " " === combinator1 ? "!" : /^!/.test(combinator1) ? combinator1.replace(/^!/, "") : "!" + combinator1;
|
|
}, reverse1 = function(expression1) {
|
|
for(var expressions1 = expression1.expressions, i1 = 0; i1 < expressions1.length; i1++){
|
|
for(var exp1 = expressions1[i1], last1 = {
|
|
parts: [],
|
|
tag: "*",
|
|
combinator: reverseCombinator1(exp1[0].combinator)
|
|
}, j1 = 0; j1 < exp1.length; j1++){
|
|
var cexp1 = exp1[j1];
|
|
cexp1.reverseCombinator || (cexp1.reverseCombinator = " "), cexp1.combinator = cexp1.reverseCombinator, delete cexp1.reverseCombinator;
|
|
}
|
|
exp1.reverse().push(last1);
|
|
}
|
|
return expression1;
|
|
}, escapeRegExp1 = function(string1) {
|
|
return string1.replace(/[-[\]{}()*+?.\\^$|,#\s]/g, function(match1) {
|
|
return "\\" + match1;
|
|
});
|
|
}, regexp1 = new RegExp("^(?:\\s*(,)\\s*|\\s*(<combinator>+)\\s*|(\\s+)|(<unicode>+|\\*)|\\#(<unicode>+)|\\.(<unicode>+)|\\[\\s*(<unicode1>+)(?:\\s*([*^$!~|]?=)(?:\\s*(?:([\"']?)(.*?)\\9)))?\\s*\\](?!\\])|(:+)(<unicode>+)(?:\\((?:(?:([\"'])([^\\13]*)\\13)|((?:\\([^)]+\\)|[^()]*)+))\\))?)".replace(/<combinator>/, "[" + escapeRegExp1(">+~`!@$%^&={}\\;</") + "]").replace(/<unicode>/g, "(?:[\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])").replace(/<unicode1>/g, "(?:[:\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])"));
|
|
function parser1(rawMatch1, separator1, combinator1, combinatorChildren1, tagName1, id1, className1, attributeKey1, attributeOperator1, attributeQuote1, attributeValue1, pseudoMarker1, pseudoClass1, pseudoQuote1, pseudoClassQuotedValue1, pseudoClassValue1) {
|
|
if ((separator1 || -1 === separatorIndex1) && (parsed1.expressions[++separatorIndex1] = [], combinatorIndex1 = -1, separator1)) return "";
|
|
if (combinator1 || combinatorChildren1 || -1 === combinatorIndex1) {
|
|
combinator1 = combinator1 || " ";
|
|
var test1, regexp1, currentSeparator1 = parsed1.expressions[separatorIndex1];
|
|
reversed1 && currentSeparator1[combinatorIndex1] && (currentSeparator1[combinatorIndex1].reverseCombinator = reverseCombinator1(combinator1)), currentSeparator1[++combinatorIndex1] = {
|
|
combinator: combinator1,
|
|
tag: "*"
|
|
};
|
|
}
|
|
var currentParsed1 = parsed1.expressions[separatorIndex1][combinatorIndex1];
|
|
if (tagName1) currentParsed1.tag = tagName1.replace(reUnescape1, "");
|
|
else if (id1) currentParsed1.id = id1.replace(reUnescape1, "");
|
|
else if (className1) className1 = className1.replace(reUnescape1, ""), currentParsed1.classList || (currentParsed1.classList = []), currentParsed1.classes || (currentParsed1.classes = []), currentParsed1.classList.push(className1), currentParsed1.classes.push({
|
|
value: className1,
|
|
regexp: RegExp("(^|\\s)" + escapeRegExp1(className1) + "(\\s|$)")
|
|
});
|
|
else if (pseudoClass1) pseudoClassValue1 = (pseudoClassValue1 = pseudoClassValue1 || pseudoClassQuotedValue1) ? pseudoClassValue1.replace(reUnescape1, "") : null, currentParsed1.pseudos || (currentParsed1.pseudos = []), currentParsed1.pseudos.push({
|
|
key: pseudoClass1.replace(reUnescape1, ""),
|
|
value: pseudoClassValue1,
|
|
type: 1 == pseudoMarker1.length ? "class" : "element"
|
|
});
|
|
else if (attributeKey1) {
|
|
switch(attributeKey1 = attributeKey1.replace(reUnescape1, ""), attributeValue1 = (attributeValue1 || "").replace(reUnescape1, ""), attributeOperator1){
|
|
case "^=":
|
|
regexp1 = RegExp("^" + escapeRegExp1(attributeValue1));
|
|
break;
|
|
case "$=":
|
|
regexp1 = RegExp(escapeRegExp1(attributeValue1) + "$");
|
|
break;
|
|
case "~=":
|
|
regexp1 = RegExp("(^|\\s)" + escapeRegExp1(attributeValue1) + "(\\s|$)");
|
|
break;
|
|
case "|=":
|
|
regexp1 = RegExp("^" + escapeRegExp1(attributeValue1) + "(-|$)");
|
|
break;
|
|
case "=":
|
|
test1 = function(value1) {
|
|
return attributeValue1 == value1;
|
|
};
|
|
break;
|
|
case "*=":
|
|
test1 = function(value1) {
|
|
return value1 && value1.indexOf(attributeValue1) > -1;
|
|
};
|
|
break;
|
|
case "!=":
|
|
test1 = function(value1) {
|
|
return attributeValue1 != value1;
|
|
};
|
|
break;
|
|
default:
|
|
test1 = function(value1) {
|
|
return !!value1;
|
|
};
|
|
}
|
|
"" == attributeValue1 && /^[*$^]=$/.test(attributeOperator1) && (test1 = function() {
|
|
return !1;
|
|
}), test1 || (test1 = function(value1) {
|
|
return value1 && regexp1.test(value1);
|
|
}), currentParsed1.attributes || (currentParsed1.attributes = []), currentParsed1.attributes.push({
|
|
key: attributeKey1,
|
|
operator: attributeOperator1,
|
|
value: attributeValue1,
|
|
test: test1
|
|
});
|
|
}
|
|
return "";
|
|
}
|
|
var Slick1 = this.Slick || {};
|
|
Slick1.parse = function(expression1) {
|
|
return parse1(expression1);
|
|
}, Slick1.escapeRegExp = escapeRegExp1, this.Slick || (this.Slick = Slick1);
|
|
}).apply("undefined" != typeof exports ? exports : this), (function() {
|
|
var local1 = {}, featuresCache1 = {}, toString1 = Object.prototype.toString;
|
|
local1.isNativeCode = function(fn1) {
|
|
return /\{\s*\[native code\]\s*\}/.test("" + fn1);
|
|
}, local1.isXML = function(document1) {
|
|
return !!document1.xmlVersion || !!document1.xml || "[object XMLDocument]" == toString1.call(document1) || 9 == document1.nodeType && "HTML" != document1.documentElement.nodeName;
|
|
}, local1.setDocument = function(document1) {
|
|
var nodeType1 = document1.nodeType;
|
|
if (9 == nodeType1) ;
|
|
else if (nodeType1) document1 = document1.ownerDocument;
|
|
else {
|
|
if (!document1.navigator) return;
|
|
document1 = document1.document;
|
|
}
|
|
if (this.document !== document1) {
|
|
this.document = document1;
|
|
var feature1, root1 = document1.documentElement, rootUid1 = this.getUIDXML(root1), features1 = featuresCache1[rootUid1];
|
|
if (features1) {
|
|
for(feature1 in features1)this[feature1] = features1[feature1];
|
|
return;
|
|
}
|
|
features1 = featuresCache1[rootUid1] = {}, features1.root = root1, features1.isXMLDocument = this.isXML(document1), features1.brokenStarGEBTN = features1.starSelectsClosedQSA = features1.idGetsName = features1.brokenMixedCaseQSA = features1.brokenGEBCN = features1.brokenCheckedQSA = features1.brokenEmptyAttributeQSA = features1.isHTMLDocument = features1.nativeMatchesSelector = !1;
|
|
var starSelectsClosed1, starSelectsComments1, brokenSecondClassNameGEBCN1, cachedGetElementsByClassName1, brokenFormAttributeGetter1, selected1, id1 = "slick_uniqueid", testNode1 = document1.createElement("div"), testRoot1 = document1.body || document1.getElementsByTagName("body")[0] || root1;
|
|
testRoot1.appendChild(testNode1);
|
|
try {
|
|
testNode1.innerHTML = '<a id="' + id1 + '"></a>', features1.isHTMLDocument = !!document1.getElementById(id1);
|
|
} catch (e1) {}
|
|
if (features1.isHTMLDocument) {
|
|
testNode1.style.display = "none", testNode1.appendChild(document1.createComment("")), starSelectsComments1 = testNode1.getElementsByTagName("*").length > 1;
|
|
try {
|
|
testNode1.innerHTML = "foo</foo>", starSelectsClosed1 = (selected1 = testNode1.getElementsByTagName("*")) && !!selected1.length && "/" == selected1[0].nodeName.charAt(0);
|
|
} catch (e1) {}
|
|
features1.brokenStarGEBTN = starSelectsComments1 || starSelectsClosed1;
|
|
try {
|
|
testNode1.innerHTML = '<a name="' + id1 + '"></a><b id="' + id1 + '"></b>', features1.idGetsName = document1.getElementById(id1) === testNode1.firstChild;
|
|
} catch (e1) {}
|
|
if (testNode1.getElementsByClassName) {
|
|
try {
|
|
testNode1.innerHTML = '<a class="f"></a><a class="b"></a>', testNode1.getElementsByClassName("b").length, testNode1.firstChild.className = "b", cachedGetElementsByClassName1 = 2 != testNode1.getElementsByClassName("b").length;
|
|
} catch (e1) {}
|
|
try {
|
|
testNode1.innerHTML = '<a class="a"></a><a class="f b a"></a>', brokenSecondClassNameGEBCN1 = 2 != testNode1.getElementsByClassName("a").length;
|
|
} catch (e1) {}
|
|
features1.brokenGEBCN = cachedGetElementsByClassName1 || brokenSecondClassNameGEBCN1;
|
|
}
|
|
if (testNode1.querySelectorAll) {
|
|
try {
|
|
testNode1.innerHTML = "foo</foo>", selected1 = testNode1.querySelectorAll("*"), features1.starSelectsClosedQSA = selected1 && !!selected1.length && "/" == selected1[0].nodeName.charAt(0);
|
|
} catch (e1) {}
|
|
try {
|
|
testNode1.innerHTML = '<a class="MiX"></a>', features1.brokenMixedCaseQSA = !testNode1.querySelectorAll(".MiX").length;
|
|
} catch (e1) {}
|
|
try {
|
|
testNode1.innerHTML = '<select><option selected="selected">a</option></select>', features1.brokenCheckedQSA = 0 == testNode1.querySelectorAll(":checked").length;
|
|
} catch (e1) {}
|
|
try {
|
|
testNode1.innerHTML = '<a class=""></a>', features1.brokenEmptyAttributeQSA = 0 != testNode1.querySelectorAll('[class*=""]').length;
|
|
} catch (e1) {}
|
|
}
|
|
try {
|
|
testNode1.innerHTML = '<form action="s"><input id="action"/></form>', brokenFormAttributeGetter1 = "s" != testNode1.firstChild.getAttribute("action");
|
|
} catch (e1) {}
|
|
if (features1.nativeMatchesSelector = root1.matchesSelector || root1.mozMatchesSelector || root1.webkitMatchesSelector, features1.nativeMatchesSelector) try {
|
|
features1.nativeMatchesSelector.call(root1, ":slick"), features1.nativeMatchesSelector = null;
|
|
} catch (e1) {}
|
|
}
|
|
try {
|
|
root1.slick_expando = 1, delete root1.slick_expando, features1.getUID = this.getUIDHTML;
|
|
} catch (e1) {
|
|
features1.getUID = this.getUIDXML;
|
|
}
|
|
testRoot1.removeChild(testNode1), testNode1 = selected1 = testRoot1 = null, features1.getAttribute = features1.isHTMLDocument && brokenFormAttributeGetter1 ? function(node1, name1) {
|
|
var method1 = this.attributeGetters[name1];
|
|
if (method1) return method1.call(node1);
|
|
var attributeNode1 = node1.getAttributeNode(name1);
|
|
return attributeNode1 ? attributeNode1.nodeValue : null;
|
|
} : function(node1, name1) {
|
|
var method1 = this.attributeGetters[name1];
|
|
return method1 ? method1.call(node1) : node1.getAttribute(name1);
|
|
}, features1.hasAttribute = root1 && this.isNativeCode(root1.hasAttribute) ? function(node1, attribute1) {
|
|
return node1.hasAttribute(attribute1);
|
|
} : function(node1, attribute1) {
|
|
return !!((node1 = node1.getAttributeNode(attribute1)) && (node1.specified || node1.nodeValue));
|
|
};
|
|
var nativeRootContains1 = root1 && this.isNativeCode(root1.contains), nativeDocumentContains1 = document1 && this.isNativeCode(document1.contains);
|
|
for(feature1 in features1.contains = nativeRootContains1 && nativeDocumentContains1 ? function(context1, node1) {
|
|
return context1.contains(node1);
|
|
} : nativeRootContains1 && !nativeDocumentContains1 ? function(context1, node1) {
|
|
return context1 === node1 || (context1 === document1 ? document1.documentElement : context1).contains(node1);
|
|
} : root1 && root1.compareDocumentPosition ? function(context1, node1) {
|
|
return context1 === node1 || !!(16 & context1.compareDocumentPosition(node1));
|
|
} : function(context1, node1) {
|
|
if (node1) do if (node1 === context1) return !0;
|
|
while (node1 = node1.parentNode)
|
|
return !1;
|
|
}, features1.documentSorter = root1.compareDocumentPosition ? function(a1, b1) {
|
|
return a1.compareDocumentPosition && b1.compareDocumentPosition ? 4 & a1.compareDocumentPosition(b1) ? -1 : a1 === b1 ? 0 : 1 : 0;
|
|
} : "sourceIndex" in root1 ? function(a1, b1) {
|
|
return a1.sourceIndex && b1.sourceIndex ? a1.sourceIndex - b1.sourceIndex : 0;
|
|
} : document1.createRange ? function(a1, b1) {
|
|
if (!a1.ownerDocument || !b1.ownerDocument) return 0;
|
|
var aRange1 = a1.ownerDocument.createRange(), bRange1 = b1.ownerDocument.createRange();
|
|
return aRange1.setStart(a1, 0), aRange1.setEnd(a1, 0), bRange1.setStart(b1, 0), bRange1.setEnd(b1, 0), aRange1.compareBoundaryPoints(Range.START_TO_END, bRange1);
|
|
} : null, root1 = null, features1)this[feature1] = features1[feature1];
|
|
}
|
|
};
|
|
var reSimpleSelector1 = /^([#.]?)((?:[\w-]+|\*))$/, reEmptyAttribute1 = /\[.+[*$^]=(?:""|'')?\]/, qsaFailExpCache1 = {};
|
|
local1.search = function(context1, expression1, append1, first1) {
|
|
var found1 = this.found = first1 ? null : append1 || [];
|
|
if (!context1) return found1;
|
|
if (context1.navigator) context1 = context1.document;
|
|
else if (!context1.nodeType) return found1;
|
|
var parsed1, i1, uniques1 = this.uniques = {}, hasOthers1 = !!(append1 && append1.length), contextIsDocument1 = 9 == context1.nodeType;
|
|
if (this.document !== (contextIsDocument1 ? context1 : context1.ownerDocument) && this.setDocument(context1), hasOthers1) for(i1 = found1.length; i1--;)uniques1[this.getUID(found1[i1])] = !0;
|
|
if ("string" == typeof expression1) {
|
|
var simpleSelector1 = expression1.match(reSimpleSelector1);
|
|
simpleSelectors: if (simpleSelector1) {
|
|
var node1, nodes1, symbol1 = simpleSelector1[1], name1 = simpleSelector1[2];
|
|
if (symbol1) {
|
|
if ("#" == symbol1) {
|
|
if (!this.isHTMLDocument || !contextIsDocument1) break simpleSelectors;
|
|
if (!(node1 = context1.getElementById(name1))) return found1;
|
|
if (this.idGetsName && node1.getAttributeNode("id").nodeValue != name1) break simpleSelectors;
|
|
if (first1) return node1 || null;
|
|
hasOthers1 && uniques1[this.getUID(node1)] || found1.push(node1);
|
|
} else if ("." == symbol1) {
|
|
if (!this.isHTMLDocument || (!context1.getElementsByClassName || this.brokenGEBCN) && context1.querySelectorAll) break simpleSelectors;
|
|
if (context1.getElementsByClassName && !this.brokenGEBCN) {
|
|
if (nodes1 = context1.getElementsByClassName(name1), first1) return nodes1[0] || null;
|
|
for(i1 = 0; node1 = nodes1[i1++];)hasOthers1 && uniques1[this.getUID(node1)] || found1.push(node1);
|
|
} else {
|
|
var matchClass1 = RegExp("(^|\\s)" + Slick1.escapeRegExp(name1) + "(\\s|$)");
|
|
for(i1 = 0, nodes1 = context1.getElementsByTagName("*"); node1 = nodes1[i1++];)if ((className = node1.className) && matchClass1.test(className)) {
|
|
if (first1) return node1;
|
|
hasOthers1 && uniques1[this.getUID(node1)] || found1.push(node1);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if ("*" == name1 && this.brokenStarGEBTN) break simpleSelectors;
|
|
if (nodes1 = context1.getElementsByTagName(name1), first1) return nodes1[0] || null;
|
|
for(i1 = 0; node1 = nodes1[i1++];)hasOthers1 && uniques1[this.getUID(node1)] || found1.push(node1);
|
|
}
|
|
return hasOthers1 && this.sort(found1), first1 ? null : found1;
|
|
}
|
|
querySelector: if (context1.querySelectorAll) {
|
|
if (!this.isHTMLDocument || qsaFailExpCache1[expression1] || this.brokenMixedCaseQSA || this.brokenCheckedQSA && expression1.indexOf(":checked") > -1 || this.brokenEmptyAttributeQSA && reEmptyAttribute1.test(expression1) || !contextIsDocument1 && expression1.indexOf(",") > -1 || Slick1.disableQSA) break querySelector;
|
|
var _expression1 = expression1, _context1 = context1;
|
|
if (!contextIsDocument1) {
|
|
var currentId1 = _context1.getAttribute("id"), slickid1 = "slickid__";
|
|
_context1.setAttribute("id", slickid1), _expression1 = "#" + slickid1 + " " + _expression1, context1 = _context1.parentNode;
|
|
}
|
|
try {
|
|
if (first1) return context1.querySelector(_expression1) || null;
|
|
nodes1 = context1.querySelectorAll(_expression1);
|
|
} catch (e1) {
|
|
qsaFailExpCache1[expression1] = 1;
|
|
break querySelector;
|
|
} finally{
|
|
contextIsDocument1 || (currentId1 ? _context1.setAttribute("id", currentId1) : _context1.removeAttribute("id"), context1 = _context1);
|
|
}
|
|
if (this.starSelectsClosedQSA) for(i1 = 0; node1 = nodes1[i1++];)node1.nodeName > "@" && !(hasOthers1 && uniques1[this.getUID(node1)]) && found1.push(node1);
|
|
else for(i1 = 0; node1 = nodes1[i1++];)hasOthers1 && uniques1[this.getUID(node1)] || found1.push(node1);
|
|
return hasOthers1 && this.sort(found1), found1;
|
|
}
|
|
if (!(parsed1 = this.Slick.parse(expression1)).length) return found1;
|
|
} else if (null == expression1) return found1;
|
|
else if (expression1.Slick) parsed1 = expression1;
|
|
else if (this.contains(context1.documentElement || context1, expression1)) return found1 ? found1.push(expression1) : found1 = expression1, found1;
|
|
else return found1;
|
|
this.posNTH = {}, this.posNTHLast = {}, this.posNTHType = {}, this.posNTHTypeLast = {}, this.push = !hasOthers1 && (first1 || 1 == parsed1.length && 1 == parsed1.expressions[0].length) ? this.pushArray : this.pushUID, null == found1 && (found1 = []);
|
|
var j1, m1, n1, combinator1, tag1, id1, classList1, classes1, attributes1, pseudos1, currentItems1, currentExpression1, currentBit1, lastBit1, expressions1 = parsed1.expressions;
|
|
search: for(i1 = 0; currentExpression1 = expressions1[i1]; i1++)for(j1 = 0; currentBit1 = currentExpression1[j1]; j1++){
|
|
if (!this[combinator1 = "combinator:" + currentBit1.combinator]) continue search;
|
|
if (tag1 = this.isXMLDocument ? currentBit1.tag : currentBit1.tag.toUpperCase(), id1 = currentBit1.id, classList1 = currentBit1.classList, classes1 = currentBit1.classes, attributes1 = currentBit1.attributes, pseudos1 = currentBit1.pseudos, lastBit1 = j1 === currentExpression1.length - 1, this.bitUniques = {}, lastBit1 ? (this.uniques = uniques1, this.found = found1) : (this.uniques = {}, this.found = []), 0 === j1) {
|
|
if (this[combinator1](context1, tag1, id1, classes1, attributes1, pseudos1, classList1), first1 && lastBit1 && found1.length) break search;
|
|
} else if (first1 && lastBit1) {
|
|
for(m1 = 0, n1 = currentItems1.length; m1 < n1; m1++)if (this[combinator1](currentItems1[m1], tag1, id1, classes1, attributes1, pseudos1, classList1), found1.length) break search;
|
|
} else for(m1 = 0, n1 = currentItems1.length; m1 < n1; m1++)this[combinator1](currentItems1[m1], tag1, id1, classes1, attributes1, pseudos1, classList1);
|
|
currentItems1 = this.found;
|
|
}
|
|
return (hasOthers1 || parsed1.expressions.length > 1) && this.sort(found1), first1 ? found1[0] || null : found1;
|
|
}, local1.uidx = 1, local1.uidk = "slick-uniqueid", local1.getUIDXML = function(node1) {
|
|
var uid1 = node1.getAttribute(this.uidk);
|
|
return uid1 || (uid1 = this.uidx++, node1.setAttribute(this.uidk, uid1)), uid1;
|
|
}, local1.getUIDHTML = function(node1) {
|
|
return node1.uniqueNumber || (node1.uniqueNumber = this.uidx++);
|
|
}, local1.sort = function(results1) {
|
|
return this.documentSorter && results1.sort(this.documentSorter), results1;
|
|
}, local1.cacheNTH = {}, local1.matchNTH = /^([+-]?\d*)?([a-z]+)?([+-]\d+)?$/, local1.parseNTHArgument = function(argument1) {
|
|
var parsed1 = argument1.match(this.matchNTH);
|
|
if (!parsed1) return !1;
|
|
var special1 = parsed1[2] || !1, a1 = parsed1[1] || 1;
|
|
"-" == a1 && (a1 = -1);
|
|
var b1 = +parsed1[3] || 0;
|
|
return parsed1 = "n" == special1 ? {
|
|
a: a1,
|
|
b: b1
|
|
} : "odd" == special1 ? {
|
|
a: 2,
|
|
b: 1
|
|
} : "even" == special1 ? {
|
|
a: 2,
|
|
b: 0
|
|
} : {
|
|
a: 0,
|
|
b: a1
|
|
}, this.cacheNTH[argument1] = parsed1;
|
|
}, local1.createNTHPseudo = function(child1, sibling1, positions1, ofType1) {
|
|
return function(node1, argument1) {
|
|
var uid1 = this.getUID(node1);
|
|
if (!this[positions1][uid1]) {
|
|
var parent1 = node1.parentNode;
|
|
if (!parent1) return !1;
|
|
var el1 = parent1[child1], count1 = 1;
|
|
if (ofType1) {
|
|
var nodeName1 = node1.nodeName;
|
|
do {
|
|
if (el1.nodeName != nodeName1) continue;
|
|
this[positions1][this.getUID(el1)] = count1++;
|
|
}while (el1 = el1[sibling1])
|
|
} else do {
|
|
if (1 != el1.nodeType) continue;
|
|
this[positions1][this.getUID(el1)] = count1++;
|
|
}while (el1 = el1[sibling1])
|
|
}
|
|
argument1 = argument1 || "n";
|
|
var parsed1 = this.cacheNTH[argument1] || this.parseNTHArgument(argument1);
|
|
if (!parsed1) return !1;
|
|
var a1 = parsed1.a, b1 = parsed1.b, pos1 = this[positions1][uid1];
|
|
if (0 == a1) return b1 == pos1;
|
|
if (a1 > 0) {
|
|
if (pos1 < b1) return !1;
|
|
} else if (b1 < pos1) return !1;
|
|
return (pos1 - b1) % a1 == 0;
|
|
};
|
|
}, local1.pushArray = function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
this.matchSelector(node1, tag1, id1, classes1, attributes1, pseudos1) && this.found.push(node1);
|
|
}, local1.pushUID = function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
var uid1 = this.getUID(node1);
|
|
!this.uniques[uid1] && this.matchSelector(node1, tag1, id1, classes1, attributes1, pseudos1) && (this.uniques[uid1] = !0, this.found.push(node1));
|
|
}, local1.matchNode = function(node1, selector1) {
|
|
if (this.isHTMLDocument && this.nativeMatchesSelector) try {
|
|
return this.nativeMatchesSelector.call(node1, selector1.replace(/\[([^=]+)=\s*([^'"\]]+?)\s*\]/g, '[$1="$2"]'));
|
|
} catch (matchError1) {}
|
|
var parsed1 = this.Slick.parse(selector1);
|
|
if (!parsed1) return !0;
|
|
var i1, expressions1 = parsed1.expressions, simpleExpCounter1 = 0;
|
|
for(i1 = 0; currentExpression = expressions1[i1]; i1++)if (1 == currentExpression.length) {
|
|
var exp1 = currentExpression[0];
|
|
if (this.matchSelector(node1, this.isXMLDocument ? exp1.tag : exp1.tag.toUpperCase(), exp1.id, exp1.classes, exp1.attributes, exp1.pseudos)) return !0;
|
|
simpleExpCounter1++;
|
|
}
|
|
if (simpleExpCounter1 == parsed1.length) return !1;
|
|
var item1, nodes1 = this.search(this.document, parsed1);
|
|
for(i1 = 0; item1 = nodes1[i1++];)if (item1 === node1) return !0;
|
|
return !1;
|
|
}, local1.matchPseudo = function(node1, name1, argument1) {
|
|
var pseudoName1 = "pseudo:" + name1;
|
|
if (this[pseudoName1]) return this[pseudoName1](node1, argument1);
|
|
var attribute1 = this.getAttribute(node1, name1);
|
|
return argument1 ? argument1 == attribute1 : !!attribute1;
|
|
}, local1.matchSelector = function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
if (tag1) {
|
|
var i1, part1, cls1, nodeName1 = this.isXMLDocument ? node1.nodeName : node1.nodeName.toUpperCase();
|
|
if ("*" == tag1) {
|
|
if (nodeName1 < "@") return !1;
|
|
} else if (nodeName1 != tag1) return !1;
|
|
}
|
|
if (id1 && node1.getAttribute("id") != id1) return !1;
|
|
if (classes1) {
|
|
for(i1 = classes1.length; i1--;)if (!((cls1 = this.getAttribute(node1, "class")) && classes1[i1].regexp.test(cls1))) return !1;
|
|
}
|
|
if (attributes1) {
|
|
for(i1 = attributes1.length; i1--;)if ((part1 = attributes1[i1]).operator ? !part1.test(this.getAttribute(node1, part1.key)) : !this.hasAttribute(node1, part1.key)) return !1;
|
|
}
|
|
if (pseudos1) {
|
|
for(i1 = pseudos1.length; i1--;)if (part1 = pseudos1[i1], !this.matchPseudo(node1, part1.key, part1.value)) return !1;
|
|
}
|
|
return !0;
|
|
};
|
|
var combinators1 = {
|
|
" ": function(node1, tag1, id1, classes1, attributes1, pseudos1, classList1) {
|
|
var i1, item1, children1;
|
|
if (this.isHTMLDocument) {
|
|
getById: if (id1) {
|
|
if (!(item1 = this.document.getElementById(id1)) && node1.all || this.idGetsName && item1 && item1.getAttributeNode("id").nodeValue != id1) {
|
|
if (!(children1 = node1.all[id1])) return;
|
|
for(children1[0] || (children1 = [
|
|
children1
|
|
]), i1 = 0; item1 = children1[i1++];){
|
|
var idNode1 = item1.getAttributeNode("id");
|
|
if (idNode1 && idNode1.nodeValue == id1) {
|
|
this.push(item1, tag1, null, classes1, attributes1, pseudos1);
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if (item1) {
|
|
if (this.document !== node1 && !this.contains(node1, item1)) return;
|
|
} else {
|
|
if (this.contains(this.root, node1)) return;
|
|
break getById;
|
|
}
|
|
this.push(item1, tag1, null, classes1, attributes1, pseudos1);
|
|
return;
|
|
}
|
|
getByClass: if (classes1 && node1.getElementsByClassName && !this.brokenGEBCN) {
|
|
if (!((children1 = node1.getElementsByClassName(classList1.join(" "))) && children1.length)) break getByClass;
|
|
for(i1 = 0; item1 = children1[i1++];)this.push(item1, tag1, id1, null, attributes1, pseudos1);
|
|
return;
|
|
}
|
|
}
|
|
getByTag: if ((children1 = node1.getElementsByTagName(tag1)) && children1.length) for(this.brokenStarGEBTN || (tag1 = null), i1 = 0; item1 = children1[i1++];)this.push(item1, tag1, id1, classes1, attributes1, pseudos1);
|
|
},
|
|
">": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
if (node1 = node1.firstChild) do 1 == node1.nodeType && this.push(node1, tag1, id1, classes1, attributes1, pseudos1);
|
|
while (node1 = node1.nextSibling)
|
|
},
|
|
"+": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
for(; node1 = node1.nextSibling;)if (1 == node1.nodeType) {
|
|
this.push(node1, tag1, id1, classes1, attributes1, pseudos1);
|
|
break;
|
|
}
|
|
},
|
|
"^": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
(node1 = node1.firstChild) && (1 == node1.nodeType ? this.push(node1, tag1, id1, classes1, attributes1, pseudos1) : this["combinator:+"](node1, tag1, id1, classes1, attributes1, pseudos1));
|
|
},
|
|
"~": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
for(; node1 = node1.nextSibling;)if (1 == node1.nodeType) {
|
|
var uid1 = this.getUID(node1);
|
|
if (this.bitUniques[uid1]) break;
|
|
this.bitUniques[uid1] = !0, this.push(node1, tag1, id1, classes1, attributes1, pseudos1);
|
|
}
|
|
},
|
|
"++": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
this["combinator:+"](node1, tag1, id1, classes1, attributes1, pseudos1), this["combinator:!+"](node1, tag1, id1, classes1, attributes1, pseudos1);
|
|
},
|
|
"~~": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
this["combinator:~"](node1, tag1, id1, classes1, attributes1, pseudos1), this["combinator:!~"](node1, tag1, id1, classes1, attributes1, pseudos1);
|
|
},
|
|
"!": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
for(; node1 = node1.parentNode;)node1 !== this.document && this.push(node1, tag1, id1, classes1, attributes1, pseudos1);
|
|
},
|
|
"!>": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
(node1 = node1.parentNode) !== this.document && this.push(node1, tag1, id1, classes1, attributes1, pseudos1);
|
|
},
|
|
"!+": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
for(; node1 = node1.previousSibling;)if (1 == node1.nodeType) {
|
|
this.push(node1, tag1, id1, classes1, attributes1, pseudos1);
|
|
break;
|
|
}
|
|
},
|
|
"!^": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
(node1 = node1.lastChild) && (1 == node1.nodeType ? this.push(node1, tag1, id1, classes1, attributes1, pseudos1) : this["combinator:!+"](node1, tag1, id1, classes1, attributes1, pseudos1));
|
|
},
|
|
"!~": function(node1, tag1, id1, classes1, attributes1, pseudos1) {
|
|
for(; node1 = node1.previousSibling;)if (1 == node1.nodeType) {
|
|
var uid1 = this.getUID(node1);
|
|
if (this.bitUniques[uid1]) break;
|
|
this.bitUniques[uid1] = !0, this.push(node1, tag1, id1, classes1, attributes1, pseudos1);
|
|
}
|
|
}
|
|
};
|
|
for(var c1 in combinators1)local1["combinator:" + c1] = combinators1[c1];
|
|
var pseudos1 = {
|
|
empty: function(node1) {
|
|
var child1 = node1.firstChild;
|
|
return !(child1 && 1 == child1.nodeType) && !(node1.innerText || node1.textContent || "").length;
|
|
},
|
|
not: function(node1, expression1) {
|
|
return !this.matchNode(node1, expression1);
|
|
},
|
|
contains: function(node1, text1) {
|
|
return (node1.innerText || node1.textContent || "").indexOf(text1) > -1;
|
|
},
|
|
"first-child": function(node1) {
|
|
for(; node1 = node1.previousSibling;)if (1 == node1.nodeType) return !1;
|
|
return !0;
|
|
},
|
|
"last-child": function(node1) {
|
|
for(; node1 = node1.nextSibling;)if (1 == node1.nodeType) return !1;
|
|
return !0;
|
|
},
|
|
"only-child": function(node1) {
|
|
for(var prev1 = node1; prev1 = prev1.previousSibling;)if (1 == prev1.nodeType) return !1;
|
|
for(var next1 = node1; next1 = next1.nextSibling;)if (1 == next1.nodeType) return !1;
|
|
return !0;
|
|
},
|
|
"nth-child": local1.createNTHPseudo("firstChild", "nextSibling", "posNTH"),
|
|
"nth-last-child": local1.createNTHPseudo("lastChild", "previousSibling", "posNTHLast"),
|
|
"nth-of-type": local1.createNTHPseudo("firstChild", "nextSibling", "posNTHType", !0),
|
|
"nth-last-of-type": local1.createNTHPseudo("lastChild", "previousSibling", "posNTHTypeLast", !0),
|
|
index: function(node1, index1) {
|
|
return this["pseudo:nth-child"](node1, "" + (index1 + 1));
|
|
},
|
|
even: function(node1) {
|
|
return this["pseudo:nth-child"](node1, "2n");
|
|
},
|
|
odd: function(node1) {
|
|
return this["pseudo:nth-child"](node1, "2n+1");
|
|
},
|
|
"first-of-type": function(node1) {
|
|
for(var nodeName1 = node1.nodeName; node1 = node1.previousSibling;)if (node1.nodeName == nodeName1) return !1;
|
|
return !0;
|
|
},
|
|
"last-of-type": function(node1) {
|
|
for(var nodeName1 = node1.nodeName; node1 = node1.nextSibling;)if (node1.nodeName == nodeName1) return !1;
|
|
return !0;
|
|
},
|
|
"only-of-type": function(node1) {
|
|
for(var prev1 = node1, nodeName1 = node1.nodeName; prev1 = prev1.previousSibling;)if (prev1.nodeName == nodeName1) return !1;
|
|
for(var next1 = node1; next1 = next1.nextSibling;)if (next1.nodeName == nodeName1) return !1;
|
|
return !0;
|
|
},
|
|
enabled: function(node1) {
|
|
return !node1.disabled;
|
|
},
|
|
disabled: function(node1) {
|
|
return node1.disabled;
|
|
},
|
|
checked: function(node1) {
|
|
return node1.checked || node1.selected;
|
|
},
|
|
focus: function(node1) {
|
|
return this.isHTMLDocument && this.document.activeElement === node1 && (node1.href || node1.type || this.hasAttribute(node1, "tabindex"));
|
|
},
|
|
root: function(node1) {
|
|
return node1 === this.root;
|
|
},
|
|
selected: function(node1) {
|
|
return node1.selected;
|
|
}
|
|
};
|
|
for(var p1 in pseudos1)local1["pseudo:" + p1] = pseudos1[p1];
|
|
var attributeGetters1 = local1.attributeGetters = {
|
|
for: function() {
|
|
return "htmlFor" in this ? this.htmlFor : this.getAttribute("for");
|
|
},
|
|
href: function() {
|
|
return "href" in this ? this.getAttribute("href", 2) : this.getAttribute("href");
|
|
},
|
|
style: function() {
|
|
return this.style ? this.style.cssText : this.getAttribute("style");
|
|
},
|
|
tabindex: function() {
|
|
var attributeNode1 = this.getAttributeNode("tabindex");
|
|
return attributeNode1 && attributeNode1.specified ? attributeNode1.nodeValue : null;
|
|
},
|
|
type: function() {
|
|
return this.getAttribute("type");
|
|
},
|
|
maxlength: function() {
|
|
var attributeNode1 = this.getAttributeNode("maxLength");
|
|
return attributeNode1 && attributeNode1.specified ? attributeNode1.nodeValue : null;
|
|
}
|
|
};
|
|
attributeGetters1.MAXLENGTH = attributeGetters1.maxLength = attributeGetters1.maxlength;
|
|
var Slick1 = local1.Slick = this.Slick || {};
|
|
Slick1.version = "1.1.7", Slick1.search = function(context1, expression1, append1) {
|
|
return local1.search(context1, expression1, append1);
|
|
}, Slick1.find = function(context1, expression1) {
|
|
return local1.search(context1, expression1, null, !0);
|
|
}, Slick1.contains = function(container1, node1) {
|
|
return local1.setDocument(container1), local1.contains(container1, node1);
|
|
}, Slick1.getAttribute = function(node1, name1) {
|
|
return local1.setDocument(node1), local1.getAttribute(node1, name1);
|
|
}, Slick1.hasAttribute = function(node1, name1) {
|
|
return local1.setDocument(node1), local1.hasAttribute(node1, name1);
|
|
}, Slick1.match = function(node1, selector1) {
|
|
return !!node1 && !!selector1 && (!selector1 || selector1 === node1 || (local1.setDocument(node1), local1.matchNode(node1, selector1)));
|
|
}, Slick1.defineAttributeGetter = function(name1, fn1) {
|
|
return local1.attributeGetters[name1] = fn1, this;
|
|
}, Slick1.lookupAttributeGetter = function(name1) {
|
|
return local1.attributeGetters[name1];
|
|
}, Slick1.definePseudo = function(name1, fn1) {
|
|
return local1["pseudo:" + name1] = function(node1, argument1) {
|
|
return fn1.call(node1, argument1);
|
|
}, this;
|
|
}, Slick1.lookupPseudo = function(name1) {
|
|
var pseudo1 = local1["pseudo:" + name1];
|
|
return pseudo1 ? function(argument1) {
|
|
return pseudo1.call(this, argument1);
|
|
} : null;
|
|
}, Slick1.override = function(regexp1, fn1) {
|
|
return local1.override(regexp1, fn1), this;
|
|
}, Slick1.isXML = local1.isXML, Slick1.uidOf = function(node1) {
|
|
return local1.getUIDHTML(node1);
|
|
}, this.Slick || (this.Slick = Slick1);
|
|
}).apply("undefined" != typeof exports ? exports : this);
|
|
var Element = function(tag1, props1) {
|
|
var konstructor1 = Element.Constructors[tag1];
|
|
if (konstructor1) return konstructor1(props1);
|
|
if ("string" != typeof tag1) return document.id(tag1).set(props1);
|
|
if (props1 || (props1 = {}), !/^[\w-]+$/.test(tag1)) {
|
|
var parsed1 = Slick.parse(tag1).expressions[0][0];
|
|
tag1 = "*" == parsed1.tag ? "div" : parsed1.tag, parsed1.id && null == props1.id && (props1.id = parsed1.id);
|
|
var attributes1 = parsed1.attributes;
|
|
if (attributes1) for(var attr1, i1 = 0, l1 = attributes1.length; i1 < l1; i1++)null != props1[(attr1 = attributes1[i1]).key] || (null != attr1.value && "=" == attr1.operator ? props1[attr1.key] = attr1.value : attr1.value || attr1.operator || (props1[attr1.key] = !0));
|
|
parsed1.classList && null == props1.class && (props1.class = parsed1.classList.join(" "));
|
|
}
|
|
return document.newElement(tag1, props1);
|
|
};
|
|
Browser.Element && (Element.prototype = Browser.Element.prototype, Element.prototype._fireEvent = function(fireEvent1) {
|
|
return function(type1, event1) {
|
|
return fireEvent1.call(this, type1, event1);
|
|
};
|
|
}(Element.prototype.fireEvent)), new Type("Element", Element).mirror(function(name1) {
|
|
if (!Array.prototype[name1]) {
|
|
var obj1 = {};
|
|
obj1[name1] = function() {
|
|
for(var results1 = [], args1 = arguments, elements1 = !0, i1 = 0, l1 = this.length; i1 < l1; i1++){
|
|
var element1 = this[i1], result1 = results1[i1] = element1[name1].apply(element1, args1);
|
|
elements1 = elements1 && "element" == typeOf(result1);
|
|
}
|
|
return elements1 ? new Elements(results1) : results1;
|
|
}, Elements.implement(obj1);
|
|
}
|
|
}), Browser.Element || (Element.parent = Object, Element.Prototype = {
|
|
$constructor: Element,
|
|
$family: Function.from("element").hide()
|
|
}, Element.mirror(function(name1, method1) {
|
|
Element.Prototype[name1] = method1;
|
|
})), Element.Constructors = {}, Element.Constructors = new Hash();
|
|
var IFrame = new Type("IFrame", function() {
|
|
var iframe1, params1 = Array.link(arguments, {
|
|
properties: Type.isObject,
|
|
iframe: function(obj1) {
|
|
return null != obj1;
|
|
}
|
|
}), props1 = params1.properties || {};
|
|
params1.iframe && (iframe1 = document.id(params1.iframe));
|
|
var onload1 = props1.onload || function() {};
|
|
delete props1.onload, props1.id = props1.name = [
|
|
props1.id,
|
|
props1.name,
|
|
iframe1 ? iframe1.id || iframe1.name : "IFrame_" + String.uniqueID()
|
|
].pick(), iframe1 = new Element(iframe1 || "iframe", props1);
|
|
var onLoad1 = function() {
|
|
onload1.call(iframe1.contentWindow);
|
|
};
|
|
return window.frames[props1.id] ? onLoad1() : iframe1.addListener("load", onLoad1), iframe1;
|
|
}), Elements = this.Elements = function(nodes1) {
|
|
if (nodes1 && nodes1.length) for(var node1, uniques1 = {}, i1 = 0; node1 = nodes1[i1++];){
|
|
var uid1 = Slick.uidOf(node1);
|
|
uniques1[uid1] || (uniques1[uid1] = !0, this.push(node1));
|
|
}
|
|
};
|
|
Elements.prototype = {
|
|
length: 0
|
|
}, Elements.parent = Array, new Type("Elements", Elements).implement({
|
|
filter: (function(filter1, bind1) {
|
|
return filter1 ? new Elements(Array.filter(this, "string" == typeOf(filter1) ? function(item1) {
|
|
return item1.match(filter1);
|
|
} : filter1, bind1)) : this;
|
|
}).protect(),
|
|
push: (function() {
|
|
for(var length1 = this.length, i1 = 0, l1 = arguments.length; i1 < l1; i1++){
|
|
var item1 = document.id(arguments[i1]);
|
|
item1 && (this[length1++] = item1);
|
|
}
|
|
return this.length = length1;
|
|
}).protect(),
|
|
unshift: (function() {
|
|
for(var items1 = [], i1 = 0, l1 = arguments.length; i1 < l1; i1++){
|
|
var item1 = document.id(arguments[i1]);
|
|
item1 && items1.push(item1);
|
|
}
|
|
return Array.prototype.unshift.apply(this, items1);
|
|
}).protect(),
|
|
concat: (function() {
|
|
for(var newElements1 = new Elements(this), i1 = 0, l1 = arguments.length; i1 < l1; i1++){
|
|
var item1 = arguments[i1];
|
|
Type.isEnumerable(item1) ? newElements1.append(item1) : newElements1.push(item1);
|
|
}
|
|
return newElements1;
|
|
}).protect(),
|
|
append: (function(collection1) {
|
|
for(var i1 = 0, l1 = collection1.length; i1 < l1; i1++)this.push(collection1[i1]);
|
|
return this;
|
|
}).protect(),
|
|
empty: (function() {
|
|
for(; this.length;)delete this[--this.length];
|
|
return this;
|
|
}).protect()
|
|
}), Elements.alias("extend", "append"), function() {
|
|
var createElementAcceptsHTML1, splice1 = Array.prototype.splice, object1 = {
|
|
0: 0,
|
|
1: 1,
|
|
length: 2
|
|
};
|
|
splice1.call(object1, 1, 1), 1 == object1[1] && Elements.implement("splice", (function() {
|
|
for(var length1 = this.length, result1 = splice1.apply(this, arguments); length1 >= this.length;)delete this[length1--];
|
|
return result1;
|
|
}).protect()), Array.forEachMethod(function(method1, name1) {
|
|
Elements.implement(name1, method1);
|
|
}), Array.mirror(Elements);
|
|
try {
|
|
createElementAcceptsHTML1 = "x" == document.createElement("<input name=x>").name;
|
|
} catch (e1) {}
|
|
var escapeQuotes1 = function(html1) {
|
|
return ("" + html1).replace(/&/g, "&").replace(/"/g, """);
|
|
};
|
|
Document.implement({
|
|
newElement: function(tag1, props1) {
|
|
return props1 && null != props1.checked && (props1.defaultChecked = props1.checked), createElementAcceptsHTML1 && props1 && (tag1 = "<" + tag1, props1.name && (tag1 += ' name="' + escapeQuotes1(props1.name) + '"'), props1.type && (tag1 += ' type="' + escapeQuotes1(props1.type) + '"'), tag1 += ">", delete props1.name, delete props1.type), this.id(this.createElement(tag1)).set(props1);
|
|
}
|
|
});
|
|
}(), function() {
|
|
Slick.uidOf(window), Slick.uidOf(document), Document.implement({
|
|
newTextNode: function(text1) {
|
|
return this.createTextNode(text1);
|
|
},
|
|
getDocument: function() {
|
|
return this;
|
|
},
|
|
getWindow: function() {
|
|
return this.window;
|
|
},
|
|
id: function() {
|
|
var types1 = {
|
|
string: function(id1, nocash1, doc1) {
|
|
return (id1 = Slick.find(doc1, "#" + id1.replace(/(\W)/g, "\\$1"))) ? types1.element(id1, nocash1) : null;
|
|
},
|
|
element: function(el1, nocash1) {
|
|
if (Slick.uidOf(el1), !nocash1 && !el1.$family && !/^(?:object|embed)$/i.test(el1.tagName)) {
|
|
var fireEvent1 = el1.fireEvent;
|
|
el1._fireEvent = function(type1, event1) {
|
|
return fireEvent1(type1, event1);
|
|
}, Object.append(el1, Element.Prototype);
|
|
}
|
|
return el1;
|
|
},
|
|
object: function(obj1, nocash1, doc1) {
|
|
return obj1.toElement ? types1.element(obj1.toElement(doc1), nocash1) : null;
|
|
}
|
|
};
|
|
return types1.textnode = types1.whitespace = types1.window = types1.document = function(zero1) {
|
|
return zero1;
|
|
}, function(el1, nocash1, doc1) {
|
|
if (el1 && el1.$family && el1.uniqueNumber) return el1;
|
|
var type1 = typeOf(el1);
|
|
return types1[type1] ? types1[type1](el1, nocash1, doc1 || document) : null;
|
|
};
|
|
}()
|
|
}), null == window.$ && Window.implement("$", function(el1, nc1) {
|
|
return document.id(el1, nc1, this.document);
|
|
}), Window.implement({
|
|
getDocument: function() {
|
|
return this.document;
|
|
},
|
|
getWindow: function() {
|
|
return this;
|
|
}
|
|
}), [
|
|
Document,
|
|
Element
|
|
].invoke("implement", {
|
|
getElements: function(expression1) {
|
|
return Slick.search(this, expression1, new Elements());
|
|
},
|
|
getElement: function(expression1) {
|
|
return document.id(Slick.find(this, expression1));
|
|
}
|
|
});
|
|
var contains1 = {
|
|
contains: function(element1) {
|
|
return Slick.contains(this, element1);
|
|
}
|
|
};
|
|
document.contains || Document.implement(contains1), document.createElement("div").contains || Element.implement(contains1), Element.implement("hasChild", function(element1) {
|
|
return this !== element1 && this.contains(element1);
|
|
}), function(search1, find1, match1) {
|
|
this.Selectors = {};
|
|
var pseudos1 = this.Selectors.Pseudo = new Hash(), addSlickPseudos1 = function() {
|
|
for(var name1 in pseudos1)pseudos1.hasOwnProperty(name1) && (Slick.definePseudo(name1, pseudos1[name1]), delete pseudos1[name1]);
|
|
};
|
|
Slick.search = function(context1, expression1, append1) {
|
|
return addSlickPseudos1(), search1.call(this, context1, expression1, append1);
|
|
}, Slick.find = function(context1, expression1) {
|
|
return addSlickPseudos1(), find1.call(this, context1, expression1);
|
|
}, Slick.match = function(node1, selector1) {
|
|
return addSlickPseudos1(), match1.call(this, node1, selector1);
|
|
};
|
|
}(Slick.search, Slick.find, Slick.match);
|
|
var injectCombinator1 = function(expression1, combinator1) {
|
|
if (!expression1) return combinator1;
|
|
for(var expressions1 = (expression1 = Object.clone(Slick.parse(expression1))).expressions, i1 = expressions1.length; i1--;)expressions1[i1][0].combinator = combinator1;
|
|
return expression1;
|
|
};
|
|
Object.forEach({
|
|
getNext: "~",
|
|
getPrevious: "!~",
|
|
getParent: "!"
|
|
}, function(combinator1, method1) {
|
|
Element.implement(method1, function(expression1) {
|
|
return this.getElement(injectCombinator1(expression1, combinator1));
|
|
});
|
|
}), Object.forEach({
|
|
getAllNext: "~",
|
|
getAllPrevious: "!~",
|
|
getSiblings: "~~",
|
|
getChildren: ">",
|
|
getParents: "!"
|
|
}, function(combinator1, method1) {
|
|
Element.implement(method1, function(expression1) {
|
|
return this.getElements(injectCombinator1(expression1, combinator1));
|
|
});
|
|
}), Element.implement({
|
|
getFirst: function(expression1) {
|
|
return document.id(Slick.search(this, injectCombinator1(expression1, ">"))[0]);
|
|
},
|
|
getLast: function(expression1) {
|
|
return document.id(Slick.search(this, injectCombinator1(expression1, ">")).getLast());
|
|
},
|
|
getWindow: function() {
|
|
return this.ownerDocument.window;
|
|
},
|
|
getDocument: function() {
|
|
return this.ownerDocument;
|
|
},
|
|
getElementById: function(id1) {
|
|
return document.id(Slick.find(this, "#" + ("" + id1).replace(/(\W)/g, "\\$1")));
|
|
},
|
|
match: function(expression1) {
|
|
return !expression1 || Slick.match(this, expression1);
|
|
}
|
|
}), null == window.$$ && Window.implement("$$", function(selector1) {
|
|
var elements1 = new Elements();
|
|
if (1 == arguments.length && "string" == typeof selector1) return Slick.search(this.document, selector1, elements1);
|
|
for(var args1 = Array.flatten(arguments), i1 = 0, l1 = args1.length; i1 < l1; i1++){
|
|
var item1 = args1[i1];
|
|
switch(typeOf(item1)){
|
|
case "element":
|
|
elements1.push(item1);
|
|
break;
|
|
case "string":
|
|
Slick.search(this.document, item1, elements1);
|
|
}
|
|
}
|
|
return elements1;
|
|
}), null == window.$$ && Window.implement("$$", function(selector1) {
|
|
if (1 == arguments.length) {
|
|
if ("string" == typeof selector1) return Slick.search(this.document, selector1, new Elements());
|
|
if (Type.isEnumerable(selector1)) return new Elements(selector1);
|
|
}
|
|
return new Elements(arguments);
|
|
});
|
|
var inserters1 = {
|
|
before: function(context1, element1) {
|
|
var parent1 = element1.parentNode;
|
|
parent1 && parent1.insertBefore(context1, element1);
|
|
},
|
|
after: function(context1, element1) {
|
|
var parent1 = element1.parentNode;
|
|
parent1 && parent1.insertBefore(context1, element1.nextSibling);
|
|
},
|
|
bottom: function(context1, element1) {
|
|
element1.appendChild(context1);
|
|
},
|
|
top: function(context1, element1) {
|
|
element1.insertBefore(context1, element1.firstChild);
|
|
}
|
|
};
|
|
inserters1.inside = inserters1.bottom, Object.each(inserters1, function(inserter1, where1) {
|
|
where1 = where1.capitalize();
|
|
var methods1 = {};
|
|
methods1["inject" + where1] = function(el1) {
|
|
return inserter1(this, document.id(el1, !0)), this;
|
|
}, methods1["grab" + where1] = function(el1) {
|
|
return inserter1(document.id(el1, !0), this), this;
|
|
}, Element.implement(methods1);
|
|
});
|
|
var propertyGetters1 = {}, propertySetters1 = {}, properties1 = {};
|
|
Array.forEach([
|
|
"type",
|
|
"value",
|
|
"defaultValue",
|
|
"accessKey",
|
|
"cellPadding",
|
|
"cellSpacing",
|
|
"colSpan",
|
|
"frameBorder",
|
|
"rowSpan",
|
|
"tabIndex",
|
|
"useMap"
|
|
], function(property1) {
|
|
properties1[property1.toLowerCase()] = property1;
|
|
}), properties1.html = "innerHTML", properties1.text = null == document.createElement("div").textContent ? "innerText" : "textContent", Object.forEach(properties1, function(real1, key1) {
|
|
propertySetters1[key1] = function(node1, value1) {
|
|
node1[real1] = value1;
|
|
}, propertyGetters1[key1] = function(node1) {
|
|
return node1[real1];
|
|
};
|
|
});
|
|
var booleans1 = {};
|
|
Array.forEach([
|
|
"compact",
|
|
"nowrap",
|
|
"ismap",
|
|
"declare",
|
|
"noshade",
|
|
"checked",
|
|
"disabled",
|
|
"readOnly",
|
|
"multiple",
|
|
"selected",
|
|
"noresize",
|
|
"defer",
|
|
"defaultChecked",
|
|
"autofocus",
|
|
"controls",
|
|
"autoplay",
|
|
"loop"
|
|
], function(bool1) {
|
|
var lower1 = bool1.toLowerCase();
|
|
booleans1[lower1] = bool1, propertySetters1[lower1] = function(node1, value1) {
|
|
node1[bool1] = !!value1;
|
|
}, propertyGetters1[lower1] = function(node1) {
|
|
return !!node1[bool1];
|
|
};
|
|
}), Object.append(propertySetters1, {
|
|
class: function(node1, value1) {
|
|
"className" in node1 ? node1.className = value1 || "" : node1.setAttribute("class", value1);
|
|
},
|
|
for: function(node1, value1) {
|
|
"htmlFor" in node1 ? node1.htmlFor = value1 : node1.setAttribute("for", value1);
|
|
},
|
|
style: function(node1, value1) {
|
|
node1.style ? node1.style.cssText = value1 : node1.setAttribute("style", value1);
|
|
},
|
|
value: function(node1, value1) {
|
|
node1.value = null != value1 ? value1 : "";
|
|
}
|
|
}), propertyGetters1.class = function(node1) {
|
|
return "className" in node1 ? node1.className || null : node1.getAttribute("class");
|
|
};
|
|
var el1 = document.createElement("button");
|
|
try {
|
|
el1.type = "button";
|
|
} catch (e1) {}
|
|
"button" != el1.type && (propertySetters1.type = function(node1, value1) {
|
|
node1.setAttribute("type", value1);
|
|
}), el1 = null;
|
|
var input1 = document.createElement("input");
|
|
input1.value = "t", input1.type = "submit", "t" != input1.value && (propertySetters1.type = function(node1, type1) {
|
|
var value1 = node1.value;
|
|
node1.type = type1, node1.value = value1;
|
|
}), input1 = null;
|
|
var pollutesGetAttribute1 = function(div1) {
|
|
return div1.random = "attribute", "attribute" == div1.getAttribute("random");
|
|
}(document.createElement("div"));
|
|
Element.implement({
|
|
setProperty: function(name1, value1) {
|
|
var setter1 = propertySetters1[name1.toLowerCase()];
|
|
if (setter1) setter1(this, value1);
|
|
else {
|
|
if (pollutesGetAttribute1) var attributeWhiteList1 = this.retrieve("$attributeWhiteList", {});
|
|
null == value1 ? (this.removeAttribute(name1), pollutesGetAttribute1 && delete attributeWhiteList1[name1]) : (this.setAttribute(name1, "" + value1), pollutesGetAttribute1 && (attributeWhiteList1[name1] = !0));
|
|
}
|
|
return this;
|
|
},
|
|
setProperties: function(attributes1) {
|
|
for(var attribute1 in attributes1)this.setProperty(attribute1, attributes1[attribute1]);
|
|
return this;
|
|
},
|
|
getProperty: function(name1) {
|
|
var getter1 = propertyGetters1[name1.toLowerCase()];
|
|
if (getter1) return getter1(this);
|
|
if (pollutesGetAttribute1) {
|
|
var attr1 = this.getAttributeNode(name1), attributeWhiteList1 = this.retrieve("$attributeWhiteList", {});
|
|
if (!attr1) return null;
|
|
if (attr1.expando && !attributeWhiteList1[name1]) {
|
|
var outer1 = this.outerHTML;
|
|
if (0 > outer1.substr(0, outer1.search(/\/?['"]?>(?![^<]*<['"])/)).indexOf(name1)) return null;
|
|
attributeWhiteList1[name1] = !0;
|
|
}
|
|
}
|
|
var result1 = Slick.getAttribute(this, name1);
|
|
return result1 || Slick.hasAttribute(this, name1) ? result1 : null;
|
|
},
|
|
getProperties: function() {
|
|
var args1 = Array.from(arguments);
|
|
return args1.map(this.getProperty, this).associate(args1);
|
|
},
|
|
removeProperty: function(name1) {
|
|
return this.setProperty(name1, null);
|
|
},
|
|
removeProperties: function() {
|
|
return Array.each(arguments, this.removeProperty, this), this;
|
|
},
|
|
set: (function(prop1, value1) {
|
|
var property1 = Element.Properties[prop1];
|
|
property1 && property1.set ? property1.set.call(this, value1) : this.setProperty(prop1, value1);
|
|
}).overloadSetter(),
|
|
get: (function(prop1) {
|
|
var property1 = Element.Properties[prop1];
|
|
return property1 && property1.get ? property1.get.apply(this) : this.getProperty(prop1);
|
|
}).overloadGetter(),
|
|
erase: function(prop1) {
|
|
var property1 = Element.Properties[prop1];
|
|
return property1 && property1.erase ? property1.erase.apply(this) : this.removeProperty(prop1), this;
|
|
},
|
|
hasClass: function(className1) {
|
|
return this.className.clean().contains(className1, " ");
|
|
},
|
|
addClass: function(className1) {
|
|
return this.hasClass(className1) || (this.className = (this.className + " " + className1).clean()), this;
|
|
},
|
|
removeClass: function(className1) {
|
|
return this.className = this.className.replace(RegExp("(^|\\s)" + className1 + "(?:\\s|$)"), "$1"), this;
|
|
},
|
|
toggleClass: function(className1, force1) {
|
|
return null == force1 && (force1 = !this.hasClass(className1)), force1 ? this.addClass(className1) : this.removeClass(className1);
|
|
},
|
|
adopt: function() {
|
|
var fragment1, parent1 = this, elements1 = Array.flatten(arguments), length1 = elements1.length;
|
|
length1 > 1 && (parent1 = fragment1 = document.createDocumentFragment());
|
|
for(var i1 = 0; i1 < length1; i1++){
|
|
var element1 = document.id(elements1[i1], !0);
|
|
element1 && parent1.appendChild(element1);
|
|
}
|
|
return fragment1 && this.appendChild(fragment1), this;
|
|
},
|
|
appendText: function(text1, where1) {
|
|
return this.grab(this.getDocument().newTextNode(text1), where1);
|
|
},
|
|
grab: function(el1, where1) {
|
|
return inserters1[where1 || "bottom"](document.id(el1, !0), this), this;
|
|
},
|
|
inject: function(el1, where1) {
|
|
return inserters1[where1 || "bottom"](this, document.id(el1, !0)), this;
|
|
},
|
|
replaces: function(el1) {
|
|
return (el1 = document.id(el1, !0)).parentNode.replaceChild(this, el1), this;
|
|
},
|
|
wraps: function(el1, where1) {
|
|
return el1 = document.id(el1, !0), this.replaces(el1).grab(el1, where1);
|
|
},
|
|
getSelected: function() {
|
|
return this.selectedIndex, new Elements(Array.from(this.options).filter(function(option1) {
|
|
return option1.selected;
|
|
}));
|
|
},
|
|
toQueryString: function() {
|
|
var queryString1 = [];
|
|
return this.getElements("input, select, textarea").each(function(el1) {
|
|
var type1 = el1.type;
|
|
if (el1.name && !el1.disabled && "submit" != type1 && "reset" != type1 && "file" != type1 && "image" != type1) {
|
|
var value1 = "select" == el1.get("tag") ? el1.getSelected().map(function(opt1) {
|
|
return document.id(opt1).get("value");
|
|
}) : "radio" != type1 && "checkbox" != type1 || el1.checked ? el1.get("value") : null;
|
|
Array.from(value1).each(function(val1) {
|
|
void 0 !== val1 && queryString1.push(encodeURIComponent(el1.name) + "=" + encodeURIComponent(val1));
|
|
});
|
|
}
|
|
}), queryString1.join("&");
|
|
}
|
|
});
|
|
var collected1 = {}, storage1 = {}, get1 = function(uid1) {
|
|
return storage1[uid1] || (storage1[uid1] = {});
|
|
}, clean1 = function(item1) {
|
|
var uid1 = item1.uniqueNumber;
|
|
return item1.removeEvents && item1.removeEvents(), item1.clearAttributes && item1.clearAttributes(), null != uid1 && (delete collected1[uid1], delete storage1[uid1]), item1;
|
|
}, formProps1 = {
|
|
input: "checked",
|
|
option: "selected",
|
|
textarea: "value"
|
|
};
|
|
Element.implement({
|
|
destroy: function() {
|
|
return Array.each(clean1(this).getElementsByTagName("*"), clean1), Element.dispose(this), null;
|
|
},
|
|
empty: function() {
|
|
return Array.from(this.childNodes).each(Element.dispose), this;
|
|
},
|
|
dispose: function() {
|
|
return this.parentNode ? this.parentNode.removeChild(this) : this;
|
|
},
|
|
clone: function(contents1, keepid1) {
|
|
contents1 = !1 !== contents1;
|
|
var i1, clone1 = this.cloneNode(contents1), ce1 = [
|
|
clone1
|
|
], te1 = [
|
|
this
|
|
];
|
|
for(contents1 && (ce1.append(Array.from(clone1.getElementsByTagName("*"))), te1.append(Array.from(this.getElementsByTagName("*")))), i1 = ce1.length; i1--;){
|
|
var node1 = ce1[i1], element1 = te1[i1];
|
|
if (keepid1 || node1.removeAttribute("id"), node1.clearAttributes && (node1.clearAttributes(), node1.mergeAttributes(element1), node1.removeAttribute("uniqueNumber"), node1.options)) for(var no1 = node1.options, eo1 = element1.options, j1 = no1.length; j1--;)no1[j1].selected = eo1[j1].selected;
|
|
var prop1 = formProps1[element1.tagName.toLowerCase()];
|
|
prop1 && element1[prop1] && (node1[prop1] = element1[prop1]);
|
|
}
|
|
if (Browser.ie) {
|
|
var co1 = clone1.getElementsByTagName("object"), to1 = this.getElementsByTagName("object");
|
|
for(i1 = co1.length; i1--;)co1[i1].outerHTML = to1[i1].outerHTML;
|
|
}
|
|
return document.id(clone1);
|
|
}
|
|
}), [
|
|
Element,
|
|
Window,
|
|
Document
|
|
].invoke("implement", {
|
|
addListener: function(type1, fn1) {
|
|
if ("unload" == type1) {
|
|
var old1 = fn1, self1 = this;
|
|
fn1 = function() {
|
|
self1.removeListener("unload", fn1), old1();
|
|
};
|
|
} else collected1[Slick.uidOf(this)] = this;
|
|
return this.addEventListener ? this.addEventListener(type1, fn1, !!arguments[2]) : this.attachEvent("on" + type1, fn1), this;
|
|
},
|
|
removeListener: function(type1, fn1) {
|
|
return this.removeEventListener ? this.removeEventListener(type1, fn1, !!arguments[2]) : this.detachEvent("on" + type1, fn1), this;
|
|
},
|
|
retrieve: function(property1, dflt1) {
|
|
var storage1 = get1(Slick.uidOf(this)), prop1 = storage1[property1];
|
|
return null != dflt1 && null == prop1 && (prop1 = storage1[property1] = dflt1), null != prop1 ? prop1 : null;
|
|
},
|
|
store: function(property1, value1) {
|
|
return get1(Slick.uidOf(this))[property1] = value1, this;
|
|
},
|
|
eliminate: function(property1) {
|
|
var storage1 = get1(Slick.uidOf(this));
|
|
return delete storage1[property1], this;
|
|
}
|
|
}), window.attachEvent && !window.addEventListener && window.addListener("unload", function() {
|
|
Object.each(collected1, clean1), window.CollectGarbage && CollectGarbage();
|
|
}), Element.Properties = {}, Element.Properties = new Hash(), Element.Properties.style = {
|
|
set: function(style1) {
|
|
this.style.cssText = style1;
|
|
},
|
|
get: function() {
|
|
return this.style.cssText;
|
|
},
|
|
erase: function() {
|
|
this.style.cssText = "";
|
|
}
|
|
}, Element.Properties.tag = {
|
|
get: function() {
|
|
return this.tagName.toLowerCase();
|
|
}
|
|
}, Element.Properties.html = {
|
|
set: function(html1) {
|
|
null == html1 ? html1 = "" : "array" == typeOf(html1) && (html1 = html1.join("")), this.innerHTML = html1;
|
|
},
|
|
erase: function() {
|
|
this.innerHTML = "";
|
|
}
|
|
};
|
|
var div1 = document.createElement("div");
|
|
div1.innerHTML = "<nav></nav>";
|
|
var supportsHTML5Elements1 = 1 == div1.childNodes.length;
|
|
if (!supportsHTML5Elements1) for(var tags1 = "abbr article aside audio canvas datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video".split(" "), fragment1 = document.createDocumentFragment(), l1 = tags1.length; l1--;)fragment1.createElement(tags1[l1]);
|
|
div1 = null;
|
|
var supportsTableInnerHTML1 = Function.attempt(function() {
|
|
return document.createElement("table").innerHTML = "<tr><td></td></tr>", !0;
|
|
}), tr1 = document.createElement("tr"), html1 = "<td></td>";
|
|
tr1.innerHTML = html1;
|
|
var supportsTRInnerHTML1 = tr1.innerHTML == html1;
|
|
tr1 = null, supportsTableInnerHTML1 && supportsTRInnerHTML1 && supportsHTML5Elements1 || (Element.Properties.html.set = function(set1) {
|
|
var translations1 = {
|
|
table: [
|
|
1,
|
|
"<table>",
|
|
"</table>"
|
|
],
|
|
select: [
|
|
1,
|
|
"<select>",
|
|
"</select>"
|
|
],
|
|
tbody: [
|
|
2,
|
|
"<table><tbody>",
|
|
"</tbody></table>"
|
|
],
|
|
tr: [
|
|
3,
|
|
"<table><tbody><tr>",
|
|
"</tr></tbody></table>"
|
|
]
|
|
};
|
|
return translations1.thead = translations1.tfoot = translations1.tbody, function(html1) {
|
|
var wrap1 = translations1[this.get("tag")];
|
|
if (wrap1 || supportsHTML5Elements1 || (wrap1 = [
|
|
0,
|
|
"",
|
|
""
|
|
]), !wrap1) return set1.call(this, html1);
|
|
var level1 = wrap1[0], wrapper1 = document.createElement("div"), target1 = wrapper1;
|
|
for(supportsHTML5Elements1 || fragment1.appendChild(wrapper1), wrapper1.innerHTML = [
|
|
wrap1[1],
|
|
html1,
|
|
wrap1[2]
|
|
].flatten().join(""); level1--;)target1 = target1.firstChild;
|
|
this.empty().adopt(target1.childNodes), supportsHTML5Elements1 || fragment1.removeChild(wrapper1);
|
|
};
|
|
}(Element.Properties.html.set));
|
|
var testForm1 = document.createElement("form");
|
|
testForm1.innerHTML = "<select><option>s</option></select>", "s" != testForm1.firstChild.value && (Element.Properties.value = {
|
|
set: function(value1) {
|
|
if ("select" != this.get("tag")) return this.setProperty("value", value1);
|
|
for(var options1 = this.getElements("option"), i1 = 0; i1 < options1.length; i1++){
|
|
var option1 = options1[i1], attr1 = option1.getAttributeNode("value");
|
|
if ((attr1 && attr1.specified ? option1.value : option1.get("text")) == value1) return option1.selected = !0;
|
|
}
|
|
},
|
|
get: function() {
|
|
var option1 = this, tag1 = option1.get("tag");
|
|
if ("select" != tag1 && "option" != tag1) return this.getProperty("value");
|
|
if ("select" == tag1 && !(option1 = option1.getSelected()[0])) return "";
|
|
var attr1 = option1.getAttributeNode("value");
|
|
return attr1 && attr1.specified ? option1.value : option1.get("text");
|
|
}
|
|
}), testForm1 = null, document.createElement("div").getAttributeNode("id") && (Element.Properties.id = {
|
|
set: function(id1) {
|
|
this.id = this.getAttributeNode("id").value = id1;
|
|
},
|
|
get: function() {
|
|
return this.id || null;
|
|
},
|
|
erase: function() {
|
|
this.id = this.getAttributeNode("id").value = "";
|
|
}
|
|
});
|
|
}(), function() {
|
|
var html1 = document.html, el1 = document.createElement("div");
|
|
el1.style.color = "red", el1.style.color = null;
|
|
var doesNotRemoveStyles1 = "red" == el1.style.color;
|
|
el1 = null, Element.Properties.styles = {
|
|
set: function(styles1) {
|
|
this.setStyles(styles1);
|
|
}
|
|
};
|
|
var hasOpacity1 = null != html1.style.opacity, hasFilter1 = null != html1.style.filter, reAlpha1 = /alpha\(opacity=([\d.]+)\)/i, setVisibility1 = function(element1, opacity1) {
|
|
element1.store("$opacity", opacity1), element1.style.visibility = opacity1 > 0 || null == opacity1 ? "visible" : "hidden";
|
|
}, setOpacity1 = hasOpacity1 ? function(element1, opacity1) {
|
|
element1.style.opacity = opacity1;
|
|
} : hasFilter1 ? function(element1, opacity1) {
|
|
var style1 = element1.style;
|
|
element1.currentStyle && element1.currentStyle.hasLayout || (style1.zoom = 1), opacity1 = null == opacity1 || 1 == opacity1 ? "" : "alpha(opacity=" + (100 * opacity1).limit(0, 100).round() + ")";
|
|
var filter1 = style1.filter || element1.getComputedStyle("filter") || "";
|
|
style1.filter = reAlpha1.test(filter1) ? filter1.replace(reAlpha1, opacity1) : filter1 + opacity1, style1.filter || style1.removeAttribute("filter");
|
|
} : setVisibility1, getOpacity1 = hasOpacity1 ? function(element1) {
|
|
var opacity1 = element1.style.opacity || element1.getComputedStyle("opacity");
|
|
return "" == opacity1 ? 1 : opacity1.toFloat();
|
|
} : hasFilter1 ? function(element1) {
|
|
var opacity1, filter1 = element1.style.filter || element1.getComputedStyle("filter");
|
|
return filter1 && (opacity1 = filter1.match(reAlpha1)), null == opacity1 || null == filter1 ? 1 : opacity1[1] / 100;
|
|
} : function(element1) {
|
|
var opacity1 = element1.retrieve("$opacity");
|
|
return null == opacity1 && (opacity1 = "hidden" == element1.style.visibility ? 0 : 1), opacity1;
|
|
}, floatName1 = null == html1.style.cssFloat ? "styleFloat" : "cssFloat";
|
|
Element.implement({
|
|
getComputedStyle: function(property1) {
|
|
if (this.currentStyle) return this.currentStyle[property1.camelCase()];
|
|
var defaultView1 = Element.getDocument(this).defaultView, computed1 = defaultView1 ? defaultView1.getComputedStyle(this, null) : null;
|
|
return computed1 ? computed1.getPropertyValue(property1 == floatName1 ? "float" : property1.hyphenate()) : null;
|
|
},
|
|
setStyle: function(property1, value1) {
|
|
if ("opacity" == property1) return null != value1 && (value1 = parseFloat(value1)), setOpacity1(this, value1), this;
|
|
if (property1 = ("float" == property1 ? floatName1 : property1).camelCase(), "string" != typeOf(value1)) {
|
|
var map1 = (Element.Styles[property1] || "@").split(" ");
|
|
value1 = Array.from(value1).map(function(val1, i1) {
|
|
return map1[i1] ? "number" == typeOf(val1) ? map1[i1].replace("@", Math.round(val1)) : val1 : "";
|
|
}).join(" ");
|
|
} else value1 == String(Number(value1)) && (value1 = Math.round(value1));
|
|
return this.style[property1] = value1, ("" == value1 || null == value1) && doesNotRemoveStyles1 && this.style.removeAttribute && this.style.removeAttribute(property1), this;
|
|
},
|
|
getStyle: function(property1) {
|
|
if ("opacity" == property1) return getOpacity1(this);
|
|
property1 = ("float" == property1 ? floatName1 : property1).camelCase();
|
|
var result1 = this.style[property1];
|
|
if (!result1 || "zIndex" == property1) {
|
|
for(var style1 in result1 = [], Element.ShortStyles)if (property1 == style1) {
|
|
for(var s1 in Element.ShortStyles[style1])result1.push(this.getStyle(s1));
|
|
return result1.join(" ");
|
|
}
|
|
result1 = this.getComputedStyle(property1);
|
|
}
|
|
if (result1) {
|
|
var color1 = (result1 = String(result1)).match(/rgba?\([\d\s,]+\)/);
|
|
color1 && (result1 = result1.replace(color1[0], color1[0].rgbToHex()));
|
|
}
|
|
if (Browser.opera || Browser.ie) {
|
|
if (/^(height|width)$/.test(property1) && !/px$/.test(result1)) {
|
|
var size1 = 0;
|
|
return ("width" == property1 ? [
|
|
"left",
|
|
"right"
|
|
] : [
|
|
"top",
|
|
"bottom"
|
|
]).each(function(value1) {
|
|
size1 += this.getStyle("border-" + value1 + "-width").toInt() + this.getStyle("padding-" + value1).toInt();
|
|
}, this), this["offset" + property1.capitalize()] - size1 + "px";
|
|
}
|
|
if (Browser.ie && /^border(.+)Width|margin|padding/.test(property1) && isNaN(parseFloat(result1))) return "0px";
|
|
}
|
|
return result1;
|
|
},
|
|
setStyles: function(styles1) {
|
|
for(var style1 in styles1)this.setStyle(style1, styles1[style1]);
|
|
return this;
|
|
},
|
|
getStyles: function() {
|
|
var result1 = {};
|
|
return Array.flatten(arguments).each(function(key1) {
|
|
result1[key1] = this.getStyle(key1);
|
|
}, this), result1;
|
|
}
|
|
}), Element.Styles = {
|
|
left: "@px",
|
|
top: "@px",
|
|
bottom: "@px",
|
|
right: "@px",
|
|
width: "@px",
|
|
height: "@px",
|
|
maxWidth: "@px",
|
|
maxHeight: "@px",
|
|
minWidth: "@px",
|
|
minHeight: "@px",
|
|
backgroundColor: "rgb(@, @, @)",
|
|
backgroundPosition: "@px @px",
|
|
color: "rgb(@, @, @)",
|
|
fontSize: "@px",
|
|
letterSpacing: "@px",
|
|
lineHeight: "@px",
|
|
clip: "rect(@px @px @px @px)",
|
|
margin: "@px @px @px @px",
|
|
padding: "@px @px @px @px",
|
|
border: "@px @ rgb(@, @, @) @px @ rgb(@, @, @) @px @ rgb(@, @, @)",
|
|
borderWidth: "@px @px @px @px",
|
|
borderStyle: "@ @ @ @",
|
|
borderColor: "rgb(@, @, @) rgb(@, @, @) rgb(@, @, @) rgb(@, @, @)",
|
|
zIndex: "@",
|
|
zoom: "@",
|
|
fontWeight: "@",
|
|
textIndent: "@px",
|
|
opacity: "@"
|
|
}, Element.implement({
|
|
setOpacity: function(value1) {
|
|
return setOpacity1(this, value1), this;
|
|
},
|
|
getOpacity: function() {
|
|
return getOpacity1(this);
|
|
}
|
|
}), Element.Properties.opacity = {
|
|
set: function(opacity1) {
|
|
setOpacity1(this, opacity1), setVisibility1(this, opacity1);
|
|
},
|
|
get: function() {
|
|
return getOpacity1(this);
|
|
}
|
|
}, Element.Styles = new Hash(Element.Styles), Element.ShortStyles = {
|
|
margin: {},
|
|
padding: {},
|
|
border: {},
|
|
borderWidth: {},
|
|
borderStyle: {},
|
|
borderColor: {}
|
|
}, [
|
|
"Top",
|
|
"Right",
|
|
"Bottom",
|
|
"Left"
|
|
].each(function(direction1) {
|
|
var Short1 = Element.ShortStyles, All1 = Element.Styles;
|
|
[
|
|
"margin",
|
|
"padding"
|
|
].each(function(style1) {
|
|
var sd1 = style1 + direction1;
|
|
Short1[style1][sd1] = All1[sd1] = "@px";
|
|
});
|
|
var bd1 = "border" + direction1;
|
|
Short1.border[bd1] = All1[bd1] = "@px @ rgb(@, @, @)";
|
|
var bdw1 = bd1 + "Width", bds1 = bd1 + "Style", bdc1 = bd1 + "Color";
|
|
Short1[bd1] = {}, Short1.borderWidth[bdw1] = Short1[bd1][bdw1] = All1[bdw1] = "@px", Short1.borderStyle[bds1] = Short1[bd1][bds1] = All1[bds1] = "@", Short1.borderColor[bdc1] = Short1[bd1][bdc1] = All1[bdc1] = "rgb(@, @, @)";
|
|
});
|
|
}(), function() {
|
|
if (Element.Properties.events = {
|
|
set: function(events1) {
|
|
this.addEvents(events1);
|
|
}
|
|
}, [
|
|
Element,
|
|
Window,
|
|
Document
|
|
].invoke("implement", {
|
|
addEvent: function(type1, fn1) {
|
|
var events1 = this.retrieve("events", {});
|
|
if (events1[type1] || (events1[type1] = {
|
|
keys: [],
|
|
values: []
|
|
}), events1[type1].keys.contains(fn1)) return this;
|
|
events1[type1].keys.push(fn1);
|
|
var realType1 = type1, custom1 = Element.Events[type1], condition1 = fn1, self1 = this;
|
|
custom1 && (custom1.onAdd && custom1.onAdd.call(this, fn1, type1), custom1.condition && (condition1 = function(event1) {
|
|
return !custom1.condition.call(this, event1, type1) || fn1.call(this, event1);
|
|
}), custom1.base && (realType1 = Function.from(custom1.base).call(this, type1)));
|
|
var defn1 = function() {
|
|
return fn1.call(self1);
|
|
}, nativeEvent1 = Element.NativeEvents[realType1];
|
|
return nativeEvent1 && (2 == nativeEvent1 && (defn1 = function(event1) {
|
|
event1 = new DOMEvent(event1, self1.getWindow()), !1 === condition1.call(self1, event1) && event1.stop();
|
|
}), this.addListener(realType1, defn1, arguments[2])), events1[type1].values.push(defn1), this;
|
|
},
|
|
removeEvent: function(type1, fn1) {
|
|
var events1 = this.retrieve("events");
|
|
if (!events1 || !events1[type1]) return this;
|
|
var list1 = events1[type1], index1 = list1.keys.indexOf(fn1);
|
|
if (-1 == index1) return this;
|
|
var value1 = list1.values[index1];
|
|
delete list1.keys[index1], delete list1.values[index1];
|
|
var custom1 = Element.Events[type1];
|
|
return custom1 && (custom1.onRemove && custom1.onRemove.call(this, fn1, type1), custom1.base && (type1 = Function.from(custom1.base).call(this, type1))), Element.NativeEvents[type1] ? this.removeListener(type1, value1, arguments[2]) : this;
|
|
},
|
|
addEvents: function(events1) {
|
|
for(var event1 in events1)this.addEvent(event1, events1[event1]);
|
|
return this;
|
|
},
|
|
removeEvents: function(events1) {
|
|
if ("object" == typeOf(events1)) {
|
|
for(type1 in events1)this.removeEvent(type1, events1[type1]);
|
|
return this;
|
|
}
|
|
var type1, attached1 = this.retrieve("events");
|
|
if (!attached1) return this;
|
|
if (events1) attached1[events1] && (attached1[events1].keys.each(function(fn1) {
|
|
this.removeEvent(events1, fn1);
|
|
}, this), delete attached1[events1]);
|
|
else {
|
|
for(type1 in attached1)this.removeEvents(type1);
|
|
this.eliminate("events");
|
|
}
|
|
return this;
|
|
},
|
|
fireEvent: function(type1, args1, delay1) {
|
|
var events1 = this.retrieve("events");
|
|
return events1 && events1[type1] && (args1 = Array.from(args1), events1[type1].keys.each(function(fn1) {
|
|
delay1 ? fn1.delay(delay1, this, args1) : fn1.apply(this, args1);
|
|
}, this)), this;
|
|
},
|
|
cloneEvents: function(from1, type1) {
|
|
var events1 = (from1 = document.id(from1)).retrieve("events");
|
|
if (!events1) return this;
|
|
if (type1) events1[type1] && events1[type1].keys.each(function(fn1) {
|
|
this.addEvent(type1, fn1);
|
|
}, this);
|
|
else for(var eventType1 in events1)this.cloneEvents(from1, eventType1);
|
|
return this;
|
|
}
|
|
}), Element.NativeEvents = {
|
|
click: 2,
|
|
dblclick: 2,
|
|
mouseup: 2,
|
|
mousedown: 2,
|
|
contextmenu: 2,
|
|
mousewheel: 2,
|
|
DOMMouseScroll: 2,
|
|
mouseover: 2,
|
|
mouseout: 2,
|
|
mousemove: 2,
|
|
selectstart: 2,
|
|
selectend: 2,
|
|
keydown: 2,
|
|
keypress: 2,
|
|
keyup: 2,
|
|
orientationchange: 2,
|
|
touchstart: 2,
|
|
touchmove: 2,
|
|
touchend: 2,
|
|
touchcancel: 2,
|
|
gesturestart: 2,
|
|
gesturechange: 2,
|
|
gestureend: 2,
|
|
focus: 2,
|
|
blur: 2,
|
|
change: 2,
|
|
reset: 2,
|
|
select: 2,
|
|
submit: 2,
|
|
paste: 2,
|
|
input: 2,
|
|
load: 2,
|
|
unload: 1,
|
|
beforeunload: 2,
|
|
resize: 1,
|
|
move: 1,
|
|
DOMContentLoaded: 1,
|
|
readystatechange: 1,
|
|
error: 1,
|
|
abort: 1,
|
|
scroll: 1
|
|
}, Element.Events = {
|
|
mousewheel: {
|
|
base: Browser.firefox ? "DOMMouseScroll" : "mousewheel"
|
|
}
|
|
}, "onmouseenter" in document.documentElement) Element.NativeEvents.mouseenter = Element.NativeEvents.mouseleave = 2;
|
|
else {
|
|
var check1 = function(event1) {
|
|
var related1 = event1.relatedTarget;
|
|
return null == related1 || !!related1 && related1 != this && "xul" != related1.prefix && "document" != typeOf(this) && !this.contains(related1);
|
|
};
|
|
Element.Events.mouseenter = {
|
|
base: "mouseover",
|
|
condition: check1
|
|
}, Element.Events.mouseleave = {
|
|
base: "mouseout",
|
|
condition: check1
|
|
};
|
|
}
|
|
window.addEventListener || (Element.NativeEvents.propertychange = 2, Element.Events.change = {
|
|
base: function() {
|
|
var type1 = this.type;
|
|
return "input" == this.get("tag") && ("radio" == type1 || "checkbox" == type1) ? "propertychange" : "change";
|
|
},
|
|
condition: function(event1) {
|
|
return "radio" != this.type || "checked" == event1.event.propertyName && this.checked;
|
|
}
|
|
}), Element.Events = new Hash(Element.Events);
|
|
}(), function() {
|
|
var eventListenerSupport1 = !!window.addEventListener;
|
|
Element.NativeEvents.focusin = Element.NativeEvents.focusout = 2;
|
|
var bubbleUp1 = function(self1, match1, fn1, event1, target1) {
|
|
for(; target1 && target1 != self1;){
|
|
if (match1(target1, event1)) return fn1.call(target1, event1, target1);
|
|
target1 = document.id(target1.parentNode);
|
|
}
|
|
}, map1 = {
|
|
mouseenter: {
|
|
base: "mouseover"
|
|
},
|
|
mouseleave: {
|
|
base: "mouseout"
|
|
},
|
|
focus: {
|
|
base: "focus" + (eventListenerSupport1 ? "" : "in"),
|
|
capture: !0
|
|
},
|
|
blur: {
|
|
base: eventListenerSupport1 ? "blur" : "focusout",
|
|
capture: !0
|
|
}
|
|
}, _key1 = "$delegation:", formObserver1 = function(type1) {
|
|
return {
|
|
base: "focusin",
|
|
remove: function(self1, uid1) {
|
|
var list1 = self1.retrieve(_key1 + type1 + "listeners", {})[uid1];
|
|
if (list1 && list1.forms) for(var i1 = list1.forms.length; i1--;)list1.forms[i1].removeEvent(type1, list1.fns[i1]);
|
|
},
|
|
listen: function(self1, match1, fn1, event1, target1, uid1) {
|
|
var form1 = "form" == target1.get("tag") ? target1 : event1.target.getParent("form");
|
|
if (form1) {
|
|
var listeners1 = self1.retrieve(_key1 + type1 + "listeners", {}), listener1 = listeners1[uid1] || {
|
|
forms: [],
|
|
fns: []
|
|
}, forms1 = listener1.forms, fns1 = listener1.fns;
|
|
if (-1 == forms1.indexOf(form1)) {
|
|
forms1.push(form1);
|
|
var _fn1 = function(event1) {
|
|
bubbleUp1(self1, match1, fn1, event1, target1);
|
|
};
|
|
form1.addEvent(type1, _fn1), fns1.push(_fn1), listeners1[uid1] = listener1, self1.store(_key1 + type1 + "listeners", listeners1);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}, inputObserver1 = function(type1) {
|
|
return {
|
|
base: "focusin",
|
|
listen: function(self1, match1, fn1, event1, target1) {
|
|
var events1 = {
|
|
blur: function() {
|
|
this.removeEvents(events1);
|
|
}
|
|
};
|
|
events1[type1] = function(event1) {
|
|
bubbleUp1(self1, match1, fn1, event1, target1);
|
|
}, event1.target.addEvents(events1);
|
|
}
|
|
};
|
|
};
|
|
eventListenerSupport1 || Object.append(map1, {
|
|
submit: formObserver1("submit"),
|
|
reset: formObserver1("reset"),
|
|
change: inputObserver1("change"),
|
|
select: inputObserver1("select")
|
|
});
|
|
var proto1 = Element.prototype, addEvent1 = proto1.addEvent, removeEvent1 = proto1.removeEvent, relay1 = function(old1, method1) {
|
|
return function(type1, fn1, useCapture1) {
|
|
if (-1 == type1.indexOf(":relay")) return old1.call(this, type1, fn1, useCapture1);
|
|
var parsed1 = Slick.parse(type1).expressions[0][0];
|
|
if ("relay" != parsed1.pseudos[0].key) return old1.call(this, type1, fn1, useCapture1);
|
|
var newType1 = parsed1.tag;
|
|
return parsed1.pseudos.slice(1).each(function(pseudo1) {
|
|
newType1 += ":" + pseudo1.key + (pseudo1.value ? "(" + pseudo1.value + ")" : "");
|
|
}), old1.call(this, type1, fn1), method1.call(this, newType1, parsed1.pseudos[0].value, fn1);
|
|
};
|
|
}, delegation1 = {
|
|
addEvent: function(type1, match1, fn1) {
|
|
var storage1 = this.retrieve("$delegates", {}), stored1 = storage1[type1];
|
|
if (stored1) {
|
|
for(var _uid1 in stored1)if (stored1[_uid1].fn == fn1 && stored1[_uid1].match == match1) return this;
|
|
}
|
|
var _type1 = type1, _match1 = match1, _fn1 = fn1, _map1 = map1[type1] || {};
|
|
type1 = _map1.base || _type1, match1 = function(target1) {
|
|
return Slick.match(target1, _match1);
|
|
};
|
|
var elementEvent1 = Element.Events[_type1];
|
|
if (elementEvent1 && elementEvent1.condition) {
|
|
var __match1 = match1, condition1 = elementEvent1.condition;
|
|
match1 = function(target1, event1) {
|
|
return __match1(target1, event1) && condition1.call(target1, event1, type1);
|
|
};
|
|
}
|
|
var self1 = this, uid1 = String.uniqueID(), delegator1 = _map1.listen ? function(event1, target1) {
|
|
!target1 && event1 && event1.target && (target1 = event1.target), target1 && _map1.listen(self1, match1, fn1, event1, target1, uid1);
|
|
} : function(event1, target1) {
|
|
!target1 && event1 && event1.target && (target1 = event1.target), target1 && bubbleUp1(self1, match1, fn1, event1, target1);
|
|
};
|
|
return stored1 || (stored1 = {}), stored1[uid1] = {
|
|
match: _match1,
|
|
fn: _fn1,
|
|
delegator: delegator1
|
|
}, storage1[_type1] = stored1, addEvent1.call(this, type1, delegator1, _map1.capture);
|
|
},
|
|
removeEvent: function(type1, match1, fn1, _uid1) {
|
|
var __uid1, s1, storage1 = this.retrieve("$delegates", {}), stored1 = storage1[type1];
|
|
if (!stored1) return this;
|
|
if (_uid1) {
|
|
var _type1 = type1, delegator1 = stored1[_uid1].delegator, _map1 = map1[type1] || {};
|
|
return type1 = _map1.base || _type1, _map1.remove && _map1.remove(this, _uid1), delete stored1[_uid1], storage1[_type1] = stored1, removeEvent1.call(this, type1, delegator1);
|
|
}
|
|
if (fn1) {
|
|
for(__uid1 in stored1)if ((s1 = stored1[__uid1]).match == match1 && s1.fn == fn1) return delegation1.removeEvent.call(this, type1, match1, fn1, __uid1);
|
|
} else for(__uid1 in stored1)(s1 = stored1[__uid1]).match == match1 && delegation1.removeEvent.call(this, type1, match1, s1.fn, __uid1);
|
|
return this;
|
|
}
|
|
};
|
|
[
|
|
Element,
|
|
Window,
|
|
Document
|
|
].invoke("implement", {
|
|
addEvent: relay1(addEvent1, delegation1.addEvent),
|
|
removeEvent: relay1(removeEvent1, delegation1.removeEvent)
|
|
});
|
|
}(), function() {
|
|
var element1 = document.createElement("div"), child1 = document.createElement("div");
|
|
element1.style.height = "0", element1.appendChild(child1);
|
|
var brokenOffsetParent1 = child1.offsetParent === element1;
|
|
element1 = child1 = null;
|
|
var isOffset1 = function(el1) {
|
|
return "static" != styleString1(el1, "position") || isBody1(el1);
|
|
}, isOffsetStatic1 = function(el1) {
|
|
return isOffset1(el1) || /^(?:table|td|th)$/i.test(el1.tagName);
|
|
};
|
|
Element.implement({
|
|
scrollTo: function(x1, y1) {
|
|
return isBody1(this) ? this.getWindow().scrollTo(x1, y1) : (this.scrollLeft = x1, this.scrollTop = y1), this;
|
|
},
|
|
getSize: function() {
|
|
return isBody1(this) ? this.getWindow().getSize() : {
|
|
x: this.offsetWidth,
|
|
y: this.offsetHeight
|
|
};
|
|
},
|
|
getScrollSize: function() {
|
|
return isBody1(this) ? this.getWindow().getScrollSize() : {
|
|
x: this.scrollWidth,
|
|
y: this.scrollHeight
|
|
};
|
|
},
|
|
getScroll: function() {
|
|
return isBody1(this) ? this.getWindow().getScroll() : {
|
|
x: this.scrollLeft,
|
|
y: this.scrollTop
|
|
};
|
|
},
|
|
getScrolls: function() {
|
|
for(var element1 = this.parentNode, position1 = {
|
|
x: 0,
|
|
y: 0
|
|
}; element1 && !isBody1(element1);)position1.x += element1.scrollLeft, position1.y += element1.scrollTop, element1 = element1.parentNode;
|
|
return position1;
|
|
},
|
|
getOffsetParent: brokenOffsetParent1 ? function() {
|
|
var element1 = this;
|
|
if (isBody1(element1) || "fixed" == styleString1(element1, "position")) return null;
|
|
for(var isOffsetCheck1 = "static" == styleString1(element1, "position") ? isOffsetStatic1 : isOffset1; element1 = element1.parentNode;)if (isOffsetCheck1(element1)) return element1;
|
|
return null;
|
|
} : function() {
|
|
var element1 = this;
|
|
if (isBody1(element1) || "fixed" == styleString1(element1, "position")) return null;
|
|
try {
|
|
return element1.offsetParent;
|
|
} catch (e1) {}
|
|
return null;
|
|
},
|
|
getOffsets: function() {
|
|
if (this.getBoundingClientRect && !Browser.Platform.ios) {
|
|
var bound1 = this.getBoundingClientRect(), html1 = document.id(this.getDocument().documentElement), htmlScroll1 = html1.getScroll(), elemScrolls1 = this.getScrolls(), isFixed1 = "fixed" == styleString1(this, "position");
|
|
return {
|
|
x: bound1.left.toInt() + elemScrolls1.x + (isFixed1 ? 0 : htmlScroll1.x) - html1.clientLeft,
|
|
y: bound1.top.toInt() + elemScrolls1.y + (isFixed1 ? 0 : htmlScroll1.y) - html1.clientTop
|
|
};
|
|
}
|
|
var element1 = this, position1 = {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
if (isBody1(this)) return position1;
|
|
for(; element1 && !isBody1(element1);){
|
|
if (position1.x += element1.offsetLeft, position1.y += element1.offsetTop, Browser.firefox) {
|
|
borderBox1(element1) || (position1.x += leftBorder1(element1), position1.y += topBorder1(element1));
|
|
var parent1 = element1.parentNode;
|
|
parent1 && "visible" != styleString1(parent1, "overflow") && (position1.x += leftBorder1(parent1), position1.y += topBorder1(parent1));
|
|
} else element1 != this && Browser.safari && (position1.x += leftBorder1(element1), position1.y += topBorder1(element1));
|
|
element1 = element1.offsetParent;
|
|
}
|
|
return Browser.firefox && !borderBox1(this) && (position1.x -= leftBorder1(this), position1.y -= topBorder1(this)), position1;
|
|
},
|
|
getPosition: function(relative1) {
|
|
var offset1 = this.getOffsets(), scroll1 = this.getScrolls(), position1 = {
|
|
x: offset1.x - scroll1.x,
|
|
y: offset1.y - scroll1.y
|
|
};
|
|
if (relative1 && (relative1 = document.id(relative1))) {
|
|
var relativePosition1 = relative1.getPosition();
|
|
return {
|
|
x: position1.x - relativePosition1.x - leftBorder1(relative1),
|
|
y: position1.y - relativePosition1.y - topBorder1(relative1)
|
|
};
|
|
}
|
|
return position1;
|
|
},
|
|
getCoordinates: function(element1) {
|
|
if (isBody1(this)) return this.getWindow().getCoordinates();
|
|
var position1 = this.getPosition(element1), size1 = this.getSize(), obj1 = {
|
|
left: position1.x,
|
|
top: position1.y,
|
|
width: size1.x,
|
|
height: size1.y
|
|
};
|
|
return obj1.right = obj1.left + obj1.width, obj1.bottom = obj1.top + obj1.height, obj1;
|
|
},
|
|
computePosition: function(obj1) {
|
|
return {
|
|
left: obj1.x - styleNumber1(this, "margin-left"),
|
|
top: obj1.y - styleNumber1(this, "margin-top")
|
|
};
|
|
},
|
|
setPosition: function(obj1) {
|
|
return this.setStyles(this.computePosition(obj1));
|
|
}
|
|
}), [
|
|
Document,
|
|
Window
|
|
].invoke("implement", {
|
|
getSize: function() {
|
|
var doc1 = getCompatElement1(this);
|
|
return {
|
|
x: doc1.clientWidth,
|
|
y: doc1.clientHeight
|
|
};
|
|
},
|
|
getScroll: function() {
|
|
var win1 = this.getWindow(), doc1 = getCompatElement1(this);
|
|
return {
|
|
x: win1.pageXOffset || doc1.scrollLeft,
|
|
y: win1.pageYOffset || doc1.scrollTop
|
|
};
|
|
},
|
|
getScrollSize: function() {
|
|
var doc1 = getCompatElement1(this), min1 = this.getSize(), body1 = this.getDocument().body;
|
|
return {
|
|
x: Math.max(doc1.scrollWidth, body1.scrollWidth, min1.x),
|
|
y: Math.max(doc1.scrollHeight, body1.scrollHeight, min1.y)
|
|
};
|
|
},
|
|
getPosition: function() {
|
|
return {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
},
|
|
getCoordinates: function() {
|
|
var size1 = this.getSize();
|
|
return {
|
|
top: 0,
|
|
left: 0,
|
|
bottom: size1.y,
|
|
right: size1.x,
|
|
height: size1.y,
|
|
width: size1.x
|
|
};
|
|
}
|
|
});
|
|
var styleString1 = Element.getComputedStyle;
|
|
function styleNumber1(element1, style1) {
|
|
return styleString1(element1, style1).toInt() || 0;
|
|
}
|
|
function borderBox1(element1) {
|
|
return "border-box" == styleString1(element1, "-moz-box-sizing");
|
|
}
|
|
function topBorder1(element1) {
|
|
return styleNumber1(element1, "border-top-width");
|
|
}
|
|
function leftBorder1(element1) {
|
|
return styleNumber1(element1, "border-left-width");
|
|
}
|
|
function isBody1(element1) {
|
|
return /^(?:body|html)$/i.test(element1.tagName);
|
|
}
|
|
function getCompatElement1(element1) {
|
|
var doc1 = element1.getDocument();
|
|
return doc1.compatMode && "CSS1Compat" != doc1.compatMode ? doc1.body : doc1.html;
|
|
}
|
|
}(), Element.alias({
|
|
position: "setPosition"
|
|
}), [
|
|
Window,
|
|
Document,
|
|
Element
|
|
].invoke("implement", {
|
|
getHeight: function() {
|
|
return this.getSize().y;
|
|
},
|
|
getWidth: function() {
|
|
return this.getSize().x;
|
|
},
|
|
getScrollTop: function() {
|
|
return this.getScroll().y;
|
|
},
|
|
getScrollLeft: function() {
|
|
return this.getScroll().x;
|
|
},
|
|
getScrollHeight: function() {
|
|
return this.getScrollSize().y;
|
|
},
|
|
getScrollWidth: function() {
|
|
return this.getScrollSize().x;
|
|
},
|
|
getTop: function() {
|
|
return this.getPosition().y;
|
|
},
|
|
getLeft: function() {
|
|
return this.getPosition().x;
|
|
}
|
|
}), function() {
|
|
var Fx1 = this.Fx = new Class({
|
|
Implements: [
|
|
Chain,
|
|
Events,
|
|
Options
|
|
],
|
|
options: {
|
|
fps: 60,
|
|
unit: !1,
|
|
duration: 500,
|
|
frames: null,
|
|
frameSkip: !0,
|
|
link: "ignore"
|
|
},
|
|
initialize: function(options1) {
|
|
this.subject = this.subject || this, this.setOptions(options1);
|
|
},
|
|
getTransition: function() {
|
|
return function(p1) {
|
|
return -(Math.cos(Math.PI * p1) - 1) / 2;
|
|
};
|
|
},
|
|
step: function(now1) {
|
|
if (this.options.frameSkip) {
|
|
var frames1 = (null != this.time ? now1 - this.time : 0) / this.frameInterval;
|
|
this.time = now1, this.frame += frames1;
|
|
} else this.frame++;
|
|
if (this.frame < this.frames) {
|
|
var delta1 = this.transition(this.frame / this.frames);
|
|
this.set(this.compute(this.from, this.to, delta1));
|
|
} else this.frame = this.frames, this.set(this.compute(this.from, this.to, 1)), this.stop();
|
|
},
|
|
set: function(now1) {
|
|
return now1;
|
|
},
|
|
compute: function(from1, to1, delta1) {
|
|
return Fx1.compute(from1, to1, delta1);
|
|
},
|
|
check: function() {
|
|
if (!this.isRunning()) return !0;
|
|
switch(this.options.link){
|
|
case "cancel":
|
|
return this.cancel(), !0;
|
|
case "chain":
|
|
this.chain(this.caller.pass(arguments, this));
|
|
}
|
|
return !1;
|
|
},
|
|
start: function(from1, to1) {
|
|
if (!this.check(from1, to1)) return this;
|
|
this.from = from1, this.to = to1, this.frame = this.options.frameSkip ? 0 : -1, this.time = null, this.transition = this.getTransition();
|
|
var frames1 = this.options.frames, fps1 = this.options.fps, duration1 = this.options.duration;
|
|
return this.duration = Fx1.Durations[duration1] || duration1.toInt(), this.frameInterval = 1000 / fps1, this.frames = frames1 || Math.round(this.duration / this.frameInterval), this.fireEvent("start", this.subject), pushInstance1.call(this, fps1), this;
|
|
},
|
|
stop: function() {
|
|
return this.isRunning() && (this.time = null, pullInstance1.call(this, this.options.fps), this.frames == this.frame ? (this.fireEvent("complete", this.subject), this.callChain() || this.fireEvent("chainComplete", this.subject)) : this.fireEvent("stop", this.subject)), this;
|
|
},
|
|
cancel: function() {
|
|
return this.isRunning() && (this.time = null, pullInstance1.call(this, this.options.fps), this.frame = this.frames, this.fireEvent("cancel", this.subject).clearChain()), this;
|
|
},
|
|
pause: function() {
|
|
return this.isRunning() && (this.time = null, pullInstance1.call(this, this.options.fps)), this;
|
|
},
|
|
resume: function() {
|
|
return this.frame < this.frames && !this.isRunning() && pushInstance1.call(this, this.options.fps), this;
|
|
},
|
|
isRunning: function() {
|
|
var list1 = instances1[this.options.fps];
|
|
return list1 && list1.contains(this);
|
|
}
|
|
});
|
|
Fx1.compute = function(from1, to1, delta1) {
|
|
return (to1 - from1) * delta1 + from1;
|
|
}, Fx1.Durations = {
|
|
short: 250,
|
|
normal: 500,
|
|
long: 1000
|
|
};
|
|
var instances1 = {}, timers1 = {}, loop1 = function() {
|
|
for(var now1 = Date.now(), i1 = this.length; i1--;){
|
|
var instance1 = this[i1];
|
|
instance1 && instance1.step(now1);
|
|
}
|
|
}, pushInstance1 = function(fps1) {
|
|
var list1 = instances1[fps1] || (instances1[fps1] = []);
|
|
list1.push(this), timers1[fps1] || (timers1[fps1] = loop1.periodical(Math.round(1000 / fps1), list1));
|
|
}, pullInstance1 = function(fps1) {
|
|
var list1 = instances1[fps1];
|
|
list1 && (list1.erase(this), !list1.length && timers1[fps1] && (delete instances1[fps1], timers1[fps1] = clearInterval(timers1[fps1])));
|
|
};
|
|
}(), Fx.CSS = new Class({
|
|
Extends: Fx,
|
|
prepare: function(element1, property1, values1) {
|
|
var from1 = (values1 = Array.from(values1))[0], to1 = values1[1];
|
|
if (null == to1) {
|
|
to1 = from1, from1 = element1.getStyle(property1);
|
|
var unit1 = this.options.unit;
|
|
if (unit1 && from1.slice(-unit1.length) != unit1 && 0 != parseFloat(from1)) {
|
|
element1.setStyle(property1, to1 + unit1);
|
|
var value1 = element1.getComputedStyle(property1);
|
|
if (!/px$/.test(value1) && null == (value1 = element1.style[("pixel-" + property1).camelCase()])) {
|
|
var left1 = element1.style.left;
|
|
element1.style.left = to1 + unit1, value1 = element1.style.pixelLeft, element1.style.left = left1;
|
|
}
|
|
from1 = (to1 || 1) / (parseFloat(value1) || 1) * (parseFloat(from1) || 0), element1.setStyle(property1, from1 + unit1);
|
|
}
|
|
}
|
|
return {
|
|
from: this.parse(from1),
|
|
to: this.parse(to1)
|
|
};
|
|
},
|
|
parse: function(value1) {
|
|
return (value1 = "string" == typeof (value1 = Function.from(value1)()) ? value1.split(" ") : Array.from(value1)).map(function(val1) {
|
|
val1 = String(val1);
|
|
var found1 = !1;
|
|
return Object.each(Fx.CSS.Parsers, function(parser1, key1) {
|
|
if (!found1) {
|
|
var parsed1 = parser1.parse(val1);
|
|
(parsed1 || 0 === parsed1) && (found1 = {
|
|
value: parsed1,
|
|
parser: parser1
|
|
});
|
|
}
|
|
}), found1 = found1 || {
|
|
value: val1,
|
|
parser: Fx.CSS.Parsers.String
|
|
};
|
|
});
|
|
},
|
|
compute: function(from1, to1, delta1) {
|
|
var computed1 = [];
|
|
return Math.min(from1.length, to1.length).times(function(i1) {
|
|
computed1.push({
|
|
value: from1[i1].parser.compute(from1[i1].value, to1[i1].value, delta1),
|
|
parser: from1[i1].parser
|
|
});
|
|
}), computed1.$family = Function.from("fx:css:value"), computed1;
|
|
},
|
|
serve: function(value1, unit1) {
|
|
"fx:css:value" != typeOf(value1) && (value1 = this.parse(value1));
|
|
var returned1 = [];
|
|
return value1.each(function(bit1) {
|
|
returned1 = returned1.concat(bit1.parser.serve(bit1.value, unit1));
|
|
}), returned1;
|
|
},
|
|
render: function(element1, property1, value1, unit1) {
|
|
element1.setStyle(property1, this.serve(value1, unit1));
|
|
},
|
|
search: function(selector1) {
|
|
if (Fx.CSS.Cache[selector1]) return Fx.CSS.Cache[selector1];
|
|
var to1 = {}, selectorTest1 = RegExp("^" + selector1.escapeRegExp() + "$");
|
|
return Array.each(document.styleSheets, function(sheet1, j1) {
|
|
var href1 = sheet1.href;
|
|
if (!(href1 && href1.contains("://")) || href1.contains(document.domain)) {
|
|
var rules1 = sheet1.rules || sheet1.cssRules;
|
|
Array.each(rules1, function(rule1, i1) {
|
|
if (rule1.style) {
|
|
var selectorText1 = rule1.selectorText ? rule1.selectorText.replace(/^\w+/, function(m1) {
|
|
return m1.toLowerCase();
|
|
}) : null;
|
|
selectorText1 && selectorTest1.test(selectorText1) && Object.each(Element.Styles, function(value1, style1) {
|
|
rule1.style[style1] && !Element.ShortStyles[style1] && (value1 = String(rule1.style[style1]), to1[style1] = /^rgb/.test(value1) ? value1.rgbToHex() : value1);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}), Fx.CSS.Cache[selector1] = to1;
|
|
}
|
|
}), Fx.CSS.Cache = {}, Fx.CSS.Parsers = {
|
|
Color: {
|
|
parse: function(value1) {
|
|
return value1.match(/^#[0-9a-f]{3,6}$/i) ? value1.hexToRgb(!0) : !!(value1 = value1.match(/(\d+),\s*(\d+),\s*(\d+)/)) && [
|
|
value1[1],
|
|
value1[2],
|
|
value1[3]
|
|
];
|
|
},
|
|
compute: function(from1, to1, delta1) {
|
|
return from1.map(function(value1, i1) {
|
|
return Math.round(Fx.compute(from1[i1], to1[i1], delta1));
|
|
});
|
|
},
|
|
serve: function(value1) {
|
|
return value1.map(Number);
|
|
}
|
|
},
|
|
Number: {
|
|
parse: parseFloat,
|
|
compute: Fx.compute,
|
|
serve: function(value1, unit1) {
|
|
return unit1 ? value1 + unit1 : value1;
|
|
}
|
|
},
|
|
String: {
|
|
parse: Function.from(!1),
|
|
compute: function(zero1, one1) {
|
|
return one1;
|
|
},
|
|
serve: function(zero1) {
|
|
return zero1;
|
|
}
|
|
}
|
|
}, Fx.CSS.Parsers = new Hash(Fx.CSS.Parsers), Fx.Tween = new Class({
|
|
Extends: Fx.CSS,
|
|
initialize: function(element1, options1) {
|
|
this.element = this.subject = document.id(element1), this.parent(options1);
|
|
},
|
|
set: function(property1, now1) {
|
|
return 1 == arguments.length && (now1 = property1, property1 = this.property || this.options.property), this.render(this.element, property1, now1, this.options.unit), this;
|
|
},
|
|
start: function(property1, from1, to1) {
|
|
if (!this.check(property1, from1, to1)) return this;
|
|
var args1 = Array.flatten(arguments);
|
|
this.property = this.options.property || args1.shift();
|
|
var parsed1 = this.prepare(this.element, this.property, args1);
|
|
return this.parent(parsed1.from, parsed1.to);
|
|
}
|
|
}), Element.Properties.tween = {
|
|
set: function(options1) {
|
|
return this.get("tween").cancel().setOptions(options1), this;
|
|
},
|
|
get: function() {
|
|
var tween1 = this.retrieve("tween");
|
|
return tween1 || (tween1 = new Fx.Tween(this, {
|
|
link: "cancel"
|
|
}), this.store("tween", tween1)), tween1;
|
|
}
|
|
}, Element.implement({
|
|
tween: function(property1, from1, to1) {
|
|
return this.get("tween").start(property1, from1, to1), this;
|
|
},
|
|
fade: function(how1) {
|
|
var method1, toggle1, fade1 = this.get("tween"), args1 = [
|
|
"opacity"
|
|
].append(arguments);
|
|
switch(null == args1[1] && (args1[1] = "toggle"), args1[1]){
|
|
case "in":
|
|
method1 = "start", args1[1] = 1;
|
|
break;
|
|
case "out":
|
|
method1 = "start", args1[1] = 0;
|
|
break;
|
|
case "show":
|
|
method1 = "set", args1[1] = 1;
|
|
break;
|
|
case "hide":
|
|
method1 = "set", args1[1] = 0;
|
|
break;
|
|
case "toggle":
|
|
var flag1 = this.retrieve("fade:flag", 1 == this.getStyle("opacity"));
|
|
method1 = "start", args1[1] = flag1 ? 0 : 1, this.store("fade:flag", !flag1), toggle1 = !0;
|
|
break;
|
|
default:
|
|
method1 = "start";
|
|
}
|
|
toggle1 || this.eliminate("fade:flag"), fade1[method1].apply(fade1, args1);
|
|
var to1 = args1[args1.length - 1];
|
|
return "set" == method1 || 0 != to1 ? this.setStyle("visibility", 0 == to1 ? "hidden" : "visible") : fade1.chain(function() {
|
|
this.element.setStyle("visibility", "hidden"), this.callChain();
|
|
}), this;
|
|
},
|
|
highlight: function(start1, end1) {
|
|
end1 || (end1 = "transparent" == (end1 = this.retrieve("highlight:original", this.getStyle("background-color"))) ? "#fff" : end1);
|
|
var tween1 = this.get("tween");
|
|
return tween1.start("background-color", start1 || "#ffff88", end1).chain((function() {
|
|
this.setStyle("background-color", this.retrieve("highlight:original")), tween1.callChain();
|
|
}).bind(this)), this;
|
|
}
|
|
}), Fx.Morph = new Class({
|
|
Extends: Fx.CSS,
|
|
initialize: function(element1, options1) {
|
|
this.element = this.subject = document.id(element1), this.parent(options1);
|
|
},
|
|
set: function(now1) {
|
|
for(var p1 in "string" == typeof now1 && (now1 = this.search(now1)), now1)this.render(this.element, p1, now1[p1], this.options.unit);
|
|
return this;
|
|
},
|
|
compute: function(from1, to1, delta1) {
|
|
var now1 = {};
|
|
for(var p1 in from1)now1[p1] = this.parent(from1[p1], to1[p1], delta1);
|
|
return now1;
|
|
},
|
|
start: function(properties1) {
|
|
if (!this.check(properties1)) return this;
|
|
"string" == typeof properties1 && (properties1 = this.search(properties1));
|
|
var from1 = {}, to1 = {};
|
|
for(var p1 in properties1){
|
|
var parsed1 = this.prepare(this.element, p1, properties1[p1]);
|
|
from1[p1] = parsed1.from, to1[p1] = parsed1.to;
|
|
}
|
|
return this.parent(from1, to1);
|
|
}
|
|
}), Element.Properties.morph = {
|
|
set: function(options1) {
|
|
return this.get("morph").cancel().setOptions(options1), this;
|
|
},
|
|
get: function() {
|
|
var morph1 = this.retrieve("morph");
|
|
return morph1 || (morph1 = new Fx.Morph(this, {
|
|
link: "cancel"
|
|
}), this.store("morph", morph1)), morph1;
|
|
}
|
|
}, Element.implement({
|
|
morph: function(props1) {
|
|
return this.get("morph").start(props1), this;
|
|
}
|
|
}), Fx.implement({
|
|
getTransition: function() {
|
|
var trans1 = this.options.transition || Fx.Transitions.Sine.easeInOut;
|
|
if ("string" == typeof trans1) {
|
|
var data1 = trans1.split(":");
|
|
trans1 = (trans1 = Fx.Transitions)[data1[0]] || trans1[data1[0].capitalize()], data1[1] && (trans1 = trans1["ease" + data1[1].capitalize() + (data1[2] ? data1[2].capitalize() : "")]);
|
|
}
|
|
return trans1;
|
|
}
|
|
}), Fx.Transition = function(transition1, params1) {
|
|
params1 = Array.from(params1);
|
|
var easeIn1 = function(pos1) {
|
|
return transition1(pos1, params1);
|
|
};
|
|
return Object.append(easeIn1, {
|
|
easeIn: easeIn1,
|
|
easeOut: function(pos1) {
|
|
return 1 - transition1(1 - pos1, params1);
|
|
},
|
|
easeInOut: function(pos1) {
|
|
return (pos1 <= 0.5 ? transition1(2 * pos1, params1) : 2 - transition1(2 * (1 - pos1), params1)) / 2;
|
|
}
|
|
});
|
|
}, Fx.Transitions = {
|
|
linear: function(zero1) {
|
|
return zero1;
|
|
}
|
|
}, Fx.Transitions = new Hash(Fx.Transitions), Fx.Transitions.extend = function(transitions1) {
|
|
for(var transition1 in transitions1)Fx.Transitions[transition1] = new Fx.Transition(transitions1[transition1]);
|
|
}, Fx.Transitions.extend({
|
|
Pow: function(p1, x1) {
|
|
return Math.pow(p1, x1 && x1[0] || 6);
|
|
},
|
|
Expo: function(p1) {
|
|
return Math.pow(2, 8 * (p1 - 1));
|
|
},
|
|
Circ: function(p1) {
|
|
return 1 - Math.sin(Math.acos(p1));
|
|
},
|
|
Sine: function(p1) {
|
|
return 1 - Math.cos(p1 * Math.PI / 2);
|
|
},
|
|
Back: function(p1, x1) {
|
|
return Math.pow(p1, 2) * (((x1 = x1 && x1[0] || 1.618) + 1) * p1 - x1);
|
|
},
|
|
Bounce: function(p1) {
|
|
for(var value1, a1 = 0, b1 = 1;; a1 += b1, b1 /= 2)if (p1 >= (7 - 4 * a1) / 11) {
|
|
value1 = b1 * b1 - Math.pow((11 - 6 * a1 - 11 * p1) / 4, 2);
|
|
break;
|
|
}
|
|
return value1;
|
|
},
|
|
Elastic: function(p1, x1) {
|
|
return Math.pow(2, 10 * --p1) * Math.cos(20 * p1 * Math.PI * (x1 && x1[0] || 1) / 3);
|
|
}
|
|
}), [
|
|
"Quad",
|
|
"Cubic",
|
|
"Quart",
|
|
"Quint"
|
|
].each(function(transition1, i1) {
|
|
Fx.Transitions[transition1] = new Fx.Transition(function(p1) {
|
|
return Math.pow(p1, i1 + 2);
|
|
});
|
|
}), function() {
|
|
var empty1 = function() {}, progressSupport1 = "onprogress" in new Browser.Request(), Request1 = this.Request = new Class({
|
|
Implements: [
|
|
Chain,
|
|
Events,
|
|
Options
|
|
],
|
|
options: {
|
|
url: "",
|
|
data: "",
|
|
headers: {
|
|
"X-Requested-With": "XMLHttpRequest",
|
|
Accept: "text/javascript, text/html, application/xml, text/xml, */*"
|
|
},
|
|
async: !0,
|
|
format: !1,
|
|
method: "post",
|
|
link: "ignore",
|
|
isSuccess: null,
|
|
emulation: !0,
|
|
urlEncoded: !0,
|
|
encoding: "utf-8",
|
|
evalScripts: !1,
|
|
evalResponse: !1,
|
|
timeout: 0,
|
|
noCache: !1
|
|
},
|
|
initialize: function(options1) {
|
|
this.xhr = new Browser.Request(), this.setOptions(options1), this.headers = this.options.headers;
|
|
},
|
|
onStateChange: function() {
|
|
var xhr1 = this.xhr;
|
|
4 == xhr1.readyState && this.running && (this.running = !1, this.status = 0, Function.attempt((function() {
|
|
var status1 = xhr1.status;
|
|
this.status = 1223 == status1 ? 204 : status1;
|
|
}).bind(this)), xhr1.onreadystatechange = empty1, progressSupport1 && (xhr1.onprogress = xhr1.onloadstart = empty1), clearTimeout(this.timer), this.response = {
|
|
text: this.xhr.responseText || "",
|
|
xml: this.xhr.responseXML
|
|
}, this.options.isSuccess.call(this, this.status) ? this.success(this.response.text, this.response.xml) : this.failure());
|
|
},
|
|
isSuccess: function() {
|
|
var status1 = this.status;
|
|
return status1 >= 200 && status1 < 300;
|
|
},
|
|
isRunning: function() {
|
|
return !!this.running;
|
|
},
|
|
processScripts: function(text1) {
|
|
return this.options.evalResponse || /(ecma|java)script/.test(this.getHeader("Content-type")) ? Browser.exec(text1) : text1.stripScripts(this.options.evalScripts);
|
|
},
|
|
success: function(text1, xml1) {
|
|
this.onSuccess(this.processScripts(text1), xml1);
|
|
},
|
|
onSuccess: function() {
|
|
this.fireEvent("complete", arguments).fireEvent("success", arguments).callChain();
|
|
},
|
|
failure: function() {
|
|
this.onFailure();
|
|
},
|
|
onFailure: function() {
|
|
this.fireEvent("complete").fireEvent("failure", this.xhr);
|
|
},
|
|
loadstart: function(event1) {
|
|
this.fireEvent("loadstart", [
|
|
event1,
|
|
this.xhr
|
|
]);
|
|
},
|
|
progress: function(event1) {
|
|
this.fireEvent("progress", [
|
|
event1,
|
|
this.xhr
|
|
]);
|
|
},
|
|
timeout: function() {
|
|
this.fireEvent("timeout", this.xhr);
|
|
},
|
|
setHeader: function(name1, value1) {
|
|
return this.headers[name1] = value1, this;
|
|
},
|
|
getHeader: function(name1) {
|
|
return Function.attempt((function() {
|
|
return this.xhr.getResponseHeader(name1);
|
|
}).bind(this));
|
|
},
|
|
check: function() {
|
|
if (!this.running) return !0;
|
|
switch(this.options.link){
|
|
case "cancel":
|
|
return this.cancel(), !0;
|
|
case "chain":
|
|
this.chain(this.caller.pass(arguments, this));
|
|
}
|
|
return !1;
|
|
},
|
|
send: function(options1) {
|
|
if (!this.check(options1)) return this;
|
|
this.options.isSuccess = this.options.isSuccess || this.isSuccess, this.running = !0;
|
|
var type1 = typeOf(options1);
|
|
("string" == type1 || "element" == type1) && (options1 = {
|
|
data: options1
|
|
});
|
|
var old1 = this.options, data1 = (options1 = Object.append({
|
|
data: old1.data,
|
|
url: old1.url,
|
|
method: old1.method
|
|
}, options1)).data, url1 = String(options1.url), method1 = options1.method.toLowerCase();
|
|
switch(typeOf(data1)){
|
|
case "element":
|
|
data1 = document.id(data1).toQueryString();
|
|
break;
|
|
case "object":
|
|
case "hash":
|
|
data1 = Object.toQueryString(data1);
|
|
}
|
|
if (this.options.format) {
|
|
var format1 = "format=" + this.options.format;
|
|
data1 = data1 ? format1 + "&" + data1 : format1;
|
|
}
|
|
if (this.options.emulation && ![
|
|
"get",
|
|
"post"
|
|
].contains(method1)) {
|
|
var _method1 = "_method=" + method1;
|
|
data1 = data1 ? _method1 + "&" + data1 : _method1, method1 = "post";
|
|
}
|
|
if (this.options.urlEncoded && [
|
|
"post",
|
|
"put"
|
|
].contains(method1)) {
|
|
var encoding1 = this.options.encoding ? "; charset=" + this.options.encoding : "";
|
|
this.headers["Content-type"] = "application/x-www-form-urlencoded" + encoding1;
|
|
}
|
|
url1 || (url1 = document.location.pathname);
|
|
var trimPosition1 = url1.lastIndexOf("/");
|
|
trimPosition1 > -1 && (trimPosition1 = url1.indexOf("#")) > -1 && (url1 = url1.substr(0, trimPosition1)), this.options.noCache && (url1 += (url1.contains("?") ? "&" : "?") + String.uniqueID()), data1 && "get" == method1 && (url1 += (url1.contains("?") ? "&" : "?") + data1, data1 = null);
|
|
var xhr1 = this.xhr;
|
|
return progressSupport1 && (xhr1.onloadstart = this.loadstart.bind(this), xhr1.onprogress = this.progress.bind(this)), xhr1.open(method1.toUpperCase(), url1, this.options.async, this.options.user, this.options.password), this.options.user && "withCredentials" in xhr1 && (xhr1.withCredentials = !0), xhr1.onreadystatechange = this.onStateChange.bind(this), Object.each(this.headers, function(value1, key1) {
|
|
try {
|
|
xhr1.setRequestHeader(key1, value1);
|
|
} catch (e1) {
|
|
this.fireEvent("exception", [
|
|
key1,
|
|
value1
|
|
]);
|
|
}
|
|
}, this), this.fireEvent("request"), xhr1.send(data1), this.options.async ? this.options.timeout && (this.timer = this.timeout.delay(this.options.timeout, this)) : this.onStateChange(), this;
|
|
},
|
|
cancel: function() {
|
|
if (!this.running) return this;
|
|
this.running = !1;
|
|
var xhr1 = this.xhr;
|
|
return xhr1.abort(), clearTimeout(this.timer), xhr1.onreadystatechange = empty1, progressSupport1 && (xhr1.onprogress = xhr1.onloadstart = empty1), this.xhr = new Browser.Request(), this.fireEvent("cancel"), this;
|
|
}
|
|
}), methods1 = {};
|
|
[
|
|
"get",
|
|
"post",
|
|
"put",
|
|
"delete",
|
|
"GET",
|
|
"POST",
|
|
"PUT",
|
|
"DELETE"
|
|
].each(function(method1) {
|
|
methods1[method1] = function(data1) {
|
|
var object1 = {
|
|
method: method1
|
|
};
|
|
return null != data1 && (object1.data = data1), this.send(object1);
|
|
};
|
|
}), Request1.implement(methods1), Element.Properties.send = {
|
|
set: function(options1) {
|
|
return this.get("send").cancel().setOptions(options1), this;
|
|
},
|
|
get: function() {
|
|
var send1 = this.retrieve("send");
|
|
return send1 || (send1 = new Request1({
|
|
data: this,
|
|
link: "cancel",
|
|
method: this.get("method") || "post",
|
|
url: this.get("action")
|
|
}), this.store("send", send1)), send1;
|
|
}
|
|
}, Element.implement({
|
|
send: function(url1) {
|
|
var sender1 = this.get("send");
|
|
return sender1.send({
|
|
data: this,
|
|
url: url1 || sender1.options.url
|
|
}), this;
|
|
}
|
|
});
|
|
}(), Request.HTML = new Class({
|
|
Extends: Request,
|
|
options: {
|
|
update: !1,
|
|
append: !1,
|
|
evalScripts: !0,
|
|
filter: !1,
|
|
headers: {
|
|
Accept: "text/html, application/xml, text/xml, */*"
|
|
}
|
|
},
|
|
success: function(text1) {
|
|
var options1 = this.options, response1 = this.response;
|
|
response1.html = text1.stripScripts(function(script1) {
|
|
response1.javascript = script1;
|
|
});
|
|
var match1 = response1.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
|
|
match1 && (response1.html = match1[1]);
|
|
var temp1 = new Element("div").set("html", response1.html);
|
|
if (response1.tree = temp1.childNodes, response1.elements = temp1.getElements(options1.filter || "*"), options1.filter && (response1.tree = response1.elements), options1.update) {
|
|
var update1 = document.id(options1.update).empty();
|
|
options1.filter ? update1.adopt(response1.elements) : update1.set("html", response1.html);
|
|
} else if (options1.append) {
|
|
var append1 = document.id(options1.append);
|
|
options1.filter ? response1.elements.reverse().inject(append1) : append1.adopt(temp1.getChildren());
|
|
}
|
|
options1.evalScripts && Browser.exec(response1.javascript), this.onSuccess(response1.tree, response1.elements, response1.html, response1.javascript);
|
|
}
|
|
}), Element.Properties.load = {
|
|
set: function(options1) {
|
|
return this.get("load").cancel().setOptions(options1), this;
|
|
},
|
|
get: function() {
|
|
var load1 = this.retrieve("load");
|
|
return load1 || (load1 = new Request.HTML({
|
|
data: this,
|
|
link: "cancel",
|
|
update: this,
|
|
method: "get"
|
|
}), this.store("load", load1)), load1;
|
|
}
|
|
}, Element.implement({
|
|
load: function() {
|
|
return this.get("load").send(Array.link(arguments, {
|
|
data: Type.isObject,
|
|
url: Type.isString
|
|
})), this;
|
|
}
|
|
}), "undefined" == typeof JSON && (this.JSON = {}), JSON = new Hash({
|
|
stringify: JSON.stringify,
|
|
parse: JSON.parse
|
|
}), function() {
|
|
var special = {
|
|
"\b": "\\b",
|
|
"\t": "\\t",
|
|
"\n": "\\n",
|
|
"\f": "\\f",
|
|
"\r": "\\r",
|
|
'"': '\\"',
|
|
"\\": "\\\\"
|
|
}, escape = function(chr1) {
|
|
return special[chr1] || "\\u" + ("0000" + chr1.charCodeAt(0).toString(16)).slice(-4);
|
|
};
|
|
JSON.validate = function(string1) {
|
|
return string1 = string1.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]").replace(/(?:^|:|,)(?:\s*\[)+/g, ""), /^[\],:{}\s]*$/.test(string1);
|
|
}, JSON.encode = JSON.stringify ? function(obj1) {
|
|
return JSON.stringify(obj1);
|
|
} : function(obj1) {
|
|
switch(obj1 && obj1.toJSON && (obj1 = obj1.toJSON()), typeOf(obj1)){
|
|
case "string":
|
|
return '"' + obj1.replace(/[\x00-\x1f\\"]/g, escape) + '"';
|
|
case "array":
|
|
return "[" + obj1.map(JSON.encode).clean() + "]";
|
|
case "object":
|
|
case "hash":
|
|
var string1 = [];
|
|
return Object.each(obj1, function(value1, key1) {
|
|
var json1 = JSON.encode(value1);
|
|
json1 && string1.push(JSON.encode(key1) + ":" + json1);
|
|
}), "{" + string1 + "}";
|
|
case "number":
|
|
case "boolean":
|
|
return "" + obj1;
|
|
case "null":
|
|
return "null";
|
|
}
|
|
return null;
|
|
}, JSON.decode = function(string, secure) {
|
|
if (!string || "string" != typeOf(string)) return null;
|
|
if (secure || JSON.secure) {
|
|
if (JSON.parse) return JSON.parse(string);
|
|
if (!JSON.validate(string)) throw Error("JSON could not decode the input; security is enabled and the value is not secure.");
|
|
}
|
|
return eval("(" + string + ")");
|
|
};
|
|
}(), Request.JSON = new Class({
|
|
Extends: Request,
|
|
options: {
|
|
secure: !0
|
|
},
|
|
initialize: function(options1) {
|
|
this.parent(options1), Object.append(this.headers, {
|
|
Accept: "application/json",
|
|
"X-Request": "JSON"
|
|
});
|
|
},
|
|
success: function(text1) {
|
|
var json1;
|
|
try {
|
|
json1 = this.response.json = JSON.decode(text1, this.options.secure);
|
|
} catch (error1) {
|
|
this.fireEvent("error", [
|
|
text1,
|
|
error1
|
|
]);
|
|
return;
|
|
}
|
|
null == json1 ? this.onFailure() : this.onSuccess(json1, text1);
|
|
}
|
|
});
|
|
var Cookie = new Class({
|
|
Implements: Options,
|
|
options: {
|
|
path: "/",
|
|
domain: !1,
|
|
duration: !1,
|
|
secure: !1,
|
|
document: document,
|
|
encode: !0
|
|
},
|
|
initialize: function(key1, options1) {
|
|
this.key = key1, this.setOptions(options1);
|
|
},
|
|
write: function(value1) {
|
|
if (this.options.encode && (value1 = encodeURIComponent(value1)), this.options.domain && (value1 += "; domain=" + this.options.domain), this.options.path && (value1 += "; path=" + this.options.path), this.options.duration) {
|
|
var date1 = new Date();
|
|
date1.setTime(date1.getTime() + 86400000 * this.options.duration), value1 += "; expires=" + date1.toGMTString();
|
|
}
|
|
return this.options.secure && (value1 += "; secure"), this.options.document.cookie = this.key + "=" + value1, this;
|
|
},
|
|
read: function() {
|
|
var value1 = this.options.document.cookie.match("(?:^|;)\\s*" + this.key.escapeRegExp() + "=([^;]*)");
|
|
return value1 ? decodeURIComponent(value1[1]) : null;
|
|
},
|
|
dispose: function() {
|
|
return new Cookie(this.key, Object.merge({}, this.options, {
|
|
duration: -1
|
|
})).write(""), this;
|
|
}
|
|
});
|
|
Cookie.write = function(key1, value1, options1) {
|
|
return new Cookie(key1, options1).write(value1);
|
|
}, Cookie.read = function(key1) {
|
|
return new Cookie(key1).read();
|
|
}, Cookie.dispose = function(key1, options1) {
|
|
return new Cookie(key1, options1).dispose();
|
|
}, function(window1, document1) {
|
|
var ready1, loaded1, shouldPoll1, timer1, checks1 = [], testElement1 = document1.createElement("div"), domready1 = function() {
|
|
clearTimeout(timer1), ready1 || (Browser.loaded = ready1 = !0, document1.removeListener("DOMContentLoaded", domready1).removeListener("readystatechange", check1), document1.fireEvent("domready"), window1.fireEvent("domready"));
|
|
}, check1 = function() {
|
|
for(var i1 = checks1.length; i1--;)if (checks1[i1]()) return domready1(), !0;
|
|
return !1;
|
|
}, poll1 = function() {
|
|
clearTimeout(timer1), check1() || (timer1 = setTimeout(poll1, 10));
|
|
};
|
|
document1.addListener("DOMContentLoaded", domready1);
|
|
var doScrollWorks1 = function() {
|
|
try {
|
|
return testElement1.doScroll(), !0;
|
|
} catch (e1) {}
|
|
return !1;
|
|
};
|
|
testElement1.doScroll && !doScrollWorks1() && (checks1.push(doScrollWorks1), shouldPoll1 = !0), document1.readyState && checks1.push(function() {
|
|
var state1 = document1.readyState;
|
|
return "loaded" == state1 || "complete" == state1;
|
|
}), "onreadystatechange" in document1 ? document1.addListener("readystatechange", check1) : shouldPoll1 = !0, shouldPoll1 && poll1(), Element.Events.domready = {
|
|
onAdd: function(fn1) {
|
|
ready1 && fn1.call(this);
|
|
}
|
|
}, Element.Events.load = {
|
|
base: "load",
|
|
onAdd: function(fn1) {
|
|
loaded1 && this == window1 && fn1.call(this);
|
|
},
|
|
condition: function() {
|
|
return this == window1 && (domready1(), delete Element.Events.load), !0;
|
|
}
|
|
}, window1.addEvent("load", function() {
|
|
loaded1 = !0;
|
|
});
|
|
}(window, document), function() {
|
|
var Swiff = this.Swiff = new Class({
|
|
Implements: Options,
|
|
options: {
|
|
id: null,
|
|
height: 1,
|
|
width: 1,
|
|
container: null,
|
|
properties: {},
|
|
params: {
|
|
quality: "high",
|
|
allowScriptAccess: "always",
|
|
wMode: "window",
|
|
swLiveConnect: !0
|
|
},
|
|
callBacks: {},
|
|
vars: {}
|
|
},
|
|
toElement: function() {
|
|
return this.object;
|
|
},
|
|
initialize: function(path1, options1) {
|
|
this.instance = "Swiff_" + String.uniqueID(), this.setOptions(options1), options1 = this.options;
|
|
var id1 = this.id = options1.id || this.instance, container1 = document.id(options1.container);
|
|
Swiff.CallBacks[this.instance] = {};
|
|
var params1 = options1.params, vars1 = options1.vars, callBacks1 = options1.callBacks, properties1 = Object.append({
|
|
height: options1.height,
|
|
width: options1.width
|
|
}, options1.properties), self1 = this;
|
|
for(var callBack1 in callBacks1)Swiff.CallBacks[this.instance][callBack1] = function(option1) {
|
|
return function() {
|
|
return option1.apply(self1.object, arguments);
|
|
};
|
|
}(callBacks1[callBack1]), vars1[callBack1] = "Swiff.CallBacks." + this.instance + "." + callBack1;
|
|
params1.flashVars = Object.toQueryString(vars1), Browser.ie ? (properties1.classid = "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", params1.movie = path1) : properties1.type = "application/x-shockwave-flash", properties1.data = path1;
|
|
var build1 = '<object id="' + id1 + '"';
|
|
for(var property1 in properties1)build1 += " " + property1 + '="' + properties1[property1] + '"';
|
|
for(var param1 in build1 += ">", params1)params1[param1] && (build1 += '<param name="' + param1 + '" value="' + params1[param1] + '" />');
|
|
build1 += "</object>", this.object = (container1 ? container1.empty() : new Element("div")).set("html", build1).firstChild;
|
|
},
|
|
replaces: function(element1) {
|
|
return (element1 = document.id(element1, !0)).parentNode.replaceChild(this.toElement(), element1), this;
|
|
},
|
|
inject: function(element1) {
|
|
return document.id(element1, !0).appendChild(this.toElement()), this;
|
|
},
|
|
remote: function() {
|
|
return Swiff.remote.apply(Swiff, [
|
|
this.toElement()
|
|
].append(arguments));
|
|
}
|
|
});
|
|
Swiff.CallBacks = {}, Swiff.remote = function(obj, fn) {
|
|
var rs = obj.CallFunction('<invoke name="' + fn + '" returntype="javascript">' + __flash__argumentsToXML(arguments, 2) + "</invoke>");
|
|
return eval(rs);
|
|
};
|
|
}();
|