swc-project/swc
1
1
Fork 0
mirror of https://github.com/swc-project/swc.git synced 2024-12-24 06:05:02 +03:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
4f23d651d1
swc/crates/swc_ecma_minifier/tests/projects/refs/mootools-1.4.5.js
Donny/강동윤 2b2f6955f2
refactor: Flatten ecmascript (#2708)
2021-11-10 19:00:54 +09:00

10631 lines
296 KiB
JavaScript
Raw Blame History

!(function (
) {
this.MooTools = {
version: "1.4.5",
build: "ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0",
};
var typeOf = (this.typeOf = function (
item
) {
if (null == item) return "null";
if (null != item.$family) return item.$family(
);
if (item.nodeName) {
if (1 == item.nodeType) return "element";
if (3 == item.nodeType)
return /\S/.test(
item.nodeValue
)
? "textnode"
: "whitespace";
} else if ("number" == typeof item.length) {
if (item.callee) return "arguments";
if ("item" in item) return "collection";
}
return typeof item;
}),
instanceOf = (this.instanceOf = function (
item, object
) {
if (null == item) return !1;
for (
var constructor = item.$constructor || item.constructor;
constructor;
) {
if (constructor === object) return !0;
constructor = constructor.parent;
}
return !!item.hasOwnProperty && item instanceof object;
}),
Function = this.Function,
enumerables = !0;
for (var i in {
toString: 1,
}) enumerables = null;
enumerables &&
(enumerables = [
"hasOwnProperty",
"valueOf",
"isPrototypeOf",
"propertyIsEnumerable",
"toLocaleString",
"toString",
"constructor",
]),
(Function.prototype.overloadSetter = function (
usePlural
) {
var self = this;
return function (
a, b
) {
if (null == a) return this;
if (usePlural || "string" != typeof a) {
for (var k in a) self.call(
this,
k,
a[k]
);
if (enumerables)
for (var i = enumerables.length; i--; )
(k = enumerables[i]),
a.hasOwnProperty(
k
) && self.call(
this,
k,
a[k]
);
} else self.call(
this,
a,
b
);
return this;
};
}),
(Function.prototype.overloadGetter = function (
usePlural
) {
var self = this;
return function (
a
) {
var args, result;
if (
("string" != typeof a
? (args = a)
: arguments.length > 1
? (args = arguments)
: usePlural && (args = [a,]),
args)
) {
result = {
};
for (var i = 0; i < args.length; i++)
result[args[i]] = self.call(
this,
args[i]
);
} else result = self.call(
this,
a
);
return result;
};
}),
(Function.prototype.extend = function (
key, value
) {
this[key] = value;
}.overloadSetter(
)),
(Function.prototype.implement = function (
key, value
) {
this.prototype[key] = value;
}.overloadSetter(
));
var slice = Array.prototype.slice;
(Function.from = function (
item
) {
return "function" == typeOf(
item
)
? item
: function (
) {
return item;
};
}),
(Array.from = function (
item
) {
return null == item
? []
: Type.isEnumerable(
item
) && "string" != typeof item
? "array" == typeOf(
item
)
? item
: slice.call(
item
)
: [item,];
}),
(Number.from = function (
item
) {
var number = parseFloat(
item
);
return isFinite(
number
)
? number
: null;
}),
(String.from = function (
item
) {
return item + "";
}),
Function.implement(
{
hide: function (
) {
return (this.$hidden = !0), this;
},
protect: function (
) {
return (this.$protected = !0), this;
},
}
);
var Type = (this.Type = function (
name, object
) {
if (name) {
var lower = name.toLowerCase(
),
typeCheck = function (
item
) {
return typeOf(
item
) == lower;
};
(Type["is" + name] = typeCheck),
null != object &&
((object.prototype.$family = function (
) {
return lower;
}.hide(
)),
(object.type = typeCheck));
}
return null == object
? null
: (object.extend(
this
),
(object.$constructor = Type),
(object.prototype.$constructor = object),
object);
}),
toString = Object.prototype.toString;
Type.isEnumerable = function (
item
) {
return (
null != item &&
"number" == typeof item.length &&
"[object Function]" != toString.call(
item
)
);
};
var hooks = {
},
hooksOf = function (
object
) {
var type = typeOf(
object.prototype
);
return hooks[type] || (hooks[type] = []);
},
implement = function (
name, method
) {
if (!method || !method.$hidden) {
for (var hooks = hooksOf(
this
), i = 0; i < hooks.length; i++) {
var hook = hooks[i];
"type" == typeOf(
hook
)
? implement.call(
hook,
name,
method
)
: hook.call(
this,
name,
method
);
}
var previous = this.prototype[name];
(null != previous && previous.$protected) ||
(this.prototype[name] = method),
null == this[name] &&
"function" == typeOf(
method
) &&
extend.call(
this,
name,
function (
item
) {
return method.apply(
item,
slice.call(
arguments,
1
)
);
}
);
}
},
extend = function (
name, method
) {
if (!method || !method.$hidden) {
var previous = this[name];
(null != previous && previous.$protected) || (this[name] = method);
}
};
Type.implement(
{
implement: implement.overloadSetter(
),
extend: extend.overloadSetter(
),
alias: function (
name, existing
) {
implement.call(
this,
name,
this.prototype[existing]
);
}.overloadSetter(
),
mirror: function (
hook
) {
return hooksOf(
this
).push(
hook
), this;
},
}
),
new Type(
"Type",
Type
);
var force = function (
name, object, methods
) {
var isType = object != Object,
prototype = object.prototype;
isType && (object = new Type(
name,
object
));
for (var i = 0, l = methods.length; i < l; i++) {
var key = methods[i],
generic = object[key],
proto = prototype[key];
generic && generic.protect(
),
isType && proto && object.implement(
key,
proto.protect(
)
);
}
if (isType) {
var methodsEnumerable = prototype.propertyIsEnumerable(
methods[0]
);
object.forEachMethod = function (
fn
) {
if (!methodsEnumerable)
for (var i = 0, l = methods.length; i < l; i++)
fn.call(
prototype,
prototype[methods[i]],
methods[i]
);
for (var key in prototype) fn.call(
prototype,
prototype[key],
key
);
};
}
return force;
};
force(
"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",
Function,
["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 = extend.overloadSetter(
)),
Date.extend(
"now",
function (
) {
return +new Date(
);
}
),
new Type(
"Boolean",
Boolean
),
(Number.prototype.$family = function (
) {
return isFinite(
this
)
? "number"
: "null";
}.hide(
)),
Number.extend(
"random",
function (
min, max
) {
return Math.floor(
Math.random(
) * (max - min + 1) + min
);
}
);
var hasOwnProperty = Object.prototype.hasOwnProperty;
Object.extend(
"forEach",
function (
object, fn, bind
) {
for (var key in object)
hasOwnProperty.call(
object,
key
) &&
fn.call(
bind,
object[key],
key,
object
);
}
),
(Object.each = Object.forEach),
Array.implement(
{
forEach: function (
fn, bind
) {
for (var i = 0, l = this.length; i < l; i++)
i in this && fn.call(
bind,
this[i],
i,
this
);
},
each: function (
fn, bind
) {
return Array.forEach(
this,
fn,
bind
), this;
},
}
);
var cloneOf = function (
item
) {
switch (typeOf(
item
)) {
case "array":
return item.clone(
);
case "object":
return Object.clone(
item
);
default:
return item;
}
};
Array.implement(
"clone",
function (
) {
for (var i = this.length, clone = new Array(
i
); i--; )
clone[i] = cloneOf(
this[i]
);
return clone;
}
);
var mergeOne = function (
source, key, current
) {
switch (typeOf(
current
)) {
case "object":
"object" == typeOf(
source[key]
)
? Object.merge(
source[key],
current
)
: (source[key] = Object.clone(
current
));
break;
case "array":
source[key] = current.clone(
);
break;
default:
source[key] = current;
}
return source;
};
Object.extend(
{
merge: function (
source, k, v
) {
if ("string" == typeOf(
k
)) return mergeOne(
source,
k,
v
);
for (var i = 1, l = arguments.length; i < l; i++) {
var object = arguments[i];
for (var key in object) mergeOne(
source,
key,
object[key]
);
}
return source;
},
clone: function (
object
) {
var clone = {
};
for (var key in object) clone[key] = cloneOf(
object[key]
);
return clone;
},
append: function (
original
) {
for (var i = 1, l = arguments.length; i < l; i++) {
var extended = arguments[i] || {
};
for (var key in extended) original[key] = extended[key];
}
return original;
},
}
),
["Object", "WhiteSpace", "TextNode", "Collection", "Arguments",].each(
function (
name
) {
new Type(
name
);
},
);
var UID = Date.now(
);
String.extend(
"uniqueID",
function (
) {
return (UID++).toString(
36
);
}
);
var Hash = (this.Hash = new Type(
"Hash",
function (
object
) {
for (var key in ("hash" == typeOf(
object
) &&
(object = Object.clone(
object.getClean(
)
)),
object))
this[key] = object[key];
return this;
}
));
Hash.implement(
{
forEach: function (
fn, bind
) {
Object.forEach(
this,
fn,
bind
);
},
getClean: function (
) {
var clean = {
};
for (var key in this)
this.hasOwnProperty(
key
) && (clean[key] = this[key]);
return clean;
},
getLength: function (
) {
var length = 0;
for (var key in this) this.hasOwnProperty(
key
) && length++;
return length;
},
}
),
Hash.alias(
"each",
"forEach"
),
(Object.type = Type.isObject);
var Native = (this.Native = function (
properties
) {
return new Type(
properties.name,
properties.initialize
);
});
(Native.type = Type.type),
(Native.implement = function (
objects, methods
) {
for (var i = 0; i < objects.length; i++) objects[i].implement(
methods
);
return Native;
});
var arrayType = Array.type;
(Array.type = function (
item
) {
return instanceOf(
item,
Array
) || arrayType(
item
);
}),
(this.$A = function (
item
) {
return Array.from(
item
).slice(
);
}),
(this.$arguments = function (
i
) {
return function (
) {
return arguments[i];
};
}),
(this.$chk = function (
obj
) {
return !(!obj && 0 !== obj);
}),
(this.$clear = function (
timer
) {
return clearTimeout(
timer
), clearInterval(
timer
), null;
}),
(this.$defined = function (
obj
) {
return null != obj;
}),
(this.$each = function (
iterable, fn, bind
) {
var type = typeOf(
iterable
);
("arguments" == type ||
"collection" == type ||
"array" == type ||
"elements" == type
? Array
: Object
).each(
iterable,
fn,
bind
);
}),
(this.$empty = function (
) {}),
(this.$extend = function (
original, extended
) {
return Object.append(
original,
extended
);
}),
(this.$H = function (
object
) {
return new Hash(
object
);
}),
(this.$merge = function (
) {
var args = Array.slice(
arguments
);
return args.unshift(
{
}
), Object.merge.apply(
null,
args
);
}),
(this.$lambda = Function.from),
(this.$mixin = Object.merge),
(this.$random = Number.random),
(this.$splat = Array.from),
(this.$time = Date.now),
(this.$type = function (
object
) {
var type = typeOf(
object
);
return "elements" == type ? "array" : "null" != type && type;
}),
(this.$unlink = function (
object
) {
switch (typeOf(
object
)) {
case "object":
return Object.clone(
object
);
case "array":
return Array.clone(
object
);
case "hash":
return new Hash(
object
);
default:
return object;
}
});
})(
),
Array.implement(
{
every: function (
fn, bind
) {
for (var i = 0, l = this.length >>> 0; i < l; i++)
if (i in this && !fn.call(
bind,
this[i],
i,
this
)) return !1;
return !0;
},
filter: function (
fn, bind
) {
for (var value, results = [], i = 0, l = this.length >>> 0; i < l; i++)
i in this &&
((value = this[i]),
fn.call(
bind,
value,
i,
this
) && results.push(
value
));
return results;
},
indexOf: function (
item, from
) {
for (
var length = this.length >>> 0,
i = from < 0
? Math.max(
0,
length + from
)
: from || 0;
i < length;
i++
)
if (this[i] === item) return i;
return -1;
},
map: function (
fn, bind
) {
for (
var length = this.length >>> 0, results = Array(
length
), i = 0;
i < length;
i++
)
i in this && (results[i] = fn.call(
bind,
this[i],
i,
this
));
return results;
},
some: function (
fn, bind
) {
for (var i = 0, l = this.length >>> 0; i < l; i++)
if (i in this && fn.call(
bind,
this[i],
i,
this
)) return !0;
return !1;
},
clean: function (
) {
return this.filter(
function (
item
) {
return null != item;
}
);
},
invoke: function (
methodName
) {
var args = Array.slice(
arguments,
1
);
return this.map(
function (
item
) {
return item[methodName].apply(
item,
args
);
}
);
},
associate: function (
keys
) {
for (
var obj = {
}, length = Math.min(
this.length,
keys.length
), i = 0;
i < length;
i++
)
obj[keys[i]] = this[i];
return obj;
},
link: function (
object
) {
for (var result = {
}, i = 0, l = this.length; i < l; i++)
for (var key in object)
if (object[key](
this[i]
)) {
(result[key] = this[i]), delete object[key];
break;
}
return result;
},
contains: function (
item, from
) {
return -1 != this.indexOf(
item,
from
);
},
append: function (
array
) {
return this.push.apply(
this,
array
), 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 (
item
) {
return this.contains(
item
) || this.push(
item
), this;
},
combine: function (
array
) {
for (var i = 0, l = array.length; i < l; i++) this.include(
array[i]
);
return this;
},
erase: function (
item
) {
for (var i = this.length; i--; ) this[i] === item && this.splice(
i,
1
);
return this;
},
empty: function (
) {
return (this.length = 0), this;
},
flatten: function (
) {
for (var array = [], i = 0, l = this.length; i < l; i++) {
var type = typeOf(
this[i]
);
"null" != type &&
(array = array.concat(
"array" == type ||
"collection" == type ||
"arguments" == type ||
instanceOf(
this[i],
Array
)
? Array.flatten(
this[i]
)
: this[i],
));
}
return array;
},
pick: function (
) {
for (var i = 0, l = this.length; i < l; i++)
if (null != this[i]) return this[i];
return null;
},
hexToRgb: function (
array
) {
if (3 != this.length) return null;
var rgb = this.map(
function (
value
) {
return 1 == value.length && (value += value), value.toInt(
16
);
}
);
return array ? rgb : "rgb(" + rgb + ")";
},
rgbToHex: function (
array
) {
if (this.length < 3) return null;
if (4 == this.length && 0 == this[3] && !array) return "transparent";
for (var hex = [], i = 0; i < 3; i++) {
var bit = (this[i] - 0).toString(
16
);
hex.push(
1 == bit.length ? "0" + bit : bit
);
}
return array
? hex
: "#" + hex.join(
""
);
},
}
),
Array.alias(
"extend",
"append"
);
var $pick = function (
) {
return Array.from(
arguments
).pick(
);
};
String.implement(
{
test: function (
regex, params
) {
return ("regexp" == typeOf(
regex
)
? regex
: new RegExp(
"" + regex,
params
)
).test(
this
);
},
contains: function (
string, separator
) {
return separator
? (separator + this + separator).indexOf(
separator + string + separator
) >
-1
: String(
this
).indexOf(
string
) > -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 (
match
) {
return match.charAt(
1
).toUpperCase(
);
}
);
},
hyphenate: function (
) {
return String(
this
).replace(
/[A-Z]/g,
function (
match
) {
return "-" + match.charAt(
0
).toLowerCase(
);
}
);
},
capitalize: function (
) {
return String(
this
).replace(
/\b[a-z]/g,
function (
match
) {
return match.toUpperCase(
);
}
);
},
escapeRegExp: function (
) {
return String(
this
).replace(
/([-.*+?^${}()|[\]\/\\])/g,
"\\$1"
);
},
toInt: function (
base
) {
return parseInt(
this,
base || 10
);
},
toFloat: function (
) {
return parseFloat(
this
);
},
hexToRgb: function (
array
) {
var hex = String(
this
).match(
/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/
);
return hex
? hex.slice(
1
).hexToRgb(
array
)
: null;
},
rgbToHex: function (
array
) {
var rgb = String(
this
).match(
/\d{1,3}/g
);
return rgb
? rgb.rgbToHex(
array
)
: null;
},
substitute: function (
object, regexp
) {
return String(
this
).replace(
regexp || /\\?\{([^{}]+)\}/g,
function (
match, name
) {
return "\\" == match.charAt(
0
)
? match.slice(
1
)
: null != object[name]
? object[name]
: "";
},
);
},
}
),
Number.implement(
{
limit: function (
min, max
) {
return Math.min(
max,
Math.max(
min,
this
)
);
},
round: function (
precision
) {
return (
(precision = Math.pow(
10,
precision || 0
).toFixed(
precision < 0 ? -precision : 0,
)),
Math.round(
this * precision
) / precision
);
},
times: function (
fn, bind
) {
for (var i = 0; i < this; i++) fn.call(
bind,
i,
this
);
},
toFloat: function (
) {
return parseFloat(
this
);
},
toInt: function (
base
) {
return parseInt(
this,
base || 10
);
},
}
),
Number.alias(
"each",
"times"
),
(function (
math
) {
var methods = {
};
[
"abs",
"acos",
"asin",
"atan",
"atan2",
"ceil",
"cos",
"exp",
"floor",
"log",
"max",
"min",
"pow",
"sin",
"sqrt",
"tan",
].each(
function (
name
) {
Number[name] ||
(methods[name] = function (
) {
return Math[name].apply(
null,
[this,].concat(
Array.from(
arguments
)
)
);
});
}
),
Number.implement(
methods
);
})(
),
Function.extend(
{
attempt: function (
) {
for (var i = 0, l = arguments.length; i < l; i++)
try {
return arguments[i](
);
} catch (e) {}
return null;
},
}
),
Function.implement(
{
attempt: function (
args, bind
) {
try {
return this.apply(
bind,
Array.from(
args
)
);
} catch (e) {}
return null;
},
bind: function (
that
) {
var self = this,
args = arguments.length > 1
? Array.slice(
arguments,
1
)
: null,
F = function (
) {},
bound = function (
) {
var context = that,
length = arguments.length;
this instanceof bound &&
((F.prototype = self.prototype), (context = new F(
)));
var result =
args || length
? self.apply(
context,
args && length
? args.concat(
Array.slice(
arguments
)
)
: args || arguments,
)
: self.call(
context
);
return context == that ? result : context;
};
return bound;
},
pass: function (
args, bind
) {
var self = this;
return (
null != args && (args = Array.from(
args
)),
function (
) {
return self.apply(
bind,
args || arguments
);
}
);
},
delay: function (
delay, bind, args
) {
return setTimeout(
this.pass(
null == args ? [] : args,
bind
),
delay
);
},
periodical: function (
periodical, bind, args
) {
return setInterval(
this.pass(
null == args ? [] : args,
bind
),
periodical
);
},
}
),
delete Function.prototype.bind,
Function.implement(
{
create: function (
options
) {
var self = this;
return (
(options = options || {
}),
function (
event
) {
var args = options.arguments;
(args =
null != args
? Array.from(
args
)
: Array.slice(
arguments,
options.event ? 1 : 0
)),
options.event && (args = [event || window.event,].extend(
args
));
var returns = function (
) {
return self.apply(
options.bind || null,
args
);
};
return options.delay
? setTimeout(
returns,
options.delay
)
: options.periodical
? setInterval(
returns,
options.periodical
)
: options.attempt
? Function.attempt(
returns
)
: returns(
);
}
);
},
bind: function (
bind, args
) {
var self = this;
return (
null != args && (args = Array.from(
args
)),
function (
) {
return self.apply(
bind,
args || arguments
);
}
);
},
bindWithEvent: function (
bind, args
) {
var self = this;
return (
null != args && (args = Array.from(
args
)),
function (
event
) {
return self.apply(
bind,
null == args
? arguments
: [event,].concat(
args
),
);
}
);
},
run: function (
args, bind
) {
return this.apply(
bind,
Array.from(
args
)
);
},
}
),
Object.create == Function.prototype.create && (Object.create = null);
var $try = Function.attempt;
!(function (
) {
var hasOwnProperty = Object.prototype.hasOwnProperty;
Object.extend(
{
subset: function (
object, keys
) {
for (var results = {
}, i = 0, l = keys.length; i < l; i++) {
var k = keys[i];
k in object && (results[k] = object[k]);
}
return results;
},
map: function (
object, fn, bind
) {
var results = {
};
for (var key in object)
hasOwnProperty.call(
object,
key
) &&
(results[key] = fn.call(
bind,
object[key],
key,
object
));
return results;
},
filter: function (
object, fn, bind
) {
var results = {
};
for (var key in object) {
var value = object[key];
hasOwnProperty.call(
object,
key
) &&
fn.call(
bind,
value,
key,
object
) &&
(results[key] = value);
}
return results;
},
every: function (
object, fn, bind
) {
for (var key in object)
if (
hasOwnProperty.call(
object,
key
) &&
!fn.call(
bind,
object[key],
key
)
)
return !1;
return !0;
},
some: function (
object, fn, bind
) {
for (var key in object)
if (hasOwnProperty.call(
object,
key
) && fn.call(
bind,
object[key],
key
))
return !0;
return !1;
},
keys: function (
object
) {
var keys = [];
for (var key in object)
hasOwnProperty.call(
object,
key
) && keys.push(
key
);
return keys;
},
values: function (
object
) {
var values = [];
for (var key in object)
hasOwnProperty.call(
object,
key
) && values.push(
object[key]
);
return values;
},
getLength: function (
object
) {
return Object.keys(
object
).length;
},
keyOf: function (
object, value
) {
for (var key in object)
if (hasOwnProperty.call(
object,
key
) && object[key] === value)
return key;
return null;
},
contains: function (
object, value
) {
return null != Object.keyOf(
object,
value
);
},
toQueryString: function (
object, base
) {
var queryString = [];
return (
Object.each(
object,
function (
value, key
) {
var result;
switch ((base && (key = base + "[" + key + "]"), typeOf(
value
))) {
case "object":
result = Object.toQueryString(
value,
key
);
break;
case "array":
var qs = {
};
value.each(
function (
val, i
) {
qs[i] = val;
}
),
(result = Object.toQueryString(
qs,
key
));
break;
default:
result = key + "=" + encodeURIComponent(
value
);
}
null != value && queryString.push(
result
);
}
),
queryString.join(
"&"
)
);
},
}
);
})(
),
Hash.implement(
{
has: Object.prototype.hasOwnProperty,
keyOf: function (
value
) {
return Object.keyOf(
this,
value
);
},
hasValue: function (
value
) {
return Object.contains(
this,
value
);
},
extend: function (
properties
) {
return (
Hash.each(
properties || {
},
function (
value, key
) {
Hash.set(
this,
key,
value
);
},
this,
),
this
);
},
combine: function (
properties
) {
return (
Hash.each(
properties || {
},
function (
value, key
) {
Hash.include(
this,
key,
value
);
},
this,
),
this
);
},
erase: function (
key
) {
return this.hasOwnProperty(
key
) && delete this[key], this;
},
get: function (
key
) {
return this.hasOwnProperty(
key
)
? this[key]
: null;
},
set: function (
key, value
) {
return (
(this[key] && !this.hasOwnProperty(
key
)) || (this[key] = value), this
);
},
empty: function (
) {
return (
Hash.each(
this,
function (
value, key
) {
delete this[key];
},
this,
),
this
);
},
include: function (
key, value
) {
return null == this[key] && (this[key] = value), this;
},
map: function (
fn, bind
) {
return new Hash(
Object.map(
this,
fn,
bind
)
);
},
filter: function (
fn, bind
) {
return new Hash(
Object.filter(
this,
fn,
bind
)
);
},
every: function (
fn, bind
) {
return Object.every(
this,
fn,
bind
);
},
some: function (
fn, bind
) {
return Object.some(
this,
fn,
bind
);
},
getKeys: function (
) {
return Object.keys(
this
);
},
getValues: function (
) {
return Object.values(
this
);
},
toQueryString: function (
base
) {
return Object.toQueryString(
this,
base
);
},
}
),
(Hash.extend = Object.append),
Hash.alias(
{
indexOf: "keyOf",
contains: "hasValue",
}
),
(function (
) {
var XMLHTTP,
MSXML2,
MSXML,
document = this.document,
window = (document.window = this),
ua = navigator.userAgent.toLowerCase(
),
platform = navigator.platform.toLowerCase(
),
UA = ua.match(
/(opera|ie|firefox|chrome|version)[\s\/:]([\w\d\.]+)?.*?(safari|version[\s\/:]([\w\d\.]+)|$)/,
) || [null, "unknown", 0,],
mode = "ie" == UA[1] && document.documentMode,
Browser = (this.Browser = {
extend: Function.prototype.extend,
name: "version" == UA[1] ? UA[3] : UA[1],
version: mode || parseFloat(
"opera" == UA[1] && UA[4] ? UA[4] : UA[2]
),
Platform: {
name: ua.match(
/ip(?:ad|od|hone)/
)
? "ios"
: (ua.match(
/(?:webos|android)/
) ||
platform.match(
/mac|win|linux/
) || ["other",])[0],
},
Features: {
xpath: !!document.evaluate,
air: !!window.runtime,
query: !!document.querySelector,
json: !!window.JSON,
},
Plugins: {
},
});
(Browser[Browser.name] = !0),
(Browser[Browser.name + parseInt(
Browser.version,
10
)] = !0),
(Browser.Platform[Browser.Platform.name] = !0),
(Browser.Request =
((XMLHTTP = function (
) {
return new XMLHttpRequest(
);
}),
(MSXML2 = function (
) {
return new ActiveXObject(
"MSXML2.XMLHTTP"
);
}),
(MSXML = function (
) {
return new ActiveXObject(
"Microsoft.XMLHTTP"
);
}),
Function.attempt(
function (
) {
return XMLHTTP(
), XMLHTTP;
},
function (
) {
return MSXML2(
), MSXML2;
},
function (
) {
return MSXML(
), MSXML;
},
))),
(Browser.Features.xhr = !!Browser.Request);
var version = (
Function.attempt(
function (
) {
return navigator.plugins["Shockwave Flash"].description;
},
function (
) {
return new ActiveXObject(
"ShockwaveFlash.ShockwaveFlash"
).GetVariable(
"$version",
);
},
) || "0 r0"
).match(
/\d+/g
);
if (
((Browser.Plugins.Flash = {
version: Number(
version[0] || "0." + version[1]
) || 0,
build: Number(
version[2]
) || 0,
}),
(Browser.exec = function (
text
) {
if (!text) return text;
if (window.execScript) window.execScript(
text
);
else {
var script = document.createElement(
"script"
);
script.setAttribute(
"type",
"text/javascript"
),
(script.text = text),
document.head.appendChild(
script
),
document.head.removeChild(
script
);
}
return text;
}),
String.implement(
"stripScripts",
function (
exec
) {
var scripts = "",
text = this.replace(
/<script[^>]*>([\s\S]*?)<\/script>/gi,
function (
all, code
) {
return (scripts += code + "\n"), "";
},
);
return (
!0 === exec
? Browser.exec(
scripts
)
: "function" == typeOf(
exec
) && exec(
scripts,
text
),
text
);
}
),
Browser.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 (
name, method
) {
window[name] = method;
}
),
(this.Document = document.$constructor = new Type(
"Document",
function (
) {},
)),
(document.$family = Function.from(
"document"
).hide(
)),
Document.mirror(
function (
name, method
) {
document[name] = method;
}
),
(document.html = document.documentElement),
document.head ||
(document.head = document.getElementsByTagName(
"head"
)[0]),
document.execCommand)
)
try {
document.execCommand(
"BackgroundImageCache",
!1,
!0
);
} catch (e) {}
if (this.attachEvent && !this.addEventListener) {
var unloadEvent = function (
) {
this.detachEvent(
"onunload",
unloadEvent
),
(document.head = document.html = document.window = null);
};
this.attachEvent(
"onunload",
unloadEvent
);
}
var arrayFrom = Array.from;
try {
arrayFrom(
document.html.childNodes
);
} catch (e) {
Array.from = function (
item
) {
if (
"string" != typeof item &&
Type.isEnumerable(
item
) &&
"array" != typeOf(
item
)
) {
for (var i = item.length, array = new Array(
i
); i--; )
array[i] = item[i];
return array;
}
return arrayFrom(
item
);
};
var prototype = Array.prototype,
slice = prototype.slice;
[
"pop",
"push",
"reverse",
"shift",
"sort",
"splice",
"unshift",
"concat",
"join",
"slice",
].each(
function (
name
) {
var method = prototype[name];
Array[name] = function (
item
) {
return method.apply(
Array.from(
item
),
slice.call(
arguments,
1
)
);
};
}
);
}
Browser.Platform.ios && (Browser.Platform.ipod = !0), (Browser.Engine = {
});
var setEngine = function (
name, version
) {
(Browser.Engine.name = name),
(Browser.Engine[name + version] = !0),
(Browser.Engine.version = version);
};
if (Browser.ie)
switch (((Browser.Engine.trident = !0), Browser.version)) {
case 6:
setEngine(
"trident",
4
);
break;
case 7:
setEngine(
"trident",
5
);
break;
case 8:
setEngine(
"trident",
6
);
}
if (
(Browser.firefox &&
((Browser.Engine.gecko = !0),
Browser.version >= 3
? setEngine(
"gecko",
19
)
: setEngine(
"gecko",
18
)),
Browser.safari || Browser.chrome)
)
switch (((Browser.Engine.webkit = !0), Browser.version)) {
case 2:
setEngine(
"webkit",
419
);
break;
case 3:
setEngine(
"webkit",
420
);
break;
case 4:
setEngine(
"webkit",
525
);
}
if (
(Browser.opera &&
((Browser.Engine.presto = !0),
Browser.version >= 9.6
? setEngine(
"presto",
960
)
: Browser.version >= 9.5
? setEngine(
"presto",
950
)
: setEngine(
"presto",
925
)),
"unknown" == Browser.name)
)
switch ((ua.match(
/(?:webkit|khtml|gecko)/
) || [])[0]) {
case "webkit":
case "khtml":
Browser.Engine.webkit = !0;
break;
case "gecko":
Browser.Engine.gecko = !0;
}
this.$exec = Browser.exec;
})(
),
(function (
) {
var _keys = {
},
DOMEvent = (this.DOMEvent = new Type(
"DOMEvent",
function (
event, win
) {
if ((win || (win = window), (event = event || win.event).$extended))
return event;
(this.event = event),
(this.$extended = !0),
(this.shift = event.shiftKey),
(this.control = event.ctrlKey),
(this.alt = event.altKey),
(this.meta = event.metaKey);
for (
var type = (this.type = event.type),
target = event.target || event.srcElement;
target && 3 == target.nodeType;
)
target = target.parentNode;
if (((this.target = document.id(
target
)), 0 == type.indexOf(
"key"
))) {
var code = (this.code = event.which || event.keyCode);
(this.key = _keys[code] || Object.keyOf(
Event.Keys,
code
)),
"keydown" == type &&
(code > 111 && code < 124
? (this.key = "f" + (code - 111))
: code > 95 && code < 106 && (this.key = code - 96)),
null == this.key &&
(this.key = String.fromCharCode(
code
).toLowerCase(
));
} else if (
"click" == type ||
"dblclick" == type ||
"contextmenu" == type ||
"DOMMouseScroll" == type ||
0 == type.indexOf(
"mouse"
)
) {
var doc = win.document;
if (
((doc =
doc.compatMode && "CSS1Compat" != doc.compatMode
? doc.body
: doc.html),
(this.page = {
x:
null != event.pageX
? event.pageX
: event.clientX + doc.scrollLeft,
y:
null != event.pageY
? event.pageY
: event.clientY + doc.scrollTop,
}),
(this.client = {
x:
null != event.pageX
? event.pageX - win.pageXOffset
: event.clientX,
y:
null != event.pageY
? event.pageY - win.pageYOffset
: event.clientY,
}),
("DOMMouseScroll" != type && "mousewheel" != type) ||
(this.wheel = event.wheelDelta
? event.wheelDelta / 120
: -(event.detail || 0) / 3),
(this.rightClick = 3 == event.which || 2 == event.button),
"mouseover" == type || "mouseout" == type)
) {
for (
var related =
event.relatedTarget ||
event[("mouseover" == type ? "from" : "to") + "Element"];
related && 3 == related.nodeType;
)
related = related.parentNode;
this.relatedTarget = document.id(
related
);
}
} else if (0 == type.indexOf(
"touch"
) || 0 == type.indexOf(
"gesture"
)) {
(this.rotation = event.rotation),
(this.scale = event.scale),
(this.targetTouches = event.targetTouches),
(this.changedTouches = event.changedTouches);
var touches = (this.touches = event.touches);
if (touches && touches[0]) {
var touch = touches[0];
(this.page = {
x: touch.pageX,
y: touch.pageY,
}),
(this.client = {
x: touch.clientX,
y: touch.clientY,
});
}
}
this.client || (this.client = {
}), this.page || (this.page = {
});
}
));
DOMEvent.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
);
},
}
),
(DOMEvent.defineKey = function (
code, key
) {
return (_keys[code] = key), this;
}),
(DOMEvent.defineKeys = DOMEvent.defineKey.overloadSetter(
!0
)),
DOMEvent.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 Class = (this.Class = new Type(
"Class",
function (
params
) {
instanceOf(
params,
Function
) && (params = {
initialize: params,
});
var newClass = function (
) {
if ((reset(
this
), newClass.$prototyping)) return this;
this.$caller = null;
var value = this.initialize
? this.initialize.apply(
this,
arguments
)
: this;
return (this.$caller = this.caller = null), value;
}
.extend(
this
)
.implement(
params
);
return (
(newClass.$constructor = Class),
(newClass.prototype.$constructor = newClass),
(newClass.prototype.parent = parent),
newClass
);
}
)),
parent = function (
) {
if (!this.$caller)
throw new Error(
'The method "parent" cannot be called.'
);
var name = this.$caller.$name,
parent = this.$caller.$owner.parent,
previous = parent ? parent.prototype[name] : null;
if (!previous)
throw new Error(
'The method "' + name + '" has no parent.'
);
return previous.apply(
this,
arguments
);
},
reset = function (
object
) {
for (var key in object) {
var value = object[key];
switch (typeOf(
value
)) {
case "object":
var F = function (
) {};
(F.prototype = value), (object[key] = reset(
new F(
)
));
break;
case "array":
object[key] = value.clone(
);
}
}
return object;
},
implement = function (
key, value, retain
) {
if (
Class.Mutators.hasOwnProperty(
key
) &&
null == (value = Class.Mutators[key].call(
this,
value
))
)
return this;
if ("function" == typeOf(
value
)) {
if (value.$hidden) return this;
this.prototype[key] = retain
? value
: (function (
self, key, method
) {
method.$origin && (method = method.$origin);
var wrapper = function (
) {
if (method.$protected && null == this.$caller)
throw new Error(
'The method "' + key + '" cannot be called.',
);
var caller = this.caller,
current = this.$caller;
(this.caller = current), (this.$caller = wrapper);
var result = method.apply(
this,
arguments
);
return (
(this.$caller = current), (this.caller = caller), result
);
}.extend(
{
$owner: self,
$origin: method,
$name: key,
}
);
return wrapper;
})(
this,
key,
value
);
} else Object.merge(
this.prototype,
key,
value
);
return this;
};
Class.implement(
"implement",
implement.overloadSetter(
)
),
(Class.Mutators = {
Extends: function (
parent
) {
(this.parent = parent),
(this.prototype = (function (
klass
) {
klass.$prototyping = !0;
var proto = new klass(
);
return delete klass.$prototyping, proto;
})(
parent
));
},
Implements: function (
items
) {
Array.from(
items
).each(
function (
item
) {
var instance = new item(
);
for (var key in instance)
implement.call(
this,
key,
instance[key],
!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 removeOn = function (
string
) {
return string.replace(
/^on([A-Z])/,
function (
full, first
) {
return first.toLowerCase(
);
}
);
};
(this.Events = new Class(
{
$events: {
},
addEvent: function (
type, fn, internal
) {
return (
(type = removeOn(
type
)),
fn == $empty ||
((this.$events[type] = (this.$events[type] || []).include(
fn
)),
internal && (fn.internal = !0)),
this
);
},
addEvents: function (
events
) {
for (var type in events) this.addEvent(
type,
events[type]
);
return this;
},
fireEvent: function (
type, args, delay
) {
type = removeOn(
type
);
var events = this.$events[type];
return events
? ((args = Array.from(
args
)),
events.each(
function (
fn
) {
delay
? fn.delay(
delay,
this,
args
)
: fn.apply(
this,
args
);
},
this
),
this)
: this;
},
removeEvent: function (
type, fn
) {
type = removeOn(
type
);
var events = this.$events[type];
if (events && !fn.internal) {
var index = events.indexOf(
fn
);
-1 != index && delete events[index];
}
return this;
},
removeEvents: function (
events
) {
var type;
if ("object" == typeOf(
events
)) {
for (type in events) this.removeEvent(
type,
events[type]
);
return this;
}
for (type in (events && (events = removeOn(
events
)), this.$events))
if (!events || events == type)
for (var fns = this.$events[type], i = fns.length; i--; )
i in fns && this.removeEvent(
type,
fns[i]
);
return this;
},
}
)),
(this.Options = new Class(
{
setOptions: function (
) {
var options = (this.options = Object.merge.apply(
null,
[{
}, this.options,].append(
arguments
),
));
if (this.addEvent)
for (var option in options)
"function" == typeOf(
options[option]
) &&
/^on[A-Z]/.test(
option
) &&
(this.addEvent(
option,
options[option]
),
delete options[option]);
return this;
},
}
));
})(
),
function (
) {
var parsed,
separatorIndex,
combinatorIndex,
reversed,
cache = {
},
reverseCache = {
},
reUnescape = /\\/g,
parse = function (
expression, isReversed
) {
if (null == expression) return null;
if (!0 === expression.Slick) return expression;
expression = ("" + expression).replace(
/^\s+|\s+$/g,
""
);
var currentCache = (reversed = !!isReversed) ? reverseCache : cache;
if (currentCache[expression]) return currentCache[expression];
for (
parsed = {
Slick: !0,
expressions: [],
raw: expression,
reverse: function (
) {
return parse(
this.raw,
!0
);
},
},
separatorIndex = -1;
expression != (expression = expression.replace(
regexp,
parser
));
);
return (
(parsed.length = parsed.expressions.length),
(currentCache[parsed.raw] = reversed
? reverse(
parsed
)
: parsed)
);
},
reverseCombinator = function (
combinator
) {
return "!" === combinator
? " "
: " " === combinator
? "!"
: /^!/.test(
combinator
)
? combinator.replace(
/^!/,
""
)
: "!" + combinator;
},
reverse = function (
expression
) {
for (
var expressions = expression.expressions, i = 0;
i < expressions.length;
i++
) {
for (
var exp = expressions[i],
last = {
parts: [],
tag: "*",
combinator: reverseCombinator(
exp[0].combinator
),
},
j = 0;
j < exp.length;
j++
) {
var cexp = exp[j];
cexp.reverseCombinator || (cexp.reverseCombinator = " "),
(cexp.combinator = cexp.reverseCombinator),
delete cexp.reverseCombinator;
}
exp.reverse(
).push(
last
);
}
return expression;
},
escapeRegExp = function (
string
) {
return string.replace(
/[-[\]{}()*+?.\\^$|,#\s]/g,
function (
match
) {
return "\\" + match;
}
);
},
regexp = new RegExp(
"^(?:\\s*(,)\\s*|\\s*(<combinator>+)\\s*|(\\s+)|(<unicode>+|\\*)|\\#(<unicode>+)|\\.(<unicode>+)|\\[\\s*(<unicode1>+)(?:\\s*([*^$!~|]?=)(?:\\s*(?:([\"']?)(.*?)\\9)))?\\s*\\](?!\\])|(:+)(<unicode>+)(?:\\((?:(?:([\"'])([^\\13]*)\\13)|((?:\\([^)]+\\)|[^()]*)+))\\))?)"
.replace(
/<combinator>/,
"[" + escapeRegExp(
">+~`!@$%^&={}\\;</"
) + "]",
)
.replace(
/<unicode>/g,
"(?:[\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])"
)
.replace(
/<unicode1>/g,
"(?:[:\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])",
),
);
function parser(
rawMatch,
separator,
combinator,
combinatorChildren,
tagName,
id,
className,
attributeKey,
attributeOperator,
attributeQuote,
attributeValue,
pseudoMarker,
pseudoClass,
pseudoQuote,
pseudoClassQuotedValue,
pseudoClassValue,
) {
if (
(separator || -1 === separatorIndex) &&
((parsed.expressions[++separatorIndex] = []),
(combinatorIndex = -1),
separator)
)
return "";
if (combinator || combinatorChildren || -1 === combinatorIndex) {
combinator = combinator || " ";
var currentSeparator = parsed.expressions[separatorIndex];
reversed &&
currentSeparator[combinatorIndex] &&
(currentSeparator[
combinatorIndex
].reverseCombinator = reverseCombinator(
combinator
)),
(currentSeparator[++combinatorIndex] = {
combinator: combinator,
tag: "*",
});
}
var currentParsed = parsed.expressions[separatorIndex][combinatorIndex];
if (tagName) currentParsed.tag = tagName.replace(
reUnescape,
""
);
else if (id) currentParsed.id = id.replace(
reUnescape,
""
);
else if (className)
(className = className.replace(
reUnescape,
""
)),
currentParsed.classList || (currentParsed.classList = []),
currentParsed.classes || (currentParsed.classes = []),
currentParsed.classList.push(
className
),
currentParsed.classes.push(
{
value: className,
regexp: new RegExp(
"(^|\\s)" + escapeRegExp(
className
) + "(\\s|$)"
),
}
);
else if (pseudoClass)
(pseudoClassValue = (pseudoClassValue =
pseudoClassValue || pseudoClassQuotedValue)
? pseudoClassValue.replace(
reUnescape,
""
)
: null),
currentParsed.pseudos || (currentParsed.pseudos = []),
currentParsed.pseudos.push(
{
key: pseudoClass.replace(
reUnescape,
""
),
value: pseudoClassValue,
type: 1 == pseudoMarker.length ? "class" : "element",
}
);
else if (attributeKey) {
var test, regexp;
switch (
((attributeKey = attributeKey.replace(
reUnescape,
""
)),
(attributeValue = (attributeValue || "").replace(
reUnescape,
""
)),
attributeOperator)
) {
case "^=":
regexp = new RegExp(
"^" + escapeRegExp(
attributeValue
)
);
break;
case "$=":
regexp = new RegExp(
escapeRegExp(
attributeValue
) + "$"
);
break;
case "~=":
regexp = new RegExp(
"(^|\\s)" + escapeRegExp(
attributeValue
) + "(\\s|$)",
);
break;
case "|=":
regexp = new RegExp(
"^" + escapeRegExp(
attributeValue
) + "(-|$)"
);
break;
case "=":
test = function (
value
) {
return attributeValue == value;
};
break;
case "*=":
test = function (
value
) {
return value && value.indexOf(
attributeValue
) > -1;
};
break;
case "!=":
test = function (
value
) {
return attributeValue != value;
};
break;
default:
test = function (
value
) {
return !!value;
};
}
"" == attributeValue &&
/^[*$^]=$/.test(
attributeOperator
) &&
(test = function (
) {
return !1;
}),
test ||
(test = function (
value
) {
return value && regexp.test(
value
);
}),
currentParsed.attributes || (currentParsed.attributes = []),
currentParsed.attributes.push(
{
key: attributeKey,
operator: attributeOperator,
value: attributeValue,
test: test,
}
);
}
return "";
}
var Slick = this.Slick || {
};
(Slick.parse = function (
expression
) {
return parse(
expression
);
}),
(Slick.escapeRegExp = escapeRegExp),
this.Slick || (this.Slick = Slick);
}.apply(
"undefined" != typeof exports ? exports : this
),
function (
) {
var local = {
},
featuresCache = {
},
toString = Object.prototype.toString;
(local.isNativeCode = function (
fn
) {
return /\{\s*\[native code\]\s*\}/.test(
"" + fn
);
}),
(local.isXML = function (
document
) {
return (
!!document.xmlVersion ||
!!document.xml ||
"[object XMLDocument]" == toString.call(
document
) ||
(9 == document.nodeType &&
"HTML" != document.documentElement.nodeName)
);
}),
(local.setDocument = function (
document
) {
var nodeType = document.nodeType;
if (9 == nodeType);
else if (nodeType) document = document.ownerDocument;
else {
if (!document.navigator) return;
document = document.document;
}
if (this.document !== document) {
this.document = document;
var feature,
root = document.documentElement,
rootUid = this.getUIDXML(
root
),
features = featuresCache[rootUid];
if (features)
for (feature in features) this[feature] = features[feature];
else {
var starSelectsClosed,
starSelectsComments,
brokenSecondClassNameGEBCN,
cachedGetElementsByClassName,
brokenFormAttributeGetter;
((features = featuresCache[rootUid] = {
}).root = root),
(features.isXMLDocument = this.isXML(
document
)),
(features.brokenStarGEBTN = features.starSelectsClosedQSA = features.idGetsName = features.brokenMixedCaseQSA = features.brokenGEBCN = features.brokenCheckedQSA = features.brokenEmptyAttributeQSA = features.isHTMLDocument = features.nativeMatchesSelector = !1);
var selected,
id = "slick_uniqueid",
testNode = document.createElement(
"div"
),
testRoot =
document.body ||
document.getElementsByTagName(
"body"
)[0] ||
root;
testRoot.appendChild(
testNode
);
try {
(testNode.innerHTML = '<a id="' + id + '"></a>'),
(features.isHTMLDocument = !!document.getElementById(
id
));
} catch (e) {}
if (features.isHTMLDocument) {
(testNode.style.display = "none"),
testNode.appendChild(
document.createComment(
""
)
),
(starSelectsComments =
testNode.getElementsByTagName(
"*"
).length > 1);
try {
(testNode.innerHTML = "foo</foo>"),
(starSelectsClosed =
(selected = testNode.getElementsByTagName(
"*"
)) &&
!!selected.length &&
"/" == selected[0].nodeName.charAt(
0
));
} catch (e) {}
features.brokenStarGEBTN =
starSelectsComments || starSelectsClosed;
try {
(testNode.innerHTML =
'<a name="' + id + '"></a><b id="' + id + '"></b>'),
(features.idGetsName =
document.getElementById(
id
) === testNode.firstChild);
} catch (e) {}
if (testNode.getElementsByClassName) {
try {
(testNode.innerHTML = '<a class="f"></a><a class="b"></a>'),
testNode.getElementsByClassName(
"b"
).length,
(testNode.firstChild.className = "b"),
(cachedGetElementsByClassName =
2 != testNode.getElementsByClassName(
"b"
).length);
} catch (e) {}
try {
(testNode.innerHTML =
'<a class="a"></a><a class="f b a"></a>'),
(brokenSecondClassNameGEBCN =
2 != testNode.getElementsByClassName(
"a"
).length);
} catch (e) {}
features.brokenGEBCN =
cachedGetElementsByClassName || brokenSecondClassNameGEBCN;
}
if (testNode.querySelectorAll) {
try {
(testNode.innerHTML = "foo</foo>"),
(selected = testNode.querySelectorAll(
"*"
)),
(features.starSelectsClosedQSA =
selected &&
!!selected.length &&
"/" == selected[0].nodeName.charAt(
0
));
} catch (e) {}
try {
(testNode.innerHTML = '<a class="MiX"></a>'),
(features.brokenMixedCaseQSA = !testNode.querySelectorAll(
".MiX",
).length);
} catch (e) {}
try {
(testNode.innerHTML =
'<select><option selected="selected">a</option></select>'),
(features.brokenCheckedQSA =
0 == testNode.querySelectorAll(
":checked"
).length);
} catch (e) {}
try {
(testNode.innerHTML = '<a class=""></a>'),
(features.brokenEmptyAttributeQSA =
0 != testNode.querySelectorAll(
'[class*=""]'
).length);
} catch (e) {}
}
try {
(testNode.innerHTML =
'<form action="s"><input id="action"/></form>'),
(brokenFormAttributeGetter =
"s" != testNode.firstChild.getAttribute(
"action"
));
} catch (e) {}
if (
((features.nativeMatchesSelector =
root.matchesSelector ||
root.mozMatchesSelector ||
root.webkitMatchesSelector),
features.nativeMatchesSelector)
)
try {
features.nativeMatchesSelector.call(
root,
":slick"
),
(features.nativeMatchesSelector = null);
} catch (e) {}
}
try {
(root.slick_expando = 1),
delete root.slick_expando,
(features.getUID = this.getUIDHTML);
} catch (e) {
features.getUID = this.getUIDXML;
}
testRoot.removeChild(
testNode
),
(testNode = selected = testRoot = null),
(features.getAttribute =
features.isHTMLDocument && brokenFormAttributeGetter
? function (
node, name
) {
var method = this.attributeGetters[name];
if (method) return method.call(
node
);
var attributeNode = node.getAttributeNode(
name
);
return attributeNode ? attributeNode.nodeValue : null;
}
: function (
node, name
) {
var method = this.attributeGetters[name];
return method
? method.call(
node
)
: node.getAttribute(
name
);
}),
(features.hasAttribute =
root && this.isNativeCode(
root.hasAttribute
)
? function (
node, attribute
) {
return node.hasAttribute(
attribute
);
}
: function (
node, attribute
) {
return !(
!(node = node.getAttributeNode(
attribute
)) ||
(!node.specified && !node.nodeValue)
);
});
var nativeRootContains = root && this.isNativeCode(
root.contains
),
nativeDocumentContains =
document && this.isNativeCode(
document.contains
);
for (feature in ((features.contains =
nativeRootContains && nativeDocumentContains
? function (
context, node
) {
return context.contains(
node
);
}
: nativeRootContains && !nativeDocumentContains
? function (
context, node
) {
return (
context === node ||
(context === document
? document.documentElement
: context
).contains(
node
)
);
}
: root && root.compareDocumentPosition
? function (
context, node
) {
return (
context === node ||
!!(16 & context.compareDocumentPosition(
node
))
);
}
: function (
context, node
) {
if (node)
do {
if (node === context) return !0;
} while ((node = node.parentNode));
return !1;
}),
(features.documentSorter = root.compareDocumentPosition
? function (
a, b
) {
return a.compareDocumentPosition && b.compareDocumentPosition
? 4 & a.compareDocumentPosition(
b
)
? -1
: a === b
? 0
: 1
: 0;
}
: "sourceIndex" in root
? function (
a, b
) {
return a.sourceIndex && b.sourceIndex
? a.sourceIndex - b.sourceIndex
: 0;
}
: document.createRange
? function (
a, b
) {
if (!a.ownerDocument || !b.ownerDocument) return 0;
var aRange = a.ownerDocument.createRange(
),
bRange = b.ownerDocument.createRange(
);
return (
aRange.setStart(
a,
0
),
aRange.setEnd(
a,
0
),
bRange.setStart(
b,
0
),
bRange.setEnd(
b,
0
),
aRange.compareBoundaryPoints(
Range.START_TO_END,
bRange
)
);
}
: null),
(root = null),
features))
this[feature] = features[feature];
}
}
});
var reSimpleSelector = /^([#.]?)((?:[\w-]+|\*))$/,
reEmptyAttribute = /\[.+[*$^]=(?:""|'')?\]/,
qsaFailExpCache = {
};
(local.search = function (
context, expression, append, first
) {
var found = (this.found = first ? null : append || []);
if (!context) return found;
if (context.navigator) context = context.document;
else if (!context.nodeType) return found;
var parsed,
i,
j,
m,
n,
combinator,
tag,
id,
classList,
classes,
attributes,
pseudos,
uniques = (this.uniques = {
}),
hasOthers = !(!append || !append.length),
contextIsDocument = 9 == context.nodeType;
if (
(this.document !==
(contextIsDocument ? context : context.ownerDocument) &&
this.setDocument(
context
),
hasOthers)
)
for (i = found.length; i--; ) uniques[this.getUID(
found[i]
)] = !0;
if ("string" == typeof expression) {
var simpleSelector = expression.match(
reSimpleSelector
);
simpleSelectors: if (simpleSelector) {
var node,
nodes,
symbol = simpleSelector[1],
name = simpleSelector[2];
if (symbol) {
if ("#" == symbol) {
if (!this.isHTMLDocument || !contextIsDocument)
break simpleSelectors;
if (!(node = context.getElementById(
name
))) return found;
if (
this.idGetsName &&
node.getAttributeNode(
"id"
).nodeValue != name
)
break simpleSelectors;
if (first) return node || null;
(hasOthers && uniques[this.getUID(
node
)]) || found.push(
node
);
} else if ("." == symbol) {
if (
!this.isHTMLDocument ||
((!context.getElementsByClassName || this.brokenGEBCN) &&
context.querySelectorAll)
)
break simpleSelectors;
if (context.getElementsByClassName && !this.brokenGEBCN) {
if (((nodes = context.getElementsByClassName(
name
)), first))
return nodes[0] || null;
for (i = 0; (node = nodes[i++]); )
(hasOthers && uniques[this.getUID(
node
)]) || found.push(
node
);
} else {
var matchClass = new RegExp(
"(^|\\s)" + Slick.escapeRegExp(
name
) + "(\\s|$)",
);
for (
nodes = context.getElementsByTagName(
"*"
), i = 0;
(node = nodes[i++]);
)
if (
((className = node.className),
className && matchClass.test(
className
))
) {
if (first) return node;
(hasOthers && uniques[this.getUID(
node
)]) ||
found.push(
node
);
}
}
}
} else {
if ("*" == name && this.brokenStarGEBTN) break simpleSelectors;
if (((nodes = context.getElementsByTagName(
name
)), first))
return nodes[0] || null;
for (i = 0; (node = nodes[i++]); )
(hasOthers && uniques[this.getUID(
node
)]) || found.push(
node
);
}
return hasOthers && this.sort(
found
), first ? null : found;
}
querySelector: if (context.querySelectorAll) {
if (
!this.isHTMLDocument ||
qsaFailExpCache[expression] ||
this.brokenMixedCaseQSA ||
(this.brokenCheckedQSA && expression.indexOf(
":checked"
) > -1) ||
(this.brokenEmptyAttributeQSA &&
reEmptyAttribute.test(
expression
)) ||
(!contextIsDocument && expression.indexOf(
","
) > -1) ||
Slick.disableQSA
)
break querySelector;
var _expression = expression,
_context = context;
if (!contextIsDocument) {
var currentId = _context.getAttribute(
"id"
);
_context.setAttribute(
"id",
"slickid__"
),
(_expression = "#slickid__ " + _expression),
(context = _context.parentNode);
}
try {
if (first) return context.querySelector(
_expression
) || null;
nodes = context.querySelectorAll(
_expression
);
} catch (e) {
qsaFailExpCache[expression] = 1;
break querySelector;
} finally {
contextIsDocument ||
(currentId
? _context.setAttribute(
"id",
currentId
)
: _context.removeAttribute(
"id"
),
(context = _context));
}
if (this.starSelectsClosedQSA)
for (i = 0; (node = nodes[i++]); )
!(node.nodeName > "@") ||
(hasOthers && uniques[this.getUID(
node
)]) ||
found.push(
node
);
else
for (i = 0; (node = nodes[i++]); )
(hasOthers && uniques[this.getUID(
node
)]) || found.push(
node
);
return hasOthers && this.sort(
found
), found;
}
if (!(parsed = this.Slick.parse(
expression
)).length) return found;
} else {
if (null == expression) return found;
if (!expression.Slick)
return this.contains(
context.documentElement || context,
expression
)
? (found
? found.push(
expression
)
: (found = expression), found)
: found;
parsed = expression;
}
(this.posNTH = {
}),
(this.posNTHLast = {
}),
(this.posNTHType = {
}),
(this.posNTHTypeLast = {
}),
(this.push =
!hasOthers &&
(first || (1 == parsed.length && 1 == parsed.expressions[0].length))
? this.pushArray
: this.pushUID),
null == found && (found = []);
var currentItems,
currentExpression,
currentBit,
lastBit,
expressions = parsed.expressions;
search: for (i = 0; (currentExpression = expressions[i]); i++)
for (j = 0; (currentBit = currentExpression[j]); j++) {
if (!this[(combinator = "combinator:" + currentBit.combinator)])
continue search;
if (
((tag = this.isXMLDocument
? currentBit.tag
: currentBit.tag.toUpperCase(
)),
(id = currentBit.id),
(classList = currentBit.classList),
(classes = currentBit.classes),
(attributes = currentBit.attributes),
(pseudos = currentBit.pseudos),
(lastBit = j === currentExpression.length - 1),
(this.bitUniques = {
}),
lastBit
? ((this.uniques = uniques), (this.found = found))
: ((this.uniques = {
}), (this.found = [])),
0 === j)
) {
if (
(this[combinator](
context,
tag,
id,
classes,
attributes,
pseudos,
classList,
),
first && lastBit && found.length)
)
break search;
} else if (first && lastBit) {
for (m = 0, n = currentItems.length; m < n; m++)
if (
(this[combinator](
currentItems[m],
tag,
id,
classes,
attributes,
pseudos,
classList,
),
found.length)
)
break search;
} else
for (m = 0, n = currentItems.length; m < n; m++)
this[combinator](
currentItems[m],
tag,
id,
classes,
attributes,
pseudos,
classList,
);
currentItems = this.found;
}
return (
(hasOthers || parsed.expressions.length > 1) && this.sort(
found
),
first ? found[0] || null : found
);
}),
(local.uidx = 1),
(local.uidk = "slick-uniqueid"),
(local.getUIDXML = function (
node
) {
var uid = node.getAttribute(
this.uidk
);
return (
uid || ((uid = this.uidx++), node.setAttribute(
this.uidk,
uid
)), uid
);
}),
(local.getUIDHTML = function (
node
) {
return node.uniqueNumber || (node.uniqueNumber = this.uidx++);
}),
(local.sort = function (
results
) {
return this.documentSorter
? (results.sort(
this.documentSorter
), results)
: results;
}),
(local.cacheNTH = {
}),
(local.matchNTH = /^([+-]?\d*)?([a-z]+)?([+-]\d+)?$/),
(local.parseNTHArgument = function (
argument
) {
var parsed = argument.match(
this.matchNTH
);
if (!parsed) return !1;
var special = parsed[2] || !1,
a = parsed[1] || 1;
"-" == a && (a = -1);
var b = +parsed[3] || 0;
return (
(parsed =
"n" == special
? {
a: a,
b: b,
}
: "odd" == special
? {
a: 2,
b: 1,
}
: "even" == special
? {
a: 2,
b: 0,
}
: {
a: 0,
b: a,
}),
(this.cacheNTH[argument] = parsed)
);
}),
(local.createNTHPseudo = function (
child, sibling, positions, ofType
) {
return function (
node, argument
) {
var uid = this.getUID(
node
);
if (!this[positions][uid]) {
var parent = node.parentNode;
if (!parent) return !1;
var el = parent[child],
count = 1;
if (ofType) {
var nodeName = node.nodeName;
do {
el.nodeName == nodeName &&
(this[positions][this.getUID(
el
)] = count++);
} while ((el = el[sibling]));
} else
do {
1 == el.nodeType &&
(this[positions][this.getUID(
el
)] = count++);
} while ((el = el[sibling]));
}
argument = argument || "n";
var parsed =
this.cacheNTH[argument] || this.parseNTHArgument(
argument
);
if (!parsed) return !1;
var a = parsed.a,
b = parsed.b,
pos = this[positions][uid];
if (0 == a) return b == pos;
if (a > 0) {
if (pos < b) return !1;
} else if (b < pos) return !1;
return (pos - b) % a == 0;
};
}),
(local.pushArray = function (
node,
tag,
id,
classes,
attributes,
pseudos,
) {
this.matchSelector(
node,
tag,
id,
classes,
attributes,
pseudos
) &&
this.found.push(
node
);
}),
(local.pushUID = function (
node, tag, id, classes, attributes, pseudos
) {
var uid = this.getUID(
node
);
!this.uniques[uid] &&
this.matchSelector(
node,
tag,
id,
classes,
attributes,
pseudos
) &&
((this.uniques[uid] = !0), this.found.push(
node
));
}),
(local.matchNode = function (
node, selector
) {
if (this.isHTMLDocument && this.nativeMatchesSelector)
try {
return this.nativeMatchesSelector.call(
node,
selector.replace(
/\[([^=]+)=\s*([^'"\]]+?)\s*\]/g,
'[$1="$2"]'
),
);
} catch (matchError) {}
var parsed = this.Slick.parse(
selector
);
if (!parsed) return !0;
var i,
expressions = parsed.expressions,
simpleExpCounter = 0;
for (i = 0; (currentExpression = expressions[i]); i++)
if (1 == currentExpression.length) {
var exp = currentExpression[0];
if (
this.matchSelector(
node,
this.isXMLDocument
? exp.tag
: exp.tag.toUpperCase(
),
exp.id,
exp.classes,
exp.attributes,
exp.pseudos,
)
)
return !0;
simpleExpCounter++;
}
if (simpleExpCounter == parsed.length) return !1;
var item,
nodes = this.search(
this.document,
parsed
);
for (i = 0; (item = nodes[i++]); ) if (item === node) return !0;
return !1;
}),
(local.matchPseudo = function (
node, name, argument
) {
var pseudoName = "pseudo:" + name;
if (this[pseudoName]) return this[pseudoName](
node,
argument
);
var attribute = this.getAttribute(
node,
name
);
return argument ? argument == attribute : !!attribute;
}),
(local.matchSelector = function (
node,
tag,
id,
classes,
attributes,
pseudos,
) {
if (tag) {
var nodeName = this.isXMLDocument
? node.nodeName
: node.nodeName.toUpperCase(
);
if ("*" == tag) {
if (nodeName < "@") return !1;
} else if (nodeName != tag) return !1;
}
if (id && node.getAttribute(
"id"
) != id) return !1;
var i, part, cls;
if (classes)
for (i = classes.length; i--; )
if (
!(cls = this.getAttribute(
node,
"class"
)) ||
!classes[i].regexp.test(
cls
)
)
return !1;
if (attributes)
for (i = attributes.length; i--; )
if (
(part = attributes[i]).operator
? !part.test(
this.getAttribute(
node,
part.key
)
)
: !this.hasAttribute(
node,
part.key
)
)
return !1;
if (pseudos)
for (i = pseudos.length; i--; )
if (
((part = pseudos[i]),
!this.matchPseudo(
node,
part.key,
part.value
))
)
return !1;
return !0;
});
var combinators = {
" ": function (
node, tag, id, classes, attributes, pseudos, classList
) {
var i, item, children;
if (this.isHTMLDocument) {
getById: if (id) {
if (
(!(item = this.document.getElementById(
id
)) && node.all) ||
(this.idGetsName &&
item &&
item.getAttributeNode(
"id"
).nodeValue != id)
) {
if (!(children = node.all[id])) return;
for (
children[0] || (children = [children,]), i = 0;
(item = children[i++]);
) {
var idNode = item.getAttributeNode(
"id"
);
if (idNode && idNode.nodeValue == id) {
this.push(
item,
tag,
null,
classes,
attributes,
pseudos
);
break;
}
}
return;
}
if (!item) {
if (this.contains(
this.root,
node
)) return;
break getById;
}
if (this.document !== node && !this.contains(
node,
item
)) return;
return void this.push(
item,
tag,
null,
classes,
attributes,
pseudos,
);
}
getByClass: if (
classes &&
node.getElementsByClassName &&
!this.brokenGEBCN
) {
if (
!(children = node.getElementsByClassName(
classList.join(
" "
)
)) ||
!children.length
)
break getByClass;
for (i = 0; (item = children[i++]); )
this.push(
item,
tag,
id,
null,
attributes,
pseudos
);
return;
}
}
if ((children = node.getElementsByTagName(
tag
)) && children.length)
for (
this.brokenStarGEBTN || (tag = null), i = 0;
(item = children[i++]);
)
this.push(
item,
tag,
id,
classes,
attributes,
pseudos
);
},
">": function (
node, tag, id, classes, attributes, pseudos
) {
if ((node = node.firstChild))
do {
1 == node.nodeType &&
this.push(
node,
tag,
id,
classes,
attributes,
pseudos
);
} while ((node = node.nextSibling));
},
"+": function (
node, tag, id, classes, attributes, pseudos
) {
for (; (node = node.nextSibling); )
if (1 == node.nodeType) {
this.push(
node,
tag,
id,
classes,
attributes,
pseudos
);
break;
}
},
"^": function (
node, tag, id, classes, attributes, pseudos
) {
(node = node.firstChild) &&
(1 == node.nodeType
? this.push(
node,
tag,
id,
classes,
attributes,
pseudos
)
: this["combinator:+"](
node,
tag,
id,
classes,
attributes,
pseudos,
));
},
"~": function (
node, tag, id, classes, attributes, pseudos
) {
for (; (node = node.nextSibling); )
if (1 == node.nodeType) {
var uid = this.getUID(
node
);
if (this.bitUniques[uid]) break;
(this.bitUniques[uid] = !0),
this.push(
node,
tag,
id,
classes,
attributes,
pseudos
);
}
},
"++": function (
node, tag, id, classes, attributes, pseudos
) {
this["combinator:+"](
node,
tag,
id,
classes,
attributes,
pseudos
),
this["combinator:!+"](
node,
tag,
id,
classes,
attributes,
pseudos
);
},
"~~": function (
node, tag, id, classes, attributes, pseudos
) {
this["combinator:~"](
node,
tag,
id,
classes,
attributes,
pseudos
),
this["combinator:!~"](
node,
tag,
id,
classes,
attributes,
pseudos
);
},
"!": function (
node, tag, id, classes, attributes, pseudos
) {
for (; (node = node.parentNode); )
node !== this.document &&
this.push(
node,
tag,
id,
classes,
attributes,
pseudos
);
},
"!>": function (
node, tag, id, classes, attributes, pseudos
) {
(node = node.parentNode) !== this.document &&
this.push(
node,
tag,
id,
classes,
attributes,
pseudos
);
},
"!+": function (
node, tag, id, classes, attributes, pseudos
) {
for (; (node = node.previousSibling); )
if (1 == node.nodeType) {
this.push(
node,
tag,
id,
classes,
attributes,
pseudos
);
break;
}
},
"!^": function (
node, tag, id, classes, attributes, pseudos
) {
(node = node.lastChild) &&
(1 == node.nodeType
? this.push(
node,
tag,
id,
classes,
attributes,
pseudos
)
: this["combinator:!+"](
node,
tag,
id,
classes,
attributes,
pseudos,
));
},
"!~": function (
node, tag, id, classes, attributes, pseudos
) {
for (; (node = node.previousSibling); )
if (1 == node.nodeType) {
var uid = this.getUID(
node
);
if (this.bitUniques[uid]) break;
(this.bitUniques[uid] = !0),
this.push(
node,
tag,
id,
classes,
attributes,
pseudos
);
}
},
};
for (var c in combinators) local["combinator:" + c] = combinators[c];
var pseudos = {
empty: function (
node
) {
var child = node.firstChild;
return !(
(child && 1 == child.nodeType) ||
(node.innerText || node.textContent || "").length
);
},
not: function (
node, expression
) {
return !this.matchNode(
node,
expression
);
},
contains: function (
node, text
) {
return (node.innerText || node.textContent || "").indexOf(
text
) > -1;
},
"first-child": function (
node
) {
for (; (node = node.previousSibling); )
if (1 == node.nodeType) return !1;
return !0;
},
"last-child": function (
node
) {
for (; (node = node.nextSibling); ) if (1 == node.nodeType) return !1;
return !0;
},
"only-child": function (
node
) {
for (var prev = node; (prev = prev.previousSibling); )
if (1 == prev.nodeType) return !1;
for (var next = node; (next = next.nextSibling); )
if (1 == next.nodeType) return !1;
return !0;
},
"nth-child": local.createNTHPseudo(
"firstChild",
"nextSibling",
"posNTH"
),
"nth-last-child": local.createNTHPseudo(
"lastChild",
"previousSibling",
"posNTHLast",
),
"nth-of-type": local.createNTHPseudo(
"firstChild",
"nextSibling",
"posNTHType",
!0,
),
"nth-last-of-type": local.createNTHPseudo(
"lastChild",
"previousSibling",
"posNTHTypeLast",
!0,
),
index: function (
node, index
) {
return this["pseudo:nth-child"](
node,
"" + (index + 1)
);
},
even: function (
node
) {
return this["pseudo:nth-child"](
node,
"2n"
);
},
odd: function (
node
) {
return this["pseudo:nth-child"](
node,
"2n+1"
);
},
"first-of-type": function (
node
) {
for (var nodeName = node.nodeName; (node = node.previousSibling); )
if (node.nodeName == nodeName) return !1;
return !0;
},
"last-of-type": function (
node
) {
for (var nodeName = node.nodeName; (node = node.nextSibling); )
if (node.nodeName == nodeName) return !1;
return !0;
},
"only-of-type": function (
node
) {
for (
var prev = node, nodeName = node.nodeName;
(prev = prev.previousSibling);
)
if (prev.nodeName == nodeName) return !1;
for (var next = node; (next = next.nextSibling); )
if (next.nodeName == nodeName) return !1;
return !0;
},
enabled: function (
node
) {
return !node.disabled;
},
disabled: function (
node
) {
return node.disabled;
},
checked: function (
node
) {
return node.checked || node.selected;
},
focus: function (
node
) {
return (
this.isHTMLDocument &&
this.document.activeElement === node &&
(node.href || node.type || this.hasAttribute(
node,
"tabindex"
))
);
},
root: function (
node
) {
return node === this.root;
},
selected: function (
node
) {
return node.selected;
},
};
for (var p in pseudos) local["pseudo:" + p] = pseudos[p];
var attributeGetters = (local.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 attributeNode = this.getAttributeNode(
"tabindex"
);
return attributeNode && attributeNode.specified
? attributeNode.nodeValue
: null;
},
type: function (
) {
return this.getAttribute(
"type"
);
},
maxlength: function (
) {
var attributeNode = this.getAttributeNode(
"maxLength"
);
return attributeNode && attributeNode.specified
? attributeNode.nodeValue
: null;
},
});
attributeGetters.MAXLENGTH = attributeGetters.maxLength =
attributeGetters.maxlength;
var Slick = (local.Slick = this.Slick || {
});
(Slick.version = "1.1.7"),
(Slick.search = function (
context, expression, append
) {
return local.search(
context,
expression,
append
);
}),
(Slick.find = function (
context, expression
) {
return local.search(
context,
expression,
null,
!0
);
}),
(Slick.contains = function (
container, node
) {
return local.setDocument(
container
), local.contains(
container,
node
);
}),
(Slick.getAttribute = function (
node, name
) {
return local.setDocument(
node
), local.getAttribute(
node,
name
);
}),
(Slick.hasAttribute = function (
node, name
) {
return local.setDocument(
node
), local.hasAttribute(
node,
name
);
}),
(Slick.match = function (
node, selector
) {
return (
!(!node || !selector) &&
(!selector ||
selector === node ||
(local.setDocument(
node
), local.matchNode(
node,
selector
)))
);
}),
(Slick.defineAttributeGetter = function (
name, fn
) {
return (local.attributeGetters[name] = fn), this;
}),
(Slick.lookupAttributeGetter = function (
name
) {
return local.attributeGetters[name];
}),
(Slick.definePseudo = function (
name, fn
) {
return (
(local["pseudo:" + name] = function (
node, argument
) {
return fn.call(
node,
argument
);
}),
this
);
}),
(Slick.lookupPseudo = function (
name
) {
var pseudo = local["pseudo:" + name];
return pseudo
? function (
argument
) {
return pseudo.call(
this,
argument
);
}
: null;
}),
(Slick.override = function (
regexp, fn
) {
return local.override(
regexp,
fn
), this;
}),
(Slick.isXML = local.isXML),
(Slick.uidOf = function (
node
) {
return local.getUIDHTML(
node
);
}),
this.Slick || (this.Slick = Slick);
}.apply(
"undefined" != typeof exports ? exports : this
);
var Element = function (
tag, props
) {
var konstructor = Element.Constructors[tag];
if (konstructor) return konstructor(
props
);
if ("string" != typeof tag) return document.id(
tag
).set(
props
);
if ((props || (props = {
}), !/^[\w-]+$/.test(
tag
))) {
var parsed = Slick.parse(
tag
).expressions[0][0];
(tag = "*" == parsed.tag ? "div" : parsed.tag),
parsed.id && null == props.id && (props.id = parsed.id);
var attributes = parsed.attributes;
if (attributes)
for (var attr, i = 0, l = attributes.length; i < l; i++)
null == props[(attr = attributes[i]).key] &&
(null != attr.value && "=" == attr.operator
? (props[attr.key] = attr.value)
: attr.value || attr.operator || (props[attr.key] = !0));
parsed.classList &&
null == props.class &&
(props.class = parsed.classList.join(
" "
));
}
return document.newElement(
tag,
props
);
};
Browser.Element &&
((Element.prototype = Browser.Element.prototype),
(Element.prototype._fireEvent = (function (
fireEvent
) {
return function (
type, event
) {
return fireEvent.call(
this,
type,
event
);
};
})(
Element.prototype.fireEvent
))),
new Type(
"Element",
Element
).mirror(
function (
name
) {
if (!Array.prototype[name]) {
var obj = {
};
(obj[name] = function (
) {
for (
var results = [],
args = arguments,
elements = !0,
i = 0,
l = this.length;
i < l;
i++
) {
var element = this[i],
result = (results[i] = element[name].apply(
element,
args
));
elements = elements && "element" == typeOf(
result
);
}
return elements
? new Elements(
results
)
: results;
}),
Elements.implement(
obj
);
}
}
),
Browser.Element ||
((Element.parent = Object),
(Element.Prototype = {
$constructor: Element,
$family: Function.from(
"element"
).hide(
),
}),
Element.mirror(
function (
name, method
) {
Element.Prototype[name] = method;
}
)),
(Element.Constructors = {
}),
(Element.Constructors = new Hash(
));
var IFrame = new Type(
"IFrame",
function (
) {
var iframe,
params = Array.link(
arguments,
{
properties: Type.isObject,
iframe: function (
obj
) {
return null != obj;
},
}
),
props = params.properties || {
};
params.iframe && (iframe = document.id(
params.iframe
));
var onload = props.onload || function (
) {};
delete props.onload,
(props.id = props.name = [
props.id,
props.name,
iframe
? iframe.id || iframe.name
: "IFrame_" + String.uniqueID(
),
].pick(
)),
(iframe = new Element(
iframe || "iframe",
props
));
var onLoad = function (
) {
onload.call(
iframe.contentWindow
);
};
return (
window.frames[props.id]
? onLoad(
)
: iframe.addListener(
"load",
onLoad
),
iframe
);
}
),
Elements = (this.Elements = function (
nodes
) {
if (nodes && nodes.length)
for (var node, uniques = {
}, i = 0; (node = nodes[i++]); ) {
var uid = Slick.uidOf(
node
);
uniques[uid] || ((uniques[uid] = !0), this.push(
node
));
}
});
(Elements.prototype = {
length: 0,
}),
(Elements.parent = Array),
new Type(
"Elements",
Elements
).implement(
{
filter: function (
filter, bind
) {
return filter
? new Elements(
Array.filter(
this,
"string" == typeOf(
filter
)
? function (
item
) {
return item.match(
filter
);
}
: filter,
bind,
),
)
: this;
}.protect(
),
push: function (
) {
for (var length = this.length, i = 0, l = arguments.length; i < l; i++) {
var item = document.id(
arguments[i]
);
item && (this[length++] = item);
}
return (this.length = length);
}.protect(
),
unshift: function (
) {
for (var items = [], i = 0, l = arguments.length; i < l; i++) {
var item = document.id(
arguments[i]
);
item && items.push(
item
);
}
return Array.prototype.unshift.apply(
this,
items
);
}.protect(
),
concat: function (
) {
for (
var newElements = new Elements(
this
), i = 0, l = arguments.length;
i < l;
i++
) {
var item = arguments[i];
Type.isEnumerable(
item
)
? newElements.append(
item
)
: newElements.push(
item
);
}
return newElements;
}.protect(
),
append: function (
collection
) {
for (var i = 0, l = collection.length; i < l; i++)
this.push(
collection[i]
);
return this;
}.protect(
),
empty: function (
) {
for (; this.length; ) delete this[--this.length];
return this;
}.protect(
),
}
),
Elements.alias(
"extend",
"append"
),
(function (
) {
var createElementAcceptsHTML,
splice = Array.prototype.splice,
object = {
0: 0,
1: 1,
length: 2,
};
splice.call(
object,
1,
1
),
1 == object[1] &&
Elements.implement(
"splice",
function (
) {
for (
var length = this.length, result = splice.apply(
this,
arguments
);
length >= this.length;
)
delete this[length--];
return result;
}.protect(
),
),
Array.forEachMethod(
function (
method, name
) {
Elements.implement(
name,
method
);
}
),
Array.mirror(
Elements
);
try {
createElementAcceptsHTML =
"x" == document.createElement(
"<input name=x>"
).name;
} catch (e) {}
var escapeQuotes = function (
html
) {
return ("" + html).replace(
/&/g,
"&amp;"
).replace(
/"/g,
"&quot;"
);
};
Document.implement(
{
newElement: function (
tag, props
) {
return (
props &&
null != props.checked &&
(props.defaultChecked = props.checked),
createElementAcceptsHTML &&
props &&
((tag = "<" + tag),
props.name && (tag += ' name="' + escapeQuotes(
props.name
) + '"'),
props.type && (tag += ' type="' + escapeQuotes(
props.type
) + '"'),
(tag += ">"),
delete props.name,
delete props.type),
this.id(
this.createElement(
tag
)
).set(
props
)
);
},
}
);
})(
),
(function (
) {
var types;
Slick.uidOf(
window
),
Slick.uidOf(
document
),
Document.implement(
{
newTextNode: function (
text
) {
return this.createTextNode(
text
);
},
getDocument: function (
) {
return this;
},
getWindow: function (
) {
return this.window;
},
id:
((types = {
string: function (
id, nocash, doc
) {
return (id = Slick.find(
doc,
"#" + id.replace(
/(\W)/g,
"\\$1"
)
))
? types.element(
id,
nocash
)
: null;
},
element: function (
el, nocash
) {
if (
(Slick.uidOf(
el
),
!nocash &&
!el.$family &&
!/^(?:object|embed)$/i.test(
el.tagName
))
) {
var fireEvent = el.fireEvent;
(el._fireEvent = function (
type, event
) {
return fireEvent(
type,
event
);
}),
Object.append(
el,
Element.Prototype
);
}
return el;
},
object: function (
obj, nocash, doc
) {
return obj.toElement
? types.element(
obj.toElement(
doc
),
nocash
)
: null;
},
}),
(types.textnode = types.whitespace = types.window = types.document = function (
zero,
) {
return zero;
}),
function (
el, nocash, doc
) {
if (el && el.$family && el.uniqueNumber) return el;
var type = typeOf(
el
);
return types[type]
? types[type](
el,
nocash,
doc || document
)
: null;
}),
}
),
null == window.$ &&
Window.implement(
"$",
function (
el, nc
) {
return document.id(
el,
nc,
this.document
);
}
),
Window.implement(
{
getDocument: function (
) {
return this.document;
},
getWindow: function (
) {
return this;
},
}
),
[Document, Element,].invoke(
"implement",
{
getElements: function (
expression
) {
return Slick.search(
this,
expression,
new Elements(
)
);
},
getElement: function (
expression
) {
return document.id(
Slick.find(
this,
expression
)
);
},
}
);
var contains = {
contains: function (
element
) {
return Slick.contains(
this,
element
);
},
};
document.contains || Document.implement(
contains
),
document.createElement(
"div"
).contains || Element.implement(
contains
),
Element.implement(
"hasChild",
function (
element
) {
return this !== element && this.contains(
element
);
}
),
(function (
search, find, match
) {
this.Selectors = {
};
var pseudos = (this.Selectors.Pseudo = new Hash(
)),
addSlickPseudos = function (
) {
for (var name in pseudos)
pseudos.hasOwnProperty(
name
) &&
(Slick.definePseudo(
name,
pseudos[name]
), delete pseudos[name]);
};
(Slick.search = function (
context, expression, append
) {
return (
addSlickPseudos(
), search.call(
this,
context,
expression,
append
)
);
}),
(Slick.find = function (
context, expression
) {
return addSlickPseudos(
), find.call(
this,
context,
expression
);
}),
(Slick.match = function (
node, selector
) {
return addSlickPseudos(
), match.call(
this,
node,
selector
);
});
})(
Slick.search,
Slick.find,
Slick.match
);
var injectCombinator = function (
expression, combinator
) {
if (!expression) return combinator;
for (
var expressions = (expression = Object.clone(
Slick.parse(
expression
)
))
.expressions,
i = expressions.length;
i--;
)
expressions[i][0].combinator = combinator;
return expression;
};
Object.forEach(
{
getNext: "~",
getPrevious: "!~",
getParent: "!",
},
function (
combinator, method
) {
Element.implement(
method,
function (
expression
) {
return this.getElement(
injectCombinator(
expression,
combinator
)
);
}
);
},
),
Object.forEach(
{
getAllNext: "~",
getAllPrevious: "!~",
getSiblings: "~~",
getChildren: ">",
getParents: "!",
},
function (
combinator, method
) {
Element.implement(
method,
function (
expression
) {
return this.getElements(
injectCombinator(
expression,
combinator
)
);
}
);
},
),
Element.implement(
{
getFirst: function (
expression
) {
return document.id(
Slick.search(
this,
injectCombinator(
expression,
">"
)
)[0],
);
},
getLast: function (
expression
) {
return document.id(
Slick.search(
this,
injectCombinator(
expression,
">"
)
).getLast(
),
);
},
getWindow: function (
) {
return this.ownerDocument.window;
},
getDocument: function (
) {
return this.ownerDocument;
},
getElementById: function (
id
) {
return document.id(
Slick.find(
this,
"#" + ("" + id).replace(
/(\W)/g,
"\\$1"
)
),
);
},
match: function (
expression
) {
return !expression || Slick.match(
this,
expression
);
},
}
),
null == window.$$ &&
Window.implement(
"$$",
function (
selector
) {
var elements = new Elements(
);
if (1 == arguments.length && "string" == typeof selector)
return Slick.search(
this.document,
selector,
elements
);
for (
var args = Array.flatten(
arguments
), i = 0, l = args.length;
i < l;
i++
) {
var item = args[i];
switch (typeOf(
item
)) {
case "element":
elements.push(
item
);
break;
case "string":
Slick.search(
this.document,
item,
elements
);
}
}
return elements;
}
),
null == window.$$ &&
Window.implement(
"$$",
function (
selector
) {
if (1 == arguments.length) {
if ("string" == typeof selector)
return Slick.search(
this.document,
selector,
new Elements(
)
);
if (Type.isEnumerable(
selector
)) return new Elements(
selector
);
}
return new Elements(
arguments
);
}
);
var inserters = {
before: function (
context, element
) {
var parent = element.parentNode;
parent && parent.insertBefore(
context,
element
);
},
after: function (
context, element
) {
var parent = element.parentNode;
parent && parent.insertBefore(
context,
element.nextSibling
);
},
bottom: function (
context, element
) {
element.appendChild(
context
);
},
top: function (
context, element
) {
element.insertBefore(
context,
element.firstChild
);
},
};
(inserters.inside = inserters.bottom),
Object.each(
inserters,
function (
inserter, where
) {
var methods = {
};
(methods["inject" + (where = where.capitalize(
))] = function (
el
) {
return inserter(
this,
document.id(
el,
!0
)
), this;
}),
(methods["grab" + where] = function (
el
) {
return inserter(
document.id(
el,
!0
),
this
), this;
}),
Element.implement(
methods
);
}
);
var propertyGetters = {
},
propertySetters = {
},
properties = {
};
Array.forEach(
[
"type",
"value",
"defaultValue",
"accessKey",
"cellPadding",
"cellSpacing",
"colSpan",
"frameBorder",
"rowSpan",
"tabIndex",
"useMap",
],
function (
property
) {
properties[property.toLowerCase(
)] = property;
},
),
(properties.html = "innerHTML"),
(properties.text =
null == document.createElement(
"div"
).textContent
? "innerText"
: "textContent"),
Object.forEach(
properties,
function (
real, key
) {
(propertySetters[key] = function (
node, value
) {
node[real] = value;
}),
(propertyGetters[key] = function (
node
) {
return node[real];
});
}
);
var booleans = {
};
Array.forEach(
[
"compact",
"nowrap",
"ismap",
"declare",
"noshade",
"checked",
"disabled",
"readOnly",
"multiple",
"selected",
"noresize",
"defer",
"defaultChecked",
"autofocus",
"controls",
"autoplay",
"loop",
],
function (
bool
) {
var lower = bool.toLowerCase(
);
(booleans[lower] = bool),
(propertySetters[lower] = function (
node, value
) {
node[bool] = !!value;
}),
(propertyGetters[lower] = function (
node
) {
return !!node[bool];
});
},
),
Object.append(
propertySetters,
{
class: function (
node, value
) {
"className" in node
? (node.className = value || "")
: node.setAttribute(
"class",
value
);
},
for: function (
node, value
) {
"htmlFor" in node
? (node.htmlFor = value)
: node.setAttribute(
"for",
value
);
},
style: function (
node, value
) {
node.style
? (node.style.cssText = value)
: node.setAttribute(
"style",
value
);
},
value: function (
node, value
) {
node.value = null != value ? value : "";
},
}
),
(propertyGetters.class = function (
node
) {
return "className" in node
? node.className || null
: node.getAttribute(
"class"
);
});
var el = document.createElement(
"button"
);
try {
el.type = "button";
} catch (e) {}
"button" != el.type &&
(propertySetters.type = function (
node, value
) {
node.setAttribute(
"type",
value
);
}),
(el = null);
var input = document.createElement(
"input"
);
(input.value = "t"),
(input.type = "submit"),
"t" != input.value &&
(propertySetters.type = function (
node, type
) {
var value = node.value;
(node.type = type), (node.value = value);
}),
(input = null);
var pollutesGetAttribute = (function (
div
) {
return (
(div.random = "attribute"), "attribute" == div.getAttribute(
"random"
)
);
})(
document.createElement(
"div"
)
);
Element.implement(
{
setProperty: function (
name, value
) {
var setter = propertySetters[name.toLowerCase(
)];
if (setter) setter(
this,
value
);
else {
if (pollutesGetAttribute)
var attributeWhiteList = this.retrieve(
"$attributeWhiteList",
{
}
);
null == value
? (this.removeAttribute(
name
),
pollutesGetAttribute && delete attributeWhiteList[name])
: (this.setAttribute(
name,
"" + value
),
pollutesGetAttribute && (attributeWhiteList[name] = !0));
}
return this;
},
setProperties: function (
attributes
) {
for (var attribute in attributes)
this.setProperty(
attribute,
attributes[attribute]
);
return this;
},
getProperty: function (
name
) {
var getter = propertyGetters[name.toLowerCase(
)];
if (getter) return getter(
this
);
if (pollutesGetAttribute) {
var attr = this.getAttributeNode(
name
),
attributeWhiteList = this.retrieve(
"$attributeWhiteList",
{
}
);
if (!attr) return null;
if (attr.expando && !attributeWhiteList[name]) {
var outer = this.outerHTML;
if (
outer
.substr(
0,
outer.search(
/\/?['"]?>(?![^<]*<['"])/
)
)
.indexOf(
name
) < 0
)
return null;
attributeWhiteList[name] = !0;
}
}
var result = Slick.getAttribute(
this,
name
);
return result || Slick.hasAttribute(
this,
name
)
? result
: null;
},
getProperties: function (
) {
var args = Array.from(
arguments
);
return args.map(
this.getProperty,
this
).associate(
args
);
},
removeProperty: function (
name
) {
return this.setProperty(
name,
null
);
},
removeProperties: function (
) {
return Array.each(
arguments,
this.removeProperty,
this
), this;
},
set: function (
prop, value
) {
var property = Element.Properties[prop];
property && property.set
? property.set.call(
this,
value
)
: this.setProperty(
prop,
value
);
}.overloadSetter(
),
get: function (
prop
) {
var property = Element.Properties[prop];
return property && property.get
? property.get.apply(
this
)
: this.getProperty(
prop
);
}.overloadGetter(
),
erase: function (
prop
) {
var property = Element.Properties[prop];
return (
property && property.erase
? property.erase.apply(
this
)
: this.removeProperty(
prop
),
this
);
},
hasClass: function (
className
) {
return this.className.clean(
).contains(
className,
" "
);
},
addClass: function (
className
) {
return (
this.hasClass(
className
) ||
(this.className = (this.className + " " + className).clean(
)),
this
);
},
removeClass: function (
className
) {
return (
(this.className = this.className.replace(
new RegExp(
"(^|\\s)" + className + "(?:\\s|$)"
),
"$1",
)),
this
);
},
toggleClass: function (
className, force
) {
return (
null == force && (force = !this.hasClass(
className
)),
force
? this.addClass(
className
)
: this.removeClass(
className
)
);
},
adopt: function (
) {
var fragment,
parent = this,
elements = Array.flatten(
arguments
),
length = elements.length;
length > 1 && (parent = fragment = document.createDocumentFragment(
));
for (var i = 0; i < length; i++) {
var element = document.id(
elements[i],
!0
);
element && parent.appendChild(
element
);
}
return fragment && this.appendChild(
fragment
), this;
},
appendText: function (
text, where
) {
return this.grab(
this.getDocument(
).newTextNode(
text
),
where
);
},
grab: function (
el, where
) {
return inserters[where || "bottom"](
document.id(
el,
!0
),
this
), this;
},
inject: function (
el, where
) {
return inserters[where || "bottom"](
this,
document.id(
el,
!0
)
), this;
},
replaces: function (
el
) {
return (
(el = document.id(
el,
!0
)).parentNode.replaceChild(
this,
el
), this
);
},
wraps: function (
el, where
) {
return (el = document.id(
el,
!0
)), this.replaces(
el
).grab(
el,
where
);
},
getSelected: function (
) {
return (
this.selectedIndex,
new Elements(
Array.from(
this.options
).filter(
function (
option
) {
return option.selected;
}
),
)
);
},
toQueryString: function (
) {
var queryString = [];
return (
this.getElements(
"input, select, textarea"
).each(
function (
el
) {
var type = el.type;
if (
el.name &&
!el.disabled &&
"submit" != type &&
"reset" != type &&
"file" != type &&
"image" != type
) {
var value =
"select" == el.get(
"tag"
)
? el.getSelected(
).map(
function (
opt
) {
return document.id(
opt
).get(
"value"
);
}
)
: ("radio" != type && "checkbox" != type) || el.checked
? el.get(
"value"
)
: null;
Array.from(
value
).each(
function (
val
) {
void 0 !== val &&
queryString.push(
encodeURIComponent(
el.name
) + "=" + encodeURIComponent(
val
),
);
}
);
}
}
),
queryString.join(
"&"
)
);
},
}
);
var collected = {
},
storage = {
},
get = function (
uid
) {
return storage[uid] || (storage[uid] = {
});
},
clean = function (
item
) {
var uid = item.uniqueNumber;
return (
item.removeEvents && item.removeEvents(
),
item.clearAttributes && item.clearAttributes(
),
null != uid && (delete collected[uid], delete storage[uid]),
item
);
},
formProps = {
input: "checked",
option: "selected",
textarea: "value",
};
Element.implement(
{
destroy: function (
) {
var children = clean(
this
).getElementsByTagName(
"*"
);
return Array.each(
children,
clean
), 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 (
contents, keepid
) {
contents = !1 !== contents;
var i,
clone = this.cloneNode(
contents
),
ce = [clone,],
te = [this,];
for (
contents &&
(ce.append(
Array.from(
clone.getElementsByTagName(
"*"
)
)
),
te.append(
Array.from(
this.getElementsByTagName(
"*"
)
)
)),
i = ce.length;
i--;
) {
var node = ce[i],
element = te[i];
if (
(keepid || node.removeAttribute(
"id"
),
node.clearAttributes &&
(node.clearAttributes(
),
node.mergeAttributes(
element
),
node.removeAttribute(
"uniqueNumber"
),
node.options))
)
for (
var no = node.options, eo = element.options, j = no.length;
j--;
)
no[j].selected = eo[j].selected;
var prop = formProps[element.tagName.toLowerCase(
)];
prop && element[prop] && (node[prop] = element[prop]);
}
if (Browser.ie) {
var co = clone.getElementsByTagName(
"object"
),
to = this.getElementsByTagName(
"object"
);
for (i = co.length; i--; ) co[i].outerHTML = to[i].outerHTML;
}
return document.id(
clone
);
},
}
),
[Element, Window, Document,].invoke(
"implement",
{
addListener: function (
type, fn
) {
if ("unload" == type) {
var old = fn,
self = this;
fn = function (
) {
self.removeListener(
"unload",
fn
), old(
);
};
} else collected[Slick.uidOf(
this
)] = this;
return (
this.addEventListener
? this.addEventListener(
type,
fn,
!!arguments[2]
)
: this.attachEvent(
"on" + type,
fn
),
this
);
},
removeListener: function (
type, fn
) {
return (
this.removeEventListener
? this.removeEventListener(
type,
fn,
!!arguments[2]
)
: this.detachEvent(
"on" + type,
fn
),
this
);
},
retrieve: function (
property, dflt
) {
var storage = get(
Slick.uidOf(
this
)
),
prop = storage[property];
return (
null != dflt && null == prop && (prop = storage[property] = dflt),
null != prop ? prop : null
);
},
store: function (
property, value
) {
return (get(
Slick.uidOf(
this
)
)[property] = value), this;
},
eliminate: function (
property
) {
return delete get(
Slick.uidOf(
this
)
)[property], this;
},
}
),
window.attachEvent &&
!window.addEventListener &&
window.addListener(
"unload",
function (
) {
Object.each(
collected,
clean
),
window.CollectGarbage && CollectGarbage(
);
}
),
(Element.Properties = {
}),
(Element.Properties = new Hash(
)),
(Element.Properties.style = {
set: function (
style
) {
this.style.cssText = style;
},
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 (
html
) {
null == html
? (html = "")
: "array" == typeOf(
html
) && (html = html.join(
""
)),
(this.innerHTML = html);
},
erase: function (
) {
this.innerHTML = "";
},
});
var div = document.createElement(
"div"
);
div.innerHTML = "<nav></nav>";
var supportsHTML5Elements = 1 == div.childNodes.length;
if (!supportsHTML5Elements)
for (
var tags = "abbr article aside audio canvas datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video".split(
" ",
),
fragment = document.createDocumentFragment(
),
l = tags.length;
l--;
)
fragment.createElement(
tags[l]
);
div = null;
var supportsTableInnerHTML = Function.attempt(
function (
) {
return (
(document.createElement(
"table"
).innerHTML = "<tr><td></td></tr>"), !0
);
}
),
tr = document.createElement(
"tr"
);
tr.innerHTML = "<td></td>";
var set,
translations,
supportsTRInnerHTML = "<td></td>" == tr.innerHTML;
(tr = null),
(supportsTableInnerHTML &&
supportsTRInnerHTML &&
supportsHTML5Elements) ||
(Element.Properties.html.set =
((set = Element.Properties.html.set),
((translations = {
table: [1, "<table>", "</table>",],
select: [1, "<select>", "</select>",],
tbody: [2, "<table><tbody>", "</tbody></table>",],
tr: [3, "<table><tbody><tr>", "</tr></tbody></table>",],
}).thead = translations.tfoot = translations.tbody),
function (
html
) {
var wrap = translations[this.get(
"tag"
)];
if ((wrap || supportsHTML5Elements || (wrap = [0, "", "",]), !wrap))
return set.call(
this,
html
);
var level = wrap[0],
wrapper = document.createElement(
"div"
),
target = wrapper;
for (
supportsHTML5Elements || fragment.appendChild(
wrapper
),
wrapper.innerHTML = [wrap[1], html, wrap[2],].flatten(
).join(
""
);
level--;
)
target = target.firstChild;
this.empty(
).adopt(
target.childNodes
),
supportsHTML5Elements || fragment.removeChild(
wrapper
),
(wrapper = null);
}));
var testForm = document.createElement(
"form"
);
(testForm.innerHTML = "<select><option>s</option></select>"),
"s" != testForm.firstChild.value &&
(Element.Properties.value = {
set: function (
value
) {
if ("select" != this.get(
"tag"
))
return this.setProperty(
"value",
value
);
for (
var options = this.getElements(
"option"
), i = 0;
i < options.length;
i++
) {
var option = options[i],
attr = option.getAttributeNode(
"value"
);
if (
(attr && attr.specified
? option.value
: option.get(
"text"
)) ==
value
)
return (option.selected = !0);
}
},
get: function (
) {
var option = this,
tag = option.get(
"tag"
);
if ("select" != tag && "option" != tag)
return this.getProperty(
"value"
);
if ("select" == tag && !(option = option.getSelected(
)[0]))
return "";
var attr = option.getAttributeNode(
"value"
);
return attr && attr.specified
? option.value
: option.get(
"text"
);
},
}),
(testForm = null),
document.createElement(
"div"
).getAttributeNode(
"id"
) &&
(Element.Properties.id = {
set: function (
id
) {
this.id = this.getAttributeNode(
"id"
).value = id;
},
get: function (
) {
return this.id || null;
},
erase: function (
) {
this.id = this.getAttributeNode(
"id"
).value = "";
},
});
})(
),
(function (
) {
var html = document.html,
el = document.createElement(
"div"
);
(el.style.color = "red"), (el.style.color = null);
var doesNotRemoveStyles = "red" == el.style.color;
(el = null),
(Element.Properties.styles = {
set: function (
styles
) {
this.setStyles(
styles
);
},
});
var hasOpacity = null != html.style.opacity,
hasFilter = null != html.style.filter,
reAlpha = /alpha\(opacity=([\d.]+)\)/i,
setVisibility = function (
element, opacity
) {
element.store(
"$opacity",
opacity
),
(element.style.visibility =
opacity > 0 || null == opacity ? "visible" : "hidden");
},
setOpacity = hasOpacity
? function (
element, opacity
) {
element.style.opacity = opacity;
}
: hasFilter
? function (
element, opacity
) {
var style = element.style;
(element.currentStyle && element.currentStyle.hasLayout) ||
(style.zoom = 1),
(opacity =
null == opacity || 1 == opacity
? ""
: "alpha(opacity=" +
(100 * opacity).limit(
0,
100
).round(
) +
")");
var filter =
style.filter || element.getComputedStyle(
"filter"
) || "";
(style.filter = reAlpha.test(
filter
)
? filter.replace(
reAlpha,
opacity
)
: filter + opacity),
style.filter || style.removeAttribute(
"filter"
);
}
: setVisibility,
getOpacity = hasOpacity
? function (
element
) {
var opacity =
element.style.opacity || element.getComputedStyle(
"opacity"
);
return "" == opacity
? 1
: opacity.toFloat(
);
}
: hasFilter
? function (
element
) {
var opacity,
filter =
element.style.filter || element.getComputedStyle(
"filter"
);
return (
filter && (opacity = filter.match(
reAlpha
)),
null == opacity || null == filter ? 1 : opacity[1] / 100
);
}
: function (
element
) {
var opacity = element.retrieve(
"$opacity"
);
return (
null == opacity &&
(opacity = "hidden" == element.style.visibility ? 0 : 1),
opacity
);
},
floatName = null == html.style.cssFloat ? "styleFloat" : "cssFloat";
Element.implement(
{
getComputedStyle: function (
property
) {
if (this.currentStyle) return this.currentStyle[property.camelCase(
)];
var defaultView = Element.getDocument(
this
).defaultView,
computed = defaultView
? defaultView.getComputedStyle(
this,
null
)
: null;
return computed
? computed.getPropertyValue(
property == floatName
? "float"
: property.hyphenate(
),
)
: null;
},
setStyle: function (
property, value
) {
if ("opacity" == property)
return (
null != value && (value = parseFloat(
value
)),
setOpacity(
this,
value
),
this
);
if (
((property = ("float" == property
? floatName
: property
).camelCase(
)),
"string" != typeOf(
value
))
) {
var map = (Element.Styles[property] || "@").split(
" "
);
value = Array.from(
value
)
.map(
function (
val, i
) {
return map[i]
? "number" == typeOf(
val
)
? map[i].replace(
"@",
Math.round(
val
)
)
: val
: "";
}
)
.join(
" "
);
} else value == String(
Number(
value
)
) && (value = Math.round(
value
));
return (
(this.style[property] = value),
("" == value || null == value) &&
doesNotRemoveStyles &&
this.style.removeAttribute &&
this.style.removeAttribute(
property
),
this
);
},
getStyle: function (
property
) {
if ("opacity" == property) return getOpacity(
this
);
property = ("float" == property ? floatName : property).camelCase(
);
var result = this.style[property];
if (!result || "zIndex" == property) {
for (var style in ((result = []), Element.ShortStyles))
if (property == style) {
for (var s in Element.ShortStyles[style])
result.push(
this.getStyle(
s
)
);
return result.join(
" "
);
}
result = this.getComputedStyle(
property
);
}
if (result) {
var color = (result = String(
result
)).match(
/rgba?\([\d\s,]+\)/
);
color && (result = result.replace(
color[0],
color[0].rgbToHex(
)
));
}
if (Browser.opera || Browser.ie) {
if (/^(height|width)$/.test(
property
) && !/px$/.test(
result
)) {
var size = 0;
return (
("width" == property
? ["left", "right",]
: ["top", "bottom",]
).each(
function (
value
) {
size +=
this.getStyle(
"border-" + value + "-width"
).toInt(
) +
this.getStyle(
"padding-" + value
).toInt(
);
},
this
),
this["offset" + property.capitalize(
)] - size + "px"
);
}
if (
Browser.ie &&
/^border(.+)Width|margin|padding/.test(
property
) &&
isNaN(
parseFloat(
result
)
)
)
return "0px";
}
return result;
},
setStyles: function (
styles
) {
for (var style in styles) this.setStyle(
style,
styles[style]
);
return this;
},
getStyles: function (
) {
var result = {
};
return (
Array.flatten(
arguments
).each(
function (
key
) {
result[key] = this.getStyle(
key
);
},
this
),
result
);
},
}
),
(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 (
value
) {
return setOpacity(
this,
value
), this;
},
getOpacity: function (
) {
return getOpacity(
this
);
},
}
),
(Element.Properties.opacity = {
set: function (
opacity
) {
setOpacity(
this,
opacity
), setVisibility(
this,
opacity
);
},
get: function (
) {
return getOpacity(
this
);
},
}),
(Element.Styles = new Hash(
Element.Styles
)),
(Element.ShortStyles = {
margin: {
},
padding: {
},
border: {
},
borderWidth: {
},
borderStyle: {
},
borderColor: {
},
}),
["Top", "Right", "Bottom", "Left",].each(
function (
direction
) {
var Short = Element.ShortStyles,
All = Element.Styles;
["margin", "padding",].each(
function (
style
) {
var sd = style + direction;
Short[style][sd] = All[sd] = "@px";
}
);
var bd = "border" + direction;
Short.border[bd] = All[bd] = "@px @ rgb(@, @, @)";
var bdw = bd + "Width",
bds = bd + "Style",
bdc = bd + "Color";
(Short[bd] = {
}),
(Short.borderWidth[bdw] = Short[bd][bdw] = All[bdw] = "@px"),
(Short.borderStyle[bds] = Short[bd][bds] = All[bds] = "@"),
(Short.borderColor[bdc] = Short[bd][bdc] = All[bdc] = "rgb(@, @, @)");
}
);
})(
),
(function (
) {
if (
((Element.Properties.events = {
set: function (
events
) {
this.addEvents(
events
);
},
}),
[Element, Window, Document,].invoke(
"implement",
{
addEvent: function (
type, fn
) {
var events = this.retrieve(
"events",
{
}
);
if (
(events[type] || (events[type] = {
keys: [],
values: [],
}),
events[type].keys.contains(
fn
))
)
return this;
events[type].keys.push(
fn
);
var realType = type,
custom = Element.Events[type],
condition = fn,
self = this;
custom &&
(custom.onAdd && custom.onAdd.call(
this,
fn,
type
),
custom.condition &&
(condition = function (
event
) {
return (
!custom.condition.call(
this,
event,
type
) ||
fn.call(
this,
event
)
);
}),
custom.base &&
(realType = Function.from(
custom.base
).call(
this,
type
)));
var defn = function (
) {
return fn.call(
self
);
},
nativeEvent = Element.NativeEvents[realType];
return (
nativeEvent &&
(2 == nativeEvent &&
(defn = function (
event
) {
(event = new DOMEvent(
event,
self.getWindow(
)
)),
!1 === condition.call(
self,
event
) && event.stop(
);
}),
this.addListener(
realType,
defn,
arguments[2]
)),
events[type].values.push(
defn
),
this
);
},
removeEvent: function (
type, fn
) {
var events = this.retrieve(
"events"
);
if (!events || !events[type]) return this;
var list = events[type],
index = list.keys.indexOf(
fn
);
if (-1 == index) return this;
var value = list.values[index];
delete list.keys[index], delete list.values[index];
var custom = Element.Events[type];
return (
custom &&
(custom.onRemove && custom.onRemove.call(
this,
fn,
type
),
custom.base &&
(type = Function.from(
custom.base
).call(
this,
type
))),
Element.NativeEvents[type]
? this.removeListener(
type,
value,
arguments[2]
)
: this
);
},
addEvents: function (
events
) {
for (var event in events) this.addEvent(
event,
events[event]
);
return this;
},
removeEvents: function (
events
) {
var type;
if ("object" == typeOf(
events
)) {
for (type in events) this.removeEvent(
type,
events[type]
);
return this;
}
var attached = this.retrieve(
"events"
);
if (!attached) return this;
if (events)
attached[events] &&
(attached[events].keys.each(
function (
fn
) {
this.removeEvent(
events,
fn
);
},
this
),
delete attached[events]);
else {
for (type in attached) this.removeEvents(
type
);
this.eliminate(
"events"
);
}
return this;
},
fireEvent: function (
type, args, delay
) {
var events = this.retrieve(
"events"
);
return events && events[type]
? ((args = Array.from(
args
)),
events[type].keys.each(
function (
fn
) {
delay
? fn.delay(
delay,
this,
args
)
: fn.apply(
this,
args
);
},
this
),
this)
: this;
},
cloneEvents: function (
from, type
) {
var events = (from = document.id(
from
)).retrieve(
"events"
);
if (!events) return this;
if (type)
events[type] &&
events[type].keys.each(
function (
fn
) {
this.addEvent(
type,
fn
);
},
this
);
else for (var eventType in events) this.cloneEvents(
from,
eventType
);
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 check = function (
event
) {
var related = event.relatedTarget;
return (
null == related ||
(!!related &&
related != this &&
"xul" != related.prefix &&
"document" != typeOf(
this
) &&
!this.contains(
related
))
);
};
(Element.Events.mouseenter = {
base: "mouseover",
condition: check,
}),
(Element.Events.mouseleave = {
base: "mouseout",
condition: check,
});
}
window.addEventListener ||
((Element.NativeEvents.propertychange = 2),
(Element.Events.change = {
base: function (
) {
var type = this.type;
return "input" != this.get(
"tag"
) ||
("radio" != type && "checkbox" != type)
? "change"
: "propertychange";
},
condition: function (
event
) {
return (
"radio" != this.type ||
("checked" == event.event.propertyName && this.checked)
);
},
})),
(Element.Events = new Hash(
Element.Events
));
})(
),
(function (
) {
var eventListenerSupport = !!window.addEventListener;
Element.NativeEvents.focusin = Element.NativeEvents.focusout = 2;
var bubbleUp = function (
self, match, fn, event, target
) {
for (; target && target != self; ) {
if (match(
target,
event
)) return fn.call(
target,
event,
target
);
target = document.id(
target.parentNode
);
}
},
map = {
mouseenter: {
base: "mouseover",
},
mouseleave: {
base: "mouseout",
},
focus: {
base: "focus" + (eventListenerSupport ? "" : "in"),
capture: !0,
},
blur: {
base: eventListenerSupport ? "blur" : "focusout",
capture: !0,
},
},
_key = "$delegation:",
formObserver = function (
type
) {
return {
base: "focusin",
remove: function (
self, uid
) {
var list = self.retrieve(
_key + type + "listeners",
{
}
)[uid];
if (list && list.forms)
for (var i = list.forms.length; i--; )
list.forms[i].removeEvent(
type,
list.fns[i]
);
},
listen: function (
self, match, fn, event, target, uid
) {
var form =
"form" == target.get(
"tag"
)
? target
: event.target.getParent(
"form"
);
if (form) {
var listeners = self.retrieve(
_key + type + "listeners",
{
}
),
listener = listeners[uid] || {
forms: [],
fns: [],
},
forms = listener.forms,
fns = listener.fns;
if (-1 == forms.indexOf(
form
)) {
forms.push(
form
);
var _fn = function (
event
) {
bubbleUp(
self,
match,
fn,
event,
target
);
};
form.addEvent(
type,
_fn
),
fns.push(
_fn
),
(listeners[uid] = listener),
self.store(
_key + type + "listeners",
listeners
);
}
}
},
};
},
inputObserver = function (
type
) {
return {
base: "focusin",
listen: function (
self, match, fn, event, target
) {
var events = {
blur: function (
) {
this.removeEvents(
events
);
},
};
(events[type] = function (
event
) {
bubbleUp(
self,
match,
fn,
event,
target
);
}),
event.target.addEvents(
events
);
},
};
};
eventListenerSupport ||
Object.append(
map,
{
submit: formObserver(
"submit"
),
reset: formObserver(
"reset"
),
change: inputObserver(
"change"
),
select: inputObserver(
"select"
),
}
);
var proto = Element.prototype,
addEvent = proto.addEvent,
removeEvent = proto.removeEvent,
relay = function (
old, method
) {
return function (
type, fn, useCapture
) {
if (-1 == type.indexOf(
":relay"
))
return old.call(
this,
type,
fn,
useCapture
);
var parsed = Slick.parse(
type
).expressions[0][0];
if ("relay" != parsed.pseudos[0].key)
return old.call(
this,
type,
fn,
useCapture
);
var newType = parsed.tag;
return (
parsed.pseudos.slice(
1
).each(
function (
pseudo
) {
newType +=
":" +
pseudo.key +
(pseudo.value ? "(" + pseudo.value + ")" : "");
}
),
old.call(
this,
type,
fn
),
method.call(
this,
newType,
parsed.pseudos[0].value,
fn
)
);
};
},
delegation = {
addEvent: function (
type, match, fn
) {
var storage = this.retrieve(
"$delegates",
{
}
),
stored = storage[type];
if (stored)
for (var _uid in stored)
if (stored[_uid].fn == fn && stored[_uid].match == match)
return this;
var _type = type,
_match = match,
_fn = fn,
_map = map[type] || {
};
(type = _map.base || _type),
(match = function (
target
) {
return Slick.match(
target,
_match
);
});
var elementEvent = Element.Events[_type];
if (elementEvent && elementEvent.condition) {
var __match = match,
condition = elementEvent.condition;
match = function (
target, event
) {
return (
__match(
target,
event
) && condition.call(
target,
event,
type
)
);
};
}
var self = this,
uid = String.uniqueID(
),
delegator = _map.listen
? function (
event, target
) {
!target && event && event.target && (target = event.target),
target && _map.listen(
self,
match,
fn,
event,
target,
uid
);
}
: function (
event, target
) {
!target && event && event.target && (target = event.target),
target && bubbleUp(
self,
match,
fn,
event,
target
);
};
return (
stored || (stored = {
}),
(stored[uid] = {
match: _match,
fn: _fn,
delegator: delegator,
}),
(storage[_type] = stored),
addEvent.call(
this,
type,
delegator,
_map.capture
)
);
},
removeEvent: function (
type, match, fn, _uid
) {
var __uid,
s,
storage = this.retrieve(
"$delegates",
{
}
),
stored = storage[type];
if (!stored) return this;
if (_uid) {
var _type = type,
delegator = stored[_uid].delegator,
_map = map[type] || {
};
return (
(type = _map.base || _type),
_map.remove && _map.remove(
this,
_uid
),
delete stored[_uid],
(storage[_type] = stored),
removeEvent.call(
this,
type,
delegator
)
);
}
if (fn) {
for (__uid in stored)
if ((s = stored[__uid]).match == match && s.fn == fn)
return delegation.removeEvent.call(
this,
type,
match,
fn,
__uid,
);
} else
for (__uid in stored)
(s = stored[__uid]).match == match &&
delegation.removeEvent.call(
this,
type,
match,
s.fn,
__uid
);
return this;
},
};
[Element, Window, Document,].invoke(
"implement",
{
addEvent: relay(
addEvent,
delegation.addEvent
),
removeEvent: relay(
removeEvent,
delegation.removeEvent
),
}
);
})(
),
(function (
) {
var element = document.createElement(
"div"
),
child = document.createElement(
"div"
);
(element.style.height = "0"), element.appendChild(
child
);
var brokenOffsetParent = child.offsetParent === element;
element = child = null;
var isOffset = function (
el
) {
return "static" != styleString(
el,
"position"
) || isBody(
el
);
},
isOffsetStatic = function (
el
) {
return isOffset(
el
) || /^(?:table|td|th)$/i.test(
el.tagName
);
};
Element.implement(
{
scrollTo: function (
x, y
) {
return (
isBody(
this
)
? this.getWindow(
).scrollTo(
x,
y
)
: ((this.scrollLeft = x), (this.scrollTop = y)),
this
);
},
getSize: function (
) {
return isBody(
this
)
? this.getWindow(
).getSize(
)
: {
x: this.offsetWidth,
y: this.offsetHeight,
};
},
getScrollSize: function (
) {
return isBody(
this
)
? this.getWindow(
).getScrollSize(
)
: {
x: this.scrollWidth,
y: this.scrollHeight,
};
},
getScroll: function (
) {
return isBody(
this
)
? this.getWindow(
).getScroll(
)
: {
x: this.scrollLeft,
y: this.scrollTop,
};
},
getScrolls: function (
) {
for (
var element = this.parentNode, position = {
x: 0,
y: 0,
};
element && !isBody(
element
);
)
(position.x += element.scrollLeft),
(position.y += element.scrollTop),
(element = element.parentNode);
return position;
},
getOffsetParent: brokenOffsetParent
? function (
) {
var element = this;
if (isBody(
element
) || "fixed" == styleString(
element,
"position"
))
return null;
for (
var isOffsetCheck =
"static" == styleString(
element,
"position"
)
? isOffsetStatic
: isOffset;
(element = element.parentNode);
)
if (isOffsetCheck(
element
)) return element;
return null;
}
: function (
) {
if (isBody(
this
) || "fixed" == styleString(
this,
"position"
))
return null;
try {
return this.offsetParent;
} catch (e) {}
return null;
},
getOffsets: function (
) {
if (this.getBoundingClientRect && !Browser.Platform.ios) {
var bound = this.getBoundingClientRect(
),
html = document.id(
this.getDocument(
).documentElement
),
htmlScroll = html.getScroll(
),
elemScrolls = this.getScrolls(
),
isFixed = "fixed" == styleString(
this,
"position"
);
return {
x:
bound.left.toInt(
) +
elemScrolls.x +
(isFixed ? 0 : htmlScroll.x) -
html.clientLeft,
y:
bound.top.toInt(
) +
elemScrolls.y +
(isFixed ? 0 : htmlScroll.y) -
html.clientTop,
};
}
var element = this,
position = {
x: 0,
y: 0,
};
if (isBody(
this
)) return position;
for (; element && !isBody(
element
); ) {
if (
((position.x += element.offsetLeft),
(position.y += element.offsetTop),
Browser.firefox)
) {
borderBox(
element
) ||
((position.x += leftBorder(
element
)),
(position.y += topBorder(
element
)));
var parent = element.parentNode;
parent &&
"visible" != styleString(
parent,
"overflow"
) &&
((position.x += leftBorder(
parent
)),
(position.y += topBorder(
parent
)));
} else
element != this &&
Browser.safari &&
((position.x += leftBorder(
element
)),
(position.y += topBorder(
element
)));
element = element.offsetParent;
}
return (
Browser.firefox &&
!borderBox(
this
) &&
((position.x -= leftBorder(
this
)), (position.y -= topBorder(
this
))),
position
);
},
getPosition: function (
relative
) {
var offset = this.getOffsets(
),
scroll = this.getScrolls(
),
position = {
x: offset.x - scroll.x,
y: offset.y - scroll.y,
};
if (relative && (relative = document.id(
relative
))) {
var relativePosition = relative.getPosition(
);
return {
x: position.x - relativePosition.x - leftBorder(
relative
),
y: position.y - relativePosition.y - topBorder(
relative
),
};
}
return position;
},
getCoordinates: function (
element
) {
if (isBody(
this
)) return this.getWindow(
).getCoordinates(
);
var position = this.getPosition(
element
),
size = this.getSize(
),
obj = {
left: position.x,
top: position.y,
width: size.x,
height: size.y,
};
return (
(obj.right = obj.left + obj.width),
(obj.bottom = obj.top + obj.height),
obj
);
},
computePosition: function (
obj
) {
return {
left: obj.x - styleNumber(
this,
"margin-left"
),
top: obj.y - styleNumber(
this,
"margin-top"
),
};
},
setPosition: function (
obj
) {
return this.setStyles(
this.computePosition(
obj
)
);
},
}
),
[Document, Window,].invoke(
"implement",
{
getSize: function (
) {
var doc = getCompatElement(
this
);
return {
x: doc.clientWidth,
y: doc.clientHeight,
};
},
getScroll: function (
) {
var win = this.getWindow(
),
doc = getCompatElement(
this
);
return {
x: win.pageXOffset || doc.scrollLeft,
y: win.pageYOffset || doc.scrollTop,
};
},
getScrollSize: function (
) {
var doc = getCompatElement(
this
),
min = this.getSize(
),
body = this.getDocument(
).body;
return {
x: Math.max(
doc.scrollWidth,
body.scrollWidth,
min.x
),
y: Math.max(
doc.scrollHeight,
body.scrollHeight,
min.y
),
};
},
getPosition: function (
) {
return {
x: 0,
y: 0,
};
},
getCoordinates: function (
) {
var size = this.getSize(
);
return {
top: 0,
left: 0,
bottom: size.y,
right: size.x,
height: size.y,
width: size.x,
};
},
}
);
var styleString = Element.getComputedStyle;
function styleNumber(
element, style
) {
return styleString(
element,
style
).toInt(
) || 0;
}
function borderBox(
element
) {
return "border-box" == styleString(
element,
"-moz-box-sizing"
);
}
function topBorder(
element
) {
return styleNumber(
element,
"border-top-width"
);
}
function leftBorder(
element
) {
return styleNumber(
element,
"border-left-width"
);
}
function isBody(
element
) {
return /^(?:body|html)$/i.test(
element.tagName
);
}
function getCompatElement(
element
) {
var doc = element.getDocument(
);
return doc.compatMode && "CSS1Compat" != doc.compatMode
? doc.body
: doc.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 Fx = (this.Fx = new Class(
{
Implements: [Chain, Events, Options,],
options: {
fps: 60,
unit: !1,
duration: 500,
frames: null,
frameSkip: !0,
link: "ignore",
},
initialize: function (
options
) {
(this.subject = this.subject || this), this.setOptions(
options
);
},
getTransition: function (
) {
return function (
p
) {
return -(Math.cos(
Math.PI * p
) - 1) / 2;
};
},
step: function (
now
) {
if (this.options.frameSkip) {
var frames =
(null != this.time ? now - this.time : 0) / this.frameInterval;
(this.time = now), (this.frame += frames);
} else this.frame++;
if (this.frame < this.frames) {
var delta = this.transition(
this.frame / this.frames
);
this.set(
this.compute(
this.from,
this.to,
delta
)
);
} else
(this.frame = this.frames),
this.set(
this.compute(
this.from,
this.to,
1
)
),
this.stop(
);
},
set: function (
now
) {
return now;
},
compute: function (
from, to, delta
) {
return Fx.compute(
from,
to,
delta
);
},
check: function (
) {
if (!this.isRunning(
)) return !0;
switch (this.options.link) {
case "cancel":
return this.cancel(
), !0;
case "chain":
return this.chain(
this.caller.pass(
arguments,
this
)
), !1;
}
return !1;
},
start: function (
from, to
) {
if (!this.check(
from,
to
)) return this;
(this.from = from),
(this.to = to),
(this.frame = this.options.frameSkip ? 0 : -1),
(this.time = null),
(this.transition = this.getTransition(
));
var frames = this.options.frames,
fps = this.options.fps,
duration = this.options.duration;
return (
(this.duration = Fx.Durations[duration] || duration.toInt(
)),
(this.frameInterval = 1e3 / fps),
(this.frames =
frames || Math.round(
this.duration / this.frameInterval
)),
this.fireEvent(
"start",
this.subject
),
pushInstance.call(
this,
fps
),
this
);
},
stop: function (
) {
return (
this.isRunning(
) &&
((this.time = null),
pullInstance.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),
pullInstance.call(
this,
this.options.fps
),
(this.frame = this.frames),
this.fireEvent(
"cancel",
this.subject
).clearChain(
)),
this
);
},
pause: function (
) {
return (
this.isRunning(
) &&
((this.time = null), pullInstance.call(
this,
this.options.fps
)),
this
);
},
resume: function (
) {
return (
this.frame < this.frames &&
!this.isRunning(
) &&
pushInstance.call(
this,
this.options.fps
),
this
);
},
isRunning: function (
) {
var list = instances[this.options.fps];
return list && list.contains(
this
);
},
}
));
(Fx.compute = function (
from, to, delta
) {
return (to - from) * delta + from;
}),
(Fx.Durations = {
short: 250,
normal: 500,
long: 1e3,
});
var instances = {
},
timers = {
},
loop = function (
) {
for (var now = Date.now(
), i = this.length; i--; ) {
var instance = this[i];
instance && instance.step(
now
);
}
},
pushInstance = function (
fps
) {
var list = instances[fps] || (instances[fps] = []);
list.push(
this
),
timers[fps] ||
(timers[fps] = loop.periodical(
Math.round(
1e3 / fps
),
list
));
},
pullInstance = function (
fps
) {
var list = instances[fps];
list &&
(list.erase(
this
),
!list.length &&
timers[fps] &&
(delete instances[fps],
(timers[fps] = clearInterval(
timers[fps]
))));
};
})(
),
(Fx.CSS = new Class(
{
Extends: Fx,
prepare: function (
element, property, values
) {
var from = (values = Array.from(
values
))[0],
to = values[1];
if (null == to) {
(to = from), (from = element.getStyle(
property
));
var unit = this.options.unit;
if (unit && from.slice(
-unit.length
) != unit && 0 != parseFloat(
from
)) {
element.setStyle(
property,
to + unit
);
var value = element.getComputedStyle(
property
);
if (
!/px$/.test(
value
) &&
null == (value = element.style[("pixel-" + property).camelCase(
)])
) {
var left = element.style.left;
(element.style.left = to + unit),
(value = element.style.pixelLeft),
(element.style.left = left);
}
(from =
((to || 1) / (parseFloat(
value
) || 1)) * (parseFloat(
from
) || 0)),
element.setStyle(
property,
from + unit
);
}
}
return {
from: this.parse(
from
),
to: this.parse(
to
),
};
},
parse: function (
value
) {
return (value =
"string" == typeof (value = Function.from(
value
)(
))
? value.split(
" "
)
: Array.from(
value
)).map(
function (
val
) {
val = String(
val
);
var found = !1;
return (
Object.each(
Fx.CSS.Parsers,
function (
parser, key
) {
if (!found) {
var parsed = parser.parse(
val
);
(parsed || 0 === parsed) &&
(found = {
value: parsed,
parser: parser,
});
}
}
),
(found = found || {
value: val,
parser: Fx.CSS.Parsers.String,
})
);
}
);
},
compute: function (
from, to, delta
) {
var computed = [];
return (
Math.min(
from.length,
to.length
).times(
function (
i
) {
computed.push(
{
value: from[i].parser.compute(
from[i].value,
to[i].value,
delta
),
parser: from[i].parser,
}
);
}
),
(computed.$family = Function.from(
"fx:css:value"
)),
computed
);
},
serve: function (
value, unit
) {
"fx:css:value" != typeOf(
value
) && (value = this.parse(
value
));
var returned = [];
return (
value.each(
function (
bit
) {
returned = returned.concat(
bit.parser.serve(
bit.value,
unit
)
);
}
),
returned
);
},
render: function (
element, property, value, unit
) {
element.setStyle(
property,
this.serve(
value,
unit
)
);
},
search: function (
selector
) {
if (Fx.CSS.Cache[selector]) return Fx.CSS.Cache[selector];
var to = {
},
selectorTest = new RegExp(
"^" + selector.escapeRegExp(
) + "$"
);
return (
Array.each(
document.styleSheets,
function (
sheet, j
) {
var href = sheet.href;
if (
!href ||
!href.contains(
"://"
) ||
href.contains(
document.domain
)
) {
var rules = sheet.rules || sheet.cssRules;
Array.each(
rules,
function (
rule, i
) {
if (rule.style) {
var selectorText = rule.selectorText
? rule.selectorText.replace(
/^\w+/,
function (
m
) {
return m.toLowerCase(
);
}
)
: null;
selectorText &&
selectorTest.test(
selectorText
) &&
Object.each(
Element.Styles,
function (
value, style
) {
rule.style[style] &&
!Element.ShortStyles[style] &&
((value = String(
rule.style[style]
)),
(to[style] = /^rgb/.test(
value
)
? value.rgbToHex(
)
: value));
}
);
}
}
);
}
}
),
(Fx.CSS.Cache[selector] = to)
);
},
}
)),
(Fx.CSS.Cache = {
}),
(Fx.CSS.Parsers = {
Color: {
parse: function (
value
) {
return value.match(
/^#[0-9a-f]{3,6}$/i
)
? value.hexToRgb(
!0
)
: !!(value = value.match(
/(\d+),\s*(\d+),\s*(\d+)/
)) && [
value[1],
value[2],
value[3],
];
},
compute: function (
from, to, delta
) {
return from.map(
function (
value, i
) {
return Math.round(
Fx.compute(
from[i],
to[i],
delta
)
);
}
);
},
serve: function (
value
) {
return value.map(
Number
);
},
},
Number: {
parse: parseFloat,
compute: Fx.compute,
serve: function (
value, unit
) {
return unit ? value + unit : value;
},
},
String: {
parse: Function.from(
!1
),
compute: function (
zero, one
) {
return one;
},
serve: function (
zero
) {
return zero;
},
},
}),
(Fx.CSS.Parsers = new Hash(
Fx.CSS.Parsers
)),
(Fx.Tween = new Class(
{
Extends: Fx.CSS,
initialize: function (
element, options
) {
(this.element = this.subject = document.id(
element
)),
this.parent(
options
);
},
set: function (
property, now
) {
return (
1 == arguments.length &&
((now = property),
(property = this.property || this.options.property)),
this.render(
this.element,
property,
now,
this.options.unit
),
this
);
},
start: function (
property, from, to
) {
if (!this.check(
property,
from,
to
)) return this;
var args = Array.flatten(
arguments
);
this.property = this.options.property || args.shift(
);
var parsed = this.prepare(
this.element,
this.property,
args
);
return this.parent(
parsed.from,
parsed.to
);
},
}
)),
(Element.Properties.tween = {
set: function (
options
) {
return this.get(
"tween"
).cancel(
).setOptions(
options
), this;
},
get: function (
) {
var tween = this.retrieve(
"tween"
);
return (
tween ||
((tween = new Fx.Tween(
this,
{
link: "cancel",
}
)),
this.store(
"tween",
tween
)),
tween
);
},
}),
Element.implement(
{
tween: function (
property, from, to
) {
return this.get(
"tween"
).start(
property,
from,
to
), this;
},
fade: function (
how
) {
var method,
toggle,
fade = this.get(
"tween"
),
args = ["opacity",].append(
arguments
);
switch ((null == args[1] && (args[1] = "toggle"), args[1])) {
case "in":
(method = "start"), (args[1] = 1);
break;
case "out":
(method = "start"), (args[1] = 0);
break;
case "show":
(method = "set"), (args[1] = 1);
break;
case "hide":
(method = "set"), (args[1] = 0);
break;
case "toggle":
var flag = this.retrieve(
"fade:flag",
1 == this.getStyle(
"opacity"
)
);
(method = "start"),
(args[1] = flag ? 0 : 1),
this.store(
"fade:flag",
!flag
),
(toggle = !0);
break;
default:
method = "start";
}
toggle || this.eliminate(
"fade:flag"
), fade[method].apply(
fade,
args
);
var to = args[args.length - 1];
return (
"set" == method || 0 != to
? this.setStyle(
"visibility",
0 == to ? "hidden" : "visible"
)
: fade.chain(
function (
) {
this.element.setStyle(
"visibility",
"hidden"
), this.callChain(
);
}
),
this
);
},
highlight: function (
start, end
) {
end ||
(end =
"transparent" ==
(end = this.retrieve(
"highlight:original",
this.getStyle(
"background-color"
),
))
? "#fff"
: end);
var tween = this.get(
"tween"
);
return (
tween.start(
"background-color",
start || "#ffff88",
end
).chain(
function (
) {
this.setStyle(
"background-color",
this.retrieve(
"highlight:original"
),
),
tween.callChain(
);
}.bind(
this
),
),
this
);
},
}
),
(Fx.Morph = new Class(
{
Extends: Fx.CSS,
initialize: function (
element, options
) {
(this.element = this.subject = document.id(
element
)),
this.parent(
options
);
},
set: function (
now
) {
for (var p in ("string" == typeof now && (now = this.search(
now
)), now))
this.render(
this.element,
p,
now[p],
this.options.unit
);
return this;
},
compute: function (
from, to, delta
) {
var now = {
};
for (var p in from) now[p] = this.parent(
from[p],
to[p],
delta
);
return now;
},
start: function (
properties
) {
if (!this.check(
properties
)) return this;
"string" == typeof properties && (properties = this.search(
properties
));
var from = {
},
to = {
};
for (var p in properties) {
var parsed = this.prepare(
this.element,
p,
properties[p]
);
(from[p] = parsed.from), (to[p] = parsed.to);
}
return this.parent(
from,
to
);
},
}
)),
(Element.Properties.morph = {
set: function (
options
) {
return this.get(
"morph"
).cancel(
).setOptions(
options
), this;
},
get: function (
) {
var morph = this.retrieve(
"morph"
);
return (
morph ||
((morph = new Fx.Morph(
this,
{
link: "cancel",
}
)),
this.store(
"morph",
morph
)),
morph
);
},
}),
Element.implement(
{
morph: function (
props
) {
return this.get(
"morph"
).start(
props
), this;
},
}
),
Fx.implement(
{
getTransition: function (
) {
var trans = this.options.transition || Fx.Transitions.Sine.easeInOut;
if ("string" == typeof trans) {
var data = trans.split(
":"
);
(trans =
(trans = Fx.Transitions)[data[0]] || trans[data[0].capitalize(
)]),
data[1] &&
(trans =
trans[
"ease" +
data[1].capitalize(
) +
(data[2]
? data[2].capitalize(
)
: "")
]);
}
return trans;
},
}
),
(Fx.Transition = function (
transition, params
) {
params = Array.from(
params
);
var easeIn = function (
pos
) {
return transition(
pos,
params
);
};
return Object.append(
easeIn,
{
easeIn: easeIn,
easeOut: function (
pos
) {
return 1 - transition(
1 - pos,
params
);
},
easeInOut: function (
pos
) {
return (
(pos <= 0.5
? transition(
2 * pos,
params
)
: 2 - transition(
2 * (1 - pos),
params
)) / 2
);
},
}
);
}),
(Fx.Transitions = {
linear: function (
zero
) {
return zero;
},
}),
(Fx.Transitions = new Hash(
Fx.Transitions
)),
(Fx.Transitions.extend = function (
transitions
) {
for (var transition in transitions)
Fx.Transitions[transition] = new Fx.Transition(
transitions[transition]
);
}),
Fx.Transitions.extend(
{
Pow: function (
p, x
) {
return Math.pow(
p,
(x && x[0]) || 6
);
},
Expo: function (
p
) {
return Math.pow(
2,
8 * (p - 1)
);
},
Circ: function (
p
) {
return 1 - Math.sin(
Math.acos(
p
)
);
},
Sine: function (
p
) {
return 1 - Math.cos(
(p * Math.PI) / 2
);
},
Back: function (
p, x
) {
return (x = (x && x[0]) || 1.618), Math.pow(
p,
2
) * ((x + 1) * p - x);
},
Bounce: function (
p
) {
for (var value, a = 0, b = 1; ; a += b, b /= 2)
if (p >= (7 - 4 * a) / 11) {
value = b * b - Math.pow(
(11 - 6 * a - 11 * p) / 4,
2
);
break;
}
return value;
},
Elastic: function (
p, x
) {
return (
Math.pow(
2,
10 * --p
) *
Math.cos(
(20 * p * Math.PI * ((x && x[0]) || 1)) / 3
)
);
},
}
),
["Quad", "Cubic", "Quart", "Quint",].each(
function (
transition, i
) {
Fx.Transitions[transition] = new Fx.Transition(
function (
p
) {
return Math.pow(
p,
i + 2
);
}
);
}
),
(function (
) {
var empty = function (
) {},
progressSupport = "onprogress" in new Browser.Request(
),
Request = (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 (
options
) {
(this.xhr = new Browser.Request(
)),
this.setOptions(
options
),
(this.headers = this.options.headers);
},
onStateChange: function (
) {
var xhr = this.xhr;
4 == xhr.readyState &&
this.running &&
((this.running = !1),
(this.status = 0),
Function.attempt(
function (
) {
var status = xhr.status;
this.status = 1223 == status ? 204 : status;
}.bind(
this
),
),
(xhr.onreadystatechange = empty),
progressSupport && (xhr.onprogress = xhr.onloadstart = empty),
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 status = this.status;
return status >= 200 && status < 300;
},
isRunning: function (
) {
return !!this.running;
},
processScripts: function (
text
) {
return this.options.evalResponse ||
/(ecma|java)script/.test(
this.getHeader(
"Content-type"
)
)
? Browser.exec(
text
)
: text.stripScripts(
this.options.evalScripts
);
},
success: function (
text, xml
) {
this.onSuccess(
this.processScripts(
text
),
xml
);
},
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 (
event
) {
this.fireEvent(
"loadstart",
[event, this.xhr,]
);
},
progress: function (
event
) {
this.fireEvent(
"progress",
[event, this.xhr,]
);
},
timeout: function (
) {
this.fireEvent(
"timeout",
this.xhr
);
},
setHeader: function (
name, value
) {
return (this.headers[name] = value), this;
},
getHeader: function (
name
) {
return Function.attempt(
function (
) {
return this.xhr.getResponseHeader(
name
);
}.bind(
this
),
);
},
check: function (
) {
if (!this.running) return !0;
switch (this.options.link) {
case "cancel":
return this.cancel(
), !0;
case "chain":
return this.chain(
this.caller.pass(
arguments,
this
)
), !1;
}
return !1;
},
send: function (
options
) {
if (!this.check(
options
)) return this;
(this.options.isSuccess = this.options.isSuccess || this.isSuccess),
(this.running = !0);
var type = typeOf(
options
);
("string" != type && "element" != type) ||
(options = {
data: options,
});
var old = this.options,
data = (options = Object.append(
{
data: old.data,
url: old.url,
method: old.method,
},
options,
)).data,
url = String(
options.url
),
method = options.method.toLowerCase(
);
switch (typeOf(
data
)) {
case "element":
data = document.id(
data
).toQueryString(
);
break;
case "object":
case "hash":
data = Object.toQueryString(
data
);
}
if (this.options.format) {
var format = "format=" + this.options.format;
data = data ? format + "&" + data : format;
}
if (this.options.emulation && !["get", "post",].contains(
method
)) {
var _method = "_method=" + method;
(data = data ? _method + "&" + data : _method), (method = "post");
}
if (this.options.urlEncoded && ["post", "put",].contains(
method
)) {
var encoding = this.options.encoding
? "; charset=" + this.options.encoding
: "";
this.headers["Content-type"] =
"application/x-www-form-urlencoded" + encoding;
}
url || (url = document.location.pathname);
var trimPosition = url.lastIndexOf(
"/"
);
trimPosition > -1 &&
(trimPosition = url.indexOf(
"#"
)) > -1 &&
(url = url.substr(
0,
trimPosition
)),
this.options.noCache &&
(url += (url.contains(
"?"
)
? "&"
: "?") + String.uniqueID(
)),
data &&
"get" == method &&
((url += (url.contains(
"?"
)
? "&"
: "?") + data), (data = null));
var xhr = this.xhr;
return (
progressSupport &&
((xhr.onloadstart = this.loadstart.bind(
this
)),
(xhr.onprogress = this.progress.bind(
this
))),
xhr.open(
method.toUpperCase(
),
url,
this.options.async,
this.options.user,
this.options.password,
),
this.options.user &&
"withCredentials" in xhr &&
(xhr.withCredentials = !0),
(xhr.onreadystatechange = this.onStateChange.bind(
this
)),
Object.each(
this.headers,
function (
value, key
) {
try {
xhr.setRequestHeader(
key,
value
);
} catch (e) {
this.fireEvent(
"exception",
[key, value,]
);
}
},
this,
),
this.fireEvent(
"request"
),
xhr.send(
data
),
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 xhr = this.xhr;
return (
xhr.abort(
),
clearTimeout(
this.timer
),
(xhr.onreadystatechange = empty),
progressSupport && (xhr.onprogress = xhr.onloadstart = empty),
(this.xhr = new Browser.Request(
)),
this.fireEvent(
"cancel"
),
this
);
},
}
)),
methods = {
};
["get", "post", "put", "delete", "GET", "POST", "PUT", "DELETE",].each(
function (
method
) {
methods[method] = function (
data
) {
var object = {
method: method,
};
return null != data && (object.data = data), this.send(
object
);
};
},
),
Request.implement(
methods
),
(Element.Properties.send = {
set: function (
options
) {
return this.get(
"send"
).cancel(
).setOptions(
options
), this;
},
get: function (
) {
var send = this.retrieve(
"send"
);
return (
send ||
((send = new Request(
{
data: this,
link: "cancel",
method: this.get(
"method"
) || "post",
url: this.get(
"action"
),
}
)),
this.store(
"send",
send
)),
send
);
},
}),
Element.implement(
{
send: function (
url
) {
var sender = this.get(
"send"
);
return (
sender.send(
{
data: this,
url: url || sender.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 (
text
) {
var options = this.options,
response = this.response;
response.html = text.stripScripts(
function (
script
) {
response.javascript = script;
}
);
var match = response.html.match(
/<body[^>]*>([\s\S]*?)<\/body>/i
);
match && (response.html = match[1]);
var temp = new Element(
"div"
).set(
"html",
response.html
);
if (
((response.tree = temp.childNodes),
(response.elements = temp.getElements(
options.filter || "*"
)),
options.filter && (response.tree = response.elements),
options.update)
) {
var update = document.id(
options.update
).empty(
);
options.filter
? update.adopt(
response.elements
)
: update.set(
"html",
response.html
);
} else if (options.append) {
var append = document.id(
options.append
);
options.filter
? response.elements.reverse(
).inject(
append
)
: append.adopt(
temp.getChildren(
)
);
}
options.evalScripts && Browser.exec(
response.javascript
),
this.onSuccess(
response.tree,
response.elements,
response.html,
response.javascript,
);
},
}
)),
(Element.Properties.load = {
set: function (
options
) {
return this.get(
"load"
).cancel(
).setOptions(
options
), this;
},
get: function (
) {
var load = this.retrieve(
"load"
);
return (
load ||
((load = new Request.HTML(
{
data: this,
link: "cancel",
update: this,
method: "get",
}
)),
this.store(
"load",
load
)),
load
);
},
}),
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 (
chr
) {
return (
special[chr] ||
"\\u" + ("0000" + chr.charCodeAt(
0
).toString(
16
)).slice(
-4
)
);
};
(JSON.validate = function (
string
) {
return (
(string = string
.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(
string
)
);
}),
(JSON.encode = JSON.stringify
? function (
obj
) {
return JSON.stringify(
obj
);
}
: function (
obj
) {
switch ((obj && obj.toJSON && (obj = obj.toJSON(
)), typeOf(
obj
))) {
case "string":
return '"' + obj.replace(
/[\x00-\x1f\\"]/g,
escape
) + '"';
case "array":
return "[" + obj.map(
JSON.encode
).clean(
) + "]";
case "object":
case "hash":
var string = [];
return (
Object.each(
obj,
function (
value, key
) {
var json = JSON.encode(
value
);
json && string.push(
JSON.encode(
key
) + ":" + json
);
}
),
"{" + string + "}"
);
case "number":
case "boolean":
return "" + obj;
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 new 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 (
options
) {
this.parent(
options
),
Object.append(
this.headers,
{
Accept: "application/json",
"X-Request": "JSON",
}
);
},
success: function (
text
) {
var json;
try {
json = this.response.json = JSON.decode(
text,
this.options.secure
);
} catch (error) {
return void this.fireEvent(
"error",
[text, error,]
);
}
null == json
? this.onFailure(
)
: this.onSuccess(
json,
text
);
},
}
));
var Cookie = new Class(
{
Implements: Options,
options: {
path: "/",
domain: !1,
duration: !1,
secure: !1,
document: document,
encode: !0,
},
initialize: function (
key, options
) {
(this.key = key), this.setOptions(
options
);
},
write: function (
value
) {
if (
(this.options.encode && (value = encodeURIComponent(
value
)),
this.options.domain && (value += "; domain=" + this.options.domain),
this.options.path && (value += "; path=" + this.options.path),
this.options.duration)
) {
var date = new Date(
);
date.setTime(
date.getTime(
) + 24 * this.options.duration * 60 * 60 * 1e3
),
(value += "; expires=" + date.toGMTString(
));
}
return (
this.options.secure && (value += "; secure"),
(this.options.document.cookie = this.key + "=" + value),
this
);
},
read: function (
) {
var value = this.options.document.cookie.match(
"(?:^|;)\\s*" + this.key.escapeRegExp(
) + "=([^;]*)",
);
return value
? decodeURIComponent(
value[1]
)
: null;
},
dispose: function (
) {
return (
new Cookie(
this.key,
Object.merge(
{
},
this.options,
{
duration: -1,
}
),
).write(
""
),
this
);
},
}
);
(Cookie.write = function (
key, value, options
) {
return new Cookie(
key,
options
).write(
value
);
}),
(Cookie.read = function (
key
) {
return new Cookie(
key
).read(
);
}),
(Cookie.dispose = function (
key, options
) {
return new Cookie(
key,
options
).dispose(
);
}),
(function (
window, document
) {
var ready,
loaded,
shouldPoll,
timer,
checks = [],
testElement = document.createElement(
"div"
),
domready = function (
) {
clearTimeout(
timer
),
ready ||
((Browser.loaded = ready = !0),
document
.removeListener(
"DOMContentLoaded",
domready
)
.removeListener(
"readystatechange",
check
),
document.fireEvent(
"domready"
),
window.fireEvent(
"domready"
));
},
check = function (
) {
for (var i = checks.length; i--; )
if (checks[i](
)) return domready(
), !0;
return !1;
},
poll = function (
) {
clearTimeout(
timer
), check(
) || (timer = setTimeout(
poll,
10
));
};
document.addListener(
"DOMContentLoaded",
domready
);
var doScrollWorks = function (
) {
try {
return testElement.doScroll(
), !0;
} catch (e) {}
return !1;
};
testElement.doScroll &&
!doScrollWorks(
) &&
(checks.push(
doScrollWorks
), (shouldPoll = !0)),
document.readyState &&
checks.push(
function (
) {
var state = document.readyState;
return "loaded" == state || "complete" == state;
}
),
"onreadystatechange" in document
? document.addListener(
"readystatechange",
check
)
: (shouldPoll = !0),
shouldPoll && poll(
),
(Element.Events.domready = {
onAdd: function (
fn
) {
ready && fn.call(
this
);
},
}),
(Element.Events.load = {
base: "load",
onAdd: function (
fn
) {
loaded && this == window && fn.call(
this
);
},
condition: function (
) {
return this == window && (domready(
), delete Element.Events.load), !0;
},
}),
window.addEvent(
"load",
function (
) {
loaded = !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 (
path, options
) {
(this.instance = "Swiff_" + String.uniqueID(
)),
this.setOptions(
options
),
(options = this.options);
var id = (this.id = options.id || this.instance),
container = document.id(
options.container
);
Swiff.CallBacks[this.instance] = {
};
var params = options.params,
vars = options.vars,
callBacks = options.callBacks,
properties = Object.append(
{
height: options.height,
width: options.width,
},
options.properties,
),
self = this;
for (var callBack in callBacks)
(Swiff.CallBacks[this.instance][callBack] = (function (
option
) {
return function (
) {
return option.apply(
self.object,
arguments
);
};
})(
callBacks[callBack]
)),
(vars[callBack] =
"Swiff.CallBacks." + this.instance + "." + callBack);
(params.flashVars = Object.toQueryString(
vars
)),
Browser.ie
? ((properties.classid =
"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"),
(params.movie = path))
: (properties.type = "application/x-shockwave-flash"),
(properties.data = path);
var build = '<object id="' + id + '"';
for (var property in properties)
build += " " + property + '="' + properties[property] + '"';
for (var param in ((build += ">"), params))
params[param] &&
(build +=
'<param name="' + param + '" value="' + params[param] + '" />');
(build += "</object>"),
(this.object = (container
? container.empty(
)
: new Element(
"div"
)
).set(
"html",
build
).firstChild);
},
replaces: function (
element
) {
return (
(element = document.id(
element,
!0
)).parentNode.replaceChild(
this.toElement(
),
element,
),
this
);
},
inject: function (
element
) {
return document.id(
element,
!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
);
});
})(
);
Reference in New Issue View Git Blame Copy Permalink